fix version page (#1121 )

Bump to 0.7.0 + Add sign-in error (#1133 )
Fix java installs (#1123 )
2024-04-23 12:09:02 -07:00 · 2024-04-23 12:05:28 -07:00 · 2024-04-18 20:28:52 -07:00 · 2024-04-15 13:58:20 -07:00 · 2024-04-14 10:10:13 -07:00 · 2024-04-07 12:13:35 -07:00
144 changed files with 7750 additions and 7908 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -25,9 +25,13 @@ body:
      description: A clear and concise description of what you expected to happen.
    validations:
      required: false
+  - type: textarea
+    attributes: 
+      label: System information
+      description: Add any information about what OS you are on (like Windows or Mac), and what version of the app you are using.
  - type: textarea
    attributes:
      label: Additional context
-      description: Add any other context about the problem here.
+      description: Add any other context about the problem here. This might include logs, screenshots, etc. The more the merrier!
    validations:
      required: false
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -2,7 +2,7 @@ blank_issues_enabled: true
 contact_links:
  - name: Discord
    about: Ask questions on our Discord Server.
-    url: https://discord.gg/modrinth-734077874708938864
+    url: https://discord.modrinth.com
  - name: Roadmap
    about: View our Roadmap. Please do not open issues for items on our roadmap.
    url: https://roadmap.modrinth.com
--- a/.github/workflows/cli-build.yml
+++ b/.github/workflows/cli-build.yml
@@ -1,44 +0,0 @@
-name: CLI Build + Lint
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-env:
-  CARGO_TERM_COLOR: always
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./theseus_cli
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.0-dev libappindicator3-dev librsvg2-dev patchelf
-
-      - name: Rust setup
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rustfmt, clippy
-
-      - name: Rust cache
-        uses: swatinem/rust-cache@v2
-        with:
-          workspaces: './src-tauri -> target'
-
-      - uses: actions-rs/cargo@v1
-        name: Build program
-        with:
-          command: build
-          args: --bin theseus_cli
-
-      - name: Run Lint
-        uses: actions-rs/clippy-check@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --bin theseus_cli
--- a/.github/workflows/tauri-build.yml
+++ b/.github/workflows/tauri-build.yml
@@ -8,7 +8,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [macos-latest, windows-latest, ubuntu-20.04]
+        platform: [macos-latest, windows-latest, ubuntu-20.04, ubuntu-22.04]

    runs-on: ${{ matrix.platform }}
    defaults:
@@ -62,7 +62,7 @@ jobs:
        if: startsWith(matrix.platform, 'ubuntu')
        run: |
          sudo apt-get update
-          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.0-dev libappindicator3-dev librsvg2-dev patchelf
+          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.0-dev libappindicator3-dev librsvg2-dev patchelf libselinux1

      - name: Install frontend dependencies
        run: pnpm install
@@ -78,6 +78,7 @@ jobs:
          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
--- a/.gitignore
+++ b/.gitignore
@@ -100,6 +100,7 @@ fabric.properties
 # that are supposed to be shared within teams.

 .idea/*
+.vscode/*

 !.idea/codeStyles
 !.idea/runConfigurations
--- a/.vscode/extensions.json
+++ b/.vscode/extensions.json
@@ -1,12 +0,0 @@
-{
-  "recommendations": [
-    "tauri-apps.tauri-vscode",
-    "vunguyentuan.vscode-css-variables",
-    "stylelint.vscode-stylelint",
-    "eamodio.gitlens",
-    "esbenp.prettier-vscode",
-    "pivaszbs.svelte-autoimport",
-    "svelte.svelte-vscode",
-    "ardenivanov.svelte-intellisense"
-  ]
-}
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -1,160 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug unit tests in library 'theseus'",
-            "cargo": {
-                "args": [
-                    "test",
-                    "--no-run",
-                    "--lib",
-                    "--package=theseus"
-                ],
-                "filter": {
-                    "name": "theseus",
-                    "kind": "lib"
-                }
-            },
-            "args": [],
-            "cwd": "${workspaceFolder}"
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug executable 'theseus_cli'",
-            "cargo": {
-                "args": [
-                    "build",
-                    "--bin=theseus_cli",
-                    "--package=theseus_cli"
-                ],
-                "filter": {
-                    "name": "theseus_cli",
-                    "kind": "bin"
-                }
-            },
-            "args": [],
-            "cwd": "${workspaceFolder}"
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug unit tests in executable 'theseus_cli'",
-            "cargo": {
-                "args": [
-                    "test",
-                    "--no-run",
-                    "--bin=theseus_cli",
-                    "--package=theseus_cli"
-                ],
-                "filter": {
-                    "name": "theseus_cli",
-                    "kind": "bin"
-                }
-            },
-            "args": [],
-            "cwd": "${workspaceFolder}"
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug executable 'theseus_playground'",
-            "cargo": {
-                "args": [
-                    "build",
-                    "--bin=theseus_playground",
-                    "--package=theseus_playground"
-                ],
-                "filter": {
-                    "name": "theseus_playground",
-                    "kind": "bin"
-                }
-            },
-            "args": [],
-            "cwd": "${workspaceFolder}"
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug unit tests in executable 'theseus_playground'",
-            "cargo": {
-                "args": [
-                    "test",
-                    "--no-run",
-                    "--bin=theseus_playground",
-                    "--package=theseus_playground"
-                ],
-                "filter": {
-                    "name": "theseus_playground",
-                    "kind": "bin"
-                }
-            },
-            "args": [],
-            "cwd": "${workspaceFolder}"
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug executable 'theseus_gui'",
-            "cargo": {
-                "args": [
-                    "build",
-                    "--bin=theseus_gui",
-                    "--package=theseus_gui"
-                ],
-                "filter": {
-                    "name": "theseus_gui",
-                    "kind": "bin"
-                }
-            },
-            "args": [],
-            "cwd": "${workspaceFolder}"
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug unit tests in executable 'theseus_gui'",
-            "cargo": {
-                "args": [
-                    "test",
-                    "--no-run",
-                    "--bin=theseus_gui",
-                    "--package=theseus_gui"
-                ],
-                "filter": {
-                    "name": "theseus_gui",
-                    "kind": "bin"
-                }
-            },
-            "args": [],
-            "cwd": "${workspaceFolder}"
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Tauri Development Debug",
-            "cargo": {
-              "args": [
-                "build",
-                "--manifest-path=./theseus_gui/src-tauri/Cargo.toml",
-                "--no-default-features"
-              ]
-            },
-            "preLaunchTask": "ui:dev"
-          },
-          {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Tauri Production Debug",
-            "cargo": {
-              "args": ["build", "--release", "--manifest-path=.theseus_gui/src-tauri/Cargo.toml"]
-            },
-            "preLaunchTask": "ui:build"
-          }      
-    ]
-}
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,60 +0,0 @@
-{
-  "cssVariables.lookupFiles": [
-    "**/*.postcss",
-    "**/node_modules/omorphia/**/*.postcss"
-  ],
-  "cssVariables.blacklistFolders": [
-    "**/.git",
-    "**/.svn",
-    "**/.hg",
-    "**/CVS",
-    "**/.DS_Store",
-    "**/.git",
-    "**/bower_components",
-    "**/tmp",
-    "**/dist",
-    "**/tests"
-  ],
-  "gitlens.showWelcomeOnInstall": false,
-  "gitlens.showWhatsNewAfterUpgrades": false,
-  "gitlens.plusFeatures.enabled": false,
-  "gitlens.currentLine.enabled": false,
-  "gitlens.currentLine.pullRequests.enabled": false,
-  "gitlens.currentLine.scrollable": true,
-  "gitlens.codeLens.enabled": false,
-  "gitlens.hovers.enabled": false,
-  "CSSNavigation.activeCSSFileExtensions": [
-    "css",
-    "postcss"
-  ],
-  "CSSNavigation.activeHTMLFileExtensions": [
-    "html",
-    "svelte",
-    "js",
-    "ts"
-  ],
-  "CSSNavigation.excludeGlobPatterns": [
-    "**/bower_components/**",
-    "**/vendor/**",
-    "**/coverage/**"
-  ],
-  "CSSNavigation.alwaysIncludeGlobPatterns": [
-    "./theseus_gui/node_modules/omorphia/**/*.postcss"
-  ],
-  "html-css-class-completion.HTMLLanguages": [
-    "html",
-    "svelte"
-  ],
-  "html-css-class-completion.includeGlobPattern": "**/*.{postcss,svelte}",
-  "html-css-class-completion.CSSLanguages": [
-    "postcss",
-  ],
-  "svelte.enable-ts-plugin": true,
-  "svelte.ask-to-enable-ts-plugin": false,
-  "svelte.plugin.css.diagnostics.enable": false,
-  "svelte.plugin.svelte.diagnostics.enable": false,
-  "rust-analyzer.linkedProjects": [
-    "./theseus/Cargo.toml"
-  ],
-  "rust-analyzer.showUnlinkedFileNotification": false,
-}
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -1,32 +0,0 @@
-{
-  // See https://go.microsoft.com/fwlink/?LinkId=733558
-  // for the documentation about the tasks.json format
-  "version": "2.0.0",
-  "tasks": [
-    {
-      "label": "ui:dev",
-      "type": "shell",
-      // `dev` keeps running in the background
-      // ideally you should also configure a `problemMatcher`
-      // see https://code.visualstudio.com/docs/editor/tasks#_can-a-background-task-be-used-as-a-prelaunchtask-in-launchjson
-      "isBackground": true,
-      // change this to your `beforeDevCommand`:
-      "command": "yarn",
-      "args": ["dev"],
-      "options": {
-        "cwd": "${workspaceFolder}/theseus_gui"
-      }
-    },
-    {
-      "label": "ui:build",
-      "type": "shell",
-      // change this to your `beforeBuildCommand`:
-      "command": "yarn",
-      "args": ["build"],
-      "options": {
-        "cwd": "${workspaceFolder}/theseus_gui"
-      }
-    }
-  ]
-
-}
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,7 +2,6 @@

 members = [
    "theseus",
-    "theseus_cli",
    "theseus_playground",
    "theseus_gui/src-tauri",
    "theseus_macros"
--- a/theseus.iml
+++ b/theseus.iml
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/theseus/library" isTestSource="false" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>
--- a/theseus/Cargo.toml
+++ b/theseus/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "theseus"
-version = "0.5.1"
+version = "0.7.0"
 authors = ["Jai A <jaiagr+gpg@pm.me>"]
 edition = "2018"

@@ -13,42 +13,46 @@ bytes = "1"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_ini = "0.2.0"
-toml = "0.7.3"
-sha1 = { version = "0.6.1", features = ["std"]}
-sha2 = "0.9.9"
+toml = "0.8.12"
+sha1_smol = { version = "1.0.0", features = ["std"] }
+sha2 = "0.10.8"
 url = "2.2"
 uuid = { version = "1.1", features = ["serde", "v4"] }
 zip = "0.6.5"
-async_zip = { version = "0.0.13", features = ["full"] }
+async_zip = { version = "0.0.17", features = ["full"] }
+flate2 = "1.0.28"
 tempfile = "3.5.0"
+urlencoding = "2.1.3"
+

 chrono = { version = "0.4.19", features = ["serde"] }
-daedalus = { version = "0.1.23" }
+daedalus = { version = "0.1.25" }
 dirs = "5.0.1"

 regex = "1.5"
 sys-info = "0.9.0"
+sysinfo = "0.30.8"
 thiserror = "1.0"

 tracing = "0.1.37"
-tracing-subscriber = {version = "0.2", features = ["chrono"]}
-tracing-error = "0.1.0"
-tracing-appender = "0.1"
+tracing-subscriber = { version = "0.3.18", features = ["chrono", "env-filter"] }
+tracing-error = "0.2.0"
+tracing-appender = "0.2.3"

-paste = { version = "1.0"}
+paste = { version = "1.0" }

-tauri = { version = "1.2", optional = true}
+tauri = { version = "1.6.1", optional = true }
 indicatif = { version = "0.17.3", optional = true }

-async-tungstenite = { version = "0.22.1", features = ["tokio-runtime", "tokio-native-tls"] }
+async-tungstenite = { version = "0.25.1", features = ["tokio-runtime", "tokio-native-tls"] }
 futures = "0.3"
-reqwest = { version = "0.11", features = ["json", "stream"] }
+reqwest = { version = "0.12.3", features = ["json", "stream"] }
 tokio = { version = "1", features = ["full"] }
 tokio-stream = { version = "0.1", features = ["fs"] }
 async-recursion = "1.0.4"

-notify = { version = "5.1.0", default-features = false }
-notify-debouncer-mini = { version = "0.2.1", default-features = false }
+notify = { version = "6.1.1", default-features = false }
+notify-debouncer-mini = { version = "0.4.1", default-features = false }

 lazy_static = "1.4.0"
 dunce = "1.0.3"
@@ -57,8 +61,13 @@ whoami = "1.4.0"

 discord-rich-presence = "0.2.3"

-[target.'cfg(windows)'.dependencies] 
-winreg = "0.50.0"
+p256 = { version = "0.13.2", features = ["ecdsa"] }
+rand = "0.8"
+byteorder = "1.5.0"
+base64 = "0.22.0"
+
+[target.'cfg(windows)'.dependencies]
+winreg = "0.52.0"

 [features]
 tauri = ["dep:tauri"]
--- a/theseus/src/api/auth.rs
+++ b/theseus/src/api/auth.rs
@@ -1,145 +0,0 @@
-//! Authentication flow interface
-use crate::{launcher::auth as inner, State};
-use chrono::Utc;
-use tokio::sync::oneshot;
-
-use crate::state::AuthTask;
-pub use inner::Credentials;
-
-/// Authenticate a user with Hydra - part 1
-/// This begins the authentication flow quasi-synchronously, returning a URL
-/// This can be used in conjunction with 'authenticate_await_complete_flow'
-/// to call authenticate and call the flow from the frontend.
-/// Visit the URL in a browser, then call and await 'authenticate_await_complete_flow'.
-pub async fn authenticate_begin_flow() -> crate::Result<url::Url> {
-    let url = AuthTask::begin_auth().await?;
-    Ok(url)
-}
-
-/// Authenticate a user with Hydra - part 2
-/// This completes the authentication flow quasi-synchronously, returning the credentials
-/// This can be used in conjunction with 'authenticate_begin_flow'
-/// to call authenticate and call the flow from the frontend.
-pub async fn authenticate_await_complete_flow(
-) -> crate::Result<(Credentials, Option<String>)> {
-    let credentials = AuthTask::await_auth_completion().await?;
-    Ok(credentials)
-}
-
-/// Cancels the active authentication flow
-pub async fn cancel_flow() -> crate::Result<()> {
-    AuthTask::cancel().await
-}
-
-/// Authenticate a user with Hydra
-/// To run this, you need to first spawn this function as a task, then
-/// open a browser to the given URL and finally wait on the spawned future
-/// with the ability to cancel in case the browser is closed before finishing
-#[tracing::instrument]
-#[theseus_macros::debug_pin]
-pub async fn authenticate(
-    browser_url: oneshot::Sender<url::Url>,
-) -> crate::Result<(Credentials, Option<String>)> {
-    let mut flow = inner::HydraAuthFlow::new().await?;
-    let state = State::get().await?;
-
-    let url = flow.prepare_login_url().await?;
-    browser_url.send(url).map_err(|url| {
-        crate::ErrorKind::OtherError(format!(
-            "Error sending browser url to parent: {url}"
-        ))
-    })?;
-
-    let credentials = flow.extract_credentials(&state.fetch_semaphore).await?;
-    {
-        let mut users = state.users.write().await;
-        users.insert(&credentials.0).await?;
-    }
-
-    if state.settings.read().await.default_user.is_none() {
-        let mut settings = state.settings.write().await;
-        settings.default_user = Some(credentials.0.id);
-    }
-
-    Ok(credentials)
-}
-
-/// Refresh some credentials using Hydra, if needed
-/// This is the primary desired way to get credentials, as it will also refresh them.
-#[tracing::instrument]
-#[theseus_macros::debug_pin]
-pub async fn refresh(user: uuid::Uuid) -> crate::Result<Credentials> {
-    let state = State::get().await?;
-    let mut users = state.users.write().await;
-
-    let mut credentials = users.get(user).ok_or_else(|| {
-        crate::ErrorKind::OtherError(
-            "You are not logged in with a Minecraft account!".to_string(),
-        )
-        .as_error()
-    })?;
-
-    let fetch_semaphore = &state.fetch_semaphore;
-    if Utc::now() > credentials.expires
-        && inner::refresh_credentials(&mut credentials, fetch_semaphore)
-            .await
-            .is_err()
-    {
-        users.remove(credentials.id).await?;
-
-        return Err(crate::ErrorKind::OtherError(
-            "Please re-authenticate with your Minecraft account!".to_string(),
-        )
-        .as_error());
-    }
-    users.insert(&credentials).await?;
-
-    Ok(credentials)
-}
-
-/// Remove a user account from the database
-#[tracing::instrument]
-pub async fn remove_user(user: uuid::Uuid) -> crate::Result<()> {
-    let state = State::get().await?;
-    let mut users = state.users.write().await;
-
-    if state.settings.read().await.default_user == Some(user) {
-        let mut settings = state.settings.write().await;
-        settings.default_user = users.0.values().next().map(|it| it.id);
-    }
-
-    users.remove(user).await?;
-    Ok(())
-}
-
-/// Check if a user exists in Theseus
-#[tracing::instrument]
-pub async fn has_user(user: uuid::Uuid) -> crate::Result<bool> {
-    let state = State::get().await?;
-    let users = state.users.read().await;
-
-    Ok(users.contains(user))
-}
-
-/// Get a copy of the list of all user credentials
-#[tracing::instrument]
-pub async fn users() -> crate::Result<Vec<Credentials>> {
-    let state = State::get().await?;
-    let users = state.users.read().await;
-    Ok(users.0.values().cloned().collect())
-}
-
-/// Get a specific user by user ID
-/// Prefer to use 'refresh' instead of this function
-#[tracing::instrument]
-pub async fn get_user(user: uuid::Uuid) -> crate::Result<Credentials> {
-    let state = State::get().await?;
-    let users = state.users.read().await;
-    let user = users.get(user).ok_or_else(|| {
-        crate::ErrorKind::OtherError(format!(
-            "Tried to get nonexistent user with ID {user}"
-        ))
-        .as_error()
-    })?;
-    Ok(user)
-}
--- a/theseus/src/api/jre.rs
+++ b/theseus/src/api/jre.rs
@@ -7,66 +7,35 @@ use crate::event::emit::{emit_loading, init_loading};
 use crate::state::CredentialsStore;
 use crate::util::fetch::{fetch_advanced, fetch_json};

+use crate::util::io;
 use crate::util::jre::extract_java_majorminor_version;
 use crate::{
-    state::JavaGlobals,
    util::jre::{self, JavaVersion},
    LoadingBarType, State,
 };

-pub const JAVA_8_KEY: &str = "JAVA_8";
-pub const JAVA_17_KEY: &str = "JAVA_17";
-pub const JAVA_18PLUS_KEY: &str = "JAVA_18PLUS";
-
-// Autodetect JavaSettings default
-// Using the supplied JavaVersions, autodetects the default JavaSettings
-// Make a guess for what the default Java global settings should be
-// Since the JRE paths are passed in as args, this handles the logic for selection. Currently this just pops the last one found
-// TODO: When tauri compiler issue is fixed, this can be be improved (ie: getting JREs in-function)
-pub async fn autodetect_java_globals(
-    mut java_8: Vec<JavaVersion>,
-    mut java_17: Vec<JavaVersion>,
-    mut java_18plus: Vec<JavaVersion>,
-) -> crate::Result<JavaGlobals> {
-    // Simply select last one found for initial guess
-    let mut java_globals = JavaGlobals::new();
-    if let Some(jre) = java_8.pop() {
-        java_globals.insert(JAVA_8_KEY.to_string(), jre);
-    }
-    if let Some(jre) = java_17.pop() {
-        java_globals.insert(JAVA_17_KEY.to_string(), jre);
-    }
-    if let Some(jre) = java_18plus.pop() {
-        java_globals.insert(JAVA_18PLUS_KEY.to_string(), jre);
-    }
-
-    Ok(java_globals)
-}
-
 // Searches for jres on the system given a java version (ex: 1.8, 1.17, 1.18)
 // Allow higher allows for versions higher than the given version to be returned ('at least')
 pub async fn find_filtered_jres(
-    version: &str,
-    jres: Vec<JavaVersion>,
-    allow_higher: bool,
+    java_version: Option<u32>,
 ) -> crate::Result<Vec<JavaVersion>> {
-    let version = extract_java_majorminor_version(version)?;
+    let jres = jre::get_all_jre().await?;
+
    // Filter out JREs that are not 1.17 or higher
-    Ok(jres
-        .into_iter()
-        .filter(|jre| {
-            let jre_version = extract_java_majorminor_version(&jre.version);
-            if let Ok(jre_version) = jre_version {
-                if allow_higher {
-                    jre_version >= version
+    Ok(if let Some(java_version) = java_version {
+        jres.into_iter()
+            .filter(|jre| {
+                let jre_version = extract_java_majorminor_version(&jre.version);
+                if let Ok(jre_version) = jre_version {
+                    jre_version.1 == java_version
                } else {
-                    jre_version == version
+                    false
                }
-            } else {
-                false
-            }
-        })
-        .collect())
+            })
+            .collect()
+    } else {
+        jres
+    })
 }

 #[theseus_macros::debug_pin]
@@ -124,6 +93,17 @@ pub async fn auto_install_java(java_version: u32) -> crate::Result<PathBuf> {
                ))
            })?;

+        // removes the old installation of java
+        if let Some(file) = archive.file_names().next() {
+            if let Some(dir) = file.split('/').next() {
+                let path = path.join(dir);
+
+                if path.exists() {
+                    io::remove_dir_all(path).await?;
+                }
+            }
+        }
+
        emit_loading(&loading_bar, 0.0, Some("Extracting java")).await?;
        archive.extract(&path).map_err(|_| {
            crate::Error::from(crate::ErrorKind::InputError(
@@ -164,22 +144,24 @@ pub async fn auto_install_java(java_version: u32) -> crate::Result<PathBuf> {
    }
 }

-// Get all JREs that exist on the system
-pub async fn get_all_jre() -> crate::Result<Vec<JavaVersion>> {
-    Ok(jre::get_all_jre().await?)
-}
-
-pub async fn validate_globals() -> crate::Result<bool> {
-    let state = State::get().await?;
-    let settings = state.settings.read().await;
-    Ok(settings.java_globals.is_all_valid().await)
-}
-
 // Validates JRE at a given at a given path
 pub async fn check_jre(path: PathBuf) -> crate::Result<Option<JavaVersion>> {
    Ok(jre::check_java_at_filepath(&path).await)
 }

+// Test JRE at a given path
+pub async fn test_jre(
+    path: PathBuf,
+    major_version: u32,
+) -> crate::Result<bool> {
+    let jre = match jre::check_java_at_filepath(&path).await {
+        Some(jre) => jre,
+        None => return Ok(false),
+    };
+    let (major, _) = extract_java_majorminor_version(&jre.version)?;
+    Ok(major == major_version)
+}
+
 // Gets maximum memory in KiB.
 pub async fn get_max_memory() -> crate::Result<u64> {
    Ok(sys_info::mem_info()
--- a/theseus/src/api/logs.rs
+++ b/theseus/src/api/logs.rs
@@ -1,30 +1,70 @@
+use std::io::{Read, SeekFrom};
+
 use crate::{
+    prelude::{Credentials, DirectoryInfo},
    util::io::{self, IOError},
    {state::ProfilePathId, State},
 };
-use serde::{Deserialize, Serialize};
+use futures::TryFutureExt;
+use serde::Serialize;
+use tokio::{
+    fs::File,
+    io::{AsyncReadExt, AsyncSeekExt},
+};

-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Debug)]
 pub struct Logs {
-    pub datetime_string: String,
-    pub output: Option<String>,
+    pub filename: String,
+    pub output: Option<CensoredString>,
 }
+
+#[derive(Serialize, Debug)]
+pub struct LatestLogCursor {
+    pub cursor: u64,
+    pub output: CensoredString,
+    pub new_file: bool,
+}
+
+#[derive(Serialize, Debug)] // Not deserialize
+#[serde(transparent)]
+pub struct CensoredString(String);
+impl CensoredString {
+    pub fn censor(mut s: String, credentials_set: &Vec<Credentials>) -> Self {
+        let username = whoami::username();
+        s = s
+            .replace(&format!("/{}/", username), "/{COMPUTER_USERNAME}/")
+            .replace(&format!("\\{}\\", username), "\\{COMPUTER_USERNAME}\\");
+        for credentials in credentials_set {
+            s = s
+                .replace(&credentials.access_token, "{MINECRAFT_ACCESS_TOKEN}")
+                .replace(&credentials.username, "{MINECRAFT_USERNAME}")
+                .replace(
+                    &credentials.id.as_simple().to_string(),
+                    "{MINECRAFT_UUID}",
+                )
+                .replace(
+                    &credentials.id.as_hyphenated().to_string(),
+                    "{MINECRAFT_UUID}",
+                );
+        }
+
+        Self(s)
+    }
+}
+
 impl Logs {
    async fn build(
        profile_subpath: &ProfilePathId,
-        datetime_string: String,
+        filename: String,
        clear_contents: Option<bool>,
    ) -> crate::Result<Self> {
        Ok(Self {
            output: if clear_contents.unwrap_or(false) {
                None
            } else {
-                Some(
-                    get_output_by_datetime(profile_subpath, &datetime_string)
-                        .await?,
-                )
+                Some(get_output_by_filename(profile_subpath, &filename).await?)
            },
-            datetime_string,
+            filename,
        })
    }
 }
@@ -34,7 +74,6 @@ pub async fn get_logs(
    profile_path: ProfilePathId,
    clear_contents: Option<bool>,
 ) -> crate::Result<Vec<Logs>> {
-    let state = State::get().await?;
    let profile_path =
        if let Some(p) = crate::profile::get(&profile_path, None).await? {
            p.profile_id()
@@ -45,39 +84,37 @@ pub async fn get_logs(
            .into());
        };

-    let logs_folder = state.directories.profile_logs_dir(&profile_path).await?;
+    let logs_folder = DirectoryInfo::profile_logs_dir(&profile_path).await?;
    let mut logs = Vec::new();
    if logs_folder.exists() {
        for entry in std::fs::read_dir(&logs_folder)
            .map_err(|e| IOError::with_path(e, &logs_folder))?
        {
-            let entry =
+            let entry: std::fs::DirEntry =
                entry.map_err(|e| IOError::with_path(e, &logs_folder))?;
            let path = entry.path();
-            if path.is_dir() {
-                if let Some(datetime_string) = path.file_name() {
-                    logs.push(
-                        Logs::build(
-                            &profile_path,
-                            datetime_string.to_string_lossy().to_string(),
-                            clear_contents,
-                        )
-                        .await,
-                    );
-                }
+            if !path.is_file() {
+                continue;
+            }
+            if let Some(file_name) = path.file_name() {
+                let file_name = file_name.to_string_lossy().to_string();
+
+                logs.push(
+                    Logs::build(&profile_path, file_name, clear_contents).await,
+                );
            }
        }
    }

    let mut logs = logs.into_iter().collect::<crate::Result<Vec<Logs>>>()?;
-    logs.sort_by_key(|x| x.datetime_string.clone());
+    logs.sort_by_key(|x| x.filename.clone());
    Ok(logs)
 }

 #[tracing::instrument]
-pub async fn get_logs_by_datetime(
+pub async fn get_logs_by_filename(
    profile_path: ProfilePathId,
-    datetime_string: String,
+    filename: String,
 ) -> crate::Result<Logs> {
    let profile_path =
        if let Some(p) = crate::profile::get(&profile_path, None).await? {
@@ -89,23 +126,71 @@ pub async fn get_logs_by_datetime(
            .into());
        };
    Ok(Logs {
-        output: Some(
-            get_output_by_datetime(&profile_path, &datetime_string).await?,
-        ),
-        datetime_string,
+        output: Some(get_output_by_filename(&profile_path, &filename).await?),
+        filename,
    })
 }

 #[tracing::instrument]
-pub async fn get_output_by_datetime(
+pub async fn get_output_by_filename(
    profile_subpath: &ProfilePathId,
-    datetime_string: &str,
-) -> crate::Result<String> {
+    file_name: &str,
+) -> crate::Result<CensoredString> {
    let state = State::get().await?;
-    let logs_folder =
-        state.directories.profile_logs_dir(profile_subpath).await?;
-    let path = logs_folder.join(datetime_string).join("stdout.log");
-    Ok(io::read_to_string(&path).await?)
+    let logs_folder = DirectoryInfo::profile_logs_dir(profile_subpath).await?;
+    let path = logs_folder.join(file_name);
+
+    let credentials: Vec<Credentials> = state
+        .users
+        .read()
+        .await
+        .users
+        .clone()
+        .into_values()
+        .collect();
+
+    // Load .gz file into String
+    if let Some(ext) = path.extension() {
+        if ext == "gz" {
+            let file = std::fs::File::open(&path)
+                .map_err(|e| IOError::with_path(e, &path))?;
+            let mut contents = [0; 1024];
+            let mut result = String::new();
+            let mut gz =
+                flate2::read::GzDecoder::new(std::io::BufReader::new(file));
+
+            while gz
+                .read(&mut contents)
+                .map_err(|e| IOError::with_path(e, &path))?
+                > 0
+            {
+                result.push_str(&String::from_utf8_lossy(&contents));
+                contents = [0; 1024];
+            }
+            return Ok(CensoredString::censor(result, &credentials));
+        } else if ext == "log" {
+            let mut result = String::new();
+            let mut contents = [0; 1024];
+            let mut file = std::fs::File::open(&path)
+                .map_err(|e| IOError::with_path(e, &path))?;
+            // iteratively read the file to a String
+            while file
+                .read(&mut contents)
+                .map_err(|e| IOError::with_path(e, &path))?
+                > 0
+            {
+                result.push_str(&String::from_utf8_lossy(&contents));
+                contents = [0; 1024];
+            }
+            let result = CensoredString::censor(result, &credentials);
+            return Ok(result);
+        }
+    }
+    Err(crate::ErrorKind::OtherError(format!(
+        "File extension not supported: {}",
+        path.display()
+    ))
+    .into())
 }

 #[tracing::instrument]
@@ -120,8 +205,7 @@ pub async fn delete_logs(profile_path: ProfilePathId) -> crate::Result<()> {
            .into());
        };

-    let state = State::get().await?;
-    let logs_folder = state.directories.profile_logs_dir(&profile_path).await?;
+    let logs_folder = DirectoryInfo::profile_logs_dir(&profile_path).await?;
    for entry in std::fs::read_dir(&logs_folder)
        .map_err(|e| IOError::with_path(e, &logs_folder))?
    {
@@ -135,9 +219,9 @@ pub async fn delete_logs(profile_path: ProfilePathId) -> crate::Result<()> {
 }

 #[tracing::instrument]
-pub async fn delete_logs_by_datetime(
+pub async fn delete_logs_by_filename(
    profile_path: ProfilePathId,
-    datetime_string: &str,
+    filename: &str,
 ) -> crate::Result<()> {
    let profile_path =
        if let Some(p) = crate::profile::get(&profile_path, None).await? {
@@ -149,9 +233,87 @@ pub async fn delete_logs_by_datetime(
            .into());
        };

-    let state = State::get().await?;
-    let logs_folder = state.directories.profile_logs_dir(&profile_path).await?;
-    let path = logs_folder.join(datetime_string);
+    let logs_folder = DirectoryInfo::profile_logs_dir(&profile_path).await?;
+    let path = logs_folder.join(filename);
    io::remove_dir_all(&path).await?;
    Ok(())
 }
+
+#[tracing::instrument]
+pub async fn get_latest_log_cursor(
+    profile_path: ProfilePathId,
+    cursor: u64, // 0 to start at beginning of file
+) -> crate::Result<LatestLogCursor> {
+    get_generic_live_log_cursor(profile_path, "latest.log", cursor).await
+}
+
+#[tracing::instrument]
+pub async fn get_generic_live_log_cursor(
+    profile_path: ProfilePathId,
+    log_file_name: &str,
+    mut cursor: u64, // 0 to start at beginning of file
+) -> crate::Result<LatestLogCursor> {
+    let profile_path =
+        if let Some(p) = crate::profile::get(&profile_path, None).await? {
+            p.profile_id()
+        } else {
+            return Err(crate::ErrorKind::UnmanagedProfileError(
+                profile_path.to_string(),
+            )
+            .into());
+        };
+
+    let state = State::get().await?;
+    let logs_folder = DirectoryInfo::profile_logs_dir(&profile_path).await?;
+    let path = logs_folder.join(log_file_name);
+    if !path.exists() {
+        // Allow silent failure if latest.log doesn't exist (as the instance may have been launched, but not yet created the file)
+        return Ok(LatestLogCursor {
+            cursor: 0,
+            new_file: false,
+            output: CensoredString("".to_string()),
+        });
+    }
+
+    let mut file = File::open(&path)
+        .await
+        .map_err(|e| IOError::with_path(e, &path))?;
+    let metadata = file
+        .metadata()
+        .await
+        .map_err(|e| IOError::with_path(e, &path))?;
+
+    let mut new_file = false;
+    if cursor > metadata.len() {
+        // Cursor is greater than file length, reset cursor to 0
+        // Likely cause is that the file was rotated while the log was being read
+        cursor = 0;
+        new_file = true;
+    }
+
+    let mut buffer = Vec::new();
+    file.seek(SeekFrom::Start(cursor))
+        .map_err(|e| IOError::with_path(e, &path))
+        .await?; // Seek to cursor
+    let bytes_read = file
+        .read_to_end(&mut buffer)
+        .map_err(|e| IOError::with_path(e, &path))
+        .await?; // Read to end of file
+    let output = String::from_utf8_lossy(&buffer).to_string(); // Convert to String
+    let cursor = cursor + bytes_read as u64; // Update cursor
+
+    let credentials: Vec<Credentials> = state
+        .users
+        .read()
+        .await
+        .users
+        .clone()
+        .into_values()
+        .collect();
+    let output = CensoredString::censor(output, &credentials);
+    Ok(LatestLogCursor {
+        cursor,
+        new_file,
+        output,
+    })
+}
--- a/theseus/src/api/metadata.rs
+++ b/theseus/src/api/metadata.rs
@@ -33,3 +33,11 @@ pub async fn get_quilt_versions() -> crate::Result<Manifest> {

    Ok(tags)
 }
+
+#[tracing::instrument]
+pub async fn get_neoforge_versions() -> crate::Result<Manifest> {
+    let state = State::get().await?;
+    let tags = state.metadata.read().await.neoforge.clone();
+
+    Ok(tags)
+}
--- a/theseus/src/api/minecraft_auth.rs
+++ b/theseus/src/api/minecraft_auth.rs
@@ -0,0 +1,76 @@
+//! Authentication flow interface
+use crate::state::{Credentials, MinecraftLoginFlow};
+use crate::State;
+
+#[tracing::instrument]
+pub async fn begin_login() -> crate::Result<MinecraftLoginFlow> {
+    let state = State::get().await?;
+    let mut users = state.users.write().await;
+
+    users.login_begin().await
+}
+
+#[tracing::instrument]
+pub async fn finish_login(
+    code: &str,
+    flow: MinecraftLoginFlow,
+) -> crate::Result<Credentials> {
+    let state = State::get().await?;
+    let mut users = state.users.write().await;
+
+    users.login_finish(code, flow).await
+}
+
+#[tracing::instrument]
+pub async fn get_default_user() -> crate::Result<Option<uuid::Uuid>> {
+    let state = State::get().await?;
+    let users = state.users.read().await;
+    Ok(users.default_user)
+}
+
+#[tracing::instrument]
+pub async fn set_default_user(user: uuid::Uuid) -> crate::Result<()> {
+    let user = get_user(user).await?;
+    let state = State::get().await?;
+    let mut users = state.users.write().await;
+    users.default_user = Some(user.id);
+    users.save().await?;
+    Ok(())
+}
+
+/// Remove a user account from the database
+#[tracing::instrument]
+pub async fn remove_user(user: uuid::Uuid) -> crate::Result<()> {
+    let state = State::get().await?;
+    let mut users = state.users.write().await;
+    users.remove(user).await?;
+
+    Ok(())
+}
+
+/// Get a copy of the list of all user credentials
+#[tracing::instrument]
+pub async fn users() -> crate::Result<Vec<Credentials>> {
+    let state = State::get().await?;
+    let users = state.users.read().await;
+    Ok(users.users.values().cloned().collect())
+}
+
+/// Get a specific user by user ID
+/// Prefer to use 'refresh' instead of this function
+#[tracing::instrument]
+pub async fn get_user(user: uuid::Uuid) -> crate::Result<Credentials> {
+    let state = State::get().await?;
+    let users = state.users.read().await;
+    let user = users
+        .users
+        .get(&user)
+        .ok_or_else(|| {
+            crate::ErrorKind::OtherError(format!(
+                "Tried to get nonexistent user with ID {user}"
+            ))
+            .as_error()
+        })?
+        .clone();
+    Ok(user)
+}
--- a/theseus/src/api/mod.rs
+++ b/theseus/src/api/mod.rs
@@ -1,9 +1,9 @@
 //! API for interacting with Theseus
-pub mod auth;
 pub mod handler;
 pub mod jre;
 pub mod logs;
 pub mod metadata;
+pub mod minecraft_auth;
 pub mod mr_auth;
 pub mod pack;
 pub mod process;
@@ -14,19 +14,19 @@ pub mod tags;

 pub mod data {
    pub use crate::state::{
-        DirectoryInfo, Hooks, JavaSettings, LinkedData, MemorySettings,
-        ModLoader, ModrinthCredentials, ModrinthCredentialsResult,
-        ModrinthProject, ModrinthTeamMember, ModrinthUser, ModrinthVersion,
-        ProfileMetadata, ProjectMetadata, Settings, Theme, WindowSize,
+        Credentials, DirectoryInfo, Hooks, JavaSettings, LinkedData,
+        MemorySettings, ModLoader, ModrinthCredentials,
+        ModrinthCredentialsResult, ModrinthProject, ModrinthTeamMember,
+        ModrinthUser, ModrinthVersion, ProfileMetadata, ProjectMetadata,
+        Settings, Theme, WindowSize,
    };
 }

 pub mod prelude {
    pub use crate::{
-        auth::{self, Credentials},
        data::*,
        event::CommandPayload,
-        jre, metadata, pack, process,
+        jre, metadata, minecraft_auth, pack, process,
        profile::{self, create, Profile},
        settings,
        state::JavaGlobals,
--- a/theseus/src/api/mr_auth.rs
+++ b/theseus/src/api/mr_auth.rs
@@ -90,22 +90,6 @@ pub async fn login_2fa(
    Ok(creds)
 }

-#[tracing::instrument]
-pub async fn login_minecraft(
-    flow: &str,
-) -> crate::Result<ModrinthCredentialsResult> {
-    let state = crate::State::get().await?;
-    let creds =
-        crate::state::login_minecraft(flow, &state.fetch_semaphore).await?;
-
-    if let ModrinthCredentialsResult::Credentials(creds) = &creds {
-        let mut write = state.credentials.write().await;
-        write.login(creds.clone()).await?;
-    }
-
-    Ok(creds)
-}
-
 #[tracing::instrument]
 pub async fn create_account(
    username: &str,
--- a/theseus/src/api/pack/import/atlauncher.rs
+++ b/theseus/src/api/pack/import/atlauncher.rs
@@ -218,6 +218,10 @@ async fn import_atlauncher_unmanaged(
        prof.metadata.linked_data = Some(LinkedData {
            project_id: description.project_id.clone(),
            version_id: description.version_id.clone(),
+            locked: Some(
+                description.project_id.is_some()
+                    && description.version_id.is_some(),
+            ),
        });
        prof.metadata.icon = description.icon.clone();
        prof.metadata.game_version = game_version.clone();
@@ -241,8 +245,12 @@ async fn import_atlauncher_unmanaged(
    if let Some(profile_val) =
        crate::api::profile::get(&profile_path, None).await?
    {
-        crate::launcher::install_minecraft(&profile_val, Some(loading_bar))
-            .await?;
+        crate::launcher::install_minecraft(
+            &profile_val,
+            Some(loading_bar),
+            false,
+        )
+        .await?;
        {
            let state = State::get().await?;
            let mut file_watcher = state.file_watcher.write().await;
--- a/theseus/src/api/pack/import/curseforge.rs
+++ b/theseus/src/api/pack/import/curseforge.rs
@@ -16,37 +16,22 @@ use crate::{

 use super::{copy_dotminecraft, recache_icon};

-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct FlameManifest {
-    pub manifest_version: u8,
-    pub name: String,
-    pub minecraft: FlameMinecraft,
-}
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct FlameMinecraft {
-    pub version: String,
-    pub mod_loaders: Vec<FlameModLoader>,
-}
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct FlameModLoader {
-    pub id: String,
-    pub primary: bool,
-}
-
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct MinecraftInstance {
    pub name: Option<String>,
+    pub base_mod_loader: Option<MinecraftInstanceModLoader>,
    pub profile_image_path: Option<PathBuf>,
    pub installed_modpack: Option<InstalledModpack>,
    pub game_version: String, // Minecraft game version. Non-prioritized, use this if Vanilla
 }
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
-
+pub struct MinecraftInstanceModLoader {
+    pub name: String,
+}
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
 pub struct InstalledModpack {
    pub thumbnail_url: Option<String>,
 }
@@ -113,35 +98,26 @@ pub async fn import_curseforge(
        }
    }

-    // Curseforge vanilla profile may not have a manifest.json, so we allow it to not exist
-    if curseforge_instance_folder.join("manifest.json").exists() {
-        // Load manifest.json
-        let cf_manifest: String = io::read_to_string(
-            &curseforge_instance_folder.join("manifest.json"),
-        )
-        .await?;
-
-        let cf_manifest: FlameManifest =
-            serde_json::from_str::<FlameManifest>(&cf_manifest)?;
-
-        let game_version = cf_manifest.minecraft.version;
+    // base mod loader is always None for vanilla
+    if let Some(instance_mod_loader) = minecraft_instance.base_mod_loader {
+        let game_version = minecraft_instance.game_version;

        // CF allows Forge, Fabric, and Vanilla
        let mut mod_loader = None;
        let mut loader_version = None;
-        for loader in cf_manifest.minecraft.mod_loaders {
-            match loader.id.split_once('-') {
-                Some(("forge", version)) => {
-                    mod_loader = Some(ModLoader::Forge);
-                    loader_version = Some(version.to_string());
-                }
-                Some(("fabric", version)) => {
-                    mod_loader = Some(ModLoader::Fabric);
-                    loader_version = Some(version.to_string());
-                }
-                _ => {}
+
+        match instance_mod_loader.name.split('-').collect::<Vec<&str>>()[..] {
+            ["forge", version] => {
+                mod_loader = Some(ModLoader::Forge);
+                loader_version = Some(version.to_string());
            }
+            ["fabric", version, _game_version] => {
+                mod_loader = Some(ModLoader::Fabric);
+                loader_version = Some(version.to_string());
+            }
+            _ => {}
        }
+
        let mod_loader = mod_loader.unwrap_or(ModLoader::Vanilla);

        let loader_version = if mod_loader != ModLoader::Vanilla {
@@ -170,7 +146,7 @@ pub async fn import_curseforge(
        })
        .await?;
    } else {
-        // If no manifest is found, it's a vanilla profile
+        // create a vanilla profile
        crate::api::profile::edit(&profile_path, |prof| {
            prof.metadata.name = override_title
                .clone()
@@ -199,8 +175,12 @@ pub async fn import_curseforge(
    if let Some(profile_val) =
        crate::api::profile::get(&profile_path, None).await?
    {
-        crate::launcher::install_minecraft(&profile_val, Some(loading_bar))
-            .await?;
+        crate::launcher::install_minecraft(
+            &profile_val,
+            Some(loading_bar),
+            false,
+        )
+        .await?;

        {
            let state = State::get().await?;
--- a/theseus/src/api/pack/import/gdlauncher.rs
+++ b/theseus/src/api/pack/import/gdlauncher.rs
@@ -112,8 +112,12 @@ pub async fn import_gdlauncher(
    if let Some(profile_val) =
        crate::api::profile::get(&profile_path, None).await?
    {
-        crate::launcher::install_minecraft(&profile_val, Some(loading_bar))
-            .await?;
+        crate::launcher::install_minecraft(
+            &profile_val,
+            Some(loading_bar),
+            false,
+        )
+        .await?;
        {
            let state = State::get().await?;
            let mut file_watcher = state.file_watcher.write().await;
--- a/theseus/src/api/pack/import/mmc.rs
+++ b/theseus/src/api/pack/import/mmc.rs
@@ -306,6 +306,7 @@ async fn import_mmc_unmanaged(
        &description,
        &backup_name,
        &dependencies,
+        false,
    )
    .await?;

@@ -322,8 +323,12 @@ async fn import_mmc_unmanaged(
    if let Some(profile_val) =
        crate::api::profile::get(&profile_path, None).await?
    {
-        crate::launcher::install_minecraft(&profile_val, Some(loading_bar))
-            .await?;
+        crate::launcher::install_minecraft(
+            &profile_val,
+            Some(loading_bar),
+            false,
+        )
+        .await?;
        {
            let state = State::get().await?;
            let mut file_watcher = state.file_watcher.write().await;
--- a/theseus/src/api/pack/import/mod.rs
+++ b/theseus/src/api/pack/import/mod.rs
@@ -251,7 +251,7 @@ pub async fn recache_icon(
    }
 }

-async fn copy_dotminecraft(
+pub async fn copy_dotminecraft(
    profile_path_id: ProfilePathId,
    dotminecraft: PathBuf,
    io_semaphore: &IoSemaphore,
@@ -301,7 +301,7 @@ async fn copy_dotminecraft(
 #[theseus_macros::debug_pin]
 #[async_recursion::async_recursion]
 #[tracing::instrument]
-async fn get_all_subfiles(src: &Path) -> crate::Result<Vec<PathBuf>> {
+pub async fn get_all_subfiles(src: &Path) -> crate::Result<Vec<PathBuf>> {
    if !src.is_dir() {
        return Ok(vec![src.to_path_buf()]);
    }
--- a/theseus/src/api/pack/install_from.rs
+++ b/theseus/src/api/pack/install_from.rs
@@ -10,7 +10,7 @@ use crate::util::fetch::{
    fetch, fetch_advanced, fetch_json, write_cached_icon,
 };
 use crate::util::io;
-use crate::State;
+use crate::{InnerProjectPathUnix, State};

 use reqwest::Method;
 use serde::{Deserialize, Serialize};
@@ -33,7 +33,7 @@ pub struct PackFormat {
 #[derive(Serialize, Deserialize, Eq, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub struct PackFile {
-    pub path: String,
+    pub path: InnerProjectPathUnix,
    pub hashes: HashMap<PackFileHash, String>,
    pub env: Option<HashMap<EnvType, SideType>>,
    pub downloads: Vec<String>,
@@ -66,11 +66,21 @@ pub enum EnvType {
 }

 #[derive(Serialize, Deserialize, Clone, Copy, Hash, PartialEq, Eq, Debug)]
-#[serde(rename_all = "kebab-case")]
 pub enum PackDependency {
+    #[serde(rename = "forge")]
    Forge,
+
+    #[serde(rename = "neoforge")]
+    #[serde(alias = "neo-forge")]
+    NeoForge,
+
+    #[serde(rename = "fabric-loader")]
    FabricLoader,
+
+    #[serde(rename = "quilt-loader")]
    QuiltLoader,
+
+    #[serde(rename = "minecraft")]
    Minecraft,
 }

@@ -152,6 +162,7 @@ pub fn get_profile_from_pack(
            linked_data: Some(LinkedData {
                project_id: Some(project_id),
                version_id: Some(version_id),
+                locked: Some(true),
            }),
            ..Default::default()
        },
@@ -178,20 +189,29 @@ pub async fn generate_pack_from_version_id(
    title: String,
    icon_url: Option<String>,
    profile_path: ProfilePathId,
+
+    // Existing loading bar. Unlike when existing_loading_bar is used, this one is pre-initialized with PackFileDownload
+    // For example, you might use this if multiple packs are being downloaded at once and you want to use the same loading bar
+    initialized_loading_bar: Option<LoadingBarId>,
 ) -> crate::Result<CreatePack> {
    let state = State::get().await?;

-    let loading_bar = init_loading(
-        LoadingBarType::PackFileDownload {
-            profile_path: profile_path.get_full_path().await?,
-            pack_name: title,
-            icon: icon_url,
-            pack_version: version_id.clone(),
-        },
-        100.0,
-        "Downloading pack file",
-    )
-    .await?;
+    let loading_bar = if let Some(bar) = initialized_loading_bar {
+        emit_loading(&bar, 0.0, Some("Downloading pack file")).await?;
+        bar
+    } else {
+        init_loading(
+            LoadingBarType::PackFileDownload {
+                profile_path: profile_path.get_full_path().await?,
+                pack_name: title,
+                icon: icon_url,
+                pack_version: version_id.clone(),
+            },
+            100.0,
+            "Downloading pack file",
+        )
+        .await?
+    };

    emit_loading(&loading_bar, 0.0, Some("Fetching version")).await?;
    let creds = state.credentials.read().await;
@@ -312,6 +332,7 @@ pub async fn set_profile_information(
    description: &CreatePackDescription,
    backup_name: &str,
    dependencies: &HashMap<PackDependency, String>,
+    ignore_lock: bool, // do not change locked status
 ) -> crate::Result<()> {
    let mut game_version: Option<&String> = None;
    let mut mod_loader = None;
@@ -323,6 +344,10 @@ pub async fn set_profile_information(
                mod_loader = Some(ModLoader::Forge);
                loader_version = Some(value);
            }
+            PackDependency::NeoForge => {
+                mod_loader = Some(ModLoader::NeoForge);
+                loader_version = Some(value);
+            }
            PackDependency::FabricLoader => {
                mod_loader = Some(ModLoader::Fabric);
                loader_version = Some(value);
@@ -362,10 +387,26 @@ pub async fn set_profile_information(
            .clone()
            .unwrap_or_else(|| backup_name.to_string());
        prof.install_stage = ProfileInstallStage::PackInstalling;
-        prof.metadata.linked_data = Some(LinkedData {
-            project_id: description.project_id.clone(),
-            version_id: description.version_id.clone(),
-        });
+
+        let project_id = description.project_id.clone();
+        let version_id = description.version_id.clone();
+
+        prof.metadata.linked_data = if project_id.is_some()
+            && version_id.is_some()
+        {
+            Some(LinkedData {
+                project_id,
+                version_id,
+                locked: if !ignore_lock {
+                    Some(true)
+                } else {
+                    prof.metadata.linked_data.as_ref().and_then(|x| x.locked)
+                },
+            })
+        } else {
+            None
+        };
+
        prof.metadata.icon = description.icon.clone();
        prof.metadata.game_version = game_version.clone();
        prof.metadata.loader_version = loader_version.clone();
--- a/theseus/src/api/pack/install_mrpack.rs
+++ b/theseus/src/api/pack/install_mrpack.rs
@@ -1,3 +1,4 @@
+use crate::config::MODRINTH_API_URL;
 use crate::event::emit::{
    emit_loading, init_or_edit_loading, loading_try_for_each_concurrent,
 };
@@ -5,13 +6,16 @@ use crate::event::LoadingBarType;
 use crate::pack::install_from::{
    set_profile_information, EnvType, PackFile, PackFileHash,
 };
-use crate::prelude::ProfilePathId;
+use crate::prelude::{ModrinthVersion, ProfilePathId, ProjectMetadata};
 use crate::state::{ProfileInstallStage, Profiles, SideType};
-use crate::util::fetch::{fetch_mirrors, write};
+use crate::util::fetch::{fetch_json, fetch_mirrors, write};
 use crate::util::io;
 use crate::{profile, State};
-use async_zip::tokio::read::seek::ZipFileReader;
+use async_zip::base::read::seek::ZipFileReader;
+use reqwest::Method;
+use serde_json::json;

+use std::collections::HashMap;
 use std::io::Cursor;
 use std::path::{Component, PathBuf};

@@ -43,6 +47,7 @@ pub async fn install_zipped_mrpack(
                title,
                icon_url,
                profile_path.clone(),
+                None,
            )
            .await?
        }
@@ -52,7 +57,7 @@ pub async fn install_zipped_mrpack(
    };

    // Install pack files, and if it fails, fail safely by removing the profile
-    let result = install_zipped_mrpack_files(create_pack).await;
+    let result = install_zipped_mrpack_files(create_pack, false).await;

    // Check existing managed packs for potential updates
    tokio::task::spawn(Profiles::update_modrinth_versions());
@@ -72,6 +77,7 @@ pub async fn install_zipped_mrpack(
 #[theseus_macros::debug_pin]
 pub async fn install_zipped_mrpack_files(
    create_pack: CreatePack,
+    ignore_lock: bool,
 ) -> crate::Result<ProfilePathId> {
    let state = &State::get().await?;

@@ -87,29 +93,21 @@ pub async fn install_zipped_mrpack_files(
    let reader: Cursor<&bytes::Bytes> = Cursor::new(&file);

    // Create zip reader around file
-    let mut zip_reader = ZipFileReader::new(reader).await.map_err(|_| {
-        crate::Error::from(crate::ErrorKind::InputError(
-            "Failed to read input modpack zip".to_string(),
-        ))
-    })?;
+    let mut zip_reader =
+        ZipFileReader::with_tokio(reader).await.map_err(|_| {
+            crate::Error::from(crate::ErrorKind::InputError(
+                "Failed to read input modpack zip".to_string(),
+            ))
+        })?;

    // Extract index of modrinth.index.json
-    let zip_index_option = zip_reader
-        .file()
-        .entries()
-        .iter()
-        .position(|f| f.entry().filename() == "modrinth.index.json");
+    let zip_index_option = zip_reader.file().entries().iter().position(|f| {
+        f.filename().as_str().unwrap_or_default() == "modrinth.index.json"
+    });
    if let Some(zip_index) = zip_index_option {
        let mut manifest = String::new();
-        let entry = zip_reader
-            .file()
-            .entries()
-            .get(zip_index)
-            .unwrap()
-            .entry()
-            .clone();
-        let mut reader = zip_reader.entry(zip_index).await?;
-        reader.read_to_string_checked(&mut manifest, &entry).await?;
+        let mut reader = zip_reader.reader_with_entry(zip_index).await?;
+        reader.read_to_string_checked(&mut manifest).await?;

        let pack: PackFormat = serde_json::from_str(&manifest)?;

@@ -126,6 +124,7 @@ pub async fn install_zipped_mrpack_files(
            &description,
            &pack.name,
            &pack.dependencies,
+            ignore_lock,
        )
        .await?;

@@ -182,15 +181,17 @@ pub async fn install_zipped_mrpack_files(
                    .await?;
                    drop(creds);

+                    let project_path = project.path.to_string();
+
                    let path =
-                        std::path::Path::new(&project.path).components().next();
+                        std::path::Path::new(&project_path).components().next();
                    if let Some(path) = path {
                        match path {
                            Component::CurDir | Component::Normal(_) => {
                                let path = profile_path
                                    .get_full_path()
                                    .await?
-                                    .join(&project.path);
+                                    .join(&project_path);
                                write(&path, &file, &state.io_semaphore)
                                    .await?;
                            }
@@ -208,34 +209,31 @@ pub async fn install_zipped_mrpack_files(
        let mut total_len = 0;

        for index in 0..zip_reader.file().entries().len() {
-            let file = zip_reader.file().entries().get(index).unwrap().entry();
+            let file = zip_reader.file().entries().get(index).unwrap();
+            let filename = file.filename().as_str().unwrap_or_default();

-            if (file.filename().starts_with("overrides")
-                || file.filename().starts_with("client_overrides"))
-                && !file.filename().ends_with('/')
+            if (filename.starts_with("overrides")
+                || filename.starts_with("client-overrides"))
+                && !filename.ends_with('/')
            {
                total_len += 1;
            }
        }

        for index in 0..zip_reader.file().entries().len() {
-            let file = zip_reader
-                .file()
-                .entries()
-                .get(index)
-                .unwrap()
-                .entry()
-                .clone();
+            let file = zip_reader.file().entries().get(index).unwrap();

-            let file_path = PathBuf::from(file.filename());
-            if (file.filename().starts_with("overrides")
-                || file.filename().starts_with("client_overrides"))
-                && !file.filename().ends_with('/')
+            let filename = file.filename().as_str().unwrap_or_default();
+
+            let file_path = PathBuf::from(filename);
+            if (filename.starts_with("overrides")
+                || filename.starts_with("client-overrides"))
+                && !filename.ends_with('/')
            {
                // Reads the file into the 'content' variable
                let mut content = Vec::new();
-                let mut reader = zip_reader.entry(index).await?;
-                reader.read_to_end_checked(&mut content, &file).await?;
+                let mut reader = zip_reader.reader_with_entry(index).await?;
+                reader.read_to_end_checked(&mut content).await?;

                let mut new_path = PathBuf::new();
                let components = file_path.components().skip(1);
@@ -274,8 +272,12 @@ pub async fn install_zipped_mrpack_files(
        }

        if let Some(profile_val) = profile::get(&profile_path, None).await? {
-            crate::launcher::install_minecraft(&profile_val, Some(loading_bar))
-                .await?;
+            crate::launcher::install_minecraft(
+                &profile_val,
+                Some(loading_bar),
+                false,
+            )
+            .await?;

            State::sync().await?;
        }
@@ -297,29 +299,22 @@ pub async fn remove_all_related_files(
    let reader: Cursor<&bytes::Bytes> = Cursor::new(&mrpack_file);

    // Create zip reader around file
-    let mut zip_reader = ZipFileReader::new(reader).await.map_err(|_| {
-        crate::Error::from(crate::ErrorKind::InputError(
-            "Failed to read input modpack zip".to_string(),
-        ))
-    })?;
+    let mut zip_reader =
+        ZipFileReader::with_tokio(reader).await.map_err(|_| {
+            crate::Error::from(crate::ErrorKind::InputError(
+                "Failed to read input modpack zip".to_string(),
+            ))
+        })?;

    // Extract index of modrinth.index.json
-    let zip_index_option = zip_reader
-        .file()
-        .entries()
-        .iter()
-        .position(|f| f.entry().filename() == "modrinth.index.json");
+    let zip_index_option = zip_reader.file().entries().iter().position(|f| {
+        f.filename().as_str().unwrap_or_default() == "modrinth.index.json"
+    });
    if let Some(zip_index) = zip_index_option {
        let mut manifest = String::new();
-        let entry = zip_reader
-            .file()
-            .entries()
-            .get(zip_index)
-            .unwrap()
-            .entry()
-            .clone();
-        let mut reader = zip_reader.entry(zip_index).await?;
-        reader.read_to_string_checked(&mut manifest, &entry).await?;
+
+        let mut reader = zip_reader.reader_with_entry(zip_index).await?;
+        reader.read_to_string_checked(&mut manifest).await?;

        let pack: PackFormat = serde_json::from_str(&manifest)?;

@@ -337,46 +332,79 @@ pub async fn remove_all_related_files(
        })
        .await?;

-        let num_files = pack.files.len();
-        use futures::StreamExt;
-        loading_try_for_each_concurrent(
-            futures::stream::iter(pack.files.into_iter())
-                .map(Ok::<PackFile, crate::Error>),
-            None,
-            None,
-            0.0,
-            num_files,
-            None,
-            |project| {
-                let profile_path = profile_path.clone();
-                async move {
-                    // Remove this file if a corresponding one exists in the filesystem
-                    let existing_file =
-                        profile_path.get_full_path().await?.join(&project.path);
-                    if existing_file.exists() {
-                        io::remove_file(&existing_file).await?;
-                    }
+        // First, remove all modrinth projects by their version hashes
+        // Remove all modrinth projects by their version hashes
+        // We need to do a fetch to get the project ids from Modrinth
+        let state = State::get().await?;
+        let all_hashes = pack
+            .files
+            .iter()
+            .filter_map(|f| Some(f.hashes.get(&PackFileHash::Sha512)?.clone()))
+            .collect::<Vec<_>>();
+        let creds = state.credentials.read().await;

-                    Ok(())
-                }
-            },
+        // First, get project info by hash
+        let files_url = format!("{}version_files", MODRINTH_API_URL);
+
+        let hash_projects = fetch_json::<HashMap<String, ModrinthVersion>>(
+            Method::POST,
+            &files_url,
+            None,
+            Some(json!({
+                "hashes": all_hashes,
+                "algorithm": "sha512",
+            })),
+            &state.fetch_semaphore,
+            &creds,
        )
        .await?;
+        let to_remove = hash_projects
+            .into_values()
+            .map(|p| p.project_id)
+            .collect::<Vec<_>>();
+        let profile =
+            profile::get(&profile_path, None).await?.ok_or_else(|| {
+                crate::ErrorKind::UnmanagedProfileError(
+                    profile_path.to_string(),
+                )
+            })?;
+        for (project_id, project) in &profile.projects {
+            if let ProjectMetadata::Modrinth { project, .. } = &project.metadata
+            {
+                if to_remove.contains(&project.id) {
+                    let path = profile
+                        .get_profile_full_path()
+                        .await?
+                        .join(project_id.0.clone());
+                    if path.exists() {
+                        io::remove_file(&path).await?;
+                    }
+                }
+            }
+        }
+
+        // Iterate over all Modrinth project file paths in the json, and remove them
+        // (There should be few, but this removes any files the .mrpack intended as Modrinth projects but were unrecognized)
+        for file in pack.files {
+            let path: PathBuf = profile_path
+                .get_full_path()
+                .await?
+                .join(file.path.to_string());
+            if path.exists() {
+                io::remove_file(&path).await?;
+            }
+        }

        // Iterate over each 'overrides' file and remove it
        for index in 0..zip_reader.file().entries().len() {
-            let file = zip_reader
-                .file()
-                .entries()
-                .get(index)
-                .unwrap()
-                .entry()
-                .clone();
+            let file = zip_reader.file().entries().get(index).unwrap();

-            let file_path = PathBuf::from(file.filename());
-            if (file.filename().starts_with("overrides")
-                || file.filename().starts_with("client_overrides"))
-                && !file.filename().ends_with('/')
+            let filename = file.filename().as_str().unwrap_or_default();
+
+            let file_path = PathBuf::from(filename);
+            if (filename.starts_with("overrides")
+                || filename.starts_with("client-overrides"))
+                && !filename.ends_with('/')
            {
                let mut new_path = PathBuf::new();
                let components = file_path.components().skip(1);
--- a/theseus/src/api/process.rs
+++ b/theseus/src/api/process.rs
@@ -2,16 +2,13 @@

 use uuid::Uuid;

+use crate::state::{MinecraftChild, ProfilePathId};
 pub use crate::{
    state::{
        Hooks, JavaSettings, MemorySettings, Profile, Settings, WindowSize,
    },
    State,
 };
-use crate::{
-    state::{MinecraftChild, ProfilePathId},
-    util::io::IOError,
-};

 // Gets whether a child process stored in the state by UUID has finished
 #[tracing::instrument]
@@ -26,7 +23,7 @@ pub async fn get_exit_status_by_uuid(
 ) -> crate::Result<Option<i32>> {
    let state = State::get().await?;
    let children = state.children.read().await;
-    Ok(children.exit_status(uuid).await?.and_then(|f| f.code()))
+    children.exit_status(uuid).await
 }

 // Gets the UUID of each stored process in the state
@@ -72,26 +69,6 @@ pub async fn get_uuids_by_profile_path(
    children.running_keys_with_profile(profile_path).await
 }

-// Gets output of a child process stored in the state by UUID, as a string
-#[tracing::instrument]
-pub async fn get_output_by_uuid(uuid: &Uuid) -> crate::Result<String> {
-    let state = State::get().await?;
-    // Get stdout from child
-    let children = state.children.read().await;
-
-    // Extract child or return crate::Error
-    if let Some(child) = children.get(uuid) {
-        let child = child.read().await;
-        Ok(child.output.get_output().await?)
-    } else {
-        Err(crate::ErrorKind::LauncherError(format!(
-            "No child process by UUID {}",
-            uuid
-        ))
-        .as_error())
-    }
-}
-
 // Kill a child process stored in the state by UUID, as a string
 #[tracing::instrument]
 pub async fn kill_by_uuid(uuid: &Uuid) -> crate::Result<()> {
@@ -124,13 +101,7 @@ pub async fn wait_for_by_uuid(uuid: &Uuid) -> crate::Result<()> {
 // Kill a running child process directly
 #[tracing::instrument(skip(running))]
 pub async fn kill(running: &mut MinecraftChild) -> crate::Result<()> {
-    running
-        .current_child
-        .write()
-        .await
-        .kill()
-        .await
-        .map_err(IOError::from)?;
+    running.current_child.write().await.kill().await?;
    Ok(())
 }

--- a/theseus/src/api/profile/create.rs
+++ b/theseus/src/api/profile/create.rs
@@ -1,13 +1,13 @@
 //! Theseus profile management interface
 use crate::pack::install_from::CreatePackProfile;
 use crate::prelude::ProfilePathId;
-use crate::profile;
 use crate::state::LinkedData;
 use crate::util::io::{self, canonicalize};
 use crate::{
    event::{emit::emit_profile, ProfilePayloadType},
    prelude::ModLoader,
 };
+use crate::{pack, profile, ErrorKind};
 pub use crate::{
    state::{JavaSettings, Profile},
    State,
@@ -102,6 +102,12 @@ pub async fn profile_create(
        }

        profile.metadata.linked_data = linked_data;
+        if let Some(linked_data) = &mut profile.metadata.linked_data {
+            linked_data.locked = Some(
+                linked_data.project_id.is_some()
+                    && linked_data.version_id.is_some(),
+            );
+        }

        emit_profile(
            uuid,
@@ -119,7 +125,7 @@ pub async fn profile_create(
        }

        if !skip_install_profile.unwrap_or(false) {
-            crate::launcher::install_minecraft(&profile, None).await?;
+            crate::launcher::install_minecraft(&profile, None, false).await?;
        }
        State::sync().await?;

@@ -154,6 +160,66 @@ pub async fn profile_create_from_creator(
    .await
 }

+pub async fn profile_create_from_duplicate(
+    copy_from: ProfilePathId,
+) -> crate::Result<ProfilePathId> {
+    // Original profile
+    let profile = profile::get(&copy_from, None).await?.ok_or_else(|| {
+        ErrorKind::UnmanagedProfileError(copy_from.to_string())
+    })?;
+
+    let profile_path_id = profile_create(
+        profile.metadata.name.clone(),
+        profile.metadata.game_version.clone(),
+        profile.metadata.loader,
+        profile.metadata.loader_version.clone().map(|it| it.id),
+        profile.metadata.icon.clone(),
+        profile.metadata.icon_url.clone(),
+        profile.metadata.linked_data.clone(),
+        Some(true),
+        Some(true),
+    )
+    .await?;
+
+    // Copy it over using the import system (essentially importing from the same profile)
+    let state = State::get().await?;
+    let bar = pack::import::copy_dotminecraft(
+        profile_path_id.clone(),
+        copy_from.get_full_path().await?,
+        &state.io_semaphore,
+        None,
+    )
+    .await?;
+
+    let duplicated_profile =
+        profile::get(&profile_path_id, None).await?.ok_or_else(|| {
+            ErrorKind::UnmanagedProfileError(profile_path_id.to_string())
+        })?;
+
+    crate::launcher::install_minecraft(&duplicated_profile, Some(bar), false)
+        .await?;
+    {
+        let state = State::get().await?;
+        let mut file_watcher = state.file_watcher.write().await;
+        Profile::watch_fs(
+            &profile.get_profile_full_path().await?,
+            &mut file_watcher,
+        )
+        .await?;
+    }
+
+    // emit profile edited
+    emit_profile(
+        profile.uuid,
+        &profile.profile_id(),
+        &profile.metadata.name,
+        ProfilePayloadType::Edited,
+    )
+    .await?;
+    State::sync().await?;
+    Ok(profile_path_id)
+}
+
 #[tracing::instrument]
 #[theseus_macros::debug_pin]
 pub(crate) async fn get_loader_version_from_loader(
@@ -180,6 +246,7 @@ pub(crate) async fn get_loader_version_from_loader(
        ModLoader::Forge => &metadata.forge,
        ModLoader::Fabric => &metadata.fabric,
        ModLoader::Quilt => &metadata.quilt,
+        ModLoader::NeoForge => &metadata.neoforge,
        _ => {
            return Err(
                ProfileCreationError::NoManifest(loader.to_string()).into()
@@ -205,8 +272,8 @@ pub(crate) async fn get_loader_version_from_loader(

    let loader_version = loaders
        .iter()
+        .find(|&x| filter(x))
        .cloned()
-        .find(filter)
        .or(
            // If stable was searched for but not found, return latest by default
            if version == "stable" {
--- a/theseus/src/api/profile/mod.rs
+++ b/theseus/src/api/profile/mod.rs
@@ -8,12 +8,13 @@ use crate::pack::install_from::{
    EnvType, PackDependency, PackFile, PackFileHash, PackFormat,
 };
 use crate::prelude::{JavaVersion, ProfilePathId, ProjectPathId};
-use crate::state::ProjectMetadata;
+use crate::state::{
+    Credentials, InnerProjectPathUnix, ProjectMetadata, SideType,
+};

 use crate::util::fetch;
 use crate::util::io::{self, IOError};
 use crate::{
-    auth::{self, refresh},
    event::{emit::emit_profile, ProfilePayloadType},
    state::MinecraftChild,
 };
@@ -25,8 +26,9 @@ use async_zip::tokio::write::ZipFileWriter;
 use async_zip::{Compression, ZipEntryBuilder};
 use serde_json::json;

-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};

+use std::iter::FromIterator;
 use std::{
    future::Future,
    path::{Path, PathBuf},
@@ -109,6 +111,26 @@ pub async fn get_full_path(path: &ProfilePathId) -> crate::Result<PathBuf> {
    Ok(full_path)
 }

+/// Get mod's full path in the filesystem
+#[tracing::instrument]
+pub async fn get_mod_full_path(
+    profile_path: &ProfilePathId,
+    project_path: &ProjectPathId,
+) -> crate::Result<PathBuf> {
+    if get(profile_path, Some(true)).await?.is_some() {
+        let full_path = io::canonicalize(
+            project_path.get_full_path(profile_path.clone()).await?,
+        )?;
+        return Ok(full_path);
+    }
+
+    Err(crate::ErrorKind::OtherError(format!(
+        "Tried to get the full path of a nonexistent or unloaded project at path {}!",
+        project_path.get_full_path(profile_path.clone()).await?.display()
+    ))
+    .into())
+}
+
 /// Edit a profile using a given asynchronous closure
 pub async fn edit<Fut>(
    path: &ProfilePathId,
@@ -260,9 +282,9 @@ pub async fn list(

 /// Installs/Repairs a profile
 #[tracing::instrument]
-pub async fn install(path: &ProfilePathId) -> crate::Result<()> {
+pub async fn install(path: &ProfilePathId, force: bool) -> crate::Result<()> {
    if let Some(profile) = get(path, None).await? {
-        crate::launcher::install_minecraft(&profile, None).await?;
+        crate::launcher::install_minecraft(&profile, None, force).await?;
    } else {
        return Err(crate::ErrorKind::UnmanagedProfileError(path.to_string())
            .as_error());
@@ -368,6 +390,10 @@ pub async fn update_project(
                    .add_project_version(update_version.id.clone())
                    .await?;

+                if project.disabled {
+                    profile.toggle_disable_project(&path).await?;
+                }
+
                if path != project_path.clone() {
                    profile.remove_project(project_path, Some(true)).await?;
                }
@@ -550,8 +576,10 @@ pub async fn remove_project(
 pub async fn export_mrpack(
    profile_path: &ProfilePathId,
    export_path: PathBuf,
-    included_overrides: Vec<String>, // which folders to include in the overrides
+    included_export_candidates: Vec<String>, // which folders/files to include in the export
    version_id: Option<String>,
+    description: Option<String>,
+    _name: Option<String>,
 ) -> crate::Result<()> {
    let state = State::get().await?;
    let io_semaphore = state.io_semaphore.0.read().await;
@@ -563,8 +591,8 @@ pub async fn export_mrpack(
        ))
    })?;

-    // remove .DS_Store files from included_overrides
-    let included_overrides = included_overrides
+    // remove .DS_Store files from included_export_candidates
+    let included_export_candidates = included_export_candidates
        .into_iter()
        .filter(|x| {
            if let Some(f) = PathBuf::from(x).file_name() {
@@ -581,16 +609,21 @@ pub async fn export_mrpack(
    let mut file = File::create(&export_path)
        .await
        .map_err(|e| IOError::with_path(e, &export_path))?;
-    let mut writer = ZipFileWriter::new(&mut file);
+    let mut writer = ZipFileWriter::with_tokio(&mut file);

    // Create mrpack json configuration file
    let version_id = version_id.unwrap_or("1.0.0".to_string());
-    let packfile = create_mrpack_json(&profile, version_id).await?;
-    let modrinth_path_list = get_modrinth_pack_list(&packfile);
+    let mut packfile =
+        create_mrpack_json(&profile, version_id, description).await?;
+    let included_candidates_set =
+        HashSet::<_>::from_iter(included_export_candidates.iter());
+    packfile.files.retain(|f| {
+        included_candidates_set.contains(&f.path.get_topmost_two_components())
+    });

    // Build vec of all files in the folder
    let mut path_list = Vec::new();
-    build_folder(profile_base_path, &mut path_list).await?;
+    add_all_recursive_folder_paths(profile_base_path, &mut path_list).await?;

    // Initialize loading bar
    let loading_bar = init_loading(
@@ -608,38 +641,13 @@ pub async fn export_mrpack(
    for path in path_list {
        emit_loading(&loading_bar, 1.0, None).await?;

-        // Get local path of file, relative to profile folder
-        let relative_path = path.strip_prefix(profile_base_path)?;
-
-        // Get highest level folder pair ('a/b' in 'a/b/c', 'a' in 'a')
-        // We only go one layer deep for the sake of not having a huge list of overrides
-        let topmost_two = relative_path.iter().take(2).collect::<Vec<_>>();
-
-        // a,b => a/b
-        // a => a
-        let topmost = match topmost_two.len() {
-            2 => PathBuf::from(topmost_two[0]).join(topmost_two[1]),
-            1 => PathBuf::from(topmost_two[0]),
-            _ => {
-                return Err(crate::ErrorKind::OtherError(
-                    "No topmost folder found".to_string(),
-                )
-                .into())
-            }
-        }
-        .to_string_lossy()
-        .to_string();
-
-        if !included_overrides.contains(&topmost) {
-            continue;
-        }
-
-        let relative_path: std::borrow::Cow<str> =
-            relative_path.to_string_lossy();
-        let relative_path = relative_path.replace('\\', "/");
-        let relative_path = relative_path.trim_start_matches('/').to_string();
-
-        if modrinth_path_list.contains(&relative_path) {
+        let relative_path = ProjectPathId::from_fs_path(&path)
+            .await?
+            .get_inner_path_unix();
+        if packfile.files.iter().any(|f| f.path == relative_path)
+            || !included_candidates_set
+                .contains(&relative_path.get_topmost_two_components())
+        {
            continue;
        }

@@ -653,7 +661,7 @@ pub async fn export_mrpack(
                .await
                .map_err(|e| IOError::with_path(e, &path))?;
            let builder = ZipEntryBuilder::new(
-                format!("overrides/{relative_path}"),
+                format!("overrides/{relative_path}").into(),
                Compression::Deflate,
            );
            writer.write_entry_whole(builder, &data).await?;
@@ -663,7 +671,7 @@ pub async fn export_mrpack(
    // Add modrinth json to the zip
    let data = serde_json::to_vec_pretty(&packfile)?;
    let builder = ZipEntryBuilder::new(
-        "modrinth.index.json".to_string(),
+        "modrinth.index.json".to_string().into(),
        Compression::Deflate,
    );
    writer.write_entry_whole(builder, &data).await?;
@@ -673,30 +681,28 @@ pub async fn export_mrpack(
    Ok(())
 }

-// Given a folder path, populate a Vec of all the subfolders
-// Intended to be used for finding potential override folders
+// Given a folder path, populate a Vec of all the subfolders and files, at most 2 layers deep
 // profile
 // -- folder1
 // -- folder2
+//    -- innerfolder
+//       -- innerfile
+//    -- folder2file
 // -- file1
-// => [folder1, folder2]
+// => [folder1, folder2/innerfolder, folder2/folder2file, file1]
 #[tracing::instrument]
-pub async fn get_potential_override_folders(
-    profile_path: ProfilePathId,
-) -> crate::Result<Vec<PathBuf>> {
+pub async fn get_pack_export_candidates(
+    profile_path: &ProfilePathId,
+) -> crate::Result<Vec<InnerProjectPathUnix>> {
    // First, get a dummy mrpack json for the files within
-    let profile: Profile =
-        get(&profile_path, None).await?.ok_or_else(|| {
-            crate::ErrorKind::OtherError(format!(
-                "Tried to export a nonexistent or unloaded profile at path {}!",
-                profile_path
-            ))
-        })?;
-    // dummy mrpack to get pack list
-    let mrpack = create_mrpack_json(&profile, "0".to_string()).await?;
-    let mrpack_files = get_modrinth_pack_list(&mrpack);
+    let profile: Profile = get(profile_path, None).await?.ok_or_else(|| {
+        crate::ErrorKind::OtherError(format!(
+            "Tried to export a nonexistent or unloaded profile at path {}!",
+            profile_path
+        ))
+    })?;

-    let mut path_list: Vec<PathBuf> = Vec::new();
+    let mut path_list: Vec<InnerProjectPathUnix> = Vec::new();

    let profile_base_dir = profile.get_profile_full_path().await?;
    let mut read_dir = io::read_dir(&profile_base_dir).await?;
@@ -715,16 +721,16 @@ pub async fn get_potential_override_folders(
                .map_err(|e| IOError::with_path(e, &profile_base_dir))?
            {
                let path: PathBuf = entry.path();
-                let name = path.strip_prefix(&profile_base_dir)?.to_path_buf();
-                if !mrpack_files.contains(&name.to_string_lossy().to_string()) {
-                    path_list.push(name);
+                if let Ok(project_path) =
+                    ProjectPathId::from_fs_path(&path).await
+                {
+                    path_list.push(project_path.get_inner_path_unix());
                }
            }
        } else {
            // One layer of files/folders if its a file
-            let name = path.strip_prefix(&profile_base_dir)?.to_path_buf();
-            if !mrpack_files.contains(&name.to_string_lossy().to_string()) {
-                path_list.push(name);
+            if let Ok(project_path) = ProjectPathId::from_fs_path(&path).await {
+                path_list.push(project_path.get_inner_path_unix());
            }
        }
    }
@@ -740,20 +746,16 @@ pub async fn run(
    let state = State::get().await?;

    // Get default account and refresh credentials (preferred way to log in)
-    let default_account = state.settings.read().await.default_user;
-    let credentials = if let Some(default_account) = default_account {
-        refresh(default_account).await?
-    } else {
-        // If no default account, try to use a logged in account
-        let users = auth::users().await?;
-        let last_account = users.first();
-        if let Some(last_account) = last_account {
-            refresh(last_account.id).await?
-        } else {
-            return Err(crate::ErrorKind::NoCredentialsError.as_error());
-        }
+    let default_account = {
+        let mut write = state.users.write().await;
+
+        write
+            .get_default_credential()
+            .await?
+            .ok_or_else(|| crate::ErrorKind::NoCredentialsError.as_error())?
    };
-    run_credentials(path, &credentials).await
+
+    run_credentials(path, &default_account).await
 }

 /// Run Minecraft using a profile, and credentials for authentication
@@ -762,7 +764,7 @@ pub async fn run(
 #[theseus_macros::debug_pin]
 pub async fn run_credentials(
    path: &ProfilePathId,
-    credentials: &auth::Credentials,
+    credentials: &Credentials,
 ) -> crate::Result<Arc<RwLock<MinecraftChild>>> {
    let state = State::get().await?;
    let settings = state.settings.read().await;
@@ -820,23 +822,12 @@ pub async fn run_credentials(
        .unwrap_or(&settings.custom_env_args);

    // Post post exit hooks
-    let post_exit_hook =
-        &profile.hooks.as_ref().unwrap_or(&settings.hooks).post_exit;
-
-    let post_exit_hook = if let Some(hook) = post_exit_hook {
-        let mut cmd = hook.split(' ');
-        if let Some(command) = cmd.next() {
-            let mut command = Command::new(command);
-            command
-                .args(&cmd.collect::<Vec<&str>>())
-                .current_dir(path.get_full_path().await?);
-            Some(command)
-        } else {
-            None
-        }
-    } else {
-        None
-    };
+    let post_exit_hook = profile
+        .hooks
+        .as_ref()
+        .unwrap_or(&settings.hooks)
+        .post_exit
+        .clone();

    // Any options.txt settings that we want set, add here
    let mut mc_set_options: Vec<(String, String)> = vec![];
@@ -922,25 +913,13 @@ pub async fn try_update_playtime(path: &ProfilePathId) -> crate::Result<()> {
    res
 }

-fn get_modrinth_pack_list(packfile: &PackFormat) -> Vec<String> {
-    packfile
-        .files
-        .iter()
-        .map(|f| {
-            let path = PathBuf::from(f.path.clone());
-            let name = path.to_string_lossy();
-            let name = name.replace('\\', "/");
-            name.trim_start_matches('/').to_string()
-        })
-        .collect::<Vec<String>>()
-}
-
 /// Creates a json configuration for a .mrpack zipped file
 // Version ID of uploaded version (ie 1.1.5), not the unique identifying ID of the version (nvrqJg44)
 #[tracing::instrument(skip_all)]
 pub async fn create_mrpack_json(
    profile: &Profile,
    version_id: String,
+    description: Option<String>,
 ) -> crate::Result<PackFormat> {
    // Add loader version to dependencies
    let mut dependencies = HashMap::new();
@@ -951,6 +930,9 @@ pub async fn create_mrpack_json(
        (crate::prelude::ModLoader::Forge, Some(v)) => {
            dependencies.insert(PackDependency::Forge, v.id)
        }
+        (crate::prelude::ModLoader::NeoForge, Some(v)) => {
+            dependencies.insert(PackDependency::NeoForge, v.id)
+        }
        (crate::prelude::ModLoader::Fabric, Some(v)) => {
            dependencies.insert(PackDependency::FabricLoader, v.id)
        }
@@ -981,18 +963,21 @@ pub async fn create_mrpack_json(
        .projects
        .iter()
        .filter_map(|(mod_path, project)| {
-            let path: String = mod_path.0.clone().to_string_lossy().to_string();
+            let path = mod_path.get_inner_path_unix();

            // Only Modrinth projects have a modrinth metadata field for the modrinth.json
            Some(Ok(match project.metadata {
                crate::prelude::ProjectMetadata::Modrinth {
-                    ref project,
                    ref version,
                    ..
                } => {
                    let mut env = HashMap::new();
-                    env.insert(EnvType::Client, project.client_side.clone());
-                    env.insert(EnvType::Server, project.server_side.clone());
+                    // TODO: envtype should be a controllable option (in general or at least .mrpack exporting)
+                    // For now, assume required.
+                    // env.insert(EnvType::Client, project.client_side.clone());
+                    // env.insert(EnvType::Server, project.server_side.clone());
+                    env.insert(EnvType::Client, SideType::Required);
+                    env.insert(EnvType::Server, SideType::Required);

                    let primary_file = if let Some(primary_file) =
                        version.files.first()
@@ -1037,7 +1022,7 @@ pub async fn create_mrpack_json(
        format_version: 1,
        version_id,
        name: profile.metadata.name.clone(),
-        summary: None,
+        summary: description,
        files,
        dependencies,
    })
@@ -1049,14 +1034,18 @@ fn sanitize_loader_version_string(s: &str, loader: PackDependency) -> &str {
        // If two or more, take the second
        // If one, take the first
        // If none, take the whole thing
-        PackDependency::Forge => {
-            let mut split: std::str::Split<'_, char> = s.split('-');
-            match split.next() {
-                Some(first) => match split.next() {
-                    Some(second) => second,
-                    None => first,
-                },
-                None => s,
+        PackDependency::Forge | PackDependency::NeoForge => {
+            if s.starts_with("1.") {
+                let mut split: std::str::Split<'_, char> = s.split('-');
+                match split.next() {
+                    Some(first) => match split.next() {
+                        Some(second) => second,
+                        None => first,
+                    },
+                    None => s,
+                }
+            } else {
+                s
            }
        }
        // For quilt, etc we take the whole thing, as it functions like: 0.20.0-beta.11 (and should not be split here)
@@ -1068,7 +1057,7 @@ fn sanitize_loader_version_string(s: &str, loader: PackDependency) -> &str {

 // Given a folder path, populate a Vec of all the files in the folder, recursively
 #[async_recursion::async_recursion]
-pub async fn build_folder(
+pub async fn add_all_recursive_folder_paths(
    path: &Path,
    path_list: &mut Vec<PathBuf>,
 ) -> crate::Result<()> {
@@ -1080,7 +1069,7 @@ pub async fn build_folder(
    {
        let path = entry.path();
        if path.is_dir() {
-            build_folder(&path, path_list).await?;
+            add_all_recursive_folder_paths(&path, path_list).await?;
        } else {
            path_list.push(path);
        }
@@ -1089,5 +1078,5 @@ pub async fn build_folder(
 }

 pub fn sanitize_profile_name(input: &str) -> String {
-    input.replace(['/', '\\', ':'], "_")
+    input.replace(['/', '\\', '?', '*', ':', '\'', '\"', '|', '<', '>'], "_")
 }
--- a/theseus/src/api/profile/update.rs
+++ b/theseus/src/api/profile/update.rs
@@ -1,21 +1,22 @@
 use crate::{
    event::{
-        emit::{emit_profile, loading_try_for_each_concurrent},
+        emit::{emit_profile, init_loading, loading_try_for_each_concurrent},
        ProfilePayloadType,
    },
    pack::{self, install_from::generate_pack_from_version_id},
    prelude::{ProfilePathId, ProjectPathId},
    profile::get,
-    state::Project,
-    State,
+    state::{ProfileInstallStage, Project},
+    LoadingBarType, State,
 };
 use futures::try_join;

-/// Updates a managed modrinth pack to the cached latest version found in 'modrinth_update_version'
+/// Updates a managed modrinth pack to the version specified by new_version_id
 #[tracing::instrument]
 #[theseus_macros::debug_pin]
-pub async fn update_managed_modrinth(
+pub async fn update_managed_modrinth_version(
    profile_path: &ProfilePathId,
+    new_version_id: &String,
 ) -> crate::Result<()> {
    let profile = get(profile_path, None).await?.ok_or_else(|| {
        crate::ErrorKind::UnmanagedProfileError(profile_path.to_string())
@@ -39,19 +40,14 @@ pub async fn update_managed_modrinth(
    let version_id =
        linked_data.version_id.as_ref().ok_or_else(unmanaged_err)?;

-    // extract modrinth_update_version, returning Ok(()) if it is none
-    let modrinth_update_version = match profile.modrinth_update_version {
-        Some(ref x) if x != version_id => x,
-        _ => return Ok(()), // No update version, or no update needed, return Ok(())
-    };
-
    // Replace the pack with the new version
    replace_managed_modrinth(
        profile_path,
        &profile,
        project_id,
        version_id,
-        Some(modrinth_update_version),
+        Some(new_version_id),
+        true, // switching versions should ignore the lock
    )
    .await?;

@@ -128,6 +124,7 @@ pub async fn repair_managed_modrinth(
        project_id,
        version_id,
        None,
+        false, // do not ignore lock, as repairing can reset the lock
    )
    .await?;

@@ -153,32 +150,61 @@ async fn replace_managed_modrinth(
    project_id: &String,
    version_id: &String,
    new_version_id: Option<&String>,
+    ignore_lock: bool,
 ) -> crate::Result<()> {
+    crate::profile::edit(profile_path, |profile| {
+        profile.install_stage = ProfileInstallStage::Installing;
+        async { Ok(()) }
+    })
+    .await?;
+
    // Fetch .mrpacks for both old and new versions
    // TODO: this will need to be updated if we revert the hacky pack method we needed for compiler speed
-    let old_pack_creator = generate_pack_from_version_id(
-        project_id.clone(),
-        version_id.clone(),
-        profile.metadata.name.clone(),
-        None,
-        profile_path.clone(),
-    );

-    // download in parallel, then join. If new_version_id is None, we don't need to download the new pack, so we clone the old one
    let (old_pack_creator, new_pack_creator) =
        if let Some(new_version_id) = new_version_id {
+            let shared_loading_bar = init_loading(
+                LoadingBarType::PackFileDownload {
+                    profile_path: profile_path.get_full_path().await?,
+                    pack_name: profile.metadata.name.clone(),
+                    icon: None,
+                    pack_version: version_id.clone(),
+                },
+                200.0, // These two downloads will share the same loading bar
+                "Downloading pack file",
+            )
+            .await?;
+
+            // download in parallel, then join.
            try_join!(
-                old_pack_creator,
+                generate_pack_from_version_id(
+                    project_id.clone(),
+                    version_id.clone(),
+                    profile.metadata.name.clone(),
+                    None,
+                    profile_path.clone(),
+                    Some(shared_loading_bar.clone())
+                ),
                generate_pack_from_version_id(
                    project_id.clone(),
                    new_version_id.clone(),
                    profile.metadata.name.clone(),
                    None,
-                    profile_path.clone()
+                    profile_path.clone(),
+                    Some(shared_loading_bar)
                )
            )?
        } else {
-            let mut old_pack_creator = old_pack_creator.await?;
+            // If new_version_id is None, we don't need to download the new pack, so we clone the old one
+            let mut old_pack_creator = generate_pack_from_version_id(
+                project_id.clone(),
+                version_id.clone(),
+                profile.metadata.name.clone(),
+                None,
+                profile_path.clone(),
+                None,
+            )
+            .await?;
            old_pack_creator.description.existing_loading_bar = None;
            (old_pack_creator.clone(), old_pack_creator)
        };
@@ -197,7 +223,11 @@ async fn replace_managed_modrinth(
    // - install all overrides
    // - edits the profile to update the new data
    // - (functionals almost identically to rteinstalling the pack 'in-place')
-    pack::install_mrpack::install_zipped_mrpack_files(new_pack_creator).await?;
+    pack::install_mrpack::install_zipped_mrpack_files(
+        new_pack_creator,
+        ignore_lock,
+    )
+    .await?;

    Ok(())
 }
--- a/theseus/src/api/settings.rs
+++ b/theseus/src/api/settings.rs
@@ -1,6 +1,7 @@
 //! Theseus profile management interface

-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
+use tokio::fs;

 use io::IOError;
 use tokio::sync::RwLock;
@@ -9,7 +10,7 @@ use crate::{
    event::emit::{emit_loading, init_loading},
    prelude::DirectoryInfo,
    state::{self, Profiles},
-    util::io,
+    util::{fetch, io},
 };
 pub use crate::{
    state::{
@@ -49,10 +50,19 @@ pub async fn set(settings: Settings) -> crate::Result<()> {
    }
    .await;

+    let updated_discord_rpc = {
+        let read = state.settings.read().await;
+        settings.disable_discord_rpc != read.disable_discord_rpc
+    };
+
    {
        *state.settings.write().await = settings;
    }

+    if updated_discord_rpc {
+        state.discord_rpc.clear_to_default(true).await?;
+    }
+
    if reset_io {
        state.reset_io_semaphore().await;
    }
@@ -67,6 +77,7 @@ pub async fn set(settings: Settings) -> crate::Result<()> {
 /// Sets the new config dir, the location of all Theseus data except for the settings.json and caches
 /// Takes control of the entire state and blocks until completion
 pub async fn set_config_dir(new_config_dir: PathBuf) -> crate::Result<()> {
+    tracing::trace!("Changing config dir to: {}", new_config_dir.display());
    if !new_config_dir.is_dir() {
        return Err(crate::ErrorKind::FSError(format!(
            "New config dir is not a folder: {}",
@@ -75,6 +86,14 @@ pub async fn set_config_dir(new_config_dir: PathBuf) -> crate::Result<()> {
        .as_error());
    }

+    if !is_dir_writeable(new_config_dir.clone()).await? {
+        return Err(crate::ErrorKind::FSError(format!(
+            "New config dir is not writeable: {}",
+            new_config_dir.display()
+        ))
+        .as_error());
+    }
+
    let loading_bar = init_loading(
        crate::LoadingBarType::ConfigChange {
            new_path: new_config_dir.clone(),
@@ -90,6 +109,54 @@ pub async fn set_config_dir(new_config_dir: PathBuf) -> crate::Result<()> {
    let old_config_dir =
        state_write.directories.config_dir.read().await.clone();

+    // Reset file watcher
+    tracing::trace!("Reset file watcher");
+    let file_watcher = state::init_watcher().await?;
+    state_write.file_watcher = RwLock::new(file_watcher);
+
+    // Getting files to be moved
+    let mut config_entries = io::read_dir(&old_config_dir).await?;
+    let across_drives = is_different_drive(&old_config_dir, &new_config_dir);
+    let mut entries = vec![];
+    let mut deletable_entries = vec![];
+    while let Some(entry) = config_entries
+        .next_entry()
+        .await
+        .map_err(|e| IOError::with_path(e, &old_config_dir))?
+    {
+        let entry_path = entry.path();
+        if let Some(file_name) = entry_path.file_name() {
+            // We are only moving the profiles and metadata folders
+            if file_name == state::PROFILES_FOLDER_NAME
+                || file_name == state::METADATA_FOLDER_NAME
+            {
+                if across_drives {
+                    entries.extend(
+                        crate::pack::import::get_all_subfiles(&entry_path)
+                            .await?,
+                    );
+                    deletable_entries.push(entry_path.clone());
+                } else {
+                    entries.push(entry_path.clone());
+                }
+            }
+        }
+    }
+
+    tracing::trace!("Moving files");
+    let semaphore = &state_write.io_semaphore;
+    let num_entries = entries.len() as f64;
+    for entry_path in entries {
+        let relative_path = entry_path.strip_prefix(&old_config_dir)?;
+        let new_path = new_config_dir.join(relative_path);
+        if across_drives {
+            fetch::copy(&entry_path, &new_path, semaphore).await?;
+        } else {
+            io::rename(entry_path.clone(), new_path.clone()).await?;
+        }
+        emit_loading(&loading_bar, 80.0 * (1.0 / num_entries), None).await?;
+    }
+
    tracing::trace!("Setting configuration setting");
    // Set load config dir setting
    let settings = {
@@ -122,41 +189,20 @@ pub async fn set_config_dir(new_config_dir: PathBuf) -> crate::Result<()> {
    tracing::trace!("Reinitializing directory");
    // Set new state information
    state_write.directories = DirectoryInfo::init(&settings)?;
-    let total_entries = std::fs::read_dir(&old_config_dir)
-        .map_err(|e| IOError::with_path(e, &old_config_dir))?
-        .count() as f64;

-    // Move all files over from state_write.directories.config_dir to new_config_dir
-    tracing::trace!("Renaming folder structure");
-    let mut i = 0.0;
-    let mut entries = io::read_dir(&old_config_dir).await?;
-    while let Some(entry) = entries
-        .next_entry()
-        .await
-        .map_err(|e| IOError::with_path(e, &old_config_dir))?
-    {
-        let entry_path = entry.path();
-        if let Some(file_name) = entry_path.file_name() {
-            // Ignore settings.json
-            if file_name == state::SETTINGS_FILE_NAME {
-                continue;
-            }
-            // Ignore caches folder
-            if file_name == state::CACHES_FOLDER_NAME {
-                continue;
-            }
-            // Ignore modrinth_logs folder
-            if file_name == state::LAUNCHER_LOGS_FOLDER_NAME {
-                continue;
-            }
-
-            let new_path = new_config_dir.join(file_name);
-            io::rename(entry_path, new_path).await?;
-
-            i += 1.0;
-            emit_loading(&loading_bar, 90.0 * (i / total_entries), None)
-                .await?;
-        }
+    // Delete entries that were from a different drive
+    let deletable_entries_len = deletable_entries.len();
+    if deletable_entries_len > 0 {
+        tracing::trace!("Deleting old files");
+    }
+    for entry in deletable_entries {
+        io::remove_dir_all(entry).await?;
+        emit_loading(
+            &loading_bar,
+            10.0 * (1.0 / deletable_entries_len as f64),
+            None,
+        )
+        .await?;
    }

    // Reset file watcher
@@ -171,11 +217,30 @@ pub async fn set_config_dir(new_config_dir: PathBuf) -> crate::Result<()> {

    emit_loading(&loading_bar, 10.0, None).await?;

-    // TODO: need to be able to safely error out of this function, reverting the changes
    tracing::info!(
        "Successfully switched config folder to: {}",
        new_config_dir.display()
    );
-
    Ok(())
 }
+
+// Function to check if two paths are on different drives/roots
+fn is_different_drive(path1: &Path, path2: &Path) -> bool {
+    let root1 = path1.components().next();
+    let root2 = path2.components().next();
+    root1 != root2
+}
+
+pub async fn is_dir_writeable(new_config_dir: PathBuf) -> crate::Result<bool> {
+    let temp_path = new_config_dir.join(".tmp");
+    match fs::write(temp_path.clone(), "test").await {
+        Ok(_) => {
+            fs::remove_file(temp_path).await?;
+            Ok(true)
+        }
+        Err(e) => {
+            tracing::error!("Error writing to new config dir: {}", e);
+            Ok(false)
+        }
+    }
+}
--- a/theseus/src/error.rs
+++ b/theseus/src/error.rs
@@ -25,15 +25,17 @@ pub enum ErrorKind {
    #[error("Metadata error: {0}")]
    MetadataError(#[from] daedalus::Error),

-    #[error("Minecraft authentication Hydra error: {0}")]
-    HydraError(String),
-
-    #[error("Minecraft authentication task error: {0}")]
-    AuthTaskError(#[from] crate::state::AuthTaskError),
+    #[error("Minecraft authentication error: {0}")]
+    MinecraftAuthenticationError(
+        #[from] crate::state::MinecraftAuthenticationError,
+    ),

    #[error("I/O error: {0}")]
    IOError(#[from] util::io::IOError),

+    #[error("I/O (std) error: {0}")]
+    StdIOError(#[from] std::io::Error),
+
    #[error("Error launching Minecraft: {0}")]
    LauncherError(String),

--- a/theseus/src/event/mod.rs
+++ b/theseus/src/event/mod.rs
@@ -31,7 +31,7 @@ impl EventState {
                }))
            })
            .await
-            .map(Arc::clone)
+            .cloned()
    }

    #[cfg(not(feature = "tauri"))]
@@ -43,7 +43,7 @@ impl EventState {
                }))
            })
            .await
-            .map(Arc::clone)
+            .cloned()
    }

    #[cfg(feature = "tauri")]
@@ -140,11 +140,15 @@ impl Drop for LoadingBarId {
                #[cfg(not(any(feature = "tauri", feature = "cli")))]
                bars.remove(&loader_uuid);
            }
-            let _ = SafeProcesses::complete(
-                crate::state::ProcessType::LoadingBar,
-                loader_uuid,
-            )
-            .await;
+            // complete calls state, and since a  LoadingBarId is created in state initialization, we only complete if its already initializaed
+            // to avoid an infinite loop.
+            if crate::State::initialized() {
+                let _ = SafeProcesses::complete(
+                    crate::state::ProcessType::LoadingBar,
+                    loader_uuid,
+                )
+                .await;
+            }
        });
    }
 }
--- a/theseus/src/launcher/args.rs
+++ b/theseus/src/launcher/args.rs
@@ -1,6 +1,6 @@
 //! Minecraft CLI argument logic
-// TODO: Rafactor this section
-use super::{auth::Credentials, parse_rule};
+use crate::launcher::parse_rules;
+use crate::state::Credentials;
 use crate::{
    state::{MemorySettings, WindowSize},
    util::{io::IOError, platform::classpath_separator},
@@ -11,6 +11,7 @@ use daedalus::{
    modded::SidedDataEntry,
 };
 use dunce::canonicalize;
+use std::collections::HashSet;
 use std::io::{BufRead, BufReader};
 use std::{collections::HashMap, path::Path};
 use uuid::Uuid;
@@ -23,12 +24,13 @@ pub fn get_class_paths(
    libraries: &[Library],
    client_path: &Path,
    java_arch: &str,
+    minecraft_updated: bool,
 ) -> crate::Result<String> {
    let mut cps = libraries
        .iter()
        .filter_map(|library| {
            if let Some(rules) = &library.rules {
-                if !rules.iter().any(|x| parse_rule(x, java_arch)) {
+                if !parse_rules(rules, java_arch, minecraft_updated) {
                    return None;
                }
            }
@@ -39,9 +41,9 @@ pub fn get_class_paths(

            Some(get_lib_path(libraries_path, &library.name, false))
        })
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<Result<HashSet<_>, _>>()?;

-    cps.push(
+    cps.insert(
        canonicalize(client_path)
            .map_err(|_| {
                crate::ErrorKind::LauncherError(format!(
@@ -54,7 +56,10 @@ pub fn get_class_paths(
            .to_string(),
    );

-    Ok(cps.join(classpath_separator(java_arch)))
+    Ok(cps
+        .into_iter()
+        .collect::<Vec<_>>()
+        .join(classpath_separator(java_arch)))
 }

 pub fn get_class_paths_jar<T: AsRef<str>>(
@@ -143,7 +148,6 @@ pub fn get_jvm_arguments(
            parsed_arguments.push(arg);
        }
    }
-    parsed_arguments.push("-Dorg.lwjgl.util.Debug=true".to_string());

    Ok(parsed_arguments)
 }
@@ -268,8 +272,8 @@ fn parse_minecraft_argument(
        .replace("${auth_player_name}", username)
        // TODO: add auth xuid eventually
        .replace("${auth_xuid}", "0")
-        .replace("${auth_uuid}", &uuid.hyphenated().to_string())
-        .replace("${uuid}", &uuid.hyphenated().to_string())
+        .replace("${auth_uuid}", &uuid.simple().to_string())
+        .replace("${uuid}", &uuid.simple().to_string())
        .replace("${clientid}", "c4502edb-87c6-40cb-b595-64a280cf8906")
        .replace("${user_properties}", "{}")
        .replace("${user_type}", "msa")
@@ -335,7 +339,7 @@ where
                }
            }
            Argument::Ruled { rules, value } => {
-                if rules.iter().any(|x| parse_rule(x, java_arch)) {
+                if parse_rules(rules, java_arch, true) {
                    match value {
                        ArgumentValue::Single(arg) => {
                            parsed_arguments.push(parse_function(
--- a/theseus/src/launcher/auth.rs
+++ b/theseus/src/launcher/auth.rs
@@ -1,177 +0,0 @@
-//! Authentication flow based on Hydra
-use crate::config::MODRINTH_API_URL;
-use crate::state::CredentialsStore;
-use crate::util::fetch::{fetch_advanced, fetch_json, FetchSemaphore};
-use async_tungstenite as ws;
-use chrono::{prelude::*, Duration};
-use futures::prelude::*;
-use lazy_static::lazy_static;
-use reqwest::Method;
-use serde::{Deserialize, Serialize};
-use url::Url;
-
-lazy_static! {
-    static ref HYDRA_URL: Url =
-        Url::parse(&format!("{MODRINTH_API_URL}auth/minecraft/"))
-            .expect("Hydra URL parse failed");
-}
-
-// Socket messages
-#[derive(Deserialize)]
-struct ErrorJSON {
-    error: String,
-}
-
-impl ErrorJSON {
-    pub fn unwrap<'a, T: Deserialize<'a>>(data: &'a [u8]) -> crate::Result<T> {
-        if let Ok(err) = serde_json::from_slice::<Self>(data) {
-            Err(crate::ErrorKind::HydraError(err.error).as_error())
-        } else {
-            Ok(serde_json::from_slice::<T>(data)?)
-        }
-    }
-}
-
-#[derive(Deserialize)]
-struct LoginCodeJSON {
-    login_code: String,
-}
-
-#[derive(Deserialize)]
-struct TokenJSON {
-    token: String,
-    refresh_token: String,
-    expires_after: u32,
-    flow: Option<String>,
-}
-
-#[derive(Deserialize)]
-struct ProfileInfoJSON {
-    id: uuid::Uuid,
-    name: String,
-}
-
-// Login information
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct Credentials {
-    pub id: uuid::Uuid,
-    pub username: String,
-    pub access_token: String,
-    pub refresh_token: String,
-    pub expires: DateTime<Utc>,
-    _ctor_scope: std::marker::PhantomData<()>,
-}
-
-// Implementation
-pub struct HydraAuthFlow<S: AsyncRead + AsyncWrite + Unpin> {
-    socket: ws::WebSocketStream<S>,
-}
-
-impl HydraAuthFlow<ws::tokio::ConnectStream> {
-    pub async fn new() -> crate::Result<Self> {
-        let (socket, _) = ws::tokio::connect_async(
-            "wss://api.modrinth.com/v2/auth/minecraft/ws",
-        )
-        .await?;
-        Ok(Self { socket })
-    }
-
-    pub async fn prepare_login_url(&mut self) -> crate::Result<Url> {
-        let code_resp = self
-            .socket
-            .try_next()
-            .await?
-            .ok_or(
-                crate::ErrorKind::WSClosedError(String::from(
-                    "login socket ID",
-                ))
-                .as_error(),
-            )?
-            .into_data();
-        let code = ErrorJSON::unwrap::<LoginCodeJSON>(&code_resp)?;
-        Ok(wrap_ref_builder!(
-            it = HYDRA_URL.join("init")? =>
-            { it.query_pairs_mut().append_pair("id", &code.login_code); }
-        ))
-    }
-
-    pub async fn extract_credentials(
-        &mut self,
-        semaphore: &FetchSemaphore,
-    ) -> crate::Result<(Credentials, Option<String>)> {
-        // Minecraft bearer token
-        let token_resp = self
-            .socket
-            .try_next()
-            .await?
-            .ok_or(
-                crate::ErrorKind::WSClosedError(String::from(
-                    "login socket ID",
-                ))
-                .as_error(),
-            )?
-            .into_data();
-        let token = ErrorJSON::unwrap::<TokenJSON>(&token_resp)?;
-        let expires =
-            Utc::now() + Duration::seconds(token.expires_after.into());
-
-        // Get account credentials
-        let info = fetch_info(&token.token, semaphore).await?;
-
-        // Return structure from response
-        Ok((
-            Credentials {
-                username: info.name,
-                id: info.id,
-                refresh_token: token.refresh_token,
-                access_token: token.token,
-                expires,
-                _ctor_scope: std::marker::PhantomData,
-            },
-            token.flow,
-        ))
-    }
-}
-
-pub async fn refresh_credentials(
-    credentials: &mut Credentials,
-    semaphore: &FetchSemaphore,
-) -> crate::Result<()> {
-    let resp = fetch_json::<TokenJSON>(
-        Method::POST,
-        &format!("{MODRINTH_API_URL}auth/minecraft/refresh"),
-        None,
-        Some(serde_json::json!({ "refresh_token": credentials.refresh_token })),
-        semaphore,
-        &CredentialsStore(None),
-    )
-    .await?;
-
-    credentials.access_token = resp.token;
-    credentials.refresh_token = resp.refresh_token;
-    credentials.expires =
-        Utc::now() + Duration::seconds(resp.expires_after.into());
-
-    Ok(())
-}
-
-// Helpers
-async fn fetch_info(
-    token: &str,
-    semaphore: &FetchSemaphore,
-) -> crate::Result<ProfileInfoJSON> {
-    let result = fetch_advanced(
-        Method::GET,
-        "https://api.minecraftservices.com/minecraft/profile",
-        None,
-        None,
-        Some(("Authorization", &format!("Bearer {token}"))),
-        None,
-        semaphore,
-        &CredentialsStore(None),
-    )
-    .await?;
-    let value = serde_json::from_slice(&result)?;
-
-    Ok(value)
-}
--- a/theseus/src/launcher/download.rs
+++ b/theseus/src/launcher/download.rs
@@ -1,5 +1,6 @@
 //! Downloader for Minecraft data

+use crate::launcher::parse_rules;
 use crate::state::CredentialsStore;
 use crate::{
    event::{
@@ -26,11 +27,13 @@ pub async fn download_minecraft(
    version: &GameVersionInfo,
    loading_bar: &LoadingBarId,
    java_arch: &str,
+    force: bool,
+    minecraft_updated: bool,
 ) -> crate::Result<()> {
    tracing::info!("Downloading Minecraft version {}", version.id);
    // 5
    let assets_index =
-        download_assets_index(st, version, Some(loading_bar)).await?;
+        download_assets_index(st, version, Some(loading_bar), force).await?;

    let amount = if version
        .processors
@@ -45,9 +48,9 @@ pub async fn download_minecraft(

    tokio::try_join! {
        // Total loading sums to 90/60
-        download_client(st, version, Some(loading_bar)), // 10
-        download_assets(st, version.assets == "legacy", &assets_index, Some(loading_bar), amount), // 40
-        download_libraries(st, version.libraries.as_slice(), &version.id, Some(loading_bar), amount, java_arch) // 40
+        download_client(st, version, Some(loading_bar), force), // 10
+        download_assets(st, version.assets == "legacy", &assets_index, Some(loading_bar), amount, force), // 40
+        download_libraries(st, version.libraries.as_slice(), &version.id, Some(loading_bar), amount, java_arch, force, minecraft_updated) // 40
    }?;

    tracing::info!("Done downloading Minecraft!");
@@ -105,6 +108,7 @@ pub async fn download_client(
    st: &State,
    version_info: &GameVersionInfo,
    loading_bar: Option<&LoadingBarId>,
+    force: bool,
 ) -> crate::Result<()> {
    let version = &version_info.id;
    tracing::debug!("Locating client for version {version}");
@@ -123,7 +127,7 @@ pub async fn download_client(
        .await
        .join(format!("{version}.jar"));

-    if !path.exists() {
+    if !path.exists() || force {
        let bytes = fetch(
            &client_download.url,
            Some(&client_download.sha1),
@@ -148,6 +152,7 @@ pub async fn download_assets_index(
    st: &State,
    version: &GameVersionInfo,
    loading_bar: Option<&LoadingBarId>,
+    force: bool,
 ) -> crate::Result<AssetsIndex> {
    tracing::debug!("Loading assets index");
    let path = st
@@ -156,7 +161,7 @@ pub async fn download_assets_index(
        .await
        .join(format!("{}.json", &version.asset_index.id));

-    let res = if path.exists() {
+    let res = if path.exists() && !force {
        io::read(path)
            .err_into::<crate::Error>()
            .await
@@ -183,6 +188,7 @@ pub async fn download_assets(
    index: &AssetsIndex,
    loading_bar: Option<&LoadingBarId>,
    loading_amount: f64,
+    force: bool,
 ) -> crate::Result<()> {
    tracing::debug!("Loading assets");
    let num_futs = index.objects.len();
@@ -206,7 +212,7 @@ pub async fn download_assets(
                let fetch_cell = OnceCell::<bytes::Bytes>::new();
                tokio::try_join! {
                    async {
-                        if !resource_path.exists() {
+                        if !resource_path.exists() || force {
                            let resource = fetch_cell
                                .get_or_try_init(|| fetch(&url, Some(hash), &st.fetch_semaphore, &CredentialsStore(None)))
                                .await?;
@@ -216,13 +222,14 @@ pub async fn download_assets(
                        Ok::<_, crate::Error>(())
                    },
                    async {
-                        if with_legacy {
+                        let resource_path = st.directories.legacy_assets_dir().await.join(
+                            name.replace('/', &String::from(std::path::MAIN_SEPARATOR))
+                        );
+
+                        if with_legacy && !resource_path.exists() || force {
                            let resource = fetch_cell
                                .get_or_try_init(|| fetch(&url, Some(hash), &st.fetch_semaphore, &CredentialsStore(None)))
                                .await?;
-                            let resource_path = st.directories.legacy_assets_dir().await.join(
-                                name.replace('/', &String::from(std::path::MAIN_SEPARATOR))
-                            );
                            write(&resource_path, resource, &st.io_semaphore).await?;
                            tracing::trace!("Fetched legacy asset with hash {hash}");
                        }
@@ -239,6 +246,7 @@ pub async fn download_assets(

 #[tracing::instrument(skip(st, libraries))]
 #[theseus_macros::debug_pin]
+#[allow(clippy::too_many_arguments)]
 pub async fn download_libraries(
    st: &State,
    libraries: &[Library],
@@ -246,6 +254,8 @@ pub async fn download_libraries(
    loading_bar: Option<&LoadingBarId>,
    loading_amount: f64,
    java_arch: &str,
+    force: bool,
+    minecraft_updated: bool,
 ) -> crate::Result<()> {
    tracing::debug!("Loading libraries");

@@ -258,7 +268,7 @@ pub async fn download_libraries(
        stream::iter(libraries.iter())
            .map(Ok::<&Library, crate::Error>), None, loading_bar,loading_amount,num_files, None,|library| async move {
                if let Some(rules) = &library.rules {
-                    if !rules.iter().any(|x| super::parse_rule(x, java_arch)) {
+                    if !parse_rules(rules, java_arch, minecraft_updated) {
                        tracing::trace!("Skipped library {}", &library.name);
                        return Ok(());
                    }
@@ -270,7 +280,7 @@ pub async fn download_libraries(
                        let path = st.directories.libraries_dir().await.join(&artifact_path);

                        match library.downloads {
-                            _ if path.exists() => Ok(()),
+                            _ if path.exists() && !force => Ok(()),
                            Some(d::minecraft::LibraryDownloads {
                                artifact: Some(ref artifact),
                                ..
--- a/theseus/src/launcher/mod.rs
+++ b/theseus/src/launcher/mod.rs
@@ -1,10 +1,9 @@
 //! Logic for launching Minecraft
 use crate::event::emit::{emit_loading, init_or_edit_loading};
 use crate::event::{LoadingBarId, LoadingBarType};
-use crate::jre::{self, JAVA_17_KEY, JAVA_18PLUS_KEY, JAVA_8_KEY};
 use crate::launcher::io::IOError;
 use crate::prelude::JavaVersion;
-use crate::state::ProfileInstallStage;
+use crate::state::{Credentials, ProfileInstallStage};
 use crate::util::io;
 use crate::{
    process,
@@ -13,26 +12,59 @@ use crate::{
 };
 use chrono::Utc;
 use daedalus as d;
-use daedalus::minecraft::VersionInfo;
+use daedalus::minecraft::{RuleAction, VersionInfo};
 use st::Profile;
 use std::collections::HashMap;
-use std::{process::Stdio, sync::Arc};
+use std::sync::Arc;
 use tokio::process::Command;
 use uuid::Uuid;

 mod args;

-pub mod auth;
 pub mod download;

+// All nones -> disallowed
+// 1+ true -> allowed
+// 1+ false -> disallowed
 #[tracing::instrument]
-pub fn parse_rule(rule: &d::minecraft::Rule, java_version: &str) -> bool {
+pub fn parse_rules(
+    rules: &[d::minecraft::Rule],
+    java_version: &str,
+    minecraft_updated: bool,
+) -> bool {
+    let mut x = rules
+        .iter()
+        .map(|x| parse_rule(x, java_version, minecraft_updated))
+        .collect::<Vec<Option<bool>>>();
+
+    if rules
+        .iter()
+        .all(|x| matches!(x.action, RuleAction::Disallow))
+    {
+        x.push(Some(true))
+    }
+
+    !(x.iter().any(|x| x == &Some(false)) || x.iter().all(|x| x.is_none()))
+}
+
+// if anything is disallowed, it should NOT be included
+// if anything is not disallowed, it shouldn't factor in final result
+// if anything is not allowed, it shouldn't factor in final result
+// if anything is allowed, it should be included
+#[tracing::instrument]
+pub fn parse_rule(
+    rule: &d::minecraft::Rule,
+    java_version: &str,
+    minecraft_updated: bool,
+) -> Option<bool> {
    use d::minecraft::{Rule, RuleAction};

    let res = match rule {
        Rule {
            os: Some(ref os), ..
-        } => crate::util::platform::os_rule(os, java_version),
+        } => {
+            crate::util::platform::os_rule(os, java_version, minecraft_updated)
+        }
        Rule {
            features: Some(ref features),
            ..
@@ -44,12 +76,24 @@ pub fn parse_rule(rule: &d::minecraft::Rule, java_version: &str) -> bool {
                || !features.is_quick_play_realms.unwrap_or(true)
                || !features.is_quick_play_singleplayer.unwrap_or(true)
        }
-        _ => false,
+        _ => return Some(true),
    };

    match rule.action {
-        RuleAction::Allow => res,
-        RuleAction::Disallow => !res,
+        RuleAction::Allow => {
+            if res {
+                Some(true)
+            } else {
+                None
+            }
+        }
+        RuleAction::Disallow => {
+            if res {
+                Some(false)
+            } else {
+                None
+            }
+        }
    }
 }

@@ -73,24 +117,17 @@ pub async fn get_java_version_from_profile(
    if let Some(java) = profile.java.clone().and_then(|x| x.override_version) {
        Ok(Some(java))
    } else {
-        let optimal_keys = match version_info
+        let key = version_info
            .java_version
            .as_ref()
            .map(|it| it.major_version)
-            .unwrap_or(8)
-        {
-            0..=15 => vec![JAVA_8_KEY, JAVA_17_KEY, JAVA_18PLUS_KEY],
-            16..=17 => vec![JAVA_17_KEY, JAVA_18PLUS_KEY],
-            _ => vec![JAVA_18PLUS_KEY],
-        };
+            .unwrap_or(8);

        let state = State::get().await?;
        let settings = state.settings.read().await;

-        for key in optimal_keys {
-            if let Some(java) = settings.java_globals.get(&key.to_string()) {
-                return Ok(Some(java.clone()));
-            }
+        if let Some(java) = settings.java_globals.get(&format!("JAVA_{key}")) {
+            return Ok(Some(java.clone()));
        }

        Ok(None)
@@ -102,6 +139,7 @@ pub async fn get_java_version_from_profile(
 pub async fn install_minecraft(
    profile: &Profile,
    existing_loading_bar: Option<LoadingBarId>,
+    repairing: bool,
 ) -> crate::Result<()> {
    let sync_projects = existing_loading_bar.is_some();
    let loading_bar = init_or_edit_loading(
@@ -130,18 +168,26 @@ pub async fn install_minecraft(

    let state = State::get().await?;
    let instance_path =
-        &io::canonicalize(&profile.get_profile_full_path().await?)?;
+        &io::canonicalize(profile.get_profile_full_path().await?)?;
    let metadata = state.metadata.read().await;

-    let version = metadata
+    let version_index = metadata
        .minecraft
        .versions
        .iter()
-        .find(|it| it.id == profile.metadata.game_version)
+        .position(|it| it.id == profile.metadata.game_version)
        .ok_or(crate::ErrorKind::LauncherError(format!(
            "Invalid game version: {}",
            profile.metadata.game_version
        )))?;
+    let version = &metadata.minecraft.versions[version_index];
+    let minecraft_updated = version_index
+        <= metadata
+            .minecraft
+            .versions
+            .iter()
+            .position(|x| x.id == "22w16a")
+            .unwrap_or(0);

    let version_jar = profile
        .metadata
@@ -156,35 +202,56 @@ pub async fn install_minecraft(
        &state,
        version,
        profile.metadata.loader_version.as_ref(),
-        None,
+        Some(repairing),
        Some(&loading_bar),
    )
    .await?;

-    let java_version = get_java_version_from_profile(profile, &version_info)
-        .await?
-        .ok_or_else(|| {
-            crate::ErrorKind::OtherError(
-                "Missing correct java installation".to_string(),
-            )
-        })?;
+    // TODO: check if java exists, if not install it add to install step
+
+    let key = version_info
+        .java_version
+        .as_ref()
+        .map(|it| it.major_version)
+        .unwrap_or(8);
+    let (java_version, set_java) = if let Some(java_version) =
+        get_java_version_from_profile(profile, &version_info).await?
+    {
+        (std::path::PathBuf::from(java_version.path), false)
+    } else {
+        let path = crate::api::jre::auto_install_java(key).await?;
+
+        (path, true)
+    };

    // Test jre version
-    let java_version = jre::check_jre(java_version.path.clone().into())
+    let java_version = crate::api::jre::check_jre(java_version.clone())
        .await?
        .ok_or_else(|| {
            crate::ErrorKind::LauncherError(format!(
-                "Java path invalid or non-functional: {}",
-                java_version.path
+                "Java path invalid or non-functional: {:?}",
+                java_version
            ))
        })?;

+    if set_java {
+        {
+            let mut settings = state.settings.write().await;
+            settings
+                .java_globals
+                .insert(format!("JAVA_{key}"), java_version.clone());
+        }
+        State::sync().await?;
+    }
+
    // Download minecraft (5-90)
    download::download_minecraft(
        &state,
        &version_info,
        &loading_bar,
        &java_version.architecture,
+        repairing,
+        minecraft_updated,
    )
    .await?;

@@ -311,8 +378,8 @@ pub async fn launch_minecraft(
    wrapper: &Option<String>,
    memory: &st::MemorySettings,
    resolution: &st::WindowSize,
-    credentials: &auth::Credentials,
-    post_exit_hook: Option<Command>,
+    credentials: &Credentials,
+    post_exit_hook: Option<String>,
    profile: &Profile,
 ) -> crate::Result<Arc<tokio::sync::RwLock<MinecraftChild>>> {
    if profile.install_stage == ProfileInstallStage::PackInstalling
@@ -325,7 +392,7 @@ pub async fn launch_minecraft(
    }

    if profile.install_stage != ProfileInstallStage::Installed {
-        install_minecraft(profile, None).await?;
+        install_minecraft(profile, None, false).await?;
    }

    let state = State::get().await?;
@@ -334,15 +401,23 @@ pub async fn launch_minecraft(
    let instance_path = profile.get_profile_full_path().await?;
    let instance_path = &io::canonicalize(instance_path)?;

-    let version = metadata
+    let version_index = metadata
        .minecraft
        .versions
        .iter()
-        .find(|it| it.id == profile.metadata.game_version)
+        .position(|it| it.id == profile.metadata.game_version)
        .ok_or(crate::ErrorKind::LauncherError(format!(
            "Invalid game version: {}",
            profile.metadata.game_version
        )))?;
+    let version = &metadata.minecraft.versions[version_index];
+    let minecraft_updated = version_index
+        <= metadata
+            .minecraft
+            .versions
+            .iter()
+            .position(|x| x.id == "22w16a")
+            .unwrap_or(0);

    let version_jar = profile
        .metadata
@@ -370,14 +445,15 @@ pub async fn launch_minecraft(
        })?;

    // Test jre version
-    let java_version = jre::check_jre(java_version.path.clone().into())
-        .await?
-        .ok_or_else(|| {
-            crate::ErrorKind::LauncherError(format!(
-                "Java path invalid or non-functional: {}",
-                java_version.path
-            ))
-        })?;
+    let java_version =
+        crate::api::jre::check_jre(java_version.path.clone().into())
+            .await?
+            .ok_or_else(|| {
+                crate::ErrorKind::LauncherError(format!(
+                    "Java path invalid or non-functional: {}",
+                    java_version.path
+                ))
+            })?;

    let client_path = state
        .directories
@@ -406,7 +482,6 @@ pub async fn launch_minecraft(
        ))
        .as_error());
    }
-
    command
        .args(
            args::get_jvm_arguments(
@@ -419,6 +494,7 @@ pub async fn launch_minecraft(
                    version_info.libraries.as_slice(),
                    &client_path,
                    &java_version.architecture,
+                    minecraft_updated,
                )?,
                &version_jar,
                *memory,
@@ -446,15 +522,16 @@ pub async fn launch_minecraft(
            .into_iter()
            .collect::<Vec<_>>(),
        )
-        .current_dir(instance_path.clone())
-        .stdout(Stdio::piped())
-        .stderr(Stdio::piped());
+        .current_dir(instance_path.clone());

    // CARGO-set DYLD_LIBRARY_PATH breaks Minecraft on macOS during testing on playground
    #[cfg(target_os = "macos")]
    if std::env::var("CARGO").is_ok() {
        command.env_remove("DYLD_FALLBACK_LIBRARY_PATH");
    }
+    // Java options should be set in instance options (the existence of _JAVA_OPTIONS overwites them)
+    command.env_remove("_JAVA_OPTIONS");
+
    command.envs(env_args);

    // Overwrites the minecraft options.txt file with the settings from the profile
@@ -484,20 +561,6 @@ pub async fn launch_minecraft(
        io::write(&options_path, options_string).await?;
    }

-    // Get Modrinth logs directories
-    let datetime_string =
-        chrono::Local::now().format("%Y%m%d_%H%M%S").to_string();
-    let logs_dir = {
-        let st = State::get().await?;
-        st.directories
-            .profile_logs_dir(&profile.profile_id())
-            .await?
-            .join(&datetime_string)
-    };
-    io::create_dir_all(&logs_dir).await?;
-
-    let stdout_log_path = logs_dir.join("stdout.log");
-
    crate::api::profile::edit(&profile.profile_id(), |prof| {
        prof.metadata.last_played = Some(Utc::now());

@@ -559,10 +622,9 @@ pub async fn launch_minecraft(
    // This also spawns the process and prepares the subsequent processes
    let mut state_children = state.children.write().await;
    state_children
-        .insert_process(
+        .insert_new_process(
            Uuid::new_v4(),
            profile.profile_id(),
-            stdout_log_path,
            command,
            post_exit_hook,
            censor_strings,
--- a/theseus/src/lib.rs
+++ b/theseus/src/lib.rs
@@ -22,4 +22,5 @@ pub use api::*;
 pub use error::*;
 pub use event::{EventState, LoadingBar, LoadingBarType};
 pub use logger::start_logger;
+pub use state::InnerProjectPathUnix;
 pub use state::State;
--- a/theseus/src/logger.rs
+++ b/theseus/src/logger.rs
@@ -24,7 +24,9 @@ pub fn start_logger() -> Option<WorkerGuard> {
    use tracing_subscriber::prelude::*;

    let filter = tracing_subscriber::EnvFilter::try_from_default_env()
-        .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("theseus=info"));
+        .unwrap_or_else(|_| {
+            tracing_subscriber::EnvFilter::new("theseus=info,theseus_gui=info")
+        });
    let subscriber = tracing_subscriber::registry()
        .with(tracing_subscriber::fmt::layer())
        .with(filter)
@@ -63,7 +65,7 @@ pub fn start_logger() -> Option<WorkerGuard> {
            tracing_subscriber::fmt::layer()
                .with_writer(non_blocking)
                .with_ansi(false) // disable ANSI escape codes
-                .with_timer(ChronoLocal::rfc3339()),
+                .with_timer(ChronoLocal::rfc_3339()),
        )
        .with(filter)
        .with(tracing_error::ErrorLayer::default());
--- a/theseus/src/state/auth_task.rs
+++ b/theseus/src/state/auth_task.rs
@@ -1,91 +0,0 @@
-use crate::launcher::auth::Credentials;
-
-use tokio::task::JoinHandle;
-
-// Authentication task
-// A wrapper over the authentication task that allows it to be called from the frontend
-// without caching the task handle in the frontend
-
-pub struct AuthTask(
-    #[allow(clippy::type_complexity)]
-    Option<JoinHandle<crate::Result<(Credentials, Option<String>)>>>,
-);
-
-impl AuthTask {
-    pub fn new() -> AuthTask {
-        AuthTask(None)
-    }
-
-    pub async fn begin_auth() -> crate::Result<url::Url> {
-        let state = crate::State::get().await?;
-
-        // Creates a channel to receive the URL
-        let (tx, rx) = tokio::sync::oneshot::channel::<url::Url>();
-        let task = tokio::spawn(crate::auth::authenticate(tx));
-
-        // If receiver is dropped, try to get Hydra error
-        let url = rx.await;
-        let url = match url {
-            Ok(url) => url,
-            Err(e) => {
-                task.await??;
-                return Err(e.into()); // truly a dropped receiver
-            }
-        };
-
-        // Flow is going, store in state and return
-        let mut write = state.auth_flow.write().await;
-        write.0 = Some(task);
-
-        Ok(url)
-    }
-
-    pub async fn await_auth_completion(
-    ) -> crate::Result<(Credentials, Option<String>)> {
-        // Gets the task handle from the state, replacing with None
-        let task = {
-            let state = crate::State::get().await?;
-            let mut write = state.auth_flow.write().await;
-
-            write.0.take()
-        };
-
-        // Waits for the task to complete, and returns the credentials
-        let credentials = task
-            .ok_or(AuthTaskError::TaskMissing)?
-            .await
-            .map_err(AuthTaskError::from)??;
-
-        Ok(credentials)
-    }
-
-    pub async fn cancel() -> crate::Result<()> {
-        // Gets the task handle from the state, replacing with None
-        let task = {
-            let state = crate::State::get().await?;
-            let mut write = state.auth_flow.write().await;
-
-            write.0.take()
-        };
-        if let Some(task) = task {
-            // Cancels the task
-            task.abort();
-        }
-
-        Ok(())
-    }
-}
-
-impl Default for AuthTask {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[derive(thiserror::Error, Debug)]
-pub enum AuthTaskError {
-    #[error("Authentication task was aborted or missing")]
-    TaskMissing,
-    #[error("Join handle error")]
-    JoinHandleError(#[from] tokio::task::JoinError),
-}
--- a/theseus/src/state/children.rs
+++ b/theseus/src/state/children.rs
@@ -1,89 +1,286 @@
 use super::{Profile, ProfilePathId};
 use chrono::{DateTime, Utc};
-use std::path::{Path, PathBuf};
-use std::process::ExitStatus;
+use serde::Deserialize;
+use serde::Serialize;
 use std::{collections::HashMap, sync::Arc};
-use tokio::fs::File;
-use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::process::Child;
 use tokio::process::Command;
-use tokio::process::{ChildStderr, ChildStdout};
 use tokio::sync::RwLock;
-use tracing::error;

 use crate::event::emit::emit_process;
 use crate::event::ProcessPayloadType;
-use crate::profile;
+use crate::util::fetch::read_json;
 use crate::util::io::IOError;
+use crate::{profile, ErrorKind};

 use tokio::task::JoinHandle;
 use uuid::Uuid;

+const PROCESSES_JSON: &str = "processes.json";
+
 // Child processes (instances of Minecraft)
 // A wrapper over a Hashmap connecting PID -> MinecraftChild
 pub struct Children(HashMap<Uuid, Arc<RwLock<MinecraftChild>>>);

-// Minecraft Child, bundles together the PID, the actual Child, and the easily queryable stdout and stderr streams
+#[derive(Debug)]
+pub enum ChildType {
+    // A child process that is being managed by tokio
+    TokioChild(Child),
+    // A child process that was rescued from a cache (e.g. a process that was launched by theseus before the launcher was restarted)
+    // This may not have all the same functionality as a TokioChild
+    RescuedPID(u32),
+}
+#[derive(Serialize, Deserialize, Debug)]
+pub struct ProcessCache {
+    pub pid: u32,
+    pub uuid: Uuid,
+    pub start_time: u64,
+    pub name: String,
+    pub exe: String,
+    pub profile_relative_path: ProfilePathId,
+    pub post_command: Option<String>,
+}
+impl ChildType {
+    pub async fn try_wait(&mut self) -> crate::Result<Option<i32>> {
+        match self {
+            ChildType::TokioChild(child) => Ok(child
+                .try_wait()
+                .map_err(IOError::from)?
+                .map(|x| x.code().unwrap_or(0))),
+            ChildType::RescuedPID(pid) => {
+                let mut system = sysinfo::System::new();
+                if !system.refresh_process(sysinfo::Pid::from_u32(*pid)) {
+                    return Ok(Some(0));
+                }
+                let process = system.process(sysinfo::Pid::from_u32(*pid));
+                if let Some(process) = process {
+                    if process.status() == sysinfo::ProcessStatus::Run {
+                        Ok(None)
+                    } else {
+                        Ok(Some(0))
+                    }
+                } else {
+                    Ok(Some(0))
+                }
+            }
+        }
+    }
+    pub async fn kill(&mut self) -> crate::Result<()> {
+        match self {
+            ChildType::TokioChild(child) => {
+                Ok(child.kill().await.map_err(IOError::from)?)
+            }
+            ChildType::RescuedPID(pid) => {
+                let mut system = sysinfo::System::new();
+                if system.refresh_process(sysinfo::Pid::from_u32(*pid)) {
+                    let process = system.process(sysinfo::Pid::from_u32(*pid));
+                    if let Some(process) = process {
+                        process.kill();
+                    }
+                }
+                Ok(())
+            }
+        }
+    }
+    pub fn id(&self) -> Option<u32> {
+        match self {
+            ChildType::TokioChild(child) => child.id(),
+            ChildType::RescuedPID(pid) => Some(*pid),
+        }
+    }
+
+    // Caches the process so that it can be restored if the launcher is restarted
+    // Stored in the caches/metadata/processes.json file
+    pub async fn cache_process(
+        &self,
+        uuid: uuid::Uuid,
+        profile_path_id: ProfilePathId,
+        post_command: Option<String>,
+    ) -> crate::Result<()> {
+        let pid = match self {
+            ChildType::TokioChild(child) => child.id().unwrap_or(0),
+            ChildType::RescuedPID(pid) => *pid,
+        };
+
+        let state = crate::State::get().await?;
+
+        let mut system = sysinfo::System::new();
+        system.refresh_processes();
+        let process =
+            system.process(sysinfo::Pid::from_u32(pid)).ok_or_else(|| {
+                crate::ErrorKind::LauncherError(format!(
+                    "Could not find process {}",
+                    pid
+                ))
+            })?;
+        let start_time = process.start_time();
+        let name = process.name().to_string();
+
+        let Some(path) = process.exe() else {
+            return Err(ErrorKind::LauncherError(format!(
+                "Cached process {} has no accessable path",
+                pid
+            ))
+            .into());
+        };
+
+        let exe = path.to_string_lossy().to_string();
+
+        let cached_process = ProcessCache {
+            pid,
+            start_time,
+            name,
+            exe,
+            post_command,
+            uuid,
+            profile_relative_path: profile_path_id,
+        };
+
+        let children_path = state
+            .directories
+            .caches_meta_dir()
+            .await
+            .join(PROCESSES_JSON);
+        let mut children_caches = if let Ok(children_json) =
+            read_json::<HashMap<uuid::Uuid, ProcessCache>>(
+                &children_path,
+                &state.io_semaphore,
+            )
+            .await
+        {
+            children_json
+        } else {
+            HashMap::new()
+        };
+        children_caches.insert(uuid, cached_process);
+        crate::util::fetch::write(
+            &children_path,
+            &serde_json::to_vec(&children_caches)?,
+            &state.io_semaphore,
+        )
+        .await?;
+
+        Ok(())
+    }
+
+    // Removes the process from the cache (ie: on process exit)
+    pub async fn remove_cache(&self, uuid: uuid::Uuid) -> crate::Result<()> {
+        let state = crate::State::get().await?;
+        let children_path = state
+            .directories
+            .caches_meta_dir()
+            .await
+            .join(PROCESSES_JSON);
+        let mut children_caches = if let Ok(children_json) =
+            read_json::<HashMap<uuid::Uuid, ProcessCache>>(
+                &children_path,
+                &state.io_semaphore,
+            )
+            .await
+        {
+            children_json
+        } else {
+            HashMap::new()
+        };
+        children_caches.remove(&uuid);
+        crate::util::fetch::write(
+            &children_path,
+            &serde_json::to_vec(&children_caches)?,
+            &state.io_semaphore,
+        )
+        .await?;
+
+        Ok(())
+    }
+}
+
+// Minecraft Child, bundles together the PID, the actual Child, and the easily queryable stdout and stderr streams (if needed)
 #[derive(Debug)]
 pub struct MinecraftChild {
    pub uuid: Uuid,
    pub profile_relative_path: ProfilePathId,
-    pub manager: Option<JoinHandle<crate::Result<ExitStatus>>>, // None when future has completed and been handled
-    pub current_child: Arc<RwLock<Child>>,
-    pub output: SharedOutput,
+    pub manager: Option<JoinHandle<crate::Result<i32>>>, // None when future has completed and been handled
+    pub current_child: Arc<RwLock<ChildType>>,
    pub last_updated_playtime: DateTime<Utc>, // The last time we updated the playtime for the associated profile
 }

 impl Children {
-    pub fn new() -> Children {
+    pub fn new() -> Self {
        Children(HashMap::new())
    }

+    // Loads cached processes from the caches/metadata/processes.json file, re-inserts them into the hashmap, and removes them from the file
+    // This will only be called once, on startup. Only processes who match a cached process (name, time started, pid, etc) will be re-inserted
+    pub async fn rescue_cache(&mut self) -> crate::Result<()> {
+        let state = crate::State::get().await?;
+        let children_path = state
+            .directories
+            .caches_meta_dir()
+            .await
+            .join(PROCESSES_JSON);
+
+        let mut children_caches = if let Ok(children_json) =
+            read_json::<HashMap<uuid::Uuid, ProcessCache>>(
+                &children_path,
+                &state.io_semaphore,
+            )
+            .await
+        {
+            // Overwrite the file with an empty hashmap- we will re-insert the cached processes
+            let empty = HashMap::<uuid::Uuid, ProcessCache>::new();
+            crate::util::fetch::write(
+                &children_path,
+                &serde_json::to_vec(&empty)?,
+                &state.io_semaphore,
+            )
+            .await?;
+
+            // Return the cached processes
+            children_json
+        } else {
+            HashMap::new()
+        };
+
+        for (_, cache) in children_caches.drain() {
+            let uuid = cache.uuid;
+            match self.insert_cached_process(cache).await {
+                Ok(child) => {
+                    self.0.insert(uuid, child);
+                }
+                Err(e) => tracing::warn!(
+                    "Failed to rescue cached process {}: {}",
+                    uuid,
+                    e
+                ),
+            }
+        }
+        Ok(())
+    }
+
    // Runs the command in process, inserts a child process to keep track of, and returns a reference to the container struct MinecraftChild
    // The threads for stdout and stderr are spawned here
    // Unlike a Hashmap's 'insert', this directly returns the reference to the MinecraftChild rather than any previously stored MinecraftChild that may exist
-
    #[tracing::instrument(skip(
        self,
        uuid,
-        log_path,
        mc_command,
        post_command,
        censor_strings
    ))]
    #[tracing::instrument(level = "trace", skip(self))]
    #[theseus_macros::debug_pin]
-    pub async fn insert_process(
+    pub async fn insert_new_process(
        &mut self,
        uuid: Uuid,
        profile_relative_path: ProfilePathId,
-        log_path: PathBuf,
        mut mc_command: Command,
-        post_command: Option<Command>, // Command to run after minecraft.
+        post_command: Option<String>, // Command to run after minecraft.
        censor_strings: HashMap<String, String>,
    ) -> crate::Result<Arc<RwLock<MinecraftChild>>> {
        // Takes the first element of the commands vector and spawns it
-        let mut child = mc_command.spawn().map_err(IOError::from)?;
+        let mc_proc = mc_command.spawn().map_err(IOError::from)?;

-        // Create std watcher threads for stdout and stderr
-        let shared_output =
-            SharedOutput::build(&log_path, censor_strings).await?;
-        if let Some(child_stdout) = child.stdout.take() {
-            let stdout_clone = shared_output.clone();
-            tokio::spawn(async move {
-                if let Err(e) = stdout_clone.read_stdout(child_stdout).await {
-                    error!("Stdout process died with error: {}", e);
-                }
-            });
-        }
-        if let Some(child_stderr) = child.stderr.take() {
-            let stderr_clone = shared_output.clone();
-            tokio::spawn(async move {
-                if let Err(e) = stderr_clone.read_stderr(child_stderr).await {
-                    error!("Stderr process died with error: {}", e);
-                }
-            });
-        }
+        let child = ChildType::TokioChild(mc_proc);

        // Slots child into manager
        let pid = child.id().ok_or_else(|| {
@@ -91,6 +288,15 @@ impl Children {
                "Process immediately failed, could not get PID".to_string(),
            )
        })?;
+
+        // Caches process so that it can be restored if the launcher is restarted
+        child
+            .cache_process(
+                uuid,
+                profile_relative_path.clone(),
+                post_command.clone(),
+            )
+            .await?;
        let current_child = Arc::new(RwLock::new(child));
        let manager = Some(tokio::spawn(Self::sequential_process_manager(
            uuid,
@@ -115,7 +321,6 @@ impl Children {
            uuid,
            profile_relative_path,
            current_child,
-            output: shared_output,
            manager,
            last_updated_playtime,
        };
@@ -125,6 +330,104 @@ impl Children {
        Ok(mchild)
    }

+    // Rescues a cached process, inserts a child process to keep track of, and returns a reference to the container struct MinecraftChild
+    // Essentially 'reconnects' to a process that was launched by theseus before the launcher was restarted
+    // However, this may not have all the same functionality as a TokioChild, as we only have the PID and not the actual Child
+    // Only processes who match a cached process (name, time started, pid, etc) will be re-inserted. The function fails with an error if the process is notably different.
+    #[tracing::instrument(skip(self, cached_process,))]
+    #[tracing::instrument(level = "trace", skip(self))]
+    #[theseus_macros::debug_pin]
+    pub async fn insert_cached_process(
+        &mut self,
+        cached_process: ProcessCache,
+    ) -> crate::Result<Arc<RwLock<MinecraftChild>>> {
+        let _state = crate::State::get().await?;
+
+        // Takes the first element of the commands vector and spawns it
+        // Checks processes, compares cached process to actual process
+        // Fails if notably different (meaning that the PID was reused, and we shouldn't reconnect to it)
+        {
+            let mut system = sysinfo::System::new();
+            system.refresh_processes();
+            let process = system
+                .process(sysinfo::Pid::from_u32(cached_process.pid))
+                .ok_or_else(|| {
+                    crate::ErrorKind::LauncherError(format!(
+                        "Could not find process {}",
+                        cached_process.pid
+                    ))
+                })?;
+
+            if cached_process.start_time != process.start_time() {
+                return Err(ErrorKind::LauncherError(format!("Cached process {} has different start time than actual process {}", cached_process.pid, process.start_time())).into());
+            }
+            if cached_process.name != process.name() {
+                return Err(ErrorKind::LauncherError(format!("Cached process {} has different name than actual process {}", cached_process.pid, process.name())).into());
+            }
+            if let Some(path) = process.exe() {
+                if cached_process.exe != path.to_string_lossy() {
+                    return Err(ErrorKind::LauncherError(format!("Cached process {} has different exe than actual process {}", cached_process.pid, path.to_string_lossy())).into());
+                }
+            } else {
+                return Err(ErrorKind::LauncherError(format!(
+                    "Cached process {} has no accessable path",
+                    cached_process.pid
+                ))
+                .into());
+            }
+        }
+
+        let child = ChildType::RescuedPID(cached_process.pid);
+
+        // Slots child into manager
+        let pid = child.id().ok_or_else(|| {
+            crate::ErrorKind::LauncherError(
+                "Process immediately failed, could not get PID".to_string(),
+            )
+        })?;
+
+        // Re-caches process so that it can be restored if the launcher is restarted
+        child
+            .cache_process(
+                cached_process.uuid,
+                cached_process.profile_relative_path.clone(),
+                cached_process.post_command.clone(),
+            )
+            .await?;
+
+        let current_child = Arc::new(RwLock::new(child));
+        let manager = Some(tokio::spawn(Self::sequential_process_manager(
+            cached_process.uuid,
+            cached_process.post_command,
+            pid,
+            current_child.clone(),
+            cached_process.profile_relative_path.clone(),
+        )));
+
+        emit_process(
+            cached_process.uuid,
+            pid,
+            ProcessPayloadType::Launched,
+            "Launched Minecraft",
+        )
+        .await?;
+
+        let last_updated_playtime = Utc::now();
+
+        // Create MinecraftChild
+        let mchild = MinecraftChild {
+            uuid: cached_process.uuid,
+            profile_relative_path: cached_process.profile_relative_path,
+            current_child,
+            manager,
+            last_updated_playtime,
+        };
+
+        let mchild = Arc::new(RwLock::new(mchild));
+        self.0.insert(cached_process.uuid, mchild.clone());
+        Ok(mchild)
+    }
+
    // Spawns a new child process and inserts it into the hashmap
    // Also, as the process ends, it spawns the follow-up process if it exists
    // By convention, ExitStatus is last command's exit status, and we exit on the first non-zero exit status
@@ -132,28 +435,23 @@ impl Children {
    #[theseus_macros::debug_pin]
    async fn sequential_process_manager(
        uuid: Uuid,
-        post_command: Option<Command>,
+        post_command: Option<String>,
        mut current_pid: u32,
-        current_child: Arc<RwLock<Child>>,
+        current_child: Arc<RwLock<ChildType>>,
        associated_profile: ProfilePathId,
-    ) -> crate::Result<ExitStatus> {
+    ) -> crate::Result<i32> {
        let current_child = current_child.clone();

        // Wait on current Minecraft Child
        let mut mc_exit_status;
        let mut last_updated_playtime = Utc::now();
        loop {
-            if let Some(t) = current_child
-                .write()
-                .await
-                .try_wait()
-                .map_err(IOError::from)?
-            {
+            if let Some(t) = current_child.write().await.try_wait().await? {
                mc_exit_status = t;
                break;
            }
            // sleep for 10ms
-            tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
+            tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;

            // Auto-update playtime every minute
            let diff = Utc::now()
@@ -168,7 +466,7 @@ impl Children {
                {
                    tracing::warn!(
                        "Failed to update playtime for profile {}: {}",
-                        associated_profile,
+                        &associated_profile,
                        e
                    );
                }
@@ -188,7 +486,7 @@ impl Children {
        {
            tracing::warn!(
                "Failed to update playtime for profile {}: {}",
-                associated_profile,
+                &associated_profile,
                e
            );
        }
@@ -196,13 +494,15 @@ impl Children {
        // Publish play time update
        // Allow failure, it will be stored locally and sent next time
        // Sent in another thread as first call may take a couple seconds and hold up process ending
+        let associated_profile_clone = associated_profile.clone();
        tokio::spawn(async move {
            if let Err(e) =
-                profile::try_update_playtime(&associated_profile).await
+                profile::try_update_playtime(&associated_profile_clone.clone())
+                    .await
            {
                tracing::warn!(
                    "Failed to update playtime for profile {}: {}",
-                    associated_profile,
+                    &associated_profile_clone,
                    e
                );
            }
@@ -224,7 +524,12 @@ impl Children {
            }
        }

-        if !mc_exit_status.success() {
+        {
+            let current_child = current_child.write().await;
+            current_child.remove_cache(uuid).await?;
+        }
+
+        if !mc_exit_status == 0 {
            emit_process(
                uuid,
                current_pid,
@@ -237,9 +542,28 @@ impl Children {
        }

        // If a post-command exist, switch to it and wait on it
+        // First, create the command by splitting arguments
+        let post_command = if let Some(hook) = post_command {
+            let mut cmd = hook.split(' ');
+            if let Some(command) = cmd.next() {
+                let mut command = Command::new(command);
+                command
+                    .args(&cmd.collect::<Vec<&str>>())
+                    .current_dir(associated_profile.get_full_path().await?);
+                Some(command)
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+
        if let Some(mut m_command) = post_command {
            {
-                let mut current_child = current_child.write().await;
+                let mut current_child: tokio::sync::RwLockWriteGuard<
+                    '_,
+                    ChildType,
+                > = current_child.write().await;
                let new_child = m_command.spawn().map_err(IOError::from)?;
                current_pid = new_child.id().ok_or_else(|| {
                    crate::ErrorKind::LauncherError(
@@ -247,7 +571,7 @@ impl Children {
                            .to_string(),
                    )
                })?;
-                *current_child = new_child;
+                *current_child = ChildType::TokioChild(new_child);
            }
            emit_process(
                uuid,
@@ -258,12 +582,7 @@ impl Children {
            .await?;

            loop {
-                if let Some(t) = current_child
-                    .write()
-                    .await
-                    .try_wait()
-                    .map_err(IOError::from)?
-                {
+                if let Some(t) = current_child.write().await.try_wait().await? {
                    mc_exit_status = t;
                    break;
                }
@@ -296,18 +615,10 @@ impl Children {

    // Get exit status of a child by PID
    // Returns None if the child is still running
-    pub async fn exit_status(
-        &self,
-        uuid: &Uuid,
-    ) -> crate::Result<Option<std::process::ExitStatus>> {
+    pub async fn exit_status(&self, uuid: &Uuid) -> crate::Result<Option<i32>> {
        if let Some(child) = self.get(uuid) {
            let child = child.write().await;
-            let status = child
-                .current_child
-                .write()
-                .await
-                .try_wait()
-                .map_err(IOError::from)?;
+            let status = child.current_child.write().await.try_wait().await?;
            Ok(status)
        } else {
            Ok(None)
@@ -326,7 +637,7 @@ impl Children {
                    .write()
                    .await
                    .try_wait()
-                    .map_err(IOError::from)?
+                    .await?
                    .is_none()
                {
                    keys.push(key);
@@ -369,7 +680,7 @@ impl Children {
                    .write()
                    .await
                    .try_wait()
-                    .map_err(IOError::from)?
+                    .await?
                    .is_none()
                {
                    profiles.push(child.profile_relative_path.clone());
@@ -392,7 +703,7 @@ impl Children {
                    .write()
                    .await
                    .try_wait()
-                    .map_err(IOError::from)?
+                    .await?
                    .is_none()
                {
                    if let Some(prof) = crate::api::profile::get(
@@ -415,107 +726,3 @@ impl Default for Children {
        Self::new()
    }
 }
-
-// SharedOutput, a wrapper around a String that can be read from and written to concurrently
-// Designed to be used with ChildStdout and ChildStderr in a tokio thread to have a simple String storage for the output of a child process
-#[derive(Debug, Clone)]
-pub struct SharedOutput {
-    output: Arc<RwLock<String>>,
-    log_file: Arc<RwLock<File>>,
-    censor_strings: HashMap<String, String>,
-}
-
-impl SharedOutput {
-    async fn build(
-        log_file_path: &Path,
-        censor_strings: HashMap<String, String>,
-    ) -> crate::Result<Self> {
-        Ok(SharedOutput {
-            output: Arc::new(RwLock::new(String::new())),
-            log_file: Arc::new(RwLock::new(
-                File::create(log_file_path)
-                    .await
-                    .map_err(|e| IOError::with_path(e, log_file_path))?,
-            )),
-            censor_strings,
-        })
-    }
-
-    // Main entry function to a created SharedOutput, returns the log as a String
-    pub async fn get_output(&self) -> crate::Result<String> {
-        let output = self.output.read().await;
-        Ok(output.clone())
-    }
-
-    async fn read_stdout(
-        &self,
-        child_stdout: ChildStdout,
-    ) -> crate::Result<()> {
-        let mut buf_reader = BufReader::new(child_stdout);
-        let mut line = String::new();
-
-        while buf_reader
-            .read_line(&mut line)
-            .await
-            .map_err(IOError::from)?
-            > 0
-        {
-            let val_line = self.censor_log(line.clone());
-
-            {
-                let mut output = self.output.write().await;
-                output.push_str(&val_line);
-            }
-            {
-                let mut log_file = self.log_file.write().await;
-                log_file
-                    .write_all(val_line.as_bytes())
-                    .await
-                    .map_err(IOError::from)?;
-            }
-
-            line.clear();
-        }
-        Ok(())
-    }
-
-    async fn read_stderr(
-        &self,
-        child_stderr: ChildStderr,
-    ) -> crate::Result<()> {
-        let mut buf_reader = BufReader::new(child_stderr);
-        let mut line = String::new();
-
-        while buf_reader
-            .read_line(&mut line)
-            .await
-            .map_err(IOError::from)?
-            > 0
-        {
-            let val_line = self.censor_log(line.clone());
-
-            {
-                let mut output = self.output.write().await;
-                output.push_str(&val_line);
-            }
-            {
-                let mut log_file = self.log_file.write().await;
-                log_file
-                    .write_all(val_line.as_bytes())
-                    .await
-                    .map_err(IOError::from)?;
-            }
-
-            line.clear();
-        }
-        Ok(())
-    }
-
-    fn censor_log(&self, mut val: String) -> String {
-        for (find, replace) in &self.censor_strings {
-            val = val.replace(find, replace);
-        }
-
-        val
-    }
-}
--- a/theseus/src/state/dirs.rs
+++ b/theseus/src/state/dirs.rs
@@ -9,6 +9,8 @@ use super::{ProfilePathId, Settings};
 pub const SETTINGS_FILE_NAME: &str = "settings.json";
 pub const CACHES_FOLDER_NAME: &str = "caches";
 pub const LAUNCHER_LOGS_FOLDER_NAME: &str = "launcher_logs";
+pub const PROFILES_FOLDER_NAME: &str = "profiles";
+pub const METADATA_FOLDER_NAME: &str = "meta";

 #[derive(Debug)]
 pub struct DirectoryInfo {
@@ -75,7 +77,7 @@ impl DirectoryInfo {
    /// Get the Minecraft instance metadata directory
    #[inline]
    pub async fn metadata_dir(&self) -> PathBuf {
-        self.config_dir.read().await.join("meta")
+        self.config_dir.read().await.join(METADATA_FOLDER_NAME)
    }

    /// Get the Minecraft java versions metadata directory
@@ -153,16 +155,15 @@ impl DirectoryInfo {
    /// Get the profiles directory for created profiles
    #[inline]
    pub async fn profiles_dir(&self) -> PathBuf {
-        self.config_dir.read().await.join("profiles")
+        self.config_dir.read().await.join(PROFILES_FOLDER_NAME)
    }

    /// Gets the logs dir for a given profile
    #[inline]
    pub async fn profile_logs_dir(
-        &self,
        profile_id: &ProfilePathId,
    ) -> crate::Result<PathBuf> {
-        Ok(profile_id.get_full_path().await?.join("modrinth_logs"))
+        Ok(profile_id.get_full_path().await?.join("logs"))
    }

    #[inline]
--- a/theseus/src/state/discord.rs
+++ b/theseus/src/state/discord.rs
@@ -16,17 +16,22 @@ pub struct DiscordGuard {
 impl DiscordGuard {
    /// Initialize discord IPC client, and attempt to connect to it
    /// If it fails, it will still return a DiscordGuard, but the client will be unconnected
-    pub async fn init() -> crate::Result<DiscordGuard> {
+    pub async fn init(is_offline: bool) -> crate::Result<DiscordGuard> {
        let mut dipc =
-            DiscordIpcClient::new("1084015525241311292").map_err(|e| {
+            DiscordIpcClient::new("1123683254248148992").map_err(|e| {
                crate::ErrorKind::OtherError(format!(
                    "Could not create Discord client {}",
                    e,
                ))
            })?;
-        let res = dipc.connect(); // Do not need to connect to Discord to use app
-        let connected = if res.is_ok() {
-            Arc::new(AtomicBool::new(true))
+
+        let connected = if !is_offline {
+            let res = dipc.connect(); // Do not need to connect to Discord to use app
+            if res.is_ok() {
+                Arc::new(AtomicBool::new(true))
+            } else {
+                Arc::new(AtomicBool::new(false))
+            }
        } else {
            Arc::new(AtomicBool::new(false))
        };
@@ -51,11 +56,46 @@ impl DiscordGuard {
        true
    }

+    // check online
+    pub async fn check_online(&self) -> bool {
+        let state = match State::get().await {
+            Ok(s) => s,
+            Err(_) => return false,
+        };
+        let offline = state.offline.read().await;
+        if *offline {
+            return false;
+        }
+        true
+    }
+
    /// Set the activity to the given message
+    /// First checks if discord is disabled, and if so, clear the activity instead
    pub async fn set_activity(
        &self,
        msg: &str,
        reconnect_if_fail: bool,
+    ) -> crate::Result<()> {
+        if !self.check_online().await {
+            return Ok(());
+        }
+
+        // Check if discord is disabled, and if so, clear the activity instead
+        let state = State::get().await?;
+        let settings = state.settings.read().await;
+        if settings.disable_discord_rpc {
+            Ok(self.clear_activity(true).await?)
+        } else {
+            Ok(self.force_set_activity(msg, reconnect_if_fail).await?)
+        }
+    }
+
+    /// Sets the activity to the given message, regardless of if discord is disabled or offline
+    /// Should not be used except for in the above method, or if it is already known that discord is enabled (specifically for state initialization) and we are connected to the internet
+    pub async fn force_set_activity(
+        &self,
+        msg: &str,
+        reconnect_if_fail: bool,
    ) -> crate::Result<()> {
        // Attempt to connect if not connected. Do not continue if it fails, as the client.set_activity can panic if it never was connected
        if !self.retry_if_not_ready().await {
@@ -99,14 +139,13 @@ impl DiscordGuard {
        Ok(())
    }

-    /*
-    /// Clear the activity
+    /// Clear the activity entirely ('disabling' the RPC until the next set_activity)
    pub async fn clear_activity(
        &self,
        reconnect_if_fail: bool,
    ) -> crate::Result<()> {
        // Attempt to connect if not connected. Do not continue if it fails, as the client.clear_activity can panic if it never was connected
-        if !self.retry_if_not_ready().await {
+        if !self.check_online().await || !self.retry_if_not_ready().await {
            return Ok(());
        }

@@ -138,7 +177,7 @@ impl DiscordGuard {
            res.map_err(could_not_clear_err)?;
        }
        Ok(())
-    }*/
+    }

    /// Clear the activity, but if there is a running profile, set the activity to that instead
    pub async fn clear_to_default(
@@ -147,6 +186,15 @@ impl DiscordGuard {
    ) -> crate::Result<()> {
        let state: Arc<tokio::sync::RwLockReadGuard<'_, State>> =
            State::get().await?;
+
+        {
+            let settings = state.settings.read().await;
+            if settings.disable_discord_rpc {
+                println!("Discord is disabled, clearing activity");
+                return self.clear_activity(true).await;
+            }
+        }
+
        if let Some(existing_child) = state
            .children
            .read()
--- a/theseus/src/state/metadata.rs
+++ b/theseus/src/state/metadata.rs
@@ -18,6 +18,7 @@ pub struct Metadata {
    pub forge: LoaderManifest,
    pub fabric: LoaderManifest,
    pub quilt: LoaderManifest,
+    pub neoforge: LoaderManifest,
 }

 impl Metadata {
@@ -26,7 +27,7 @@ impl Metadata {
    }

    pub async fn fetch() -> crate::Result<Self> {
-        let (minecraft, forge, fabric, quilt) = tokio::try_join! {
+        let (minecraft, forge, fabric, quilt, neoforge) = tokio::try_join! {
            async {
                let url = Self::get_manifest("minecraft");
                fetch_version_manifest(Some(&url)).await
@@ -42,6 +43,10 @@ impl Metadata {
            async {
                let url = Self::get_manifest("quilt");
                fetch_loader_manifest(&url).await
+            },
+            async {
+                let url = Self::get_manifest("neo");
+                fetch_loader_manifest(&url).await
            }
        }?;

@@ -50,6 +55,7 @@ impl Metadata {
            forge,
            fabric,
            quilt,
+            neoforge,
        })
    }

@@ -63,6 +69,8 @@ impl Metadata {
    ) -> crate::Result<Self> {
        let mut metadata = None;
        let metadata_path = dirs.caches_meta_dir().await.join("metadata.json");
+        let metadata_backup_path =
+            dirs.caches_meta_dir().await.join("metadata.json.bak");

        if let Ok(metadata_json) =
            read_json::<Metadata>(&metadata_path, io_semaphore).await
@@ -79,6 +87,13 @@ impl Metadata {
                )
                .await?;

+                write(
+                    &metadata_backup_path,
+                    &serde_json::to_vec(&metadata_fetch).unwrap_or_default(),
+                    io_semaphore,
+                )
+                .await?;
+
                metadata = Some(metadata_fetch);
                Ok::<(), crate::Error>(())
            }
@@ -90,6 +105,18 @@ impl Metadata {
                    tracing::warn!("Unable to fetch launcher metadata: {err}")
                }
            }
+        } else if let Ok(metadata_json) =
+            read_json::<Metadata>(&metadata_backup_path, io_semaphore).await
+        {
+            metadata = Some(metadata_json);
+            std::fs::copy(&metadata_backup_path, &metadata_path).map_err(
+                |err| {
+                    crate::ErrorKind::FSError(format!(
+                        "Error restoring metadata backup: {err}"
+                    ))
+                    .as_error()
+                },
+            )?;
        }

        if let Some(meta) = metadata {
@@ -112,6 +139,15 @@ impl Metadata {
                .caches_meta_dir()
                .await
                .join("metadata.json");
+            let metadata_backup_path = state
+                .directories
+                .caches_meta_dir()
+                .await
+                .join("metadata.json.bak");
+
+            if metadata_path.exists() {
+                std::fs::copy(&metadata_path, &metadata_backup_path).unwrap();
+            }

            write(
                &metadata_path,
--- a/theseus/src/state/minecraft_auth.rs
+++ b/theseus/src/state/minecraft_auth.rs
@@ -0,0 +1,878 @@
+use crate::data::DirectoryInfo;
+use crate::util::fetch::{read_json, write, IoSemaphore, REQWEST_CLIENT};
+use crate::State;
+use base64::prelude::{BASE64_STANDARD, BASE64_URL_SAFE_NO_PAD};
+use base64::Engine;
+use byteorder::BigEndian;
+use chrono::{DateTime, Duration, Utc};
+use p256::ecdsa::signature::Signer;
+use p256::ecdsa::{Signature, SigningKey, VerifyingKey};
+use p256::pkcs8::{DecodePrivateKey, EncodePrivateKey, LineEnding};
+use rand::rngs::OsRng;
+use rand::Rng;
+use reqwest::header::HeaderMap;
+use reqwest::Response;
+use serde::de::DeserializeOwned;
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use std::collections::HashMap;
+use std::future::Future;
+use uuid::Uuid;
+
+#[derive(Debug, Clone, Copy)]
+pub enum MinecraftAuthStep {
+    GetDeviceToken,
+    SisuAuthenicate,
+    GetOAuthToken,
+    RefreshOAuthToken,
+    SisuAuthorize,
+    XstsAuthorize,
+    MinecraftToken,
+    MinecraftEntitlements,
+    MinecraftProfile,
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum MinecraftAuthenticationError {
+    #[error("Failed to serialize private key to PEM: {0}")]
+    PEMSerialize(#[from] p256::pkcs8::Error),
+    #[error("Failed to serialize body to JSON during step {step:?}: {source}")]
+    SerializeBody {
+        step: MinecraftAuthStep,
+        #[source]
+        source: serde_json::Error,
+    },
+    #[error(
+        "Failed to deserialize response to JSON during step {step:?}: {source}"
+    )]
+    DeserializeResponse {
+        step: MinecraftAuthStep,
+        raw: String,
+        #[source]
+        source: serde_json::Error,
+    },
+    #[error("Request failed during step {step:?}: {source}")]
+    Request {
+        step: MinecraftAuthStep,
+        #[source]
+        source: reqwest::Error,
+    },
+    #[error("Error creating signed request buffer {step:?}: {source}")]
+    ConstructingSignedRequest {
+        step: MinecraftAuthStep,
+        #[source]
+        source: std::io::Error,
+    },
+    #[error("Error reading user hash")]
+    NoUserHash,
+}
+
+const AUTH_JSON: &str = "minecraft_auth.json";
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct SaveDeviceToken {
+    pub id: String,
+    pub private_key: String,
+    pub x: String,
+    pub y: String,
+    pub token: DeviceToken,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct MinecraftLoginFlow {
+    pub challenge: String,
+    pub session_id: String,
+    pub redirect_uri: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct MinecraftAuthStore {
+    pub users: HashMap<Uuid, Credentials>,
+    pub token: Option<SaveDeviceToken>,
+    pub default_user: Option<Uuid>,
+}
+
+impl MinecraftAuthStore {
+    #[tracing::instrument]
+    pub async fn init(
+        dirs: &DirectoryInfo,
+        io_semaphore: &IoSemaphore,
+    ) -> crate::Result<Self> {
+        let auth_path = dirs.caches_meta_dir().await.join(AUTH_JSON);
+        let store = read_json(&auth_path, io_semaphore).await.ok();
+
+        if let Some(store) = store {
+            Ok(store)
+        } else {
+            Ok(Self {
+                users: HashMap::new(),
+                token: None,
+                default_user: None,
+            })
+        }
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub async fn save(&self) -> crate::Result<()> {
+        let state = State::get().await?;
+        let auth_path =
+            state.directories.caches_meta_dir().await.join(AUTH_JSON);
+
+        write(&auth_path, &serde_json::to_vec(&self)?, &state.io_semaphore)
+            .await?;
+
+        Ok(())
+    }
+
+    #[tracing::instrument(skip(self))]
+    async fn refresh_and_get_device_token(
+        &mut self,
+    ) -> crate::Result<(DeviceTokenKey, DeviceToken)> {
+        macro_rules! generate_key {
+            ($self:ident, $generate_key:expr, $device_token:expr, $SaveDeviceToken:path) => {{
+                let key = generate_key()?;
+                let token = device_token(&key).await?;
+
+                self.token = Some(SaveDeviceToken {
+                    id: key.id.clone(),
+                    private_key: key
+                        .key
+                        .to_pkcs8_pem(LineEnding::default())
+                        .map_err(|err| {
+                            MinecraftAuthenticationError::PEMSerialize(err)
+                        })?
+                        .to_string(),
+                    x: key.x.clone(),
+                    y: key.y.clone(),
+                    token: token.clone(),
+                });
+                self.save().await?;
+
+                (key, token)
+            }};
+        }
+
+        let (key, token) = if let Some(ref token) = self.token {
+            if token.token.not_after > Utc::now() {
+                if let Ok(private_key) =
+                    SigningKey::from_pkcs8_pem(&token.private_key)
+                {
+                    (
+                        DeviceTokenKey {
+                            id: token.id.clone(),
+                            key: private_key,
+                            x: token.x.clone(),
+                            y: token.y.clone(),
+                        },
+                        token.token.clone(),
+                    )
+                } else {
+                    generate_key!(
+                        self,
+                        generate_key,
+                        device_token,
+                        SaveDeviceToken
+                    )
+                }
+            } else {
+                generate_key!(self, generate_key, device_token, SaveDeviceToken)
+            }
+        } else {
+            generate_key!(self, generate_key, device_token, SaveDeviceToken)
+        };
+
+        Ok((key, token))
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub async fn login_begin(&mut self) -> crate::Result<MinecraftLoginFlow> {
+        let (key, token) = self.refresh_and_get_device_token().await?;
+
+        let challenge = generate_oauth_challenge();
+        let (session_id, redirect_uri) =
+            sisu_authenticate(&token.token, &challenge, &key).await?;
+
+        Ok(MinecraftLoginFlow {
+            challenge,
+            session_id,
+            redirect_uri: redirect_uri.msa_oauth_redirect,
+        })
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub async fn login_finish(
+        &mut self,
+        code: &str,
+        flow: MinecraftLoginFlow,
+    ) -> crate::Result<Credentials> {
+        let (key, token) = self.refresh_and_get_device_token().await?;
+
+        let oauth_token = oauth_token(code, &flow.challenge).await?;
+        let sisu_authorize = sisu_authorize(
+            Some(&flow.session_id),
+            &oauth_token.access_token,
+            &token.token,
+            &key,
+        )
+        .await?;
+
+        let xbox_token =
+            xsts_authorize(sisu_authorize, &token.token, &key).await?;
+        let minecraft_token = minecraft_token(xbox_token).await?;
+
+        minecraft_entitlements(&minecraft_token.access_token).await?;
+
+        let profile = minecraft_profile(&minecraft_token.access_token).await?;
+
+        let profile_id = profile.id.unwrap_or_default();
+
+        let credentials = Credentials {
+            id: profile_id,
+            username: profile.name,
+            access_token: minecraft_token.access_token,
+            refresh_token: oauth_token.refresh_token,
+            expires: Utc::now()
+                + Duration::seconds(oauth_token.expires_in as i64),
+        };
+
+        self.users.insert(profile_id, credentials.clone());
+
+        if self.default_user.is_none() {
+            self.default_user = Some(profile_id);
+        }
+
+        self.save().await?;
+
+        Ok(credentials)
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub async fn get_default_credential(
+        &mut self,
+    ) -> crate::Result<Option<Credentials>> {
+        let credentials = if let Some(default_user) = self.default_user {
+            if let Some(creds) = self.users.get(&default_user) {
+                Some(creds)
+            } else {
+                self.users.values().next()
+            }
+        } else {
+            self.users.values().next()
+        };
+
+        if let Some(creds) = credentials {
+            if self.default_user != Some(creds.id) {
+                self.default_user = Some(creds.id);
+                self.save().await?;
+            }
+
+            if creds.expires < Utc::now() {
+                let cred_id = creds.id;
+                let profile_name = creds.username.clone();
+
+                let oauth_token = oauth_refresh(&creds.refresh_token).await?;
+                let (key, token) = self.refresh_and_get_device_token().await?;
+
+                let sisu_authorize = sisu_authorize(
+                    None,
+                    &oauth_token.access_token,
+                    &token.token,
+                    &key,
+                )
+                .await?;
+
+                let xbox_token =
+                    xsts_authorize(sisu_authorize, &token.token, &key).await?;
+
+                let minecraft_token = minecraft_token(xbox_token).await?;
+
+                let val = Credentials {
+                    id: cred_id,
+                    username: profile_name,
+                    access_token: minecraft_token.access_token,
+                    refresh_token: oauth_token.refresh_token,
+                    expires: Utc::now()
+                        + Duration::seconds(oauth_token.expires_in as i64),
+                };
+
+                self.users.insert(val.id, val.clone());
+                self.save().await?;
+
+                Ok(Some(val))
+            } else {
+                Ok(Some(creds.clone()))
+            }
+        } else {
+            Ok(None)
+        }
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub async fn remove(
+        &mut self,
+        id: Uuid,
+    ) -> crate::Result<Option<Credentials>> {
+        let val = self.users.remove(&id);
+        self.save().await?;
+        Ok(val)
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct Credentials {
+    pub id: Uuid,
+    pub username: String,
+    pub access_token: String,
+    pub refresh_token: String,
+    pub expires: DateTime<Utc>,
+}
+
+const MICROSOFT_CLIENT_ID: &str = "00000000402b5328";
+const REDIRECT_URL: &str = "https://login.live.com/oauth20_desktop.srf";
+const REQUESTED_SCOPES: &str = "service::user.auth.xboxlive.com::MBI_SSL";
+
+// flow steps
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "PascalCase")]
+pub struct DeviceToken {
+    pub issue_instant: DateTime<Utc>,
+    pub not_after: DateTime<Utc>,
+    pub token: String,
+    pub display_claims: HashMap<String, serde_json::Value>,
+}
+
+#[tracing::instrument(skip(key))]
+pub async fn device_token(
+    key: &DeviceTokenKey,
+) -> Result<DeviceToken, MinecraftAuthenticationError> {
+    Ok(send_signed_request(
+        None,
+        "https://device.auth.xboxlive.com/device/authenticate",
+        "/device/authenticate",
+        json!({
+            "Properties": {
+                "AuthMethod": "ProofOfPossession",
+                "Id": format!("{{{}}}", key.id),
+                "DeviceType": "Win32",
+                "Version": "10.16.0",
+                "ProofKey": {
+                    "kty": "EC",
+                    "x": key.x,
+                    "y": key.y,
+                    "crv": "P-256",
+                    "alg": "ES256",
+                    "use": "sig"
+                }
+            },
+            "RelyingParty": "http://auth.xboxlive.com",
+            "TokenType": "JWT"
+
+        }),
+        key,
+        MinecraftAuthStep::GetDeviceToken,
+    )
+    .await?
+    .1)
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "PascalCase")]
+struct RedirectUri {
+    pub msa_oauth_redirect: String,
+}
+
+#[tracing::instrument(skip(key))]
+async fn sisu_authenticate(
+    token: &str,
+    challenge: &str,
+    key: &DeviceTokenKey,
+) -> Result<(String, RedirectUri), MinecraftAuthenticationError> {
+    let (headers, res) = send_signed_request(
+        None,
+        "https://sisu.xboxlive.com/authenticate",
+        "/authenticate",
+        json!({
+          "AppId": MICROSOFT_CLIENT_ID,
+          "DeviceToken": token,
+          "Offers": [
+            REQUESTED_SCOPES
+          ],
+          "Query": {
+            "code_challenge": challenge,
+            "code_challenge_method": "plain",
+            "state": "",
+            "prompt": "select_account"
+          },
+          "RedirectUri": REDIRECT_URL,
+          "Sandbox": "RETAIL",
+          "TokenType": "code",
+        }),
+        key,
+        MinecraftAuthStep::SisuAuthenicate,
+    )
+    .await?;
+
+    let session_id = headers
+        .get("X-SessionId")
+        .and_then(|x| x.to_str().ok())
+        .unwrap()
+        .to_string();
+
+    Ok((session_id, res))
+}
+
+#[derive(Deserialize)]
+struct OAuthToken {
+    // pub token_type: String,
+    pub expires_in: u64,
+    // pub scope: String,
+    pub access_token: String,
+    pub refresh_token: String,
+    // pub user_id: String,
+    // pub foci: String,
+}
+
+#[tracing::instrument]
+async fn oauth_token(
+    code: &str,
+    challenge: &str,
+) -> Result<OAuthToken, MinecraftAuthenticationError> {
+    let mut query = HashMap::new();
+    query.insert("client_id", "00000000402b5328");
+    query.insert("code", code);
+    query.insert("code_verifier", challenge);
+    query.insert("grant_type", "authorization_code");
+    query.insert("redirect_uri", "https://login.live.com/oauth20_desktop.srf");
+    query.insert("scope", "service::user.auth.xboxlive.com::MBI_SSL");
+
+    let res = auth_retry(|| {
+        REQWEST_CLIENT
+            .post("https://login.live.com/oauth20_token.srf")
+            .header("Accept", "application/json")
+            .form(&query)
+            .send()
+    })
+    .await
+    .map_err(|source| MinecraftAuthenticationError::Request {
+        source,
+        step: MinecraftAuthStep::GetOAuthToken,
+    })?;
+
+    let text = res.text().await.map_err(|source| {
+        MinecraftAuthenticationError::Request {
+            source,
+            step: MinecraftAuthStep::GetOAuthToken,
+        }
+    })?;
+
+    serde_json::from_str(&text).map_err(|source| {
+        MinecraftAuthenticationError::DeserializeResponse {
+            source,
+            raw: text,
+            step: MinecraftAuthStep::GetOAuthToken,
+        }
+    })
+}
+
+#[tracing::instrument]
+async fn oauth_refresh(
+    refresh_token: &str,
+) -> Result<OAuthToken, MinecraftAuthenticationError> {
+    let mut query = HashMap::new();
+    query.insert("client_id", "00000000402b5328");
+    query.insert("refresh_token", refresh_token);
+    query.insert("grant_type", "refresh_token");
+    query.insert("redirect_uri", "https://login.live.com/oauth20_desktop.srf");
+    query.insert("scope", "service::user.auth.xboxlive.com::MBI_SSL");
+
+    let res = auth_retry(|| {
+        REQWEST_CLIENT
+            .post("https://login.live.com/oauth20_token.srf")
+            .header("Accept", "application/json")
+            .form(&query)
+            .send()
+    })
+    .await
+    .map_err(|source| MinecraftAuthenticationError::Request {
+        source,
+        step: MinecraftAuthStep::RefreshOAuthToken,
+    })?;
+
+    let text = res.text().await.map_err(|source| {
+        MinecraftAuthenticationError::Request {
+            source,
+            step: MinecraftAuthStep::RefreshOAuthToken,
+        }
+    })?;
+
+    serde_json::from_str(&text).map_err(|source| {
+        MinecraftAuthenticationError::DeserializeResponse {
+            source,
+            raw: text,
+            step: MinecraftAuthStep::RefreshOAuthToken,
+        }
+    })
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "PascalCase")]
+struct SisuAuthorize {
+    // pub authorization_token: DeviceToken,
+    // pub device_token: String,
+    // pub sandbox: String,
+    pub title_token: DeviceToken,
+    pub user_token: DeviceToken,
+    // pub web_page: String,
+}
+
+#[tracing::instrument(skip(key))]
+async fn sisu_authorize(
+    session_id: Option<&str>,
+    access_token: &str,
+    device_token: &str,
+    key: &DeviceTokenKey,
+) -> Result<SisuAuthorize, MinecraftAuthenticationError> {
+    Ok(send_signed_request(
+        None,
+        "https://sisu.xboxlive.com/authorize",
+        "/authorize",
+        json!({
+            "AccessToken": format!("t={access_token}"),
+            "AppId": "00000000402b5328",
+            "DeviceToken": device_token,
+            "ProofKey": {
+                "kty": "EC",
+                "x": key.x,
+                "y": key.y,
+                "crv": "P-256",
+                "alg": "ES256",
+                "use": "sig"
+            },
+            "Sandbox": "RETAIL",
+            "SessionId": session_id,
+            "SiteName": "user.auth.xboxlive.com",
+        }),
+        key,
+        MinecraftAuthStep::SisuAuthorize,
+    )
+    .await?
+    .1)
+}
+
+#[tracing::instrument(skip(key))]
+async fn xsts_authorize(
+    authorize: SisuAuthorize,
+    device_token: &str,
+    key: &DeviceTokenKey,
+) -> Result<DeviceToken, MinecraftAuthenticationError> {
+    Ok(send_signed_request(
+        None,
+        "https://xsts.auth.xboxlive.com/xsts/authorize",
+        "/xsts/authorize",
+        json!({
+            "RelyingParty": "rp://api.minecraftservices.com/",
+            "TokenType": "JWT",
+            "Properties": {
+                "SandboxId": "RETAIL",
+                "UserTokens": [authorize.user_token.token],
+                "DeviceToken": device_token,
+                "TitleToken": authorize.title_token.token,
+            },
+        }),
+        key,
+        MinecraftAuthStep::XstsAuthorize,
+    )
+    .await?
+    .1)
+}
+
+#[derive(Deserialize)]
+struct MinecraftToken {
+    // pub username: String,
+    pub access_token: String,
+    // pub token_type: String,
+    // pub expires_in: u64,
+}
+
+#[tracing::instrument]
+async fn minecraft_token(
+    token: DeviceToken,
+) -> Result<MinecraftToken, MinecraftAuthenticationError> {
+    let uhs = token
+        .display_claims
+        .get("xui")
+        .and_then(|x| x.get(0))
+        .and_then(|x| x.get("uhs"))
+        .and_then(|x| x.as_str().map(String::from))
+        .ok_or_else(|| MinecraftAuthenticationError::NoUserHash)?;
+
+    let token = token.token;
+
+    let res = auth_retry(|| {
+        REQWEST_CLIENT
+            .post("https://api.minecraftservices.com/launcher/login")
+            .header("Accept", "application/json")
+            .json(&json!({
+                "platform": "PC_LAUNCHER",
+                "xtoken": format!("XBL3.0 x={uhs};{token}"),
+            }))
+            .send()
+    })
+    .await
+    .map_err(|source| MinecraftAuthenticationError::Request {
+        source,
+        step: MinecraftAuthStep::MinecraftToken,
+    })?;
+
+    let text = res.text().await.map_err(|source| {
+        MinecraftAuthenticationError::Request {
+            source,
+            step: MinecraftAuthStep::MinecraftToken,
+        }
+    })?;
+
+    serde_json::from_str(&text).map_err(|source| {
+        MinecraftAuthenticationError::DeserializeResponse {
+            source,
+            raw: text,
+            step: MinecraftAuthStep::MinecraftToken,
+        }
+    })
+}
+
+#[derive(Deserialize)]
+struct MinecraftProfile {
+    pub id: Option<Uuid>,
+    pub name: String,
+}
+
+#[tracing::instrument]
+async fn minecraft_profile(
+    token: &str,
+) -> Result<MinecraftProfile, MinecraftAuthenticationError> {
+    let res = auth_retry(|| {
+        REQWEST_CLIENT
+            .get("https://api.minecraftservices.com/minecraft/profile")
+            .header("Accept", "application/json")
+            .bearer_auth(token)
+            .send()
+    })
+    .await
+    .map_err(|source| MinecraftAuthenticationError::Request {
+        source,
+        step: MinecraftAuthStep::MinecraftProfile,
+    })?;
+
+    let text = res.text().await.map_err(|source| {
+        MinecraftAuthenticationError::Request {
+            source,
+            step: MinecraftAuthStep::MinecraftProfile,
+        }
+    })?;
+
+    serde_json::from_str(&text).map_err(|source| {
+        MinecraftAuthenticationError::DeserializeResponse {
+            source,
+            raw: text,
+            step: MinecraftAuthStep::MinecraftProfile,
+        }
+    })
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct MinecraftEntitlements {}
+
+#[tracing::instrument]
+async fn minecraft_entitlements(
+    token: &str,
+) -> Result<MinecraftEntitlements, MinecraftAuthenticationError> {
+    let res = auth_retry(|| {
+        REQWEST_CLIENT
+            .get(format!("https://api.minecraftservices.com/entitlements/license?requestId={}", Uuid::new_v4()))
+            .header("Accept", "application/json")
+            .bearer_auth(token)
+            .send()
+    })
+        .await.map_err(|source| MinecraftAuthenticationError::Request { source, step: MinecraftAuthStep::MinecraftEntitlements })?;
+
+    let text = res.text().await.map_err(|source| {
+        MinecraftAuthenticationError::Request {
+            source,
+            step: MinecraftAuthStep::MinecraftEntitlements,
+        }
+    })?;
+
+    serde_json::from_str(&text).map_err(|source| {
+        MinecraftAuthenticationError::DeserializeResponse {
+            source,
+            raw: text,
+            step: MinecraftAuthStep::MinecraftEntitlements,
+        }
+    })
+}
+
+// auth utils
+#[tracing::instrument(skip(reqwest_request))]
+async fn auth_retry<F>(
+    reqwest_request: impl Fn() -> F,
+) -> Result<reqwest::Response, reqwest::Error>
+where
+    F: Future<Output = Result<Response, reqwest::Error>>,
+{
+    const RETRY_COUNT: usize = 9; // Does command 9 times
+    const RETRY_WAIT: std::time::Duration =
+        std::time::Duration::from_millis(250);
+
+    let mut resp = reqwest_request().await?;
+    for i in 0..RETRY_COUNT {
+        if resp.status().is_success() {
+            break;
+        }
+        tracing::debug!(
+            "Request failed with status code {}, retrying...",
+            resp.status()
+        );
+        if i < RETRY_COUNT - 1 {
+            tokio::time::sleep(RETRY_WAIT).await;
+        }
+        resp = reqwest_request().await?;
+    }
+    Ok(resp)
+}
+
+pub struct DeviceTokenKey {
+    pub id: String,
+    pub key: SigningKey,
+    pub x: String,
+    pub y: String,
+}
+
+#[tracing::instrument]
+fn generate_key() -> Result<DeviceTokenKey, MinecraftAuthenticationError> {
+    let id = Uuid::new_v4().to_string();
+
+    let signing_key = SigningKey::random(&mut OsRng);
+    let public_key = VerifyingKey::from(&signing_key);
+
+    let encoded_point = public_key.to_encoded_point(false);
+
+    Ok(DeviceTokenKey {
+        id,
+        key: signing_key,
+        x: BASE64_URL_SAFE_NO_PAD.encode(encoded_point.x().unwrap()),
+        y: BASE64_URL_SAFE_NO_PAD.encode(encoded_point.y().unwrap()),
+    })
+}
+
+#[tracing::instrument(skip(key))]
+async fn send_signed_request<T: DeserializeOwned>(
+    authorization: Option<&str>,
+    url: &str,
+    url_path: &str,
+    raw_body: serde_json::Value,
+    key: &DeviceTokenKey,
+    step: MinecraftAuthStep,
+) -> Result<(HeaderMap, T), MinecraftAuthenticationError> {
+    let auth = authorization.map_or(Vec::new(), |v| v.as_bytes().to_vec());
+
+    let body = serde_json::to_vec(&raw_body).map_err(|source| {
+        MinecraftAuthenticationError::SerializeBody { source, step }
+    })?;
+    let time: u128 =
+        { ((Utc::now().timestamp() as u128) + 11644473600) * 10000000 };
+
+    use byteorder::WriteBytesExt;
+    let mut buffer = Vec::new();
+    buffer.write_u32::<BigEndian>(1).map_err(|source| {
+        MinecraftAuthenticationError::ConstructingSignedRequest { source, step }
+    })?;
+    buffer.write_u8(0).map_err(|source| {
+        MinecraftAuthenticationError::ConstructingSignedRequest { source, step }
+    })?;
+    buffer
+        .write_u64::<BigEndian>(time as u64)
+        .map_err(|source| {
+            MinecraftAuthenticationError::ConstructingSignedRequest {
+                source,
+                step,
+            }
+        })?;
+    buffer.write_u8(0).map_err(|source| {
+        MinecraftAuthenticationError::ConstructingSignedRequest { source, step }
+    })?;
+    buffer.extend_from_slice("POST".as_bytes());
+    buffer.write_u8(0).map_err(|source| {
+        MinecraftAuthenticationError::ConstructingSignedRequest { source, step }
+    })?;
+    buffer.extend_from_slice(url_path.as_bytes());
+    buffer.write_u8(0).map_err(|source| {
+        MinecraftAuthenticationError::ConstructingSignedRequest { source, step }
+    })?;
+    buffer.extend_from_slice(&auth);
+    buffer.write_u8(0).map_err(|source| {
+        MinecraftAuthenticationError::ConstructingSignedRequest { source, step }
+    })?;
+    buffer.extend_from_slice(&body);
+    buffer.write_u8(0).map_err(|source| {
+        MinecraftAuthenticationError::ConstructingSignedRequest { source, step }
+    })?;
+
+    let ecdsa_sig: Signature = key.key.sign(&buffer);
+
+    let mut sig_buffer = Vec::new();
+    sig_buffer.write_i32::<BigEndian>(1).map_err(|source| {
+        MinecraftAuthenticationError::ConstructingSignedRequest { source, step }
+    })?;
+    sig_buffer
+        .write_u64::<BigEndian>(time as u64)
+        .map_err(|source| {
+            MinecraftAuthenticationError::ConstructingSignedRequest {
+                source,
+                step,
+            }
+        })?;
+    sig_buffer.extend_from_slice(&ecdsa_sig.r().to_bytes());
+    sig_buffer.extend_from_slice(&ecdsa_sig.s().to_bytes());
+
+    let signature = BASE64_STANDARD.encode(&sig_buffer);
+
+    let res = auth_retry(|| {
+        let mut request = REQWEST_CLIENT
+            .post(url)
+            .header("Content-Type", "application/json")
+            .header("Accept", "application/json")
+            .header("x-xbl-contract-version", "1")
+            .header("signature", &signature);
+
+        if let Some(auth) = authorization {
+            request = request.header("Authorization", auth);
+        }
+
+        request.body(body.clone()).send()
+    })
+    .await
+    .map_err(|source| MinecraftAuthenticationError::Request { source, step })?;
+
+    let headers = res.headers().clone();
+    let res = res.text().await.map_err(|source| {
+        MinecraftAuthenticationError::Request { source, step }
+    })?;
+
+    let body = serde_json::from_str(&res).map_err(|source| {
+        MinecraftAuthenticationError::DeserializeResponse {
+            source,
+            raw: res,
+            step,
+        }
+    })?;
+    Ok((headers, body))
+}
+
+#[tracing::instrument]
+fn generate_oauth_challenge() -> String {
+    let mut rng = rand::thread_rng();
+
+    let bytes: Vec<u8> = (0..32).map(|_| rng.gen()).collect();
+    bytes.iter().map(|byte| format!("{:02x}", byte)).collect()
+}
--- a/theseus/src/state/mod.rs
+++ b/theseus/src/state/mod.rs
@@ -5,7 +5,6 @@ use std::path::PathBuf;
 use crate::event::LoadingBarType;
 use crate::loading_join;

-use crate::state::users::Users;
 use crate::util::fetch::{self, FetchSemaphore, IoSemaphore};
 use notify::RecommendedWatcher;
 use notify_debouncer_mini::{new_debouncer, DebounceEventResult, Debouncer};
@@ -32,14 +31,9 @@ pub use self::settings::*;
 mod projects;
 pub use self::projects::*;

-mod users;
-
 mod children;
 pub use self::children::*;

-mod auth_task;
-pub use self::auth_task::*;
-
 mod tags;
 pub use self::tags::*;

@@ -52,6 +46,9 @@ pub use self::safe_processes::*;
 mod discord;
 pub use self::discord::*;

+mod minecraft_auth;
+pub use self::minecraft_auth::*;
+
 mod mr_auth;
 pub use self::mr_auth::*;

@@ -87,9 +84,7 @@ pub struct State {
    /// Launcher processes that should be safely exited on shutdown
    pub(crate) safety_processes: RwLock<SafeProcesses>,
    /// Launcher user account info
-    pub(crate) users: RwLock<Users>,
-    /// Authentication flow
-    pub auth_flow: RwLock<AuthTask>,
+    pub(crate) users: RwLock<MinecraftAuthStore>,
    /// Modrinth Credentials Store
    pub credentials: RwLock<CredentialsStore>,
    /// Modrinth auth flow
@@ -127,6 +122,10 @@ impl State {
            .await)
    }

+    pub fn initialized() -> bool {
+        LAUNCHER_STATE.initialized()
+    }
+
    #[tracing::instrument]
    #[theseus_macros::debug_pin]
    async fn initialize_state() -> crate::Result<RwLock<State>> {
@@ -168,7 +167,7 @@ impl State {
            &fetch_semaphore,
            &CredentialsStore(None),
        );
-        let users_fut = Users::init(&directories, &io_semaphore);
+        let users_fut = MinecraftAuthStore::init(&directories, &io_semaphore);
        let creds_fut = CredentialsStore::init(&directories, &io_semaphore);
        // Launcher data
        let (metadata, profiles, tags, users, creds) = loading_join! {
@@ -180,16 +179,17 @@ impl State {
            creds_fut,
        }?;

-        let children = Children::new();
-        let auth_flow = AuthTask::new();
        let safety_processes = SafeProcesses::new();

-        let discord_rpc = DiscordGuard::init().await?;
-        {
+        let discord_rpc = DiscordGuard::init(is_offline).await?;
+        if !settings.disable_discord_rpc && !is_offline {
            // Add default Idling to discord rich presence
-            let _ = discord_rpc.set_activity("Idling...", true).await;
+            // Force add to avoid recursion
+            let _ = discord_rpc.force_set_activity("Idling...", true).await;
        }

+        let children = Children::new();
+
        // Starts a loop of checking if we are online, and updating
        Self::offine_check_loop();

@@ -211,7 +211,6 @@ impl State {
            profiles: RwLock::new(profiles),
            users: RwLock::new(users),
            children: RwLock::new(children),
-            auth_flow: RwLock::new(auth_flow),
            credentials: RwLock::new(creds),
            tags: RwLock::new(tags),
            discord_rpc,
@@ -238,11 +237,6 @@ impl State {

    /// Updates state with data from the web, if we are online
    pub fn update() {
-        tokio::task::spawn(Metadata::update());
-        tokio::task::spawn(Tags::update());
-        tokio::task::spawn(Profiles::update_projects());
-        tokio::task::spawn(Profiles::update_modrinth_versions());
-        tokio::task::spawn(CredentialsStore::update_creds());
        tokio::task::spawn(async {
            if let Ok(state) = crate::State::get().await {
                if !*state.offline.read().await {
@@ -250,10 +244,9 @@ impl State {
                    let res2 = Tags::update();
                    let res3 = Metadata::update();
                    let res4 = Profiles::update_projects();
-                    let res5 = Settings::update_java();
                    let res6 = CredentialsStore::update_creds();

-                    let _ = join!(res1, res2, res3, res4, res5, res6);
+                    let _ = join!(res1, res2, res3, res4, res6);
                }
            }
        });
@@ -346,7 +339,6 @@ pub async fn init_watcher() -> crate::Result<Debouncer<RecommendedWatcher>> {

    let file_watcher = new_debouncer(
        Duration::from_secs_f32(2.0),
-        None,
        move |res: DebounceEventResult| {
            futures::executor::block_on(async {
                tx.send(res).await.unwrap();
@@ -381,7 +373,7 @@ pub async fn init_watcher() -> crate::Result<Debouncer<RecommendedWatcher>> {

                        // At this point, new_path is the path to the profile, and subfile is whether it's a subfile of the profile or not
                        let profile_path_id =
-                            ProfilePathId::new(&PathBuf::from(
+                            ProfilePathId::new(PathBuf::from(
                                new_path.file_name().unwrap_or_default(),
                            ));

@@ -409,9 +401,7 @@ pub async fn init_watcher() -> crate::Result<Debouncer<RecommendedWatcher>> {
                        }
                    });
                }
-                Err(errors) => errors.iter().for_each(|err| {
-                    tracing::warn!("Unable to watch file: {err}")
-                }),
+                Err(error) => tracing::warn!("Unable to watch file: {error}"),
            }
        }
    });
--- a/theseus/src/state/mr_auth.rs
+++ b/theseus/src/state/mr_auth.rs
@@ -322,29 +322,6 @@ pub async fn create_account(
    get_creds_from_res(response, semaphore).await
 }

-pub async fn login_minecraft(
-    flow: &str,
-    semaphore: &FetchSemaphore,
-) -> crate::Result<ModrinthCredentialsResult> {
-    let resp = fetch_advanced(
-        Method::POST,
-        &format!("{MODRINTH_API_URL}auth/login/minecraft"),
-        None,
-        Some(serde_json::json!({
-            "flow": flow,
-        })),
-        None,
-        None,
-        semaphore,
-        &CredentialsStore(None),
-    )
-    .await?;
-
-    let response = serde_json::from_slice::<HashMap<String, Value>>(&resp)?;
-
-    get_result_from_res("session", response, semaphore).await
-}
-
 pub async fn refresh_credentials(
    credentials_store: &mut CredentialsStore,
    semaphore: &FetchSemaphore,
@@ -374,6 +351,7 @@ pub async fn refresh_credentials(
        }
    }

+    credentials_store.save().await?;
    Ok(())
 }

--- a/theseus/src/state/profiles.rs
+++ b/theseus/src/state/profiles.rs
@@ -72,8 +72,8 @@ impl ProfilePathId {
    }

    // Create a new ProfilePathId from a relative path
-    pub fn new(path: &Path) -> Self {
-        ProfilePathId(PathBuf::from(path))
+    pub fn new(path: impl Into<PathBuf>) -> Self {
+        ProfilePathId(path.into())
    }

    pub async fn get_full_path(&self) -> crate::Result<PathBuf> {
@@ -95,6 +95,45 @@ impl std::fmt::Display for ProfilePathId {
    }
 }

+#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq, Hash)]
+#[serde(into = "RawProjectPath", from = "RawProjectPath")]
+pub struct InnerProjectPathUnix(pub String);
+
+impl InnerProjectPathUnix {
+    pub fn get_topmost_two_components(&self) -> String {
+        self.to_string()
+            .split('/')
+            .take(2)
+            .collect::<Vec<_>>()
+            .join("/")
+    }
+}
+
+impl std::fmt::Display for InnerProjectPathUnix {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl From<RawProjectPath> for InnerProjectPathUnix {
+    fn from(value: RawProjectPath) -> Self {
+        // Convert windows path to unix path.
+        // .mrpacks no longer generate windows paths, but this is here for backwards compatibility before this was fixed
+        // https://github.com/modrinth/theseus/issues/595
+        InnerProjectPathUnix(value.0.replace('\\', "/"))
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(transparent)]
+struct RawProjectPath(pub String);
+
+impl From<InnerProjectPathUnix> for RawProjectPath {
+    fn from(value: InnerProjectPathUnix) -> Self {
+        RawProjectPath(value.0)
+    }
+}
+
 /// newtype wrapper over a Profile path, to be usable as a clear identifier for the kind of path used
 /// eg: for "a/b/c/profiles/My Mod/mods/myproj", the ProjectPathId would be "mods/myproj"
 #[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq, Hash)]
@@ -102,11 +141,14 @@ impl std::fmt::Display for ProfilePathId {
 pub struct ProjectPathId(pub PathBuf);
 impl ProjectPathId {
    // Create a new ProjectPathId from a full file path
-    pub async fn from_fs_path(path: PathBuf) -> crate::Result<Self> {
-        let path: PathBuf = io::canonicalize(path)?;
-        let profiles_dir: PathBuf = io::canonicalize(
+    pub async fn from_fs_path(path: &PathBuf) -> crate::Result<Self> {
+        // This is avoiding dunce::canonicalize deliberately. On Windows, paths will always be convert to UNC,
+        // but this is ok because we are stripping that with the prefix. Using std::fs avoids different behaviors with dunce that
+        // come with too-long paths
+        let profiles_dir: PathBuf = std::fs::canonicalize(
            State::get().await?.directories.profiles_dir().await,
        )?;
+        let path: PathBuf = std::fs::canonicalize(path)?;
        let path = path
            .strip_prefix(profiles_dir)
            .ok()
@@ -124,11 +166,23 @@ impl ProjectPathId {
        &self,
        profile: ProfilePathId,
    ) -> crate::Result<PathBuf> {
-        let _state = State::get().await?;
        let profile_dir = profile.get_full_path().await?;
        Ok(profile_dir.join(&self.0))
    }

+    // Gets inner path in unix convention as a String
+    // ie: 'mods\myproj' -> 'mods/myproj'
+    // Used for exporting to mrpack, which should have a singular convention
+    pub fn get_inner_path_unix(&self) -> InnerProjectPathUnix {
+        InnerProjectPathUnix(
+            self.0
+                .components()
+                .map(|c| c.as_os_str().to_string_lossy().to_string())
+                .collect::<Vec<_>>()
+                .join("/"),
+        )
+    }
+
    // Create a new ProjectPathId from a relative path
    pub fn new(path: &Path) -> Self {
        ProjectPathId(PathBuf::from(path))
@@ -193,6 +247,15 @@ pub struct ProfileMetadata {
 pub struct LinkedData {
    pub project_id: Option<String>,
    pub version_id: Option<String>,
+
+    #[serde(default = "default_locked")]
+    pub locked: Option<bool>,
+}
+
+// Called if linked_data is present but locked is not
+// Meaning this is a legacy profile, and we should consider it locked
+pub fn default_locked() -> Option<bool> {
+    Some(true)
 }

 #[derive(
@@ -205,6 +268,7 @@ pub enum ModLoader {
    Forge,
    Fabric,
    Quilt,
+    NeoForge,
 }

 impl std::fmt::Display for ModLoader {
@@ -214,6 +278,7 @@ impl std::fmt::Display for ModLoader {
            Self::Forge => "Forge",
            Self::Fabric => "Fabric",
            Self::Quilt => "Quilt",
+            Self::NeoForge => "NeoForge",
        })
    }
 }
@@ -225,6 +290,7 @@ impl ModLoader {
            Self::Forge => "forge",
            Self::Fabric => "fabric",
            Self::Quilt => "quilt",
+            Self::NeoForge => "neoforge",
        }
    }
 }
@@ -719,7 +785,15 @@ impl Profiles {
                        None
                    }
                };
+
                if let Some(profile) = prof {
+                    // Clear out modrinth_logs of all files in profiles folder (these are legacy)
+                    // TODO: should be removed in a future build
+                    let modrinth_logs = path.join("modrinth_logs");
+                    if modrinth_logs.exists() {
+                        let _ = std::fs::remove_dir_all(modrinth_logs);
+                    }
+
                    let path = io::canonicalize(path)?;
                    Profile::watch_fs(&path, file_watcher).await?;
                    profiles.insert(profile.profile_id(), profile);
@@ -818,8 +892,6 @@ impl Profiles {
            // Fetch online from Modrinth each latest version
            future::try_join_all(modrinth_updatables.into_iter().map(
                |(profile_path, linked_project)| {
-                    let profile_path = profile_path;
-                    let linked_project = linked_project;
                    let state = state.clone();
                    async move {
                        let creds = state.credentials.read().await;
--- a/theseus/src/state/projects.rs
+++ b/theseus/src/state/projects.rs
@@ -228,38 +228,29 @@ async fn read_icon_from_file(
        let zip_file_reader = ZipFileReader::new(path).await;
        if let Ok(zip_file_reader) = zip_file_reader {
            // Get index of icon file and open it
-            let zip_index_option = zip_file_reader
-                .file()
-                .entries()
-                .iter()
-                .position(|f| f.entry().filename() == icon_path);
-            if let Some(index) = zip_index_option {
-                let entry = zip_file_reader
-                    .file()
-                    .entries()
-                    .get(index)
-                    .unwrap()
-                    .entry();
-                let mut bytes = Vec::new();
-                if zip_file_reader
-                    .entry(zip_index_option.unwrap())
-                    .await?
-                    .read_to_end_checked(&mut bytes, entry)
-                    .await
-                    .is_ok()
-                {
-                    let bytes = bytes::Bytes::from(bytes);
-                    let path = write_cached_icon(
-                        &icon_path,
-                        cache_dir,
-                        bytes,
-                        io_semaphore,
-                    )
-                    .await?;
+            let zip_index_option =
+                zip_file_reader.file().entries().iter().position(|f| {
+                    f.filename().as_str().unwrap_or_default() == icon_path
+                });
+            let mut bytes = Vec::new();
+            if zip_file_reader
+                .reader_with_entry(zip_index_option.unwrap())
+                .await?
+                .read_to_end_checked(&mut bytes)
+                .await
+                .is_ok()
+            {
+                let bytes = bytes::Bytes::from(bytes);
+                let path = write_cached_icon(
+                    &icon_path,
+                    cache_dir,
+                    bytes,
+                    io_semaphore,
+                )
+                .await?;

-                    return Ok(Some(path));
-                }
-            };
+                return Ok(Some(path));
+            }
        }
    }

@@ -464,13 +455,12 @@ pub async fn infer_data_from_files(
        };

        // Forge
-        let zip_index_option = zip_file_reader
-            .file()
-            .entries()
-            .iter()
-            .position(|f| f.entry().filename() == "META-INF/mods.toml");
+        let zip_index_option =
+            zip_file_reader.file().entries().iter().position(|f| {
+                f.filename().as_str().unwrap_or_default()
+                    == "META-INF/mods.toml"
+            });
        if let Some(index) = zip_index_option {
-            let file = zip_file_reader.file().entries().get(index).unwrap();
            #[derive(Deserialize)]
            #[serde(rename_all = "camelCase")]
            struct ForgeModInfo {
@@ -489,9 +479,9 @@ pub async fn infer_data_from_files(

            let mut file_str = String::new();
            if zip_file_reader
-                .entry(index)
+                .reader_with_entry(index)
                .await?
-                .read_to_string_checked(&mut file_str, file.entry())
+                .read_to_string_checked(&mut file_str)
                .await
                .is_ok()
            {
@@ -538,13 +528,11 @@ pub async fn infer_data_from_files(
        }

        // Forge
-        let zip_index_option = zip_file_reader
-            .file()
-            .entries()
-            .iter()
-            .position(|f| f.entry().filename() == "mcmod.info");
+        let zip_index_option =
+            zip_file_reader.file().entries().iter().position(|f| {
+                f.filename().as_str().unwrap_or_default() == "mcmod.info"
+            });
        if let Some(index) = zip_index_option {
-            let file = zip_file_reader.file().entries().get(index).unwrap();
            #[derive(Deserialize)]
            #[serde(rename_all = "camelCase")]
            struct ForgeMod {
@@ -558,9 +546,9 @@ pub async fn infer_data_from_files(

            let mut file_str = String::new();
            if zip_file_reader
-                .entry(index)
+                .reader_with_entry(index)
                .await?
-                .read_to_string_checked(&mut file_str, file.entry())
+                .read_to_string_checked(&mut file_str)
                .await
                .is_ok()
            {
@@ -599,13 +587,11 @@ pub async fn infer_data_from_files(
        }

        // Fabric
-        let zip_index_option = zip_file_reader
-            .file()
-            .entries()
-            .iter()
-            .position(|f| f.entry().filename() == "fabric.mod.json");
+        let zip_index_option =
+            zip_file_reader.file().entries().iter().position(|f| {
+                f.filename().as_str().unwrap_or_default() == "fabric.mod.json"
+            });
        if let Some(index) = zip_index_option {
-            let file = zip_file_reader.file().entries().get(index).unwrap();
            #[derive(Deserialize)]
            #[serde(untagged)]
            enum FabricAuthor {
@@ -625,9 +611,9 @@ pub async fn infer_data_from_files(

            let mut file_str = String::new();
            if zip_file_reader
-                .entry(index)
+                .reader_with_entry(index)
                .await?
-                .read_to_string_checked(&mut file_str, file.entry())
+                .read_to_string_checked(&mut file_str)
                .await
                .is_ok()
            {
@@ -669,13 +655,11 @@ pub async fn infer_data_from_files(
        }

        // Quilt
-        let zip_index_option = zip_file_reader
-            .file()
-            .entries()
-            .iter()
-            .position(|f| f.entry().filename() == "quilt.mod.json");
+        let zip_index_option =
+            zip_file_reader.file().entries().iter().position(|f| {
+                f.filename().as_str().unwrap_or_default() == "quilt.mod.json"
+            });
        if let Some(index) = zip_index_option {
-            let file = zip_file_reader.file().entries().get(index).unwrap();
            #[derive(Deserialize)]
            struct QuiltMetadata {
                pub name: Option<String>,
@@ -692,9 +676,9 @@ pub async fn infer_data_from_files(

            let mut file_str = String::new();
            if zip_file_reader
-                .entry(index)
+                .reader_with_entry(index)
                .await?
-                .read_to_string_checked(&mut file_str, file.entry())
+                .read_to_string_checked(&mut file_str)
                .await
                .is_ok()
            {
@@ -746,13 +730,11 @@ pub async fn infer_data_from_files(
        }

        // Other
-        let zip_index_option = zip_file_reader
-            .file()
-            .entries()
-            .iter()
-            .position(|f| f.entry().filename() == "pack.mcmeta");
+        let zip_index_option =
+            zip_file_reader.file().entries().iter().position(|f| {
+                f.filename().as_str().unwrap_or_default() == "pack.mcmeta"
+            });
        if let Some(index) = zip_index_option {
-            let file = zip_file_reader.file().entries().get(index).unwrap();
            #[derive(Deserialize)]
            struct Pack {
                description: Option<String>,
@@ -760,9 +742,9 @@ pub async fn infer_data_from_files(

            let mut file_str = String::new();
            if zip_file_reader
-                .entry(index)
+                .reader_with_entry(index)
                .await?
-                .read_to_string_checked(&mut file_str, file.entry())
+                .read_to_string_checked(&mut file_str)
                .await
                .is_ok()
            {
@@ -815,7 +797,7 @@ pub async fn infer_data_from_files(
    let mut corrected_hashmap = HashMap::new();
    let mut stream = tokio_stream::iter(return_projects);
    while let Some((h, v)) = stream.next().await {
-        let h = ProjectPathId::from_fs_path(h).await?;
+        let h = ProjectPathId::from_fs_path(&h).await?;
        corrected_hashmap.insert(h, v);
    }

--- a/theseus/src/state/settings.rs
+++ b/theseus/src/state/settings.rs
@@ -1,8 +1,4 @@
 //! Theseus settings file
-use crate::{
-    jre::{self, autodetect_java_globals, find_filtered_jres},
-    State,
-};
 use serde::{Deserialize, Serialize};
 use std::path::{Path, PathBuf};
 use tokio::fs;
@@ -24,15 +20,18 @@ pub struct Settings {
    pub custom_java_args: Vec<String>,
    pub custom_env_args: Vec<(String, String)>,
    pub java_globals: JavaGlobals,
-    pub default_user: Option<uuid::Uuid>,
    pub hooks: Hooks,
    pub max_concurrent_downloads: usize,
    pub max_concurrent_writes: usize,
    pub version: u32,
    pub collapsed_navigation: bool,
    #[serde(default)]
+    pub disable_discord_rpc: bool,
+    #[serde(default)]
    pub hide_on_process: bool,
    #[serde(default)]
+    pub native_decorations: bool,
+    #[serde(default)]
    pub default_page: DefaultPage,
    #[serde(default)]
    pub developer_mode: bool,
@@ -49,8 +48,10 @@ pub struct Settings {
 impl Settings {
    #[tracing::instrument]
    pub async fn init(file: &Path) -> crate::Result<Self> {
-        if file.exists() {
-            fs::read(&file)
+        let mut rescued = false;
+
+        let settings = if file.exists() {
+            let loaded_settings = fs::read(&file)
                .await
                .map_err(|err| {
                    crate::ErrorKind::FSError(format!(
@@ -61,9 +62,25 @@ impl Settings {
                .and_then(|it| {
                    serde_json::from_slice::<Settings>(&it)
                        .map_err(crate::Error::from)
-                })
+                });
+            // settings is corrupted. Back up the file and create a new one
+            if let Err(ref err) = loaded_settings {
+                tracing::error!("Failed to load settings file: {err}. ");
+                let backup_file = file.with_extension("json.bak");
+                tracing::error!("Corrupted settings file will be backed up as {}, and a new settings file will be created.", backup_file.display());
+                let _ = fs::rename(file, backup_file).await;
+                rescued = true;
+            }
+            loaded_settings.ok()
        } else {
-            Ok(Self {
+            None
+        };
+
+        if let Some(settings) = settings {
+            Ok(settings)
+        } else {
+            // Create new settings file
+            let settings = Self {
                theme: Theme::Dark,
                memory: MemorySettings::default(),
                force_fullscreen: false,
@@ -71,57 +88,28 @@ impl Settings {
                custom_java_args: Vec::new(),
                custom_env_args: Vec::new(),
                java_globals: JavaGlobals::new(),
-                default_user: None,
                hooks: Hooks::default(),
                max_concurrent_downloads: 10,
                max_concurrent_writes: 10,
                version: CURRENT_FORMAT_VERSION,
                collapsed_navigation: false,
+                disable_discord_rpc: false,
                hide_on_process: false,
+                native_decorations: false,
                default_page: DefaultPage::Home,
                developer_mode: false,
                opt_out_analytics: false,
                advanced_rendering: true,
-                fully_onboarded: false,
+                fully_onboarded: rescued, // If we rescued the settings file, we should consider the user fully onboarded

                // By default, the config directory is the same as the settings directory
                loaded_config_dir: DirectoryInfo::get_initial_settings_dir(),
-            })
-        }
-    }
-
-    #[tracing::instrument]
-    #[theseus_macros::debug_pin]
-    pub async fn update_java() {
-        let res = async {
-            let state = State::get().await?;
-            let settings_read = state.settings.write().await;
-
-            if settings_read.java_globals.count() == 0 {
-                drop(settings_read);
-                let jres = jre::get_all_jre().await?;
-                let java_8 =
-                    find_filtered_jres("1.8", jres.clone(), false).await?;
-                let java_17 =
-                    find_filtered_jres("1.17", jres.clone(), false).await?;
-                let java_18plus =
-                    find_filtered_jres("1.18", jres.clone(), true).await?;
-                let java_globals =
-                    autodetect_java_globals(java_8, java_17, java_18plus)
-                        .await?;
-                state.settings.write().await.java_globals = java_globals;
+            };
+            if rescued {
+                settings.sync(file).await?;
            }
-
-            Ok::<(), crate::Error>(())
+            Ok(settings)
        }
-        .await;
-
-        match res {
-            Ok(()) => {}
-            Err(err) => {
-                tracing::warn!("Unable to update launcher java: {err}")
-            }
-        };
    }

    #[tracing::instrument(skip(self))]
--- a/theseus/src/state/tags.rs
+++ b/theseus/src/state/tags.rs
@@ -32,6 +32,8 @@ impl Tags {
    ) -> crate::Result<Self> {
        let mut tags = None;
        let tags_path = dirs.caches_meta_dir().await.join("tags.json");
+        let tags_path_backup =
+            dirs.caches_meta_dir().await.join("tags.json.bak");

        if let Ok(tags_json) = read_json::<Self>(&tags_path, io_semaphore).await
        {
@@ -43,11 +45,28 @@ impl Tags {
                    tracing::warn!("Unable to fetch launcher tags: {err}")
                }
            }
+        } else if let Ok(tags_json) =
+            read_json::<Self>(&tags_path_backup, io_semaphore).await
+        {
+            tags = Some(tags_json);
+            std::fs::copy(&tags_path_backup, &tags_path).map_err(|err| {
+                crate::ErrorKind::FSError(format!(
+                    "Error restoring tags backup: {err}"
+                ))
+                .as_error()
+            })?;
        }

        if let Some(tags_data) = tags {
            write(&tags_path, &serde_json::to_vec(&tags_data)?, io_semaphore)
                .await?;
+            write(
+                &tags_path_backup,
+                &serde_json::to_vec(&tags_data)?,
+                io_semaphore,
+            )
+            .await?;
+
            Ok(tags_data)
        } else {
            Err(crate::ErrorKind::NoValueFor(String::from("launcher tags"))
@@ -68,6 +87,14 @@ impl Tags {

            let tags_path =
                state.directories.caches_meta_dir().await.join("tags.json");
+            let tags_path_backup = state
+                .directories
+                .caches_meta_dir()
+                .await
+                .join("tags.json.bak");
+            if tags_path.exists() {
+                std::fs::copy(&tags_path, &tags_path_backup).unwrap();
+            }

            write(
                &tags_path,
--- a/theseus/src/state/users.rs
+++ b/theseus/src/state/users.rs
@@ -1,70 +0,0 @@
-//! User login info
-use crate::auth::Credentials;
-use crate::data::DirectoryInfo;
-use crate::util::fetch::{read_json, write, IoSemaphore};
-use crate::State;
-use std::collections::HashMap;
-use uuid::Uuid;
-
-const USERS_JSON: &str = "users.json";
-
-/// The set of users stored in the launcher
-#[derive(Clone)]
-pub(crate) struct Users(pub(crate) HashMap<Uuid, Credentials>);
-
-impl Users {
-    pub async fn init(
-        dirs: &DirectoryInfo,
-        io_semaphore: &IoSemaphore,
-    ) -> crate::Result<Self> {
-        let users_path = dirs.caches_meta_dir().await.join(USERS_JSON);
-        let users = read_json(&users_path, io_semaphore).await.ok();
-
-        if let Some(users) = users {
-            Ok(Self(users))
-        } else {
-            Ok(Self(HashMap::new()))
-        }
-    }
-
-    pub async fn save(&self) -> crate::Result<()> {
-        let state = State::get().await?;
-        let users_path =
-            state.directories.caches_meta_dir().await.join(USERS_JSON);
-        write(
-            &users_path,
-            &serde_json::to_vec(&self.0)?,
-            &state.io_semaphore,
-        )
-        .await?;
-
-        Ok(())
-    }
-
-    #[tracing::instrument(skip_all)]
-    pub async fn insert(
-        &mut self,
-        credentials: &Credentials,
-    ) -> crate::Result<&Self> {
-        self.0.insert(credentials.id, credentials.clone());
-        self.save().await?;
-        Ok(self)
-    }
-
-    #[tracing::instrument(skip(self))]
-    pub fn contains(&self, id: Uuid) -> bool {
-        self.0.contains_key(&id)
-    }
-
-    #[tracing::instrument(skip(self))]
-    pub fn get(&self, id: Uuid) -> Option<Credentials> {
-        self.0.get(&id).cloned()
-    }
-
-    #[tracing::instrument(skip(self))]
-    pub async fn remove(&mut self, id: Uuid) -> crate::Result<&Self> {
-        self.0.remove(&id);
-        self.save().await?;
-        Ok(self)
-    }
-}
--- a/theseus/src/util/fetch.rs
+++ b/theseus/src/util/fetch.rs
@@ -20,7 +20,7 @@ pub struct IoSemaphore(pub RwLock<Semaphore>);
 pub struct FetchSemaphore(pub RwLock<Semaphore>);

 lazy_static! {
-    static ref REQWEST_CLIENT: reqwest::Client = {
+    pub static ref REQWEST_CLIENT: reqwest::Client = {
        let mut headers = reqwest::header::HeaderMap::new();
        let header = reqwest::header::HeaderValue::from_str(&format!(
            "modrinth/theseus/{} (support@modrinth.com)",
@@ -337,7 +337,7 @@ pub async fn write_cached_icon(

 async fn sha1_async(bytes: Bytes) -> crate::Result<String> {
    let hash = tokio::task::spawn_blocking(move || {
-        sha1::Sha1::from(bytes).hexdigest()
+        sha1_smol::Sha1::from(bytes).hexdigest()
    })
    .await?;

--- a/theseus/src/util/io.rs
+++ b/theseus/src/util/io.rs
@@ -1,7 +1,10 @@
 // IO error
 // A wrapper around the tokio IO functions that adds the path to the error message, instead of the uninformative std::io::Error.

-use std::path::Path;
+use std::{io::Write, path::Path};
+
+use tempfile::NamedTempFile;
+use tokio::task::spawn_blocking;

 #[derive(Debug, thiserror::Error)]
 pub enum IOError {
@@ -113,15 +116,40 @@ pub async fn write(
    path: impl AsRef<std::path::Path>,
    data: impl AsRef<[u8]>,
 ) -> Result<(), IOError> {
-    let path = path.as_ref();
-    tokio::fs::write(path, data)
-        .await
-        .map_err(|e| IOError::IOPathError {
+    let path = path.as_ref().to_owned();
+    let data = data.as_ref().to_owned();
+    spawn_blocking(move || {
+        let cloned_path = path.clone();
+        sync_write(data, path).map_err(|e| IOError::IOPathError {
            source: e,
-            path: path.to_string_lossy().to_string(),
+            path: cloned_path.to_string_lossy().to_string(),
        })
+    })
+    .await
+    .map_err(|_| {
+        std::io::Error::new(std::io::ErrorKind::Other, "background task failed")
+    })??;
+
+    Ok(())
 }

+fn sync_write(
+    data: impl AsRef<[u8]>,
+    path: impl AsRef<Path>,
+) -> Result<(), std::io::Error> {
+    let mut tempfile =
+        NamedTempFile::new_in(path.as_ref().parent().ok_or_else(|| {
+            std::io::Error::new(
+                std::io::ErrorKind::Other,
+                "could not get parent directory for temporary file",
+            )
+        })?)?;
+    tempfile.write_all(data.as_ref())?;
+    let tmp_path = tempfile.into_temp_path();
+    let path = path.as_ref();
+    tmp_path.persist(path)?;
+    std::io::Result::Ok(())
+}
 // rename
 pub async fn rename(
    from: impl AsRef<std::path::Path>,
--- a/theseus/src/util/jre.rs
+++ b/theseus/src/util/jre.rs
@@ -43,7 +43,9 @@ pub async fn get_all_jre() -> Result<Vec<JavaVersion>, JREError> {
        r"C:\Program Files (x86)\Eclipse Adoptium",
    ];
    for java_path in java_paths {
-        let Ok(java_subpaths) = std::fs::read_dir(java_path) else {continue };
+        let Ok(java_subpaths) = std::fs::read_dir(java_path) else {
+            continue;
+        };
        for java_subpath in java_subpaths.flatten() {
            let path = java_subpath.path();
            jre_paths.insert(path.join("bin"));
@@ -97,7 +99,7 @@ pub fn get_paths_from_jre_winregkey(jre_key: RegKey) -> HashSet<PathBuf> {
            for subkey_value in subkey_value_names {
                let path: Result<String, std::io::Error> =
                    subkey.get_value(subkey_value);
-                let Ok(path) = path else {continue};
+                let Ok(path) = path else { continue };

                jre_paths.insert(PathBuf::from(path).join("bin"));
            }
@@ -264,7 +266,9 @@ pub async fn check_java_at_filepaths(
 pub async fn check_java_at_filepath(path: &Path) -> Option<JavaVersion> {
    // Attempt to canonicalize the potential java filepath
    // If it fails, this path does not exist and None is returned (no Java here)
-    let Ok(path) = io::canonicalize(path) else { return None };
+    let Ok(path) = io::canonicalize(path) else {
+        return None;
+    };

    // Checks for existence of Java at this filepath
    // Adds JAVA_BIN to the end of the path if it is not already there
--- a/theseus/src/util/platform.rs
+++ b/theseus/src/util/platform.rs
@@ -56,7 +56,12 @@ pub const ARCH_WIDTH: &str = "64";
 pub const ARCH_WIDTH: &str = "32";

 // Platform rule handling
-pub fn os_rule(rule: &OsRule, java_arch: &str) -> bool {
+pub fn os_rule(
+    rule: &OsRule,
+    java_arch: &str,
+    // Minecraft updated over 1.18.2 (supports MacOS Natively)
+    minecraft_updated: bool,
+) -> bool {
    let mut rule_match = true;

    if let Some(ref arch) = rule.arch {
@@ -64,8 +69,14 @@ pub fn os_rule(rule: &OsRule, java_arch: &str) -> bool {
    }

    if let Some(name) = &rule.name {
-        rule_match &=
-            &Os::native() == name || &Os::native_arch(java_arch) == name;
+        if minecraft_updated
+            && (name != &Os::LinuxArm64 || name != &Os::LinuxArm32)
+        {
+            rule_match &=
+                &Os::native() == name || &Os::native_arch(java_arch) == name;
+        } else {
+            rule_match &= &Os::native_arch(java_arch) == name;
+        }
    }

    if let Some(version) = &rule.version {
--- a/theseus_cli/Cargo.toml
+++ b/theseus_cli/Cargo.toml
@@ -1,34 +0,0 @@
-[package]
-name = "theseus_cli"
-version = "0.5.1"
-authors = ["Jai A <jaiagr+gpg@pm.me>"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-theseus = { path = "../theseus", features = ["cli"] }
-daedalus = {version = "0.1.15", features = ["bincode"]}
-tokio = { version = "1", features = ["full"] }
-tokio-stream = { version = "0.1", features = ["fs"] }
-futures = "0.3"
-argh = "0.1"
-paris = { version = "1.5", features = ["macros", "no_logger"] }
-dialoguer = "0.10"
-tabled = "0.5"
-dirs = "4.0"
-uuid = {version = "1.1", features = ["v4", "serde"]}
-url = "2.2"
-
-color-eyre = "0.6"
-eyre = "0.6"
-tracing = "0.1"
-tracing-error = "0.2"
-tracing-futures = "0.2"
-tracing-subscriber = {version = "0.3", features = ["env-filter"]}
-dunce = "1.0.3"
-
-webbrowser = "0.7"
-
-[target.'cfg(windows)'.dependencies] 
-winreg = "0.11.0"
--- a/theseus_cli/src/main.rs
+++ b/theseus_cli/src/main.rs
@@ -1,52 +0,0 @@
-use eyre::Result;
-use futures::TryFutureExt;
-use paris::*;
-use tracing_error::ErrorLayer;
-use tracing_futures::WithSubscriber;
-use tracing_subscriber::prelude::*;
-use tracing_subscriber::{fmt, EnvFilter};
-
-#[macro_use]
-mod util;
-
-mod subcommands;
-
-#[derive(argh::FromArgs, Debug)]
-/// The official Modrinth CLI
-pub struct Args {
-    #[argh(subcommand)]
-    pub subcommand: subcommands::Subcommand,
-}
-
-#[tracing::instrument]
-fn main() -> Result<()> {
-    let args = argh::from_env::<Args>();
-
-    color_eyre::install()?;
-    let filter = EnvFilter::try_from_default_env()
-        .or_else(|_| EnvFilter::try_new("info"))?;
-
-    let format = fmt::layer()
-        .without_time()
-        .with_writer(std::io::stderr)
-        .with_target(false)
-        .compact();
-
-    tracing_subscriber::registry()
-        .with(format)
-        .with(filter)
-        .with(ErrorLayer::default())
-        .init();
-
-    tokio::runtime::Builder::new_multi_thread()
-        .enable_all()
-        .build()?
-        .block_on(
-            async move {
-                args.dispatch()
-                    .inspect_err(|_| error!("An error has occurred!\n"))
-                    .await
-            }
-            .with_current_subscriber(),
-        )
-}
--- a/theseus_cli/src/subcommands/mod.rs
+++ b/theseus_cli/src/subcommands/mod.rs
@@ -1,20 +0,0 @@
-use eyre::Result;
-
-mod profile;
-mod user;
-
-#[derive(argh::FromArgs, Debug)]
-#[argh(subcommand)]
-pub enum Subcommand {
-    Profile(profile::ProfileCommand),
-    User(user::UserCommand),
-}
-
-impl crate::Args {
-    pub async fn dispatch(&self) -> Result<()> {
-        dispatch!(self.subcommand, (self) => {
-            Subcommand::Profile,
-            Subcommand::User
-        })
-    }
-}
--- a/theseus_cli/src/subcommands/profile.rs
+++ b/theseus_cli/src/subcommands/profile.rs
@@ -1,369 +0,0 @@
-//! Profile management subcommand
-use crate::util::{
-    confirm_async, prompt_async, select_async, table, table_path_display,
-};
-use daedalus::modded::LoaderVersion;
-use dunce::canonicalize;
-use eyre::{ensure, Result};
-use futures::prelude::*;
-use paris::*;
-use std::path::{Path, PathBuf};
-use tabled::Tabled;
-use theseus::prelude::*;
-use theseus::profile::create::profile_create;
-use tokio::fs;
-use tokio_stream::wrappers::ReadDirStream;
-
-#[derive(argh::FromArgs, Debug)]
-#[argh(subcommand, name = "profile")]
-/// manage Minecraft instances
-pub struct ProfileCommand {
-    #[argh(subcommand)]
-    action: ProfileSubcommand,
-}
-
-#[derive(argh::FromArgs, Debug)]
-#[argh(subcommand)]
-pub enum ProfileSubcommand {
-    Init(ProfileInit),
-    List(ProfileList),
-    Remove(ProfileRemove),
-    Run(ProfileRun),
-}
-
-#[derive(argh::FromArgs, Debug)]
-#[argh(subcommand, name = "init")]
-/// create a new profile and manage it with Theseus
-pub struct ProfileInit {
-    #[argh(positional, default = "std::env::current_dir().unwrap()")]
-    /// the path of the newly created profile
-    path: PathBuf,
-
-    #[argh(option)]
-    /// the name of the profile
-    name: Option<String>,
-
-    #[argh(option)]
-    /// the game version of the profile
-    game_version: Option<String>,
-
-    #[argh(option, from_str_fn(modloader_from_str))]
-    /// the modloader to use
-    modloader: Option<ModLoader>,
-
-    #[argh(option)]
-    /// the modloader version to use, set to "latest", "stable", or the ID of your chosen loader
-    loader_version: Option<String>,
-}
-
-impl ProfileInit {
-    pub async fn run(
-        &self,
-        _args: &crate::Args,
-        _largs: &ProfileCommand,
-    ) -> Result<()> {
-        // TODO: validate inputs from args early
-        let state = State::get().await?;
-        let metadata = state.metadata.read().await;
-
-        if self.path.exists() {
-            ensure!(
-                self.path.is_dir(),
-                "Attempted to create profile in something other than a folder!"
-            );
-            ensure!(
-                !self.path.join("profile.json").exists(),
-                "Profile already exists! Perhaps you want `profile add` instead?"
-            );
-            if ReadDirStream::new(fs::read_dir(&self.path).await?)
-                .next()
-                .await
-                .is_some()
-            {
-                warn!("You are trying to create a profile in a non-empty directory. If this is an instance from another launcher, please be sure to properly fill the profile.json fields!");
-                if !confirm_async(
-                    String::from("Do you wish to continue"),
-                    false,
-                )
-                .await?
-                {
-                    eyre::bail!("Aborted!");
-                }
-            }
-        } else {
-            fs::create_dir_all(&self.path).await?;
-        }
-        info!(
-            "Creating profile at path {}",
-            &canonicalize(&self.path)?.display()
-        );
-
-        // TODO: abstract default prompting
-        let name = match &self.name {
-            Some(name) => name.clone(),
-            None => {
-                let default = self.path.file_name().unwrap().to_string_lossy();
-
-                prompt_async(
-                    String::from("Instance name"),
-                    Some(default.into_owned()),
-                )
-                .await?
-            }
-        };
-
-        let game_version = match &self.game_version {
-            Some(version) => version.clone(),
-            None => {
-                let default = &metadata.minecraft.latest.release;
-
-                prompt_async(
-                    String::from("Game version"),
-                    Some(default.clone()),
-                )
-                .await?
-            }
-        };
-
-        let loader = match &self.modloader {
-            Some(loader) => *loader,
-            None => {
-                let choice = select_async(
-                    "Modloader".to_owned(),
-                    &["vanilla", "fabric", "forge"],
-                )
-                .await?;
-
-                match choice {
-                    0 => ModLoader::Vanilla,
-                    1 => ModLoader::Fabric,
-                    2 => ModLoader::Forge,
-                    _ => eyre::bail!(
-                        "Invalid modloader ID: {choice}. This is a bug in the launcher!"
-                    ),
-                }
-            }
-        };
-
-        let loader = if loader != ModLoader::Vanilla {
-            let version = match &self.loader_version {
-                Some(version) => String::from(version),
-                None => prompt_async(
-                    String::from(
-                        "Modloader version (latest, stable, or a version ID)",
-                    ),
-                    Some(String::from("latest")),
-                )
-                .await?,
-            };
-
-            let filter = |it: &LoaderVersion| match version.as_str() {
-                "latest" => true,
-                "stable" => it.stable,
-                id => it.id == *id,
-            };
-
-            let loader_data = match loader {
-                ModLoader::Forge => &metadata.forge,
-                ModLoader::Fabric => &metadata.fabric,
-                _ => eyre::bail!("Could not get manifest for loader {loader}. This is a bug in the CLI!"),
-            };
-
-            let loaders = &loader_data.game_versions
-                .iter()
-                .find(|it| it.id == game_version)
-                .ok_or_else(|| eyre::eyre!("Modloader {loader} unsupported for Minecraft version {game_version}"))?
-                .loaders;
-
-            let loader_version =
-                loaders.iter().cloned().find(filter).ok_or_else(|| {
-                    eyre::eyre!(
-                        "Invalid version {version} for modloader {loader}"
-                    )
-                })?;
-
-            Some((loader_version, loader))
-        } else {
-            None
-        };
-
-        profile_create(
-            name,
-            game_version,
-            loader.clone().map(|x| x.1).unwrap_or(ModLoader::Vanilla),
-            loader.map(|x| x.0.id),
-            None,
-            None,
-            None,
-            None,
-            None,
-        )
-        .await?;
-
-        success!(
-            "Successfully created instance, it is now available to use with Theseus!"
-        );
-        Ok(())
-    }
-}
-
-#[derive(argh::FromArgs, Debug)]
-/// list all managed profiles
-#[argh(subcommand, name = "list")]
-pub struct ProfileList {}
-
-#[derive(Tabled)]
-struct ProfileRow<'a> {
-    name: &'a str,
-    #[field(display_with = "table_path_display")]
-    path: &'a Path,
-    #[header("game version")]
-    game_version: &'a str,
-    loader: &'a ModLoader,
-    #[header("loader version")]
-    loader_version: &'a str,
-}
-
-impl<'a> From<&'a Profile> for ProfileRow<'a> {
-    fn from(it: &'a Profile) -> Self {
-        Self {
-            name: &it.metadata.name,
-            path: Path::new(&it.metadata.name),
-            game_version: &it.metadata.game_version,
-            loader: &it.metadata.loader,
-            loader_version: it
-                .metadata
-                .loader_version
-                .as_ref()
-                .map_or("", |it| &it.id),
-        }
-    }
-}
-
-impl<'a> From<&'a Path> for ProfileRow<'a> {
-    fn from(it: &'a Path) -> Self {
-        Self {
-            name: "?",
-            path: it,
-            game_version: "?",
-            loader: &ModLoader::Vanilla,
-            loader_version: "?",
-        }
-    }
-}
-
-impl ProfileList {
-    pub async fn run(
-        &self,
-        _args: &crate::Args,
-        _largs: &ProfileCommand,
-    ) -> Result<()> {
-        let profiles = profile::list(None).await?;
-        let rows = profiles.values().map(ProfileRow::from);
-
-        let table = table(rows).with(
-            tabled::Modify::new(tabled::Column(1..=1))
-                .with(tabled::MaxWidth::wrapping(40)),
-        );
-        println!("{table}");
-
-        Ok(())
-    }
-}
-
-#[derive(argh::FromArgs, Debug)]
-/// unmanage a profile
-#[argh(subcommand, name = "remove")]
-pub struct ProfileRemove {
-    #[argh(positional, default = "std::env::current_dir().unwrap()")]
-    /// the profile to get rid of
-    profile: PathBuf,
-}
-
-impl ProfileRemove {
-    pub async fn run(
-        &self,
-        _args: &crate::Args,
-        _largs: &ProfileCommand,
-    ) -> Result<()> {
-        let profile =
-            ProfilePathId::from_fs_path(canonicalize(&self.profile)?).await?;
-        info!("Removing profile {} from Theseus", self.profile.display());
-
-        if confirm_async(String::from("Do you wish to continue"), true).await? {
-            profile::remove(&profile).await?;
-            State::sync().await?;
-            success!("Profile removed!");
-        } else {
-            error!("Aborted!");
-        }
-
-        Ok(())
-    }
-}
-
-#[derive(argh::FromArgs, Debug)]
-/// run a profile
-#[argh(subcommand, name = "run")]
-pub struct ProfileRun {
-    #[argh(positional, default = "std::env::current_dir().unwrap()")]
-    /// the profile to run
-    profile: PathBuf,
-
-    #[argh(option)]
-    /// the user to authenticate with
-    user: Option<uuid::Uuid>,
-}
-
-impl ProfileRun {
-    pub async fn run(
-        &self,
-        _args: &crate::Args,
-        _largs: &ProfileCommand,
-    ) -> Result<()> {
-        info!("Starting profile at path {}...", self.profile.display());
-        let path = canonicalize(&self.profile)?;
-
-        let id = future::ready(self.user.ok_or(()))
-            .or_else(|_| async move {
-                let state = State::get().await?;
-                let settings = state.settings.read().await;
-
-                settings.default_user
-                    .ok_or(eyre::eyre!(
-                        "Could not find any users, please add one using the `user add` command."
-                    ))
-            })
-            .await?;
-        let credentials = auth::refresh(id).await?;
-
-        let profile_path_id = ProfilePathId::from_fs_path(path).await?;
-        let proc_lock =
-            profile::run_credentials(&profile_path_id, &credentials).await?;
-        let mut proc = proc_lock.write().await;
-        process::wait_for(&mut proc).await?;
-
-        success!("Process exited successfully!");
-        Ok(())
-    }
-}
-
-impl ProfileCommand {
-    pub async fn run(&self, args: &crate::Args) -> Result<()> {
-        dispatch!(&self.action, (args, self) => {
-            ProfileSubcommand::Init,
-            ProfileSubcommand::List,
-            ProfileSubcommand::Remove,
-            ProfileSubcommand::Run
-        })
-    }
-}
-
-fn modloader_from_str(it: &str) -> core::result::Result<ModLoader, String> {
-    match it {
-        "vanilla" => Ok(ModLoader::Vanilla),
-        "forge" => Ok(ModLoader::Forge),
-        "fabric" => Ok(ModLoader::Fabric),
-        _ => Err(String::from("Invalid modloader: {it}")),
-    }
-}
--- a/theseus_cli/src/subcommands/user.rs
+++ b/theseus_cli/src/subcommands/user.rs
@@ -1,177 +0,0 @@
-//! User management subcommand
-use crate::util::{confirm_async, table};
-use eyre::Result;
-use paris::*;
-use tabled::Tabled;
-use theseus::prelude::*;
-use tokio::sync::oneshot;
-
-#[derive(argh::FromArgs, Debug)]
-#[argh(subcommand, name = "user")]
-/// manage Minecraft accounts
-pub struct UserCommand {
-    #[argh(subcommand)]
-    action: UserSubcommand,
-}
-
-#[derive(argh::FromArgs, Debug)]
-#[argh(subcommand)]
-pub enum UserSubcommand {
-    Add(UserAdd),
-    List(UserList),
-    Remove(UserRemove),
-    SetDefault(UserDefault),
-}
-
-#[derive(argh::FromArgs, Debug)]
-/// add a new user to Theseus
-#[argh(subcommand, name = "add")]
-pub struct UserAdd {
-    #[argh(option)]
-    /// the browser to authenticate using
-    browser: Option<webbrowser::Browser>,
-}
-
-impl UserAdd {
-    pub async fn run(
-        &self,
-        _args: &crate::Args,
-        _largs: &UserCommand,
-    ) -> Result<()> {
-        info!("Adding new user account to Theseus");
-        info!("A browser window will now open, follow the login flow there.");
-
-        let (tx, rx) = oneshot::channel::<url::Url>();
-        let flow = tokio::spawn(auth::authenticate(tx));
-
-        let url = rx.await?;
-        match self.browser {
-            Some(browser) => webbrowser::open_browser(browser, url.as_str()),
-            None => webbrowser::open(url.as_str()),
-        }?;
-
-        let credentials = flow.await??;
-        State::sync().await?;
-        success!("Logged in user {}.", credentials.0.username);
-        Ok(())
-    }
-}
-
-#[derive(argh::FromArgs, Debug)]
-/// list all known users
-#[argh(subcommand, name = "list")]
-pub struct UserList {}
-
-#[derive(Tabled)]
-struct UserRow<'a> {
-    username: &'a str,
-    id: uuid::Uuid,
-    default: bool,
-}
-
-impl<'a> UserRow<'a> {
-    pub fn from(
-        credentials: &'a Credentials,
-        default: Option<uuid::Uuid>,
-    ) -> Self {
-        Self {
-            username: &credentials.username,
-            id: credentials.id,
-            default: Some(credentials.id) == default,
-        }
-    }
-}
-
-impl UserList {
-    pub async fn run(
-        &self,
-        _args: &crate::Args,
-        _largs: &UserCommand,
-    ) -> Result<()> {
-        let state = State::get().await?;
-        let default = state.settings.read().await.default_user;
-
-        let users = auth::users().await?;
-        let rows = users.iter().map(|user| UserRow::from(user, default));
-
-        let table = table(rows);
-        println!("{table}");
-
-        Ok(())
-    }
-}
-
-#[derive(argh::FromArgs, Debug)]
-/// remove a user
-#[argh(subcommand, name = "remove")]
-pub struct UserRemove {
-    /// the user to remove
-    #[argh(positional)]
-    user: uuid::Uuid,
-}
-
-impl UserRemove {
-    pub async fn run(
-        &self,
-        _args: &crate::Args,
-        _largs: &UserCommand,
-    ) -> Result<()> {
-        info!("Removing user {}", self.user.as_hyphenated());
-
-        if confirm_async(String::from("Do you wish to continue"), true).await? {
-            if !auth::has_user(self.user).await? {
-                warn!("Profile was not managed by Theseus!");
-            } else {
-                auth::remove_user(self.user).await?;
-                State::sync().await?;
-                success!("User removed!");
-            }
-        } else {
-            error!("Aborted!");
-        }
-
-        Ok(())
-    }
-}
-
-#[derive(argh::FromArgs, Debug)]
-/// set the default user
-#[argh(subcommand, name = "set-default")]
-pub struct UserDefault {
-    /// the user to set as default
-    #[argh(positional)]
-    user: uuid::Uuid,
-}
-
-impl UserDefault {
-    pub async fn run(
-        &self,
-        _args: &crate::Args,
-        _largs: &UserCommand,
-    ) -> Result<()> {
-        info!("Setting user {} as default", self.user.as_hyphenated());
-
-        let state = State::get().await?;
-        let mut settings = state.settings.write().await;
-
-        if settings.default_user == Some(self.user) {
-            warn!("User is already the default!");
-        } else {
-            settings.default_user = Some(self.user);
-            success!("User set as default!");
-        }
-
-        Ok(())
-    }
-}
-
-impl UserCommand {
-    pub async fn run(&self, args: &crate::Args) -> Result<()> {
-        dispatch!(&self.action, (args, self) => {
-            UserSubcommand::Add,
-            UserSubcommand::List,
-            UserSubcommand::Remove,
-            UserSubcommand::SetDefault
-        })
-    }
-}
--- a/theseus_cli/src/util.rs
+++ b/theseus_cli/src/util.rs
@@ -1,95 +0,0 @@
-use dialoguer::{Confirm, Input, Select};
-use eyre::Result;
-use std::{borrow::Cow, path::Path};
-use tabled::{Table, Tabled};
-
-// TODO: make primarily async to avoid copies
-
-// Prompting helpers
-pub fn prompt(prompt: &str, default: Option<String>) -> Result<String> {
-    let prompt = match default.as_deref() {
-        Some("") => Cow::Owned(format!("{prompt} (optional)")),
-        Some(default) => Cow::Owned(format!("{prompt} (default: {default})")),
-        None => Cow::Borrowed(prompt),
-    };
-    print_prompt(&prompt);
-
-    let mut input = Input::<String>::new();
-    input.with_prompt("").show_default(false);
-
-    if let Some(default) = default {
-        input.default(default);
-    }
-
-    Ok(input.interact_text()?.trim().to_owned())
-}
-
-pub async fn prompt_async(
-    text: String,
-    default: Option<String>,
-) -> Result<String> {
-    tokio::task::spawn_blocking(move || prompt(&text, default)).await?
-}
-
-// Selection helpers
-pub fn select(prompt: &str, choices: &[&str]) -> Result<usize> {
-    print_prompt(prompt);
-
-    let res = Select::new().items(choices).default(0).interact()?;
-    eprintln!("> {}", choices[res]);
-    Ok(res)
-}
-
-pub async fn select_async(
-    prompt: String,
-    choices: &'static [&'static str],
-) -> Result<usize> {
-    tokio::task::spawn_blocking(move || select(&prompt, choices)).await?
-}
-
-// Confirmation helpers
-pub fn confirm(prompt: &str, default: bool) -> Result<bool> {
-    print_prompt(prompt);
-    Ok(Confirm::new().default(default).interact()?)
-}
-
-pub async fn confirm_async(prompt: String, default: bool) -> Result<bool> {
-    tokio::task::spawn_blocking(move || confirm(&prompt, default)).await?
-}
-
-// Table helpers
-pub fn table<T: Tabled>(rows: impl IntoIterator<Item = T>) -> Table {
-    Table::new(rows).with(tabled::Style::psql())
-}
-
-pub fn table_path_display(path: &Path) -> String {
-    let mut res = path.display().to_string();
-
-    if let Some(home_dir) = dirs::home_dir() {
-        res = res.replace(&home_dir.display().to_string(), "~");
-    }
-
-    res
-}
-
-// Dispatch macros
-macro_rules! dispatch {
-    ($on:expr, $args:tt => {$($option:path),+}) => {
-        match $on {
-            $($option (ref cmd) => dispatch!(@apply cmd => $args)),+
-        }
-    };
-
-    (@apply $cmd:expr => ($($args:expr),*)) => {{
-        use tracing_futures::WithSubscriber;
-        $cmd.run($($args),*).with_current_subscriber().await
-    }};
-}
-
-// Internal helpers
-fn print_prompt(prompt: &str) {
-    println!(
-        "{}",
-        paris::formatter::colorize_string(format!("<yellow>?</> {prompt}:"))
-    );
-}
--- a/theseus_gui/index.html
+++ b/theseus_gui/index.html
@@ -1,4 +1,4 @@
-<!DOCTYPE html>
+<!doctype html>
 <html lang="en">
  <head>
    <meta charset="UTF-8" />
--- a/theseus_gui/package.json
+++ b/theseus_gui/package.json
@@ -1,7 +1,7 @@
 {
  "name": "theseus_gui",
  "private": true,
-  "version": "0.5.1",
+  "version": "0.7.0",
  "type": "module",
  "scripts": {
    "dev": "vite",
@@ -13,30 +13,30 @@
    "fix": "eslint --fix --ext .js,.vue,.ts,.jsx,.tsx,.html,.vue . && prettier --write ."
  },
  "dependencies": {
-    "@tauri-apps/api": "^1.3.0",
-    "dayjs": "^1.11.7",
-    "floating-vue": "^2.0.0-beta.20",
-    "mixpanel-browser": "^2.47.0",
-    "ofetch": "^1.0.1",
-    "omorphia": "^0.4.38",
-    "pinia": "^2.1.3",
-    "qrcode.vue": "^3.4.0",
+    "@tauri-apps/api": "^1.5.3",
+    "dayjs": "^1.11.10",
+    "floating-vue": "^5.2.2",
+    "mixpanel-browser": "^2.49.0",
+    "ofetch": "^1.3.4",
+    "omorphia": "^0.4.41",
+    "pinia": "^2.1.7",
    "tauri-plugin-window-state-api": "github:tauri-apps/tauri-plugin-window-state#v1",
-    "vite-svg-loader": "^4.0.0",
-    "vue": "^3.3.4",
-    "vue-multiselect": "^3.0.0-beta.2",
-    "vue-router": "4.2.1"
+    "vite-svg-loader": "^5.1.0",
+    "vue": "^3.4.21",
+    "vue-multiselect": "3.0.0-beta.3",
+    "vue-router": "4.3.0",
+    "vue-virtual-scroller": "2.0.0-beta.8"
  },
  "devDependencies": {
-    "@rollup/plugin-alias": "^4.0.4",
-    "@tauri-apps/cli": "^1.3.1",
-    "@vitejs/plugin-vue": "^4.2.3",
-    "eslint": "^8.41.0",
-    "eslint-config-prettier": "^8.8.0",
-    "eslint-plugin-vue": "^9.14.1",
-    "prettier": "^2.8.8",
-    "sass": "^1.62.1",
-    "vite": "^4.3.9",
+    "@rollup/plugin-alias": "^5.1.0",
+    "@tauri-apps/cli": "^1.5.11",
+    "@vitejs/plugin-vue": "^5.0.4",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-vue": "^9.24.0",
+    "prettier": "^3.2.5",
+    "sass": "^1.74.1",
+    "vite": "^5.2.8",
    "vite-plugin-eslint": "^1.8.1"
  },
  "packageManager": "pnpm@8.6.0"
--- a/theseus_gui/pnpm-lock.yaml
+++ b/theseus_gui/pnpm-lock.yaml
--- a/theseus_gui/src-tauri/App.entitlements
+++ b/theseus_gui/src-tauri/App.entitlements
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.cs.disable-library-validation</key>
+    <true/>
+    <key>com.apple.security.cs.allow-dyld-environment-variables</key>
+    <true/>
+    <key>com.apple.security.device.audio-input</key>
+    <true/>
+    <key>com.apple.security.device.camera</key>
+    <true/>
+</dict>
+</plist>
--- a/theseus_gui/src-tauri/Cargo.toml
+++ b/theseus_gui/src-tauri/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "theseus_gui"
-version = "0.5.1"
+version = "0.7.0"
 description = "A Tauri App"
 authors = ["you"]
 license = ""
@@ -19,10 +19,10 @@ theseus = { path = "../../theseus", features = ["tauri"] }
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }

-tauri = { version = "1.3", features = ["app-all", "devtools", "dialog", "dialog-confirm", "dialog-open", "macos-private-api", "os-all", "protocol-asset", "shell-open", "updater", "window-close", "window-create", "window-hide", "window-maximize", "window-minimize", "window-set-decorations", "window-show", "window-start-dragging", "window-unmaximize", "window-unminimize"] }
+tauri = { version = "1.6", features = ["app-all", "devtools", "dialog", "dialog-confirm", "dialog-open", "macos-private-api", "os-all", "protocol-asset", "shell-open", "updater", "window-close", "window-create", "window-hide", "window-maximize", "window-minimize", "window-set-decorations", "window-show", "window-start-dragging", "window-unmaximize", "window-unminimize"] }
 tauri-plugin-single-instance = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "v1" }
 tauri-plugin-window-state = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "v1" }
-tauri-plugin-deep-link = "0.1.1"
+tauri-plugin-deep-link = "0.1.2"

 tokio = { version = "1", features = ["full"] }
 thiserror = "1.0"
@@ -38,10 +38,10 @@ uuid = { version = "1.1", features = ["serde", "v4"] }
 os_info = "3.7.0"

 tracing = "0.1.37"
-tracing-error = "0.1"
+tracing-error = "0.2.0"

-sentry = "0.30"
-sentry-rust-minidump = "0.5"
+sentry = "0.32.2"
+sentry-rust-minidump = "0.7.0"

 lazy_static = "1"
 once_cell = "1"
@@ -50,13 +50,13 @@ once_cell = "1"
 window-shadows = "0.2.1"

 [target.'cfg(target_os = "macos")'.dependencies]
-cocoa = "0.24.1"
+cocoa = "0.25.0"
 objc = "0.2.7"

 [features]
 # by default Tauri runs in production mode
 # when `tauri dev` runs it is executed with `cargo run --no-default-features` if `devPath` is an URL
 default = ["custom-protocol"]
-# this feature is used used for production builds where `devPath` points to the filesystem
+# this feature is used for production builds where `devPath` points to the filesystem
 # DO NOT remove this
 custom-protocol = ["tauri/custom-protocol"]
--- a/theseus_gui/src-tauri/src/api/auth.rs
+++ b/theseus_gui/src-tauri/src/api/auth.rs
@@ -1,16 +1,15 @@
 use crate::api::Result;
+use chrono::{Duration, Utc};
 use tauri::plugin::TauriPlugin;
+use tauri::{Manager, UserAttentionType};
 use theseus::prelude::*;

 pub fn init<R: tauri::Runtime>() -> TauriPlugin<R> {
    tauri::plugin::Builder::new("auth")
        .invoke_handler(tauri::generate_handler![
-            auth_authenticate_begin_flow,
-            auth_authenticate_await_completion,
-            auth_cancel_flow,
-            auth_refresh,
+            auth_get_default_user,
+            auth_set_default_user,
            auth_remove_user,
-            auth_has_user,
            auth_users,
            auth_get_user,
        ])
@@ -20,48 +19,82 @@ pub fn init<R: tauri::Runtime>() -> TauriPlugin<R> {
 /// Authenticate a user with Hydra - part 1
 /// This begins the authentication flow quasi-synchronously, returning a URL to visit (that the user will sign in at)
 #[tauri::command]
-pub async fn auth_authenticate_begin_flow() -> Result<url::Url> {
-    Ok(auth::authenticate_begin_flow().await?)
-}
+pub async fn auth_login(app: tauri::AppHandle) -> Result<Option<Credentials>> {
+    let flow = minecraft_auth::begin_login().await?;

-/// Authenticate a user with Hydra - part 2
-/// This completes the authentication flow quasi-synchronously, returning the sign-in credentials
-/// (and also adding the credentials to the state)
-#[tauri::command]
-pub async fn auth_authenticate_await_completion(
-) -> Result<(Credentials, Option<String>)> {
-    Ok(auth::authenticate_await_complete_flow().await?)
-}
+    let start = Utc::now();

-#[tauri::command]
-pub async fn auth_cancel_flow() -> Result<()> {
-    Ok(auth::cancel_flow().await?)
-}
+    if let Some(window) = app.get_window("signin") {
+        window.close()?;
+    }

-/// Refresh some credentials using Hydra, if needed
-// invoke('plugin:auth|auth_refresh',user)
-#[tauri::command]
-pub async fn auth_refresh(user: uuid::Uuid) -> Result<Credentials> {
-    Ok(auth::refresh(user).await?)
-}
+    let window = tauri::WindowBuilder::new(
+        &app,
+        "signin",
+        tauri::WindowUrl::External(flow.redirect_uri.parse().map_err(
+            |_| {
+                theseus::ErrorKind::OtherError(
+                    "Error parsing auth redirect URL".to_string(),
+                )
+                .as_error()
+            },
+        )?),
+    )
+    .title("Sign into Modrinth")
+    .always_on_top(true)
+    .center()
+    .build()?;

+    window.request_user_attention(Some(UserAttentionType::Critical))?;
+
+    while (Utc::now() - start) < Duration::minutes(10) {
+        if window.title().is_err() {
+            // user closed window, cancelling flow
+            return Ok(None);
+        }
+
+        if window
+            .url()
+            .as_str()
+            .starts_with("https://login.live.com/oauth20_desktop.srf")
+        {
+            if let Some((_, code)) =
+                window.url().query_pairs().find(|x| x.0 == "code")
+            {
+                window.close()?;
+                let val =
+                    minecraft_auth::finish_login(&code.clone(), flow).await?;
+
+                return Ok(Some(val));
+            }
+        }
+
+        tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+    }
+
+    window.close()?;
+    Ok(None)
+}
 #[tauri::command]
 pub async fn auth_remove_user(user: uuid::Uuid) -> Result<()> {
-    Ok(auth::remove_user(user).await?)
+    Ok(minecraft_auth::remove_user(user).await?)
 }

-/// Check if a user exists in Theseus
-// invoke('plugin:auth|auth_has_user',user)
 #[tauri::command]
-pub async fn auth_has_user(user: uuid::Uuid) -> Result<bool> {
-    Ok(auth::has_user(user).await?)
+pub async fn auth_get_default_user() -> Result<Option<uuid::Uuid>> {
+    Ok(minecraft_auth::get_default_user().await?)
+}
+
+#[tauri::command]
+pub async fn auth_set_default_user(user: uuid::Uuid) -> Result<()> {
+    Ok(minecraft_auth::set_default_user(user).await?)
 }

 /// Get a copy of the list of all user credentials
 // invoke('plugin:auth|auth_users',user)
 #[tauri::command]
 pub async fn auth_users() -> Result<Vec<Credentials>> {
-    Ok(auth::users().await?)
+    Ok(minecraft_auth::users().await?)
 }

 /// Get a user from the UUID
@@ -69,5 +102,5 @@ pub async fn auth_users() -> Result<Vec<Credentials>> {
 // invoke('plugin:auth|auth_users',user)
 #[tauri::command]
 pub async fn auth_get_user(user: uuid::Uuid) -> Result<Credentials> {
-    Ok(auth::get_user(user).await?)
+    Ok(minecraft_auth::get_user(user).await?)
 }
--- a/theseus_gui/src-tauri/src/api/jre.rs
+++ b/theseus_gui/src-tauri/src/api/jre.rs
@@ -8,50 +8,21 @@ use theseus::prelude::*;
 pub fn init<R: tauri::Runtime>() -> TauriPlugin<R> {
    tauri::plugin::Builder::new("jre")
        .invoke_handler(tauri::generate_handler![
-            jre_get_all_jre,
            jre_find_filtered_jres,
-            jre_autodetect_java_globals,
-            jre_validate_globals,
            jre_get_jre,
+            jre_test_jre,
            jre_auto_install_java,
            jre_get_max_memory,
        ])
        .build()
 }

-/// Get all JREs that exist on the system
-#[tauri::command]
-pub async fn jre_get_all_jre() -> Result<Vec<JavaVersion>> {
-    Ok(jre::get_all_jre().await?)
-}
-
 // Finds the installation of Java 8, if it exists
 #[tauri::command]
 pub async fn jre_find_filtered_jres(
-    jres: Vec<JavaVersion>,
-    version: String,
-    allow_higher: bool,
+    version: Option<u32>,
 ) -> Result<Vec<JavaVersion>> {
-    Ok(jre::find_filtered_jres(&version, jres, allow_higher).await?)
-}
-
-// Autodetect Java globals, by searching the users computer.
-// Selects from the given JREs, and returns a new JavaGlobals
-// Returns a *NEW* JavaGlobals that can be put into Settings
-#[tauri::command]
-pub async fn jre_autodetect_java_globals(
-    java_8: Vec<JavaVersion>,
-    java_17: Vec<JavaVersion>,
-    java_18plus: Vec<JavaVersion>,
-) -> Result<JavaGlobals> {
-    Ok(jre::autodetect_java_globals(java_8, java_17, java_18plus).await?)
-}
-
-// Validates java globals, by checking if the paths exist
-// If false, recommend to direct them to reassign, or to re-guess
-#[tauri::command]
-pub async fn jre_validate_globals() -> Result<bool> {
-    Ok(jre::validate_globals().await?)
+    Ok(jre::find_filtered_jres(version).await?)
 }

 // Validates JRE at a given path
@@ -61,6 +32,12 @@ pub async fn jre_get_jre(path: PathBuf) -> Result<Option<JavaVersion>> {
    jre::check_jre(path).await.map_err(|e| e.into())
 }

+// Tests JRE of a certain version
+#[tauri::command]
+pub async fn jre_test_jre(path: PathBuf, major_version: u32) -> Result<bool> {
+    Ok(jre::test_jre(path, major_version).await?)
+}
+
 // Auto installs java for the given java version
 #[tauri::command]
 pub async fn jre_auto_install_java(java_version: u32) -> Result<PathBuf> {
--- a/theseus_gui/src-tauri/src/api/logs.rs
+++ b/theseus_gui/src-tauri/src/api/logs.rs
@@ -1,14 +1,14 @@
 use crate::api::Result;
 use theseus::{
-    logs::{self, Logs},
+    logs::{self, CensoredString, LatestLogCursor, Logs},
    prelude::ProfilePathId,
 };

 /*
-A log is a struct containing the datetime string, stdout, and stderr, as follows:
+A log is a struct containing the filename string, stdout, and stderr, as follows:

 pub struct Logs {
-    pub datetime_string:  String,
+    pub filename:  String,
    pub stdout: String,
    pub stderr: String,
 }
@@ -18,15 +18,16 @@ pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
    tauri::plugin::Builder::new("logs")
        .invoke_handler(tauri::generate_handler![
            logs_get_logs,
-            logs_get_logs_by_datetime,
-            logs_get_output_by_datetime,
+            logs_get_logs_by_filename,
+            logs_get_output_by_filename,
            logs_delete_logs,
-            logs_delete_logs_by_datetime,
+            logs_delete_logs_by_filename,
+            logs_get_latest_log_cursor,
        ])
        .build()
 }

-/// Get all Logs for a profile, sorted by datetime
+/// Get all Logs for a profile, sorted by filename
 #[tauri::command]
 pub async fn logs_get_logs(
    profile_path: ProfilePathId,
@@ -37,21 +38,21 @@ pub async fn logs_get_logs(
    Ok(val)
 }

-/// Get a Log struct for a profile by profile id and datetime string
+/// Get a Log struct for a profile by profile id and filename string
 #[tauri::command]
-pub async fn logs_get_logs_by_datetime(
+pub async fn logs_get_logs_by_filename(
    profile_path: ProfilePathId,
-    datetime_string: String,
+    filename: String,
 ) -> Result<Logs> {
-    Ok(logs::get_logs_by_datetime(profile_path, datetime_string).await?)
+    Ok(logs::get_logs_by_filename(profile_path, filename).await?)
 }

-/// Get the stdout for a profile by profile id and datetime string
+/// Get the stdout for a profile by profile id and filename string
 #[tauri::command]
-pub async fn logs_get_output_by_datetime(
+pub async fn logs_get_output_by_filename(
    profile_path: ProfilePathId,
-    datetime_string: String,
-) -> Result<String> {
+    filename: String,
+) -> Result<CensoredString> {
    let profile_path = if let Some(p) =
        crate::profile::get(&profile_path, None).await?
    {
@@ -63,7 +64,7 @@ pub async fn logs_get_output_by_datetime(
        .into());
    };

-    Ok(logs::get_output_by_datetime(&profile_path, &datetime_string).await?)
+    Ok(logs::get_output_by_filename(&profile_path, &filename).await?)
 }

 /// Delete all logs for a profile by profile id
@@ -72,11 +73,20 @@ pub async fn logs_delete_logs(profile_path: ProfilePathId) -> Result<()> {
    Ok(logs::delete_logs(profile_path).await?)
 }

-/// Delete a log for a profile by profile id and datetime string
+/// Delete a log for a profile by profile id and filename string
 #[tauri::command]
-pub async fn logs_delete_logs_by_datetime(
+pub async fn logs_delete_logs_by_filename(
    profile_path: ProfilePathId,
-    datetime_string: String,
+    filename: String,
 ) -> Result<()> {
-    Ok(logs::delete_logs_by_datetime(profile_path, &datetime_string).await?)
+    Ok(logs::delete_logs_by_filename(profile_path, &filename).await?)
+}
+
+/// Get live log from a cursor
+#[tauri::command]
+pub async fn logs_get_latest_log_cursor(
+    profile_path: ProfilePathId,
+    cursor: u64, // 0 to start at beginning of file
+) -> Result<LatestLogCursor> {
+    Ok(logs::get_latest_log_cursor(profile_path, cursor).await?)
 }
--- a/theseus_gui/src-tauri/src/api/metadata.rs
+++ b/theseus_gui/src-tauri/src/api/metadata.rs
@@ -9,6 +9,7 @@ pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
            metadata_get_fabric_versions,
            metadata_get_forge_versions,
            metadata_get_quilt_versions,
+            metadata_get_neoforge_versions,
        ])
        .build()
 }
@@ -36,3 +37,9 @@ pub async fn metadata_get_forge_versions() -> Result<Manifest> {
 pub async fn metadata_get_quilt_versions() -> Result<Manifest> {
    Ok(theseus::metadata::get_quilt_versions().await?)
 }
+
+/// Gets the quilt versions from daedalus
+#[tauri::command]
+pub async fn metadata_get_neoforge_versions() -> Result<Manifest> {
+    Ok(theseus::metadata::get_neoforge_versions().await?)
+}
--- a/theseus_gui/src-tauri/src/api/mod.rs
+++ b/theseus_gui/src-tauri/src/api/mod.rs
@@ -35,6 +35,9 @@ pub enum TheseusSerializableError {
    #[error("IO error: {0}")]
    IO(#[from] std::io::Error),

+    #[error("Tauri error: {0}")]
+    Tauri(#[from] tauri::Error),
+
    #[cfg(target_os = "macos")]
    #[error("Callback error: {0}")]
    Callback(String),
@@ -88,9 +91,12 @@ macro_rules! impl_serialize {
 #[cfg(target_os = "macos")]
 impl_serialize! {
    IO,
+    Tauri,
    Callback
 }
+
 #[cfg(not(target_os = "macos"))]
 impl_serialize! {
    IO,
+    Tauri,
 }
--- a/theseus_gui/src-tauri/src/api/mr_auth.rs
+++ b/theseus_gui/src-tauri/src/api/mr_auth.rs
@@ -10,7 +10,6 @@ pub fn init<R: tauri::Runtime>() -> TauriPlugin<R> {
            cancel_flow,
            login_pass,
            login_2fa,
-            login_minecraft,
            create_account,
            refresh,
            logout,
@@ -49,11 +48,6 @@ pub async fn login_2fa(code: &str, flow: &str) -> Result<ModrinthCredentials> {
    Ok(theseus::mr_auth::login_2fa(code, flow).await?)
 }

-#[tauri::command]
-pub async fn login_minecraft(flow: &str) -> Result<ModrinthCredentialsResult> {
-    Ok(theseus::mr_auth::login_minecraft(flow).await?)
-}
-
 #[tauri::command]
 pub async fn create_account(
    username: &str,
--- a/theseus_gui/src-tauri/src/api/process.rs
+++ b/theseus_gui/src-tauri/src/api/process.rs
@@ -12,7 +12,6 @@ pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
            process_get_uuids_by_profile_path,
            process_get_all_running_profile_paths,
            process_get_all_running_profiles,
-            process_get_output_by_uuid,
            process_kill_by_uuid,
            process_wait_for_by_uuid,
        ])
@@ -66,12 +65,6 @@ pub async fn process_get_all_running_profiles() -> Result<Vec<Profile>> {
    Ok(process::get_all_running_profiles().await?)
 }

-// Gets process stderr by process UUID
-#[tauri::command]
-pub async fn process_get_output_by_uuid(uuid: Uuid) -> Result<String> {
-    Ok(process::get_output_by_uuid(&uuid).await?)
-}
-
 // Kill a process by process UUID
 #[tauri::command]
 pub async fn process_kill_by_uuid(uuid: Uuid) -> Result<()> {
--- a/theseus_gui/src-tauri/src/api/profile.rs
+++ b/theseus_gui/src-tauri/src/api/profile.rs
@@ -3,7 +3,7 @@ use daedalus::modded::LoaderVersion;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
-use theseus::prelude::*;
+use theseus::{prelude::*, InnerProjectPathUnix};
 use uuid::Uuid;

 pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
@@ -13,6 +13,7 @@ pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
            profile_get,
            profile_get_optimal_jre_key,
            profile_get_full_path,
+            profile_get_mod_full_path,
            profile_list,
            profile_check_installed,
            profile_install,
@@ -22,7 +23,7 @@ pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
            profile_add_project_from_path,
            profile_toggle_disable_project,
            profile_remove_project,
-            profile_update_managed_modrinth,
+            profile_update_managed_modrinth_version,
            profile_repair_managed_modrinth,
            profile_run,
            profile_run_wait,
@@ -31,7 +32,7 @@ pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
            profile_edit,
            profile_edit_icon,
            profile_export_mrpack,
-            profile_get_potential_override_folders,
+            profile_get_pack_export_candidates,
        ])
        .build()
 }
@@ -63,6 +64,17 @@ pub async fn profile_get_full_path(path: ProfilePathId) -> Result<PathBuf> {
    Ok(res)
 }

+// Get's a mod's full path
+// invoke('plugin:profile|profile_get_mod_full_path',path)
+#[tauri::command]
+pub async fn profile_get_mod_full_path(
+    path: ProfilePathId,
+    project_path: ProjectPathId,
+) -> Result<PathBuf> {
+    let res = profile::get_mod_full_path(&path, &project_path).await?;
+    Ok(res)
+}
+
 // Get optimal java version from profile
 #[tauri::command]
 pub async fn profile_get_optimal_jre_key(
@@ -105,8 +117,8 @@ pub async fn profile_check_installed(
 /// Installs/Repairs a profile
 /// invoke('plugin:profile|profile_install')
 #[tauri::command]
-pub async fn profile_install(path: ProfilePathId) -> Result<()> {
-    profile::install(&path).await?;
+pub async fn profile_install(path: ProfilePathId, force: bool) -> Result<()> {
+    profile::install(&path, force).await?;
    Ok(())
 }

@@ -173,12 +185,16 @@ pub async fn profile_remove_project(
    Ok(())
 }

-// Updates a managed Modrinth profile
+// Updates a managed Modrinth profile to a version of version_id
 #[tauri::command]
-pub async fn profile_update_managed_modrinth(
+pub async fn profile_update_managed_modrinth_version(
    path: ProfilePathId,
+    version_id: String,
 ) -> Result<()> {
-    Ok(profile::update::update_managed_modrinth(&path).await?)
+    Ok(
+        profile::update::update_managed_modrinth_version(&path, &version_id)
+            .await?,
+    )
 }

 // Repairs a managed Modrinth profile by updating it to the current version
@@ -197,31 +213,28 @@ pub async fn profile_export_mrpack(
    export_location: PathBuf,
    included_overrides: Vec<String>,
    version_id: Option<String>,
+    description: Option<String>,
+    name: Option<String>, // only used to cache
 ) -> Result<()> {
    profile::export_mrpack(
        &path,
        export_location,
        included_overrides,
        version_id,
+        description,
+        name,
    )
    .await?;
    Ok(())
 }

-// Given a folder path, populate a Vec of all the subfolders
-// Intended to be used for finding potential override folders
-// profile
-// -- folder1
-// -- folder2
-// -- file1
-// => [folder1, folder2]
+/// See [`profile::get_pack_export_candidates`]
 #[tauri::command]
-pub async fn profile_get_potential_override_folders(
+pub async fn profile_get_pack_export_candidates(
    profile_path: ProfilePathId,
-) -> Result<Vec<PathBuf>> {
-    let overrides =
-        profile::get_potential_override_folders(profile_path).await?;
-    Ok(overrides)
+) -> Result<Vec<InnerProjectPathUnix>> {
+    let candidates = profile::get_pack_export_candidates(&profile_path).await?;
+    Ok(candidates)
 }

 // Run minecraft using a profile using the default credentials
--- a/theseus_gui/src-tauri/src/api/profile_create.rs
+++ b/theseus_gui/src-tauri/src/api/profile_create.rs
@@ -4,12 +4,15 @@ use theseus::prelude::*;

 pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
    tauri::plugin::Builder::new("profile_create")
-        .invoke_handler(tauri::generate_handler![profile_create,])
+        .invoke_handler(tauri::generate_handler![
+            profile_create,
+            profile_duplicate
+        ])
        .build()
 }

 // Creates a profile at  the given filepath and adds it to the in-memory state
-// invoke('plugin:profile|profile_add',profile)
+// invoke('plugin:profile_create|profile_add',profile)
 #[tauri::command]
 pub async fn profile_create(
    name: String,         // the name of the profile, and relative path
@@ -33,3 +36,11 @@ pub async fn profile_create(
    .await?;
    Ok(res)
 }
+
+// Creates a profile from a duplicate
+// invoke('plugin:profile_create|profile_duplicate',profile)
+#[tauri::command]
+pub async fn profile_duplicate(path: ProfilePathId) -> Result<ProfilePathId> {
+    let res = profile::create::profile_create_from_duplicate(path).await?;
+    Ok(res)
+}
--- a/theseus_gui/src-tauri/src/api/settings.rs
+++ b/theseus_gui/src-tauri/src/api/settings.rs
@@ -8,7 +8,8 @@ pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
        .invoke_handler(tauri::generate_handler![
            settings_get,
            settings_set,
-            settings_change_config_dir
+            settings_change_config_dir,
+            settings_is_dir_writeable
        ])
        .build()
 }
@@ -37,3 +38,11 @@ pub async fn settings_change_config_dir(new_config_dir: PathBuf) -> Result<()> {
    settings::set_config_dir(new_config_dir).await?;
    Ok(())
 }
+
+#[tauri::command]
+pub async fn settings_is_dir_writeable(
+    new_config_dir: PathBuf,
+) -> Result<bool> {
+    let res = settings::is_dir_writeable(new_config_dir).await?;
+    Ok(res)
+}
--- a/theseus_gui/src-tauri/src/api/utils.rs
+++ b/theseus_gui/src-tauri/src/api/utils.rs
@@ -1,8 +1,12 @@
 use serde::{Deserialize, Serialize};
-use theseus::{handler, prelude::CommandPayload, State};
+use theseus::{
+    handler,
+    prelude::{CommandPayload, DirectoryInfo},
+    State,
+};

 use crate::api::Result;
-use std::{env, process::Command};
+use std::{env, path::PathBuf, process::Command};

 pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
    tauri::plugin::Builder::new("utils")
@@ -10,6 +14,7 @@ pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
            get_os,
            should_disable_mouseover,
            show_in_folder,
+            show_launcher_logs_folder,
            progress_bars_list,
            safety_check_safe_loading_bars,
            get_opening_command,
@@ -76,13 +81,19 @@ pub async fn should_disable_mouseover() -> bool {
 }

 #[tauri::command]
-pub fn show_in_folder(path: String) -> Result<()> {
+pub fn show_in_folder(path: PathBuf) -> Result<()> {
    {
        #[cfg(target_os = "windows")]
        {
-            Command::new("explorer")
-                .args([&path]) // The comma after select is not a typo
-                .spawn()?;
+            if path.is_dir() {
+                Command::new("explorer")
+                    .args([&path]) // The comma after select is not a typo
+                    .spawn()?;
+            } else {
+                Command::new("explorer")
+                    .args(["/select,", &path.to_string_lossy()]) // The comma after select is not a typo
+                    .spawn()?;
+            }
        }

        #[cfg(target_os = "linux")]
@@ -90,14 +101,14 @@ pub fn show_in_folder(path: String) -> Result<()> {
            use std::fs::metadata;
            use std::path::PathBuf;

-            if path.contains(',') {
+            if path.to_string_lossy().to_string().contains(',') {
                // see https://gitlab.freedesktop.org/dbus/dbus/-/issues/76
                let new_path = match metadata(&path)?.is_dir() {
                    true => path,
                    false => {
                        let mut path2 = PathBuf::from(path);
                        path2.pop();
-                        path2.to_string_lossy().to_string()
+                        path2
                    }
                };
                Command::new("xdg-open").arg(&new_path).spawn()?;
@@ -108,7 +119,13 @@ pub fn show_in_folder(path: String) -> Result<()> {

        #[cfg(target_os = "macos")]
        {
-            Command::new("open").args([&path]).spawn()?;
+            if path.is_dir() {
+                Command::new("open").args([&path]).spawn()?;
+            } else {
+                Command::new("open")
+                    .args(["-R", &path.as_os_str().to_string_lossy()])
+                    .spawn()?;
+            }
        }

        Ok::<(), theseus::Error>(())
@@ -117,6 +134,14 @@ pub fn show_in_folder(path: String) -> Result<()> {
    Ok(())
 }

+#[tauri::command]
+pub fn show_launcher_logs_folder() -> Result<()> {
+    let path = DirectoryInfo::launcher_logs_dir().unwrap_or_default();
+    // failure to get folder just opens filesystem
+    // (ie: if in debug mode only and launcher_logs never created)
+    show_in_folder(path)
+}
+
 // Get opening command
 // For example, if a user clicks on an .mrpack to open the app.
 // This should be called once and only when the app is done booting up and ready to receive a command
--- a/theseus_gui/src-tauri/src/main.rs
+++ b/theseus_gui/src-tauri/src/main.rs
@@ -13,11 +13,14 @@ mod error;
 mod macos;

 // Should be called in launcher initialization
+#[tracing::instrument(skip_all)]
 #[tauri::command]
 async fn initialize_state(app: tauri::AppHandle) -> api::Result<()> {
    theseus::EventState::init(app).await?;
-    State::get().await?;
+    let s = State::get().await?;
    State::update();
+
+    s.children.write().await.rescue_cache().await?;
    Ok(())
 }

@@ -143,6 +146,7 @@ fn main() {
            initialize_state,
            is_dev,
            toggle_decorations,
+            api::auth::auth_login,
        ]);

    builder
--- a/theseus_gui/src-tauri/tauri.conf.json
+++ b/theseus_gui/src-tauri/tauri.conf.json
@@ -8,7 +8,7 @@
  },
  "package": {
    "productName": "Modrinth App",
-    "version": "0.5.1"
+    "version": "0.7.0"
  },
  "tauri": {
    "allowlist": {
@@ -64,7 +64,7 @@
      "identifier": "com.modrinth.theseus",
      "longDescription": "",
      "macOS": {
-        "entitlements": null,
+        "entitlements": "App.entitlements",
        "exceptionDomain": "",
        "frameworks": [],
        "providerShortName": null,
@@ -83,7 +83,7 @@
      }
    },
    "security": {
-      "csp": "default-src 'self'; connect-src https://modrinth.com https://*.modrinth.com https://mixpanel.com https://*.mixpanel.com https://*.cloudflare.com; font-src https://cdn-raw.modrinth.com/fonts/inter/; img-src tauri: https: data: blob: 'unsafe-inline' asset: https://asset.localhost; script-src https://*.cloudflare.com 'self'; frame-src https://*.cloudflare.com 'self'; style-src unsafe-inline 'self'"
+      "csp": "default-src 'self'; connect-src https://modrinth.com https://*.modrinth.com https://mixpanel.com https://*.mixpanel.com https://*.cloudflare.com https://api.mclo.gs; font-src https://cdn-raw.modrinth.com/fonts/inter/; img-src tauri: https: data: blob: 'unsafe-inline' asset: https://asset.localhost; script-src https://*.cloudflare.com 'self'; frame-src https://*.cloudflare.com https://www.youtube.com https://www.youtube-nocookie.com https://discord.com 'self'; style-src unsafe-inline 'self'"
    },
    "updater": {
      "active": true,
--- a/theseus_gui/src/App.vue
+++ b/theseus_gui/src/App.vue
@@ -7,9 +7,11 @@ import {
  LibraryIcon,
  PlusIcon,
  SettingsIcon,
+  FileIcon,
  Button,
  Notifications,
  XIcon,
+  Card,
 } from 'omorphia'
 import { useLoading, useTheming } from '@/store/state'
 import AccountsCard from '@/components/ui/AccountsCard.vue'
@@ -18,13 +20,14 @@ import { get } from '@/helpers/settings'
 import Breadcrumbs from '@/components/ui/Breadcrumbs.vue'
 import RunningAppBar from '@/components/ui/RunningAppBar.vue'
 import SplashScreen from '@/components/ui/SplashScreen.vue'
+import ErrorModal from '@/components/ui/ErrorModal.vue'
 import ModrinthLoadingIndicator from '@/components/modrinth-loading-indicator'
-import { useNotifications } from '@/store/notifications.js'
+import { handleError, useNotifications } from '@/store/notifications.js'
 import { offline_listener, command_listener, warning_listener } from '@/helpers/events.js'
-import { MinimizeIcon, MaximizeIcon } from '@/assets/icons'
+import { MinimizeIcon, MaximizeIcon, ChatIcon } from '@/assets/icons'
 import { type } from '@tauri-apps/api/os'
 import { appWindow } from '@tauri-apps/api/window'
-import { isDev, getOS, isOffline } from '@/helpers/utils.js'
+import { isDev, getOS, isOffline, showLauncherLogsFolder } from '@/helpers/utils.js'
 import {
  mixpanel_track,
  mixpanel_init,
@@ -38,31 +41,43 @@ import { TauriEvent } from '@tauri-apps/api/event'
 import { await_sync, check_safe_loading_bars_complete } from './helpers/state'
 import { confirm } from '@tauri-apps/api/dialog'
 import URLConfirmModal from '@/components/ui/URLConfirmModal.vue'
-import StickyTitleBar from '@/components/ui/tutorial/StickyTitleBar.vue'
 import OnboardingScreen from '@/components/ui/tutorial/OnboardingScreen.vue'
+import { install_from_file } from './helpers/pack'
+import { useError } from '@/store/error.js'

 const themeStore = useTheming()
 const urlModal = ref(null)
 const isLoading = ref(true)

-const videoPlaying = ref(false)
 const offline = ref(false)
 const showOnboarding = ref(false)
+const nativeDecorations = ref(false)

 const onboardingVideo = ref()

+const failureText = ref(null)
+const os = ref('')
+
 defineExpose({
  initialize: async () => {
    isLoading.value = false
-    const { theme, opt_out_analytics, collapsed_navigation, advanced_rendering, fully_onboarded } =
-      await get()
-    const os = await getOS()
+    const {
+      native_decorations,
+      theme,
+      opt_out_analytics,
+      collapsed_navigation,
+      advanced_rendering,
+      fully_onboarded,
+    } = await get()
    // video should play if the user is not on linux, and has not onboarded
-    videoPlaying.value = !fully_onboarded && os !== 'Linux'
+    os.value = await getOS()
    const dev = await isDev()
    const version = await getVersion()
    showOnboarding.value = !fully_onboarded

+    nativeDecorations.value = native_decorations
+    if (os.value !== 'MacOS') appWindow.setDecorations(native_decorations)
+
    themeStore.setThemeState(theme)
    themeStore.collapsedNavigation = collapsed_navigation
    themeStore.advancedRendering = advanced_rendering
@@ -91,13 +106,18 @@ defineExpose({
        title: 'Warning',
        text: e.message,
        type: 'warn',
-      })
+      }),
    )

    if (showOnboarding.value) {
      onboardingVideo.value.play()
    }
  },
+  failure: async (e) => {
+    isLoading.value = false
+    failureText.value = e
+    os.value = await getOS()
+  },
 })

 const confirmClose = async () => {
@@ -106,12 +126,16 @@ const confirmClose = async () => {
    {
      title: 'Modrinth',
      type: 'warning',
-    }
+    },
  )
  return confirmed
 }

 const handleClose = async () => {
+  if (failureText.value != null) {
+    await TauriWindow.getCurrent().close()
+    return
+  }
  // State should respond immeiately if it's safe to close
  // If not, code is deadlocked or worse, so wait 2 seconds and then ask the user to confirm closing
  // (Exception: if the user is changing config directory, which takes control of the state, and it's taking a significant amount of time for some reason)
@@ -129,6 +153,16 @@ const handleClose = async () => {
  await TauriWindow.getCurrent().close()
 }

+const openSupport = async () => {
+  window.__TAURI_INVOKE__('tauri', {
+    __tauriModule: 'Shell',
+    message: {
+      cmd: 'open',
+      path: 'https://discord.gg/modrinth',
+    },
+  })
+}
+
 TauriWindow.getCurrent().listen(TauriEvent.WINDOW_CLOSE_REQUESTED, async () => {
  await handleClose()
 })
@@ -145,12 +179,19 @@ const isOnBrowse = computed(() => route.path.startsWith('/browse'))
 const loading = useLoading()

 const notifications = useNotifications()
-const notificationsWrapper = ref(null)
+const notificationsWrapper = ref()

 watch(notificationsWrapper, () => {
  notifications.setNotifs(notificationsWrapper.value)
 })

+const error = useError()
+const errorModal = ref()
+
+watch(errorModal, () => {
+  error.setErrorModal(errorModal.value)
+})
+
 document.querySelector('body').addEventListener('click', function (e) {
  let target = e.target
  while (target != null) {
@@ -193,23 +234,64 @@ document.querySelector('body').addEventListener('auxclick', function (e) {

 const accounts = ref(null)

-command_listener((e) => {
-  console.log(e)
-  urlModal.value.show(e)
+command_listener(async (e) => {
+  if (e.event === 'RunMRPack') {
+    // RunMRPack should directly install a local mrpack given a path
+    if (e.path.endsWith('.mrpack')) {
+      await install_from_file(e.path).catch(handleError)
+      mixpanel_track('InstanceCreate', {
+        source: 'CreationModalFileDrop',
+      })
+    }
+  } else {
+    // Other commands are URL-based (deep linking)
+    urlModal.value.show(e)
+  }
 })
 </script>

 <template>
-  <StickyTitleBar v-if="videoPlaying" />
-  <video
-    v-if="videoPlaying"
-    ref="onboardingVideo"
-    class="video"
-    src="@/assets/video.mp4"
-    autoplay
-    @ended="videoPlaying = false"
-  />
-  <SplashScreen v-else-if="!videoPlaying && isLoading" app-loading />
+  <div v-if="failureText" class="failure dark-mode">
+    <div class="appbar-failure dark-mode">
+      <Button v-if="os != 'MacOS'" icon-only @click="TauriWindow.getCurrent().close()">
+        <XIcon />
+      </Button>
+    </div>
+    <div class="error-view dark-mode">
+      <Card class="error-text">
+        <div class="label">
+          <h3>
+            <span class="label__title size-card-header">Failed to initialize</span>
+          </h3>
+        </div>
+        <div class="error-div">
+          Modrinth App failed to load correctly. This may be because of a corrupted file, or because
+          the app is missing crucial files.
+        </div>
+        <div class="error-div">You may be able to fix it one of the following ways:</div>
+        <ul class="error-div">
+          <li>Ennsuring you are connected to the internet, then try restarting the app.</li>
+          <li>Redownloading the app.</li>
+        </ul>
+        <div class="error-div">
+          If it still does not work, you can seek support using the link below. You should provide
+          the following error, as well as any recent launcher logs in the folder below.
+        </div>
+        <div class="error-div">The following error was provided:</div>
+
+        <Card class="error-message">
+          {{ failureText.message }}
+        </Card>
+
+        <div class="button-row push-right">
+          <Button @click="showLauncherLogsFolder"><FileIcon />Open launcher logs</Button>
+
+          <Button @click="openSupport"><ChatIcon />Get support</Button>
+        </div>
+      </Card>
+    </div>
+  </div>
+  <SplashScreen v-else-if="isLoading" app-loading />
  <OnboardingScreen v-else-if="showOnboarding" :finish="() => (showOnboarding = false)" />
  <div v-else class="container">
    <div class="nav-container">
@@ -266,7 +348,7 @@ command_listener((e) => {
            </Suspense>
          </section>
        </div>
-        <section class="window-controls">
+        <section v-if="!nativeDecorations" class="window-controls">
          <Button class="titlebar-button" icon-only @click="() => appWindow.minimize()">
            <MinimizeIcon />
          </Button>
@@ -304,6 +386,7 @@ command_listener((e) => {
  </div>
  <URLConfirmModal ref="urlModal" />
  <Notifications ref="notificationsWrapper" />
+  <ErrorModal ref="errorModal" />
 </template>

 <style lang="scss" scoped>
@@ -366,13 +449,13 @@ command_listener((e) => {

  .view {
    width: calc(100% - var(--sidebar-width));
+    background-color: var(--color-raised-bg);

    .appbar {
      display: flex;
      align-items: center;
      flex-grow: 1;
      background: var(--color-raised-bg);
-      box-shadow: var(--shadow-inset-sm), var(--shadow-floating);
      text-align: center;
      padding: var(--gap-md);
      height: 3.25rem;
@@ -388,6 +471,54 @@ command_listener((e) => {
      overflow: auto;
      overflow-x: hidden;
      background-color: var(--color-bg);
+      border-top-left-radius: var(--radius-xl);
+    }
+  }
+}
+
+.failure {
+  height: 100vh;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  background-color: var(--color-bg);
+
+  .appbar-failure {
+    display: flex; /* Change to flex to align items horizontally */
+    justify-content: flex-end; /* Align items to the right */
+    height: 3.25rem;
+    //no select
+    user-select: none;
+    -webkit-user-select: none;
+  }
+
+  .error-view {
+    display: flex; /* Change to flex to align items horizontally */
+    justify-content: center;
+    width: 100%;
+    background-color: var(--color-bg);
+
+    color: var(--color-base);
+
+    .card {
+      background-color: var(--color-raised-bg);
+    }
+
+    .error-text {
+      display: flex;
+      max-width: 60%;
+      gap: 0.25rem;
+      flex-direction: column;
+
+      .error-div {
+        // spaced out
+        margin: 0.5rem;
+      }
+
+      .error-message {
+        margin: 0.5rem;
+        background-color: var(--color-button-bg);
+      }
    }
  }
 }
@@ -521,4 +652,15 @@ command_listener((e) => {
  object-fit: cover;
  border-radius: var(--radius-md);
 }
+
+.button-row {
+  display: flex;
+  flex-direction: row;
+  justify-content: space-between;
+  gap: var(--gap-md);
+
+  .transparent {
+    padding: var(--gap-sm) 0;
+  }
+}
 </style>
--- a/theseus_gui/src/assets/external/google.svg
+++ b/theseus_gui/src/assets/external/google.svg
@@ -1,20 +1,22 @@
 <svg
  data-v-8c2610d6=""
+  xmlns="http://www.w3.org/2000/svg"
  xml:space="preserve"
  viewBox="0 0 100 100"
  style="fill-rule: evenodd; clip-rule: evenodd; stroke-linejoin: round; stroke-miterlimit: 2;"><circle cx="50" cy="50" r="50" style="fill:#fff;"
 />
-  <g transform="translate(14.39 14.302) scale(.09916)"><clipPath id="a"><path d="M0 0h705.6v720H0z"/></clipPath>
-    <g clip-path="url(#a)"><path d="M-4117.16-2597.44v139.42h193.74c-8.51 44.84-34.04 82.8-72.33 108.33l116.84 90.66c68.07-62.84 107.35-155.13 107.35-264.77 0-25.53-2.29-50.07-6.55-73.63l-339.05-.01Z" style="fill:#4285f4;fill-rule:nonzero;" transform="translate(4477.16 2891.98)"/>
-      <path
-        d="m-4318.92-2463.46-26.35 20.17-93.28 72.65c59.24 117.49 180.65 198.66 321.38 198.66 97.2 0 178.69-32.07 238.25-87.05l-116.83-90.66c-32.08 21.6-72.99 34.69-121.42 34.69-93.6 0-173.13-63.16-201.6-148.25l-.15-.21Z"
-        style="fill:#34a853;fill-rule:nonzero;" transform="translate(4477.16 2891.98)"/>
-      <path
-        d="M-4438.55-2693.33c-24.54 48.44-38.61 103.09-38.61 161.34 0 58.26 14.07 112.91 38.61 161.35 0 .32 119.79-92.95 119.79-92.95-7.2-21.6-11.46-44.5-11.46-68.4 0-23.89 4.26-46.8 11.46-68.4l-119.79-92.94Z"
-        style="fill:#fbbc05;fill-rule:nonzero;" transform="translate(4477.16 2891.98)"/>
-      <path
-        d="M-4117.16-2748.64c53.02 0 100.14 18.33 137.78 53.67l103.09-103.09c-62.51-58.25-143.67-93.93-240.87-93.93-140.73 0-262.15 80.84-321.39 198.66l119.79 92.95c28.47-85.09 108-148.26 201.6-148.26Z"
-        style="fill:#ea4335;fill-rule:nonzero;" transform="translate(4477.16 2891.98)"/>
-    </g>
+  <g transform="translate(14.39 14.302) scale(.09916)">
+    <path
+      d="M-4117.16-2597.44v139.42h193.74c-8.51 44.84-34.04 82.8-72.33 108.33l116.84 90.66c68.07-62.84 107.35-155.13 107.35-264.77 0-25.53-2.29-50.07-6.55-73.63l-339.05-.01Z"
+      style="fill:#4285f4;fill-rule:nonzero;" transform="translate(4477.16 2891.98)"/>
+    <path
+      d="m-4318.92-2463.46-26.35 20.17-93.28 72.65c59.24 117.49 180.65 198.66 321.38 198.66 97.2 0 178.69-32.07 238.25-87.05l-116.83-90.66c-32.08 21.6-72.99 34.69-121.42 34.69-93.6 0-173.13-63.16-201.6-148.25l-.15-.21Z"
+      style="fill:#34a853;fill-rule:nonzero;" transform="translate(4477.16 2891.98)"/>
+    <path
+      d="M-4438.55-2693.33c-24.54 48.44-38.61 103.09-38.61 161.34 0 58.26 14.07 112.91 38.61 161.35 0 .32 119.79-92.95 119.79-92.95-7.2-21.6-11.46-44.5-11.46-68.4 0-23.89 4.26-46.8 11.46-68.4l-119.79-92.94Z"
+      style="fill:#fbbc05;fill-rule:nonzero;" transform="translate(4477.16 2891.98)"/>
+    <path
+      d="M-4117.16-2748.64c53.02 0 100.14 18.33 137.78 53.67l103.09-103.09c-62.51-58.25-143.67-93.93-240.87-93.93-140.73 0-262.15 80.84-321.39 198.66l119.79 92.95c28.47-85.09 108-148.26 201.6-148.26Z"
+      style="fill:#ea4335;fill-rule:nonzero;" transform="translate(4477.16 2891.98)"/>
  </g>
 </svg>
--- a/theseus_gui/src/assets/video.mp4
+++ b/theseus_gui/src/assets/video.mp4
--- a/theseus_gui/src/components/GridDisplay.vue
+++ b/theseus_gui/src/components/GridDisplay.vue
@@ -20,7 +20,7 @@ import {
 import ContextMenu from '@/components/ui/ContextMenu.vue'
 import dayjs from 'dayjs'
 import { useTheming } from '@/store/theme.js'
-import { remove } from '@/helpers/profile.js'
+import { duplicate, remove } from '@/helpers/profile.js'
 import { handleError } from '@/store/notifications.js'

 const props = defineProps({
@@ -45,17 +45,23 @@ const confirmModal = ref(null)
 async function deleteProfile() {
  if (currentDeleteInstance.value) {
    instanceComponents.value = instanceComponents.value.filter(
-      (x) => x.instance.path !== currentDeleteInstance.value
+      (x) => x.instance.path !== currentDeleteInstance.value,
    )
    await remove(currentDeleteInstance.value).catch(handleError)
  }
 }

-const handleRightClick = (event, item) => {
+async function duplicateProfile(p) {
+  await duplicate(p).catch(handleError)
+}
+
+const handleRightClick = (event, profilePathId) => {
+  const item = instanceComponents.value.find((x) => x.instance.path === profilePathId)
  const baseOptions = [
    { name: 'add_content' },
    { type: 'divider' },
    { name: 'edit' },
+    { name: 'duplicate' },
    { name: 'open' },
    { name: 'copy' },
    { type: 'divider' },
@@ -82,7 +88,7 @@ const handleRightClick = (event, item) => {
            color: 'primary',
          },
          ...baseOptions,
-        ]
+        ],
  )
 }

@@ -100,6 +106,10 @@ const handleOptionsClick = async (args) => {
    case 'edit':
      await args.item.seeInstance()
      break
+    case 'duplicate':
+      if (args.item.instance.install_stage == 'installed')
+        await duplicateProfile(args.item.instance.path)
+      break
    case 'open':
      await args.item.openFolder()
      break
@@ -131,7 +141,7 @@ const filteredResults = computed(() => {

  if (sortBy.value === 'Game version') {
    instances.sort((a, b) => {
-      return a.metadata.name.localeCompare(b.metadata.game_version)
+      return a.metadata.game_version.localeCompare(b.metadata.game_version)
    })
  }

@@ -285,11 +295,11 @@ const filteredResults = computed(() => {
    </div>
    <section class="instances">
      <Instance
-        v-for="(instance, index) in instanceSection.value"
+        v-for="instance in instanceSection.value"
        ref="instanceComponents"
-        :key="instance.path"
+        :key="instance.path + instance.install_stage"
        :instance="instance"
-        @contextmenu.prevent.stop="(event) => handleRightClick(event, instanceComponents[index])"
+        @contextmenu.prevent.stop="(event) => handleRightClick(event, instance.path)"
      />
    </section>
  </div>
@@ -298,6 +308,7 @@ const filteredResults = computed(() => {
    <template #stop> <StopCircleIcon /> Stop </template>
    <template #add_content> <PlusIcon /> Add content </template>
    <template #edit> <EyeIcon /> View instance </template>
+    <template #duplicate> <ClipboardCopyIcon /> Duplicate instance</template>
    <template #delete> <TrashIcon /> Delete </template>
    <template #open> <FolderOpenIcon /> Open folder </template>
    <template #copy> <ClipboardCopyIcon /> Copy path </template>
--- a/theseus_gui/src/components/RowDisplay.vue
+++ b/theseus_gui/src/components/RowDisplay.vue
@@ -25,13 +25,14 @@ import {
  kill_by_uuid,
 } from '@/helpers/process.js'
 import { handleError } from '@/store/notifications.js'
-import { remove, run } from '@/helpers/profile.js'
+import { duplicate, remove, run } from '@/helpers/profile.js'
 import { useRouter } from 'vue-router'
 import { showProfileInFolder } from '@/helpers/utils.js'
 import { useFetch } from '@/helpers/fetch.js'
 import { install as pack_install } from '@/helpers/pack.js'
 import { useTheming } from '@/store/state.js'
 import { mixpanel_track } from '@/helpers/mixpanel'
+import { handleSevereError } from '@/store/error.js'

 const router = useRouter()

@@ -50,7 +51,7 @@ const props = defineProps({
 })

 const actualInstances = computed(() =>
-  props.instances.filter((x) => x && x.instances && x.instances[0])
+  props.instances.filter((x) => x && x.instances && x.instances[0]),
 )

 const modsRow = ref(null)
@@ -70,11 +71,16 @@ async function deleteProfile() {
  }
 }

+async function duplicateProfile(p) {
+  await duplicate(p).catch(handleError)
+}
+
 const handleInstanceRightClick = async (event, passedInstance) => {
  const baseOptions = [
    { name: 'add_content' },
    { type: 'divider' },
    { name: 'edit' },
+    { name: 'duplicate' },
    { name: 'open_folder' },
    { name: 'copy_path' },
    { type: 'divider' },
@@ -124,7 +130,7 @@ const handleProjectClick = (event, passedInstance) => {
 const handleOptionsClick = async (args) => {
  switch (args.option) {
    case 'play':
-      await run(args.item.path).catch(handleError)
+      await run(args.item.path).catch(handleSevereError)
      mixpanel_track('InstanceStart', {
        loader: args.item.metadata.loader,
        game_version: args.item.metadata.game_version,
@@ -150,6 +156,9 @@ const handleOptionsClick = async (args) => {
        path: `/instance/${encodeURIComponent(args.item.path)}/`,
      })
      break
+    case 'duplicate':
+      if (args.item.install_stage == 'installed') await duplicateProfile(args.item.path)
+      break
    case 'delete':
      currentDeleteInstance.value = args.item.path
      deleteConfirmModal.value.show()
@@ -163,7 +172,7 @@ const handleOptionsClick = async (args) => {
    case 'install': {
      const versions = await useFetch(
        `https://api.modrinth.com/v2/project/${args.item.project_id}/version`,
-        'project versions'
+        'project versions',
      )

      if (args.item.project_type === 'modpack') {
@@ -171,7 +180,7 @@ const handleOptionsClick = async (args) => {
          args.item.project_id,
          versions[0].id,
          args.item.title,
-          args.item.icon_url
+          args.item.icon_url,
        )
      } else {
        modInstallModal.value.show(args.item.project_id, versions)
@@ -189,14 +198,14 @@ const handleOptionsClick = async (args) => {
      break
    case 'copy_link':
      await navigator.clipboard.writeText(
-        `https://modrinth.com/${args.item.project_type}/${args.item.slug}`
+        `https://modrinth.com/${args.item.project_type}/${args.item.slug}`,
      )
      break
  }
 }

-const maxInstancesPerRow = ref(0)
-const maxProjectsPerRow = ref(0)
+const maxInstancesPerRow = ref(1)
+const maxProjectsPerRow = ref(1)

 const calculateCardsPerRow = () => {
  // Calculate how many cards fit in one row
@@ -237,7 +246,7 @@ onUnmounted(() => {
      <section v-if="row.instances[0].metadata" ref="modsRow" class="instances">
        <Instance
          v-for="instance in row.instances.slice(0, maxInstancesPerRow)"
-          :key="instance?.project_id || instance?.id"
+          :key="(instance?.project_id || instance?.id) + instance.install_stage"
          :instance="instance"
          @contextmenu.prevent.stop="(event) => handleInstanceRightClick(event, instance)"
        />
@@ -263,6 +272,7 @@ onUnmounted(() => {
    <template #edit> <EyeIcon /> View instance </template>
    <template #delete> <TrashIcon /> Delete </template>
    <template #open_folder> <FolderOpenIcon /> Open folder </template>
+    <template #duplicate> <ClipboardCopyIcon /> Duplicate instance</template>
    <template #copy_path> <ClipboardCopyIcon /> Copy path </template>
    <template #install> <DownloadIcon /> Install </template>
    <template #open_link> <GlobeIcon /> Open in Modrinth <ExternalIcon /> </template>
--- a/theseus_gui/src/components/modrinth-loading-indicator.js
+++ b/theseus_gui/src/components/modrinth-loading-indicator.js
@@ -66,7 +66,7 @@ export default defineComponent({
            zIndex: 6,
          },
        },
-        slots
+        slots,
      )
  },
 })
--- a/theseus_gui/src/components/ui/AccountsCard.vue
+++ b/theseus_gui/src/components/ui/AccountsCard.vue
@@ -2,7 +2,7 @@
  <div
    v-if="mode !== 'isolated'"
    ref="button"
-    v-tooltip="'Minecraft accounts'"
+    v-tooltip.right="'Minecraft accounts'"
    class="button-base avatar-button"
    :class="{ expanded: mode === 'expanded' }"
    @click="showCard = !showCard"
@@ -56,62 +56,22 @@
      </Button>
    </Card>
  </transition>
-  <Modal ref="loginModal" class="modal" header="Signing in">
-    <div class="modal-body">
-      <QrcodeVue :value="loginUrl" class="qr-code" margin="3" size="160" />
-      <div class="modal-text">
-        <p>
-          Sign into Microsoft with your browser. If your browser didn't open, you can copy and open
-          the link below, or scan the QR code with your device.
-        </p>
-        <div class="iconified-input">
-          <LogInIcon />
-          <input type="text" :value="loginUrl" readonly />
-          <Button
-            v-tooltip="'Copy link'"
-            icon-only
-            color="raised"
-            @click="() => navigator.clipboard.writeText(loginUrl)"
-          >
-            <ClipboardCopyIcon />
-          </Button>
-        </div>
-        <div class="button-row">
-          <Button @click="openUrl">
-            <GlobeIcon />
-            Open link
-          </Button>
-          <Button class="transparent" @click="loginModal.hide"> Cancel </Button>
-        </div>
-      </div>
-    </div>
-  </Modal>
 </template>

 <script setup>
-import {
-  Avatar,
-  Button,
-  Card,
-  PlusIcon,
-  TrashIcon,
-  LogInIcon,
-  Modal,
-  GlobeIcon,
-  ClipboardCopyIcon,
-} from 'omorphia'
-import { ref, computed, onMounted, onBeforeUnmount } from 'vue'
+import { Avatar, Button, Card, PlusIcon, TrashIcon, LogInIcon } from 'omorphia'
+import { ref, computed, onMounted, onBeforeUnmount, onUnmounted } from 'vue'
 import {
  users,
  remove_user,
-  authenticate_begin_flow,
-  authenticate_await_completion,
+  set_default_user,
+  login as login_flow,
+  get_default_user,
 } from '@/helpers/auth'
-import { get, set } from '@/helpers/settings'
 import { handleError } from '@/store/state.js'
-import { get as getCreds, login_minecraft } from '@/helpers/mr_auth'
 import { mixpanel_track } from '@/helpers/mixpanel'
-import QrcodeVue from 'qrcode.vue'
+import { process_listener } from '@/helpers/events'
+import { handleSevereError } from '@/store/error.js'

 defineProps({
  mode: {
@@ -123,13 +83,11 @@ defineProps({

 const emit = defineEmits(['change'])

-const settings = ref({})
-const accounts = ref([])
-const loginUrl = ref('')
-const loginModal = ref(null)
+const accounts = ref({})
+const defaultUser = ref()

 async function refreshValues() {
-  settings.value = await get().catch(handleError)
+  defaultUser.value = await get_default_user().catch(handleError)
  accounts.value = await users().catch(handleError)
 }
 defineExpose({
@@ -138,50 +96,27 @@ defineExpose({
 await refreshValues()

 const displayAccounts = computed(() =>
-  accounts.value.filter((account) => settings.value.default_user !== account.id)
+  accounts.value.filter((account) => defaultUser.value !== account.id),
 )

 const selectedAccount = computed(() =>
-  accounts.value.find((account) => account.id === settings.value.default_user)
+  accounts.value.find((account) => account.id === defaultUser.value),
 )

 async function setAccount(account) {
-  settings.value.default_user = account.id
-  await set(settings.value).catch(handleError)
+  defaultUser.value = account.id
+  await set_default_user(account.id).catch(handleError)
  emit('change')
 }

 async function login() {
-  const url = await authenticate_begin_flow().catch(handleError)
-  loginUrl.value = url
+  const loggedIn = await login_flow().catch(handleSevereError)

-  await window.__TAURI_INVOKE__('tauri', {
-    __tauriModule: 'Shell',
-    message: {
-      cmd: 'open',
-      path: url,
-    },
-  })
-
-  loginModal.value.show()
-
-  const loggedIn = await authenticate_await_completion().catch(handleError)
-
-  if (loggedIn && loggedIn[0]) {
-    await setAccount(loggedIn[0])
+  if (loggedIn) {
+    await setAccount(loggedIn)
    await refreshValues()
-
-    const creds = await getCreds().catch(handleError)
-    if (!creds) {
-      try {
-        await login_minecraft(loggedIn[1])
-      } catch (err) {
-        /* empty */
-      }
-    }
  }

-  loginModal.value.hide()
  mixpanel_track('AccountLogIn')
 }

@@ -212,6 +147,12 @@ const handleClickOutside = (event) => {
  }
 }

+const unlisten = await process_listener(async (e) => {
+  if (e.event === 'launched') {
+    await refreshValues()
+  }
+})
+
 onMounted(() => {
  window.addEventListener('click', handleClickOutside)
 })
@@ -219,6 +160,10 @@ onMounted(() => {
 onBeforeUnmount(() => {
  window.removeEventListener('click', handleClickOutside)
 })
+
+onUnmounted(() => {
+  unlisten()
+})
 </script>

 <style scoped lang="scss">
@@ -382,17 +327,42 @@ onBeforeUnmount(() => {
  flex-direction: row;
  gap: var(--gap-lg);
  align-items: center;
-  padding: var(--gap-lg);
+  padding: var(--gap-xl);

  .modal-text {
    display: flex;
    flex-direction: column;
    gap: var(--gap-sm);
+    width: 100%;

    h2,
    p {
      margin: 0;
    }
+
+    .code-text {
+      display: flex;
+      flex-direction: row;
+      gap: var(--gap-xs);
+      align-items: center;
+
+      .code {
+        background-color: var(--color-bg);
+        border-radius: var(--radius-md);
+        border: solid 1px var(--color-button-bg);
+        font-family: var(--mono-font);
+        letter-spacing: var(--gap-md);
+        color: var(--color-contrast);
+        font-size: 2rem;
+        font-weight: bold;
+        padding: var(--gap-sm) 0 var(--gap-sm) var(--gap-md);
+      }
+
+      .btn {
+        width: 2.5rem;
+        height: 2.5rem;
+      }
+    }
  }
 }

@@ -404,4 +374,17 @@ onBeforeUnmount(() => {
 .modal {
  position: absolute;
 }
+
+.code {
+  color: var(--color-brand);
+  padding: 0.05rem 0.1rem;
+  // row not column
+  display: flex;
+
+  .card {
+    background: var(--color-base);
+    color: var(--color-contrast);
+    padding: 0.5rem 1rem;
+  }
+}
 </style>
--- a/theseus_gui/src/components/ui/Breadcrumbs.vue
+++ b/theseus_gui/src/components/ui/Breadcrumbs.vue
@@ -44,8 +44,8 @@ const breadcrumbs = computed(() => {
    route.meta.useContext === true
      ? breadcrumbData.context
      : route.meta.useRootContext === true
-      ? breadcrumbData.rootContext
-      : null
+        ? breadcrumbData.rootContext
+        : null
  return additionalContext ? [additionalContext, ...route.meta.breadcrumb] : route.meta.breadcrumb
 })
 </script>
--- a/theseus_gui/src/components/ui/ContextMenu.vue
+++ b/theseus_gui/src/components/ui/ContextMenu.vue
@@ -11,7 +11,11 @@
    >
      <div v-for="(option, index) in options" :key="index" @click.stop="optionClicked(option.name)">
        <hr v-if="option.type === 'divider'" class="divider" />
-        <div v-else class="item clickable" :class="[option.color ?? 'base']">
+        <div
+          v-else-if="!(isLinkedData(item) && option.name === `add_content`)"
+          class="item clickable"
+          :class="[option.color ?? 'base']"
+        >
          <slot :name="option.name" />
        </div>
      </div>
@@ -55,6 +59,15 @@ defineExpose({
  },
 })

+const isLinkedData = (item) => {
+  if (item.instance != undefined && item.instance.metadata.linked_data) {
+    return true
+  } else if (item.metadata != undefined && item.metadata.linked_data) {
+    return true
+  }
+  return false
+}
+
 const hideContextMenu = () => {
  shown.value = false
  emit('menu-closed')
--- a/theseus_gui/src/components/ui/ErrorModal.vue
+++ b/theseus_gui/src/components/ui/ErrorModal.vue
@@ -0,0 +1,223 @@
+<script setup>
+import { Modal, XIcon, IssuesIcon, LogInIcon } from 'omorphia'
+import { ChatIcon } from '@/assets/icons'
+import { ref } from 'vue'
+import { login as login_flow, set_default_user } from '@/helpers/auth.js'
+import { handleError } from '@/store/notifications.js'
+import mixpanel from 'mixpanel-browser'
+import { handleSevereError } from '@/store/error.js'
+
+const errorModal = ref()
+const error = ref()
+
+const title = ref('An error occurred')
+const errorType = ref('unknown')
+const supportLink = ref('https://support.modrinth.com')
+const metadata = ref({})
+
+defineExpose({
+  async show(errorVal) {
+    if (errorVal.message && errorVal.message.includes('Minecraft authentication error:')) {
+      title.value = 'Unable to sign in to Minecraft'
+      errorType.value = 'minecraft_auth'
+      supportLink.value =
+        'https://support.modrinth.com/en/articles/9038231-minecraft-sign-in-issues'
+
+      if (errorVal.message.includes('existing connection was forcibly closed')) {
+        metadata.value.network = true
+      }
+      if (errorVal.message.includes('because the target machine actively refused it')) {
+        metadata.value.hostsFile = true
+      }
+    } else if (errorVal.message && errorVal.message.includes('User is not logged in')) {
+      title.value = 'Sign in to Minecraft'
+      errorType.value = 'minecraft_sign_in'
+      supportLink.value = 'https://support.modrinth.com'
+    } else {
+      title.value = 'An error occurred'
+      errorType.value = 'unknown'
+      supportLink.value = 'https://support.modrinth.com'
+      metadata.value = {}
+    }
+
+    error.value = errorVal
+    errorModal.value.show()
+  },
+})
+
+const loadingMinecraft = ref(false)
+async function loginMinecraft() {
+  try {
+    loadingMinecraft.value = true
+    const loggedIn = await login_flow()
+
+    if (loggedIn) {
+      await set_default_user(loggedIn.id).catch(handleError)
+    }
+
+    await mixpanel.track('AccountLogIn')
+    loadingMinecraft.value = false
+    errorModal.value.hide()
+  } catch (err) {
+    loadingMinecraft.value = false
+    handleSevereError(err)
+  }
+}
+</script>
+
+<template>
+  <Modal ref="errorModal" :header="title">
+    <div class="modal-body">
+      <div class="markdown-body">
+        <template v-if="errorType === 'minecraft_auth'">
+          <p>
+            Signing into Microsoft account is a complex task for the launchers, and there are a lot
+            of things can go wrong.
+          </p>
+          <template v-if="metadata.network">
+            <h3>Network issues</h3>
+            <p>
+              It looks like there were issues with the Modrinth App connecting to Microsoft's
+              servers. This is often the result of a poor connection, so we recommend trying again
+              to see if it works. If issues continue to persist, follow the steps in
+              <a
+                href="https://support.modrinth.com/en/articles/9038231-minecraft-sign-in-issues#h_e71a5f805f"
+              >
+                our support article
+              </a>
+              to troubleshoot.
+            </p>
+          </template>
+          <template v-else-if="metadata.hostsFile">
+            <h3>Network issues</h3>
+            <p>
+              The Modrinth App tried to connect to Microsoft / Xbox / Minecraft services, but the
+              remote server rejected the connection. This may indicate that these services are
+              blocked by the hosts file. Please visit
+              <a
+                href="https://support.modrinth.com/en/articles/9038231-minecraft-sign-in-issues#h_d694a29256"
+              >
+                our support article
+              </a>
+              for steps on how to fix the issue.
+            </p>
+          </template>
+          <template v-else>
+            <h3>Make sure you are signing into the right Microsoft account</h3>
+            <p>
+              More often than not, this error is caused by you signing into an incorrect Microsoft
+              account which isn't linked to Minecraft. Double check and try again!
+            </p>
+            <h3>Try signing in and launching through the official launcher first</h3>
+            <p>
+              If you just bought Minecraft, are coming from the Bedrock Edition world and have never
+              played Java before, or just subscribed to PC Game Pass, you would need to start the
+              game at least once using the
+              <a href="https://www.minecraft.net/en-us/download">official Minecraft Launcher</a>.
+              Once you're done, come back here and sign in!
+            </p>
+          </template>
+          <div class="cta-button">
+            <button class="btn btn-primary" :disabled="loadingMinecraft" @click="loginMinecraft">
+              <LogInIcon /> Sign in to Minecraft
+            </button>
+          </div>
+          <hr />
+          <p>
+            If nothing is working and you need help, visit
+            <a :href="supportLink">our support page</a>
+            and start a chat using the widget in the bottom right and we will be more than happy to
+            assist!
+          </p>
+          <details>
+            <summary>Debug info</summary>
+            {{ error.message ?? error }}
+          </details>
+        </template>
+        <div v-else-if="errorType === 'minecraft_sign_in'">
+          <div class="warning-banner">
+            <div class="warning-banner__title">
+              <IssuesIcon />
+              <span>Installed the app before April 23rd, 2024?</span>
+            </div>
+            <div class="warning-banner__description">
+              Modrinth has updated our sign-in workflow to allow for better stability, security, and
+              performance. You must sign in again so your credentials can be upgraded to this new
+              flow.
+            </div>
+          </div>
+          <p>
+            To play this instance, you must sign in through Microsoft below. If you don't have a
+            Minecraft account, you can purchase the game on the
+            <a href="https://www.minecraft.net/en-us/store/minecraft-java-bedrock-edition-pc"
+              >Minecraft website</a
+            >.
+          </p>
+          <div class="cta-button">
+            <button class="btn btn-primary" :disabled="loadingMinecraft" @click="loginMinecraft">
+              <LogInIcon /> Sign in to Minecraft
+            </button>
+          </div>
+        </div>
+        <template v-else>
+          {{ error.message ?? error }}
+        </template>
+      </div>
+      <div class="input-group push-right">
+        <a :href="supportLink" class="btn" @click="errorModal.hide()"><ChatIcon /> Get support</a>
+        <button class="btn" @click="errorModal.hide()"><XIcon /> Close</button>
+      </div>
+    </div>
+  </Modal>
+</template>
+
+<style>
+.light-mode {
+  --color-orange-bg: rgba(255, 163, 71, 0.2);
+}
+
+.dark-mode,
+.oled-mode {
+  --color-orange-bg: rgba(224, 131, 37, 0.2);
+}
+</style>
+
+<style scoped lang="scss">
+.cta-button {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0.5rem;
+}
+
+.warning-banner {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  padding: var(--gap-lg);
+  background-color: var(--color-orange-bg);
+  border: 2px solid var(--color-orange);
+  border-radius: var(--radius-md);
+  margin-bottom: 1rem;
+}
+
+.warning-banner__title {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  font-weight: 700;
+
+  svg {
+    color: var(--color-orange);
+    height: 1.5rem;
+    width: 1.5rem;
+  }
+}
+
+.modal-body {
+  display: flex;
+  flex-direction: column;
+  gap: var(--gap-md);
+  padding: var(--gap-lg);
+}
+</style>
--- a/theseus_gui/src/components/ui/ExportModal.vue
+++ b/theseus_gui/src/components/ui/ExportModal.vue
@@ -1,11 +1,10 @@
 <script setup>
-import { Button, Checkbox, Modal, SendIcon, XIcon } from 'omorphia'
+import { Button, Checkbox, Modal, XIcon, PlusIcon } from 'omorphia'
 import { PackageIcon, VersionIcon } from '@/assets/icons'
 import { ref } from 'vue'
-import { export_profile_mrpack, get_potential_override_folders } from '@/helpers/profile.js'
+import { export_profile_mrpack, get_pack_export_candidates } from '@/helpers/profile.js'
 import { open } from '@tauri-apps/api/dialog'
 import { handleError } from '@/store/notifications.js'
-import { sep } from '@tauri-apps/api/path'
 import { useTheming } from '@/store/theme'

 const props = defineProps({
@@ -24,21 +23,34 @@ defineExpose({

 const exportModal = ref(null)
 const nameInput = ref(props.instance.metadata.name)
+const exportDescription = ref('')
 const versionInput = ref('1.0.0')
 const files = ref([])
 const folders = ref([])
+const showingFiles = ref(false)

 const themeStore = useTheming()

 const initFiles = async () => {
  const newFolders = new Map()
+  const sep = '/'
  files.value = []
-  await get_potential_override_folders(props.instance.path).then((filePaths) =>
+  await get_pack_export_candidates(props.instance.path).then((filePaths) =>
    filePaths
      .map((folder) => ({
        path: folder,
        name: folder.split(sep).pop(),
-        selected: false,
+        selected:
+          folder.startsWith('mods') ||
+          folder.startsWith('datapacks') ||
+          folder.startsWith('resourcepacks') ||
+          folder.startsWith('shaderpacks') ||
+          folder.startsWith('config'),
+        disabled:
+          folder === 'profile.json' ||
+          folder.startsWith('modrinth_logs') ||
+          folder.startsWith('.fabric') ||
+          folder.includes('.DS_Store'),
      }))
      .forEach((pathData) => {
        const parent = pathData.path.split(sep).slice(0, -1).join(sep)
@@ -51,7 +63,7 @@ const initFiles = async () => {
        } else {
          files.value.push(pathData)
        }
-      })
+      }),
  )
  folders.value = [...newFolders.entries()].map(([name, value]) => [
    {
@@ -83,7 +95,9 @@ const exportPack = async () => {
      props.instance.path,
      outputPath + `/${nameInput.value} ${versionInput.value}.mrpack`,
      filesToExport,
-      versionInput.value
+      versionInput.value,
+      exportDescription.value,
+      nameInput.value,
    ).catch((err) => handleError(err))
    exportModal.value.hide()
  }
@@ -113,11 +127,31 @@ const exportPack = async () => {
          </Button>
        </div>
      </div>
+      <div class="adjacent-input">
+        <div class="labeled_input">
+          <p>Description</p>
+
+          <div class="textarea-wrapper">
+            <textarea v-model="exportDescription" placeholder="Enter modpack description..." />
+          </div>
+        </div>
+      </div>
+
      <div class="table">
        <div class="table-head">
-          <div class="table-cell">Select files as overrides</div>
+          <div class="table-cell row-wise">
+            Select files and folders to include in pack
+            <Button
+              class="sleek-primary collapsed-button"
+              icon-only
+              @click="() => (showingFiles = !showingFiles)"
+            >
+              <PlusIcon v-if="!showingFiles" />
+              <XIcon v-else />
+            </Button>
+          </div>
        </div>
-        <div class="table-content">
+        <div v-if="showingFiles" class="table-content">
          <div v-for="[path, children] of folders" :key="path.name" class="table-row">
            <div class="table-cell file-entry">
              <div class="file-primary">
@@ -125,6 +159,7 @@ const exportPack = async () => {
                  :model-value="children.every((child) => child.selected)"
                  :label="path.name"
                  class="select-checkbox"
+                  :disabled="children.every((x) => x.disabled)"
                  @update:model-value="
                    (newValue) => children.forEach((child) => (child.selected = newValue))
                  "
@@ -137,7 +172,12 @@ const exportPack = async () => {
              </div>
              <div v-if="path.showingMore" class="file-secondary">
                <div v-for="child in children" :key="child.path" class="file-secondary-row">
-                  <Checkbox v-model="child.selected" :label="child.name" class="select-checkbox" />
+                  <Checkbox
+                    v-model="child.selected"
+                    :label="child.name"
+                    class="select-checkbox"
+                    :disabled="child.disabled"
+                  />
                </div>
              </div>
            </div>
@@ -145,7 +185,12 @@ const exportPack = async () => {
          <div v-for="file in files" :key="file.path" class="table-row">
            <div class="table-cell file-entry">
              <div class="file-primary">
-                <Checkbox v-model="file.selected" :label="file.name" class="select-checkbox" />
+                <Checkbox
+                  v-model="file.selected"
+                  :label="file.name"
+                  :disabled="file.disabled"
+                  class="select-checkbox"
+                />
              </div>
            </div>
          </div>
@@ -156,10 +201,6 @@ const exportPack = async () => {
          <XIcon />
          Cancel
        </Button>
-        <Button disabled>
-          <SendIcon />
-          Share
-        </Button>
        <Button color="primary" @click="exportPack">
          <PackageIcon />
          Export
@@ -240,4 +281,24 @@ const exportPack = async () => {
  gap: var(--gap-sm);
  align-items: center;
 }
+
+.row-wise {
+  display: flex;
+  flex-direction: row;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.textarea-wrapper {
+  // margin-top: 1rem;
+  height: 12rem;
+
+  textarea {
+    max-height: 12rem;
+  }
+
+  .preview {
+    overflow-y: auto;
+  }
+}
 </style>
--- a/theseus_gui/src/components/ui/IncompatibilityWarningModal.vue
+++ b/theseus_gui/src/components/ui/IncompatibilityWarningModal.vue
@@ -82,7 +82,7 @@ defineExpose({
    selectedVersions,
    extMarkInstalled,
    projectIdVal,
-    projectTypeVal
+    projectTypeVal,
  ) => {
    instance.value = instanceVal
    projectTitle.value = projectTitleVal
--- a/theseus_gui/src/components/ui/InstallConfirmModal.vue
+++ b/theseus_gui/src/components/ui/InstallConfirmModal.vue
@@ -36,7 +36,7 @@ async function install() {
    projectId.value,
    version.value,
    title.value,
-    icon.value ? icon.value : null
+    icon.value ? icon.value : null,
  ).catch(handleError)
  mixpanel_track('PackInstall', {
    id: projectId.value,
--- a/theseus_gui/src/components/ui/Instance.vue
+++ b/theseus_gui/src/components/ui/Instance.vue
@@ -17,6 +17,7 @@ import { handleError } from '@/store/state.js'
 import { showProfileInFolder } from '@/helpers/utils.js'
 import ModInstallModal from '@/components/ui/ModInstallModal.vue'
 import { mixpanel_track } from '@/helpers/mixpanel'
+import { handleSevereError } from '@/store/error.js'

 const props = defineProps({
  instance: {
@@ -33,7 +34,7 @@ const playing = ref(false)

 const uuid = ref(null)
 const modLoading = ref(
-  props.instance.install_stage ? props.instance.install_stage !== 'installed' : false
+  props.instance.install_stage ? props.instance.install_stage !== 'installed' : false,
 )

 watch(
@@ -42,7 +43,7 @@ watch(
    modLoading.value = props.instance.install_stage
      ? props.instance.install_stage !== 'installed'
      : false
-  }
+  },
 )

 const router = useRouter()
@@ -72,7 +73,7 @@ const install = async (e) => {
  modLoading.value = true
  const versions = await useFetch(
    `https://api.modrinth.com/v2/project/${props.instance.project_id}/version`,
-    'project versions'
+    'project versions',
  )

  if (props.instance.project_type === 'modpack') {
@@ -89,7 +90,7 @@ const install = async (e) => {
        props.instance.project_id,
        versions[0].id,
        props.instance.title,
-        props.instance.icon_url
+        props.instance.icon_url,
      ).catch(handleError)
      modLoading.value = false

@@ -104,14 +105,14 @@ const install = async (e) => {
        props.instance.project_id,
        versions[0].id,
        props.instance.title,
-        props.instance.icon_url
+        props.instance.icon_url,
      )
  } else {
    modInstallModal.value.show(
      props.instance.project_id,
      versions,
      props.instance.title,
-      props.instance.project_type
+      props.instance.project_type,
    )
  }

@@ -121,7 +122,7 @@ const install = async (e) => {
 const play = async (e, context) => {
  e?.stopPropagation()
  modLoading.value = true
-  uuid.value = await run(props.instance.path).catch(handleError)
+  uuid.value = await run(props.instance.path).catch(handleSevereError)
  modLoading.value = false
  playing.value = true

@@ -187,7 +188,7 @@ onUnmounted(() => unlisten())
  <div class="instance">
    <Card class="instance-card-item button-base" @click="seeInstance" @mouseenter="checkProcess">
      <Avatar
-        size="sm"
+        size="lg"
        :src="
          props.instance.metadata
            ? !props.instance.metadata.icon ||
@@ -267,7 +268,10 @@ onUnmounted(() => unlisten())
  right: calc(var(--gap-md) * 2);
  bottom: 3.25rem;
  opacity: 0;
-  transition: 0.2s ease-in-out bottom, 0.2s ease-in-out opacity, 0.1s ease-in-out filter !important;
+  transition:
+    0.2s ease-in-out bottom,
+    0.2s ease-in-out opacity,
+    0.1s ease-in-out filter !important;
  cursor: pointer;
  box-shadow: var(--shadow-floating);

--- a/theseus_gui/src/components/ui/InstanceCreationModal.vue
+++ b/theseus_gui/src/components/ui/InstanceCreationModal.vue
@@ -20,7 +20,13 @@
      </div>
      <div class="input-row">
        <p class="input-label">Name</p>
-        <input v-model="profile_name" autocomplete="off" class="text-input" type="text" />
+        <input
+          v-model="profile_name"
+          autocomplete="off"
+          class="text-input"
+          type="text"
+          maxlength="100"
+        />
      </div>
      <div class="input-row">
        <p class="input-label">Loader</p>
@@ -171,14 +177,14 @@
            loading
              ? 'Importing...'
              : Array.from(profiles.values())
-                  .flatMap((e) => e)
-                  .some((e) => e.selected)
-              ? `Import ${
-                  Array.from(profiles.values())
                    .flatMap((e) => e)
-                    .filter((e) => e.selected).length
-                } profiles`
-              : 'Select profiles to import'
+                    .some((e) => e.selected)
+                ? `Import ${
+                    Array.from(profiles.values())
+                      .flatMap((e) => e)
+                      .filter((e) => e.selected).length
+                  } profiles`
+                : 'Select profiles to import'
          }}
        </Button>
        <ProgressBar
@@ -216,6 +222,7 @@ import {
  get_fabric_versions,
  get_forge_versions,
  get_quilt_versions,
+  get_neoforge_versions,
 } from '@/helpers/metadata'
 import { handleError } from '@/store/notifications.js'
 import Multiselect from 'vue-multiselect'
@@ -293,21 +300,28 @@ onUnmounted(() => {
  }
 })

-const [fabric_versions, forge_versions, quilt_versions, all_game_versions, loaders] =
-  await Promise.all([
-    get_fabric_versions().then(shallowRef).catch(handleError),
-    get_forge_versions().then(shallowRef).catch(handleError),
-    get_quilt_versions().then(shallowRef).catch(handleError),
-    get_game_versions().then(shallowRef).catch(handleError),
-    get_loaders()
-      .then((value) =>
-        value
-          .filter((item) => item.supported_project_types.includes('modpack'))
-          .map((item) => item.name.toLowerCase())
-      )
-      .then(ref)
-      .catch(handleError),
-  ])
+const [
+  fabric_versions,
+  forge_versions,
+  quilt_versions,
+  neoforge_versions,
+  all_game_versions,
+  loaders,
+] = await Promise.all([
+  get_fabric_versions().then(shallowRef).catch(handleError),
+  get_forge_versions().then(shallowRef).catch(handleError),
+  get_quilt_versions().then(shallowRef).catch(handleError),
+  get_neoforge_versions().then(shallowRef).catch(handleError),
+  get_game_versions().then(shallowRef).catch(handleError),
+  get_loaders()
+    .then((value) =>
+      value
+        .filter((item) => item.supported_project_types.includes('modpack'))
+        .map((item) => item.name.toLowerCase()),
+    )
+    .then(ref)
+    .catch(handleError),
+])
 loaders.value.unshift('vanilla')

 const game_versions = computed(() => {
@@ -320,6 +334,8 @@ const game_versions = computed(() => {
        defaultVal &= forge_versions.value.gameVersions.some((x) => item.id === x.id)
      } else if (loader.value === 'quilt') {
        defaultVal &= quilt_versions.value.gameVersions.some((x) => item.id === x.id)
+      } else if (loader.value === 'neoforge') {
+        defaultVal &= neoforge_versions.value.gameVersions.some((x) => item.id === x.id)
      }

      return defaultVal
@@ -351,7 +367,7 @@ const create_instance = async () => {
    game_version.value,
    loader.value,
    loader.value === 'vanilla' ? null : loader_version_value ?? 'stable',
-    icon.value
+    icon.value,
  ).catch(handleError)

  mixpanel_track('InstanceCreate', {
@@ -394,6 +410,10 @@ const selectable_versions = computed(() => {
        .loaders.map((item) => item.id)
    } else if (loader.value === 'quilt') {
      return quilt_versions.value.gameVersions[0].loaders.map((item) => item.id)
+    } else if (loader.value === 'neoforge') {
+      return neoforge_versions.value.gameVersions
+        .find((item) => item.id === game_version.value)
+        .loaders.map((item) => item.id)
    }
  }
  return []
@@ -421,7 +441,7 @@ const profiles = ref(
    ['ATLauncher', []],
    ['Curseforge', []],
    ['PrismLauncher', []],
-  ])
+  ]),
 )

 const loading = ref(false)
@@ -450,7 +470,7 @@ const promises = profileOptions.value.map(async (option) => {
    profileOptions.value.find((profile) => profile.name === option.name).path = path
    profiles.value.set(
      option.name,
-      instances.map((name) => ({ name, selected: false }))
+      instances.map((name) => ({ name, selected: false })),
    )
  } catch (error) {
    // Allow failure silently
@@ -469,12 +489,12 @@ const selectLauncherPath = async () => {
 const reload = async () => {
  const instances = await get_importable_instances(
    selectedProfileType.value.name,
-    selectedProfileType.value.path
+    selectedProfileType.value.path,
  ).catch(handleError)
  if (instances) {
    profiles.value.set(
      selectedProfileType.value.name,
-      instances.map((name) => ({ name, selected: false }))
+      instances.map((name) => ({ name, selected: false })),
    )
  } else {
    profiles.value.set(selectedProfileType.value.name, [])
--- a/theseus_gui/src/components/ui/JavaDetectionModal.vue
+++ b/theseus_gui/src/components/ui/JavaDetectionModal.vue
@@ -37,12 +37,7 @@
 <script setup>
 import { Modal, PlusIcon, CheckIcon, Button, XIcon } from 'omorphia'
 import { ref } from 'vue'
-import {
-  find_jre_17_jres,
-  find_jre_18plus_jres,
-  find_jre_8_jres,
-  get_all_jre,
-} from '@/helpers/jre.js'
+import { find_filtered_jres } from '@/helpers/jre.js'
 import { handleError } from '@/store/notifications.js'
 import { mixpanel_track } from '@/helpers/mixpanel'
 import { useTheming } from '@/store/theme.js'
@@ -55,15 +50,10 @@ const currentSelected = ref({})

 defineExpose({
  show: async (version, currentSelectedJava) => {
-    if (version <= 8 && !!version) {
-      chosenInstallOptions.value = await find_jre_8_jres().catch(handleError)
-    } else if (version >= 18) {
-      chosenInstallOptions.value = await find_jre_18plus_jres().catch(handleError)
-    } else if (version) {
-      chosenInstallOptions.value = await find_jre_17_jres().catch(handleError)
-    } else {
-      chosenInstallOptions.value = await get_all_jre().catch(handleError)
-    }
+    chosenInstallOptions.value = await find_filtered_jres(version).catch(handleError)
+
+    console.log(chosenInstallOptions.value)
+    console.log(version)

    currentSelected.value = currentSelectedJava
    if (!currentSelected.value) {
--- a/theseus_gui/src/components/ui/JavaSelector.vue
+++ b/theseus_gui/src/components/ui/JavaSelector.vue
@@ -18,6 +18,14 @@
      "
    />
    <span class="installation-buttons">
+      <Button
+        v-if="props.version"
+        :disabled="props.disabled || installingJava"
+        @click="reinstallJava"
+      >
+        <DownloadIcon />
+        {{ installingJava ? 'Installing...' : 'Install recommended' }}
+      </Button>
      <Button :disabled="props.disabled" @click="autoDetect">
        <SearchIcon />
        Auto detect
@@ -44,8 +52,16 @@
 </template>

 <script setup>
-import { Button, SearchIcon, PlayIcon, CheckIcon, XIcon, FolderSearchIcon } from 'omorphia'
-import { find_jre_17_jres, get_jre } from '@/helpers/jre.js'
+import {
+  Button,
+  SearchIcon,
+  PlayIcon,
+  CheckIcon,
+  XIcon,
+  FolderSearchIcon,
+  DownloadIcon,
+} from 'omorphia'
+import { auto_install_java, find_filtered_jres, get_jre, test_jre } from '@/helpers/jre.js'
 import { ref } from 'vue'
 import { open } from '@tauri-apps/api/dialog'
 import JavaDetectionModal from '@/components/ui/JavaDetectionModal.vue'
@@ -60,7 +76,10 @@ const props = defineProps({
  },
  modelValue: {
    type: Object,
-    required: true,
+    default: () => ({
+      path: '',
+      version: '',
+    }),
  },
  disabled: {
    type: Boolean,
@@ -82,15 +101,21 @@ const emit = defineEmits(['update:modelValue'])

 const testingJava = ref(false)
 const testingJavaSuccess = ref(null)
+
+const installingJava = ref(false)
+
 async function testJava() {
  testingJava.value = true
-  let result = await get_jre(props.modelValue ? props.modelValue.path : '')
+  testingJavaSuccess.value = await test_jre(
+    props.modelValue ? props.modelValue.path : '',
+    1,
+    props.version,
+  )
  testingJava.value = false
-  testingJavaSuccess.value = !!result

  mixpanel_track('JavaTest', {
    path: props.modelValue ? props.modelValue.path : '',
-    success: !!result,
+    success: testingJavaSuccess.value,
  })

  setTimeout(() => {
@@ -109,13 +134,13 @@ async function handleJavaFileInput() {
        version: props.version.toString(),
        architecture: 'x86',
      }
-
-      mixpanel_track('JavaManualSelect', {
-        path: filePath,
-        version: props.version,
-      })
    }

+    mixpanel_track('JavaManualSelect', {
+      path: filePath,
+      version: props.version,
+    })
+
    emit('update:modelValue', result)
  }
 }
@@ -125,12 +150,35 @@ async function autoDetect() {
  if (!props.compact) {
    detectJavaModal.value.show(props.version, props.modelValue)
  } else {
-    let versions = await find_jre_17_jres().catch(handleError)
+    let versions = await find_filtered_jres(props.version).catch(handleError)
    if (versions.length > 0) {
      emit('update:modelValue', versions[0])
    }
  }
 }
+
+async function reinstallJava() {
+  installingJava.value = true
+  const path = await auto_install_java(props.version).catch(handleError)
+  let result = await get_jre(path)
+
+  console.log('java result ' + result)
+  if (!result) {
+    result = {
+      path: path,
+      version: props.version.toString(),
+      architecture: 'x86',
+    }
+  }
+
+  mixpanel_track('JavaReInstall', {
+    path: path,
+    version: props.version,
+  })
+
+  emit('update:modelValue', result)
+  installingJava.value = false
+}
 </script>

 <style lang="scss" scoped>
--- a/theseus_gui/src/components/ui/ModInstallModal.vue
+++ b/theseus_gui/src/components/ui/ModInstallModal.vue
@@ -112,7 +112,8 @@ async function getData() {
          .flatMap((v) => v.loaders)
          .some(
            (value) =>
-              value === profile.metadata.loader || ['minecraft', 'iris', 'optifine'].includes(value)
+              value === profile.metadata.loader ||
+              ['minecraft', 'iris', 'optifine'].includes(value),
          )
      )
    })
@@ -175,7 +176,7 @@ const createInstance = async () => {
    versions.value[0].game_versions[0],
    loader,
    'latest',
-    icon.value
+    icon.value,
  ).catch(handleError)

  await installMod(id, versions.value[0].id).catch(handleError)
@@ -245,13 +246,32 @@ const check_valid = computed(() => {
            />
            {{ profile.metadata.name }}
          </Button>
-          <Button :disabled="profile.installedMod || profile.installing" @click="install(profile)">
-            <DownloadIcon v-if="!profile.installedMod && !profile.installing" />
-            <CheckIcon v-else-if="profile.installedMod" />
-            {{
-              profile.installing ? 'Installing...' : profile.installedMod ? 'Installed' : 'Install'
-            }}
-          </Button>
+          <div
+            v-tooltip="
+              profile.metadata.linked_data?.locked && !profile.installedMod
+                ? 'Unpair or unlock an instance to add mods.'
+                : ''
+            "
+          >
+            <Button
+              :disabled="
+                profile.installedMod || profile.installing || profile.metadata.linked_data?.locked
+              "
+              @click="install(profile)"
+            >
+              <DownloadIcon v-if="!profile.installedMod && !profile.installing" />
+              <CheckIcon v-else-if="profile.installedMod" />
+              {{
+                profile.installing
+                  ? 'Installing...'
+                  : profile.installedMod
+                    ? 'Installed'
+                    : profile.metadata.linked_data && profile.metadata.linked_data.locked
+                      ? 'Paired'
+                      : 'Install'
+              }}
+            </Button>
+          </div>
        </div>
      </div>
      <Card v-if="showCreation" class="creation-card">
--- a/theseus_gui/src/components/ui/ModpackVersionModal.vue
+++ b/theseus_gui/src/components/ui/ModpackVersionModal.vue
@@ -0,0 +1,187 @@
+<script setup>
+import { Button, Modal, CheckIcon, Badge } from 'omorphia'
+import { computed, ref } from 'vue'
+import { useTheming } from '@/store/theme'
+import { update_managed_modrinth_version } from '@/helpers/profile'
+import { releaseColor } from '@/helpers/utils'
+import { SwapIcon } from '@/assets/icons/index.js'
+
+const props = defineProps({
+  versions: {
+    type: Array,
+    required: true,
+  },
+  instance: {
+    type: Object,
+    default: null,
+  },
+})
+
+defineExpose({
+  show: () => {
+    modpackVersionModal.value.show()
+  },
+})
+
+const filteredVersions = computed(() => {
+  return props.versions
+})
+
+const modpackVersionModal = ref(null)
+const installedVersion = computed(() => props.instance?.metadata?.linked_data?.version_id)
+const installing = computed(() => props.instance.install_stage !== 'installed')
+const inProgress = ref(false)
+
+const themeStore = useTheming()
+
+const switchVersion = async (versionId) => {
+  inProgress.value = true
+  await update_managed_modrinth_version(props.instance.path, versionId)
+  inProgress.value = false
+}
+</script>
+
+<template>
+  <Modal
+    ref="modpackVersionModal"
+    class="modpack-version-modal"
+    header="Change modpack version"
+    :noblur="!themeStore.advancedRendering"
+  >
+    <div class="modal-body">
+      <Card v-if="instance.metadata.linked_data" class="mod-card">
+        <div class="table">
+          <div class="table-row with-columns table-head">
+            <div class="table-cell table-text download-cell" />
+            <div class="name-cell table-cell table-text">Name</div>
+            <div class="table-cell table-text">Supports</div>
+          </div>
+          <div class="scrollable">
+            <div
+              v-for="version in filteredVersions"
+              :key="version.id"
+              class="table-row with-columns selectable"
+              @click="$router.push(`/project/${$route.params.id}/version/${version.id}`)"
+            >
+              <div class="table-cell table-text">
+                <Button
+                  :color="version.id === installedVersion ? '' : 'primary'"
+                  icon-only
+                  :disabled="inProgress || installing || version.id === installedVersion"
+                  @click.stop="() => switchVersion(version.id)"
+                >
+                  <SwapIcon v-if="version.id !== installedVersion" />
+                  <CheckIcon v-else />
+                </Button>
+              </div>
+              <div class="name-cell table-cell table-text">
+                <div class="version-link">
+                  {{ version.name.charAt(0).toUpperCase() + version.name.slice(1) }}
+                  <div class="version-badge">
+                    <div class="channel-indicator">
+                      <Badge
+                        :color="releaseColor(version.version_type)"
+                        :type="
+                          version.version_type.charAt(0).toUpperCase() +
+                          version.version_type.slice(1)
+                        "
+                      />
+                    </div>
+                    <div>
+                      {{ version.version_number }}
+                    </div>
+                  </div>
+                </div>
+              </div>
+              <div class="table-cell table-text stacked-text">
+                <span>
+                  {{
+                    version.loaders
+                      .map((str) => str.charAt(0).toUpperCase() + str.slice(1))
+                      .join(', ')
+                  }}
+                </span>
+                <span>
+                  {{ version.game_versions.join(', ') }}
+                </span>
+              </div>
+            </div>
+          </div>
+        </div>
+      </Card>
+    </div>
+  </Modal>
+</template>
+
+<style scoped lang="scss">
+.filter-header {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: space-between;
+  align-items: center;
+  gap: 0.5rem;
+  margin-bottom: 0.5rem;
+}
+
+.with-columns {
+  grid-template-columns: min-content 1fr 1fr;
+}
+
+.scrollable {
+  overflow-y: auto;
+  max-height: 25rem;
+}
+
+.card-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  background-color: var(--color-raised-bg);
+}
+
+.mod-card {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+  overflow: hidden;
+  margin-top: 0.5rem;
+}
+
+.version-link {
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+
+  .version-badge {
+    display: flex;
+    flex-wrap: wrap;
+
+    .channel-indicator {
+      margin-right: 0.5rem;
+    }
+  }
+}
+
+.stacked-text {
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+  align-items: flex-start;
+}
+
+.download-cell {
+  width: 4rem;
+  padding: 1rem;
+}
+
+.modal-body {
+  padding: var(--gap-xl);
+  display: flex;
+  flex-direction: column;
+  gap: var(--gap-md);
+}
+
+.table {
+  border: 1px solid var(--color-bg);
+}
+</style>
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
ToBinio	08b26f9d5d	fix version page (#1121 )	2024-04-23 12:09:02 -07:00
Geometrically	99ea06e22a	Bump to 0.7.0 + Add sign-in error (#1133 )	2024-04-23 12:05:28 -07:00
Geometrically	49cecf837b	Fix java installs (#1123 ) * Fix java installs * Finish java installs	2024-04-18 20:28:52 -07:00
Geometrically	2877919639	Switch to official launcher auth (#1118 ) * Switch to official launcher auth * add debug info * Fix build	2024-04-15 13:58:20 -07:00
MelanX	76447019c0	Fix `client-overrides` not getting extracted (#1120 ) Closes #1112 According to the [docs](https://support.modrinth.com/en/articles/8802351-modrinth-modpack-format-mrpack#h_3ad1b429f0), it needs to be `client-overrides`, not `client_overrides`. This PR fixes this typo.	2024-04-14 10:10:13 -07:00
ToBinio	3e7fd80824	chore: update dependencies (#1103 ) * update trivial dependencies * switch to sha1_smol * update async_zip * fix cli * clippy & fmt * js lints * fix build for ci	2024-04-07 12:13:35 -07:00
KnifesmithCode	6699b4cb33	Use Tokio directly instead of Tauri in io.rs (#1087 )	2024-04-03 14:44:16 -07:00
Wyatt Verchere	3ff0ff238a	adds credentials refresh save (#1030 )	2024-01-30 19:31:08 -05:00
Wyatt Verchere	0d3f007dd4	Config transfer (#951 ) * fixed config dir issue * jackson's sync write	2024-01-05 14:00:48 -05:00
Carter	9702dae19d	Switch from stdout log to latest log MOD-595 (#964 ) * Switch from stdout log to latest log * remove std capture * Remove unused functions	2024-01-05 14:00:08 -05:00
chaos	f6a697780b	Remove lwjgl debugging arg (#959 )	2023-12-28 17:00:27 -05:00
maxomatic458	ef8b525376	fix custom profile import for CF (#914 ) * use minecraftinstance.json for CF * fix fabric version	2023-12-13 17:26:56 -07:00
Geometrically	e39635c75b	Fix auth (finally) (#937 ) * Finish auth * Clippy + fix avatar on alts * add retrying to entitlement request	2023-12-12 20:57:01 -07:00
chaos	260744c8af	Wrap version names. Closes #908 (#928 )	2023-12-11 20:53:18 -07:00
Emma Alexia	54114e6e94	Fix #901 - add YT nocookie and Discord to CSP (#904 )	2023-12-11 20:52:28 -07:00
Emma Alexia	1bd721d523	Enable light mode and OLED mode as options (#936 ) Will eventually need the new component from knossos to be ported, but this will suffice for now	2023-12-11 20:51:29 -07:00
Jai A	c1518c52f3	fix avatar merge	2023-11-21 10:16:36 -07:00
ToBinio	531b38e562	display App version in settings (#801 ) Co-authored-by: Geometrically <18202329+Geometrically@users.noreply.github.com>	2023-11-21 08:38:22 -07:00
chaos	fd299aabe8	Check for write access before change. (#890 ) * Check for write access before change. Closes #862 * Formatting.	2023-11-21 08:37:05 -07:00
chaos	4b1a3eb41e	Add missing noblur value to modals. Closes #713 (#891 )	2023-11-21 08:35:57 -07:00
chaos	a5739fa7e2	Bump version + revert to mc-heads.net (#895 )	2023-11-21 08:35:32 -07:00
Wyatt Verchere	25662d1402	Auth retrying, std logs (#879 )	2023-11-17 21:49:32 -07:00
Brayden Zee	01ab507e3a	Search pagination fix (#800 ) * Fix account tool tip displaying in the wrong place * Set page to one after search	2023-11-15 17:22:49 -07:00
Ryan Lauderbach	4491d50935	Update breadcrumbs on profile name update (#643 ) * Update breadcrumbs on profile name update * Fix formatting	2023-11-15 16:43:19 -07:00
fxd	3c2889714a	native decorations toggle (#541 ) * add native decorations toggle * osname mac -> MacOS * remove newlines	2023-11-15 16:42:59 -07:00
Octelly	eb6e7d1491	fixed typo (#493 ) duplicate "used"	2023-11-15 16:41:34 -07:00
MrLiam2614	a8eb561774	Fixed bug when creating instance starting or ending with spaces has errors (#845 ) Based on issue #808	2023-11-15 16:39:53 -07:00
ToBinio	6152eeefe3	fix rendering/calculation of maxProjectsPerRow in homepage (#872 )	2023-11-15 16:39:17 -07:00
ToBinio	b8b1668fee	change instance fullscreen-checkbox to toggle (#848 )	2023-11-15 16:38:35 -07:00
ToBinio	aaf808477e	disable disabled projects on update (#871 )	2023-11-15 16:38:13 -07:00
chaos	8e3ddbcfaf	Update avatar URLs to use Crafatar API. (#877 )	2023-11-15 16:37:54 -07:00
Geometrically	a17e096d94	Bump version + fix neoforge 1.20.2+ (#863 )	2023-11-08 15:07:53 -08:00
Jackson Kruger	f5c7f90d19	Fix handling of paths longer than 260 chars on Windows during export (#847 )	2023-10-30 18:27:30 -07:00
Carter	bd18dbdbe8	correct file import linked_data option logic (#835 )	2023-10-23 17:04:02 -07:00
Geometrically	696000546b	Fix apple build (#825 ) * Fix apple build * fix pr	2023-10-21 18:55:50 -07:00
Geometrically	dc5785c874	Fix apple build (#824 )	2023-10-21 18:47:15 -07:00
Geometrically	afaec4b1bf	Bump Theseus Version (#818 ) * push to test on windows * Fix windows sup * Fix macos * Fix back * new resolver for windows testing * Custom macos handling for some versions * Fix 1.13+ broken * fix arg parsing mac * small winblows fix * remove debug info; set meta url * run lint + fix clippy * Remove useless commnet	2023-10-21 13:08:47 -07:00
Carter	7fb8850071	reduce side effects during migration hydration (#803 )	2023-10-15 22:12:26 -07:00
Carter	8ccc7dfcd2	Fix launcher duplicate profile function (#804 )	2023-10-12 10:41:44 -07:00
ToBinio	da07d7328d	fix google.svg (#795 )	2023-10-09 10:34:56 -07:00
Jackson Kruger	772597ce2a	Make export selection consistent between platforms and allow selecting which projects to export (#789 ) * Experimenting with tests * Overhaul handling of paths for pack files to always use standardized style Also allows disabling export of all items * Minor improvements * Revert test things * Minor tweaks * Fix clippy warning	2023-10-09 10:34:19 -07:00
ToBinio	e76a7d57c0	fix categories duplicating (#773 )	2023-10-06 19:59:18 -07:00
Jackson Kruger	ebc4da6c29	Use 'neoforge' instead of 'neo-forge' in mrpacks (#787 )	2023-10-04 15:42:09 -07:00
Miraculixx	f73c112e07	Fixing bug report template - Wrong nesting (#756 ) * Wrap string in quotes to support brackets * Moving string to label	2023-10-02 10:28:45 -07:00
chaos	7fbc9fa357	Allow mods to be added to unlocked instances. (#760 ) * Allow mods to be added to unlocked instances. * Learn about optional chaining?.	2023-10-02 10:27:04 -07:00
chaos	6f8ffcaf35	Overflow and mrpack fixes, comfortable memory slider and more. (#762 ) * Add overflow rules for certain elements. * Round scrollbar corners to be more attractive. * Avoid corners in avatar & fix white corner in logs * Increase step to 64 for memory related inputs. * Fix overflow on title in mod browse. Fixes #740 * Fix overflow in instance mod browsing. * Add checks for instances without versions.	2023-10-02 10:26:22 -07:00
Wyatt Verchere	1e8852b540	Bugs again (#703 ) * initial * more fixes * logs * more fixes * working rescuer * minor log display fix * mac fixes * minor fix * libsselinux1 * linux error * actions test * more bugs. Modpack page! BIG changes * changed minimum 64 -> 8 * removed modpack page moved to modal * removed unnecessary css * mac compile * many revs * Merge colorful logs (#725) * make implementation not dumb * run prettier * null -> true * Add line numbers & make errors more robust. * improvments * changes; virtual scroll --------- Co-authored-by: qtchaos <72168435+qtchaos@users.noreply.github.com> * omorphia colors, comments fix * fixes; _JAVA_OPTIONS * revs * mac specific * more mac * some fixes * quick fix * add java reinstall option --------- Co-authored-by: qtchaos <72168435+qtchaos@users.noreply.github.com> Co-authored-by: Jai A <jaiagr+gpg@pm.me>	2023-09-12 09:27:03 -07:00
Modrinth Bot	bc02192d80	[no ci] synced file(s) with modrinth/.github (#731 )	2023-09-10 12:42:05 -04:00
George Tsotsos	405f77e466	Rounded corner to improve UI continuity (#711 ) * round top right corner * remove conflicting shadow & more radius * remove unnecessary css rule	2023-09-04 17:15:33 -04:00
Geometrically	2fad02df23	Fix some small things (#658 )	2023-08-23 11:03:09 -04:00
chaos	1eb8998296	Update CSP to allow mclo.gs (#648 ) * Update CSP to allow mclo.gs * Fix semicolon location	2023-08-22 10:08:30 -04:00
Geometrically	2d3baff031	Neoforge support (#653 )	2023-08-21 17:39:39 -04:00
Banzobotic	7bea362503	Update CSP to allow youtube embeds (#640 )	2023-08-19 14:05:06 -04:00
chaos	abb02ad624	Fix being able to add mods to paired instances (#630 ) * Fix being able to add mods to paired instances * Remove debugging output.	2023-08-18 21:30:07 -04:00
Geometrically	f7f73b8163	Fix auth refresh (#631 )	2023-08-18 21:27:42 -04:00
Wyatt Verchere	6d9d403e7b	Hydra local (#594 ) * initial commit * merge fixes * added sanitizing * linter * Improve sign in UI * simple simple! * bump version --------- Co-authored-by: CodexAdrian <83074853+CodexAdrian@users.noreply.github.com> Co-authored-by: Jai A <jaiagr+gpg@pm.me>	2023-08-17 20:26:21 -04:00