fix: update all versions to -mac specific

feat: add macos signing args
Reqwest optionally load certificates from disk (#94 )
2025-11-10 04:22:13 +10:00 · 2025-08-02 12:02:34 +10:00 · 2025-08-02 12:00:25 +10:00 · 2025-08-02 11:59:50 +10:00 · 2025-08-01 14:13:13 +10:00 · 2025-08-01 14:09:16 +10:00
106 changed files with 8995 additions and 4419 deletions
--- a/.env
+++ b/.env
@ -1 +0,0 @@
-DATABASE_URL=./drop.db
--- a/.github/workflows/clippy.yml
+++ b/.github/workflows/clippy.yml
@ -0,0 +1,23 @@
+on: push
+name: Clippy check
+jobs:
+  clippy_check:
+    runs-on: ubuntu-24.04
+    permissions:
+      checks: write
+    steps:
+      - uses: actions/checkout@v1
+      - name: install dependencies (ubuntu only)
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libglib2.0-dev libgtk-3-dev libwebkit2gtk-4.1-dev
+
+      - uses: actions-rs/toolchain@v1
+        with:
+            toolchain: nightly
+            components: clippy
+            override: true
+      - uses: actions-rs/clippy-check@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --manifest-path ./src-tauri/Cargo.toml
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -24,6 +24,8 @@ jobs:
            args: '--target x86_64-apple-darwin'
          - platform: 'ubuntu-22.04' # for Tauri v1 you could replace this with ubuntu-20.04.
            args: ''
+          - platform: 'ubuntu-22.04-arm'
+            args: '--target aarch64-unknown-linux-gnu'
          - platform: 'windows-latest'
            args: ''

@ -46,12 +48,11 @@ jobs:
          targets: ${{ matrix.platform == 'macos-latest' && 'aarch64-apple-darwin,x86_64-apple-darwin' || '' }}

      - name: install dependencies (ubuntu only)
-        if: matrix.platform == 'ubuntu-22.04' # This must match the platform value defined above.
+        if: matrix.platform == 'ubuntu-22.04' || matrix.platform == 'ubuntu-22.04-arm' # This must match the platform value defined above.
        run: |
          sudo apt-get update
-          sudo apt-get install -y libwebkit2gtk-4.0-dev libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf
        # webkitgtk 4.0 is for Tauri v1 - webkitgtk 4.1 is for Tauri v2.
-        # You can remove the one that doesn't apply to your app to speed up the workflow a bit.

      - name: install frontend dependencies
        run: yarn install # change this to npm, pnpm or bun depending on which one you use.
@ -59,8 +60,11 @@ jobs:
      - uses: tauri-apps/tauri-action@v0
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          APPLE_SIGNING_IDENTITY: ${{ env.APPLE_SIGNING_IDENTITY }}
        with:
-          tagName: dev-v__VERSION__ # the action automatically replaces \_\_VERSION\_\_ with the app version.
+          tagName: v__VERSION__ # the action automatically replaces \_\_VERSION\_\_ with the app version.
          releaseName: 'Auto-release v__VERSION__'
          releaseBody: 'See the assets to download this version and install. This release was created automatically.'
          releaseDraft: false
--- a/.gitmodules
+++ b/.gitmodules
@ -1,3 +1,9 @@
 [submodule "drop-base"]
 	path = drop-base
 	url = https://github.com/drop-oss/drop-base
+[submodule "src-tauri/tailscale/libtailscale"]
+	path = src-tauri/tailscale/libtailscale
+	url = https://github.com/tailscale/libtailscale.git
+[submodule "src-tauri/umu/umu-launcher"]
+	path = src-tauri/umu/umu-launcher
+	url = https://github.com/Open-Wine-Components/umu-launcher.git
--- a/README.md
+++ b/README.md
@ -4,7 +4,7 @@ Drop app is the companion app for [Drop](https://github.com/Drop-OSS/drop). It u

 ## Running
 Before setting up the drop app, be sure that you have a server set up. 
-The instructions for this can be found on the [Drop Wiki](https://wiki.droposs.org/guides/quickstart.html)
+The instructions for this can be found on the [Drop Docs](https://docs.droposs.org/docs/guides/quickstart)

 ## Current features
 Currently supported are the following features:
--- a/app.vue
+++ b/app.vue
@ -1,4 +1,5 @@
 <template>
+  <LoadingIndicator />
  <NuxtLayout class="select-none w-screen h-screen">
    <NuxtPage />
    <ModalStack />
--- a/components/GameStatusButton.vue
+++ b/components/GameStatusButton.vue
@ -1,78 +1,52 @@
 <template>
  <!-- Do not add scale animations to this: https://stackoverflow.com/a/35683068 -->
  <div class="inline-flex divide-x divide-zinc-900">
-    <button
-      type="button"
-      @click="() => buttonActions[props.status.type]()"
-      :class="[
-        styles[props.status.type],
-        showDropdown ? 'rounded-l-md' : 'rounded-md',
-        'inline-flex uppercase font-display items-center gap-x-2 px-4 py-3 text-md font-semibold shadow-sm focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2',
-      ]"
-    >
-      <component
-        :is="buttonIcons[props.status.type]"
-        class="-mr-0.5 size-5"
-        aria-hidden="true"
-      />
+    <button type="button" @click="() => buttonActions[props.status.type]()" :class="[
+      styles[props.status.type],
+      showDropdown ? 'rounded-l-md' : 'rounded-md',
+      'inline-flex uppercase font-display items-center gap-x-2 px-4 py-3 text-md font-semibold shadow-sm focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2',
+    ]">
+      <component :is="buttonIcons[props.status.type]" class="-mr-0.5 size-5" aria-hidden="true" />
      {{ buttonNames[props.status.type] }}
    </button>
-    <Menu
-      v-if="showDropdown"
-      as="div"
-      class="relative inline-block text-left grow"
-    >
+    <Menu v-if="showDropdown" as="div" class="relative inline-block text-left grow">
      <div class="h-full">
-        <MenuButton
-          :class="[
-            styles[props.status.type],
-            'inline-flex w-full h-full justify-center items-center rounded-r-md px-1 py-2 text-sm font-semibold shadow-sm group',
-            'focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2',
-          ]"
-        >
+        <MenuButton :class="[
+          styles[props.status.type],
+          'inline-flex w-full h-full justify-center items-center rounded-r-md px-1 py-2 text-sm font-semibold shadow-sm group',
+          'focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2',
+        ]">
          <ChevronDownIcon class="size-5" aria-hidden="true" />
        </MenuButton>
      </div>

-      <transition
-        enter-active-class="transition ease-out duration-100"
-        enter-from-class="transform opacity-0 scale-95"
-        enter-to-class="transform opacity-100 scale-100"
-        leave-active-class="transition ease-in duration-75"
-        leave-from-class="transform opacity-100 scale-100"
-        leave-to-class="transform opacity-0 scale-95"
-      >
+      <transition enter-active-class="transition ease-out duration-100" enter-from-class="transform opacity-0 scale-95"
+        enter-to-class="transform opacity-100 scale-100" leave-active-class="transition ease-in duration-75"
+        leave-from-class="transform opacity-100 scale-100" leave-to-class="transform opacity-0 scale-95">
        <MenuItems
-          class="absolute right-0 z-[500] mt-2 w-32 origin-top-right rounded-md bg-zinc-900 shadow-lg ring-1 ring-zinc-100/5 focus:outline-none"
-        >
+          class="absolute right-0 z-[500] mt-2 w-32 origin-top-right rounded-md bg-zinc-900 shadow-lg ring-1 ring-zinc-100/5 focus:outline-none">
          <div class="py-1">
            <MenuItem v-slot="{ active }">
-              <button
-                @click="() => emit('options')"
-                :class="[
-                  active
-                    ? 'bg-zinc-800 text-zinc-100 outline-none'
-                    : 'text-zinc-400',
-                  'w-full block px-4 py-2 text-sm inline-flex justify-between',
-                ]"
-              >
-                Options
-                <Cog6ToothIcon class="size-5" />
-              </button>
+            <button @click="() => emit('options')" :class="[
+              active
+                ? 'bg-zinc-800 text-zinc-100 outline-none'
+                : 'text-zinc-400',
+              'w-full block px-4 py-2 text-sm inline-flex justify-between',
+            ]">
+              Options
+              <Cog6ToothIcon class="size-5" />
+            </button>
            </MenuItem>
            <MenuItem v-slot="{ active }">
-              <button
-                @click="() => emit('uninstall')"
-                :class="[
-                  active
-                    ? 'bg-zinc-800 text-zinc-100 outline-none'
-                    : 'text-zinc-400',
-                  'w-full block px-4 py-2 text-sm inline-flex justify-between',
-                ]"
-              >
-                Uninstall
-                <TrashIcon class="size-5" />
-              </button>
+            <button @click="() => emit('uninstall')" :class="[
+              active
+                ? 'bg-zinc-800 text-zinc-100 outline-none'
+                : 'text-zinc-400',
+              'w-full block px-4 py-2 text-sm inline-flex justify-between',
+            ]">
+              Uninstall
+              <TrashIcon class="size-5" />
+            </button>
            </MenuItem>
          </div>
        </MenuItems>
@ -87,6 +61,7 @@ import {
  ChevronDownIcon,
  PlayIcon,
  QueueListIcon,
+  StopIcon,
  WrenchIcon,
 } from "@heroicons/vue/20/solid";

@ -103,12 +78,14 @@ const emit = defineEmits<{
  (e: "uninstall"): void;
  (e: "kill"): void;
  (e: "options"): void;
+  (e: "resume"): void
 }>();

 const showDropdown = computed(
  () =>
    props.status.type === GameStatusEnum.Installed ||
-    props.status.type === GameStatusEnum.SetupRequired
+    props.status.type === GameStatusEnum.SetupRequired ||
+    props.status.type === GameStatusEnum.PartiallyInstalled
 );

 const styles: { [key in GameStatusEnum]: string } = {
@ -128,6 +105,8 @@ const styles: { [key in GameStatusEnum]: string } = {
    "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700 hover:bg-zinc-700",
  [GameStatusEnum.Running]:
    "bg-zinc-800 text-white hover:bg-zinc-700 focus-visible:outline-zinc-700 hover:bg-zinc-700",
+  [GameStatusEnum.PartiallyInstalled]:
+    "bg-gray-600 text-white hover:bg-gray-500 focus-visible:outline-gray-600 hover:bg-gray-500"
 };

 const buttonNames: { [key in GameStatusEnum]: string } = {
@ -139,6 +118,7 @@ const buttonNames: { [key in GameStatusEnum]: string } = {
  [GameStatusEnum.Updating]: "Updating",
  [GameStatusEnum.Uninstalling]: "Uninstalling",
  [GameStatusEnum.Running]: "Stop",
+  [GameStatusEnum.PartiallyInstalled]: "Resume"
 };

 const buttonIcons: { [key in GameStatusEnum]: Component } = {
@ -149,7 +129,8 @@ const buttonIcons: { [key in GameStatusEnum]: Component } = {
  [GameStatusEnum.Installed]: PlayIcon,
  [GameStatusEnum.Updating]: ArrowDownTrayIcon,
  [GameStatusEnum.Uninstalling]: TrashIcon,
-  [GameStatusEnum.Running]: PlayIcon,
+  [GameStatusEnum.Running]: StopIcon,
+  [GameStatusEnum.PartiallyInstalled]: ArrowDownTrayIcon
 };

 const buttonActions: { [key in GameStatusEnum]: () => void } = {
@ -159,7 +140,8 @@ const buttonActions: { [key in GameStatusEnum]: () => void } = {
  [GameStatusEnum.SetupRequired]: () => emit("launch"),
  [GameStatusEnum.Installed]: () => emit("launch"),
  [GameStatusEnum.Updating]: () => emit("queue"),
-  [GameStatusEnum.Uninstalling]: () => {},
+  [GameStatusEnum.Uninstalling]: () => { },
  [GameStatusEnum.Running]: () => emit("kill"),
+  [GameStatusEnum.PartiallyInstalled]: () => emit("resume")
 };
 </script>
--- a/components/Header.vue
+++ b/components/Header.vue
@ -42,7 +42,7 @@
        </ol>
      </div>
    </div>
-    <WindowControl class="h-16 w-16 p-4" />
+    <WindowControl  />
  </div>
 </template>

--- a/components/HeaderButton.vue
+++ b/components/HeaderButton.vue
@ -1,5 +1,5 @@
 <template>
-    <button class="transition h-10 w-10 text-zinc-300 hover:bg-zinc-800 hover:text-zinc-100 p-2">
+    <button class="transition h-full aspect-square text-zinc-300 hover:bg-zinc-800 hover:text-zinc-100 p-[1.1rem]">
        <slot />
    </button>
 </template>
--- a/components/HeaderUserWidget.vue
+++ b/components/HeaderUserWidget.vue
@ -23,7 +23,7 @@
      <MenuItems
        class="absolute bg-zinc-900 right-0 top-10 z-50 w-56 origin-top-right focus:outline-none shadow-md"
      >
-        <PanelWidget class="flex-col gap-y-2">
+        <div class="flex-col gap-y-2">
          <NuxtLink
            to="/id/me"
            class="transition inline-flex items-center w-full py-3 px-4 hover:bg-zinc-800"
@ -65,7 +65,7 @@
              </button>
            </MenuItem>
          </div>
-        </PanelWidget>
+        </div>
      </MenuItems>
    </transition>
  </Menu>
@ -87,7 +87,7 @@ router.afterEach(() => {

 const state = useAppState();
 const profilePictureUrl: string = await useObject(
-  state.value.user?.profilePicture ?? ""
+  state.value.user?.profilePictureObjectId ?? ""
 );
 const adminUrl: string = await invoke("gen_drop_url", {
  path: "/admin",
--- a/components/InitiateAuthModule.vue
+++ b/components/InitiateAuthModule.vue
@ -13,11 +13,7 @@
      <div class="max-w-lg">
        <slot />
        <div class="mt-10">
-          <button
-            @click="() => authWrapper_wrapper()"
-            :disabled="loading"
-            class="text-sm text-left font-semibold leading-7 text-blue-600"
-          >
+          <div>
            <div v-if="loading" role="status">
              <svg
                aria-hidden="true"
@ -37,10 +33,19 @@
              </svg>
              <span class="sr-only">Loading...</span>
            </div>
-            <span v-else>
-              Sign in with your browser <span aria-hidden="true">&rarr;</span>
+            <span class="inline-flex gap-x-8 items-center" v-else>
+              <button
+                @click="() => authWrapper_wrapper()"
+                :disabled="loading"
+                class="px-3 py-1 inline-flex items-center gap-x-2 bg-zinc-700 rounded text-sm text-left font-semibold leading-7 text-white"
+              >
+                Sign in with your browser <ArrowTopRightOnSquareIcon class="size-4" />
+              </button>
+              <NuxtLink href="/auth/code" class="text-zinc-100 text-sm hover:text-zinc-300">
+                Use a code &rarr;
+              </NuxtLink>
            </span>
-          </button>
+          </div>

          <div class="mt-5" v-if="offerManual">
            <h1 class="text-zinc-100 font-semibold">Having trouble?</h1>
@ -121,6 +126,7 @@

 <script setup lang="ts">
 import { XCircleIcon } from "@heroicons/vue/16/solid";
+import { ArrowTopRightOnSquareIcon } from "@heroicons/vue/20/solid";
 import { invoke } from "@tauri-apps/api/core";

 const loading = ref(false);
@ -136,15 +142,16 @@ async function auth() {
 }

 function authWrapper_wrapper() {
+  error.value = undefined;
  loading.value = true;
  auth().catch((e) => {
    loading.value = false;
    error.value = e;
-    if(offerManualTimeout) clearTimeout(offerManualTimeout);
+    if (offerManualTimeout) clearTimeout(offerManualTimeout);
  });
  offerManualTimeout = setTimeout(() => {
    offerManual.value = true;
-  }, 10000);
+  }, 2000);
 }

 async function continueManual() {
--- a/components/LibrarySearch.vue
+++ b/components/LibrarySearch.vue
@ -1,19 +1,30 @@
 <template>
  <div>
-    <div
-      class="relative mb-3 transition-transform duration-300 hover:scale-105 active:scale-95"
-    >
+    <div class="mb-3 inline-flex gap-x-2">
      <div
-        class="pointer-events-none absolute inset-y-0 left-0 flex items-center pl-3"
+        class="relative transition-transform duration-300 hover:scale-105 active:scale-95"
      >
-        <MagnifyingGlassIcon class="h-5 w-5 text-zinc-400" aria-hidden="true" />
+        <div
+          class="pointer-events-none absolute inset-y-0 left-0 flex items-center pl-3"
+        >
+          <MagnifyingGlassIcon
+            class="h-5 w-5 text-zinc-400"
+            aria-hidden="true"
+          />
+        </div>
+        <input
+          type="text"
+          v-model="searchQuery"
+          class="block w-full rounded-lg border-0 bg-zinc-800/50 py-2 pl-10 pr-3 text-zinc-100 placeholder:text-zinc-500 focus:bg-zinc-800 focus:ring-2 focus:ring-inset focus:ring-blue-500 sm:text-sm sm:leading-6"
+          placeholder="Search library..."
+        />
      </div>
-      <input
-        type="text"
-        v-model="searchQuery"
-        class="block w-full rounded-lg border-0 bg-zinc-800/50 py-2 pl-10 pr-3 text-zinc-100 placeholder:text-zinc-500 focus:bg-zinc-800 focus:ring-2 focus:ring-inset focus:ring-blue-500 sm:text-sm sm:leading-6"
-        placeholder="Search library..."
-      />
+      <button
+        @click="() => calculateGames(true)"
+        class="p-1 flex items-center justify-center transition-transform duration-300 size-10 hover:scale-110 active:scale-90 rounded-lg bg-zinc-800/50 text-zinc-100"
+      >
+        <ArrowPathIcon class="size-4" />
+      </button>
    </div>

    <TransitionGroup name="list" tag="ul" class="flex flex-col gap-y-1.5">
@ -60,7 +71,7 @@
 </template>

 <script setup lang="ts">
-import { MagnifyingGlassIcon } from "@heroicons/vue/20/solid";
+import { ArrowPathIcon, MagnifyingGlassIcon } from "@heroicons/vue/20/solid";
 import { invoke } from "@tauri-apps/api/core";
 import { GameStatusEnum, type Game, type GameStatus } from "~/types";
 import { TransitionGroup } from "vue";
@ -76,6 +87,7 @@ const gameStatusTextStyle: { [key in GameStatusEnum]: string } = {
  [GameStatusEnum.Updating]: "text-blue-500",
  [GameStatusEnum.Uninstalling]: "text-zinc-100",
  [GameStatusEnum.SetupRequired]: "text-yellow-500",
+  [GameStatusEnum.PartiallyInstalled]: "text-gray-600",
 };
 const gameStatusText: { [key in GameStatusEnum]: string } = {
  [GameStatusEnum.Remote]: "Not installed",
@ -86,6 +98,7 @@ const gameStatusText: { [key in GameStatusEnum]: string } = {
  [GameStatusEnum.Uninstalling]: "Uninstalling...",
  [GameStatusEnum.SetupRequired]: "Setup required",
  [GameStatusEnum.Running]: "Running",
+  [GameStatusEnum.PartiallyInstalled]: "Partially installed",
 };

 const router = useRouter();
@ -99,16 +112,20 @@ const icons: { [key: string]: string } = {};

 const rawGames: Ref<Game[], Game[]> = ref([]);

-async function calculateGames() {
-  rawGames.value = await invoke("fetch_library");
-  for (const game of rawGames.value) {
+async function calculateGames(clearAll = false) {
+  if (clearAll) rawGames.value = [];
+  // If we update immediately, the navigation gets re-rendered before we
+  // add all the necessary state, and it freaks tf out
+  const newGames = await invoke<typeof rawGames.value>("fetch_library");
+  for (const game of newGames) {
    if (games[game.id]) continue;
    games[game.id] = await useGame(game.id);
  }
-  for (const game of rawGames.value) {
+  for (const game of newGames) {
    if (icons[game.id]) continue;
-    icons[game.id] = await useObject(game.mIconId);
+    icons[game.id] = await useObject(game.mIconObjectId);
  }
+  rawGames.value = newGames;
 }

 await calculateGames();
--- a/components/LoadingIndicator.vue
+++ b/components/LoadingIndicator.vue
@ -0,0 +1,7 @@
+<template></template>
+
+<script setup lang="ts">
+const loading = useLoadingIndicator();
+
+watch(loading.isLoading, console.log);
+</script>
--- a/components/MiniHeader.vue
+++ b/components/MiniHeader.vue
@ -1,6 +1,6 @@
 <template>
  <div
-    class="h-10 cursor-pointer flex flex-row items-center justify-between bg-zinc-950"
+    class="h-16 cursor-pointer flex flex-row items-center justify-between bg-zinc-950"
  >
    <div class="px-5 py-3 grow" @mousedown="() => window.startDragging()">
      <Wordmark class="mt-1" />
--- a/components/WindowControl.vue
+++ b/components/WindowControl.vue
@ -1,4 +1,7 @@
 <template>
+  <HeaderButton v-if="showMinimise" @click="() => minimise()">
+    <MinusIcon />
+  </HeaderButton>
  <HeaderButton @click="() => close()">
    <XMarkIcon />
  </HeaderButton>
@ -8,11 +11,14 @@
 import { MinusIcon, XMarkIcon } from "@heroicons/vue/16/solid";
 import { getCurrentWindow } from "@tauri-apps/api/window";

-async function close(){
-  console.log(window);
-  const result = await window.close();
-  console.log(`closed window: ${result}`);
+const window = getCurrentWindow();
+const showMinimise = await window.isMinimizable();
+
+async function close() {
+  await window.close();
 }

-const window = getCurrentWindow();
+async function minimise() {
+  await window.minimize();
+}
 </script>
--- a/composables/game.ts
+++ b/composables/game.ts
@ -14,7 +14,6 @@ export type SerializedGameStatus = [
 ];

 export const parseStatus = (status: SerializedGameStatus): GameStatus => {
-  console.log(status);
  if (status[0]) {
    return {
      type: status[0].type,
@ -48,7 +47,6 @@ export const useGame = async (gameId: string) => {
          status: SerializedGameStatus;
          version?: GameVersion;
        } = event.payload as any;
-        console.log(payload.status);
        gameStatusRegistry[gameId].value = parseStatus(payload.status);
        
        /**
--- a/composables/state-navigation.ts
+++ b/composables/state-navigation.ts
@ -1,9 +1,11 @@
+import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
 import { data } from "autoprefixer";
 import { AppStatus, type AppState } from "~/types";

 export function setupHooks() {
  const router = useRouter();
+  const state = useAppState();

  listen("auth/processing", (event) => {
    router.push("/auth/processing");
@ -15,8 +17,9 @@ export function setupHooks() {
    );
  });

-  listen("auth/finished", (event) => {
-    router.push("/store");
+  listen("auth/finished", async (event) => {
+    router.push("/library");
+    state.value = JSON.parse(await invoke("fetch_state"));
  });

  listen("download_error", (event) => {
@ -27,12 +30,31 @@ export function setupHooks() {
        description: `Drop encountered an error while downloading your game: "${(
          event.payload as unknown as string
        ).toString()}"`,
-        buttonText: "Close"
+        buttonText: "Close",
      },
      (e, c) => c()
    );
  });

+  // This is for errors that (we think) aren't our fault
+  listen("launch_external_error", (event) => {
+    createModal(
+      ModalType.Confirmation,
+      {
+        title: "Did something go wrong?",
+        description:
+          "Drop detected that something might've gone wrong with launching your game. Do you want to open the log directory?",
+        buttonText: "Open",
+      },
+      async (e, c) => {
+        if (e == "confirm") {
+          await invoke("open_process_logs", { gameId: event.payload });
+        }
+        c();
+      }
+    );
+  });
+
  /*

  document.addEventListener("contextmenu", (event) => {
@ -60,6 +82,6 @@ export function initialNavigation(state: Ref<AppState>) {
      router.push("/error/serverunavailable");
      break;
    default:
-      router.push("/store");
+      router.push("/library");
  }
 }
--- a/2
+++ b/2
--- a/package.json
+++ b/package.json
@ -1,7 +1,7 @@
 {
  "name": "drop-app",
  "private": true,
-  "version": "0.3.0-rc-1",
+  "version": "0.3.1-mac",
  "type": "module",
  "scripts": {
    "build": "nuxt build",
@ -18,6 +18,7 @@
    "@tauri-apps/api": ">=2.0.0",
    "@tauri-apps/plugin-deep-link": "~2",
    "@tauri-apps/plugin-dialog": "^2.0.1",
+    "@tauri-apps/plugin-opener": "^2.4.0",
    "@tauri-apps/plugin-os": "~2",
    "@tauri-apps/plugin-shell": "^2.2.1",
    "koa": "^2.16.1",
@ -37,7 +38,9 @@
    "autoprefixer": "^10.4.20",
    "postcss": "^8.4.47",
    "sass-embedded": "^1.79.4",
-    "tailwindcss": "^3.4.13"
+    "tailwindcss": "^3.4.13",
+    "typescript": "^5.8.3",
+    "vue-tsc": "^2.2.10"
  },
  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }
--- a/pages/auth/code.vue
+++ b/pages/auth/code.vue
@ -0,0 +1,37 @@
+<template>
+  <div class="min-h-full w-full flex items-center justify-center">
+    <div class="flex flex-col items-center">
+      <div class="text-center">
+        <h1 class="text-3xl font-semibold font-display leading-6 text-zinc-100">
+          Device authorization
+        </h1>
+        <div class="mt-4">
+          <p class="text-sm text-zinc-400 max-w-md mx-auto">
+            Open Drop on another one of your devices, and use your account
+            dropdown to "Authorize client", and enter the code below.
+          </p>
+          <div
+            class="mt-8 flex items-center justify-center gap-x-5 text-8xl font-bold text-zinc-100"
+          >
+            <span v-for="letter in code.split('')">{{ letter }}</span>
+          </div>
+        </div>
+        <div class="mt-10 flex items-center justify-center gap-x-6">
+          <NuxtLink href="/auth" class="text-sm font-semibold text-blue-600"
+            ><span aria-hidden="true">&larr;</span> Use a different method
+          </NuxtLink>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { invoke } from "@tauri-apps/api/core";
+
+const code = await invoke<string>("auth_initiate_code");
+
+definePageMeta({
+  layout: "mini",
+});
+</script>
--- a/pages/library/[id]/index.vue
+++ b/pages/library/[id]/index.vue
@ -32,6 +32,7 @@
            @uninstall="() => uninstall()"
            @kill="() => kill()"
            @options="() => (configureModalOpen = true)"
+            @resume="() => resumeDownload()"
            :status="status"
          />
          <a
@ -75,7 +76,7 @@
                      <TransitionGroup name="slide" tag="div" class="h-full">
                        <img
                          v-for="(url, index) in mediaUrls"
-                          :key="url"
+                          :key="index"
                          :src="url"
                          class="absolute inset-0 w-full h-full object-cover"
                          v-show="index === currentImageIndex"
@ -156,8 +157,8 @@
    <template #default>
      <div class="sm:flex sm:items-start">
        <div class="mt-3 text-center sm:mt-0 sm:text-left">
-          <h3 class="text-base font-semibold text-zinc-100"
-            >Install {{ game.mName }}?
+          <h3 class="text-base font-semibold text-zinc-100">
+            Install {{ game.mName }}?
          </h3>
          <div class="mt-2">
            <p class="text-sm text-zinc-400">
@ -349,9 +350,7 @@
    <template #buttons>
      <LoadingButton
        @click="() => install()"
-        :disabled="
-          !(versionOptions && versionOptions.length > 0 && !installDir)
-        "
+        :disabled="!(versionOptions && versionOptions.length > 0)"
        :loading="installLoading"
        type="submit"
        class="ml-2 w-full sm:w-fit"
@ -369,7 +368,11 @@
    </template>
  </ModalTemplate>

-  <GameOptionsModal v-if="status.type === GameStatusEnum.Installed" v-model="configureModalOpen" :game-id="game.id" />
+  <GameOptionsModal
+    v-if="status.type === GameStatusEnum.Installed"
+    v-model="configureModalOpen"
+    :game-id="game.id"
+  />

  <Transition
    enter="transition ease-out duration-300"
@ -419,7 +422,7 @@
          <img
            v-for="(url, index) in mediaUrls"
            v-show="currentImageIndex === index"
-            :key="url"
+            :key="index"
            :src="url"
            class="max-h-[90vh] max-w-[90vw] object-contain"
            :alt="`${game.mName} screenshot ${index + 1}`"
@ -440,10 +443,6 @@

 <script setup lang="ts">
 import {
-  Dialog,
-  DialogTitle,
-  TransitionChild,
-  TransitionRoot,
  Listbox,
  ListboxButton,
  ListboxLabel,
@ -477,11 +476,14 @@ const remoteUrl: string = await invoke("gen_drop_url", {
  path: `/store/${game.value.id}`,
 });

-const bannerUrl = await useObject(game.value.mBannerId);
+const bannerUrl = await useObject(game.value.mBannerObjectId);

 // Get all available images
 const mediaUrls = await Promise.all(
-  game.value.mImageCarousel.map((id) => useObject(id))
+  game.value.mImageCarouselObjectIds.map(async (v) => {
+    const src = await useObject(v);
+    return src;
+  })
 );

 const htmlDescription = micromark(game.value.mDescription);
@ -532,6 +534,14 @@ async function install() {
  installLoading.value = false;
 }

+async function resumeDownload() {
+  try {
+    await invoke("resume_download", { gameId: game.value.id });
+  } catch (e) {
+    console.error(e);
+  }
+}
+
 async function launch() {
  try {
    await invoke("launch_game", { id: game.value.id });
--- a/pages/queue.vue
+++ b/pages/queue.vue
@ -91,7 +91,12 @@
 <script setup lang="ts">
 import { ServerIcon, XMarkIcon } from "@heroicons/vue/20/solid";
 import { invoke } from "@tauri-apps/api/core";
-import type { DownloadableMetadata, Game, GameStatus } from "~/types";
+import { GameStatusEnum, type DownloadableMetadata, type Game, type GameStatus } from "~/types";
+
+// const actionNames = {
+//   [GameStatusEnum.Downloading]: "downloading",
+//   [GameStatusEnum.Verifying]: "verifying",
+// }

 const windowWidth = ref(window.innerWidth);
 window.addEventListener("resize", (event) => {
@ -158,7 +163,7 @@ function loadGamesForQueue(v: typeof queue.value) {
    if (games.value[id]) return;
    (async () => {
      const gameData = await useGame(id);
-      const cover = await useObject(gameData.game.mCoverId);
+      const cover = await useObject(gameData.game.mCoverObjectId);
      games.value[id] = { ...gameData, cover };
    })();
  }
--- a/pages/settings/debug.vue
+++ b/pages/settings/debug.vue
@ -106,8 +106,6 @@ const systemData = await invoke<{
  dataDir: string;
 }>("fetch_system_data");

-console.log(systemData);
-
 clientId.value = systemData.clientId;
 baseUrl.value = systemData.baseUrl;
 dataDir.value = systemData.dataDir;
--- a/pages/store/index.vue
+++ b/pages/store/index.vue
@ -1,4 +1,37 @@
 <template>
-  <iframe src="server://drop.local/store" class="w-full h-full" />
+  <div class="grow w-full h-full flex items-center justify-center">
+    <div class="flex flex-col items-center">
+      <BuildingStorefrontIcon
+        class="h-12 w-12 text-blue-600"
+        aria-hidden="true"
+      />
+      <div class="mt-3 text-center sm:mt-5">
+        <h1 class="text-3xl font-semibold font-display leading-6 text-zinc-100">
+          Store not supported in client
+        </h1>
+        <div class="mt-4">
+          <p class="text-sm text-zinc-400 max-w-lg">
+            Currently, Drop requires you to view the store in your browser.
+            Please click the button below to open it in your default browser.
+          </p>
+          <NuxtLink
+            :href="storeUrl"
+            target="_blank"
+            class="mt-6 transition text-sm/6 font-semibold text-zinc-400 hover:text-zinc-100 inline-flex gap-x-2 items-center duration-200 hover:scale-105"
+          >
+            Open Store <ArrowTopRightOnSquareIcon class="size-4" />
+          </NuxtLink>
+        </div>
+      </div>
+    </div>
+  </div>
 </template>
-<script setup lang="ts"></script>
+<script setup lang="ts">
+import {
+  ArrowTopRightOnSquareIcon,
+  BuildingStorefrontIcon,
+} from "@heroicons/vue/20/solid";
+import { invoke } from "@tauri-apps/api/core";
+
+const storeUrl = await invoke<string>("gen_drop_url", { path: "/store" });
+</script>
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@ -1,9 +1,9 @@
 [package]
 name = "drop-app"
-version = "0.3.0-rc-1"
+version = "0.3.1-mac"
 description = "The client application for the open-source, self-hosted game distribution platform Drop"
 authors = ["Drop OSS"]
-edition = "2021"
+edition = "2024"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@ -16,8 +16,6 @@ tauri-plugin-single-instance = { version = "2.0.0", features = ["deep-link"] }
 # This seems to be only an issue on Windows, see https://github.com/rust-lang/cargo/issues/8519
 name = "drop_app_lib"
 crate-type = ["staticlib", "cdylib", "rlib"]
-
-[build]
 rustflags = ["-C", "target-feature=+aes,+sse2"]


@ -27,9 +25,7 @@ tauri-build = { version = "2.0.0", features = [] }
 [dependencies]
 tauri-plugin-shell = "2.2.1"
 serde_json = "1"
-serde-binary = "0.5.0"
 rayon = "1.10.0"
-directories = "5.0.1"
 webbrowser = "1.0.2"
 url = "2.5.2"
 tauri-plugin-deep-link = "2"
@ -51,15 +47,30 @@ throttle_my_fn = "0.2.6"
 parking_lot = "0.12.3"
 atomic-instant-full = "0.1.0"
 cacache = "13.1.0"
-bincode = "1.3.3"
 http-serde = "2.1.1"
 reqwest-middleware = "0.4.0"
 reqwest-middleware-cache = "0.1.1"
 deranged = "=0.4.0"
 droplet-rs = "0.7.3"
 gethostname = "1.0.1"
-native_db = "0.8.1"
-native_model = "0.6.1"
+zstd = "0.13.3"
+tar = "0.4.44"
+rand = "0.9.1"
+regex = "1.11.1"
+tempfile = "3.19.1"
+schemars = "0.8.22"
+sha1 = "0.10.6"
+dirs = "6.0.0"
+whoami = "1.6.0"
+filetime = "0.2.25"
+walkdir = "2.5.0"
+known-folders = "1.2.0"
+native_model = { version = "0.6.1", features = ["rmp_serde_1_3"] }
+tauri-plugin-opener = "2.4.0"
+bitcode = "0.6.6"
+reqwest-websocket = "0.5.0"
+futures-lite = "2.6.0"
+# tailscale = { path = "./tailscale" }

 [dependencies.dynfmt]
 version = "0.1.5"
@ -67,7 +78,7 @@ features = ["curly"]

 [dependencies.tauri]
 version = "2.1.1"
-features = ["tray-icon"]
+features = ["protocol-asset", "tray-icon"]

 [dependencies.tokio]
 version = "1.40.0"
@ -83,19 +94,16 @@ features = ["fs"]

 [dependencies.uuid]
 version = "1.10.0"
-features = [
-    "v4",                # Lets you generate random UUIDs
-    "fast-rng",          # Use a faster (but still sufficiently random) RNG
-    "macro-diagnostics", # Enable better diagnostics for compile-time UUIDs
-]
+features = ["v4", "fast-rng", "macro-diagnostics"]

 [dependencies.rustbreak]
 version = "2"
-features = [] # You can also use "yaml_enc" or "bin_enc"
+features = ["other_errors"] # You can also use "yaml_enc" or "bin_enc"

 [dependencies.reqwest]
 version = "0.12"
-features = ["json", "blocking"]
+default-features = false
+features = ["json", "http2", "blocking", "rustls-tls-webpki-roots"]

 [dependencies.serde]
 version = "1"
--- a/src-tauri/build.rs
+++ b/src-tauri/build.rs
@ -1,3 +1,3 @@
 fn main() {
-    tauri_build::build()
+    tauri_build::build();
 }
--- a/src-tauri/capabilities/default.json
+++ b/src-tauri/capabilities/default.json
@ -14,6 +14,7 @@
    "core:window:allow-close",
    "deep-link:default",
    "dialog:default",
-    "os:default"
+    "os:default",
+    "opener:default"
  ]
 }
--- a/src-tauri/src/client/autostart.rs
+++ b/src-tauri/src/client/autostart.rs
@ -1,4 +1,4 @@
-use crate::database::db::{borrow_db_checked, borrow_db_mut_checked, save_db};
+use crate::database::db::{borrow_db_checked, borrow_db_mut_checked};
 use log::debug;
 use tauri::AppHandle;
 use tauri_plugin_autostart::ManagerExt;
@ -17,7 +17,6 @@ pub fn toggle_autostart_logic(app: AppHandle, enabled: bool) -> Result<(), Strin
    let mut db_handle = borrow_db_mut_checked();
    db_handle.settings.autostart = enabled;
    drop(db_handle);
-    save_db();

    Ok(())
 }
--- a/src-tauri/src/client/cleanup.rs
+++ b/src-tauri/src/client/cleanup.rs
@ -13,10 +13,10 @@ pub fn cleanup_and_exit(app: &AppHandle, state: &tauri::State<'_, std::sync::Mut
    let download_manager = state.lock().unwrap().download_manager.clone();
    match download_manager.ensure_terminated() {
        Ok(res) => match res {
-            Ok(_) => debug!("download manager terminated correctly"),
-            Err(_) => error!("download manager failed to terminate correctly"),
+            Ok(()) => debug!("download manager terminated correctly"),
+            Err(()) => error!("download manager failed to terminate correctly"),
        },
-        Err(e) => panic!("{:?}", e),
+        Err(e) => panic!("{e:?}"),
    }

    app.exit(0);
--- a/src-tauri/src/client/commands.rs
+++ b/src-tauri/src/client/commands.rs
--- a/src-tauri/src/client/mod.rs
+++ b/src-tauri/src/client/mod.rs
@ -0,0 +1,3 @@
+pub mod autostart;
+pub mod cleanup;
+pub mod commands;
--- a/src-tauri/src/cloud_saves/backup_manager.rs
+++ b/src-tauri/src/cloud_saves/backup_manager.rs
@ -0,0 +1,102 @@
+use std::{collections::HashMap, path::PathBuf, str::FromStr};
+
+use log::warn;
+
+use crate::{database::db::{GameVersion, DATA_ROOT_DIR}, error::backup_error::BackupError, process::process_manager::Platform};
+
+use super::path::CommonPath;
+
+pub struct BackupManager<'a> {
+    pub current_platform: Platform,
+    pub sources: HashMap<(Platform, Platform), &'a (dyn BackupHandler + Sync + Send)>,
+}
+
+impl BackupManager<'_> {
+    pub fn new() -> Self {
+        BackupManager {
+            #[cfg(target_os = "windows")]
+            current_platform: Platform::Windows,
+
+            #[cfg(target_os = "macos")]
+            current_platform: Platform::MacOs,
+
+            #[cfg(target_os = "linux")]
+            current_platform: Platform::Linux,
+
+            sources: HashMap::from([
+                // Current platform to target platform
+                (
+                    (Platform::Windows, Platform::Windows),
+                    &WindowsBackupManager {} as &(dyn BackupHandler + Sync + Send),
+                ),
+                (
+                    (Platform::Linux, Platform::Linux),
+                    &LinuxBackupManager {} as &(dyn BackupHandler + Sync + Send),
+                ),
+                (
+                    (Platform::MacOs, Platform::MacOs),
+                    &MacBackupManager {} as &(dyn BackupHandler + Sync + Send),
+                ),
+                
+            ]),
+        }
+    }
+    
+}
+
+pub trait BackupHandler: Send + Sync {
+    fn root_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { Ok(DATA_ROOT_DIR.lock().unwrap().join("games")) }
+    fn game_translate(&self, _path: &PathBuf, game: &GameVersion) -> Result<PathBuf, BackupError> { Ok(PathBuf::from_str(&game.game_id).unwrap()) }
+    fn base_translate(&self, path: &PathBuf, game: &GameVersion) -> Result<PathBuf, BackupError> { Ok(self.root_translate(path, game)?.join(self.game_translate(path, game)?)) }
+    fn home_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { let c = CommonPath::Home.get().ok_or(BackupError::NotFound); println!("{:?}", c); c }
+    fn store_user_id_translate(&self, _path: &PathBuf, game: &GameVersion) -> Result<PathBuf, BackupError> { PathBuf::from_str(&game.game_id).map_err(|_| BackupError::ParseError) }
+    fn os_user_name_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { Ok(PathBuf::from_str(&whoami::username()).unwrap()) }
+    fn win_app_data_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected Windows Reference in Backup <winAppData>"); Err(BackupError::InvalidSystem) }
+    fn win_local_app_data_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected Windows Reference in Backup <winLocalAppData>"); Err(BackupError::InvalidSystem) }
+    fn win_local_app_data_low_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected Windows Reference in Backup <winLocalAppDataLow>"); Err(BackupError::InvalidSystem) }
+    fn win_documents_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected Windows Reference in Backup <winDocuments>"); Err(BackupError::InvalidSystem) }
+    fn win_public_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected Windows Reference in Backup <winPublic>"); Err(BackupError::InvalidSystem) }
+    fn win_program_data_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected Windows Reference in Backup <winProgramData>"); Err(BackupError::InvalidSystem) }
+    fn win_dir_translate(&self, _path: &PathBuf,_game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected Windows Reference in Backup <winDir>"); Err(BackupError::InvalidSystem) }
+    fn xdg_data_translate(&self, _path: &PathBuf,_game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected XDG Reference in Backup <xdgData>"); Err(BackupError::InvalidSystem) }
+    fn xdg_config_translate(&self, _path: &PathBuf,_game: &GameVersion) -> Result<PathBuf, BackupError> { warn!("Unexpected XDG Reference in Backup <xdgConfig>"); Err(BackupError::InvalidSystem) }
+    fn skip_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> { Ok(PathBuf::new()) }
+}
+
+pub struct LinuxBackupManager {}
+impl BackupHandler for LinuxBackupManager {
+    fn xdg_config_translate(&self, _path: &PathBuf,_game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(CommonPath::Data.get().ok_or(BackupError::NotFound)?)
+    }
+    fn xdg_data_translate(&self, _path: &PathBuf,_game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(CommonPath::Config.get().ok_or(BackupError::NotFound)?)
+    }
+}
+pub struct WindowsBackupManager {}
+impl BackupHandler for WindowsBackupManager {
+    fn win_app_data_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(CommonPath::Config.get().ok_or(BackupError::NotFound)?)
+    }
+    fn win_local_app_data_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(CommonPath::DataLocal.get().ok_or(BackupError::NotFound)?)
+    }
+    fn win_local_app_data_low_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(CommonPath::DataLocalLow.get().ok_or(BackupError::NotFound)?)
+    }
+    fn win_dir_translate(&self, _path: &PathBuf,_game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(PathBuf::from_str("C:/Windows").unwrap())
+    }
+    fn win_documents_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(CommonPath::Document.get().ok_or(BackupError::NotFound)?)
+
+    }
+    fn win_program_data_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(PathBuf::from_str("C:/ProgramData").unwrap())
+    }
+    fn win_public_translate(&self, _path: &PathBuf, _game: &GameVersion) -> Result<PathBuf, BackupError> {
+        Ok(CommonPath::Public.get().ok_or(BackupError::NotFound)?)
+
+    }
+}
+pub struct MacBackupManager {}
+impl BackupHandler for MacBackupManager {}
--- a/src-tauri/src/cloud_saves/conditions.rs
+++ b/src-tauri/src/cloud_saves/conditions.rs
@ -0,0 +1,6 @@
+use crate::process::process_manager::Platform;
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub enum Condition {
+    Os(Platform)
+}
--- a/src-tauri/src/cloud_saves/metadata.rs
+++ b/src-tauri/src/cloud_saves/metadata.rs
@ -0,0 +1,35 @@
+use crate::database::db::GameVersion;
+
+use super::conditions::{Condition};
+
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct CloudSaveMetadata {
+    pub files: Vec<GameFile>,
+    pub game_version: GameVersion,
+    pub save_id: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameFile {
+    pub path: String,
+    pub id: Option<String>,
+    pub data_type: DataType,
+    pub tags: Vec<Tag>,
+    pub conditions: Vec<Condition>
+}
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
+pub enum DataType {
+    Registry,
+    File,
+    Other
+}
+#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Tag {
+    Config,
+    Save,
+    #[default]
+    #[serde(other)]
+    Other,
+}
--- a/src-tauri/src/cloud_saves/mod.rs
+++ b/src-tauri/src/cloud_saves/mod.rs
@ -0,0 +1,7 @@
+pub mod conditions;
+pub mod metadata;
+pub mod resolver;
+pub mod placeholder;
+pub mod normalise;
+pub mod path;
+pub mod backup_manager;
--- a/src-tauri/src/cloud_saves/normalise.rs
+++ b/src-tauri/src/cloud_saves/normalise.rs
@ -0,0 +1,162 @@
+use std::sync::LazyLock;
+
+use regex::Regex;
+use crate::process::process_manager::Platform;
+
+use super::placeholder::*;
+
+
+pub fn normalize(path: &str, os: Platform) -> String {
+    let mut path = path.trim().trim_end_matches(['/', '\\']).replace('\\', "/");
+
+    if path == "~" || path.starts_with("~/") {
+        path = path.replacen('~', HOME, 1);
+    }
+
+    static CONSECUTIVE_SLASHES: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"/{2,}").unwrap());
+    static UNNECESSARY_DOUBLE_STAR_1: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"([^/*])\*{2,}").unwrap());
+    static UNNECESSARY_DOUBLE_STAR_2: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\*{2,}([^/*])").unwrap());
+    static ENDING_WILDCARD: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(/\*)+$").unwrap());
+    static ENDING_DOT: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(/\.)$").unwrap());
+    static INTERMEDIATE_DOT: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(/\./)").unwrap());
+    static BLANK_SEGMENT: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(/\s+/)").unwrap());
+    static APP_DATA: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%appdata%").unwrap());
+    static APP_DATA_ROAMING: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%userprofile%/AppData/Roaming").unwrap());
+    static APP_DATA_LOCAL: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%localappdata%").unwrap());
+    static APP_DATA_LOCAL_2: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%userprofile%/AppData/Local/").unwrap());
+    static USER_PROFILE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%userprofile%").unwrap());
+    static DOCUMENTS: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)%userprofile%/Documents").unwrap());
+
+    for (pattern, replacement) in [
+        (&CONSECUTIVE_SLASHES, "/"),
+        (&UNNECESSARY_DOUBLE_STAR_1, "${1}*"),
+        (&UNNECESSARY_DOUBLE_STAR_2, "*${1}"),
+        (&ENDING_WILDCARD, ""),
+        (&ENDING_DOT, ""),
+        (&INTERMEDIATE_DOT, "/"),
+        (&BLANK_SEGMENT, "/"),
+        (&APP_DATA, WIN_APP_DATA),
+        (&APP_DATA_ROAMING, WIN_APP_DATA),
+        (&APP_DATA_LOCAL, WIN_LOCAL_APP_DATA),
+        (&APP_DATA_LOCAL_2, &format!("{}/", WIN_LOCAL_APP_DATA)),
+        (&USER_PROFILE, HOME),
+        (&DOCUMENTS, WIN_DOCUMENTS),
+    ] {
+        path = pattern.replace_all(&path, replacement).to_string();
+    }
+
+    if os == Platform::Windows {
+        let documents_2: Regex = Regex::new(r"(?i)<home>/Documents").unwrap();
+
+        #[allow(clippy::single_element_loop)]
+        for (pattern, replacement) in [(&documents_2, WIN_DOCUMENTS)] {
+            path = pattern.replace_all(&path, replacement).to_string();
+        }
+    }
+
+    for (pattern, replacement) in [
+        ("{64BitSteamID}", STORE_USER_ID),
+        ("{Steam3AccountID}", STORE_USER_ID),
+    ] {
+        path = path.replace(pattern, replacement);
+    }
+
+    path
+}
+
+fn too_broad(path: &str) -> bool {
+    println!("Path: {}", path);
+    use {BASE, HOME, ROOT, STORE_USER_ID, WIN_APP_DATA, WIN_DIR, WIN_DOCUMENTS, XDG_CONFIG, XDG_DATA};
+
+    let path_lower = path.to_lowercase();
+
+    for item in ALL {
+        if path == *item {
+            return true;
+        }
+    }
+
+    for item in AVOID_WILDCARDS {
+        if path.starts_with(&format!("{}/*", item)) || path.starts_with(&format!("{}/{}", item, STORE_USER_ID)) {
+            return true;
+        }
+    }
+
+    // These paths are present whether or not the game is installed.
+    // If possible, they should be narrowed down on the wiki.
+    for item in [
+        format!("{}/{}", BASE, STORE_USER_ID), // because `<storeUserId>` is handled as `*`
+        format!("{}/Documents", HOME),
+        format!("{}/Saved Games", HOME),
+        format!("{}/AppData", HOME),
+        format!("{}/AppData/Local", HOME),
+        format!("{}/AppData/Local/Packages", HOME),
+        format!("{}/AppData/LocalLow", HOME),
+        format!("{}/AppData/Roaming", HOME),
+        format!("{}/Documents/My Games", HOME),
+        format!("{}/Library/Application Support", HOME),
+        format!("{}/Library/Application Support/UserData", HOME),
+        format!("{}/Library/Preferences", HOME),
+        format!("{}/.renpy", HOME),
+        format!("{}/.renpy/persistent", HOME),
+        format!("{}/Library", HOME),
+        format!("{}/Library/RenPy", HOME),
+        format!("{}/Telltale Games", HOME),
+        format!("{}/config", ROOT),
+        format!("{}/MMFApplications", WIN_APP_DATA),
+        format!("{}/RenPy", WIN_APP_DATA),
+        format!("{}/RenPy/persistent", WIN_APP_DATA),
+        format!("{}/win.ini", WIN_DIR),
+        format!("{}/SysWOW64", WIN_DIR),
+        format!("{}/My Games", WIN_DOCUMENTS),
+        format!("{}/Telltale Games", WIN_DOCUMENTS),
+        format!("{}/unity3d", XDG_CONFIG),
+        format!("{}/unity3d", XDG_DATA),
+        "C:/Program Files".to_string(),
+        "C:/Program Files (x86)".to_string(),
+    ] {
+        let item = item.to_lowercase();
+        if path_lower == item
+            || path_lower.starts_with(&format!("{}/*", item))
+            || path_lower.starts_with(&format!("{}/{}", item, STORE_USER_ID.to_lowercase()))
+            || path_lower.starts_with(&format!("{}/savesdir", item))
+        {
+            return true;
+        }
+    }
+    
+
+    // Drive letters:
+    let drives: Regex = Regex::new(r"^[a-zA-Z]:$").unwrap();
+    if drives.is_match(path) {
+        return true;
+    }
+
+    // Colon not for a drive letter
+    if path.get(2..).is_some_and(|path| path.contains(':')) {
+        return true;
+    }
+
+    // Root:
+    if path == "/" {
+        return true;
+    }
+
+    // Relative path wildcard:
+    if path.starts_with('*') {
+        return true;
+    }
+
+    false
+}
+
+pub fn usable(path: &str) -> bool {
+    let unprintable: Regex = Regex::new(r"(\p{Cc}|\p{Cf})").unwrap();
+
+    !path.is_empty()
+        && !path.contains("{{")
+        && !path.starts_with("./")
+        && !path.starts_with("../")
+        && !too_broad(path)
+        && !unprintable.is_match(path)
+}
--- a/src-tauri/src/cloud_saves/path.rs
+++ b/src-tauri/src/cloud_saves/path.rs
@ -0,0 +1,48 @@
+use std::{path::PathBuf, sync::LazyLock};
+
+pub enum CommonPath {
+    Config,
+    Data,
+    DataLocal,
+    DataLocalLow,
+    Document,
+    Home,
+    Public,
+    SavedGames,
+}
+
+impl CommonPath {
+    pub fn get(&self) -> Option<PathBuf> {
+        static CONFIG: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::config_dir());
+        static DATA: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::data_dir());
+        static DATA_LOCAL: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::data_local_dir());
+        static DOCUMENT: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::document_dir());
+        static HOME: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::home_dir());
+        static PUBLIC: LazyLock<Option<PathBuf>> = LazyLock::new(|| dirs::public_dir());
+
+        #[cfg(windows)]
+        static DATA_LOCAL_LOW: LazyLock<Option<PathBuf>> = LazyLock::new(|| {
+            known_folders::get_known_folder_path(known_folders::KnownFolder::LocalAppDataLow)
+        });
+        #[cfg(not(windows))]
+        static DATA_LOCAL_LOW: Option<PathBuf> = None;
+
+        #[cfg(windows)]
+        static SAVED_GAMES: LazyLock<Option<PathBuf>> = LazyLock::new(|| {
+            known_folders::get_known_folder_path(known_folders::KnownFolder::SavedGames)
+        });
+        #[cfg(not(windows))]
+        static SAVED_GAMES: Option<PathBuf> = None;
+
+        match self {
+            Self::Config => CONFIG.clone(),
+            Self::Data => DATA.clone(),
+            Self::DataLocal => DATA_LOCAL.clone(),
+            Self::DataLocalLow => DATA_LOCAL_LOW.clone(),
+            Self::Document => DOCUMENT.clone(),
+            Self::Home => HOME.clone(),
+            Self::Public => PUBLIC.clone(),
+            Self::SavedGames => SAVED_GAMES.clone(),
+        }
+    }
+}
--- a/src-tauri/src/cloud_saves/placeholder.rs
+++ b/src-tauri/src/cloud_saves/placeholder.rs
@ -0,0 +1,51 @@
+use std::sync::LazyLock;
+
+pub const ALL: &[&str] = &[
+    ROOT,
+    GAME,
+    BASE,
+    HOME,
+    STORE_USER_ID,
+    OS_USER_NAME,
+    WIN_APP_DATA,
+    WIN_LOCAL_APP_DATA,
+    WIN_DOCUMENTS,
+    WIN_PUBLIC,
+    WIN_PROGRAM_DATA,
+    WIN_DIR,
+    XDG_DATA,
+    XDG_CONFIG,
+];
+
+/// These are paths where `<placeholder>/*/` is suspicious.
+pub const AVOID_WILDCARDS: &[&str] = &[
+    ROOT,
+    HOME,
+    WIN_APP_DATA,
+    WIN_LOCAL_APP_DATA,
+    WIN_DOCUMENTS,
+    WIN_PUBLIC,
+    WIN_PROGRAM_DATA,
+    WIN_DIR,
+    XDG_DATA,
+    XDG_CONFIG,
+];
+
+pub const ROOT: &str = "<root>"; // a directory where games are installed (configured in backup tool)
+pub const GAME: &str = "<game>"; // an installDir (if defined) or the game's canonical name in the manifest
+pub const BASE: &str = "<base>"; // shorthand for <root>/<game> (unless overridden by store-specific rules)
+pub const HOME: &str = "<home>"; // current user's home directory in the OS (~)
+pub const STORE_USER_ID: &str = "<storeUserId>"; // a store-specific id from the manifest, corresponding to the root's store type
+pub const OS_USER_NAME: &str = "<osUserName>"; // current user's ID in the game store
+pub const WIN_APP_DATA: &str = "<winAppData>"; // current user's name in the OS
+pub const WIN_LOCAL_APP_DATA: &str = "<winLocalAppData>"; // %APPDATA% on Windows
+pub const WIN_LOCAL_APP_DATA_LOW: &str = "<winLocalAppDataLow>"; // %LOCALAPPDATA% on Windows
+pub const WIN_DOCUMENTS: &str = "<winDocuments>"; // <home>/AppData/LocalLow on Windows
+pub const WIN_PUBLIC: &str = "<winPublic>"; // <home>/Documents (f.k.a. <home>/My Documents) or a localized equivalent on Windows
+pub const WIN_PROGRAM_DATA: &str = "<winProgramData>"; // %PUBLIC% on Windows
+pub const WIN_DIR: &str = "<winDir>"; // %PROGRAMDATA% on Windows
+pub const XDG_DATA: &str = "<xdgData>"; // %WINDIR% on Windows
+pub const XDG_CONFIG: &str = "<xdgConfig>"; // $XDG_DATA_HOME on Linux
+pub const SKIP: &str = "<skip>"; // $XDG_CONFIG_HOME on Linux
+
+pub static OS_USERNAME: LazyLock<String> = LazyLock::new(|| whoami::username());
--- a/src-tauri/src/cloud_saves/resolver.rs
+++ b/src-tauri/src/cloud_saves/resolver.rs
@ -0,0 +1,262 @@
+use std::{
+    fs::{self, create_dir_all, File},
+    io::{self, ErrorKind, Read, Write},
+    path::{Path, PathBuf},
+    thread::sleep,
+    time::Duration,
+};
+
+use super::{
+    backup_manager::BackupHandler, conditions::Condition, metadata::GameFile, placeholder::*,
+};
+use log::{debug, warn};
+use rustix::path::Arg;
+use tempfile::tempfile;
+
+use crate::{
+    database::db::GameVersion, error::backup_error::BackupError, process::process_manager::Platform,
+};
+
+use super::{backup_manager::BackupManager, metadata::CloudSaveMetadata, normalise::normalize};
+
+pub fn resolve(meta: &mut CloudSaveMetadata) -> File {
+    let f = File::create_new("save").unwrap();
+    let compressor = zstd::Encoder::new(f, 22).unwrap();
+    let mut tarball = tar::Builder::new(compressor);
+    let manager = BackupManager::new();
+    for file in meta.files.iter_mut() {
+        let id = uuid::Uuid::new_v4().to_string();
+        let os = match file
+            .conditions
+            .iter()
+            .find_map(|p| match p {
+                super::conditions::Condition::Os(os) => Some(os),
+                _ => None,
+            })
+            .cloned()
+        {
+            Some(os) => os,
+            None => {
+                warn!(
+                    "File {:?} could not be backed up because it did not provide an OS",
+                    &file
+                );
+                continue;
+            }
+        };
+        let handler = match manager.sources.get(&(manager.current_platform, os)) {
+            Some(h) => *h,
+            None => continue,
+        };
+        let t_path = PathBuf::from(normalize(&file.path, os));
+        println!("{:?}", &t_path);
+        let path = parse_path(t_path, handler, &meta.game_version).unwrap();
+        let f = std::fs::metadata(&path).unwrap(); // TODO: Fix unwrap here
+        if f.is_dir() {
+            tarball.append_dir_all(&id, path).unwrap();
+        } else if f.is_file() {
+            tarball
+                .append_file(&id, &mut File::open(path).unwrap())
+                .unwrap();
+        }
+        file.id = Some(id);
+    }
+    let binding = serde_json::to_string(meta).unwrap();
+    let serialized = binding.as_bytes();
+    let mut file = tempfile().unwrap();
+    file.write(serialized).unwrap();
+    tarball.append_file("metadata", &mut file).unwrap();
+    tarball.into_inner().unwrap().finish().unwrap()
+}
+
+pub fn extract(file: PathBuf) -> Result<(), BackupError> {
+    let tmpdir = tempfile::tempdir().unwrap();
+
+    // Reopen the file for reading
+    let file = File::open(file).unwrap();
+
+    let decompressor = zstd::Decoder::new(file).unwrap();
+    let mut f = tar::Archive::new(decompressor);
+    f.unpack(tmpdir.path()).unwrap();
+
+    let path = tmpdir.path();
+
+    let mut manifest = File::open(path.join("metadata")).unwrap();
+
+    let mut manifest_slice = Vec::new();
+    manifest.read_to_end(&mut manifest_slice).unwrap();
+
+    let manifest: CloudSaveMetadata = serde_json::from_slice(&manifest_slice).unwrap();
+
+    for file in manifest.files {
+        let current_path = path.join(file.id.as_ref().unwrap());
+
+        let manager = BackupManager::new();
+        let os = match file
+            .conditions
+            .iter()
+            .find_map(|p| match p {
+                super::conditions::Condition::Os(os) => Some(os),
+                _ => None,
+            })
+            .cloned()
+        {
+            Some(os) => os,
+            None => {
+                warn!(
+                    "File {:?} could not be replaced up because it did not provide an OS",
+                    &file
+                );
+                continue;
+            }
+        };
+        let handler = match manager.sources.get(&(manager.current_platform, os)) {
+            Some(h) => *h,
+            None => continue,
+        };
+
+        let new_path = parse_path(file.path.into(), handler, &manifest.game_version)?;
+        create_dir_all(&new_path.parent().unwrap()).unwrap();
+
+        println!(
+            "Current path {:?} copying to {:?}",
+            &current_path, &new_path
+        );
+
+        copy_item(current_path, new_path).unwrap();
+    }
+
+    Ok(())
+}
+
+pub fn copy_item<P: AsRef<Path>>(src: P, dest: P) -> io::Result<()> {
+    let src_path = src.as_ref();
+    let dest_path = dest.as_ref();
+
+    let metadata = fs::metadata(&src_path)?;
+
+    if metadata.is_file() {
+        // Ensure the parent directory of the destination exists for a file copy
+        if let Some(parent) = dest_path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        fs::copy(&src_path, &dest_path)?;
+    } else if metadata.is_dir() {
+        // For directories, we call the recursive helper function.
+        // The destination for the recursive copy is the `dest_path` itself.
+        copy_dir_recursive(&src_path, &dest_path)?;
+    } else {
+        // Handle other file types like symlinks if necessary,
+        // for now, return an error or skip.
+        return Err(io::Error::new(
+            io::ErrorKind::Other,
+            format!("Source {:?} is neither a file nor a directory", src_path),
+        ));
+    }
+
+    Ok(())
+}
+
+fn copy_dir_recursive(src: &Path, dest: &Path) -> io::Result<()> {
+    fs::create_dir_all(&dest)?;
+
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let entry_path = entry.path();
+        let entry_file_name = match entry_path.file_name() {
+            Some(name) => name,
+            None => continue, // Skip if somehow there's no file name
+        };
+        let dest_entry_path = dest.join(entry_file_name);
+        let metadata = entry.metadata()?;
+
+        if metadata.is_file() {
+            debug!(
+                "Writing file {} to {}",
+                entry_path.display(),
+                dest_entry_path.display()
+            );
+            fs::copy(&entry_path, &dest_entry_path)?;
+        } else if metadata.is_dir() {
+            copy_dir_recursive(&entry_path, &dest_entry_path)?;
+        }
+        // Ignore other types like symlinks for this basic implementation
+    }
+
+    Ok(())
+}
+
+pub fn parse_path(
+    path: PathBuf,
+    backup_handler: &dyn BackupHandler,
+    game: &GameVersion,
+) -> Result<PathBuf, BackupError> {
+    println!("Parsing: {:?}", &path);
+    let mut s = PathBuf::new();
+    for component in path.components() {
+        match component.as_str().unwrap() {
+            ROOT => s.push(backup_handler.root_translate(&path, game)?),
+            GAME => s.push(backup_handler.game_translate(&path, game)?),
+            BASE => s.push(backup_handler.base_translate(&path, game)?),
+            HOME => s.push(backup_handler.home_translate(&path, game)?),
+            STORE_USER_ID => s.push(backup_handler.store_user_id_translate(&path, game)?),
+            OS_USER_NAME => s.push(backup_handler.os_user_name_translate(&path, game)?),
+            WIN_APP_DATA => s.push(backup_handler.win_app_data_translate(&path, game)?),
+            WIN_LOCAL_APP_DATA => s.push(backup_handler.win_local_app_data_translate(&path, game)?),
+            WIN_LOCAL_APP_DATA_LOW => {
+                s.push(backup_handler.win_local_app_data_low_translate(&path, game)?)
+            }
+            WIN_DOCUMENTS => s.push(backup_handler.win_documents_translate(&path, game)?),
+            WIN_PUBLIC => s.push(backup_handler.win_public_translate(&path, game)?),
+            WIN_PROGRAM_DATA => s.push(backup_handler.win_program_data_translate(&path, game)?),
+            WIN_DIR => s.push(backup_handler.win_dir_translate(&path, game)?),
+            XDG_DATA => s.push(backup_handler.xdg_data_translate(&path, game)?),
+            XDG_CONFIG => s.push(backup_handler.xdg_config_translate(&path, game)?),
+            SKIP => s.push(backup_handler.skip_translate(&path, game)?),
+            _ => s.push(PathBuf::from(component.as_os_str())),
+        }
+    }
+
+    println!("Final line: {:?}", &s);
+    Ok(s)
+}
+
+pub fn test() {
+    let mut meta = CloudSaveMetadata {
+        files: vec![
+            GameFile {
+                path: String::from("<home>/favicon.png"),
+                id: None,
+                data_type: super::metadata::DataType::File,
+                tags: Vec::new(),
+                conditions: vec![Condition::Os(Platform::Linux)],
+            },
+            GameFile {
+                path: String::from("<home>/Documents/Pixel Art"),
+                id: None,
+                data_type: super::metadata::DataType::File,
+                tags: Vec::new(),
+                conditions: vec![Condition::Os(Platform::Linux)],
+            },
+        ],
+        game_version: GameVersion {
+            game_id: String::new(),
+            version_name: String::new(),
+            platform: Platform::Linux,
+            launch_command: String::new(),
+            launch_args: Vec::new(),
+            launch_command_template: String::new(),
+            setup_command: String::new(),
+            setup_args: Vec::new(),
+            setup_command_template: String::new(),
+            only_setup: true,
+            version_index: 0,
+            delta: false,
+            umu_id_override: None,
+        },
+        save_id: String::from("aaaaaaa"),
+    };
+    //resolve(&mut meta);
+
+    extract("save".into()).unwrap();
+}
--- a/src-tauri/src/cloud_saves/strict_path.rs
+++ b/src-tauri/src/cloud_saves/strict_path.rs
--- a/src-tauri/src/database/commands.rs
+++ b/src-tauri/src/database/commands.rs
@ -7,13 +7,13 @@ use std::{
 use serde_json::Value;

 use crate::{
-    database::{db::borrow_db_mut_checked, settings::Settings},
-    download_manager::internal_error::InternalError,
+    database::db::borrow_db_mut_checked, error::download_manager_error::DownloadManagerError,
 };

 use super::{
-    db::{borrow_db_checked, save_db, DATA_ROOT_DIR},
+    db::{borrow_db_checked, DATA_ROOT_DIR},
    debug::SystemData,
+    models::data::Settings,
 };

 // Will, in future, return disk/remaining size
@ -28,12 +28,10 @@ pub fn fetch_download_dir_stats() -> Vec<PathBuf> {
 pub fn delete_download_dir(index: usize) {
    let mut lock = borrow_db_mut_checked();
    lock.applications.install_dirs.remove(index);
-    drop(lock);
-    save_db();
 }

 #[tauri::command]
-pub fn add_download_dir(new_dir: PathBuf) -> Result<(), InternalError<()>> {
+pub fn add_download_dir(new_dir: PathBuf) -> Result<(), DownloadManagerError<()>> {
    // Check the new directory is all good
    let new_dir_path = Path::new(&new_dir);
    if new_dir_path.exists() {
@ -60,7 +58,6 @@ pub fn add_download_dir(new_dir: PathBuf) -> Result<(), InternalError<()>> {
    }
    lock.applications.install_dirs.push(new_dir);
    drop(lock);
-    save_db();

    Ok(())
 }
@ -74,8 +71,6 @@ pub fn update_settings(new_settings: Value) {
    }
    let new_settings: Settings = serde_json::from_value(current_settings).unwrap();
    db_lock.settings = new_settings;
-    drop(db_lock);
-    save_db();
 }
 #[tauri::command]
 pub fn fetch_settings() -> Settings {
@ -87,7 +82,7 @@ pub fn fetch_system_data() -> SystemData {
    SystemData::new(
        db_handle.auth.as_ref().unwrap().client_id.clone(),
        db_handle.base_url.clone(),
-        DATA_ROOT_DIR.lock().unwrap().to_string_lossy().to_string(),
+        DATA_ROOT_DIR.to_string_lossy().to_string(),
        std::env::var("RUST_LOG").unwrap_or_else(|_| "info".to_string()),
    )
 }
--- a/src-tauri/src/database/db.rs
+++ b/src-tauri/src/database/db.rs
@ -1,150 +1,44 @@
 use std::{
-    collections::HashMap,
    fs::{self, create_dir_all},
-    hash::Hash,
-    path::{Path, PathBuf},
-    sync::{LazyLock, Mutex, RwLockReadGuard, RwLockWriteGuard},
+    mem::ManuallyDrop,
+    ops::{Deref, DerefMut},
+    path::PathBuf,
+    sync::{Arc, LazyLock, RwLockReadGuard, RwLockWriteGuard},
 };

 use chrono::Utc;
-use directories::BaseDirs;
-use log::{debug, error, info};
+use log::{debug, error, info, warn};
+use native_model::{Decode, Encode};
 use rustbreak::{DeSerError, DeSerializer, PathDatabase, RustbreakError};
-use serde::{de::DeserializeOwned, Deserialize, Serialize};
-use serde_with::serde_as;
-use tauri::AppHandle;
+use serde::{de::DeserializeOwned, Serialize};
 use url::Url;

-use crate::{
-    database::settings::Settings,
-    download_manager::downloadable_metadata::DownloadableMetadata,
-    games::{library::push_game_update, state::GameStatusManager},
-    process::process_manager::Platform,
-    DB,
-};
+use crate::DB;

-#[derive(serde::Serialize, Clone, Deserialize)]
-pub struct DatabaseAuth {
-    pub private: String,
-    pub cert: String,
-    pub client_id: String,
-    pub web_token: Option<String>,
-}
+use super::models::data::Database;

-// Strings are version names for a particular game
-#[derive(Serialize, Clone, Deserialize)]
-#[serde(tag = "type")]
-pub enum GameDownloadStatus {
-    Remote {},
-    SetupRequired {
-        version_name: String,
-        install_dir: String,
-    },
-    Installed {
-        version_name: String,
-        install_dir: String,
-    },
-}
-
-// Stuff that shouldn't be synced to disk
-#[derive(Clone, Serialize, Deserialize)]
-pub enum ApplicationTransientStatus {
-    Downloading { version_name: String },
-    Uninstalling {},
-    Updating { version_name: String },
-    Running {},
-}
-
-fn default_template() -> String {
-    "{}".to_owned()
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct GameVersion {
-    pub game_id: String,
-    pub version_name: String,
-
-    pub platform: Platform,
-
-    pub launch_command: String,
-    pub launch_args: Vec<String>,
-    #[serde(default = "default_template")]
-    pub launch_command_template: String,
-
-    pub setup_command: String,
-    pub setup_args: Vec<String>,
-    #[serde(default = "default_template")]
-    pub setup_command_template: String,
-
-    pub only_setup: bool,
-
-    pub version_index: usize,
-    pub delta: bool,
-
-    pub umu_id_override: Option<String>,
-}
-
-#[serde_as]
-#[derive(Serialize, Clone, Deserialize, Default)]
-#[serde(rename_all = "camelCase")]
-pub struct DatabaseApplications {
-    pub install_dirs: Vec<PathBuf>,
-    // Guaranteed to exist if the game also exists in the app state map
-    pub game_statuses: HashMap<String, GameDownloadStatus>,
-    pub game_versions: HashMap<String, HashMap<String, GameVersion>>,
-    pub installed_game_version: HashMap<String, DownloadableMetadata>,
-
-    #[serde(skip)]
-    pub transient_statuses: HashMap<DownloadableMetadata, ApplicationTransientStatus>,
-}
-
-#[derive(Serialize, Deserialize, Clone, Default)]
-pub struct Database {
-    #[serde(default)]
-    pub settings: Settings,
-    pub auth: Option<DatabaseAuth>,
-    pub base_url: String,
-    pub applications: DatabaseApplications,
-    pub prev_database: Option<PathBuf>,
-    pub cache_dir: PathBuf,
-}
-impl Database {
-    fn new<T: Into<PathBuf>>(
-        games_base_dir: T,
-        prev_database: Option<PathBuf>,
-        cache_dir: PathBuf,
-    ) -> Self {
-        Self {
-            applications: DatabaseApplications {
-                install_dirs: vec![games_base_dir.into()],
-                game_statuses: HashMap::new(),
-                game_versions: HashMap::new(),
-                installed_game_version: HashMap::new(),
-                transient_statuses: HashMap::new(),
-            },
-            prev_database,
-            base_url: "".to_owned(),
-            auth: None,
-            settings: Settings::default(),
-            cache_dir,
-        }
-    }
-}
-pub static DATA_ROOT_DIR: LazyLock<Mutex<PathBuf>> =
-    LazyLock::new(|| Mutex::new(BaseDirs::new().unwrap().data_dir().join("drop")));
+pub static DATA_ROOT_DIR: LazyLock<Arc<PathBuf>> =
+    LazyLock::new(|| Arc::new(dirs::data_dir().unwrap().join("drop")));

 // Custom JSON serializer to support everything we need
 #[derive(Debug, Default, Clone)]
 pub struct DropDatabaseSerializer;

-impl<T: Serialize + DeserializeOwned> DeSerializer<T> for DropDatabaseSerializer {
+impl<T: native_model::Model + Serialize + DeserializeOwned> DeSerializer<T>
+    for DropDatabaseSerializer
+{
    fn serialize(&self, val: &T) -> rustbreak::error::DeSerResult<Vec<u8>> {
-        serde_json::to_vec(val).map_err(|e| DeSerError::Internal(e.to_string()))
+        native_model::rmp_serde_1_3::RmpSerde::encode(val)
+            .map_err(|e| DeSerError::Internal(e.to_string()))
    }

-    fn deserialize<R: std::io::Read>(&self, s: R) -> rustbreak::error::DeSerResult<T> {
-        serde_json::from_reader(s).map_err(|e| DeSerError::Internal(e.to_string()))
+    fn deserialize<R: std::io::Read>(&self, mut s: R) -> rustbreak::error::DeSerResult<T> {
+        let mut buf = Vec::new();
+        s.read_to_end(&mut buf)
+            .map_err(|e| rustbreak::error::DeSerError::Other(e.into()))?;
+        let val = native_model::rmp_serde_1_3::RmpSerde::decode(buf)
+            .map_err(|e| DeSerError::Internal(e.to_string()))?;
+        Ok(val)
    }
 }

@ -158,34 +52,32 @@ pub trait DatabaseImpls {
 }
 impl DatabaseImpls for DatabaseInterface {
    fn set_up_database() -> DatabaseInterface {
-        let data_root_dir = DATA_ROOT_DIR.lock().unwrap();
-        let db_path = data_root_dir.join("drop.db");
-        let games_base_dir = data_root_dir.join("games");
-        let logs_root_dir = data_root_dir.join("logs");
-        let cache_dir = data_root_dir.join("cache");
+        let db_path = DATA_ROOT_DIR.join("drop.db");
+        let games_base_dir = DATA_ROOT_DIR.join("games");
+        let logs_root_dir = DATA_ROOT_DIR.join("logs");
+        let cache_dir = DATA_ROOT_DIR.join("cache");
+        let pfx_dir = DATA_ROOT_DIR.join("pfx");

-        debug!("creating data directory at {:?}", data_root_dir);
-        create_dir_all(data_root_dir.clone()).unwrap();
+        debug!("creating data directory at {DATA_ROOT_DIR:?}");
+        create_dir_all(DATA_ROOT_DIR.as_path()).unwrap();
        create_dir_all(&games_base_dir).unwrap();
        create_dir_all(&logs_root_dir).unwrap();
        create_dir_all(&cache_dir).unwrap();
+        create_dir_all(&pfx_dir).unwrap();

        let exists = fs::exists(db_path.clone()).unwrap();

-        match exists {
-            true => match PathDatabase::load_from_path(db_path.clone()) {
-                Ok(db) => db,
-                Err(e) => handle_invalid_database(e, db_path, games_base_dir, cache_dir),
-            },
-            false => {
-                let default = Database::new(games_base_dir, None, cache_dir);
-                debug!(
-                    "Creating database at path {}",
-                    db_path.as_os_str().to_str().unwrap()
-                );
-                PathDatabase::create_at_path(db_path, default)
-                    .expect("Database could not be created")
-            }
+        if exists { match PathDatabase::load_from_path(db_path.clone()) {
+            Ok(db) => db,
+            Err(e) => handle_invalid_database(e, db_path, games_base_dir, cache_dir),
+        } } else {
+            let default = Database::new(games_base_dir, None, cache_dir);
+            debug!(
+                "Creating database at path {}",
+                db_path.as_os_str().to_str().unwrap()
+            );
+            PathDatabase::create_at_path(db_path, default)
+                .expect("Database could not be created")
        }
    }

@ -206,16 +98,14 @@ fn handle_invalid_database(
    games_base_dir: PathBuf,
    cache_dir: PathBuf,
 ) -> rustbreak::Database<Database, rustbreak::backend::PathBackend, DropDatabaseSerializer> {
+    warn!("{_e}");
    let new_path = {
        let time = Utc::now().timestamp();
        let mut base = db_path.clone();
-        base.set_file_name(format!("drop.db.backup-{}", time));
+        base.set_file_name(format!("drop.db.backup-{time}"));
        base
    };
-    info!(
-        "old database stored at: {}",
-        new_path.to_string_lossy().to_string()
-    );
+    info!("old database stored at: {}", new_path.to_string_lossy());
    fs::rename(&db_path, &new_path).unwrap();

    let db = Database::new(
@ -227,32 +117,59 @@ fn handle_invalid_database(
    PathDatabase::create_at_path(db_path, db).expect("Database could not be created")
 }

-pub fn borrow_db_checked<'a>() -> RwLockReadGuard<'a, Database> {
+// To automatically save the database upon drop
+pub struct DBRead<'a>(RwLockReadGuard<'a, Database>);
+pub struct DBWrite<'a>(ManuallyDrop<RwLockWriteGuard<'a, Database>>);
+impl<'a> Deref for DBWrite<'a> {
+    type Target = RwLockWriteGuard<'a, Database>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl<'a> Deref for DBRead<'a> {
+    type Target = RwLockReadGuard<'a, Database>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl DerefMut for DBWrite<'_> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl Drop for DBWrite<'_> {
+    fn drop(&mut self) {
+        unsafe {
+            ManuallyDrop::drop(&mut self.0);
+        }
+
+        match DB.save() {
+            Ok(()) => {}
+            Err(e) => {
+                error!("database failed to save with error {e}");
+                panic!("database failed to save with error {e}")
+            }
+        }
+    }
+}
+pub fn borrow_db_checked<'a>() -> DBRead<'a> {
    match DB.borrow_data() {
-        Ok(data) => data,
+        Ok(data) => DBRead(data),
        Err(e) => {
-            error!("database borrow failed with error {}", e);
-            panic!("database borrow failed with error {}", e);
+            error!("database borrow failed with error {e}");
+            panic!("database borrow failed with error {e}");
        }
    }
 }

-pub fn borrow_db_mut_checked<'a>() -> RwLockWriteGuard<'a, Database> {
+pub fn borrow_db_mut_checked<'a>() -> DBWrite<'a> {
    match DB.borrow_data_mut() {
-        Ok(data) => data,
+        Ok(data) => DBWrite(ManuallyDrop::new(data)),
        Err(e) => {
-            error!("database borrow mut failed with error {}", e);
-            panic!("database borrow mut failed with error {}", e);
-        }
-    }
-}
-
-pub fn save_db() {
-    match DB.save() {
-        Ok(_) => {}
-        Err(e) => {
-            error!("database failed to save with error {}", e);
-            panic!("database failed to save with error {}", e)
+            error!("database borrow mut failed with error {e}");
+            panic!("database borrow mut failed with error {e}");
        }
    }
 }
--- a/src-tauri/src/database/mod.rs
+++ b/src-tauri/src/database/mod.rs
@ -1,4 +1,4 @@
 pub mod commands;
 pub mod db;
 pub mod debug;
-pub mod settings;
+pub mod models;
--- a/src-tauri/src/database/models.rs
+++ b/src-tauri/src/database/models.rs
@ -0,0 +1,347 @@
+use crate::database::models::data::Database;
+
+pub mod data {
+    use std::path::PathBuf;
+
+    use native_model::native_model;
+    use serde::{Deserialize, Serialize};
+
+    pub type GameVersion = v1::GameVersion;
+    pub type Database = v3::Database;
+    pub type Settings = v1::Settings;
+    pub type DatabaseAuth = v1::DatabaseAuth;
+
+    pub type GameDownloadStatus = v2::GameDownloadStatus;
+    pub type ApplicationTransientStatus = v1::ApplicationTransientStatus;
+    pub type DownloadableMetadata = v1::DownloadableMetadata;
+    pub type DownloadType = v1::DownloadType;
+    pub type DatabaseApplications = v2::DatabaseApplications;
+    pub type DatabaseCompatInfo = v2::DatabaseCompatInfo;
+
+    use std::{collections::HashMap, process::Command};
+
+    use crate::process::process_manager::UMU_LAUNCHER_EXECUTABLE;
+
+    pub mod v1 {
+        use crate::process::process_manager::Platform;
+        use serde_with::serde_as;
+        use std::{collections::HashMap, path::PathBuf};
+
+        use super::{Serialize, Deserialize, native_model};
+
+        fn default_template() -> String {
+            "{}".to_owned()
+        }
+
+        #[derive(Serialize, Deserialize, Clone, Debug)]
+        #[serde(rename_all = "camelCase")]
+        #[native_model(id = 2, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
+        pub struct GameVersion {
+            pub game_id: String,
+            pub version_name: String,
+
+            pub platform: Platform,
+
+            pub launch_command: String,
+            pub launch_args: Vec<String>,
+            #[serde(default = "default_template")]
+            pub launch_command_template: String,
+
+            pub setup_command: String,
+            pub setup_args: Vec<String>,
+            #[serde(default = "default_template")]
+            pub setup_command_template: String,
+
+            pub only_setup: bool,
+
+            pub version_index: usize,
+            pub delta: bool,
+
+            pub umu_id_override: Option<String>,
+        }
+
+        #[serde_as]
+        #[derive(Serialize, Clone, Deserialize, Default)]
+        #[serde(rename_all = "camelCase")]
+        #[native_model(id = 3, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
+        pub struct DatabaseApplications {
+            pub install_dirs: Vec<PathBuf>,
+            // Guaranteed to exist if the game also exists in the app state map
+            pub game_statuses: HashMap<String, GameDownloadStatus>,
+            pub game_versions: HashMap<String, HashMap<String, GameVersion>>,
+            pub installed_game_version: HashMap<String, DownloadableMetadata>,
+
+            #[serde(skip)]
+            pub transient_statuses: HashMap<DownloadableMetadata, ApplicationTransientStatus>,
+        }
+
+        #[derive(Serialize, Deserialize, Clone, Debug)]
+        #[serde(rename_all = "camelCase")]
+        #[native_model(id = 4, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
+        pub struct Settings {
+            pub autostart: bool,
+            pub max_download_threads: usize,
+            pub force_offline: bool, // ... other settings ...
+        }
+        impl Default for Settings {
+            fn default() -> Self {
+                Self {
+                    autostart: false,
+                    max_download_threads: 4,
+                    force_offline: false,
+                }
+            }
+        }
+
+        // Strings are version names for a particular game
+        #[derive(Serialize, Clone, Deserialize)]
+        #[serde(tag = "type")]
+        #[native_model(id = 5, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
+        pub enum GameDownloadStatus {
+            Remote {},
+            SetupRequired {
+                version_name: String,
+                install_dir: String,
+            },
+            Installed {
+                version_name: String,
+                install_dir: String,
+            },
+        }
+
+        // Stuff that shouldn't be synced to disk
+        #[derive(Clone, Serialize, Deserialize, Debug)]
+        pub enum ApplicationTransientStatus {
+            Downloading { version_name: String },
+            Uninstalling {},
+            Updating { version_name: String },
+            Running {},
+        }
+
+        #[derive(serde::Serialize, Clone, Deserialize)]
+        #[native_model(id = 6, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
+        pub struct DatabaseAuth {
+            pub private: String,
+            pub cert: String,
+            pub client_id: String,
+            pub web_token: Option<String>,
+        }
+
+        #[native_model(id = 8, version = 1)]
+        #[derive(
+            Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Clone, Copy,
+        )]
+        pub enum DownloadType {
+            Game,
+            Tool,
+            Dlc,
+            Mod,
+        }
+
+        #[native_model(id = 7, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
+        #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Clone)]
+        #[serde(rename_all = "camelCase")]
+        pub struct DownloadableMetadata {
+            pub id: String,
+            pub version: Option<String>,
+            pub download_type: DownloadType,
+        }
+        impl DownloadableMetadata {
+            pub fn new(id: String, version: Option<String>, download_type: DownloadType) -> Self {
+                Self {
+                    id,
+                    version,
+                    download_type,
+                }
+            }
+        }
+
+        #[native_model(id = 1, version = 1)]
+        #[derive(Serialize, Deserialize, Clone, Default)]
+        pub struct Database {
+            #[serde(default)]
+            pub settings: Settings,
+            pub auth: Option<DatabaseAuth>,
+            pub base_url: String,
+            pub applications: DatabaseApplications,
+            pub prev_database: Option<PathBuf>,
+            pub cache_dir: PathBuf,
+        }
+    }
+
+    pub mod v2 {
+        use std::{collections::HashMap, path::PathBuf};
+
+        use serde_with::serde_as;
+
+        use super::{Serialize, Deserialize, native_model, Settings, DatabaseAuth, v1, GameVersion, DownloadableMetadata, ApplicationTransientStatus};
+
+        #[native_model(id = 1, version = 2, with = native_model::rmp_serde_1_3::RmpSerde)]
+        #[derive(Serialize, Deserialize, Clone, Default)]
+        pub struct Database {
+            #[serde(default)]
+            pub settings: Settings,
+            pub auth: Option<DatabaseAuth>,
+            pub base_url: String,
+            pub applications: v1::DatabaseApplications,
+            #[serde(skip)]
+            pub prev_database: Option<PathBuf>,
+            pub cache_dir: PathBuf,
+            pub compat_info: Option<DatabaseCompatInfo>,
+        }
+
+        #[native_model(id = 8, version = 2, with = native_model::rmp_serde_1_3::RmpSerde)]
+        #[derive(Serialize, Deserialize, Clone, Default)]
+
+        pub struct DatabaseCompatInfo {
+            pub umu_installed: bool,
+        }
+
+        impl From<v1::Database> for Database {
+            fn from(value: v1::Database) -> Self {
+                Self {
+                    settings: value.settings,
+                    auth: value.auth,
+                    base_url: value.base_url,
+                    applications: value.applications,
+                    prev_database: value.prev_database,
+                    cache_dir: value.cache_dir,
+                    compat_info: crate::database::models::Database::create_new_compat_info(),
+                }
+            }
+        }
+        // Strings are version names for a particular game
+        #[derive(Serialize, Clone, Deserialize, Debug)]
+        #[serde(tag = "type")]
+        #[native_model(id = 5, version = 2, with = native_model::rmp_serde_1_3::RmpSerde)]
+        pub enum GameDownloadStatus {
+            Remote {},
+            SetupRequired {
+                version_name: String,
+                install_dir: String,
+            },
+            Installed {
+                version_name: String,
+                install_dir: String,
+            },
+            PartiallyInstalled {
+                version_name: String,
+                install_dir: String,
+            },
+        }
+        impl From<v1::GameDownloadStatus> for GameDownloadStatus {
+            fn from(value: v1::GameDownloadStatus) -> Self {
+                match value {
+                    v1::GameDownloadStatus::Remote {} => Self::Remote {},
+                    v1::GameDownloadStatus::SetupRequired {
+                        version_name,
+                        install_dir,
+                    } => Self::SetupRequired {
+                        version_name,
+                        install_dir,
+                    },
+                    v1::GameDownloadStatus::Installed {
+                        version_name,
+                        install_dir,
+                    } => Self::Installed {
+                        version_name,
+                        install_dir,
+                    },
+                }
+            }
+        }
+        #[serde_as]
+        #[derive(Serialize, Clone, Deserialize, Default)]
+        #[serde(rename_all = "camelCase")]
+        #[native_model(id = 3, version = 2, with = native_model::rmp_serde_1_3::RmpSerde)]
+        pub struct DatabaseApplications {
+            pub install_dirs: Vec<PathBuf>,
+            // Guaranteed to exist if the game also exists in the app state map
+            pub game_statuses: HashMap<String, GameDownloadStatus>,
+            pub game_versions: HashMap<String, HashMap<String, GameVersion>>,
+            pub installed_game_version: HashMap<String, DownloadableMetadata>,
+
+            #[serde(skip)]
+            pub transient_statuses: HashMap<DownloadableMetadata, ApplicationTransientStatus>,
+        }
+        impl From<v1::DatabaseApplications> for DatabaseApplications {
+            fn from(value: v1::DatabaseApplications) -> Self {
+                Self {
+                    game_statuses: value
+                        .game_statuses
+                        .into_iter()
+                        .map(|x| (x.0, x.1.into()))
+                        .collect::<HashMap<String, GameDownloadStatus>>(),
+                    install_dirs: value.install_dirs,
+                    game_versions: value.game_versions,
+                    installed_game_version: value.installed_game_version,
+                    transient_statuses: value.transient_statuses,
+                }
+            }
+        }
+    }
+    mod v3 {
+        use std::path::PathBuf;
+
+        use super::{Serialize, Deserialize, native_model, Settings, DatabaseAuth, DatabaseApplications, DatabaseCompatInfo, v2};
+        #[native_model(id = 1, version = 3, with = native_model::rmp_serde_1_3::RmpSerde)]
+        #[derive(Serialize, Deserialize, Clone, Default)]
+        pub struct Database {
+            #[serde(default)]
+            pub settings: Settings,
+            pub auth: Option<DatabaseAuth>,
+            pub base_url: String,
+            pub applications: DatabaseApplications,
+            #[serde(skip)]
+            pub prev_database: Option<PathBuf>,
+            pub cache_dir: PathBuf,
+            pub compat_info: Option<DatabaseCompatInfo>,
+        }
+        impl From<v2::Database> for Database {
+            fn from(value: v2::Database) -> Self {
+                Self {
+                    settings: value.settings,
+                    auth: value.auth,
+                    base_url: value.base_url,
+                    applications: value.applications.into(),
+                    prev_database: value.prev_database,
+                    cache_dir: value.cache_dir,
+                    compat_info: Database::create_new_compat_info(),
+                }
+            }
+        }
+    }
+    impl Database {
+        fn create_new_compat_info() -> Option<DatabaseCompatInfo> {
+            #[cfg(target_os = "windows")]
+            return None;
+
+            let has_umu_installed = Command::new(UMU_LAUNCHER_EXECUTABLE).spawn().is_ok();
+            Some(DatabaseCompatInfo {
+                umu_installed: has_umu_installed,
+            })
+        }
+
+        pub fn new<T: Into<PathBuf>>(
+            games_base_dir: T,
+            prev_database: Option<PathBuf>,
+            cache_dir: PathBuf,
+        ) -> Self {
+            Self {
+                applications: DatabaseApplications {
+                    install_dirs: vec![games_base_dir.into()],
+                    game_statuses: HashMap::new(),
+                    game_versions: HashMap::new(),
+                    installed_game_version: HashMap::new(),
+                    transient_statuses: HashMap::new(),
+                },
+                prev_database,
+                base_url: String::new(),
+                auth: None,
+                settings: Settings::default(),
+                cache_dir,
+                compat_info: Database::create_new_compat_info(),
+            }
+        }
+    }
+}
--- a/src-tauri/src/database/settings.rs
+++ b/src-tauri/src/database/settings.rs
@ -1,26 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct Settings {
-    pub autostart: bool,
-    pub max_download_threads: usize,
-    pub force_offline: bool
-    // ... other settings ...
-}
-impl Default for Settings {
-    fn default() -> Self {
-        Self {
-            autostart: false,
-            max_download_threads: 4,
-            force_offline: false
-        }
-    }
-}
-// Ideally use pointers instead of a macro to assign the settings
-// fn deserialize_into<T>(v: serde_json::Value, t: &mut T) -> Result<(), serde_json::Error>
-//     where T: for<'a> Deserialize<'a>
-// {
-//     *t = serde_json::from_value(v)?;
-//     Ok(())
-// }
--- a/src-tauri/src/download_manager/commands.rs
+++ b/src-tauri/src/download_manager/commands.rs
@ -1,15 +1,15 @@
 use std::sync::Mutex;

-use crate::{download_manager::downloadable_metadata::DownloadableMetadata, AppState};
+use crate::{database::models::data::DownloadableMetadata, AppState};

 #[tauri::command]
 pub fn pause_downloads(state: tauri::State<'_, Mutex<AppState>>) {
-    state.lock().unwrap().download_manager.pause_downloads()
+    state.lock().unwrap().download_manager.pause_downloads();
 }

 #[tauri::command]
 pub fn resume_downloads(state: tauri::State<'_, Mutex<AppState>>) {
-    state.lock().unwrap().download_manager.resume_downloads()
+    state.lock().unwrap().download_manager.resume_downloads();
 }

 #[tauri::command]
@ -22,10 +22,10 @@ pub fn move_download_in_queue(
        .lock()
        .unwrap()
        .download_manager
-        .rearrange(old_index, new_index)
+        .rearrange(old_index, new_index);
 }

 #[tauri::command]
 pub fn cancel_game(state: tauri::State<'_, Mutex<AppState>>, meta: DownloadableMetadata) {
-    state.lock().unwrap().download_manager.cancel(meta)
+    state.lock().unwrap().download_manager.cancel(meta);
 }
--- a/src-tauri/src/download_manager/download_manager_builder.rs
+++ b/src-tauri/src/download_manager/download_manager_builder.rs
@ -1,27 +1,29 @@
 use std::{
    collections::HashMap,
    sync::{
-        mpsc::{channel, Receiver, Sender},
        Arc, Mutex,
+        mpsc::{Receiver, Sender, channel},
    },
-    thread::{spawn, JoinHandle},
+    thread::{JoinHandle, spawn},
 };

 use log::{debug, error, info, warn};
 use tauri::{AppHandle, Emitter};

 use crate::{
+    database::models::data::DownloadableMetadata,
    error::application_download_error::ApplicationDownloadError,
    games::library::{QueueUpdateEvent, QueueUpdateEventQueueData, StatsUpdateEvent},
 };

 use super::{
-    download_manager::{DownloadManager, DownloadManagerSignal, DownloadManagerStatus},
-    download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag},
+    download_manager_frontend::{DownloadManager, DownloadManagerSignal, DownloadManagerStatus},
    downloadable::Downloadable,
-    downloadable_metadata::DownloadableMetadata,
-    progress_object::ProgressObject,
-    queue::Queue,
+    util::{
+        download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag},
+        progress_object::ProgressObject,
+        queue::Queue,
+    },
 };

 pub type DownloadAgent = Arc<Box<dyn Downloadable + Send + Sync>>;
@ -174,15 +176,14 @@ impl DownloadManagerBuilder {
                DownloadManagerSignal::Cancel(meta) => {
                    self.manage_cancel_signal(&meta);
                }
-                _ => {}
-            };
+            }
        }
    }
    fn manage_queue_signal(&mut self, download_agent: DownloadAgent) {
        debug!("got signal Queue");
        let meta = download_agent.metadata();

-        debug!("queue metadata: {:?}", meta);
+        debug!("queue metadata: {meta:?}");

        if self.download_queue.exists(meta.clone()) {
            warn!("download with same ID already exists");
@ -208,14 +209,15 @@ impl DownloadManagerBuilder {
            return;
        }

-        if self.current_download_agent.is_some() {
-            if self.download_queue.read().front().unwrap() == &self.current_download_agent.as_ref().unwrap().metadata() {
-                debug!(
-                    "Current download agent: {:?}",
-                    self.current_download_agent.as_ref().unwrap().metadata()
-                );
-                return;
-            }
+        if self.current_download_agent.is_some()
+            && self.download_queue.read().front().unwrap()
+                == &self.current_download_agent.as_ref().unwrap().metadata()
+        {
+            debug!(
+                "Current download agent: {:?}",
+                self.current_download_agent.as_ref().unwrap().metadata()
+            );
+            return;
        }

        debug!("current download queue: {:?}", self.download_queue.read());
@ -223,7 +225,7 @@ impl DownloadManagerBuilder {
        // Should always be Some if the above two statements keep going
        let agent_data = self.download_queue.read().front().unwrap().clone();

-        info!("starting download for {:?}", agent_data);
+        info!("starting download for {agent_data:?}");

        let download_agent = self
            .download_agent_registry
@ -240,26 +242,47 @@ impl DownloadManagerBuilder {
        let app_handle = self.app_handle.clone();

        *download_thread_lock = Some(spawn(move || {
-            match download_agent.download(&app_handle) {
-                // Ok(true) is for completed and exited properly
-                Ok(true) => {
-                    debug!("download {:?} has completed", download_agent.metadata());
+            loop {
+                let download_result = match download_agent.download(&app_handle) {
+                    // Ok(true) is for completed and exited properly
+                    Ok(v) => v,
+                    Err(e) => {
+                        error!("download {:?} has error {}", download_agent.metadata(), &e);
+                        download_agent.on_error(&app_handle, &e);
+                        sender.send(DownloadManagerSignal::Error(e)).unwrap();
+                        return;
+                    }
+                };
+
+                // If the download gets cancel
+                if !download_result {
+                    download_agent.on_incomplete(&app_handle);
+                    return;
+                }
+
+                let validate_result = match download_agent.validate() {
+                    Ok(v) => v,
+                    Err(e) => {
+                        error!(
+                            "download {:?} has validation error {}",
+                            download_agent.metadata(),
+                            &e
+                        );
+                        download_agent.on_error(&app_handle, &e);
+                        sender.send(DownloadManagerSignal::Error(e)).unwrap();
+                        return;
+                    }
+                };
+
+                if validate_result {
                    download_agent.on_complete(&app_handle);
                    sender
                        .send(DownloadManagerSignal::Completed(download_agent.metadata()))
                        .unwrap();
-                }
-                // Ok(false) is for incomplete but exited properly
-                Ok(false) => {
-                    download_agent.on_incomplete(&app_handle);
-                }
-                Err(e) => {
-                    error!("download {:?} has error {}", download_agent.metadata(), &e);
-                    download_agent.on_error(&app_handle, &e);
-                    sender.send(DownloadManagerSignal::Error(e)).unwrap();
+                    sender.send(DownloadManagerSignal::UpdateUIQueue).unwrap();
+                    return;
                }
            }
-            sender.send(DownloadManagerSignal::UpdateUIQueue).unwrap();
        }));

        self.set_status(DownloadManagerStatus::Downloading);
@ -276,11 +299,12 @@ impl DownloadManagerBuilder {
    }
    fn manage_completed_signal(&mut self, meta: DownloadableMetadata) {
        debug!("got signal Completed");
-        if let Some(interface) = &self.current_download_agent {
-            if interface.metadata() == meta {
-                self.remove_and_cleanup_front_download(&meta);
-            }
+        if let Some(interface) = &self.current_download_agent
+            && interface.metadata() == meta
+        {
+            self.remove_and_cleanup_front_download(&meta);
        }
+
        self.push_ui_queue_update();
        self.sender.send(DownloadManagerSignal::Go).unwrap();
    }
@ -292,7 +316,7 @@ impl DownloadManagerBuilder {
            self.stop_and_wait_current_download();
            self.remove_and_cleanup_front_download(&current_agent.metadata());
        }
-        self.set_status(DownloadManagerStatus::Error(error));
+        self.set_status(DownloadManagerStatus::Error);
    }
    fn manage_cancel_signal(&mut self, meta: &DownloadableMetadata) {
        debug!("got signal Cancel");
--- a/src-tauri/src/download_manager/download_manager_frontend.rs
+++ b/src-tauri/src/download_manager/download_manager_frontend.rs
@ -12,22 +12,24 @@ use std::{
 use log::{debug, info};
 use serde::Serialize;

-use crate::error::application_download_error::ApplicationDownloadError;
+use crate::{
+    database::models::data::DownloadableMetadata,
+    error::application_download_error::ApplicationDownloadError,
+};

 use super::{
    download_manager_builder::{CurrentProgressObject, DownloadAgent},
-    downloadable_metadata::DownloadableMetadata,
-    queue::Queue,
+    util::queue::Queue,
 };

 pub enum DownloadManagerSignal {
-    /// Resumes (or starts) the DownloadManager
+    /// Resumes (or starts) the `DownloadManager`
    Go,
-    /// Pauses the DownloadManager
+    /// Pauses the `DownloadManager`
    Stop,
-    /// Called when a DownloadAgent has fully completed a download.
+    /// Called when a `DownloadAgent` has fully completed a download.
    Completed(DownloadableMetadata),
-    /// Generates and appends a DownloadAgent
+    /// Generates and appends a `DownloadAgent`
    /// to the registry and queue
    Queue(DownloadAgent),
    /// Tells the Manager to stop the current
@ -36,16 +38,11 @@ pub enum DownloadManagerSignal {
    Finish,
    /// Stops, removes, and tells a download to cleanup
    Cancel(DownloadableMetadata),
-    /// Removes a given application
-    Remove(DownloadableMetadata),
    /// Any error which occurs in the agent
    Error(ApplicationDownloadError),
    /// Pushes UI update
    UpdateUIQueue,
    UpdateUIStats(usize, usize), //kb/s and seconds
-    /// Uninstall download
-    /// Takes download ID
-    Uninstall(DownloadableMetadata),
 }

 #[derive(Debug)]
@ -53,8 +50,7 @@ pub enum DownloadManagerStatus {
    Downloading,
    Paused,
    Empty,
-    Error(ApplicationDownloadError),
-    Finished,
+    Error,
 }

 impl Serialize for DownloadManagerStatus {
@ -62,7 +58,7 @@ impl Serialize for DownloadManagerStatus {
    where
        S: serde::Serializer,
    {
-        serializer.serialize_str(&format!["{:?}", self])
+        serializer.serialize_str(&format!["{self:?}"])
    }
 }

@ -70,17 +66,18 @@ impl Serialize for DownloadManagerStatus {
 pub enum DownloadStatus {
    Queued,
    Downloading,
+    Validating,
    Error,
 }

-/// Accessible front-end for the DownloadManager
+/// Accessible front-end for the `DownloadManager`
 ///
 /// The system works entirely through signals, both internally and externally,
-/// all of which are accessible through the DownloadManagerSignal type, but
+/// all of which are accessible through the `DownloadManagerSignal` type, but
 /// should not be used directly. Rather, signals are abstracted through this
 /// interface.
 ///
-/// The actual download queue may be accessed through the .edit() function,
+/// The actual download queue may be accessed through the .`edit()` function,
 /// which provides raw access to the underlying queue.
 /// THIS EDITING IS BLOCKING!!!
 pub struct DownloadManager {
@ -142,7 +139,7 @@ impl DownloadManager {
    pub fn rearrange(&self, current_index: usize, new_index: usize) {
        if current_index == new_index {
            return;
-        };
+        }

        let needs_pause = current_index == 0 || new_index == 0;
        if needs_pause {
@ -151,10 +148,7 @@ impl DownloadManager {
                .unwrap();
        }

-        debug!(
-            "moving download at index {} to index {}",
-            current_index, new_index
-        );
+        debug!("moving download at index {current_index} to index {new_index}");

        let mut queue = self.edit();
        let to_move = queue.remove(current_index).unwrap();
@ -167,10 +161,7 @@ impl DownloadManager {
        self.command_sender
            .send(DownloadManagerSignal::UpdateUIQueue)
            .unwrap();
-        self.command_sender
-            .send(DownloadManagerSignal::Go)
-            .unwrap();
-
+        self.command_sender.send(DownloadManagerSignal::Go).unwrap();
    }
    pub fn pause_downloads(&self) {
        self.command_sender
@ -187,17 +178,12 @@ impl DownloadManager {
        let terminator = self.terminator.lock().unwrap().take();
        terminator.unwrap().join()
    }
-    pub fn uninstall_application(&self, meta: DownloadableMetadata) {
-        self.command_sender
-            .send(DownloadManagerSignal::Uninstall(meta))
-            .unwrap();
-    }
    pub fn get_sender(&self) -> Sender<DownloadManagerSignal> {
        self.command_sender.clone()
    }
 }

-/// Takes in the locked value from .edit() and attempts to
+/// Takes in the locked value from .`edit()` and attempts to
 /// get the index of whatever id is passed in
 fn get_index_from_id(
    queue: &mut MutexGuard<'_, VecDeque<DownloadableMetadata>>,
--- a/src-tauri/src/download_manager/downloadable.rs
+++ b/src-tauri/src/download_manager/downloadable.rs
@ -2,17 +2,21 @@ use std::sync::Arc;

 use tauri::AppHandle;

-use crate::error::application_download_error::ApplicationDownloadError;
+use crate::{
+    database::models::data::DownloadableMetadata,
+    error::application_download_error::ApplicationDownloadError,
+};

 use super::{
-    download_manager::DownloadStatus, download_thread_control_flag::DownloadThreadControl,
-    downloadable_metadata::DownloadableMetadata, progress_object::ProgressObject,
+    download_manager_frontend::DownloadStatus,
+    util::{download_thread_control_flag::DownloadThreadControl, progress_object::ProgressObject},
 };

 pub trait Downloadable: Send + Sync {
    fn download(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError>;
    fn progress(&self) -> Arc<ProgressObject>;
    fn control_flag(&self) -> DownloadThreadControl;
+    fn validate(&self) -> Result<bool, ApplicationDownloadError>;
    fn status(&self) -> DownloadStatus;
    fn metadata(&self) -> DownloadableMetadata;
    fn on_initialised(&self, app_handle: &AppHandle);
--- a/src-tauri/src/download_manager/downloadable_metadata.rs
+++ b/src-tauri/src/download_manager/downloadable_metadata.rs
@ -1,26 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Clone, Copy)]
-pub enum DownloadType {
-    Game,
-    Tool,
-    DLC,
-    Mod,
-}
-
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct DownloadableMetadata {
-    pub id: String,
-    pub version: Option<String>,
-    pub download_type: DownloadType,
-}
-impl DownloadableMetadata {
-    pub fn new(id: String, version: Option<String>, download_type: DownloadType) -> Self {
-        Self {
-            id,
-            version,
-            download_type,
-        }
-    }
-}
--- a/src-tauri/src/download_manager/internal_error.rs
+++ b/src-tauri/src/download_manager/internal_error.rs
@ -1,27 +0,0 @@
-use std::{fmt::Display, io, sync::mpsc::SendError};
-
-use serde_with::SerializeDisplay;
-
-#[derive(SerializeDisplay)]
-pub enum InternalError<T> {
-    IOError(io::Error),
-    SignalError(SendError<T>),
-}
-impl<T> Display for InternalError<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            InternalError::IOError(error) => write!(f, "{}", error),
-            InternalError::SignalError(send_error) => write!(f, "{}", send_error),
-        }
-    }
-}
-impl<T> From<SendError<T>> for InternalError<T> {
-    fn from(value: SendError<T>) -> Self {
-        InternalError::SignalError(value)
-    }
-}
-impl<T> From<io::Error> for InternalError<T> {
-    fn from(value: io::Error) -> Self {
-        InternalError::IOError(value)
-    }
-}
--- a/src-tauri/src/download_manager/mod.rs
+++ b/src-tauri/src/download_manager/mod.rs
@ -1,10 +1,5 @@
 pub mod commands;
-pub mod download_manager;
 pub mod download_manager_builder;
-pub mod download_thread_control_flag;
+pub mod download_manager_frontend;
 pub mod downloadable;
-pub mod downloadable_metadata;
-pub mod internal_error;
-pub mod progress_object;
-pub mod queue;
-pub mod rolling_progress_updates;
+pub mod util;
--- a/src-tauri/src/download_manager/queue.rs
+++ b/src-tauri/src/download_manager/queue.rs
@ -1,80 +0,0 @@
-use std::{
-    collections::VecDeque,
-    sync::{Arc, Mutex, MutexGuard},
-};
-
-use super::downloadable_metadata::DownloadableMetadata;
-
-#[derive(Clone)]
-pub struct Queue {
-    inner: Arc<Mutex<VecDeque<DownloadableMetadata>>>,
-}
-
-#[allow(dead_code)]
-impl Default for Queue {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Queue {
-    pub fn new() -> Self {
-        Self {
-            inner: Arc::new(Mutex::new(VecDeque::new())),
-        }
-    }
-    pub fn read(&self) -> VecDeque<DownloadableMetadata> {
-        self.inner.lock().unwrap().clone()
-    }
-    pub fn edit(&self) -> MutexGuard<'_, VecDeque<DownloadableMetadata>> {
-        self.inner.lock().unwrap()
-    }
-    pub fn pop_front(&self) -> Option<DownloadableMetadata> {
-        self.edit().pop_front()
-    }
-    pub fn is_empty(&self) -> bool {
-        self.inner.lock().unwrap().len() == 0
-    }
-    pub fn exists(&self, meta: DownloadableMetadata) -> bool {
-        self.read().contains(&meta)
-    }
-    /// Either inserts `interface` at the specified index, or appends to
-    /// the back of the deque if index is greater than the length of the deque
-    pub fn insert(&self, interface: DownloadableMetadata, index: usize) {
-        if self.read().len() > index {
-            self.append(interface);
-        } else {
-            self.edit().insert(index, interface);
-        }
-    }
-    pub fn append(&self, interface: DownloadableMetadata) {
-        self.edit().push_back(interface);
-    }
-    pub fn pop_front_if_equal(&self, meta: &DownloadableMetadata) -> Option<DownloadableMetadata> {
-        let mut queue = self.edit();
-        let front = queue.front()?;
-        if front == meta {
-            return queue.pop_front();
-        }
-        None
-    }
-    pub fn get_by_meta(&self, meta: &DownloadableMetadata) -> Option<usize> {
-        self.read().iter().position(|data| data == meta)
-    }
-    pub fn move_to_index_by_meta(
-        &self,
-        meta: &DownloadableMetadata,
-        new_index: usize,
-    ) -> Result<(), ()> {
-        let index = match self.get_by_meta(meta) {
-            Some(index) => index,
-            None => return Err(()),
-        };
-        let existing = match self.edit().remove(index) {
-            Some(existing) => existing,
-            None => return Err(()),
-        };
-        self.edit().insert(new_index, existing);
-        Ok(())
-    }
-}
--- a/src-tauri/src/download_manager/util/download_thread_control_flag.rs
+++ b/src-tauri/src/download_manager/util/download_thread_control_flag.rs
@ -22,10 +22,7 @@ impl From<DownloadThreadControlFlag> for bool {
 /// false => Stop
 impl From<bool> for DownloadThreadControlFlag {
    fn from(value: bool) -> Self {
-        match value {
-            true => DownloadThreadControlFlag::Go,
-            false => DownloadThreadControlFlag::Stop,
-        }
+        if value { DownloadThreadControlFlag::Go } else { DownloadThreadControlFlag::Stop }
    }
 }

--- a/src-tauri/src/download_manager/util/mod.rs
+++ b/src-tauri/src/download_manager/util/mod.rs
@ -0,0 +1,4 @@
+pub mod download_thread_control_flag;
+pub mod progress_object;
+pub mod queue;
+pub mod rolling_progress_updates;
--- a/src-tauri/src/download_manager/util/progress_object.rs
+++ b/src-tauri/src/download_manager/util/progress_object.rs
@ -10,9 +10,9 @@ use std::{
 use atomic_instant_full::AtomicInstant;
 use throttle_my_fn::throttle;

-use super::{
-    download_manager::DownloadManagerSignal, rolling_progress_updates::RollingProgressWindow,
-};
+use crate::download_manager::download_manager_frontend::DownloadManagerSignal;
+
+use super::rolling_progress_updates::RollingProgressWindow;

 #[derive(Clone)]
 pub struct ProgressObject {
@ -84,6 +84,17 @@ impl ProgressObject {
            .map(|instance| instance.load(Ordering::Relaxed))
            .sum()
    }
+    pub fn reset(&self, size: usize) {
+        self.set_time_now();
+        self.set_size(size);
+        self.bytes_last_update.store(0, Ordering::Release);
+        self.rolling.reset();
+        self.progress_instances
+            .lock()
+            .unwrap()
+            .iter()
+            .for_each(|x| x.store(0, Ordering::Release));
+    }
    pub fn get_max(&self) -> usize {
        *self.max.lock().unwrap()
    }
@ -122,7 +133,7 @@ pub fn calculate_update(progress: &ProgressObject) {

    let kilobytes_per_second = bytes_since_last_update / (time_since_last_update as usize).max(1);

-    let bytes_remaining = max - current_bytes_downloaded; // bytes
+    let bytes_remaining = max.saturating_sub(current_bytes_downloaded); // bytes

    progress.update_window(kilobytes_per_second);
    push_update(progress, bytes_remaining);
--- a/src-tauri/src/download_manager/util/queue.rs
+++ b/src-tauri/src/download_manager/util/queue.rs
@ -0,0 +1,44 @@
+use std::{
+    collections::VecDeque,
+    sync::{Arc, Mutex, MutexGuard},
+};
+
+use crate::database::models::data::DownloadableMetadata;
+
+#[derive(Clone)]
+pub struct Queue {
+    inner: Arc<Mutex<VecDeque<DownloadableMetadata>>>,
+}
+
+#[allow(dead_code)]
+impl Default for Queue {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Queue {
+    pub fn new() -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(VecDeque::new())),
+        }
+    }
+    pub fn read(&self) -> VecDeque<DownloadableMetadata> {
+        self.inner.lock().unwrap().clone()
+    }
+    pub fn edit(&self) -> MutexGuard<'_, VecDeque<DownloadableMetadata>> {
+        self.inner.lock().unwrap()
+    }
+    pub fn pop_front(&self) -> Option<DownloadableMetadata> {
+        self.edit().pop_front()
+    }
+    pub fn exists(&self, meta: DownloadableMetadata) -> bool {
+        self.read().contains(&meta)
+    }
+    pub fn append(&self, interface: DownloadableMetadata) {
+        self.edit().push_back(interface);
+    }
+    pub fn get_by_meta(&self, meta: &DownloadableMetadata) -> Option<usize> {
+        self.read().iter().position(|data| data == meta)
+    }
+}
--- a/src-tauri/src/download_manager/util/rolling_progress_updates.rs
+++ b/src-tauri/src/download_manager/util/rolling_progress_updates.rs
@ -11,7 +11,7 @@ pub struct RollingProgressWindow<const S: usize> {
 impl<const S: usize> RollingProgressWindow<S> {
    pub fn new() -> Self {
        Self {
-            window: Arc::new([(); S].map(|_| AtomicUsize::new(0))),
+            window: Arc::new([(); S].map(|()| AtomicUsize::new(0))),
            current: Arc::new(AtomicUsize::new(0)),
        }
    }
@ -30,4 +30,9 @@ impl<const S: usize> RollingProgressWindow<S> {
            .sum::<usize>()
            / S
    }
+    pub fn reset(&self) {
+        self.window
+            .iter()
+            .for_each(|x| x.store(0, Ordering::Release));
+    }
 }
--- a/src-tauri/src/error/application_download_error.rs
+++ b/src-tauri/src/error/application_download_error.rs
@ -5,14 +5,13 @@ use std::{

 use serde_with::SerializeDisplay;

-use super::{remote_access_error::RemoteAccessError, setup_error::SetupError};
+use super::remote_access_error::RemoteAccessError;

 // TODO: Rename / separate from downloads
 #[derive(Debug, SerializeDisplay)]
 pub enum ApplicationDownloadError {
    Communication(RemoteAccessError),
    Checksum,
-    Setup(SetupError),
    Lock,
    IoError(io::ErrorKind),
    DownloadError,
@ -21,11 +20,10 @@ pub enum ApplicationDownloadError {
 impl Display for ApplicationDownloadError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
-            ApplicationDownloadError::Communication(error) => write!(f, "{}", error),
-            ApplicationDownloadError::Setup(error) => write!(f, "an error occurred while setting up the download: {}", error),
+            ApplicationDownloadError::Communication(error) => write!(f, "{error}"),
            ApplicationDownloadError::Lock => write!(f, "failed to acquire lock. Something has gone very wrong internally. Please restart the application"),
            ApplicationDownloadError::Checksum => write!(f, "checksum failed to validate for download"),
-            ApplicationDownloadError::IoError(error) => write!(f, "{}", error),
+            ApplicationDownloadError::IoError(error) => write!(f, "io error: {error}"),
            ApplicationDownloadError::DownloadError => write!(f, "download failed. See Download Manager status for specific error"),
        }
    }
--- a/src-tauri/src/error/download_manager_error.rs
+++ b/src-tauri/src/error/download_manager_error.rs
@ -0,0 +1,27 @@
+use std::{fmt::Display, io, sync::mpsc::SendError};
+
+use serde_with::SerializeDisplay;
+
+#[derive(SerializeDisplay)]
+pub enum DownloadManagerError<T> {
+    IOError(io::Error),
+    SignalError(SendError<T>),
+}
+impl<T> Display for DownloadManagerError<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            DownloadManagerError::IOError(error) => write!(f, "{error}"),
+            DownloadManagerError::SignalError(send_error) => write!(f, "{send_error}"),
+        }
+    }
+}
+impl<T> From<SendError<T>> for DownloadManagerError<T> {
+    fn from(value: SendError<T>) -> Self {
+        DownloadManagerError::SignalError(value)
+    }
+}
+impl<T> From<io::Error> for DownloadManagerError<T> {
+    fn from(value: io::Error) -> Self {
+        DownloadManagerError::IOError(value)
+    }
+}
--- a/src-tauri/src/error/drop_server_error.rs
+++ b/src-tauri/src/error/drop_server_error.rs
@ -5,6 +5,6 @@ use serde::Deserialize;
 pub struct DropServerError {
    pub status_code: usize,
    pub status_message: String,
-    pub message: String,
-    pub url: String,
+    // pub message: String,
+    // pub url: String,
 }
--- a/src-tauri/src/error/library_error.rs
+++ b/src-tauri/src/error/library_error.rs
@ -11,8 +11,7 @@ impl Display for LibraryError {
        match self {
            LibraryError::MetaNotFound(id) => write!(
                f,
-                "Could not locate any installed version of game ID {} in the database",
-                id
+                "Could not locate any installed version of game ID {id} in the database"
            ),
        }
    }
--- a/src-tauri/src/error/mod.rs
+++ b/src-tauri/src/error/mod.rs
@ -1,6 +1,6 @@
 pub mod application_download_error;
+pub mod download_manager_error;
 pub mod drop_server_error;
 pub mod library_error;
 pub mod process_error;
 pub mod remote_access_error;
-pub mod setup_error;
--- a/src-tauri/src/error/process_error.rs
+++ b/src-tauri/src/error/process_error.rs
@ -4,7 +4,6 @@ use serde_with::SerializeDisplay;

 #[derive(SerializeDisplay)]
 pub enum ProcessError {
-    SetupRequired,
    NotInstalled,
    AlreadyRunning,
    NotDownloaded,
@ -13,21 +12,22 @@ pub enum ProcessError {
    IOError(Error),
    FormatError(String), // String errors supremacy
    InvalidPlatform,
+    OpenerError(tauri_plugin_opener::Error)
 }

 impl Display for ProcessError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let s = match self {
-            ProcessError::SetupRequired => "Game not set up",
            ProcessError::NotInstalled => "Game not installed",
            ProcessError::AlreadyRunning => "Game already running",
            ProcessError::NotDownloaded => "Game not downloaded",
-            ProcessError::InvalidID => "Invalid Game ID",
-            ProcessError::InvalidVersion => "Invalid Game version",
+            ProcessError::InvalidID => "Invalid game ID",
+            ProcessError::InvalidVersion => "Invalid game version",
            ProcessError::IOError(error) => &error.to_string(),
-            ProcessError::InvalidPlatform => "This Game cannot be played on the current platform",
-            ProcessError::FormatError(e) => &format!("Failed to format template: {}", e),
-        };
-        write!(f, "{}", s)
+            ProcessError::InvalidPlatform => "This game cannot be played on the current platform",
+            ProcessError::FormatError(e) => &format!("Failed to format template: {e}"),
+            ProcessError::OpenerError(error) => &format!("Failed to open directory: {error}"),
+                    };
+        write!(f, "{s}")
    }
 }
--- a/src-tauri/src/error/remote_access_error.rs
+++ b/src-tauri/src/error/remote_access_error.rs
@ -1,5 +1,4 @@
 use std::{
-    any::{Any, TypeId},
    error::Error,
    fmt::{Display, Formatter},
    sync::Arc,
@ -14,16 +13,16 @@ use super::drop_server_error::DropServerError;
 #[derive(Debug, SerializeDisplay)]
 pub enum RemoteAccessError {
    FetchError(Arc<reqwest::Error>),
+    FetchErrorWS(Arc<reqwest_websocket::Error>),
    ParsingError(ParseError),
    InvalidEndpoint,
    HandshakeFailed(String),
    GameNotFound(String),
    InvalidResponse(DropServerError),
-    InvalidRedirect,
+    UnparseableResponse(String),
    ManifestDownloadFailed(StatusCode, String),
    OutOfSync,
-    Cache(cacache::Error),
-    Generic(String),
+    Cache(std::io::Error),
 }

 impl Display for RemoteAccessError {
@ -31,7 +30,10 @@ impl Display for RemoteAccessError {
        match self {
            RemoteAccessError::FetchError(error) => {
                if error.is_connect() {
-                    return write!(f, "Failed to connect to Drop server. Check if you access Drop through a browser, and then try again.");
+                    return write!(
+                        f,
+                        "Failed to connect to Drop server. Check if you access Drop through a browser, and then try again."
+                    );
                }

                write!(
@ -40,27 +42,45 @@ impl Display for RemoteAccessError {
                    error,
                    error
                        .source()
-                        .map(|e| e.to_string())
+                        .map(std::string::ToString::to_string)
                        .or_else(|| Some("Unknown error".to_string()))
                        .unwrap()
                )
-            },
+            }
+            RemoteAccessError::FetchErrorWS(error) => write!(
+                f,
+                "{}: {}",
+                error,
+                error
+                    .source()
+                    .map(|e| e.to_string())
+                    .or_else(|| Some("Unknown error".to_string()))
+                    .unwrap()
+            ),
            RemoteAccessError::ParsingError(parse_error) => {
-                write!(f, "{}", parse_error)
+                write!(f, "{parse_error}")
            }
            RemoteAccessError::InvalidEndpoint => write!(f, "invalid drop endpoint"),
-            RemoteAccessError::HandshakeFailed(message) => write!(f, "failed to complete handshake: {}", message),
-            RemoteAccessError::GameNotFound(id) => write!(f, "could not find game on server: {}", id),
-            RemoteAccessError::InvalidResponse(error) => write!(f, "server returned an invalid response: {} {}", error.status_code, error.status_message),
-            RemoteAccessError::InvalidRedirect => write!(f, "server redirect was invalid"),
-            RemoteAccessError::ManifestDownloadFailed(status, response) => write!(
+            RemoteAccessError::HandshakeFailed(message) => {
+                write!(f, "failed to complete handshake: {message}")
+            }
+            RemoteAccessError::GameNotFound(id) => write!(f, "could not find game on server: {id}"),
+            RemoteAccessError::InvalidResponse(error) => write!(
                f,
-                "failed to download game manifest: {} {}",
-                status, response
+                "server returned an invalid response: {}, {}",
+                error.status_code, error.status_message
            ),
-            RemoteAccessError::OutOfSync => write!(f, "server's and client's time are out of sync. Please ensure they are within at least 30 seconds of each other"),
-            RemoteAccessError::Generic(message) => write!(f, "{}", message),
-            RemoteAccessError::Cache(error) => write!(f, "Cache Error: {}", error),
+            RemoteAccessError::UnparseableResponse(error) => {
+                write!(f, "server returned an invalid response: {error}")
+            }
+            RemoteAccessError::ManifestDownloadFailed(status, response) => {
+                write!(f, "failed to download game manifest: {status} {response}")
+            }
+            RemoteAccessError::OutOfSync => write!(
+                f,
+                "server's and client's time are out of sync. Please ensure they are within at least 30 seconds of each other"
+            ),
+            RemoteAccessError::Cache(error) => write!(f, "Cache Error: {error}"),
        }
    }
 }
@ -70,6 +90,11 @@ impl From<reqwest::Error> for RemoteAccessError {
        RemoteAccessError::FetchError(Arc::new(err))
    }
 }
+impl From<reqwest_websocket::Error> for RemoteAccessError {
+    fn from(err: reqwest_websocket::Error) -> Self {
+        RemoteAccessError::FetchErrorWS(Arc::new(err))
+    }
+}
 impl From<ParseError> for RemoteAccessError {
    fn from(err: ParseError) -> Self {
        RemoteAccessError::ParsingError(err)
--- a/src-tauri/src/error/setup_error.rs
+++ b/src-tauri/src/error/setup_error.rs
@ -1,14 +0,0 @@
-use std::fmt::{Display, Formatter};
-
-#[derive(Debug, Clone)]
-pub enum SetupError {
-    Context,
-}
-
-impl Display for SetupError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            SetupError::Context => write!(f, "failed to generate contexts for download"),
-        }
-    }
-}
--- a/src-tauri/src/games/collections/collection.rs
+++ b/src-tauri/src/games/collections/collection.rs
@ -11,7 +11,7 @@ pub struct Collection {
    name: String,
    is_default: bool,
    user_id: String,
-    entries: Vec<CollectionObject>
+    entries: Vec<CollectionObject>,
 }

 #[derive(Serialize, Deserialize, Debug, Clone, Default)]
@ -21,4 +21,3 @@ pub struct CollectionObject {
    game_id: String,
    game: Game,
 }
-
--- a/src-tauri/src/games/collections/commands.rs
+++ b/src-tauri/src/games/collections/commands.rs
@ -1,14 +1,18 @@
-use reqwest::blocking::Client;
 use serde_json::json;
 use url::Url;

-use crate::{database::db::DatabaseImpls, error::remote_access_error::RemoteAccessError, remote::{auth::generate_authorization_header, requests::make_request}, DB};
+use crate::{
+    DB,
+    database::db::DatabaseImpls,
+    error::remote_access_error::RemoteAccessError,
+    remote::{auth::generate_authorization_header, requests::make_request, utils::DROP_CLIENT_SYNC},
+};

 use super::collection::{Collection, Collections};

 #[tauri::command]
 pub fn fetch_collections() -> Result<Collections, RemoteAccessError> {
-    let client = Client::new();
+    let client = DROP_CLIENT_SYNC.clone();
    let response = make_request(&client, &["/api/v1/client/collection"], &[], |r| {
        r.header("Authorization", generate_authorization_header())
    })?
@ -19,10 +23,13 @@ pub fn fetch_collections() -> Result<Collections, RemoteAccessError> {

 #[tauri::command]
 pub fn fetch_collection(collection_id: String) -> Result<Collection, RemoteAccessError> {
-    let client = Client::new();
-    let response = make_request(&client, &["/api/v1/client/collection/", &collection_id], &[], |r| {
-        r.header("Authorization", generate_authorization_header())
-    })?
+    let client = DROP_CLIENT_SYNC.clone();
+    let response = make_request(
+        &client,
+        &["/api/v1/client/collection/", &collection_id],
+        &[],
+        |r| r.header("Authorization", generate_authorization_header()),
+    )?
    .send()?;

    Ok(response.json()?)
@ -30,25 +37,31 @@ pub fn fetch_collection(collection_id: String) -> Result<Collection, RemoteAcces

 #[tauri::command]
 pub fn create_collection(name: String) -> Result<Collection, RemoteAccessError> {
-    let client = Client::new();
+    let client = DROP_CLIENT_SYNC.clone();
    let base_url = DB.fetch_base_url();

-    let base_url = Url::parse(&format!("{}api/v1/client/collection/", base_url))?;
-
+    let base_url = Url::parse(&format!("{base_url}api/v1/client/collection/"))?;

    let response = client
        .post(base_url)
        .header("Authorization", generate_authorization_header())
        .json(&json!({"name": name}))
        .send()?;
-    
+
    Ok(response.json()?)
 }

 #[tauri::command]
-pub fn add_game_to_collection(collection_id: String, game_id: String) -> Result<(), RemoteAccessError> {
-    let client = Client::new();
-    let url = Url::parse(&format!("{}api/v1/client/collection/{}/entry/", DB.fetch_base_url(), collection_id))?;
+pub fn add_game_to_collection(
+    collection_id: String,
+    game_id: String,
+) -> Result<(), RemoteAccessError> {
+    let client = DROP_CLIENT_SYNC.clone();
+    let url = Url::parse(&format!(
+        "{}api/v1/client/collection/{}/entry/",
+        DB.fetch_base_url(),
+        collection_id
+    ))?;

    client
        .post(url)
@ -60,8 +73,12 @@ pub fn add_game_to_collection(collection_id: String, game_id: String) -> Result<

 #[tauri::command]
 pub fn delete_collection(collection_id: String) -> Result<bool, RemoteAccessError> {
-    let client = Client::new();
-    let base_url = Url::parse(&format!("{}api/v1/client/collection/{}", DB.fetch_base_url(), collection_id))?;
+    let client = DROP_CLIENT_SYNC.clone();
+    let base_url = Url::parse(&format!(
+        "{}api/v1/client/collection/{}",
+        DB.fetch_base_url(),
+        collection_id
+    ))?;

    let response = client
        .delete(base_url)
@ -71,9 +88,16 @@ pub fn delete_collection(collection_id: String) -> Result<bool, RemoteAccessErro
    Ok(response.json()?)
 }
 #[tauri::command]
-pub fn delete_game_in_collection(collection_id: String, game_id: String) -> Result<(), RemoteAccessError> {
-    let client = Client::new();
-    let base_url = Url::parse(&format!("{}api/v1/client/collection/{}/entry", DB.fetch_base_url(), collection_id))?;
+pub fn delete_game_in_collection(
+    collection_id: String,
+    game_id: String,
+) -> Result<(), RemoteAccessError> {
+    let client = DROP_CLIENT_SYNC.clone();
+    let base_url = Url::parse(&format!(
+        "{}api/v1/client/collection/{}/entry",
+        DB.fetch_base_url(),
+        collection_id
+    ))?;

    client
        .delete(base_url)
@ -82,4 +106,4 @@ pub fn delete_game_in_collection(collection_id: String, game_id: String) -> Resu
        .send()?;

    Ok(())
-}
+}
--- a/src-tauri/src/games/collections/mod.rs
+++ b/src-tauri/src/games/collections/mod.rs
@ -1,2 +1,2 @@
+pub mod collection;
 pub mod commands;
-pub mod collection;
--- a/src-tauri/src/games/commands.rs
+++ b/src-tauri/src/games/commands.rs
@ -1,9 +1,15 @@
 use std::sync::Mutex;

-use tauri::{AppHandle, Manager};
+use tauri::AppHandle;

 use crate::{
-    database::db::GameVersion, error::{library_error::LibraryError, remote_access_error::RemoteAccessError}, games::library::{fetch_game_logic_offline, fetch_library_logic_offline, get_current_meta, uninstall_game_logic}, offline, AppState
+    database::models::data::GameVersion,
+    error::{library_error::LibraryError, remote_access_error::RemoteAccessError},
+    games::library::{
+        fetch_game_logic_offline, fetch_library_logic_offline, get_current_meta,
+        uninstall_game_logic,
+    },
+    offline, AppState,
 };

 use super::{
@ -15,16 +21,29 @@ use super::{
 };

 #[tauri::command]
-pub fn fetch_library(state: tauri::State<'_, Mutex<AppState>>) -> Result<Vec<Game>, RemoteAccessError> {
-    offline!(state, fetch_library_logic, fetch_library_logic_offline, state)
+pub fn fetch_library(
+    state: tauri::State<'_, Mutex<AppState>>,
+) -> Result<Vec<Game>, RemoteAccessError> {
+    offline!(
+        state,
+        fetch_library_logic,
+        fetch_library_logic_offline,
+        state
+    )
 }

 #[tauri::command]
 pub fn fetch_game(
    game_id: String,
-    state: tauri::State<'_, Mutex<AppState>>
+    state: tauri::State<'_, Mutex<AppState>>,
 ) -> Result<FetchGameStruct, RemoteAccessError> {
-    offline!(state, fetch_game_logic, fetch_game_logic_offline, game_id, state)
+    offline!(
+        state,
+        fetch_game_logic,
+        fetch_game_logic_offline,
+        game_id,
+        state
+    )
 }

 #[tauri::command]
--- a/src-tauri/src/games/downloads/commands.rs
+++ b/src-tauri/src/games/downloads/commands.rs
@ -1,10 +1,14 @@
-use std::sync::{Arc, Mutex};
+use std::{
+    path::PathBuf,
+    sync::{Arc, Mutex},
+};

 use crate::{
+    database::{db::borrow_db_checked, models::data::GameDownloadStatus},
    download_manager::{
-        download_manager::DownloadManagerSignal, downloadable::Downloadable,
-        internal_error::InternalError,
+        download_manager_frontend::DownloadManagerSignal, downloadable::Downloadable,
    },
+    error::download_manager_error::DownloadManagerError,
    AppState,
 };

@ -16,9 +20,9 @@ pub fn download_game(
    game_version: String,
    install_dir: usize,
    state: tauri::State<'_, Mutex<AppState>>,
-) -> Result<(), InternalError<DownloadManagerSignal>> {
+) -> Result<(), DownloadManagerError<DownloadManagerSignal>> {
    let sender = state.lock().unwrap().download_manager.get_sender();
-    let game_download_agent = Arc::new(Box::new(GameDownloadAgent::new(
+    let game_download_agent = Arc::new(Box::new(GameDownloadAgent::new_from_index(
        game_id,
        game_version,
        install_dir,
@ -30,3 +34,39 @@ pub fn download_game(
        .download_manager
        .queue_download(game_download_agent)?)
 }
+
+#[tauri::command]
+pub fn resume_download(
+    game_id: String,
+    state: tauri::State<'_, Mutex<AppState>>,
+) -> Result<(), DownloadManagerError<DownloadManagerSignal>> {
+    let s = borrow_db_checked()
+        .applications
+        .game_statuses
+        .get(&game_id)
+        .unwrap()
+        .clone();
+
+    let (version_name, install_dir) = match s {
+        GameDownloadStatus::Remote {} => unreachable!(),
+        GameDownloadStatus::SetupRequired { .. } => unreachable!(),
+        GameDownloadStatus::Installed { .. } => unreachable!(),
+        GameDownloadStatus::PartiallyInstalled {
+            version_name,
+            install_dir,
+        } => (version_name, install_dir),
+    };
+    let sender = state.lock().unwrap().download_manager.get_sender();
+    let parent_dir: PathBuf = install_dir.into();
+    let game_download_agent = Arc::new(Box::new(GameDownloadAgent::new(
+        game_id,
+        version_name.clone(),
+        parent_dir.parent().unwrap().to_path_buf(),
+        sender,
+    )) as Box<dyn Downloadable + Send + Sync>);
+    Ok(state
+        .lock()
+        .unwrap()
+        .download_manager
+        .queue_download(game_download_agent)?)
+}
--- a/src-tauri/src/games/downloads/download_agent.rs
+++ b/src-tauri/src/games/downloads/download_agent.rs
@ -1,70 +1,77 @@
 use crate::auth::generate_authorization_header;
-use crate::database::db::{
-    borrow_db_checked, ApplicationTransientStatus, DatabaseImpls,
-    GameDownloadStatus,
+use crate::database::db::{borrow_db_checked, borrow_db_mut_checked};
+use crate::database::models::data::{
+    ApplicationTransientStatus, DownloadType, DownloadableMetadata,
 };
-use crate::download_manager::download_manager::{DownloadManagerSignal, DownloadStatus};
-use crate::download_manager::download_thread_control_flag::{
+use crate::download_manager::download_manager_frontend::{DownloadManagerSignal, DownloadStatus};
+use crate::download_manager::downloadable::Downloadable;
+use crate::download_manager::util::download_thread_control_flag::{
    DownloadThreadControl, DownloadThreadControlFlag,
 };
-use crate::download_manager::downloadable::Downloadable;
-use crate::download_manager::downloadable_metadata::{DownloadType, DownloadableMetadata};
-use crate::download_manager::progress_object::{ProgressHandle, ProgressObject};
+use crate::download_manager::util::progress_object::{ProgressHandle, ProgressObject};
 use crate::error::application_download_error::ApplicationDownloadError;
 use crate::error::remote_access_error::RemoteAccessError;
 use crate::games::downloads::manifest::{DropDownloadContext, DropManifest};
-use crate::games::library::{on_game_complete, push_game_update, GameUpdateEvent};
+use crate::games::downloads::validate::game_validate_logic;
+use crate::games::library::{on_game_complete, on_game_incomplete, push_game_update};
 use crate::remote::requests::make_request;
-use crate::DB;
+use crate::remote::utils::DROP_CLIENT_SYNC;
 use log::{debug, error, info};
 use rayon::ThreadPoolBuilder;
-use slice_deque::SliceDeque;
-use std::fs::{create_dir_all, File};
-use std::path::Path;
+use std::collections::HashMap;
+use std::fs::{OpenOptions, create_dir_all};
+use std::path::{Path, PathBuf};
 use std::sync::mpsc::Sender;
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
 use tauri::{AppHandle, Emitter};
-use urlencoding::encode;

 #[cfg(target_os = "linux")]
-use rustix::fs::{fallocate, FallocateFlags};
+use rustix::fs::{FallocateFlags, fallocate};

 use super::download_logic::download_game_chunk;
-use super::stored_manifest::StoredManifest;
+use super::drop_data::DropData;

 pub struct GameDownloadAgent {
    pub id: String,
    pub version: String,
    pub control_flag: DownloadThreadControl,
    contexts: Mutex<Vec<DropDownloadContext>>,
-    completed_contexts: Mutex<SliceDeque<usize>>,
+    context_map: Mutex<HashMap<String, bool>>,
    pub manifest: Mutex<Option<DropManifest>>,
    pub progress: Arc<ProgressObject>,
    sender: Sender<DownloadManagerSignal>,
-    pub stored_manifest: StoredManifest,
+    pub stored_manifest: DropData,
    status: Mutex<DownloadStatus>,
 }

 impl GameDownloadAgent {
-    pub fn new(
+    pub fn new_from_index(
        id: String,
        version: String,
        target_download_dir: usize,
        sender: Sender<DownloadManagerSignal>,
    ) -> Self {
-        // Don't run by default
-        let control_flag = DownloadThreadControl::new(DownloadThreadControlFlag::Stop);
-
        let db_lock = borrow_db_checked();
        let base_dir = db_lock.applications.install_dirs[target_download_dir].clone();
        drop(db_lock);

+        Self::new(id, version, base_dir, sender)
+    }
+    pub fn new(
+        id: String,
+        version: String,
+        base_dir: PathBuf,
+        sender: Sender<DownloadManagerSignal>,
+    ) -> Self {
+        // Don't run by default
+        let control_flag = DownloadThreadControl::new(DownloadThreadControlFlag::Stop);
+
        let base_dir_path = Path::new(&base_dir);
        let data_base_dir_path = base_dir_path.join(id.clone());

        let stored_manifest =
-            StoredManifest::generate(id.clone(), version.clone(), data_base_dir_path.clone());
+            DropData::generate(id.clone(), version.clone(), data_base_dir_path.clone());

        Self {
            id,
@ -72,7 +79,7 @@ impl GameDownloadAgent {
            control_flag,
            manifest: Mutex::new(None),
            contexts: Mutex::new(Vec::new()),
-            completed_contexts: Mutex::new(SliceDeque::new()),
+            context_map: Mutex::new(HashMap::new()),
            progress: Arc::new(ProgressObject::new(0, 0, sender.clone())),
            sender,
            stored_manifest,
@ -109,7 +116,7 @@ impl GameDownloadAgent {
        );
        let res = self
            .run()
-            .map_err(|_| ApplicationDownloadError::DownloadError);
+            .map_err(|()| ApplicationDownloadError::DownloadError);

        debug!(
            "{} took {}ms to download",
@ -129,7 +136,7 @@ impl GameDownloadAgent {

    fn download_manifest(&self) -> Result<(), ApplicationDownloadError> {
        let header = generate_authorization_header();
-        let client = reqwest::blocking::Client::new();
+        let client = DROP_CLIENT_SYNC.clone();
        let response = make_request(
            &client,
            &["/api/v1/client/game/manifest"],
@ -177,11 +184,12 @@ impl GameDownloadAgent {
    }

    pub fn ensure_contexts(&self) -> Result<(), ApplicationDownloadError> {
-        if !self.contexts.lock().unwrap().is_empty() {
-            return Ok(());
+        if self.contexts.lock().unwrap().is_empty() {
+            self.generate_contexts()?;
        }

-        self.generate_contexts()?;
+        *self.context_map.lock().unwrap() = self.stored_manifest.get_contexts();
+
        Ok(())
    }

@ -193,20 +201,19 @@ impl GameDownloadAgent {
        let base_path = Path::new(&self.stored_manifest.base_path);
        create_dir_all(base_path).unwrap();

-        {
-            let mut completed_contexts_lock = self.completed_contexts.lock().unwrap();
-            completed_contexts_lock.clear();
-            completed_contexts_lock
-                .extend_from_slice(&self.stored_manifest.get_completed_contexts());
-        }
-
        for (raw_path, chunk) in manifest {
            let path = base_path.join(Path::new(&raw_path));

            let container = path.parent().unwrap();
            create_dir_all(container).unwrap();

-            let file = File::create(path.clone()).unwrap();
+            let file = OpenOptions::new()
+                .read(true)
+                .write(true)
+                .truncate(true)
+                .create(true)
+                .open(path.clone())
+                .unwrap();
            let mut running_offset = 0;

            for (index, length) in chunk.lengths.iter().enumerate() {
@ -229,6 +236,14 @@ impl GameDownloadAgent {
                let _ = fallocate(file, FallocateFlags::empty(), 0, running_offset);
            }
        }
+        let existing_contexts = self.stored_manifest.get_completed_contexts();
+        self.stored_manifest.set_contexts(
+            &contexts
+                .iter()
+                .map(|x| (x.checksum.clone(), existing_contexts.contains(&x.checksum)))
+                .collect::<Vec<(String, bool)>>(),
+        );
+
        *self.contexts.lock().unwrap() = contexts;

        Ok(())
@ -247,13 +262,14 @@ impl GameDownloadAgent {
            .build()
            .unwrap();

-        let completed_indexes = Arc::new(boxcar::Vec::new());
-        let completed_indexes_loop_arc = completed_indexes.clone();
+        let completed_contexts = Arc::new(boxcar::Vec::new());
+        let completed_indexes_loop_arc = completed_contexts.clone();

        let contexts = self.contexts.lock().unwrap();
-        debug!("{:#?}", contexts);
+        debug!("{contexts:#?}");
        pool.scope(|scope| {
-            let client = &reqwest::blocking::Client::new();
+            let client = &DROP_CLIENT_SYNC.clone();
+            let context_map = self.context_map.lock().unwrap();
            for (index, context) in contexts.iter().enumerate() {
                let client = client.clone();
                let completed_indexes = completed_indexes_loop_arc.clone();
@ -262,7 +278,7 @@ impl GameDownloadAgent {
                let progress_handle = ProgressHandle::new(progress, self.progress.clone());

                // If we've done this one already, skip it
-                if self.completed_contexts.lock().unwrap().contains(&index) {
+                if Some(&true) == context_map.get(&context.checksum) {
                    progress_handle.skip(context.length);
                    continue;
                }
@ -278,7 +294,7 @@ impl GameDownloadAgent {
                        ("name", &context.file_name),
                        ("chunk", &context.index.to_string()),
                    ],
-                    |r| r.header("Authorization", generate_authorization_header()),
+                    |r| r,
                ) {
                    Ok(request) => request,
                    Err(e) => {
@ -294,13 +310,12 @@ impl GameDownloadAgent {
                scope.spawn(move |_| {
                    match download_game_chunk(context, &self.control_flag, progress_handle, request)
                    {
-                        Ok(res) => {
-                            if res {
-                                completed_indexes.push(index);
-                            }
+                        Ok(true) => {
+                            completed_indexes.push(context.checksum.clone());
                        }
+                        Ok(false) => {}
                        Err(e) => {
-                            error!("{}", e);
+                            error!("{e}");
                            sender.send(DownloadManagerSignal::Error(e)).unwrap();
                        }
                    }
@ -308,36 +323,42 @@ impl GameDownloadAgent {
            }
        });

-        let newly_completed = completed_indexes.to_owned();
+        let newly_completed = completed_contexts.clone();

        let completed_lock_len = {
-            let mut completed_contexts_lock = self.completed_contexts.lock().unwrap();
+            let mut context_map_lock = self.context_map.lock().unwrap();
            for (_, item) in newly_completed.iter() {
-                completed_contexts_lock.push_front(*item);
+                context_map_lock.insert(item.clone(), true);
            }

-            completed_contexts_lock.len()
+            context_map_lock.values().filter(|x| **x).count()
        };
+        let context_map_lock = self.context_map.lock().unwrap();
+        let contexts = contexts
+            .iter()
+            .map(|x| {
+                (
+                    x.checksum.clone(),
+                    context_map_lock.get(&x.checksum).copied().unwrap_or(false),
+                )
+            })
+            .collect::<Vec<(String, bool)>>();
+        drop(context_map_lock);

-        // If we're not out of contexts, we're not done, so we don't fire completed
-        if completed_lock_len != contexts.len() {
+        self.stored_manifest.set_contexts(&contexts);
+        self.stored_manifest.write();
+
+        // If there are any contexts left which are false
+        if !contexts.iter().all(|x| x.1) {
            info!(
                "download agent for {} exited without completing ({}/{})",
                self.id.clone(),
                completed_lock_len,
                contexts.len(),
            );
-            self.stored_manifest
-                .set_completed_contexts(self.completed_contexts.lock().unwrap().as_slice());
-            self.stored_manifest.write();
            return Ok(false);
        }

-        // We've completed
-        self.sender
-            .send(DownloadManagerSignal::Completed(self.metadata()))
-            .unwrap();
-
        Ok(true)
    }
 }
@ -374,10 +395,13 @@ impl Downloadable for GameDownloadAgent {
            .emit("download_error", error.to_string())
            .unwrap();

-        error!("error while managing download: {}", error);
+        error!("error while managing download: {error}");

-        let mut handle = DB.borrow_data_mut().unwrap();
-        handle.applications.transient_statuses.remove(&self.metadata());
+        let mut handle = borrow_db_mut_checked();
+        handle
+            .applications
+            .transient_statuses
+            .remove(&self.metadata());
    }

    fn on_complete(&self, app_handle: &tauri::AppHandle) {
@ -391,18 +415,13 @@ impl Downloadable for GameDownloadAgent {

    // TODO: fix this function. It doesn't restart the download properly, nor does it reset the state properly
    fn on_incomplete(&self, app_handle: &tauri::AppHandle) {
-        let meta = self.metadata();
-        *self.status.lock().unwrap() = DownloadStatus::Queued;
-        app_handle
-            .emit(
-                &format!("update_game/{}", meta.id),
-                GameUpdateEvent {
-                    game_id: meta.id.clone(),
-                    status: (Some(GameDownloadStatus::Remote {}), None),
-                    version: None,
-                },
-            )
-            .unwrap();
+        on_game_incomplete(
+            &self.metadata(),
+            self.stored_manifest.base_path.to_string_lossy().to_string(),
+            app_handle,
+        )
+        .unwrap();
+        println!("Attempting to redownload");
    }

    fn on_cancelled(&self, _app_handle: &tauri::AppHandle) {}
@ -410,4 +429,15 @@ impl Downloadable for GameDownloadAgent {
    fn status(&self) -> DownloadStatus {
        self.status.lock().unwrap().clone()
    }
+
+    fn validate(&self) -> Result<bool, ApplicationDownloadError> {
+        *self.status.lock().unwrap() = DownloadStatus::Validating;
+        game_validate_logic(
+            &self.stored_manifest,
+            self.contexts.lock().unwrap().clone(),
+            self.progress.clone(),
+            self.sender.clone(),
+            &self.control_flag,
+        )
+    }
 }
--- a/src-tauri/src/games/downloads/download_logic.rs
+++ b/src-tauri/src/games/downloads/download_logic.rs
@ -1,16 +1,18 @@
-use crate::download_manager::download_thread_control_flag::{
+use crate::download_manager::util::download_thread_control_flag::{
    DownloadThreadControl, DownloadThreadControlFlag,
 };
-use crate::download_manager::progress_object::ProgressHandle;
+use crate::download_manager::util::progress_object::ProgressHandle;
 use crate::error::application_download_error::ApplicationDownloadError;
+use crate::error::drop_server_error::DropServerError;
 use crate::error::remote_access_error::RemoteAccessError;
 use crate::games::downloads::manifest::DropDownloadContext;
-use log::warn;
+use crate::remote::auth::generate_authorization_header;
+use log::{debug, warn};
 use md5::{Context, Digest};
 use reqwest::blocking::{RequestBuilder, Response};

 use std::fs::{set_permissions, Permissions};
-use std::io::{ErrorKind, Read};
+use std::io::Read;
 #[cfg(unix)]
 use std::os::unix::fs::PermissionsExt;
 use std::{
@ -25,8 +27,9 @@ pub struct DropWriter<W: Write> {
 }
 impl DropWriter<File> {
    fn new(path: PathBuf) -> Self {
+        let destination = OpenOptions::new().write(true).create(true).truncate(false).open(&path).unwrap();
        Self {
-            destination: OpenOptions::new().write(true).open(path).unwrap(),
+            destination,
            hasher: Context::new(),
        }
    }
@ -39,12 +42,9 @@ impl DropWriter<File> {
 // Write automatically pushes to file and hasher
 impl Write for DropWriter<File> {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.hasher.write_all(buf).map_err(|e| {
-            io::Error::new(
-                ErrorKind::Other,
-                format!("Unable to write to hasher: {}", e),
-            )
-        })?;
+        self.hasher
+            .write_all(buf)
+            .map_err(|e| io::Error::other(format!("Unable to write to hasher: {e}")))?;
        self.destination.write(buf)
    }

@ -92,19 +92,32 @@ impl<'a> DropDownloadPipeline<'a, Response, File> {
        let mut current_size = 0;
        loop {
            if self.control_flag.get() == DownloadThreadControlFlag::Stop {
+                buf_writer.flush()?;
                return Ok(false);
            }

-            let bytes_read = self.source.read(&mut copy_buf)?;
+            let mut bytes_read = self.source.read(&mut copy_buf)?;
            current_size += bytes_read;

+            if current_size > self.size {
+                let over = current_size - self.size;
+                warn!("server sent too many bytes... {over} over");
+                bytes_read -= over;
+                current_size = self.size;
+            }
+
            buf_writer.write_all(&copy_buf[0..bytes_read])?;
            self.progress.add(bytes_read);

-            if current_size == self.size {
+            if current_size >= self.size {
+                debug!(
+                    "finished with final size of {} vs {}",
+                    current_size, self.size
+                );
                break;
            }
        }
+        buf_writer.flush()?;

        Ok(true)
    }
@ -126,15 +139,21 @@ pub fn download_game_chunk(
        progress.set(0);
        return Ok(false);
    }
-
    let response = request
+        .header("Authorization", generate_authorization_header())
        .send()
        .map_err(|e| ApplicationDownloadError::Communication(e.into()))?;

    if response.status() != 200 {
-        let err = response.json().unwrap();
+        debug!("chunk request got status code: {}", response.status());
+        let raw_res = response.text().unwrap();
+        if let Ok(err) = serde_json::from_str::<DropServerError>(&raw_res) {
+            return Err(ApplicationDownloadError::Communication(
+                RemoteAccessError::InvalidResponse(err),
+            ));
+        }
        return Err(ApplicationDownloadError::Communication(
-            RemoteAccessError::InvalidResponse(err),
+            RemoteAccessError::UnparseableResponse(raw_res),
        ));
    }

@ -154,20 +173,21 @@ pub fn download_game_chunk(
        ));
    }

-    let mut pipeline = DropDownloadPipeline::new(
-        response,
-        destination,
-        control_flag,
-        progress,
-        content_length.unwrap().try_into().unwrap(),
-    );
+    let length = content_length.unwrap().try_into().unwrap();
+
+    if length != ctx.length {
+        return Err(ApplicationDownloadError::DownloadError);
+    }
+
+    let mut pipeline =
+        DropDownloadPipeline::new(response, destination, control_flag, progress, length);

    let completed = pipeline
        .copy()
        .map_err(|e| ApplicationDownloadError::IoError(e.kind()))?;
    if !completed {
        return Ok(false);
-    };
+    }

    // If we complete the file, set the permissions (if on Linux)
    #[cfg(unix)]
@ -185,5 +205,10 @@ pub fn download_game_chunk(
        return Err(ApplicationDownloadError::Checksum);
    }

+    debug!(
+        "Successfully finished download #{}, copied {} bytes",
+        ctx.checksum, length
+    );
+
    Ok(true)
 }
--- a/src-tauri/src/games/downloads/drop_data.rs
+++ b/src-tauri/src/games/downloads/drop_data.rs
@ -0,0 +1,103 @@
+use std::{
+    collections::HashMap, fs::File, io::{Read, Write}, path::PathBuf
+};
+
+use log::{debug, error, info, warn};
+use native_model::{Decode, Encode};
+
+pub type DropData = v1::DropData;
+
+static DROP_DATA_PATH: &str = ".dropdata";
+
+pub mod v1 {
+    use std::{collections::HashMap, path::PathBuf, sync::Mutex};
+
+    use native_model::native_model;
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Serialize, Deserialize, Debug)]
+    #[native_model(id = 9, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
+    pub struct DropData {
+        pub game_id: String,
+        pub game_version: String,
+        pub contexts: Mutex<HashMap<String, bool>>,
+        pub base_path: PathBuf,
+    }
+
+    impl DropData {
+        pub fn new(game_id: String, game_version: String, base_path: PathBuf) -> Self {
+            Self {
+                base_path,
+                game_id,
+                game_version,
+                contexts: Mutex::new(HashMap::new()),
+            }
+        }
+    }
+}
+
+impl DropData {
+    pub fn generate(game_id: String, game_version: String, base_path: PathBuf) -> Self {
+        let mut file = if let Ok(file) = File::open(base_path.join(DROP_DATA_PATH)) { file } else {
+            debug!("Generating new dropdata for game {game_id}");
+            return DropData::new(game_id, game_version, base_path);
+        };
+
+        let mut s = Vec::new();
+        match file.read_to_end(&mut s) {
+            Ok(_) => {}
+            Err(e) => {
+                error!("{e}");
+                return DropData::new(game_id, game_version, base_path);
+            }
+        }
+
+        match native_model::rmp_serde_1_3::RmpSerde::decode(s) {
+            Ok(manifest) => manifest,
+            Err(e) => {
+                warn!("{e}");
+                DropData::new(game_id, game_version, base_path)
+            }
+        }
+    }
+    pub fn write(&self) {
+        let manifest_raw = match native_model::rmp_serde_1_3::RmpSerde::encode(&self) {
+            Ok(data) => data,
+            Err(_) => return,
+        };
+
+        let mut file = match File::create(self.base_path.join(DROP_DATA_PATH)) {
+            Ok(file) => file,
+            Err(e) => {
+                error!("{e}");
+                return;
+            }
+        };
+
+        match file.write_all(&manifest_raw) {
+            Ok(()) => {}
+            Err(e) => error!("{e}"),
+        }
+    }
+    pub fn set_contexts(&self, completed_contexts: &[(String, bool)]) {
+        *self.contexts.lock().unwrap() = completed_contexts.iter().map(|s| (s.0.clone(), s.1)).collect();
+    }
+    pub fn set_context(&self, context: String, state: bool) {
+        self.contexts.lock().unwrap().entry(context).insert_entry(state);
+    }
+    pub fn get_completed_contexts(&self) -> Vec<String> {
+        self.contexts
+            .lock()
+            .unwrap()
+            .iter()
+            .filter_map(|x| if *x.1 { Some(x.0.clone()) } else { None })
+            .collect()
+    }
+    pub fn get_contexts(&self) -> HashMap<String, bool> {
+        info!(
+            "Any contexts which are complete? {}",
+            self.contexts.lock().unwrap().iter().any(|x| *x.1)
+        );
+        self.contexts.lock().unwrap().clone()
+    }
+}
--- a/src-tauri/src/games/downloads/mod.rs
+++ b/src-tauri/src/games/downloads/mod.rs
@ -1,5 +1,6 @@
 pub mod commands;
 pub mod download_agent;
 mod download_logic;
+mod drop_data;
 mod manifest;
-mod stored_manifest;
+pub mod validate;
--- a/src-tauri/src/games/downloads/stored_manifest.rs
+++ b/src-tauri/src/games/downloads/stored_manifest.rs
@ -1,79 +0,0 @@
-use std::{
-    fs::File,
-    io::{Read, Write},
-    path::PathBuf,
-    sync::Mutex,
-};
-
-use log::{error, warn};
-use serde::{Deserialize, Serialize};
-use serde_binary::binary_stream::Endian;
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct StoredManifest {
-    game_id: String,
-    game_version: String,
-    pub completed_contexts: Mutex<Vec<usize>>,
-    pub base_path: PathBuf,
-}
-
-static DROP_DATA_PATH: &str = ".dropdata";
-
-impl StoredManifest {
-    pub fn new(game_id: String, game_version: String, base_path: PathBuf) -> Self {
-        Self {
-            base_path,
-            game_id,
-            game_version,
-            completed_contexts: Mutex::new(Vec::new()),
-        }
-    }
-    pub fn generate(game_id: String, game_version: String, base_path: PathBuf) -> Self {
-        let mut file = match File::open(base_path.join(DROP_DATA_PATH)) {
-            Ok(file) => file,
-            Err(_) => return StoredManifest::new(game_id, game_version, base_path),
-        };
-
-        let mut s = Vec::new();
-        match file.read_to_end(&mut s) {
-            Ok(_) => {}
-            Err(e) => {
-                error!("{}", e);
-                return StoredManifest::new(game_id, game_version, base_path);
-            }
-        };
-
-        match serde_binary::from_vec::<StoredManifest>(s, Endian::Little) {
-            Ok(manifest) => manifest,
-            Err(e) => {
-                warn!("{}", e);
-                StoredManifest::new(game_id, game_version, base_path)
-            }
-        }
-    }
-    pub fn write(&self) {
-        let manifest_raw = match serde_binary::to_vec(&self, Endian::Little) {
-            Ok(json) => json,
-            Err(_) => return,
-        };
-
-        let mut file = match File::create(self.base_path.join(DROP_DATA_PATH)) {
-            Ok(file) => file,
-            Err(e) => {
-                error!("{}", e);
-                return;
-            }
-        };
-
-        match file.write_all(&manifest_raw) {
-            Ok(_) => {}
-            Err(e) => error!("{}", e),
-        };
-    }
-    pub fn set_completed_contexts(&self, completed_contexts: &[usize]) {
-        *self.completed_contexts.lock().unwrap() = completed_contexts.to_owned();
-    }
-    pub fn get_completed_contexts(&self) -> Vec<usize> {
-        self.completed_contexts.lock().unwrap().clone()
-    }
-}
--- a/src-tauri/src/games/downloads/validate.rs
+++ b/src-tauri/src/games/downloads/validate.rs
@ -0,0 +1,185 @@
+use std::{
+    fs::File,
+    io::{self, BufWriter, Read, Seek, SeekFrom, Write},
+    sync::{Arc, mpsc::Sender},
+};
+
+use log::{debug, error, info};
+use md5::Context;
+use rayon::ThreadPoolBuilder;
+
+use crate::{
+    database::db::borrow_db_checked,
+    download_manager::{
+        download_manager_frontend::DownloadManagerSignal,
+        util::{
+            download_thread_control_flag::{DownloadThreadControl, DownloadThreadControlFlag},
+            progress_object::{ProgressHandle, ProgressObject},
+        },
+    },
+    error::application_download_error::ApplicationDownloadError,
+    games::downloads::{drop_data::DropData, manifest::DropDownloadContext},
+};
+
+pub fn game_validate_logic(
+    dropdata: &DropData,
+    contexts: Vec<DropDownloadContext>,
+    progress: Arc<ProgressObject>,
+    sender: Sender<DownloadManagerSignal>,
+    control_flag: &DownloadThreadControl,
+) -> Result<bool, ApplicationDownloadError> {
+    progress.reset(contexts.len());
+    let max_download_threads = borrow_db_checked().settings.max_download_threads;
+
+    debug!(
+        "validating game: {} with {} threads",
+        dropdata.game_id, max_download_threads
+    );
+    let pool = ThreadPoolBuilder::new()
+        .num_threads(max_download_threads)
+        .build()
+        .unwrap();
+
+    debug!("{contexts:#?}");
+    let invalid_chunks = Arc::new(boxcar::Vec::new());
+    pool.scope(|scope| {
+        for (index, context) in contexts.iter().enumerate() {
+            let current_progress = progress.get(index);
+            let progress_handle = ProgressHandle::new(current_progress, progress.clone());
+            let invalid_chunks_scoped = invalid_chunks.clone();
+            let sender = sender.clone();
+
+            scope.spawn(move |_| {
+                match validate_game_chunk(context, control_flag, progress_handle) {
+                    Ok(true) => {
+                        debug!(
+                            "Finished context #{} with checksum {}",
+                            index, context.checksum
+                        );
+                    }
+                    Ok(false) => {
+                        debug!(
+                            "Didn't finish context #{} with checksum {}",
+                            index, &context.checksum
+                        );
+                        invalid_chunks_scoped.push(context.checksum.clone());
+                    }
+                    Err(e) => {
+                        error!("{e}");
+                        sender.send(DownloadManagerSignal::Error(e)).unwrap();
+                    }
+                }
+            });
+        }
+    });
+
+
+    // If there are any contexts left which are false
+    if !invalid_chunks.is_empty() {
+        info!(
+            "validation of game id {} failed for chunks {:?}",
+            dropdata.game_id.clone(),
+            invalid_chunks
+        );
+
+        for context in invalid_chunks.iter() {
+            dropdata.set_context(context.1.clone(), false);
+        }
+
+        dropdata.write();
+
+        return Ok(false);
+    }
+
+    Ok(true)
+}
+
+pub fn validate_game_chunk(
+    ctx: &DropDownloadContext,
+    control_flag: &DownloadThreadControl,
+    progress: ProgressHandle,
+) -> Result<bool, ApplicationDownloadError> {
+    debug!(
+        "Starting chunk validation {}, {}, {} #{}",
+        ctx.file_name, ctx.index, ctx.offset, ctx.checksum
+    );
+    // If we're paused
+    if control_flag.get() == DownloadThreadControlFlag::Stop {
+        progress.set(0);
+        return Ok(false);
+    }
+
+    let Ok(mut source) = File::open(&ctx.path) else {
+        return Ok(false);
+    };
+
+    if ctx.offset != 0 {
+        source
+            .seek(SeekFrom::Start(ctx.offset))
+            .expect("Failed to seek to file offset");
+    }
+
+    let mut hasher = md5::Context::new();
+
+    let completed =
+        validate_copy(&mut source, &mut hasher, ctx.length, control_flag, progress).unwrap();
+    if !completed {
+        return Ok(false);
+    }
+
+    let res = hex::encode(hasher.compute().0);
+    if res != ctx.checksum {
+        println!(
+            "Checksum failed. Correct: {}, actual: {}",
+            &ctx.checksum, &res
+        );
+        return Ok(false);
+    }
+
+    debug!(
+        "Successfully finished verification #{}, copied {} bytes",
+        ctx.checksum, ctx.length
+    );
+
+    Ok(true)
+}
+
+fn validate_copy(
+    source: &mut File,
+    dest: &mut Context,
+    size: usize,
+    control_flag: &DownloadThreadControl,
+    progress: ProgressHandle,
+) -> Result<bool, io::Error> {
+    let copy_buf_size = 512;
+    let mut copy_buf = vec![0; copy_buf_size];
+    let mut buf_writer = BufWriter::with_capacity(1024 * 1024, dest);
+    let mut total_bytes = 0;
+
+    loop {
+        if control_flag.get() == DownloadThreadControlFlag::Stop {
+            buf_writer.flush()?;
+            return Ok(false);
+        }
+
+        let mut bytes_read = source.read(&mut copy_buf)?;
+        total_bytes += bytes_read;
+
+        // If we read over (likely), truncate our read to
+        // the right size
+        if total_bytes > size {
+            let over = total_bytes - size;
+            bytes_read -= over;
+            total_bytes = size;
+        }
+
+        buf_writer.write_all(&copy_buf[0..bytes_read])?;
+        progress.add(bytes_read);
+
+        if total_bytes >= size {
+            break;
+        }
+    }
+    buf_writer.flush()?;
+    Ok(true)
+}
--- a/src-tauri/src/games/library.rs
+++ b/src-tauri/src/games/library.rs
@ -2,31 +2,34 @@ use std::fs::remove_dir_all;
 use std::sync::Mutex;
 use std::thread::spawn;

-use log::{debug, error, info, warn};
+use log::{debug, error, warn};
 use serde::{Deserialize, Serialize};
+use tauri::AppHandle;
 use tauri::Emitter;
-use tauri::{AppHandle, Manager};

-use crate::database::db::{borrow_db_checked, borrow_db_mut_checked, save_db, GameVersion};
-use crate::database::db::{ApplicationTransientStatus, GameDownloadStatus};
-use crate::download_manager::download_manager::DownloadStatus;
-use crate::download_manager::downloadable_metadata::DownloadableMetadata;
+use crate::database::db::{borrow_db_checked, borrow_db_mut_checked};
+use crate::database::models::data::{
+    ApplicationTransientStatus, DownloadableMetadata, GameDownloadStatus, GameVersion,
+};
+use crate::download_manager::download_manager_frontend::DownloadStatus;
 use crate::error::library_error::LibraryError;
 use crate::error::remote_access_error::RemoteAccessError;
 use crate::games::state::{GameStatusManager, GameStatusWithTransient};
 use crate::remote::auth::generate_authorization_header;
 use crate::remote::cache::{cache_object, get_cached_object, get_cached_object_db};
 use crate::remote::requests::make_request;
-use crate::{AppState, DB};
+use crate::remote::utils::DROP_CLIENT_SYNC;
+use crate::AppState;
+use bitcode::{Encode, Decode};

-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct FetchGameStruct {
    game: Game,
    status: GameStatusWithTransient,
    version: Option<GameVersion>,
 }

-#[derive(Serialize, Deserialize, Clone, Debug, Default)]
+#[derive(Serialize, Deserialize, Clone, Debug, Default, Encode, Decode)]
 #[serde(rename_all = "camelCase")]
 pub struct Game {
    id: String,
@ -35,11 +38,11 @@ pub struct Game {
    m_description: String,
    // mDevelopers
    // mPublishers
-    m_icon_id: String,
-    m_banner_id: String,
-    m_cover_id: String,
-    m_image_library: Vec<String>,
-    m_image_carousel: Vec<String>,
+    m_icon_object_id: String,
+    m_banner_object_id: String,
+    m_cover_object_id: String,
+    m_image_library_object_ids: Vec<String>,
+    m_image_carousel_object_ids: Vec<String>,
 }
 #[derive(serde::Serialize, Clone)]
 pub struct GameUpdateEvent {
@ -76,7 +79,7 @@ pub fn fetch_library_logic(
 ) -> Result<Vec<Game>, RemoteAccessError> {
    let header = generate_authorization_header();

-    let client = reqwest::blocking::Client::new();
+    let client = DROP_CLIENT_SYNC.clone();
    let response = make_request(&client, &["/api/v1/client/user/library"], &[], |f| {
        f.header("Authorization", header)
    })?
@ -84,7 +87,7 @@ pub fn fetch_library_logic(

    if response.status() != 200 {
        let err = response.json().unwrap();
-        warn!("{:?}", err);
+        warn!("{err:?}");
        return Err(RemoteAccessError::InvalidResponse(err));
    }

@ -94,7 +97,7 @@ pub fn fetch_library_logic(

    let mut db_handle = borrow_db_mut_checked();

-    for game in games.iter() {
+    for game in &games {
        handle.games.insert(game.id.clone(), game.clone());
        if !db_handle.applications.game_statuses.contains_key(&game.id) {
            db_handle
@ -105,13 +108,13 @@ pub fn fetch_library_logic(
    }

    // Add games that are installed but no longer in library
-    for (_, meta) in &db_handle.applications.installed_game_version {
-        if games.iter().find(|e| e.id == meta.id).is_some() {
+    for meta in db_handle.applications.installed_game_version.values() {
+        if games.iter().any(|e| e.id == meta.id) {
            continue;
        }
        // We should always have a cache of the object
        // Pass db_handle because otherwise we get a gridlock
-        let game = get_cached_object_db::<String, Game>(meta.id.clone(), &db_handle)?;
+        let game = get_cached_object_db::<Game>(&meta.id.clone(), &db_handle)?;
        games.push(game);
    }

@ -143,7 +146,7 @@ pub fn fetch_game_logic(
 ) -> Result<FetchGameStruct, RemoteAccessError> {
    let mut state_handle = state.lock().unwrap();

-    let handle = DB.borrow_data().unwrap();
+    let handle = borrow_db_checked();

    let metadata_option = handle.applications.installed_game_version.get(&id);
    let version = match metadata_option {
@ -171,11 +174,11 @@ pub fn fetch_game_logic(
            version,
        };

-        cache_object(id, game)?;
+        cache_object(&id, game)?;

        return Ok(data);
    }
-    let client = reqwest::blocking::Client::new();
+    let client = DROP_CLIENT_SYNC.clone();
    let response = make_request(&client, &["/api/v1/client/game/", &id], &[], |r| {
        r.header("Authorization", generate_authorization_header())
    })?
@ -186,7 +189,7 @@ pub fn fetch_game_logic(
    }
    if response.status() != 200 {
        let err = response.json().unwrap();
-        warn!("{:?}", err);
+        warn!("{err:?}");
        return Err(RemoteAccessError::InvalidResponse(err));
    }

@ -210,7 +213,7 @@ pub fn fetch_game_logic(
        version,
    };

-    cache_object(id, &game)?;
+    cache_object(&id, &game)?;

    Ok(data)
 }
@ -219,7 +222,7 @@ pub fn fetch_game_logic_offline(
    id: String,
    _state: tauri::State<'_, Mutex<AppState>>,
 ) -> Result<FetchGameStruct, RemoteAccessError> {
-    let handle = DB.borrow_data().unwrap();
+    let handle = borrow_db_checked();
    let metadata_option = handle.applications.installed_game_version.get(&id);
    let version = match metadata_option {
        None => None,
@ -237,7 +240,7 @@ pub fn fetch_game_logic_offline(
    drop(handle);

    let status = GameStatusManager::fetch_state(&id);
-    let game = get_cached_object::<String, Game>(id)?;
+    let game = get_cached_object::<Game>(&id)?;

    Ok(FetchGameStruct {
        game,
@ -250,7 +253,7 @@ pub fn fetch_game_verion_options_logic(
    game_id: String,
    state: tauri::State<'_, Mutex<AppState>>,
 ) -> Result<Vec<GameVersion>, RemoteAccessError> {
-    let client = reqwest::blocking::Client::new();
+    let client = DROP_CLIENT_SYNC.clone();

    let response = make_request(
        &client,
@ -262,7 +265,7 @@ pub fn fetch_game_verion_options_logic(

    if response.status() != 200 {
        let err = response.json().unwrap();
-        warn!("{:?}", err);
+        warn!("{err:?}");
        return Err(RemoteAccessError::InvalidResponse(err));
    }

@ -312,6 +315,10 @@ pub fn uninstall_game_logic(meta: DownloadableMetadata, app_handle: &AppHandle)
            version_name,
            install_dir,
        } => Some((version_name, install_dir)),
+        GameDownloadStatus::PartiallyInstalled {
+            version_name,
+            install_dir,
+        } => Some((version_name, install_dir)),
        _ => None,
    } {
        db_handle
@ -323,36 +330,34 @@ pub fn uninstall_game_logic(meta: DownloadableMetadata, app_handle: &AppHandle)
        drop(db_handle);

        let app_handle = app_handle.clone();
-        spawn(move || match remove_dir_all(install_dir) {
-            Err(e) => {
-                error!("{}", e);
-            }
-            Ok(_) => {
-                let mut db_handle = borrow_db_mut_checked();
-                db_handle.applications.transient_statuses.remove(&meta);
-                db_handle
-                    .applications
-                    .installed_game_version
-                    .remove(&meta.id);
-                db_handle
-                    .applications
-                    .game_statuses
-                    .entry(meta.id.clone())
-                    .and_modify(|e| *e = GameDownloadStatus::Remote {});
-                drop(db_handle);
-                save_db();
+        spawn(move || if let Err(e) = remove_dir_all(install_dir) {
+            error!("{e}");
+        } else {
+            let mut db_handle = borrow_db_mut_checked();
+            db_handle.applications.transient_statuses.remove(&meta);
+            db_handle
+                .applications
+                .installed_game_version
+                .remove(&meta.id);
+            db_handle
+                .applications
+                .game_statuses
+                .entry(meta.id.clone())
+                .and_modify(|e| *e = GameDownloadStatus::Remote {});
+            drop(db_handle);

-                debug!("uninstalled game id {}", &meta.id);
-                app_handle.emit("update_library", {}).unwrap();
+            debug!("uninstalled game id {}", &meta.id);
+            app_handle.emit("update_library", ()).unwrap();

-                push_game_update(
-                    &app_handle,
-                    &meta.id,
-                    None,
-                    (Some(GameDownloadStatus::Remote {}), None),
-                );
-            }
+            push_game_update(
+                &app_handle,
+                &meta.id,
+                None,
+                (Some(GameDownloadStatus::Remote {}), None),
+            );
        });
+    } else {
+        warn!("invalid previous state for uninstall, failing silently.");
    }
 }

@ -364,6 +369,66 @@ pub fn get_current_meta(game_id: &String) -> Option<DownloadableMetadata> {
        .cloned()
 }

+pub fn on_game_incomplete(
+    meta: &DownloadableMetadata,
+    install_dir: String,
+    app_handle: &AppHandle,
+) -> Result<(), RemoteAccessError> {
+    // Fetch game version information from remote
+    if meta.version.is_none() {
+        return Err(RemoteAccessError::GameNotFound(meta.id.clone()));
+    }
+
+    let client = DROP_CLIENT_SYNC.clone();
+    let response = make_request(
+        &client,
+        &["/api/v1/client/game/version"],
+        &[
+            ("id", &meta.id),
+            ("version", meta.version.as_ref().unwrap()),
+        ],
+        |f| f.header("Authorization", generate_authorization_header()),
+    )?
+    .send()?;
+
+    let game_version: GameVersion = response.json()?;
+
+    let mut handle = borrow_db_mut_checked();
+    handle
+        .applications
+        .game_versions
+        .entry(meta.id.clone())
+        .or_default()
+        .insert(meta.version.clone().unwrap(), game_version.clone());
+    handle
+        .applications
+        .installed_game_version
+        .insert(meta.id.clone(), meta.clone());
+
+    let status = GameDownloadStatus::PartiallyInstalled {
+        version_name: meta.version.clone().unwrap(),
+        install_dir,
+    };
+
+    handle
+        .applications
+        .game_statuses
+        .insert(meta.id.clone(), status.clone());
+    drop(handle);
+    app_handle
+        .emit(
+            &format!("update_game/{}", meta.id),
+            GameUpdateEvent {
+                game_id: meta.id.clone(),
+                status: (Some(status), None),
+                version: Some(game_version),
+            },
+        )
+        .unwrap();
+
+    Ok(())
+}
+
 pub fn on_game_complete(
    meta: &DownloadableMetadata,
    install_dir: String,
@ -376,7 +441,7 @@ pub fn on_game_complete(

    let header = generate_authorization_header();

-    let client = reqwest::blocking::Client::new();
+    let client = DROP_CLIENT_SYNC.clone();
    let response = make_request(
        &client,
        &["/api/v1/client/game/version"],
@ -403,7 +468,6 @@ pub fn on_game_complete(
        .insert(meta.id.clone(), meta.clone());

    drop(handle);
-    save_db();

    let status = if game_version.setup_command.is_empty() {
        GameDownloadStatus::Installed {
@ -423,7 +487,6 @@ pub fn on_game_complete(
        .game_statuses
        .insert(meta.id.clone(), status.clone());
    drop(db_handle);
-    save_db();
    app_handle
        .emit(
            &format!("update_game/{}", meta.id),
@ -438,10 +501,15 @@ pub fn on_game_complete(
    Ok(())
 }

-pub fn push_game_update(app_handle: &AppHandle, game_id: &String, version: Option<GameVersion>, status: GameStatusWithTransient) {
+pub fn push_game_update(
+    app_handle: &AppHandle,
+    game_id: &String,
+    version: Option<GameVersion>,
+    status: GameStatusWithTransient,
+) {
    app_handle
        .emit(
-            &format!("update_game/{}", game_id),
+            &format!("update_game/{game_id}"),
            GameUpdateEvent {
                game_id: game_id.clone(),
                status,
@ -462,7 +530,7 @@ pub fn update_game_configuration(
    game_id: String,
    options: FrontendGameOptions,
 ) -> Result<(), LibraryError> {
-    let mut handle = DB.borrow_data_mut().unwrap();
+    let mut handle = borrow_db_mut_checked();
    let installed_version = handle
        .applications
        .installed_game_version
@ -493,8 +561,5 @@ pub fn update_game_configuration(
        .unwrap()
        .insert(version.to_string(), existing_configuration);

-    drop(handle);
-    save_db();
-
    Ok(())
 }
--- a/src-tauri/src/games/mod.rs
+++ b/src-tauri/src/games/mod.rs
@ -1,5 +1,5 @@
+pub mod collections;
 pub mod commands;
 pub mod downloads;
 pub mod library;
 pub mod state;
-pub mod collections;
--- a/src-tauri/src/games/state.rs
+++ b/src-tauri/src/games/state.rs
@ -1,4 +1,7 @@
-use crate::database::db::{borrow_db_checked, ApplicationTransientStatus, GameDownloadStatus};
+use crate::database::{
+    db::borrow_db_checked,
+    models::data::{ApplicationTransientStatus, GameDownloadStatus},
+};

 pub type GameStatusWithTransient = (
    Option<GameDownloadStatus>,
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@ -1,30 +1,36 @@
+#![feature(fn_traits)]
+#![feature(duration_constructors)]
+#![deny(clippy::all)]
+
 mod database;
 mod games;

-mod autostart;
-mod cleanup;
-mod commands;
+mod client;
 mod download_manager;
 mod error;
 mod process;
 mod remote;

-use crate::database::db::DatabaseImpls;
-use autostart::{get_autostart_enabled, toggle_autostart};
-use cleanup::{cleanup_and_exit, quit};
-use commands::fetch_state;
+use crate::process::commands::open_process_logs;
+use crate::remote::commands::auth_initiate_code;
+use crate::{database::db::DatabaseImpls, games::downloads::commands::resume_download};
+use bitcode::{Decode, Encode};
+use client::commands::fetch_state;
+use client::{
+    autostart::{get_autostart_enabled, sync_autostart_on_startup, toggle_autostart},
+    cleanup::{cleanup_and_exit, quit},
+};
 use database::commands::{
    add_download_dir, delete_download_dir, fetch_download_dir_stats, fetch_settings,
    fetch_system_data, update_settings,
 };
-use database::db::{
-    borrow_db_checked, borrow_db_mut_checked, DatabaseInterface, GameDownloadStatus, DATA_ROOT_DIR,
-};
+use database::db::{DATA_ROOT_DIR, DatabaseInterface, borrow_db_checked, borrow_db_mut_checked};
+use database::models::data::GameDownloadStatus;
 use download_manager::commands::{
    cancel_game, move_download_in_queue, pause_downloads, resume_downloads,
 };
-use download_manager::download_manager::DownloadManager;
 use download_manager::download_manager_builder::DownloadManagerBuilder;
+use download_manager::download_manager_frontend::DownloadManager;
 use games::collections::commands::{
    add_game_to_collection, create_collection, delete_collection, delete_game_in_collection,
    fetch_collection, fetch_collections,
@ -33,15 +39,13 @@ use games::commands::{
    fetch_game, fetch_game_status, fetch_game_verion_options, fetch_library, uninstall_game,
 };
 use games::downloads::commands::download_game;
-use games::library::{update_game_configuration, Game};
-use http::Response;
-use http::{header::*, response::Builder as ResponseBuilder};
-use log::{debug, info, warn, LevelFilter};
+use games::library::{Game, update_game_configuration};
+use log::{LevelFilter, debug, info, warn};
+use log4rs::Config;
 use log4rs::append::console::ConsoleAppender;
 use log4rs::append::file::FileAppender;
 use log4rs::config::{Appender, Root};
 use log4rs::encode::pattern::PatternEncoder;
-use log4rs::Config;
 use process::commands::{kill_game, launch_game};
 use process::process_manager::ProcessManager;
 use remote::auth::{self, recieve_handshake};
@ -49,19 +53,21 @@ use remote::commands::{
    auth_initiate, fetch_drop_object, gen_drop_url, manual_recieve_handshake, retry_connect,
    sign_out, use_remote,
 };
-use remote::fetch_object::{fetch_object, fetch_object_offline};
-use remote::requests::make_request;
+use remote::fetch_object::fetch_object;
 use remote::server_proto::{handle_server_proto, handle_server_proto_offline};
-use reqwest::blocking::Body;
 use serde::{Deserialize, Serialize};
-use std::env;
+use std::fs::File;
+use std::io::Write;
+use std::panic::PanicHookInfo;
 use std::path::Path;
 use std::str::FromStr;
 use std::sync::Arc;
+use std::time::SystemTime;
 use std::{
    collections::HashMap,
    sync::{LazyLock, Mutex},
 };
+use std::{env, panic};
 use tauri::menu::{Menu, MenuItem, PredefinedMenuItem};
 use tauri::tray::TrayIconBuilder;
 use tauri::{AppHandle, Manager, RunEvent, WindowEvent};
@ -79,17 +85,16 @@ pub enum AppStatus {
    ServerUnavailable,
 }

-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize, Encode, Decode)]
 #[serde(rename_all = "camelCase")]
 pub struct User {
    id: String,
    username: String,
    admin: bool,
    display_name: String,
-    profile_picture: String,
+    profile_picture_object_id: String,
 }

-
 #[derive(Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct AppState<'a> {
@ -109,7 +114,7 @@ fn setup(handle: AppHandle) -> AppState<'static> {
            "{d} | {l} | {f}:{L} - {m}{n}",
        )))
        .append(false)
-        .build(DATA_ROOT_DIR.lock().unwrap().join("./drop.log"))
+        .build(DATA_ROOT_DIR.join("./drop.log"))
        .unwrap();

    let console = ConsoleAppender::builder()
@ -159,10 +164,11 @@ fn setup(handle: AppHandle) -> AppState<'static> {
    let mut missing_games = Vec::new();
    let statuses = db_handle.applications.game_statuses.clone();
    drop(db_handle);
-    for (game_id, status) in statuses.into_iter() {
+    for (game_id, status) in statuses {
        match status {
-            database::db::GameDownloadStatus::Remote {} => {}
-            database::db::GameDownloadStatus::SetupRequired {
+            GameDownloadStatus::Remote {} => {}
+            GameDownloadStatus::PartiallyInstalled { .. } => {}
+            GameDownloadStatus::SetupRequired {
                version_name: _,
                install_dir,
            } => {
@ -171,7 +177,7 @@ fn setup(handle: AppHandle) -> AppState<'static> {
                    missing_games.push(game_id);
                }
            }
-            database::db::GameDownloadStatus::Installed {
+            GameDownloadStatus::Installed {
                version_name: _,
                install_dir,
            } => {
@ -183,7 +189,7 @@ fn setup(handle: AppHandle) -> AppState<'static> {
        }
    }

-    info!("detected games missing: {:?}", missing_games);
+    info!("detected games missing: {missing_games:?}");

    let mut db_handle = borrow_db_mut_checked();
    for game_id in missing_games {
@ -199,8 +205,8 @@ fn setup(handle: AppHandle) -> AppState<'static> {
    debug!("finished setup!");

    // Sync autostart state
-    if let Err(e) = autostart::sync_autostart_on_startup(&handle) {
-        warn!("failed to sync autostart state: {}", e);
+    if let Err(e) = sync_autostart_on_startup(&handle) {
+        warn!("failed to sync autostart state: {e}");
    }

    AppState {
@ -214,9 +220,31 @@ fn setup(handle: AppHandle) -> AppState<'static> {

 pub static DB: LazyLock<DatabaseInterface> = LazyLock::new(DatabaseInterface::set_up_database);

+pub fn custom_panic_handler(e: &PanicHookInfo) -> Option<()> {
+    let crash_file = DATA_ROOT_DIR.join(format!(
+        "crash-{}.log",
+        SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .ok()?
+            .as_secs()
+    ));
+    let mut file = File::create_new(crash_file).ok()?;
+    file.write_all(format!("Drop crashed with the following panic:\n{e}").as_bytes())
+        .ok()?;
+    drop(file);
+
+    Some(())
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
+    panic::set_hook(Box::new(|e| {
+        let _ = custom_panic_handler(e);
+        println!("{e}");
+    }));
+
    let mut builder = tauri::Builder::default()
+        .plugin(tauri_plugin_opener::init())
        .plugin(tauri_plugin_os::init())
        .plugin(tauri_plugin_dialog::init());

@ -240,6 +268,7 @@ pub fn run() {
            fetch_settings,
            // Auth
            auth_initiate,
+            auth_initiate_code,
            retry_connect,
            manual_recieve_handshake,
            sign_out,
@ -265,6 +294,7 @@ pub fn run() {
            delete_game_in_collection,
            // Downloads
            download_game,
+            resume_download,
            move_download_in_queue,
            pause_downloads,
            resume_downloads,
@ -275,6 +305,7 @@ pub fn run() {
            kill_game,
            toggle_autostart,
            get_autostart_enabled,
+            open_process_logs
        ])
        .plugin(tauri_plugin_shell::init())
        .plugin(tauri_plugin_dialog::init())
@ -288,10 +319,9 @@ pub fn run() {
            debug!("initialized drop client");
            app.manage(Mutex::new(state));

-            #[cfg(any(target_os = "linux", all(debug_assertions, windows)))]
            {
                use tauri_plugin_deep_link::DeepLinkExt;
-                app.deep_link().register_all()?;
+                let _ = app.deep_link().register_all();
                debug!("registered all pre-defined deep links");
            }

@ -307,7 +337,7 @@ pub fn run() {
            .inner_size(1536.0, 864.0)
            .decorations(false)
            .shadow(false)
-            .data_directory(DATA_ROOT_DIR.lock().unwrap().join(".webview"))
+            .data_directory(DATA_ROOT_DIR.join(".webview"))
            .build()
            .unwrap();

@ -316,7 +346,7 @@ pub fn run() {
                let binding = event.urls();
                let url = binding.first().unwrap();
                if url.host_str().unwrap() == "handshake" {
-                    recieve_handshake(handle.clone(), url.path().to_string())
+                    recieve_handshake(handle.clone(), url.path().to_string());
                }
            });

@ -334,34 +364,32 @@ pub fn run() {
                ],
            )?;

-            TrayIconBuilder::new()
-                .icon(app.default_window_icon().unwrap().clone())
-                .menu(&menu)
-                .on_menu_event(|app, event| match event.id.as_ref() {
-                    "open" => {
-                        app.webview_windows().get("main").unwrap().show().unwrap();
-                    }
-                    "quit" => {
-                        cleanup_and_exit(app, &app.state());
-                    }
+            run_on_tray(|| {
+                TrayIconBuilder::new()
+                    .icon(app.default_window_icon().unwrap().clone())
+                    .menu(&menu)
+                    .on_menu_event(|app, event| match event.id.as_ref() {
+                        "open" => {
+                            app.webview_windows().get("main").unwrap().show().unwrap();
+                        }
+                        "quit" => {
+                            cleanup_and_exit(app, &app.state());
+                        }

-                    _ => {
-                        warn!("menu event not handled: {:?}", event.id);
-                    }
-                })
-                .build(app)
-                .expect("error while setting up tray menu");
+                        _ => {
+                            warn!("menu event not handled: {:?}", event.id);
+                        }
+                    })
+                    .build(app)
+                    .expect("error while setting up tray menu");
+            });

            {
                let mut db_handle = borrow_db_mut_checked();
                if let Some(original) = db_handle.prev_database.take() {
                    warn!(
                        "Database corrupted. Original file at {}",
-                        original
-                            .canonicalize()
-                            .unwrap()
-                            .to_string_lossy()
-                            .to_string()
+                        original.canonicalize().unwrap().to_string_lossy()
                    );
                    app.dialog()
                        .message(
@ -375,15 +403,10 @@ pub fn run() {

            Ok(())
        })
-        .register_asynchronous_uri_scheme_protocol("object", move |ctx, request, responder| {
-            let state: tauri::State<'_, Mutex<AppState>> = ctx.app_handle().state();
-            offline!(
-                state,
-                fetch_object,
-                fetch_object_offline,
-                request,
-                responder
-            );
+        .register_asynchronous_uri_scheme_protocol("object", move |_ctx, request, responder| {
+            tauri::async_runtime::spawn(async move {
+                fetch_object(request, responder).await;
+            });
        })
        .register_asynchronous_uri_scheme_protocol("server", move |ctx, request, responder| {
            let state: tauri::State<'_, Mutex<AppState>> = ctx.app_handle().state();
@ -394,12 +417,13 @@ pub fn run() {
                request,
                responder
            );
-
        })
        .on_window_event(|window, event| {
            if let WindowEvent::CloseRequested { api, .. } = event {
-                window.hide().unwrap();
-                api.prevent_close();
+                run_on_tray(|| {
+                    window.hide().unwrap();
+                    api.prevent_close();
+                });
            }
        })
        .build(tauri::generate_context!())
@ -407,9 +431,20 @@ pub fn run() {

    app.run(|_app_handle, event| {
        if let RunEvent::ExitRequested { code, api, .. } = event {
-            if code.is_none() {
-                api.prevent_exit();
-            }
+            run_on_tray(|| {
+                if code.is_none() {
+                    api.prevent_exit();
+                }
+            });
        }
    });
 }
+
+fn run_on_tray<T: FnOnce()>(f: T) {
+    if match std::env::var("NO_TRAY_ICON") {
+        Ok(s) => s.to_lowercase() != "true",
+        Err(_) => true,
+    } {
+        (f)();
+    }
+}
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@ -2,5 +2,5 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]

 fn main() {
-    drop_app_lib::run()
+    drop_app_lib::run();
 }
--- a/src-tauri/src/process/commands.rs
+++ b/src-tauri/src/process/commands.rs
@ -17,9 +17,9 @@ pub fn launch_game(
    //};

    match process_manager_lock.launch_process(id) {
-        Ok(_) => {}
+        Ok(()) => {}
        Err(e) => return Err(e),
-    };
+    }

    drop(process_manager_lock);
    drop(state_lock);
@ -38,3 +38,13 @@ pub fn kill_game(
        .kill_game(game_id)
        .map_err(ProcessError::IOError)
 }
+
+#[tauri::command]
+pub fn open_process_logs(
+    game_id: String,
+    state: tauri::State<'_, Mutex<AppState>>,
+) -> Result<(), ProcessError> {
+    let state_lock = state.lock().unwrap();
+    let mut process_manager_lock = state_lock.process_manager.lock().unwrap();
+    process_manager_lock.open_process_logs(game_id)
+}
--- a/src-tauri/src/process/compat.rs
+++ b/src-tauri/src/process/compat.rs
@ -1,13 +1 @@
-// Since this code isn't being used, we can either:
-// 1. Delete the entire file if compatibility features are not planned
-// 2. Or add a TODO comment if planning to implement later

-// Option 1: Delete the file
-// Delete src-tauri/src/process/compat.rs
-
-// Option 2: Add TODO comment
-/*
-TODO: Compatibility layer for running Windows games on Linux
-This module is currently unused but reserved for future implementation
-of Windows game compatibility features on Linux.
-*/
--- a/src-tauri/src/process/mod.rs
+++ b/src-tauri/src/process/mod.rs
@ -1,3 +1,4 @@
 pub mod commands;
+#[cfg(target_os = "linux")]
 pub mod compat;
 pub mod process_manager;
--- a/src-tauri/src/process/process_manager.rs
+++ b/src-tauri/src/process/process_manager.rs
@ -1,12 +1,13 @@
 use std::{
    collections::HashMap,
-    fs::{File, OpenOptions},
-    io::{self, Error},
-    path::{Path, PathBuf},
-    process::{Child, Command, ExitStatus},
+    fs::{OpenOptions, create_dir_all},
+    io::{self},
+    path::PathBuf,
+    process::{Command, ExitStatus},
    str::FromStr,
    sync::{Arc, Mutex},
    thread::spawn,
+    time::{Duration, SystemTime},
 };

 use dynfmt::Format;
@ -14,40 +15,46 @@ use dynfmt::SimpleCurlyFormat;
 use log::{debug, info, warn};
 use serde::{Deserialize, Serialize};
 use shared_child::SharedChild;
-use tauri::{AppHandle, Manager};
-use umu_wrapper_lib::command_builder::UmuCommandBuilder;
+use tauri::{AppHandle, Emitter, Manager};
+use tauri_plugin_opener::OpenerExt;

 use crate::{
-    database::db::{
-        borrow_db_mut_checked, ApplicationTransientStatus, GameDownloadStatus, GameVersion,
-        DATA_ROOT_DIR,
+    AppState, DB,
+    database::{
+        db::{DATA_ROOT_DIR, borrow_db_mut_checked},
+        models::data::{
+            ApplicationTransientStatus, DownloadType, DownloadableMetadata, GameDownloadStatus,
+            GameVersion,
+        },
    },
-    download_manager::downloadable_metadata::{DownloadType, DownloadableMetadata},
    error::process_error::ProcessError,
    games::{library::push_game_update, state::GameStatusManager},
-    AppState, DB,
 };

+pub struct RunningProcess {
+    handle: Arc<SharedChild>,
+    start: SystemTime,
+    manually_killed: bool,
+}
+
 pub struct ProcessManager<'a> {
    current_platform: Platform,
    log_output_dir: PathBuf,
-    processes: HashMap<String, Arc<SharedChild>>,
+    processes: HashMap<String, RunningProcess>,
    app_handle: AppHandle,
    game_launchers: HashMap<(Platform, Platform), &'a (dyn ProcessHandler + Sync + Send + 'static)>,
 }

 impl ProcessManager<'_> {
    pub fn new(app_handle: AppHandle) -> Self {
-        let root_dir_lock = DATA_ROOT_DIR.lock().unwrap();
-        let log_output_dir = root_dir_lock.join("logs");
-        drop(root_dir_lock);
+        let log_output_dir = DATA_ROOT_DIR.join("logs");

        ProcessManager {
            #[cfg(target_os = "windows")]
            current_platform: Platform::Windows,

            #[cfg(target_os = "macos")]
-            current_platform: Platform::macOS,
+            current_platform: Platform::MacOs,

            #[cfg(target_os = "linux")]
            current_platform: Platform::Linux,
@ -66,7 +73,7 @@ impl ProcessManager<'_> {
                    &NativeGameLauncher {} as &(dyn ProcessHandler + Sync + Send + 'static),
                ),
                (
-                    (Platform::macOS, Platform::macOS),
+                    (Platform::MacOs, Platform::MacOs),
                    &NativeGameLauncher {} as &(dyn ProcessHandler + Sync + Send + 'static),
                ),
                (
@ -78,10 +85,11 @@ impl ProcessManager<'_> {
    }

    pub fn kill_game(&mut self, game_id: String) -> Result<(), io::Error> {
-        match self.processes.get(&game_id) {
-            Some(child) => {
-                child.kill()?;
-                child.wait()?;
+        match self.processes.get_mut(&game_id) {
+            Some(process) => {
+                process.manually_killed = true;
+                process.handle.kill()?;
+                process.handle.wait()?;
                Ok(())
            }
            None => Err(io::Error::new(
@ -91,15 +99,26 @@ impl ProcessManager<'_> {
        }
    }

+    pub fn open_process_logs(&mut self, game_id: String) -> Result<(), ProcessError> {
+        let dir = self.log_output_dir.join(game_id);
+        self.app_handle
+            .opener()
+            .open_path(dir.to_str().unwrap(), None::<&str>)
+            .map_err(ProcessError::OpenerError)?;
+        Ok(())
+    }
+
    fn on_process_finish(&mut self, game_id: String, result: Result<ExitStatus, std::io::Error>) {
        if !self.processes.contains_key(&game_id) {
-            warn!("process on_finish was called, but game_id is no longer valid. finished with result: {:?}", result);
+            warn!(
+                "process on_finish was called, but game_id is no longer valid. finished with result: {result:?}"
+            );
            return;
        }

        debug!("process for {:?} exited with {:?}", &game_id, result);

-        self.processes.remove(&game_id);
+        let process = self.processes.remove(&game_id).unwrap();

        let mut db_handle = borrow_db_mut_checked();
        let meta = db_handle
@ -111,39 +130,41 @@ impl ProcessManager<'_> {
        db_handle.applications.transient_statuses.remove(&meta);

        let current_state = db_handle.applications.game_statuses.get(&game_id).cloned();
-        if let Some(saved_state) = current_state {
-            if let GameDownloadStatus::SetupRequired {
-                version_name,
-                install_dir,
-            } = saved_state
-            {
-                if let Ok(exit_code) = result {
-                    if exit_code.success() {
-                        db_handle.applications.game_statuses.insert(
-                            game_id.clone(),
-                            GameDownloadStatus::Installed {
-                                version_name: version_name.to_string(),
-                                install_dir: install_dir.to_string(),
-                            },
-                        );
-                    }
-                }
-            }
+        if let Some(GameDownloadStatus::SetupRequired {
+            version_name,
+            install_dir,
+        }) = current_state
+            && let Ok(exit_code) = result
+            && exit_code.success()
+        {
+            db_handle.applications.game_statuses.insert(
+                game_id.clone(),
+                GameDownloadStatus::Installed {
+                    version_name: version_name.to_string(),
+                    install_dir: install_dir.to_string(),
+                },
+            );
        }
        drop(db_handle);

+        let elapsed = process.start.elapsed().unwrap_or(Duration::ZERO);
+        // If we started and ended really quickly, something might've gone wrong
+        // Or if the status isn't 0
+        // Or if it's an error
+        if !process.manually_killed
+            && (elapsed.as_secs() <= 2 || result.is_err() || !result.unwrap().success())
+        {
+            warn!("drop detected that the game {game_id} may have failed to launch properly");
+            let _ = self.app_handle.emit("launch_external_error", &game_id);
+        }
+
        let status = GameStatusManager::fetch_state(&game_id);
-
        push_game_update(&self.app_handle, &game_id, None, status);
-
-        // TODO better management
    }

    pub fn valid_platform(&self, platform: &Platform) -> Result<bool, String> {
        let current = &self.current_platform;
-        Ok(self
-            .game_launchers
-            .contains_key(&(current.clone(), platform.clone())))
+        Ok(self.game_launchers.contains_key(&(*current, *platform)))
    }

    pub fn launch_process(&mut self, game_id: String) -> Result<(), ProcessError> {
@ -160,9 +181,7 @@ impl ProcessManager<'_> {
            .cloned()
        {
            Some(GameDownloadStatus::Installed { version_name, .. }) => version_name,
-            Some(GameDownloadStatus::SetupRequired { .. }) => {
-                return Err(ProcessError::SetupRequired)
-            }
+            Some(GameDownloadStatus::SetupRequired { version_name, .. }) => version_name,
            _ => return Err(ProcessError::NotInstalled),
        };
        let meta = DownloadableMetadata {
@ -192,6 +211,10 @@ impl ProcessManager<'_> {
                version_name,
                install_dir,
            } => (version_name, install_dir),
+            GameDownloadStatus::PartiallyInstalled {
+                version_name,
+                install_dir,
+            } => (version_name, install_dir),
            _ => return Err(ProcessError::NotDownloaded),
        };

@ -203,18 +226,17 @@ impl ProcessManager<'_> {
            .get(version_name)
            .ok_or(ProcessError::InvalidVersion)?;

+        // TODO: refactor this path with open_process_logs
+        let game_log_folder = &self.log_output_dir.join(game_id);
+        create_dir_all(game_log_folder).map_err(ProcessError::IOError)?;
+
        let current_time = chrono::offset::Local::now();
        let log_file = OpenOptions::new()
            .write(true)
            .truncate(true)
            .read(true)
            .create(true)
-            .open(self.log_output_dir.join(format!(
-                "{}-{}-{}.log",
-                &game_id,
-                &version,
-                current_time.timestamp()
-            )))
+            .open(game_log_folder.join(format!("{}-{}.log", &version, current_time.timestamp())))
            .map_err(ProcessError::IOError)?;

        let error_file = OpenOptions::new()
@ -222,16 +244,15 @@ impl ProcessManager<'_> {
            .truncate(true)
            .read(true)
            .create(true)
-            .open(self.log_output_dir.join(format!(
-                "{}-{}-{}-error.log",
-                &game_id,
+            .open(game_log_folder.join(format!(
+                "{}-{}-error.log",
                &version,
                current_time.timestamp()
            )))
            .map_err(ProcessError::IOError)?;

-        let current_platform = self.current_platform.clone();
-        let target_platform = game_version.platform.clone();
+        let current_platform = self.current_platform;
+        let target_platform = game_version.platform;

        let game_launcher = self
            .game_launchers
@ -247,16 +268,20 @@ impl ProcessManager<'_> {
                version_name: _,
                install_dir: _,
            } => (&game_version.setup_command, &game_version.setup_args),
-            GameDownloadStatus::Remote {} => unreachable!("nuh uh"),
+            GameDownloadStatus::PartiallyInstalled {
+                version_name: _,
+                install_dir: _,
+            } => unreachable!("Game registered as 'Partially Installed'"),
+            GameDownloadStatus::Remote {} => unreachable!("Game registered as 'Remote'"),
        };

-        let launch = PathBuf::from_str(&install_dir).unwrap().join(launch);
+        let launch = PathBuf::from_str(install_dir).unwrap().join(launch);
        let launch = launch.to_str().unwrap();

        let launch_string = game_launcher.create_launch_process(
            &meta,
            launch.to_string(),
-            args.to_vec(),
+            args.clone(),
            game_version,
            install_dir,
        );
@ -266,17 +291,20 @@ impl ProcessManager<'_> {
            .map_err(|e| ProcessError::FormatError(e.to_string()))?
            .to_string();

+        #[cfg(target_os = "windows")]
+        use std::os::windows::process::CommandExt;
+
        #[cfg(target_os = "windows")]
        let mut command = Command::new("cmd");
        #[cfg(target_os = "windows")]
-        command.args(["/C", &launch_string]);
+        command.raw_arg(format!("/C \"{}\"", &launch_string));

-        info!("launching (in {}): {}", install_dir, launch_string,);
+        info!("launching (in {install_dir}): {launch_string}",);

        #[cfg(unix)]
        let mut command: Command = Command::new("sh");
        #[cfg(unix)]
-        command.arg("-c").arg(launch_string);
+        command.args(vec!["-c", &launch_string]);

        command
            .stderr(error_file)
@ -319,16 +347,61 @@ impl ProcessManager<'_> {
            drop(app_state_handle);
        });

-        self.processes.insert(meta.id, wait_thread_handle);
+        self.processes.insert(
+            meta.id,
+            RunningProcess {
+                handle: wait_thread_handle,
+                start: SystemTime::now(),
+                manually_killed: false,
+            },
+        );
        Ok(())
    }
 }

-#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Copy, Debug)]
 pub enum Platform {
    Windows,
    Linux,
-    macOS,
+    MacOs,
+}
+
+impl Platform {
+    #[cfg(target_os = "windows")]
+    pub const HOST: Platform = Self::Windows;
+    #[cfg(target_os = "macos")]
+    pub const HOST: Platform = Self::MacOs;
+    #[cfg(target_os = "linux")]
+    pub const HOST: Platform = Self::Linux;
+
+    pub fn is_case_sensitive(&self) -> bool {
+        match self {
+            Self::Windows | Self::MacOs => false,
+            Self::Linux => true,
+        }
+    }
+}
+
+impl From<&str> for Platform {
+    fn from(value: &str) -> Self {
+        match value.to_lowercase().trim() {
+            "windows" => Self::Windows,
+            "linux" => Self::Linux,
+            "mac" | "macos" => Self::MacOs,
+            _ => unimplemented!(),
+        }
+    }
+}
+
+impl From<whoami::Platform> for Platform {
+    fn from(value: whoami::Platform) -> Self {
+        match value {
+            whoami::Platform::Windows => Platform::Windows,
+            whoami::Platform::Linux => Platform::Linux,
+            whoami::Platform::MacOS => Platform::MacOs,
+            _ => unimplemented!(),
+        }
+    }
 }

 pub trait ProcessHandler: Send + 'static {
@ -349,14 +422,14 @@ impl ProcessHandler for NativeGameLauncher {
        _meta: &DownloadableMetadata,
        launch_command: String,
        args: Vec<String>,
-        game_version: &GameVersion,
-        current_dir: &str,
+        _game_version: &GameVersion,
+        _current_dir: &str,
    ) -> String {
        format!("\"{}\" {}", launch_command, args.join(" "))
    }
 }

-const UMU_LAUNCHER_EXECUTABLE: &str = "umu-run";
+pub const UMU_LAUNCHER_EXECUTABLE: &str = "umu-run";
 struct UMULauncher;
 impl ProcessHandler for UMULauncher {
    fn create_launch_process(
@ -369,10 +442,13 @@ impl ProcessHandler for UMULauncher {
    ) -> String {
        debug!("Game override: \"{:?}\"", &game_version.umu_id_override);
        let game_id = match &game_version.umu_id_override {
-            Some(game_override) => game_override
-                .is_empty()
-                .then_some(game_version.game_id.clone())
-                .unwrap_or(game_override.clone()),
+            Some(game_override) => {
+                if game_override.is_empty() {
+                    game_version.game_id.clone()
+                } else {
+                    game_override.clone()
+                }
+            }
            None => game_version.game_id.clone(),
        };
        format!(
--- a/src-tauri/src/remote/auth.rs
+++ b/src-tauri/src/remote/auth.rs
@ -1,20 +1,18 @@
-use std::{env, sync::Mutex};
+use std::{collections::HashMap, env, sync::Mutex};

 use chrono::Utc;
 use droplet_rs::ssl::sign_nonce;
 use gethostname::gethostname;
 use log::{debug, error, warn};
 use serde::{Deserialize, Serialize};
-use serde_json::json;
 use tauri::{AppHandle, Emitter, Manager};
 use url::Url;

 use crate::{
-    database::db::{
-        borrow_db_checked, borrow_db_mut_checked, save_db, DatabaseAuth, DatabaseImpls,
-    },
-    error::{drop_server_error::DropServerError, remote_access_error::RemoteAccessError},
-    AppState, AppStatus, User, DB,
+    database::{
+        db::{borrow_db_checked, borrow_db_mut_checked},
+        models::data::DatabaseAuth,
+    }, error::{drop_server_error::DropServerError, remote_access_error::RemoteAccessError}, remote::utils::DROP_CLIENT_SYNC, AppState, AppStatus, User
 };

 use super::{
@ -22,11 +20,17 @@ use super::{
    requests::make_request,
 };

+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct CapabilityConfiguration {}
+
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 struct InitiateRequestBody {
    name: String,
    platform: String,
+    capabilities: HashMap<String, CapabilityConfiguration>,
+    mode: String,
 }

 #[derive(Serialize)]
@ -58,18 +62,16 @@ pub fn generate_authorization_header() -> String {
 }

 pub fn fetch_user() -> Result<User, RemoteAccessError> {
-    let base_url = DB.fetch_base_url();
-
    let header = generate_authorization_header();

-    let client = reqwest::blocking::Client::new();
+    let client = DROP_CLIENT_SYNC.clone();
    let response = make_request(&client, &["/api/v1/client/user"], &[], |f| {
        f.header("Authorization", header)
    })?
    .send()?;
    if response.status() != 200 {
        let err: DropServerError = response.json()?;
-        warn!("{:?}", err);
+        warn!("{err:?}");

        if err.status_message == "Nonce expired" {
            return Err(RemoteAccessError::OutOfSync);
@ -78,11 +80,11 @@ pub fn fetch_user() -> Result<User, RemoteAccessError> {
        return Err(RemoteAccessError::InvalidResponse(err));
    }

-    response.json::<User>().map_err(|e| e.into())
+    response.json::<User>().map_err(std::convert::Into::into)
 }

 fn recieve_handshake_logic(app: &AppHandle, path: String) -> Result<(), RemoteAccessError> {
-    let path_chunks: Vec<&str> = path.split("/").collect();
+    let path_chunks: Vec<&str> = path.split('/').collect();
    if path_chunks.len() != 3 {
        app.emit("auth/failed", ()).unwrap();
        return Err(RemoteAccessError::HandshakeFailed(
@ -98,14 +100,17 @@ fn recieve_handshake_logic(app: &AppHandle, path: String) -> Result<(), RemoteAc
    let client_id = path_chunks.get(1).unwrap();
    let token = path_chunks.get(2).unwrap();
    let body = HandshakeRequestBody {
-        client_id: client_id.to_string(),
-        token: token.to_string(),
+        client_id: (*client_id).to_string(),
+        token: (*token).to_string(),
    };

    let endpoint = base_url.join("/api/v1/client/auth/handshake")?;
-    let client = reqwest::blocking::Client::new();
+    let client = DROP_CLIENT_SYNC.clone();
    let response = client.post(endpoint).json(&body).send()?;
    debug!("handshake responsded with {}", response.status().as_u16());
+    if !response.status().is_success() {
+        return Err(RemoteAccessError::InvalidResponse(response.json()?));
+    }
    let response_struct: HandshakeResponse = response.json()?;

    {
@ -116,8 +121,6 @@ fn recieve_handshake_logic(app: &AppHandle, path: String) -> Result<(), RemoteAc
            client_id: response_struct.id,
            web_token: None, // gets created later
        });
-        drop(handle);
-        save_db();
    }

    let web_token = {
@ -134,32 +137,6 @@ fn recieve_handshake_logic(app: &AppHandle, path: String) -> Result<(), RemoteAc
    let mut handle = borrow_db_mut_checked();
    let mut_auth = handle.auth.as_mut().unwrap();
    mut_auth.web_token = Some(web_token);
-    drop(handle);
-    save_db();
-
-    {
-        let app_state = app.state::<Mutex<AppState>>();
-        let mut app_state_handle = app_state.lock().unwrap();
-        app_state_handle.status = AppStatus::SignedIn;
-        app_state_handle.user = Some(fetch_user()?);
-
-        // Setup capabilities
-        let endpoint = base_url.join("/api/v1/client/capability")?;
-        let header = generate_authorization_header();
-        let body = json!({
-            "capability": "cloudSaves",
-            "configuration": {}
-        });
-        let response = client
-            .post(endpoint)
-            .header("Authorization", header)
-            .json(&body)
-            .send()?;
-
-        if response.status().is_success() {
-            debug!("registered client for 'cloudSaves' capability")
-        }
-    }

    Ok(())
 }
@ -170,15 +147,25 @@ pub fn recieve_handshake(app: AppHandle, path: String) {

    let handshake_result = recieve_handshake_logic(&app, path);
    if let Err(e) = handshake_result {
-        warn!("error with authentication: {}", e);
+        warn!("error with authentication: {e}");
        app.emit("auth/failed", e.to_string()).unwrap();
        return;
    }

+    let app_state = app.state::<Mutex<AppState>>();
+    let mut state_lock = app_state.lock().unwrap();
+
+    let (app_status, user) = setup();
+
+    state_lock.status = app_status;
+    state_lock.user = user;
+
+    drop(state_lock);
+
    app.emit("auth/finished", ()).unwrap();
 }

-pub fn auth_initiate_logic() -> Result<(), RemoteAccessError> {
+pub fn auth_initiate_logic(mode: String) -> Result<String, RemoteAccessError> {
    let base_url = {
        let db_lock = borrow_db_checked();
        Url::parse(&db_lock.base_url.clone())?
@ -190,9 +177,14 @@ pub fn auth_initiate_logic() -> Result<(), RemoteAccessError> {
    let body = InitiateRequestBody {
        name: format!("{} (Desktop)", hostname.into_string().unwrap()),
        platform: env::consts::OS.to_string(),
+        capabilities: HashMap::from([
+            ("peerAPI".to_owned(), CapabilityConfiguration {}),
+            ("cloudSaves".to_owned(), CapabilityConfiguration {}),
+        ]),
+        mode,
    };

-    let client = reqwest::blocking::Client::new();
+    let client = DROP_CLIENT_SYNC.clone();
    let response = client.post(endpoint.to_string()).json(&body).send()?;

    if response.status() != 200 {
@ -202,13 +194,9 @@ pub fn auth_initiate_logic() -> Result<(), RemoteAccessError> {
        return Err(RemoteAccessError::HandshakeFailed(data.status_message));
    }

-    let redir_url = response.text()?;
-    let complete_redir_url = base_url.join(&redir_url)?;
+    let response = response.text()?;

-    debug!("opening web browser to continue authentication");
-    webbrowser::open(complete_redir_url.as_ref()).unwrap();
-
-    Ok(())
+    Ok(response)
 }

 pub fn setup() -> (AppStatus, Option<User>) {
@ -220,7 +208,7 @@ pub fn setup() -> (AppStatus, Option<User>) {
        let user_result = match fetch_user() {
            Ok(data) => data,
            Err(RemoteAccessError::FetchError(_)) => {
-                let user = get_cached_object::<String, User>("user".to_owned()).unwrap();
+                let user = get_cached_object::<User>("user").unwrap();
                return (AppStatus::Offline, Some(user));
            }
            Err(_) => return (AppStatus::SignedInNeedsReauth, None),
--- a/src-tauri/src/remote/cache.rs
+++ b/src-tauri/src/remote/cache.rs
@ -1,20 +1,23 @@
-use std::sync::RwLockReadGuard;
+use std::{
+    fs::File,
+    io::{self, Write},
+    path::{Path, PathBuf},
+    time::SystemTime,
+};

 use crate::{
-    database::db::{borrow_db_checked, Database},
+    database::{db::borrow_db_checked, models::data::Database},
    error::remote_access_error::RemoteAccessError,
 };
-use cacache::Integrity;
-use http::{header::CONTENT_TYPE, response::Builder as ResponseBuilder, Response};
-use serde::{de::DeserializeOwned, Deserialize, Serialize};
-use serde_binary::binary_stream::Endian;
-
+use bitcode::{Decode, DecodeOwned, Encode};
+use http::{Response, header::CONTENT_TYPE, response::Builder as ResponseBuilder};
+use log::debug;

 #[macro_export]
 macro_rules! offline {
    ($var:expr, $func1:expr, $func2:expr, $( $arg:expr ),* ) => {

-        if crate::borrow_db_checked().settings.force_offline || $var.lock().unwrap().status == crate::AppStatus::Offline {
+        if $crate::borrow_db_checked().settings.force_offline || $var.lock().unwrap().status == $crate::AppStatus::Offline {
            $func2( $( $arg ), *)
        } else {
            $func1( $( $arg ), *)
@ -22,31 +25,68 @@ macro_rules! offline {
    }
 }

-pub fn cache_object<'a, K: AsRef<str>, D: Serialize + DeserializeOwned>(
-    key: K,
-    data: &D,
-) -> Result<Integrity, RemoteAccessError> {
-    let bytes = serde_binary::to_vec(data, Endian::Little).unwrap();
-    cacache::write_sync(&borrow_db_checked().cache_dir, key, bytes)
-        .map_err(|e| RemoteAccessError::Cache(e))
+fn get_sys_time_in_secs() -> u64 {
+    match SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {
+        Ok(n) => n.as_secs(),
+        Err(_) => panic!("SystemTime before UNIX EPOCH!"),
+    }
 }
-pub fn get_cached_object<'a, K: AsRef<str>, D: Serialize + DeserializeOwned>(
-    key: K,
-) -> Result<D, RemoteAccessError> {
-    get_cached_object_db::<K, D>(key, &borrow_db_checked())
+
+fn get_cache_path(base: &Path, key: &str) -> PathBuf {
+    let key_hash = hex::encode(md5::compute(key.as_bytes()).0);
+    base.join(key_hash)
 }
-pub fn get_cached_object_db<'a, K: AsRef<str>, D: Serialize + DeserializeOwned>(
-    key: K,
+
+fn write_sync(base: &Path, key: &str, data: Vec<u8>) -> io::Result<()> {
+    let cache_path = get_cache_path(base, key);
+    let mut file = File::create(cache_path)?;
+    file.write_all(&data)?;
+    Ok(())
+}
+
+fn read_sync(base: &Path, key: &str) -> io::Result<Vec<u8>> {
+    let cache_path = get_cache_path(base, key);
+    let file = std::fs::read(cache_path)?;
+    Ok(file)
+}
+
+pub fn cache_object<D: Encode>(key: &str, data: &D) -> Result<(), RemoteAccessError> {
+    let bytes = bitcode::encode(data);
+    write_sync(&borrow_db_checked().cache_dir, key, bytes).map_err(RemoteAccessError::Cache)
+}
+pub fn get_cached_object<D: Encode + DecodeOwned>(key: &str) -> Result<D, RemoteAccessError> {
+    get_cached_object_db::<D>(key, &borrow_db_checked())
+}
+pub fn get_cached_object_db<D: DecodeOwned>(
+    key: &str,
    db: &Database,
 ) -> Result<D, RemoteAccessError> {
-    let bytes = cacache::read_sync(&db.cache_dir, key).map_err(|e| RemoteAccessError::Cache(e))?;
-    let data = serde_binary::from_slice::<D>(&bytes, Endian::Little).unwrap();
+    let start = SystemTime::now();
+    let bytes = read_sync(&db.cache_dir, key).map_err(RemoteAccessError::Cache)?;
+    let read = start.elapsed().unwrap();
+    let data =
+        bitcode::decode::<D>(&bytes).map_err(|e| RemoteAccessError::Cache(io::Error::other(e)))?;
+    let decode = start.elapsed().unwrap();
+    debug!(
+        "cache object took: r:{}, d:{}, b:{}",
+        read.as_millis(),
+        read.abs_diff(decode).as_millis(),
+        bytes.len()
+    );
    Ok(data)
 }
-#[derive(Serialize, Deserialize)]
+#[derive(Encode, Decode)]
 pub struct ObjectCache {
    content_type: String,
    body: Vec<u8>,
+    expiry: u64,
+}
+
+impl ObjectCache {
+    pub fn has_expired(&self) -> bool {
+        let current = get_sys_time_in_secs();
+        self.expiry < current
+    }
 }

 impl From<Response<Vec<u8>>> for ObjectCache {
@ -60,6 +100,7 @@ impl From<Response<Vec<u8>>> for ObjectCache {
                .unwrap()
                .to_owned(),
            body: value.body().clone(),
+            expiry: get_sys_time_in_secs() + 60 * 60 * 24,
        }
    }
 }
@ -69,3 +110,9 @@ impl From<ObjectCache> for Response<Vec<u8>> {
        resp_builder.body(value.body).unwrap()
    }
 }
+impl From<&ObjectCache> for Response<Vec<u8>> {
+    fn from(value: &ObjectCache) -> Self {
+        let resp_builder = ResponseBuilder::new().header(CONTENT_TYPE, value.content_type.clone());
+        resp_builder.body(value.body.clone()).unwrap()
+    }
+}
--- a/src-tauri/src/remote/commands.rs
+++ b/src-tauri/src/remote/commands.rs
@ -1,16 +1,20 @@
 use std::sync::Mutex;

-use log::debug;
-use reqwest::blocking::Client;
+use futures_lite::StreamExt;
+use log::{debug, warn};
+use reqwest_websocket::{Message, RequestBuilderExt};
+use serde::Deserialize;
 use tauri::{AppHandle, Emitter, Manager};
 use url::Url;

 use crate::{
-    database::db::{borrow_db_checked, borrow_db_mut_checked, save_db}, error::remote_access_error::RemoteAccessError, remote::{auth::generate_authorization_header, requests::make_request}, AppState, AppStatus
+    database::db::{borrow_db_checked, borrow_db_mut_checked}, error::remote_access_error::RemoteAccessError, remote::{auth::generate_authorization_header, requests::make_request, utils::DROP_CLIENT_SYNC}, AppState, AppStatus
 };

 use super::{
-    auth::{auth_initiate_logic, recieve_handshake, setup}, cache::{cache_object, get_cached_object}, remote::use_remote_logic
+    auth::{auth_initiate_logic, recieve_handshake, setup},
+    cache::{cache_object, get_cached_object},
+    utils::use_remote_logic,
 };

 #[tauri::command]
@ -36,24 +40,22 @@ pub fn gen_drop_url(path: String) -> Result<String, RemoteAccessError> {

 #[tauri::command]
 pub fn fetch_drop_object(path: String) -> Result<Vec<u8>, RemoteAccessError> {
-    let drop_url = gen_drop_url(path.clone());
-    let req = make_request(
-        &Client::new(), 
-        &[&path],
-        &[], 
-        |r| { r.header("Authorization", generate_authorization_header()) }
-    )?.send();
+    let _drop_url = gen_drop_url(path.clone())?;
+    let req = make_request(&DROP_CLIENT_SYNC, &[&path], &[], |r| {
+        r.header("Authorization", generate_authorization_header())
+    })?
+    .send();

    match req {
        Ok(data) => {
            let data = data.bytes()?.to_vec();
            cache_object(&path, &data)?;
            Ok(data)
-        },
+        }
        Err(e) => {
-            debug!("{}", e);
-            get_cached_object::<&str, Vec<u8>>(&path)
-        },
+            debug!("{e}");
+            get_cached_object::<Vec<u8>>(&path)
+        }
    }
 }
 #[tauri::command]
@ -62,8 +64,6 @@ pub fn sign_out(app: AppHandle) {
    {
        let mut handle = borrow_db_mut_checked();
        handle.auth = None;
-        drop(handle);
-        save_db();
    }

    // Update app state
@ -90,10 +90,81 @@ pub fn retry_connect(state: tauri::State<'_, Mutex<AppState>>) {

 #[tauri::command]
 pub fn auth_initiate() -> Result<(), RemoteAccessError> {
-    auth_initiate_logic()
+    let base_url = {
+        let db_lock = borrow_db_checked();
+        Url::parse(&db_lock.base_url.clone())?
+    };
+
+    let redir_url = auth_initiate_logic("callback".to_string())?;
+    let complete_redir_url = base_url.join(&redir_url)?;
+
+    debug!("opening web browser to continue authentication");
+    webbrowser::open(complete_redir_url.as_ref()).unwrap();
+    Ok(())
+}
+
+#[derive(Deserialize)]
+struct CodeWebsocketResponse {
+    #[serde(rename = "type")]
+    response_type: String,
+    value: String,
+}
+
+#[tauri::command]
+pub fn auth_initiate_code(app: AppHandle) -> Result<String, RemoteAccessError> {
+    let base_url = {
+        let db_lock = borrow_db_checked();
+        Url::parse(&db_lock.base_url.clone())?
+    };
+
+    let code = auth_initiate_logic("code".to_string())?;
+    let header_code = code.clone();
+
+    tauri::async_runtime::spawn(async move {
+        let load = async || -> Result<(), RemoteAccessError> {
+            let ws_url = base_url.join("/api/v1/client/auth/code/ws")?;
+            let response = reqwest::Client::default()
+                .get(ws_url)
+                .header("Authorization", header_code)
+                .upgrade()
+                .send()
+                .await?;
+
+            let mut websocket = response.into_websocket().await?;
+
+            while let Some(token) = websocket.try_next().await? {
+                if let Message::Text(response) = token {
+                    let response = serde_json::from_str::<CodeWebsocketResponse>(&response)
+                        .map_err(|e| RemoteAccessError::UnparseableResponse(e.to_string()))?;
+                    match response.response_type.as_str() {
+                        "token" => {
+                            let recieve_app = app.clone();
+                            tauri::async_runtime::spawn_blocking(move || {
+                                manual_recieve_handshake(recieve_app, response.value);
+                            });
+                            return Ok(());
+                        }
+                        _ => return Err(RemoteAccessError::HandshakeFailed(response.value)),
+                    }
+                }
+            }
+
+            Err(RemoteAccessError::HandshakeFailed(
+                "Failed to connect to websocket".to_string(),
+            ))
+        };
+
+        let result = load().await;
+        if let Err(err) = result {
+            warn!("{err}");
+            app.emit("auth/failed", err.to_string()).unwrap();
+        }
+    });
+
+    Ok(code)
 }

 #[tauri::command]
 pub fn manual_recieve_handshake(app: AppHandle, token: String) {
-    recieve_handshake(app, format!("handshake/{}", token));
+    recieve_handshake(app, format!("handshake/{token}"));
 }
--- a/src-tauri/src/remote/fetch_object.rs
+++ b/src-tauri/src/remote/fetch_object.rs
@ -2,30 +2,36 @@ use http::{header::CONTENT_TYPE, response::Builder as ResponseBuilder};
 use log::warn;
 use tauri::UriSchemeResponder;

-use super::{auth::generate_authorization_header, cache::{cache_object, get_cached_object, ObjectCache}, requests::make_request};
+use crate::{database::db::DatabaseImpls, remote::utils::DROP_CLIENT_ASYNC, DB};

-pub fn fetch_object(
-    request: http::Request<Vec<u8>>,
-    responder: UriSchemeResponder,
-) {
+use super::{
+    auth::generate_authorization_header,
+    cache::{ObjectCache, cache_object, get_cached_object},
+};
+
+pub async fn fetch_object(request: http::Request<Vec<u8>>, responder: UriSchemeResponder) {
    // Drop leading /
    let object_id = &request.uri().path()[1..];

-    let header = generate_authorization_header();
-    let client: reqwest::blocking::Client = reqwest::blocking::Client::new();
-    let response = make_request(&client, &["/api/v1/client/object/", object_id], &[], |f| {
-        f.header("Authorization", header)
-    })
-    .unwrap()
-    .send();
-    if response.is_err() {
-        let data = get_cached_object::<&str, ObjectCache>(object_id);
+    let cache_result = get_cached_object::<ObjectCache>(object_id);
+    if let Ok(cache_result) = &cache_result
+        && !cache_result.has_expired()
+    {
+        responder.respond(cache_result.into());
+        return;
+    }

-        match data {
-            Ok(data) => responder.respond(data.into()),
+    let header = generate_authorization_header();
+    let client = DROP_CLIENT_ASYNC.clone();
+    let url = format!("{}api/v1/client/object/{object_id}", DB.fetch_base_url());
+    let response = client.get(url).header("Authorization", header).send().await;
+
+    if response.is_err() {
+        match cache_result {
+            Ok(cache_result) => responder.respond(cache_result.into()),
            Err(e) => {
-                warn!("{}", e)
-            },
+                warn!("{e}");
+            }
        }
        return;
    }
@ -35,21 +41,11 @@ pub fn fetch_object(
        CONTENT_TYPE,
        response.headers().get("Content-Type").unwrap(),
    );
-    let data = Vec::from(response.bytes().unwrap());
+    let data = Vec::from(response.bytes().await.unwrap());
    let resp = resp_builder.body(data).unwrap();
-    cache_object::<&str, ObjectCache>(object_id, &resp.clone().into()).unwrap();
+    if cache_result.is_err() || cache_result.unwrap().has_expired() {
+        cache_object::<ObjectCache>(object_id, &resp.clone().into()).unwrap();
+    }

    responder.respond(resp);
 }
-pub fn fetch_object_offline(
-    request: http::Request<Vec<u8>>,
-    responder: UriSchemeResponder,
-) {
-    let object_id = &request.uri().path()[1..];
-    let data = get_cached_object::<&str, ObjectCache>(object_id);
-
-    match data {
-        Ok(data) => responder.respond(data.into()),
-        Err(e) => warn!("{}", e),
-    }
-}
--- a/src-tauri/src/remote/mod.rs
+++ b/src-tauri/src/remote/mod.rs
@ -3,6 +3,6 @@ pub mod auth;
 pub mod cache;
 pub mod commands;
 pub mod fetch_object;
-pub mod remote;
 pub mod requests;
-pub mod server_proto;
+pub mod server_proto;
+pub mod utils;
--- a/src-tauri/src/remote/remote.rs
+++ b/src-tauri/src/remote/remote.rs
@ -1,48 +0,0 @@
-use std::sync::Mutex;
-
-use log::{debug, warn};
-use serde::Deserialize;
-use url::Url;
-
-use crate::{
-    database::db::{borrow_db_mut_checked, save_db},
-    error::remote_access_error::RemoteAccessError,
-    AppState, AppStatus,
-};
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct DropHealthcheck {
-    app_name: String,
-}
-
-pub fn use_remote_logic(
-    url: String,
-    state: tauri::State<'_, Mutex<AppState<'_>>>,
-) -> Result<(), RemoteAccessError> {
-    debug!("connecting to url {}", url);
-    let base_url = Url::parse(&url)?;
-
-    // Test Drop url
-    let test_endpoint = base_url.join("/api/v1")?;
-    let response = reqwest::blocking::get(test_endpoint.to_string())?;
-
-    let result: DropHealthcheck = response.json()?;
-
-    if result.app_name != "Drop" {
-        warn!("user entered drop endpoint that connected, but wasn't identified as Drop");
-        return Err(RemoteAccessError::InvalidEndpoint);
-    }
-
-    let mut app_state = state.lock().unwrap();
-    app_state.status = AppStatus::SignedOut;
-    drop(app_state);
-
-    let mut db_state = borrow_db_mut_checked();
-    db_state.base_url = base_url.to_string();
-    drop(db_state);
-
-    save_db();
-
-    Ok(())
-}
--- a/src-tauri/src/remote/server_proto.rs
+++ b/src-tauri/src/remote/server_proto.rs
@ -1,14 +1,9 @@
-use std::{path::PathBuf, str::FromStr};
+use std::str::FromStr;

-use http::{
-    uri::{Authority, PathAndQuery},
-    Request, Response, StatusCode, Uri,
-};
-use log::info;
-use reqwest::blocking::Client;
+use http::{uri::PathAndQuery, Request, Response, StatusCode, Uri};
 use tauri::UriSchemeResponder;

-use crate::database::db::borrow_db_checked;
+use crate::{database::db::borrow_db_checked, remote::utils::DROP_CLIENT_SYNC};

 pub fn handle_server_proto_offline(_request: Request<Vec<u8>>, responder: UriSchemeResponder) {
    let four_oh_four = Response::builder()
@ -30,26 +25,22 @@ pub fn handle_server_proto(request: Request<Vec<u8>>, responder: UriSchemeRespon

    let mut new_uri = request.uri().clone().into_parts();
    new_uri.path_and_query =
-        Some(PathAndQuery::from_str(&format!("{}?noWrapper=true", path)).unwrap());
+        Some(PathAndQuery::from_str(&format!("{path}?noWrapper=true")).unwrap());
    new_uri.authority = remote_uri.authority().cloned();
    new_uri.scheme = remote_uri.scheme().cloned();
    let new_uri = Uri::from_parts(new_uri).unwrap();

-    let whitelist_prefix = vec!["/store", "/api", "/_", "/fonts"];
+    let whitelist_prefix = ["/store", "/api", "/_", "/fonts"];

-    if whitelist_prefix
-        .iter()
-        .map(|f| !path.starts_with(f))
-        .all(|f| f)
-    {
+    if whitelist_prefix.iter().all(|f| !path.starts_with(f)) {
        webbrowser::open(&new_uri.to_string()).unwrap();
        return;
    }

-    let client = Client::new();
+    let client = DROP_CLIENT_SYNC.clone();
    let response = client
        .request(request.method().clone(), new_uri.to_string())
-        .header("Authorization", format!("Bearer {}", web_token))
+        .header("Authorization", format!("Bearer {web_token}"))
        .headers(request.headers().clone())
        .send()
        .unwrap();
--- a/src-tauri/src/remote/utils.rs
+++ b/src-tauri/src/remote/utils.rs
@ -0,0 +1,105 @@
+use std::{
+    fs::{self, File},
+    io::Read,
+    sync::{LazyLock, Mutex},
+};
+
+use log::{debug, info, warn};
+use reqwest::Certificate;
+use serde::Deserialize;
+use url::Url;
+
+use crate::{
+    AppState, AppStatus,
+    database::db::{DATA_ROOT_DIR, borrow_db_mut_checked},
+    error::remote_access_error::RemoteAccessError,
+};
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DropHealthcheck {
+    app_name: String,
+}
+
+pub static DROP_CLIENT_SYNC: LazyLock<reqwest::blocking::Client> = LazyLock::new(get_client_sync);
+pub static DROP_CLIENT_ASYNC: LazyLock<reqwest::Client> = LazyLock::new(get_client_async);
+
+fn fetch_certificates() -> Vec<Certificate> {
+    let certificate_dir = DATA_ROOT_DIR.join("certificates");
+
+    let mut certs = Vec::new();
+    match fs::read_dir(certificate_dir) {
+        Ok(c) => {
+            for entry in c {
+                match entry {
+                    Ok(c) => {
+                        let mut buf = Vec::new();
+                        File::open(c.path()).unwrap().read_to_end(&mut buf).unwrap();
+
+                        for cert in Certificate::from_pem_bundle(&buf).unwrap() {
+                            certs.push(cert);
+                        }
+                        info!(
+                            "added {} certificate(s) from {}",
+                            certs.len(),
+                            c.file_name().into_string().unwrap()
+                        );
+                    }
+                    Err(_) => todo!(),
+                }
+            }
+        }
+        Err(e) => {
+            debug!("not loading certificates due to error: {e}");
+        }
+    };
+    certs
+}
+
+pub fn get_client_sync() -> reqwest::blocking::Client {
+    let mut client = reqwest::blocking::ClientBuilder::new();
+    
+    let certs = fetch_certificates();
+    for cert in certs {
+        client = client.add_root_certificate(cert);
+    }
+    client.build().unwrap()
+}
+pub fn get_client_async() -> reqwest::Client {
+    let mut client = reqwest::ClientBuilder::new();
+
+    let certs = fetch_certificates();
+    for cert in certs {
+        client = client.add_root_certificate(cert);
+    }
+    client.build().unwrap()
+}
+
+pub fn use_remote_logic(
+    url: String,
+    state: tauri::State<'_, Mutex<AppState<'_>>>,
+) -> Result<(), RemoteAccessError> {
+    debug!("connecting to url {url}");
+    let base_url = Url::parse(&url)?;
+
+    // Test Drop url
+    let test_endpoint = base_url.join("/api/v1")?;
+    let client = DROP_CLIENT_SYNC.clone();
+    let response = client.get(test_endpoint.to_string()).send()?;
+
+    let result: DropHealthcheck = response.json()?;
+
+    if result.app_name != "Drop" {
+        warn!("user entered drop endpoint that connected, but wasn't identified as Drop");
+        return Err(RemoteAccessError::InvalidEndpoint);
+    }
+
+    let mut app_state = state.lock().unwrap();
+    app_state.status = AppStatus::SignedOut;
+    drop(app_state);
+
+    let mut db_state = borrow_db_mut_checked();
+    db_state.base_url = base_url.to_string();
+
+    Ok(())
+}
--- a/src-tauri/tailscale/.gitignore
+++ b/src-tauri/tailscale/.gitignore
@ -0,0 +1,7 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+
+# Generated by Tauri
+# will have schema files for capabilities auto-completion
+/gen/schemas
--- a/src-tauri/tailscale/Cargo.lock
+++ b/src-tauri/tailscale/Cargo.lock
@ -0,0 +1,294 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "abs-file-macro"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3909701959b9fcb4d065c3cf3044fe77f6b07a85d748be4630f5214e8d7acc1"
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.71.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
+dependencies = [
+ "bitflags",
+ "cexpr",
+ "clang-sys",
+ "itertools",
+ "log",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "clang-sys"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "glob"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
+
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.172"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
+
+[[package]]
+name = "libloading"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a793df0d7afeac54f95b471d3af7f0d4fb975699f972341a4b76988d49cdf0c"
+dependencies = [
+ "cfg-if",
+ "windows-targets",
+]
+
+[[package]]
+name = "log"
+version = "0.4.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "664ec5419c51e34154eec046ebcba56312d5a2fc3b09a06da188e1ad21afadf6"
+dependencies = [
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "regex"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "syn"
+version = "2.0.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tailscale"
+version = "0.1.0"
+dependencies = [
+ "abs-file-macro",
+ "bindgen",
+ "libc",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+
+[[package]]
+name = "windows-targets"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1e4c7e8ceaaf9cb7d7507c974735728ab453b67ef8f18febdd7c11fe59dca8b"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
--- a/src-tauri/tailscale/Cargo.toml
+++ b/src-tauri/tailscale/Cargo.toml
@ -0,0 +1,11 @@
+[package]
+name = "tailscale"
+version = "0.1.0"
+edition = "2024"
+
+[build-dependencies]
+bindgen = "*"
+abs-file-macro = "0.1.2"
+
+[dependencies]
+libc = "0.2.172"
--- a/src-tauri/tailscale/build.rs
+++ b/src-tauri/tailscale/build.rs
@ -0,0 +1,36 @@
+extern crate bindgen;
+
+use abs_file_macro::abs_file;
+use std::path::PathBuf;
+use std::process::Command;
+
+fn main() {
+    let build_folder = PathBuf::from(abs_file!());
+    let build_folder = build_folder.parent().unwrap();
+
+    let in_path = build_folder.join("libtailscale");
+    let out_path = build_folder.join("src/");
+
+    let mut make_cmd = Command::new("make");
+    make_cmd.arg("c-archive");
+    make_cmd.current_dir(in_path.clone());
+
+    make_cmd.status().expect("Make build failed");
+
+    let bindings = bindgen::Builder::default()
+        .header(in_path.join("libtailscale.h").to_str().unwrap())
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .generate()
+        .expect("Unable to generate bindings");
+
+    bindings
+        .write_to_file(out_path.join("bindings.rs"))
+        .expect("Couldn't write bindings!");
+
+    println!("cargo:rerun-if-changed=libtailscale/tailscale.go");
+    println!(
+        "cargo:rustc-link-search=native={}",
+        in_path.to_str().unwrap()
+    );
+    println!("cargo:rustc-link-lib=static={}", "tailscale");
+}
--- a/src-tauri/tailscale/libtailscale
+++ b/src-tauri/tailscale/libtailscale
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
DecDuck	f1bc7bf418	fix: update all versions to -mac specific	2025-08-02 12:02:34 +10:00
DecDuck	cb2295dd7c	feat: add macos signing args	2025-08-02 12:00:25 +10:00
DecDuck	cc5339a389	Reqwest optionally load certificates from disk (#94 ) * feat: Add get_client function Signed-off-by: quexeky <git@quexeky.dev> * chore: Converted all instances of reqwest::blocking::Client::new() and reqwest::Client::new() to DROP_CLIENT_SYNC and DROP_CLIENT_ASYNC respectively Signed-off-by: quexeky <git@quexeky.dev> * fix: use_remote_logic not using certificates Signed-off-by: quexeky <git@quexeky.dev> * fix: add log statement to certificates * chore: add more logging * fix: clippy * refactor: into single fetch_certificates func --------- Signed-off-by: quexeky <git@quexeky.dev> Co-authored-by: quexeky <git@quexeky.dev>	2025-08-02 11:59:50 +10:00
DecDuck	6104bfda72	Bump version to v0.3.1 (#85 )	2025-08-01 14:13:13 +10:00
DecDuck	be688cb18f	Version bump: v0.3.0	2025-08-01 14:09:16 +10:00
DecDuck	13cc69f10e	Device code authorization (#83 ) * feat: device code authorization * Fix for setup executable unable to be launched (#81) * Fix for redownload invalid chunks (#84) * feat: Redownloading invalid chunks Signed-off-by: quexeky <git@quexeky.dev> * fix: clippy * fix: clippy x2 --------- Signed-off-by: quexeky <git@quexeky.dev> Co-authored-by: quexeky <git@quexeky.dev> * chore: Run clippy fix pedantic Signed-off-by: quexeky <git@quexeky.dev> * feat: add better error handling * fix: clippy --------- Signed-off-by: quexeky <git@quexeky.dev> Co-authored-by: quexeky <git@quexeky.dev>	2025-08-01 13:12:05 +10:00
quexeky	574782f445	chore: Run clippy fix pedantic Signed-off-by: quexeky <git@quexeky.dev>	2025-08-01 08:42:45 +10:00
DecDuck	b5a8543194	Fix for redownload invalid chunks (#84 ) * feat: Redownloading invalid chunks Signed-off-by: quexeky <git@quexeky.dev> * fix: clippy * fix: clippy x2 --------- Signed-off-by: quexeky <git@quexeky.dev> Co-authored-by: quexeky <git@quexeky.dev>	2025-07-31 18:25:38 +10:00
DecDuck	d0e4aea5ce	Fix for setup executable unable to be launched (#81 )	2025-07-30 09:57:07 +10:00
DecDuck	739e6166c5	Cache-first object fetching (#76 ) * fix: submillisecond cache hits * fix: async object loading to hand control back to renderer * fix: clippy	2025-07-27 12:04:50 +10:00
DecDuck	682c6e9c0b	Bump version to v0.3.0-rc-8 (#74 )	2025-07-25 22:21:59 +10:00
DecDuck	46e1f16cdd	Process manager fixes (#71 ) * fix: launching on linux * feat: #70 * feat: add dummy store page * feat: add store redir and refresh button to library * feat: cache first object fetching * feat: Remove let_chains feature and update to Rust 2024 Signed-off-by: quexeky <git@quexeky.dev> * feat: Check for if process was manually stopped Signed-off-by: quexeky <git@quexeky.dev> * fix: use bitcode instead of serde * chore: remove logs * fix: clippy * fix: clippy 2 * fix: swap to stop icon --------- Signed-off-by: quexeky <git@quexeky.dev> Co-authored-by: quexeky <git@quexeky.dev>	2025-07-25 10:44:40 +10:00
DecDuck	d19f9bbc31	Fix client running behind reverse proxy (#69 ) * fix: reverse proxy 400 due to duplicate header * fix: clippy * bump version and update ci	2025-07-18 20:08:12 +10:00
DecDuck	2913fdf35b	Release v0.3.0-rc-6 (#68 )	2025-07-18 17:38:36 +10:00
DecDuck	f9fdf151ea	Clippy CI/CD (#67 ) * feat: add clippy ci * fix: clippy errors * fix: ci/cd * fix: update ci packages * fix: add gtk3 to ci deps * fix: add webkit to ci deps * fix: ci deps and perms * fix: add clippy settings to lib.rs	2025-07-18 17:36:04 +10:00
DecDuck	495d93705e	Panic hook to generate crash dumps #65 (#66 )	2025-07-18 16:35:02 +10:00
DecDuck	c477dd4872	Fix windows build by removing linux extension import (#64 )	2025-07-14 16:43:11 +10:00
DecDuck	f560a62c8f	Download fixes (#63 ) * refactor: Rename StoredManifest to DropData Signed-off-by: quexeky <git@quexeky.dev> * fix: Downloads when resuming would truncate files which had not been finished Signed-off-by: quexeky <git@quexeky.dev> * chore: Didn't import debug macro Signed-off-by: quexeky <git@quexeky.dev> * fix: Download chunks with wrong indexes Migrated to using checksums as indexes instead Signed-off-by: quexeky <git@quexeky.dev> * feat: Resume download button Also added DBWrite and DBRead structs to make database management easier Signed-off-by: quexeky <git@quexeky.dev> * feat: Download resuming Signed-off-by: quexeky <git@quexeky.dev> * feat: Resume button and PartiallyInstalled status Signed-off-by: quexeky <git@quexeky.dev> * feat: Download validation Signed-off-by: quexeky <git@quexeky.dev> * chore: Ran cargo fix & cargo fmt Signed-off-by: quexeky <git@quexeky.dev> * fix: download validation, installs, etc * chore: version bump --------- Signed-off-by: quexeky <git@quexeky.dev> Co-authored-by: quexeky <git@quexeky.dev>	2025-07-14 16:31:06 +10:00
quexeky	2874b9776b	fix: Accidentally moved request when setting the header Signed-off-by: quexeky <git@quexeky.dev>	2025-06-25 09:17:06 +10:00
DecDuck	afcd4e916f	chore: bump version to 0.3.0-rc-4	2025-06-25 09:05:08 +10:00
quexeky	885fa42ecc	fix: Move Authorization header generation to download_game_chunk() Signed-off-by: quexeky <git@quexeky.dev>	2025-06-25 06:53:42 +10:00
quexeky	6d295bd47f	fix: Broken README path Signed-off-by: quexeky <git@quexeky.dev>	2025-06-07 06:37:14 +10:00
quexeky	c3ee09af85	fix: Update broken README link in docs Signed-off-by: quexeky <git@quexeky.dev>	2025-06-07 06:35:57 +10:00
quexeky	0ce55e12c5	fix: Re-update the user and app status when recieve_handshake is called (#54 ) Also enabled assetProtocol for better caching in general Signed-off-by: quexeky <git@quexeky.dev>	2025-06-06 12:09:44 +10:00
DecDuck	86bce1c68d	Release: v0.3.0-rc-3 (#51 )	2025-06-06 09:25:44 +10:00
quexeky	924e4e334c	Database not being properly serialised with rpm_serde (#48 ) Signed-off-by: quexeky <git@quexeky.dev>	2025-06-05 17:22:22 +10:00
DecDuck	065eb2356a	fix: database corrupted on every startup (#40 )	2025-06-01 19:53:24 +10:00
DecDuck	689e9ad890	fix: add new dependencies to linux build	2025-05-28 20:51:32 +10:00
quexeky	7c35ed73aa	fix: Folders can now be copied too Signed-off-by: quexeky <git@quexeky.dev>	2025-05-28 20:48:34 +10:00
quexeky	8f261a5dac	chore: Add extract() function Signed-off-by: quexeky <git@quexeky.dev>	2025-05-28 20:48:34 +10:00
quexeky	67b6f2aa2e	chore: Initial path normalisation & parsing with backup generation Signed-off-by: quexeky <git@quexeky.dev>	2025-05-28 20:47:43 +10:00
DecDuck	11e2b3fe8a	fix: regenerate lockfile	2025-05-28 20:37:26 +10:00
DecDuck	eba224f998	fix: remove memd-exec dependency	2025-05-28 20:22:18 +10:00
DecDuck	d045385a5d	build: 0.3.0-rc-2	2025-05-28 20:09:58 +10:00
quexeky	d878806ade	Merge branch 'compat' into develop Signed-off-by: quexeky <git@quexeky.dev>	2025-05-28 11:24:30 +10:00
quexeky	b71081006e	refactor: Reorganise file structure Signed-off-by: quexeky <git@quexeky.dev>	2025-05-28 11:19:48 +10:00
quexeky	c9e1ed78eb	refactor: Delete downloadable_metadata.rs Signed-off-by: quexeky <git@quexeky.dev>	2025-05-28 09:18:33 +10:00
DecDuck	446aa70b0b	inprogress: compat	2025-05-28 09:07:09 +10:00
quexeky	1d0b81078a	feat: Add "NO_TRAY_ICON" env option Signed-off-by: quexeky <git@quexeky.dev>	2025-05-27 12:13:49 +10:00
DecDuck	5251a56c3c	feat: add arm linux builds	2025-05-25 11:46:24 +10:00
quexeky	eeca8a7a98	chore(tailscale): Add test Signed-off-by: quexeky <git@quexeky.dev>	2025-05-16 15:01:50 +10:00
quexeky	365cdaf311	feat(tailscale): Add TailscaleListener and TailscaleConn Needs testing on a native windows machine Signed-off-by: quexeky <git@quexeky.dev>	2025-05-16 12:57:11 +10:00
DecDuck	2957773179	fix: remove reqwest default-features to compile without openssl	2025-05-15 21:03:31 +10:00
DecDuck	15e5fe4dc0	fix: move to reqwest rustls	2025-05-15 20:58:48 +10:00
DecDuck	2dc0a78354	fix: update cargo lock	2025-05-15 20:53:04 +10:00
DecDuck	51c480f245	feat: inline capability registration	2025-05-15 16:05:34 +10:00
quexeky	95d223e2b2	feat(tailscale): Add wrapper around libtailscale with Tailscale struct Signed-off-by: quexeky <git@quexeky.dev>	2025-05-15 15:23:20 +10:00
DecDuck	790e8c2afe	feat: move to native_model to allow for database upgrades	2025-05-15 10:13:24 +10:00
DecDuck	02edb2cbc1	chore: libtailscale rust build	2025-05-14 10:01:26 +10:00
DecDuck	4b4c0734ec	fix: windows builds	2025-05-10 16:41:37 +10:00
DecDuck	e75e0044fb	fix: windows launching	2025-05-10 15:38:20 +10:00
DecDuck	65561abdab	fix: update object id paths for new server	2025-05-10 15:25:40 +10:00
DecDuck	fed3e08dce	fix: re-add minimise button	2025-05-10 14:22:21 +10:00
DecDuck	b0b1e397b1	fix: install dir flow	2025-05-10 09:02:59 +10:00