Merge branch 'develop' into bigpicturemode

* chore: Major refactoring

Still needs a massive go-over because there shouldn't be anything referencing tauri in any of the workspaces except the original one. Process manager has been refactored as an example

Signed-off-by: quexeky <git@quexeky.dev>

* fix: Remote tauri dependency from process

Signed-off-by: quexeky <git@quexeky.dev>

* refactor: Improvements to src-tauri

Signed-off-by: quexeky <git@quexeky.dev>

* refactor: Builds, but some logic still left to move back

Signed-off-by: quexeky <git@quexeky.dev>

* refactor: Finish refactor

Signed-off-by: quexeky <git@quexeky.dev>

* chore: Run cargo clippy && cargo fmt

Signed-off-by: quexeky <git@quexeky.dev>

* refactor: Move everything into src-tauri

Signed-off-by: quexeky <git@quexeky.dev>

---------

Signed-off-by: quexeky <git@quexeky.dev>

.github/workflows/release.yml

@@ -51,7 +51,7 @@ jobs:
         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.1-dev libappindicator3-dev librsvg2-dev patchelf
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf xdg-utils
         # webkitgtk 4.0 is for Tauri v1 - webkitgtk 4.1 is for Tauri v2.
 
 
@@ -69,9 +69,9 @@ jobs:
           security set-keychain-settings -t 3600 -u build.keychain
           
           curl https://droposs.org/drop.crt --output drop.pem
-          sudo security authorizationdb write com.apple.trust-settings.admin allow
-          sudo security add-trusted-cert -d -r trustRoot -k build.keychain -p codeSign -u -1 drop.pem
-          sudo security authorizationdb remove com.apple.trust-settings.admin
+          sudo security authorizationdb write com.apple.trust-settings.user allow
+          security add-trusted-cert -r trustRoot -k build.keychain -p codeSign -u -1 drop.pem
+          sudo security authorizationdb remove com.apple.trust-settings.user
 
           security import certificate.p12 -k build.keychain -P "$APPLE_CERTIFICATE_PASSWORD" -T /usr/bin/codesign
           security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k "$KEYCHAIN_PASSWORD" build.keychain

.gitignore

@@ -29,4 +29,6 @@ src-tauri/flamegraph.svg
 src-tauri/perf*
 
 /*.AppImage
-/squashfs-root
+/squashfs-root
+
+/target/

README.md

@@ -1,29 +1,21 @@
-# Drop App
+# Drop Desktop Client
 
-Drop app is the companion app for [Drop](https://github.com/Drop-OSS/drop). It uses a Tauri base with Nuxt 3 + TailwindCSS on top of it, so we can re-use components from the web UI.
+The Drop Desktop Client is the companion app for [Drop](https://github.com/Drop-OSS/drop). It is the official & intended way to download and play games on your Drop server.
 
-## 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 Docs](https://docs.droposs.org/docs/guides/quickstart)
+## Internals
 
-## Current features
-Currently supported are the following features:
-- Signin (with custom server)
-- Database registering & recovery
-- Dynamic library fetching from server
-- Installing & uninstalling games
-- Download progress monitoring
-- Launching / playing games
+It uses a Tauri base with Nuxt 3 + TailwindCSS on top of it, so we can re-use components from the web UI.
 
 ## Development
+Before setting up a development environemnt, be sure that you have a server set up. The instructions for this can be found on the [Drop Docs](https://docs.droposs.org/docs/guides/quickstart).
 
-Install dependencies with `yarn`
+Then, install dependencies with `yarn`. This'll install the custom builder's dependencies. Then, check everything works properly with `yarn tauri build`. 
 
-Run the app in development with `yarn tauri dev`. NVIDIA users on Linux, use shell script `./nvidia-prop-dev.sh`
+Run the app in development with `yarn tauri dev`. NVIDIA users on Linux, use shell script `./nvidia-prop-dev.sh`
 
 To manually specify the logging level, add the environment variable `RUST_LOG=[debug, info, warn, error]` to `yarn tauri dev`:
 
 e.g. `RUST_LOG=debug yarn tauri dev`
 
 ## Contributing
-Check the original [Drop repo](https://github.com/Drop-OSS/drop/blob/main/CONTRIBUTING.md) for contributing guidelines. 
+Check out the contributing guide on our Developer Docs: [Drop Developer Docs - Contributing](https://developer.droposs.org/contributing).

build.mjs

@@ -21,6 +21,13 @@ async function spawn(exec, opts) {
   });
 }
 
+const expectedLibs = ["drop-base/package.json"];
+
+for (const lib of expectedLibs) {
+  const path = `./libs/${lib}`;
+  if (!fs.existsSync(path)) throw `Missing "${expectedLibs}". Run "git submodule update --init --recursive"`;
+}
+
 const views = fs.readdirSync(".").filter((view) => {
   const expectedPath = `./${view}/package.json`;
   return fs.existsSync(expectedPath);

main/app.vue

@@ -1,5 +1,5 @@
 <template>
-  <LoadingIndicator />
+  <NuxtLoadingIndicator color="#2563eb" />
   <NuxtLayout class="select-none w-screen h-screen">
     <NuxtPage />
     <ModalStack />
@@ -7,14 +7,7 @@
 </template>
 
 <script setup lang="ts">
-import "~/composables/downloads.js";
-
 import { invoke } from "@tauri-apps/api/core";
-import { useAppState } from "./composables/app-state.js";
-import {
-  initialNavigation,
-  setupHooks,
-} from "./composables/state-navigation.js";
 
 const router = useRouter();
 

main/components/Header.vue

@@ -2,9 +2,7 @@
   <div class="h-16 bg-zinc-950 flex flex-row justify-between">
     <div class="flex flex-row grow items-center pl-5 pr-2 py-3">
       <div class="inline-flex items-center gap-x-10">
-        <NuxtLink to="/store">
-          <Wordmark class="h-8 mb-0.5" />
-        </NuxtLink>
+        <Wordmark class="h-8 mb-0.5" />
         <nav class="inline-flex items-center mt-0.5">
           <ol class="inline-flex items-center gap-x-6">
             <NuxtLink
@@ -42,7 +40,7 @@
         </ol>
       </div>
     </div>
-    <WindowControl  />
+    <WindowControl />
   </div>
 </template>
 

main/components/HeaderUserWidget.vue

@@ -37,7 +37,7 @@
           </NuxtLink>
           <div class="h-0.5 rounded-full w-full bg-zinc-800" />
           <div class="flex flex-col mb-1">
-            <MenuItem v-slot="{ active }">
+            <MenuItem v-if="state.user.admin" v-slot="{ active }">
               <a
                 :href="adminUrl"
                 target="_blank"
@@ -76,7 +76,6 @@ import { Menu, MenuButton, MenuItem, MenuItems } from "@headlessui/vue";
 import { ChevronDownIcon } from "@heroicons/vue/16/solid";
 import type { NavigationItem } from "../types";
 import HeaderWidget from "./HeaderWidget.vue";
-import { useAppState } from "~/composables/app-state";
 import { invoke } from "@tauri-apps/api/core";
 
 const open = ref(false);

main/components/LibrarySearch.vue

@@ -1,5 +1,5 @@
 <template>
-  <div>
+  <div class="flex flex-col h-full">
     <div class="mb-3 inline-flex gap-x-2">
       <div
         class="relative transition-transform duration-300 hover:scale-105 active:scale-95"
@@ -20,7 +20,7 @@
         />
       </div>
       <button
-        @click="() => calculateGames(true)"
+        @click="() => calculateGames(true, 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" />
@@ -28,64 +28,125 @@
     </div>
 
     <TransitionGroup name="list" tag="ul" class="flex flex-col gap-y-1.5">
-      <NuxtLink
-        v-for="nav in filteredNavigation"
+      <Disclosure
+        as="div"
+        v-for="(nav, navIndex) in filteredNavigation"
         :key="nav.id"
-        :class="[
-          'transition-all duration-300 rounded-lg flex items-center py-2 px-3 hover:scale-105 active:scale-95 hover:shadow-lg hover:shadow-zinc-950/50',
-          nav.index === currentNavigation
-            ? 'bg-zinc-800 text-zinc-100 shadow-md shadow-zinc-950/20'
-            : nav.isInstalled.value
-            ? 'text-zinc-300 hover:bg-zinc-800/90 hover:text-zinc-200'
-            : 'text-zinc-500 hover:bg-zinc-800/70 hover:text-zinc-300',
-        ]"
-        :href="nav.route"
+        class="first:pt-0 last:pb-0"
+        v-slot="{ open }"
+        :default-open="nav.deft"
       >
-        <div class="flex items-center w-full gap-x-3">
-          <div
-            class="flex-none transition-transform duration-300 hover:-rotate-2"
+        <dt>
+          <DisclosureButton
+            class="flex w-full items-center justify-between text-left text-gray-900 dark:text-white"
           >
-            <img
-              class="size-8 object-cover bg-zinc-900 rounded-lg transition-all duration-300 shadow-sm"
-              :src="icons[nav.id]"
-              alt=""
-            />
-          </div>
-          <div class="flex flex-col flex-1">
-            <p
-              class="truncate text-xs font-display leading-5 flex-1 font-semibold"
-            >
-              {{ nav.label }}
-            </p>
-            <p
-              class="text-xs font-medium"
-              :class="[gameStatusTextStyle[games[nav.id].status.value.type]]"
-            >
-              {{ gameStatusText[games[nav.id].status.value.type] }}
-            </p>
-          </div>
-        </div>
-      </NuxtLink>
+            <span class="text-sm font-semibold font-display">{{
+              nav.name
+            }}</span>
+            <span class="ml-6 flex h-7 items-center">
+              <PlusSmallIcon v-if="!open" class="size-6" aria-hidden="true" />
+              <MinusSmallIcon v-else class="size-6" aria-hidden="true" />
+            </span>
+          </DisclosureButton>
+        </dt>
+        <DisclosurePanel as="dd" class="mt-2 flex flex-col gap-y-1.5">
+          <NuxtLink
+            v-for="item in nav.items"
+            :key="nav.id"
+            :class="[
+              'transition-all duration-300 rounded-lg flex items-center px-1 py-1.5 hover:scale-105 active:scale-95 hover:shadow-lg hover:shadow-zinc-950/50',
+              currentNavigation == item.id
+                ? 'bg-zinc-800 text-zinc-100 shadow-md shadow-zinc-950/20'
+                : item.isInstalled.value
+                ? 'text-zinc-300 hover:bg-zinc-800/90 hover:text-zinc-200'
+                : 'text-zinc-500 hover:bg-zinc-800/70 hover:text-zinc-300',
+            ]"
+            :href="item.route"
+          >
+            <div class="flex items-center w-full gap-x-2">
+              <div
+                class="flex-none transition-transform duration-300 hover:-rotate-2"
+              >
+                <img
+                  class="size-6 object-cover bg-zinc-900 rounded transition-all duration-300 shadow-sm"
+                  :src="icons[item.id]"
+                  alt=""
+                />
+              </div>
+              <div class="flex flex-col gap-x-2">
+                <p
+                  class="text-sm whitespace-nowrap font-display font-semibold"
+                >
+                  {{ item.label }}
+                </p>
+                <p
+                  class="truncate text-[10px] font-bold uppercase font-display"
+                  :class="[
+                    gameStatusTextStyle[games[item.id].status.value.type],
+                  ]"
+                >
+                  {{ gameStatusText[games[item.id].status.value.type] }}
+                </p>
+              </div>
+            </div>
+          </NuxtLink>
+        </DisclosurePanel>
+      </Disclosure>
     </TransitionGroup>
+    <div
+      v-if="loading"
+      class="h-full grow flex p-8 justify-center text-zinc-100"
+    >
+      <div role="status">
+        <svg
+          aria-hidden="true"
+          class="w-6 h-6 text-transparent animate-spin fill-zinc-600"
+          viewBox="0 0 100 101"
+          fill="none"
+          xmlns="http://www.w3.org/2000/svg"
+        >
+          <path
+            d="M100 50.5908C100 78.2051 77.6142 100.591 50 100.591C22.3858 100.591 0 78.2051 0 50.5908C0 22.9766 22.3858 0.59082 50 0.59082C77.6142 0.59082 100 22.9766 100 50.5908ZM9.08144 50.5908C9.08144 73.1895 27.4013 91.5094 50 91.5094C72.5987 91.5094 90.9186 73.1895 90.9186 50.5908C90.9186 27.9921 72.5987 9.67226 50 9.67226C27.4013 9.67226 9.08144 27.9921 9.08144 50.5908Z"
+            fill="currentColor"
+          />
+          <path
+            d="M93.9676 39.0409C96.393 38.4038 97.8624 35.9116 97.0079 33.5539C95.2932 28.8227 92.871 24.3692 89.8167 20.348C85.8452 15.1192 80.8826 10.7238 75.2124 7.41289C69.5422 4.10194 63.2754 1.94025 56.7698 1.05124C51.7666 0.367541 46.6976 0.446843 41.7345 1.27873C39.2613 1.69328 37.813 4.19778 38.4501 6.62326C39.0873 9.04874 41.5694 10.4717 44.0505 10.1071C47.8511 9.54855 51.7191 9.52689 55.5402 10.0491C60.8642 10.7766 65.9928 12.5457 70.6331 15.2552C75.2735 17.9648 79.3347 21.5619 82.5849 25.841C84.9175 28.9121 86.7997 32.2913 88.1811 35.8758C89.083 38.2158 91.5421 39.6781 93.9676 39.0409Z"
+            fill="currentFill"
+          />
+        </svg>
+        <span class="sr-only">Loading...</span>
+      </div>
+    </div>
   </div>
 </template>
 
 <script setup lang="ts">
-import { ArrowPathIcon, MagnifyingGlassIcon } from "@heroicons/vue/20/solid";
+import { Disclosure, DisclosureButton, DisclosurePanel } from "@headlessui/vue";
+import {
+  ArrowPathIcon,
+  MagnifyingGlassIcon,
+  MinusSmallIcon,
+  PlusSmallIcon,
+} from "@heroicons/vue/20/solid";
 import { invoke } from "@tauri-apps/api/core";
-import { GameStatusEnum, type Game, type GameStatus } from "~/types";
+import {
+  GameStatusEnum,
+  type Collection as Collection,
+  type Game,
+  type GameStatus,
+} from "~/types";
 import { TransitionGroup } from "vue";
 import { listen } from "@tauri-apps/api/event";
 
 // Style information
 const gameStatusTextStyle: { [key in GameStatusEnum]: string } = {
   [GameStatusEnum.Installed]: "text-green-500",
-  [GameStatusEnum.Downloading]: "text-blue-500",
+  [GameStatusEnum.Downloading]: "text-zinc-400",
   [GameStatusEnum.Validating]: "text-blue-300",
   [GameStatusEnum.Running]: "text-green-500",
-  [GameStatusEnum.Remote]: "text-zinc-500",
-  [GameStatusEnum.Queued]: "text-blue-500",
-  [GameStatusEnum.Updating]: "text-blue-500",
+  [GameStatusEnum.Remote]: "text-zinc-700",
+  [GameStatusEnum.Queued]: "text-zinc-400",
+  [GameStatusEnum.Updating]: "text-zinc-400",
   [GameStatusEnum.Uninstalling]: "text-zinc-100",
   [GameStatusEnum.SetupRequired]: "text-yellow-500",
   [GameStatusEnum.PartiallyInstalled]: "text-gray-400",
@@ -107,71 +168,117 @@ const router = useRouter();
 
 const searchQuery = ref("");
 
+const loading = ref(false);
 const games: {
   [key: string]: { game: Game; status: Ref<GameStatus, GameStatus> };
 } = {};
 const icons: { [key: string]: string } = {};
 
-const rawGames: Ref<Game[], Game[]> = ref([]);
+const collections: Ref<Collection[]> = ref([]);
 
-async function calculateGames(clearAll = false) {
-  if (clearAll) rawGames.value = [];
+async function calculateGames(clearAll = false, forceRefresh = false) {
+  if (clearAll) {
+    collections.value = [];
+    loading.value = true;
+  }
   // 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) {
+  const newGames = await invoke<Game[]>("fetch_library", {
+    hardRefresh: forceRefresh,
+  });
+  const otherCollections = await invoke<Collection[]>("fetch_collections", {
+    hardRefresh: forceRefresh,
+  });
+  const allGames = [
+    ...newGames,
+    ...otherCollections
+      .map((e) => e.entries)
+      .flat()
+      .map((e) => e.game),
+  ].filter((v, i, a) => a.indexOf(v) === i);
+
+  for (const game of allGames) {
     if (games[game.id]) continue;
     games[game.id] = await useGame(game.id);
   }
-  for (const game of newGames) {
+  for (const game of allGames) {
     if (icons[game.id]) continue;
     icons[game.id] = await useObject(game.mIconObjectId);
   }
-  rawGames.value = newGames;
+
+  const libraryCollection = {
+    id: "library",
+    name: "Library",
+    isDefault: true,
+    entries: newGames.map((e) => ({ gameId: e.id, game: e })),
+  } satisfies Collection;
+
+  loading.value = false;
+  collections.value = [libraryCollection, ...otherCollections];
 }
 
-await calculateGames();
+// Wait up to 300 ms for the library to load, otherwise
+// show the loading state while we while
+await new Promise<void>((r) => {
+  let hasResolved = false;
+  const resolveFunc = () => {
+    if (!hasResolved) r();
+    hasResolved = true;
+  };
+  calculateGames(true).then(resolveFunc);
+  setTimeout(resolveFunc, 300);
+});
 
 const navigation = computed(() =>
-  rawGames.value.map((game) => {
-    const status = games[game.id].status;
+  collections.value.map((collection) => {
+    const items = collection.entries.map(({ game }) => {
+      const status = games[game.id].status;
 
-    const isInstalled = computed(
-      () =>
-        status.value.type == GameStatusEnum.Installed ||
-        status.value.type == GameStatusEnum.SetupRequired
-    );
+      const isInstalled = computed(
+        () => status.value.type != GameStatusEnum.Remote
+      );
 
-    const item = {
-      label: game.mName,
-      route: `/library/${game.id}`,
-      prefix: `/library/${game.id}`,
-      isInstalled,
-      id: game.id,
+      const item = {
+        label: game.mName,
+        route: `/library/${game.id}`,
+        prefix: `/library/${game.id}`,
+        isInstalled,
+        id: game.id,
+      };
+      return item;
+    });
+
+    return {
+      id: collection.id,
+      name: collection.name,
+      deft: collection.isDefault,
+      items,
     };
-    return item;
   })
 );
-const { currentNavigation, recalculateNavigation } = useCurrentNavigationIndex(
-  navigation.value
-);
+
+const route = useRoute();
+const currentNavigation = computed(() => {
+  return route.path.slice("/library/".length);
+});
 
 const filteredNavigation = computed(() => {
   if (!searchQuery.value)
     return navigation.value.map((e, i) => ({ ...e, index: i }));
   const query = searchQuery.value.toLowerCase();
   return navigation.value
-    .filter((nav) => nav.label.toLowerCase().includes(query))
-    .map((e, i) => ({ ...e, index: i }));
+    .map((c) => ({
+      ...c,
+      items: c.items.filter((nav) => nav.label.toLowerCase().includes(query)),
+    }))
+    .filter((e) => e.items.length > 0);
 });
 
 listen("update_library", async (event) => {
   console.log("Updating library");
-  let oldNavigation = navigation.value[currentNavigation.value];
+  let oldNavigation = currentNavigation.value;
   await calculateGames();
-  recalculateNavigation();
-  if (oldNavigation !== navigation.value[currentNavigation.value]) {
-    console.log("Triggered");
+  if (oldNavigation !== currentNavigation.value) {
     router.push("/library");
   }
 });

main/components/LoadingIndicator.vue

@@ -1,7 +0,0 @@
-<template></template>
-
-<script setup lang="ts">
-const loading = useLoadingIndicator();
-
-watch(loading.isLoading, console.log);
-</script>

main/components/PageWidget.vue

@@ -1,7 +0,0 @@
-<template>
-  <NuxtLink
-    class="inline-flex items-center gap-x-2 px-1 py-0.5 rounded bg-blue-900 text-zinc-100 hover:bg-blue-800"
-  >
-    <slot />
-  </NuxtLink>
-</template>

main/nuxt.config.ts

@@ -9,13 +9,17 @@ export default defineNuxtConfig({
     },
   },
 
-  css: ["~/assets/main.scss"],
-
   ssr: false,
 
-  extends: [["../libs/drop-base"]],
+  extends: ["../shared", "../libs/drop-base"],
 
   app: {
     baseURL: "/main",
-  }
+  },
+
+  devtools: {
+    enabled: false,
+  },
+
+  
 });

main/package.json

@@ -1,7 +1,7 @@
 {
   "name": "view",
   "private": true,
-  "version": "0.3.1",
+  "version": "0.3.3",
   "type": "module",
   "scripts": {
     "build": "nuxt generate",

main/pages/community.vue

@@ -0,0 +1,25 @@
+<template>
+  <div class="grow w-full h-full flex items-center justify-center">
+    <div class="flex flex-col items-center">
+      <WrenchScrewdriverIcon
+        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">
+          Under construction
+        </h1>
+        <div class="mt-4">
+          <p class="text-sm text-zinc-400 max-w-lg">
+            This page hasn't been implemented yet.
+          </p>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+<script setup lang="ts">
+import {
+  WrenchScrewdriverIcon,
+} from "@heroicons/vue/20/solid";
+</script>

main/pages/library/[id]/index.vue

@@ -243,7 +243,10 @@
             </div>
           </Listbox>
         </div>
-        <div v-else class="mt-1 rounded-md bg-red-600/10 p-4">
+        <div
+          v-else-if="versionOptions === null || versionOptions?.length == 0"
+          class="mt-1 rounded-md bg-red-600/10 p-4"
+        >
           <div class="flex">
             <div class="flex-shrink-0">
               <XCircleIcon class="h-5 w-5 text-red-600" aria-hidden="true" />
@@ -256,6 +259,27 @@
             </div>
           </div>
         </div>
+        <div v-else class="w-full flex items-center justify-center p-4">
+          <div role="status">
+            <svg
+              aria-hidden="true"
+              class="w-7 h-7 text-transparent animate-spin fill-white"
+              viewBox="0 0 100 101"
+              fill="none"
+              xmlns="http://www.w3.org/2000/svg"
+            >
+              <path
+                d="M100 50.5908C100 78.2051 77.6142 100.591 50 100.591C22.3858 100.591 0 78.2051 0 50.5908C0 22.9766 22.3858 0.59082 50 0.59082C77.6142 0.59082 100 22.9766 100 50.5908ZM9.08144 50.5908C9.08144 73.1895 27.4013 91.5094 50 91.5094C72.5987 91.5094 90.9186 73.1895 90.9186 50.5908C90.9186 27.9921 72.5987 9.67226 50 9.67226C27.4013 9.67226 9.08144 27.9921 9.08144 50.5908Z"
+                fill="currentColor"
+              />
+              <path
+                d="M93.9676 39.0409C96.393 38.4038 97.8624 35.9116 97.0079 33.5539C95.2932 28.8227 92.871 24.3692 89.8167 20.348C85.8452 15.1192 80.8826 10.7238 75.2124 7.41289C69.5422 4.10194 63.2754 1.94025 56.7698 1.05124C51.7666 0.367541 46.6976 0.446843 41.7345 1.27873C39.2613 1.69328 37.813 4.19778 38.4501 6.62326C39.0873 9.04874 41.5694 10.4717 44.0505 10.1071C47.8511 9.54855 51.7191 9.52689 55.5402 10.0491C60.8642 10.7766 65.9928 12.5457 70.6331 15.2552C75.2735 17.9648 79.3347 21.5619 82.5849 25.841C84.9175 28.9121 86.7997 32.2913 88.1811 35.8758C89.083 38.2158 91.5421 39.6781 93.9676 39.0409Z"
+                fill="currentFill"
+              />
+            </svg>
+            <span class="sr-only">Loading...</span>
+          </div>
+        </div>
         <div v-if="installDirs">
           <Listbox as="div" v-model="installDir">
             <ListboxLabel class="block text-sm/6 font-medium text-zinc-100"
@@ -510,13 +534,13 @@ async function installFlow() {
   installDirs.value = undefined;
 
   try {
-    versionOptions.value = await invoke("fetch_game_verion_options", {
+    versionOptions.value = await invoke("fetch_game_version_options", {
       gameId: game.value.id,
     });
-    console.log(versionOptions.value);
     installDirs.value = await invoke("fetch_download_dir_stats");
   } catch (error) {
     installError.value = (error as string).toString();
+    versionOptions.value = undefined;
   }
 }
 

main/pages/news.vue

@@ -0,0 +1,25 @@
+<template>
+  <div class="grow w-full h-full flex items-center justify-center">
+    <div class="flex flex-col items-center">
+      <WrenchScrewdriverIcon
+        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">
+          Under construction
+        </h1>
+        <div class="mt-4">
+          <p class="text-sm text-zinc-400 max-w-lg">
+            This page hasn't been implemented yet.
+          </p>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+<script setup lang="ts">
+import {
+  WrenchScrewdriverIcon,
+} from "@heroicons/vue/20/solid";
+</script>

main/pages/queue.vue

@@ -4,18 +4,18 @@
       class="h-16 overflow-hidden relative rounded-xl flex flex-row border border-zinc-900"
     >
       <div
-        class="bg-zinc-900 z-10 w-32 flex flex-col gap-x-2 text-blue-400 font-display items-left justify-center pl-2"
+        class="bg-zinc-900 z-10 w-32 flex flex-col gap-x-2 font-display items-left justify-center pl-2"
       >
-        <span class="font-semibold">{{ formatKilobytes(stats.speed) }}/s</span>
-        <span v-if="stats.time > 0" class="text-sm"
+        <span class="font-bold text-zinc-100">{{ formatKilobytes(stats.speed) }}B/s</span>
+        <span v-if="stats.time > 0" class="text-xs text-zinc-400"
           >{{ formatTime(stats.time) }} left</span
         >
       </div>
-      <div class="absolute inset-0 h-full flex flex-row items-end justify-end">
+      <div class="absolute inset-0 h-full flex flex-row items-end justify-end space-x-[1px]">
         <div
           v-for="bar in speedHistory"
           :style="{ height: `${(bar / speedMax) * 100}%` }"
-          class="w-[8px] bg-blue-600/40"
+          class="w-[3px] bg-blue-600 rounded-t-full"
         />
       </div>
     </div>
@@ -62,9 +62,9 @@
                 class="mt-2 inline-flex items-center gap-x-1 text-zinc-400 text-sm font-display"
                 ><span class="text-zinc-300">{{
                   formatKilobytes(element.current / 1000)
-                }}</span>
+                }}B</span>
                 /
-                <span class="">{{ formatKilobytes(element.max / 1000) }}</span
+                <span class="">{{ formatKilobytes(element.max / 1000) }}B</span
                 ><ServerIcon class="size-5"
               /></span>
             </div>
@@ -91,7 +91,7 @@
 <script setup lang="ts">
 import { ServerIcon, XMarkIcon } from "@heroicons/vue/20/solid";
 import { invoke } from "@tauri-apps/api/core";
-import { GameStatusEnum, type DownloadableMetadata, type Game, type GameStatus } from "~/types";
+import { type DownloadableMetadata, type Game, type GameStatus } from "~/types";
 
 // const actionNames = {
 //   [GameStatusEnum.Downloading]: "downloading",
@@ -105,12 +105,12 @@ window.addEventListener("resize", (event) => {
 
 const queue = useQueueState();
 const stats = useStatsState();
-const speedHistory = useState<Array<number>>(() => []);
-const speedHistoryMax = computed(() => windowWidth.value / 8);
+const speedHistory = useDownloadHistory();
+const speedHistoryMax = computed(() => windowWidth.value / 4);
 const speedMax = computed(
-  () => speedHistory.value.reduce((a, b) => (a > b ? a : b)) * 1.3
+  () => speedHistory.value.reduce((a, b) => (a > b ? a : b)) * 1.1
 );
-const previousGameId = ref<string | undefined>();
+const previousGameId = useState<string | undefined>('previous_game');
 
 const games: Ref<{
   [key: string]: { game: Game; status: Ref<GameStatus>; cover: string };
@@ -122,14 +122,15 @@ function resetHistoryGraph() {
 }
 function checkReset(v: QueueState) {
   const currentGame = v.queue.at(0)?.meta.id;
+    // If we don't have a game
+  if (!currentGame) return;
+
   // If we're finished
   if (!currentGame && previousGameId.value) {
     previousGameId.value = undefined;
     resetHistoryGraph();
     return;
   }
-  // If we don't have a game
-  if (!currentGame) return;
   // If we started a new download
   if (currentGame && !previousGameId.value) {
     previousGameId.value = currentGame;
@@ -149,9 +150,10 @@ watch(queue, (v) => {
 });
 
 watch(stats, (v) => {
+  if(v.speed == 0) return;
   const newLength = speedHistory.value.push(v.speed);
   if (newLength > speedHistoryMax.value) {
-    speedHistory.value.splice(0, 1);
+    speedHistory.value.splice(0, newLength - speedHistoryMax.value);
   }
   checkReset(queue.value);
 });
@@ -183,7 +185,7 @@ async function cancelGame(meta: DownloadableMetadata) {
 }
 
 function formatKilobytes(bytes: number): string {
-  const units = ["KB", "MB", "GB", "TB", "PB"];
+  const units = ["K", "M", "G", "T", "P"];
   let value = bytes;
   let unitIndex = 0;
   const scalar = 1000;

main/pages/settings/interface.vue

@@ -1,7 +1,23 @@
 <template>
-    
+  <div class="grow w-full h-full flex items-center justify-center">
+    <div class="flex flex-col items-center">
+      <WrenchScrewdriverIcon
+        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">
+          Under construction
+        </h1>
+        <div class="mt-4">
+          <p class="text-sm text-zinc-400 max-w-lg">
+            This page hasn't been implemented yet.
+          </p>
+        </div>
+      </div>
+    </div>
+  </div>
 </template>
-
 <script setup lang="ts">
-
+import { WrenchScrewdriverIcon } from "@heroicons/vue/20/solid";
 </script>

main/tailwind.config.js

@@ -7,6 +7,7 @@ export default {
     "./plugins/**/*.{js,ts}",
     "./app.vue",
     "./error.vue",
+    "../shared/components/**/*.vue"
   ],
   theme: {
     extend: {

main/types.ts

@@ -37,6 +37,13 @@ export type Game = {
   mImageCarouselObjectIds: string[];
 };
 
+export type Collection = {
+  id: string;
+  name: string;
+  isDefault: boolean;
+  entries: Array<{ gameId: string; game: Game }>;
+};
+
 export type GameVersion = {
   launchCommandTemplate: string;
 };

package.json

@@ -14,7 +14,8 @@
     "@tauri-apps/plugin-os": "^2.3.0",
     "@tauri-apps/plugin-shell": "^2.3.0",
     "pino": "^9.7.0",
-    "pino-pretty": "^13.1.1"
+    "pino-pretty": "^13.1.1",
+    "tauri": "^0.15.0"
   },
   "devDependencies": {
     "@tauri-apps/cli": "^2.7.1"

shared/app.vue

@@ -0,0 +1,50 @@
+<template>
+  <NuxtLoadingIndicator color="#2563eb" />
+  <NuxtLayout class="select-none w-screen h-screen">
+    <NuxtPage />
+    <ModalStack />
+  </NuxtLayout>
+</template>
+
+<script setup lang="ts">
+import "~/composables/downloads.js";
+
+import { invoke } from "@tauri-apps/api/core";
+import { useAppState } from "./composables/app-state.js";
+import {
+  initialNavigation,
+  setupHooks,
+} from "./composables/state-navigation.js";
+
+const router = useRouter();
+
+const state = useAppState();
+
+async function fetchState() {
+  try {
+    state.value = JSON.parse(await invoke("fetch_state"));
+    if (!state.value)
+      throw createError({
+        statusCode: 500,
+        statusMessage: `App state is: ${state.value}`,
+        fatal: true,
+      });
+  } catch (e) {
+    console.error("failed to parse state", e);
+    throw e;
+  }
+}
+await fetchState();
+
+// This is inefficient but apparently we do it lol
+router.beforeEach(async () => {
+  await fetchState();
+});
+
+setupHooks();
+initialNavigation(state);
+
+useHead({
+  title: "Drop",
+});
+</script>

shared/assets/main.scss

@@ -0,0 +1,84 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+html,
+body {
+  -ms-overflow-style: none; /* IE and Edge /
+scrollbar-width: none; / Firefox */
+}
+
+/* Hide scrollbar for Chrome, Safari and Opera */
+html::-webkit-scrollbar {
+  display: none;
+}
+
+$motiva: (
+  ("MotivaSansThin.ttf", "ttf", 100, normal),
+  ("MotivaSansLight.woff.ttf", "woff", 300, normal),
+  ("MotivaSansRegular.woff.ttf", "woff", 400, normal),
+  ("MotivaSansMedium.woff.ttf", "woff", 500, normal),
+  ("MotivaSansBold.woff.ttf", "woff", 600, normal),
+  ("MotivaSansExtraBold.ttf", "woff", 700, normal),
+  ("MotivaSansBlack.woff.ttf", "woff", 900, normal)
+);
+
+$helvetica: (
+  ("Helvetica.woff", "woff", 400, normal),
+  ("Helvetica-Oblique.woff", "woff", 400, italic),
+  ("Helvetica-Bold.woff", "woff", 600, normal),
+  ("Helvetica-BoldOblique.woff", "woff", 600, italic),
+  ("helvetica-light-587ebe5a59211.woff2", "woff2", 300, normal)
+);
+
+@each $file, $format, $weight, $style in $motiva {
+  @font-face {
+    font-family: "Motiva Sans";
+    src: url("/fonts/motiva/#{$file}") format($format);
+    font-weight: $weight;
+    font-style: $style;
+  }
+}
+
+@each $file, $format, $weight, $style in $helvetica {
+  @font-face {
+    font-family: "Helvetica";
+    src: url("/fonts/helvetica/#{$file}") format($format);
+    font-weight: $weight;
+    font-style: $style;
+  }
+}
+
+@font-face {
+  font-family: "Inter";
+  src: url("/fonts/inter/InterVariable.ttf");
+  font-style: normal;
+}
+
+@font-face {
+  font-family: "Inter";
+  src: url("/fonts/inter/InterVariable-Italic.ttf");
+  font-style: italic;
+}
+
+/* ===== Scrollbar CSS ===== */
+/* Firefox */
+* {
+  scrollbar-width: 4px;
+  scrollbar-color: #52525b #00000000;
+}
+
+/* Chrome, Edge, and Safari */
+*::-webkit-scrollbar {
+  width: 4px;
+}
+
+*::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+*::-webkit-scrollbar-thumb {
+  background-color: #52525b;
+  border-radius: 10px;
+  border: 3px solid #52525b;
+}

shared/composables/downloads.ts

@@ -32,3 +32,5 @@ listen("update_stats", (event) => {
   const stats = useStatsState();
   stats.value = event.payload as StatsState;
 });
+
+export const useDownloadHistory = () => useState<Array<number>>('history', () => []);

shared/composables/game.ts

@@ -43,6 +43,7 @@ export const useGame = async (gameId: string) => {
       gameStatusRegistry[gameId] = ref(parseStatus(data.status));
 
       listen(`update_game/${gameId}`, (event) => {
+        console.log(event);
         const payload: {
           status: SerializedGameStatus;
           version?: GameVersion;

shared/composables/use-object.ts

@@ -1,5 +1,5 @@
 import { convertFileSrc } from "@tauri-apps/api/core";
 
-export const useObject = async (id: string) => {
+export const useObject = (id: string) => {
   return convertFileSrc(id, "object");
 };

shared/error.vue

@@ -0,0 +1,91 @@
+<template>
+  <NuxtLayout name="default">
+    <div
+      class="grid min-h-full grid-cols-1 grid-rows-[1fr,auto,1fr] lg:grid-cols-[max(50%,36rem),1fr]"
+    >
+      <header
+        class="mx-auto w-full max-w-7xl px-6 pt-6 sm:pt-10 lg:col-span-2 lg:col-start-1 lg:row-start-1 lg:px-8"
+      >
+        <Logo class="h-10 w-auto sm:h-12" />
+        
+      </header>
+      <main
+        class="mx-auto w-full max-w-7xl px-6 py-24 sm:py-32 lg:col-span-2 lg:col-start-1 lg:row-start-2 lg:px-8"
+      >
+        <div class="max-w-lg">
+          <p class="text-base font-semibold leading-8 text-blue-600">
+            {{ error?.statusCode }}
+          </p>
+          <h1
+            class="mt-4 text-3xl font-bold font-display tracking-tight text-zinc-100 sm:text-5xl"
+          >
+            Oh no!
+          </h1>
+          <p
+            v-if="message"
+            class="mt-3 font-bold text-base leading-7 text-red-500"
+          >
+            {{ message }}
+          </p>
+          <p class="mt-6 text-base leading-7 text-zinc-400">
+            An error occurred while responding to your request. If you believe
+            this to be a bug, please report it. Try signing in and see if it
+            resolves the issue.
+          </p>
+          <div class="mt-10">
+            <!-- full app reload to fix errors -->
+            <a
+              href="/store"
+              class="text-sm font-semibold leading-7 text-blue-600"
+              ><span aria-hidden="true">&larr;</span> Back to store</a
+            >
+          </div>
+        </div>
+      </main>
+      <footer class="self-end lg:col-span-2 lg:col-start-1 lg:row-start-3">
+        <div class="border-t border-zinc-700 bg-zinc-900 py-10">
+          <nav
+            class="mx-auto flex w-full max-w-7xl items-center gap-x-4 px-6 text-sm leading-7 text-zinc-400 lg:px-8"
+          >
+            <NuxtLink href="/docs">Documentation</NuxtLink>
+            <svg
+              viewBox="0 0 2 2"
+              aria-hidden="true"
+              class="h-0.5 w-0.5 fill-zinc-600"
+            >
+              <circle cx="1" cy="1" r="1" />
+            </svg>
+            <a href="https://discord.gg/NHx46XKJWA" target="_blank"
+              >Support Discord</a
+            >
+          </nav>
+        </div>
+      </footer>
+      <div
+        class="hidden lg:relative lg:col-start-2 lg:row-start-1 lg:row-end-4 lg:block"
+      >
+        <img
+          src="@/assets/wallpaper.jpg"
+          alt=""
+          class="absolute inset-0 h-full w-full object-cover"
+        />
+      </div>
+    </div>
+  </NuxtLayout>
+</template>
+
+<script setup lang="ts">
+import type { NuxtError } from "#app";
+
+const props = defineProps({
+  error: Object as () => NuxtError,
+});
+
+const statusCode = props.error?.statusCode;
+const message =
+  props.error?.statusMessage ||
+  props.error?.message ||
+  "An unknown error occurred.";
+
+console.error(props.error);
+</script>

shared/nuxt.config.ts

@@ -0,0 +1,25 @@
+// https://nuxt.com/docs/api/configuration/nuxt-config
+export default defineNuxtConfig({
+  compatibilityDate: "2024-04-03",
+
+  postcss: {
+    plugins: {
+      tailwindcss: {},
+      autoprefixer: {},
+    },
+  },
+
+  css: ["~/assets/main.scss"],
+
+  ssr: false,
+
+  extends: [["../libs/drop-base"]],
+
+  app: {
+    baseURL: "/main",
+  },
+
+  devtools: {
+    enabled: false,
+  },
+});

shared/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "view",
+  "private": true,
+  "version": "0.3.3",
+  "type": "module",
+  "scripts": {
+    "build": "nuxt generate",
+    "dev": "nuxt dev",
+    "postinstall": "nuxt prepare",
+    "tauri": "tauri"
+  },
+  "dependencies": {
+    "@headlessui/vue": "^1.7.23",
+    "@heroicons/vue": "^2.1.5",
+    "@nuxtjs/tailwindcss": "^6.12.2",
+    "@tauri-apps/api": "^2.7.0",
+    "koa": "^2.16.1",
+    "markdown-it": "^14.1.0",
+    "micromark": "^4.0.1",
+    "nuxt": "^3.16.0",
+    "scss": "^0.2.4",
+    "vue-router": "latest",
+    "vuedraggable": "^4.1.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/forms": "^0.5.9",
+    "@tailwindcss/typography": "^0.5.15",
+    "@types/markdown-it": "^14.1.2",
+    "autoprefixer": "^10.4.20",
+    "postcss": "^8.4.47",
+    "sass-embedded": "^1.79.4",
+    "tailwindcss": "^3.4.13",
+    "typescript": "^5.8.3",
+    "vue-tsc": "^2.2.10"
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
+}

shared/tailwind.config.js

@@ -0,0 +1,20 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    "./components/**/*.{js,vue,ts}",
+    "./layouts/**/*.vue",
+    "./pages/**/*.vue",
+    "./plugins/**/*.{js,ts}",
+    "./app.vue",
+    "./error.vue",
+  ],
+  theme: {
+    extend: {
+      fontFamily: {
+        sans: ["Inter"],
+        display: ["Motiva Sans"],
+      },
+    },
+  },
+  plugins: [require("@tailwindcss/forms"), require('@tailwindcss/typography')],
+};

shared/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  // https://nuxt.com/docs/guide/concepts/typescript
+  "extends": "./.nuxt/tsconfig.json",
+  "exclude": ["src-tauri/**/*"]
+}

shared/types.ts

@@ -0,0 +1,96 @@
+import type { Component } from "vue";
+
+export type NavigationItem = {
+  prefix: string;
+  route: string;
+  label: string;
+};
+
+export type QuickActionNav = {
+  icon: Component;
+  notifications?: number;
+  action: () => Promise<void>;
+};
+
+export type User = {
+  id: string;
+  username: string;
+  admin: boolean;
+  displayName: string;
+  profilePictureObjectId: string;
+};
+
+export type AppState = {
+  status: AppStatus;
+  user?: User;
+};
+
+export type Game = {
+  id: string;
+  mName: string;
+  mShortDescription: string;
+  mDescription: string;
+  mIconObjectId: string;
+  mBannerObjectId: string;
+  mCoverObjectId: string;
+  mImageLibraryObjectIds: string[];
+  mImageCarouselObjectIds: string[];
+};
+
+export type Collection = {
+  id: string;
+  name: string;
+  isDefault: boolean;
+  entries: Array<{ gameId: string; game: Game }>;
+};
+
+export type GameVersion = {
+  launchCommandTemplate: string;
+};
+
+export enum AppStatus {
+  NotConfigured = "NotConfigured",
+  Offline = "Offline",
+  SignedOut = "SignedOut",
+  SignedIn = "SignedIn",
+  SignedInNeedsReauth = "SignedInNeedsReauth",
+  ServerUnavailable = "ServerUnavailable",
+}
+
+export enum GameStatusEnum {
+  Remote = "Remote",
+  Queued = "Queued",
+  Downloading = "Downloading",
+  Validating = "Validating",
+  Installed = "Installed",
+  Updating = "Updating",
+  Uninstalling = "Uninstalling",
+  SetupRequired = "SetupRequired",
+  Running = "Running",
+  PartiallyInstalled = "PartiallyInstalled",
+}
+
+export type GameStatus = {
+  type: GameStatusEnum;
+  version_name?: string;
+  install_dir?: string;
+};
+
+export enum DownloadableType {
+  Game = "Game",
+  Tool = "Tool",
+  DLC = "DLC",
+  Mod = "Mod",
+}
+
+export type DownloadableMetadata = {
+  id: string;
+  version: string;
+  downloadType: DownloadableType;
+};
+
+export type Settings = {
+  autostart: boolean;
+  maxDownloadThreads: number;
+  forceOffline: boolean;
+};

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "drop-app"
-version = "0.3.1"
+version = "0.3.3"
 description = "The client application for the open-source, self-hosted game distribution platform Drop"
 authors = ["Drop OSS"]
 edition = "2024"
@@ -65,7 +65,7 @@ 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"] }
+native_model = { version = "0.6.4", features = ["rmp_serde_1_3"], git = "https://github.com/Drop-OSS/native_model.git"}
 tauri-plugin-opener = "2.4.0"
 bitcode = "0.6.6"
 reqwest-websocket = "0.5.0"
@@ -73,8 +73,21 @@ futures-lite = "2.6.0"
 page_size = "0.6.0"
 sysinfo = "0.36.1"
 humansize = "2.1.3"
+tokio-util = { version = "0.7.16", features = ["io"] }
+futures-core = "0.3.31"
+bytes = "1.10.1"
 # tailscale = { path = "./tailscale" }
 
+
+# Workspaces
+client = { version = "0.1.0", path = "./client" }
+database = { path = "./database" }
+process = { path = "./process" }
+remote = { version = "0.1.0", path = "./remote" }
+utils = { path = "./utils" }
+games = { version = "0.1.0", path = "./games" }
+download_manager = { version = "0.1.0", path = "./download_manager" }
+
 [dependencies.dynfmt]
 version = "0.1.5"
 features = ["curly"]
@@ -104,9 +117,17 @@ version = "2"
 features = ["other_errors"] # You can also use "yaml_enc" or "bin_enc"
 
 [dependencies.reqwest]
-version = "0.12"
+version = "0.12.22"
 default-features = false
-features = ["json", "http2", "blocking", "rustls-tls", "native-tls-alpn", "rustls-tls-webpki-roots"]
+features = [
+    "json",
+    "http2",
+    "blocking",
+    "rustls-tls",
+    "native-tls-alpn",
+    "rustls-tls-native-roots",
+    "stream",
+]
 
 [dependencies.serde]
 version = "1"
@@ -116,3 +137,18 @@ features = ["derive", "rc"]
 lto = true
 codegen-units = 1
 panic = 'abort'
+
+
+[workspace]
+members = [
+    "client",
+    "database",
+    "process",
+    "remote",
+    "utils",
+    "cloud_saves",
+    "download_manager",
+    "games",
+]
+
+resolver = "3"

src-tauri/client/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "client"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+bitcode = "0.6.7"
+database = { version = "0.1.0", path = "../database" }
+log = "0.4.28"
+serde = { version = "1.0.228", features = ["derive"] }
+tauri = "2.8.5"
+tauri-plugin-autostart = "2.5.0"

src-tauri/client/src/app_status.rs

@@ -0,0 +1,12 @@
+use serde::Serialize;
+
+#[derive(Clone, Copy, Serialize, Eq, PartialEq)]
+pub enum AppStatus {
+    NotConfigured,
+    Offline,
+    ServerError,
+    SignedOut,
+    SignedIn,
+    SignedInNeedsReauth,
+    ServerUnavailable,
+}

src-tauri/client/src/autostart.rs

@@ -0,0 +1,26 @@
+use database::borrow_db_checked;
+use log::debug;
+use tauri::AppHandle;
+use tauri_plugin_autostart::ManagerExt;
+
+// New function to sync state on startup
+pub fn sync_autostart_on_startup(app: &AppHandle) -> Result<(), String> {
+    let db_handle = borrow_db_checked();
+    let should_be_enabled = db_handle.settings.autostart;
+    drop(db_handle);
+
+    let manager = app.autolaunch();
+    let current_state = manager.is_enabled().map_err(|e| e.to_string())?;
+
+    if current_state != should_be_enabled {
+        if should_be_enabled {
+            manager.enable().map_err(|e| e.to_string())?;
+            debug!("synced autostart: enabled");
+        } else {
+            manager.disable().map_err(|e| e.to_string())?;
+            debug!("synced autostart: disabled");
+        }
+    }
+
+    Ok(())
+}

src-tauri/client/src/compat.rs

@@ -0,0 +1,52 @@
+use std::{
+    ffi::OsStr,
+    path::PathBuf,
+    process::{Command, Stdio},
+    sync::LazyLock,
+};
+
+use log::info;
+
+pub static COMPAT_INFO: LazyLock<Option<CompatInfo>> = LazyLock::new(create_new_compat_info);
+
+pub static UMU_LAUNCHER_EXECUTABLE: LazyLock<Option<PathBuf>> = LazyLock::new(|| {
+    let x = get_umu_executable();
+    info!("{:?}", &x);
+    x
+});
+
+#[derive(Clone)]
+pub struct CompatInfo {
+    pub umu_installed: bool,
+}
+
+fn create_new_compat_info() -> Option<CompatInfo> {
+    #[cfg(target_os = "windows")]
+    return None;
+
+    let has_umu_installed = UMU_LAUNCHER_EXECUTABLE.is_some();
+    Some(CompatInfo {
+        umu_installed: has_umu_installed,
+    })
+}
+
+const UMU_BASE_LAUNCHER_EXECUTABLE: &str = "umu-run";
+const UMU_INSTALL_DIRS: [&str; 4] = ["/app/share", "/use/local/share", "/usr/share", "/opt"];
+
+fn get_umu_executable() -> Option<PathBuf> {
+    if check_executable_exists(UMU_BASE_LAUNCHER_EXECUTABLE) {
+        return Some(PathBuf::from(UMU_BASE_LAUNCHER_EXECUTABLE));
+    }
+
+    for dir in UMU_INSTALL_DIRS {
+        let p = PathBuf::from(dir).join(UMU_BASE_LAUNCHER_EXECUTABLE);
+        if check_executable_exists(&p) {
+            return Some(p);
+        }
+    }
+    None
+}
+fn check_executable_exists<P: AsRef<OsStr>>(exec: P) -> bool {
+    let has_umu_installed = Command::new(exec).stdout(Stdio::null()).output();
+    has_umu_installed.is_ok()
+}

src-tauri/client/src/lib.rs

@@ -0,0 +1,4 @@
+pub mod app_status;
+pub mod autostart;
+pub mod compat;
+pub mod user;

src-tauri/client/src/user.rs

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

src-tauri/cloud_saves/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "cloud_saves"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+database = { version = "0.1.0", path = "../database" }
+dirs = "6.0.0"
+log = "0.4.28"
+regex = "1.11.3"
+rustix = "1.1.2"
+serde = "1.0.228"
+serde_json = "1.0.145"
+serde_with = "3.15.0"
+tar = "0.4.44"
+tempfile = "3.23.0"
+uuid = "1.18.1"
+whoami = "1.6.1"
+zstd = "0.13.3"

src-tauri/cloud_saves/src/backup_manager.rs

@@ -0,0 +1,234 @@
+use std::{collections::HashMap, path::PathBuf, str::FromStr};
+
+#[cfg(target_os = "linux")]
+use database::platform::Platform;
+use database::{GameVersion, db::DATA_ROOT_DIR};
+use log::warn;
+
+use crate::error::BackupError;
+
+use super::path::CommonPath;
+
+pub struct BackupManager<'a> {
+    pub current_platform: Platform,
+    pub sources: HashMap<(Platform, Platform), &'a (dyn BackupHandler + Sync + Send)>,
+}
+
+impl Default for BackupManager<'_> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+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.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> {
+        CommonPath::Data.get().ok_or(BackupError::NotFound)
+    }
+    fn xdg_data_translate(
+        &self,
+        _path: &PathBuf,
+        _game: &GameVersion,
+    ) -> Result<PathBuf, BackupError> {
+        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> {
+        CommonPath::Config.get().ok_or(BackupError::NotFound)
+    }
+    fn win_local_app_data_translate(
+        &self,
+        _path: &PathBuf,
+        _game: &GameVersion,
+    ) -> Result<PathBuf, BackupError> {
+        CommonPath::DataLocal.get().ok_or(BackupError::NotFound)
+    }
+    fn win_local_app_data_low_translate(
+        &self,
+        _path: &PathBuf,
+        _game: &GameVersion,
+    ) -> Result<PathBuf, BackupError> {
+        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> {
+        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> {
+        CommonPath::Public.get().ok_or(BackupError::NotFound)
+    }
+}
+pub struct MacBackupManager {}
+impl BackupHandler for MacBackupManager {}

src-tauri/cloud_saves/src/conditions.rs

@@ -1,6 +1,7 @@
-use crate::process::process_manager::Platform;
+use database::platform::Platform;
 
 #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum Condition {
-    Os(Platform)
+    Os(Platform),
+    Other
 }

src-tauri/cloud_saves/src/error.rs

@@ -0,0 +1,27 @@
+use std::fmt::Display;
+
+use serde_with::SerializeDisplay;
+
+#[derive(Debug, SerializeDisplay, Clone, Copy)]
+
+pub enum BackupError {
+    InvalidSystem,
+
+    NotFound,
+
+    ParseError,
+}
+
+impl Display for BackupError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let s = match self {
+            BackupError::InvalidSystem => "Attempted to generate path for invalid system",
+
+            BackupError::NotFound => "Could not generate or find path",
+
+            BackupError::ParseError => "Failed to parse path",
+        };
+
+        write!(f, "{}", s)
+    }
+}

src-tauri/cloud_saves/src/lib.rs

@@ -0,0 +1,8 @@
+pub mod backup_manager;
+pub mod conditions;
+pub mod error;
+pub mod metadata;
+pub mod normalise;
+pub mod path;
+pub mod placeholder;
+pub mod resolver;

src-tauri/cloud_saves/src/metadata.rs

@@ -1,7 +1,6 @@
-use crate::database::db::GameVersion;
-
-use super::conditions::{Condition};
+use database::GameVersion;
 
+use super::conditions::Condition;
 
 #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct CloudSaveMetadata {
@@ -16,15 +15,17 @@ pub struct GameFile {
     pub id: Option<String>,
     pub data_type: DataType,
     pub tags: Vec<Tag>,
-    pub conditions: Vec<Condition>
+    pub conditions: Vec<Condition>,
 }
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
 pub enum DataType {
     Registry,
     File,
-    Other
+    Other,
 }
-#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
+#[derive(
+    Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize,
+)]
 #[serde(rename_all = "camelCase")]
 pub enum Tag {
     Config,
@@ -32,4 +33,4 @@ pub enum Tag {
     #[default]
     #[serde(other)]
     Other,
-}
+}

src-tauri/cloud_saves/src/normalise.rs

@@ -1,11 +1,10 @@
 use std::sync::LazyLock;
 
+use database::platform::Platform;
 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('\\', "/");
 
@@ -14,18 +13,25 @@ pub fn normalize(path: &str, os: Platform) -> String {
     }
 
     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 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());
+    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, "/"),
@@ -66,7 +72,9 @@ pub fn normalize(path: &str, os: Platform) -> String {
 
 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};
+    use {
+        BASE, HOME, ROOT, STORE_USER_ID, WIN_APP_DATA, WIN_DIR, WIN_DOCUMENTS, XDG_CONFIG, XDG_DATA,
+    };
 
     let path_lower = path.to_lowercase();
 
@@ -77,7 +85,9 @@ fn too_broad(path: &str) -> bool {
     }
 
     for item in AVOID_WILDCARDS {
-        if path.starts_with(&format!("{}/*", item)) || path.starts_with(&format!("{}/{}", item, STORE_USER_ID)) {
+        if path.starts_with(&format!("{}/*", item))
+            || path.starts_with(&format!("{}/{}", item, STORE_USER_ID))
+        {
             return true;
         }
     }
@@ -124,7 +134,6 @@ fn too_broad(path: &str) -> bool {
             return true;
         }
     }
-    
 
     // Drive letters:
     let drives: Regex = Regex::new(r"^[a-zA-Z]:$").unwrap();
@@ -159,4 +168,4 @@ pub fn usable(path: &str) -> bool {
         && !path.starts_with("../")
         && !too_broad(path)
         && !unprintable.is_match(path)
-}
+}

src-tauri/cloud_saves/src/path.rs

@@ -13,12 +13,12 @@ pub enum CommonPath {
 
 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());
+        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(|| {

src-tauri/cloud_saves/src/placeholder.rs

@@ -48,4 +48,4 @@ 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());
+pub static OS_USERNAME: LazyLock<String> = LazyLock::new(whoami::username);

src-tauri/cloud_saves/src/resolver.rs

@@ -1,22 +1,17 @@
 use std::{
-    fs::{self, create_dir_all, File},
-    io::{self, ErrorKind, Read, Write},
+    fs::{self, File, create_dir_all},
+    io::{self, Read, Write},
     path::{Path, PathBuf},
-    thread::sleep,
-    time::Duration,
 };
 
-use super::{
-    backup_manager::BackupHandler, conditions::Condition, metadata::GameFile, placeholder::*,
-};
+use crate::error::BackupError;
+
+use super::{backup_manager::BackupHandler, placeholder::*};
+use database::GameVersion;
 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 {
@@ -31,7 +26,7 @@ pub fn resolve(meta: &mut CloudSaveMetadata) -> File {
             .iter()
             .find_map(|p| match p {
                 super::conditions::Condition::Os(os) => Some(os),
-                _ => None,
+                _ => None
             })
             .cloned()
         {
@@ -64,7 +59,7 @@ pub fn resolve(meta: &mut CloudSaveMetadata) -> File {
     let binding = serde_json::to_string(meta).unwrap();
     let serialized = binding.as_bytes();
     let mut file = tempfile().unwrap();
-    file.write(serialized).unwrap();
+    file.write_all(serialized).unwrap();
     tarball.append_file("metadata", &mut file).unwrap();
     tarball.into_inner().unwrap().finish().unwrap()
 }
@@ -97,7 +92,7 @@ pub fn extract(file: PathBuf) -> Result<(), BackupError> {
             .iter()
             .find_map(|p| match p {
                 super::conditions::Condition::Os(os) => Some(os),
-                _ => None,
+                _ => None
             })
             .cloned()
         {
@@ -116,7 +111,7 @@ pub fn extract(file: PathBuf) -> Result<(), BackupError> {
         };
 
         let new_path = parse_path(file.path.into(), handler, &manifest.game_version)?;
-        create_dir_all(&new_path.parent().unwrap()).unwrap();
+        create_dir_all(new_path.parent().unwrap()).unwrap();
 
         println!(
             "Current path {:?} copying to {:?}",
@@ -133,23 +128,22 @@ 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)?;
+    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)?;
+        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)?;
+        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,
+        return Err(io::Error::other(
             format!("Source {:?} is neither a file nor a directory", src_path),
         ));
     }
@@ -158,7 +152,7 @@ pub fn copy_item<P: AsRef<Path>>(src: P, dest: P) -> io::Result<()> {
 }
 
 fn copy_dir_recursive(src: &Path, dest: &Path) -> io::Result<()> {
-    fs::create_dir_all(&dest)?;
+    fs::create_dir_all(dest)?;
 
     for entry in fs::read_dir(src)? {
         let entry = entry?;
@@ -220,43 +214,3 @@ pub fn parse_path(
     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();
-}

src-tauri/database/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "database"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+chrono = "0.4.42"
+dirs = "6.0.0"
+log = "0.4.28"
+native_model = { version = "0.6.4", features = ["rmp_serde_1_3"], git = "https://github.com/Drop-OSS/native_model.git"}
+rustbreak = "2.0.0"
+serde = "1.0.228"
+serde_with = "3.15.0"
+url = "2.5.7"
+whoami = "1.6.1"

src-tauri/database/src/db.rs

@@ -0,0 +1,45 @@
+use std::{
+    path::PathBuf,
+    sync::{Arc, LazyLock},
+};
+
+use rustbreak::{DeSerError, DeSerializer};
+use serde::{Serialize, de::DeserializeOwned};
+
+use crate::interface::{DatabaseImpls, DatabaseInterface};
+
+pub static DB: LazyLock<DatabaseInterface> = LazyLock::new(DatabaseInterface::set_up_database);
+
+#[cfg(not(debug_assertions))]
+static DATA_ROOT_PREFIX: &str = "drop";
+#[cfg(debug_assertions)]
+static DATA_ROOT_PREFIX: &str = "drop-debug";
+
+pub static DATA_ROOT_DIR: LazyLock<Arc<PathBuf>> = LazyLock::new(|| {
+    Arc::new(
+        dirs::data_dir()
+            .expect("Failed to get data dir")
+            .join(DATA_ROOT_PREFIX),
+    )
+});
+
+// Custom JSON serializer to support everything we need
+#[derive(Debug, Default, Clone)]
+pub struct DropDatabaseSerializer;
+
+impl<T: native_model::Model + Serialize + DeserializeOwned> DeSerializer<T>
+    for DropDatabaseSerializer
+{
+    fn serialize(&self, val: &T) -> rustbreak::error::DeSerResult<Vec<u8>> {
+        native_model::encode(val).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, _version) =
+            native_model::decode(buf).map_err(|e| DeSerError::Internal(e.to_string()))?;
+        Ok(val)
+    }
+}

src-tauri/database/src/interface.rs

@@ -3,44 +3,18 @@ use std::{
     mem::ManuallyDrop,
     ops::{Deref, DerefMut},
     path::PathBuf,
-    sync::{Arc, LazyLock, RwLockReadGuard, RwLockWriteGuard},
+    sync::{RwLockReadGuard, RwLockWriteGuard},
 };
 
 use chrono::Utc;
 use log::{debug, error, info, warn};
-use native_model::{Decode, Encode};
-use rustbreak::{DeSerError, DeSerializer, PathDatabase, RustbreakError};
-use serde::{Serialize, de::DeserializeOwned};
+use rustbreak::{PathDatabase, RustbreakError};
 use url::Url;
 
-use crate::DB;
-
-use super::models::data::Database;
-
-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: native_model::Model + Serialize + DeserializeOwned> DeSerializer<T>
-    for DropDatabaseSerializer
-{
-    fn serialize(&self, val: &T) -> rustbreak::error::DeSerResult<Vec<u8>> {
-        native_model::rmp_serde_1_3::RmpSerde::encode(val)
-            .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)
-    }
-}
+use crate::{
+    db::{DATA_ROOT_DIR, DB, DropDatabaseSerializer},
+    models::data::Database,
+};
 
 pub type DatabaseInterface =
     rustbreak::Database<Database, rustbreak::backend::PathBackend, DropDatabaseSerializer>;
@@ -59,13 +33,49 @@ impl DatabaseImpls for DatabaseInterface {
         let pfx_dir = DATA_ROOT_DIR.join("pfx");
 
         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();
+        create_dir_all(DATA_ROOT_DIR.as_path()).unwrap_or_else(|e| {
+            panic!(
+                "Failed to create directory {} with error {}",
+                DATA_ROOT_DIR.display(),
+                e
+            )
+        });
+        create_dir_all(&games_base_dir).unwrap_or_else(|e| {
+            panic!(
+                "Failed to create directory {} with error {}",
+                games_base_dir.display(),
+                e
+            )
+        });
+        create_dir_all(&logs_root_dir).unwrap_or_else(|e| {
+            panic!(
+                "Failed to create directory {} with error {}",
+                logs_root_dir.display(),
+                e
+            )
+        });
+        create_dir_all(&cache_dir).unwrap_or_else(|e| {
+            panic!(
+                "Failed to create directory {} with error {}",
+                cache_dir.display(),
+                e
+            )
+        });
+        create_dir_all(&pfx_dir).unwrap_or_else(|e| {
+            panic!(
+                "Failed to create directory {} with error {}",
+                pfx_dir.display(),
+                e
+            )
+        });
 
-        let exists = fs::exists(db_path.clone()).unwrap();
+        let exists = fs::exists(db_path.clone()).unwrap_or_else(|e| {
+            panic!(
+                "Failed to find if {} exists with error {}",
+                db_path.display(),
+                e
+            )
+        });
 
         if exists {
             match PathDatabase::load_from_path(db_path.clone()) {
@@ -74,21 +84,19 @@ impl DatabaseImpls for DatabaseInterface {
             }
         } else {
             let default = Database::new(games_base_dir, None, cache_dir);
-            debug!(
-                "Creating database at path {}",
-                db_path.as_os_str().to_str().unwrap()
-            );
+            debug!("Creating database at path {}", db_path.display());
             PathDatabase::create_at_path(db_path, default).expect("Database could not be created")
         }
     }
 
     fn database_is_set_up(&self) -> bool {
-        !self.borrow_data().unwrap().base_url.is_empty()
+        !borrow_db_checked().base_url.is_empty()
     }
 
     fn fetch_base_url(&self) -> Url {
-        let handle = self.borrow_data().unwrap();
-        Url::parse(&handle.base_url).unwrap()
+        let handle = borrow_db_checked();
+        Url::parse(&handle.base_url)
+            .unwrap_or_else(|_| panic!("Failed to parse base url {}", handle.base_url))
     }
 }
 
@@ -107,13 +115,16 @@ fn handle_invalid_database(
         base
     };
     info!("old database stored at: {}", new_path.to_string_lossy());
-    fs::rename(&db_path, &new_path).unwrap();
+    fs::rename(&db_path, &new_path).unwrap_or_else(|e| {
+        panic!(
+            "Could not rename database {} to {} with error {}",
+            db_path.display(),
+            new_path.display(),
+            e
+        )
+    });
 
-    let db = Database::new(
-        games_base_dir.into_os_string().into_string().unwrap(),
-        Some(new_path),
-        cache_dir,
-    );
+    let db = Database::new(games_base_dir, Some(new_path), cache_dir);
 
     PathDatabase::create_at_path(db_path, db).expect("Database could not be created")
 }

src-tauri/database/src/lib.rs

@@ -0,0 +1,14 @@
+#![feature(nonpoison_rwlock)]
+
+pub mod db;
+pub mod debug;
+pub mod interface;
+pub mod models;
+pub mod platform;
+
+pub use db::DB;
+pub use interface::{borrow_db_checked, borrow_db_mut_checked};
+pub use models::data::{
+    ApplicationTransientStatus, Database, DatabaseApplications, DatabaseAuth, DownloadType,
+    DownloadableMetadata, GameDownloadStatus, GameVersion, Settings,
+};

src-tauri/database/src/models.rs

@@ -1,17 +1,12 @@
-/**
- * NEXT BREAKING CHANGE
- * 
- * UPDATE DATABASE TO USE RPMSERDENAMED
- * 
- * WE CAN'T DELETE ANY FIELDS
- */
 pub mod data {
-    use std::path::PathBuf;
+    use std::{hash::Hash, path::PathBuf};
 
-    
     use native_model::native_model;
     use serde::{Deserialize, Serialize};
 
+    // NOTE: Within each version, you should NEVER use these types.
+    // Declare it using the actual version that it is from, i.e. v1::Settings rather than just Settings from here
+
     pub type GameVersion = v1::GameVersion;
     pub type Database = v3::Database;
     pub type Settings = v1::Settings;
@@ -19,25 +14,41 @@ pub mod data {
 
     pub type GameDownloadStatus = v2::GameDownloadStatus;
     pub type ApplicationTransientStatus = v1::ApplicationTransientStatus;
+    /**
+     * Need to be universally accessible by the ID, and the version is just a couple sprinkles on top
+     */
     pub type DownloadableMetadata = v1::DownloadableMetadata;
     pub type DownloadType = v1::DownloadType;
     pub type DatabaseApplications = v2::DatabaseApplications;
-    pub type DatabaseCompatInfo = v2::DatabaseCompatInfo;
+    // pub type DatabaseCompatInfo = v2::DatabaseCompatInfo;
 
     use std::collections::HashMap;
 
-    pub mod v1 {
-        use crate::process::process_manager::Platform;
+    impl PartialEq for DownloadableMetadata {
+        fn eq(&self, other: &Self) -> bool {
+            self.id == other.id && self.download_type == other.download_type
+        }
+    }
+    impl Hash for DownloadableMetadata {
+        fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+            self.id.hash(state);
+            self.download_type.hash(state);
+        }
+    }
+
+    mod v1 {
         use serde_with::serde_as;
         use std::{collections::HashMap, path::PathBuf};
 
+        use crate::platform::Platform;
+
         use super::{Deserialize, Serialize, native_model};
 
         fn default_template() -> String {
             "{}".to_owned()
         }
 
-        #[derive(Serialize, Deserialize, Clone, Debug)]
+        #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
         #[serde(rename_all = "camelCase")]
         #[native_model(id = 2, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
         pub struct GameVersion {
@@ -116,6 +127,7 @@ pub mod data {
         // Stuff that shouldn't be synced to disk
         #[derive(Clone, Serialize, Deserialize, Debug)]
         pub enum ApplicationTransientStatus {
+            Queued { version_name: String },
             Downloading { version_name: String },
             Uninstalling {},
             Updating { version_name: String },
@@ -144,7 +156,7 @@ pub mod data {
         }
 
         #[native_model(id = 7, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
-        #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Clone)]
+        #[derive(Debug, Eq, PartialOrd, Ord, Serialize, Deserialize, Clone)]
         #[serde(rename_all = "camelCase")]
         pub struct DownloadableMetadata {
             pub id: String,
@@ -174,22 +186,19 @@ pub mod data {
         }
     }
 
-    pub mod v2 {
+    mod v2 {
         use std::{collections::HashMap, path::PathBuf};
 
         use serde_with::serde_as;
 
-        use super::{
-            ApplicationTransientStatus, DatabaseAuth, Deserialize, DownloadableMetadata,
-            GameVersion, Serialize, Settings, native_model, v1,
-        };
+        use super::{Deserialize, Serialize, native_model, v1};
 
-        #[native_model(id = 1, version = 2, with = native_model::rmp_serde_1_3::RmpSerde)]
+        #[native_model(id = 1, version = 2, with = native_model::rmp_serde_1_3::RmpSerde, from = v1::Database)]
         #[derive(Serialize, Deserialize, Clone, Default)]
         pub struct Database {
             #[serde(default)]
-            pub settings: Settings,
-            pub auth: Option<DatabaseAuth>,
+            pub settings: v1::Settings,
+            pub auth: Option<v1::DatabaseAuth>,
             pub base_url: String,
             pub applications: v1::DatabaseApplications,
             #[serde(skip)]
@@ -198,7 +207,7 @@ pub mod data {
             pub compat_info: Option<DatabaseCompatInfo>,
         }
 
-        #[native_model(id = 8, version = 2, with = native_model::rmp_serde_1_3::RmpSerde)]
+        #[native_model(id = 9, version = 1, with = native_model::rmp_serde_1_3::RmpSerde)]
         #[derive(Serialize, Deserialize, Clone, Default)]
 
         pub struct DatabaseCompatInfo {
@@ -221,7 +230,7 @@ pub mod data {
         // 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)]
+        #[native_model(id = 5, version = 2, with = native_model::rmp_serde_1_3::RmpSerde, from = v1::GameDownloadStatus)]
         pub enum GameDownloadStatus {
             Remote {},
             SetupRequired {
@@ -261,16 +270,18 @@ pub mod data {
         #[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)]
+        #[native_model(id = 3, version = 2, with = native_model::rmp_serde_1_3::RmpSerde, from=v1::DatabaseApplications)]
         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>,
+
+            pub game_versions: HashMap<String, HashMap<String, v1::GameVersion>>,
+            pub installed_game_version: HashMap<String, v1::DownloadableMetadata>,
 
             #[serde(skip)]
-            pub transient_statuses: HashMap<DownloadableMetadata, ApplicationTransientStatus>,
+            pub transient_statuses:
+                HashMap<v1::DownloadableMetadata, v1::ApplicationTransientStatus>,
         }
         impl From<v1::DatabaseApplications> for DatabaseApplications {
             fn from(value: v1::DatabaseApplications) -> Self {
@@ -291,22 +302,19 @@ pub mod data {
     mod v3 {
         use std::path::PathBuf;
 
-        use super::{
-            DatabaseApplications, DatabaseAuth, DatabaseCompatInfo, Deserialize, Serialize,
-            Settings, native_model, v2,
-        };
-        #[native_model(id = 1, version = 3, with = native_model::rmp_serde_1_3::RmpSerde)]
+        use super::{Deserialize, Serialize, native_model, v1, v2};
+        #[native_model(id = 1, version = 3, with = native_model::rmp_serde_1_3::RmpSerde, from = v2::Database)]
         #[derive(Serialize, Deserialize, Clone, Default)]
         pub struct Database {
             #[serde(default)]
-            pub settings: Settings,
-            pub auth: Option<DatabaseAuth>,
+            pub settings: v1::Settings,
+            pub auth: Option<v1::DatabaseAuth>,
             pub base_url: String,
-            pub applications: DatabaseApplications,
+            pub applications: v2::DatabaseApplications,
             #[serde(skip)]
             pub prev_database: Option<PathBuf>,
             pub cache_dir: PathBuf,
-            pub compat_info: Option<DatabaseCompatInfo>,
+            pub compat_info: Option<v2::DatabaseCompatInfo>,
         }
 
         impl From<v2::Database> for Database {
@@ -347,4 +355,19 @@ pub mod data {
             }
         }
     }
+    impl DatabaseAuth {
+        pub fn new(
+            private: String,
+            cert: String,
+            client_id: String,
+            web_token: Option<String>,
+        ) -> Self {
+            Self {
+                private,
+                cert,
+                client_id,
+                web_token,
+            }
+        }
+    }
 }

src-tauri/database/src/platform.rs

@@ -0,0 +1,46 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Copy, Debug)]
+pub enum Platform {
+    Windows,
+    Linux,
+    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,
+            platform => unimplemented!("Playform {} is not supported", platform),
+        }
+    }
+}

src-tauri/download_manager/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "download_manager"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+atomic-instant-full = "0.1.0"
+database = { version = "0.1.0", path = "../database" }
+humansize = "2.1.3"
+log = "0.4.28"
+parking_lot = "0.12.5"
+remote = { version = "0.1.0", path = "../remote" }
+serde = "1.0.228"
+serde_with = "3.15.0"
+tauri = "2.8.5"
+throttle_my_fn = "0.2.6"
+utils = { version = "0.1.0", path = "../utils" }

src-tauri/download_manager/src/download_manager_builder.rs

@@ -7,13 +7,15 @@ use std::{
     thread::{JoinHandle, spawn},
 };
 
+use database::DownloadableMetadata;
 use log::{debug, error, info, warn};
-use tauri::{AppHandle, Emitter};
+use tauri::AppHandle;
+use utils::{app_emit, lock, send};
 
 use crate::{
-    database::models::data::DownloadableMetadata,
-    error::application_download_error::ApplicationDownloadError,
-    games::library::{QueueUpdateEvent, QueueUpdateEventQueueData, StatsUpdateEvent},
+    download_manager_frontend::DownloadStatus,
+    error::ApplicationDownloadError,
+    frontend_updates::{QueueUpdateEvent, QueueUpdateEventQueueData, StatsUpdateEvent},
 };
 
 use super::{
@@ -75,7 +77,6 @@ pub struct DownloadManagerBuilder {
     status: Arc<Mutex<DownloadManagerStatus>>,
     app_handle: AppHandle,
 
-    current_download_agent: Option<DownloadAgent>, // Should be the only download agent in the map with the "Go" flag
     current_download_thread: Mutex<Option<JoinHandle<()>>>,
     active_control_flag: Option<DownloadThreadControl>,
 }
@@ -95,7 +96,6 @@ impl DownloadManagerBuilder {
             progress: active_progress.clone(),
             app_handle,
 
-            current_download_agent: None,
             current_download_thread: Mutex::new(None),
             active_control_flag: None,
         };
@@ -106,7 +106,7 @@ impl DownloadManagerBuilder {
     }
 
     fn set_status(&self, status: DownloadManagerStatus) {
-        *self.status.lock().unwrap() = status;
+        *lock!(self.status) = status;
     }
 
     fn remove_and_cleanup_front_download(&mut self, meta: &DownloadableMetadata) -> DownloadAgent {
@@ -120,24 +120,30 @@ impl DownloadManagerBuilder {
     // Make sure the download thread is terminated
     fn cleanup_current_download(&mut self) {
         self.active_control_flag = None;
-        *self.progress.lock().unwrap() = None;
-        self.current_download_agent = None;
+        *lock!(self.progress) = None;
 
-        let mut download_thread_lock = self.current_download_thread.lock().unwrap();
-        *download_thread_lock = None;
+        let mut download_thread_lock = lock!(self.current_download_thread);
+
+        if let Some(unfinished_thread) = download_thread_lock.take()
+            && !unfinished_thread.is_finished()
+        {
+            unfinished_thread.join().unwrap();
+        }
         drop(download_thread_lock);
     }
 
-    fn stop_and_wait_current_download(&self) {
+    fn stop_and_wait_current_download(&self) -> bool {
         self.set_status(DownloadManagerStatus::Paused);
         if let Some(current_flag) = &self.active_control_flag {
             current_flag.set(DownloadThreadControlFlag::Stop);
         }
 
-        let mut download_thread_lock = self.current_download_thread.lock().unwrap();
+        let mut download_thread_lock = lock!(self.current_download_thread);
         if let Some(current_download_thread) = download_thread_lock.take() {
-            current_download_thread.join().unwrap();
-        }
+            return current_download_thread.join().is_ok();
+        };
+
+        true
     }
 
     fn manage_queue(mut self) -> Result<(), ()> {
@@ -190,13 +196,11 @@ impl DownloadManagerBuilder {
             return;
         }
 
-        download_agent.on_initialised(&self.app_handle);
+        download_agent.on_queued(&self.app_handle);
         self.download_queue.append(meta.clone());
         self.download_agent_registry.insert(meta, download_agent);
 
-        self.sender
-            .send(DownloadManagerSignal::UpdateUIQueue)
-            .unwrap();
+        send!(self.sender, DownloadManagerSignal::UpdateUIQueue);
     }
 
     fn manage_go_signal(&mut self) {
@@ -209,23 +213,13 @@ impl DownloadManagerBuilder {
             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());
 
-        // 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:?}");
+        let agent_data = if let Some(agent_data) = self.download_queue.read().front() {
+            agent_data.clone()
+        } else {
+            return;
+        };
 
         let download_agent = self
             .download_agent_registry
@@ -233,12 +227,26 @@ impl DownloadManagerBuilder {
             .unwrap()
             .clone();
 
+        let status = download_agent.status();
+
+        // This download is already going
+        if status != DownloadStatus::Queued {
+            return;
+        }
+
+        // Ensure all others are marked as queued
+        for agent in self.download_agent_registry.values() {
+            if agent.metadata() != agent_data && agent.status() != DownloadStatus::Queued {
+                agent.on_queued(&self.app_handle);
+            }
+        }
+
+        info!("starting download for {agent_data:?}");
         self.active_control_flag = Some(download_agent.control_flag());
-        self.current_download_agent = Some(download_agent.clone());
 
         let sender = self.sender.clone();
 
-        let mut download_thread_lock = self.current_download_thread.lock().unwrap();
+        let mut download_thread_lock = lock!(self.current_download_thread);
         let app_handle = self.app_handle.clone();
 
         *download_thread_lock = Some(spawn(move || {
@@ -249,17 +257,21 @@ impl DownloadManagerBuilder {
                     Err(e) => {
                         error!("download {:?} has error {}", download_agent.metadata(), &e);
                         download_agent.on_error(&app_handle, &e);
-                        sender.send(DownloadManagerSignal::Error(e)).unwrap();
+                        send!(sender, DownloadManagerSignal::Error(e));
                         return;
                     }
                 };
 
-                // If the download gets cancelled
+                // If the download gets canceled
                 // immediately return, on_cancelled gets called for us earlier
                 if !download_result {
                     return;
                 }
 
+                if download_agent.control_flag().get() == DownloadThreadControlFlag::Stop {
+                    return;
+                }
+
                 let validate_result = match download_agent.validate(&app_handle) {
                     Ok(v) => v,
                     Err(e) => {
@@ -269,17 +281,22 @@ impl DownloadManagerBuilder {
                             &e
                         );
                         download_agent.on_error(&app_handle, &e);
-                        sender.send(DownloadManagerSignal::Error(e)).unwrap();
+                        send!(sender, DownloadManagerSignal::Error(e));
                         return;
                     }
                 };
 
+                if download_agent.control_flag().get() == DownloadThreadControlFlag::Stop {
+                    return;
+                }
+
                 if validate_result {
                     download_agent.on_complete(&app_handle);
-                    sender
-                        .send(DownloadManagerSignal::Completed(download_agent.metadata()))
-                        .unwrap();
-                    sender.send(DownloadManagerSignal::UpdateUIQueue).unwrap();
+                    send!(
+                        sender,
+                        DownloadManagerSignal::Completed(download_agent.metadata())
+                    );
+                    send!(sender, DownloadManagerSignal::UpdateUIQueue);
                     return;
                 }
             }
@@ -299,58 +316,52 @@ impl DownloadManagerBuilder {
     }
     fn manage_completed_signal(&mut self, meta: DownloadableMetadata) {
         debug!("got signal Completed");
-        if let Some(interface) = &self.current_download_agent
-            && interface.metadata() == meta
+        if let Some(interface) = self.download_queue.read().front()
+            && interface == &meta
         {
             self.remove_and_cleanup_front_download(&meta);
         }
 
         self.push_ui_queue_update();
-        self.sender.send(DownloadManagerSignal::Go).unwrap();
+        send!(self.sender, DownloadManagerSignal::Go);
     }
     fn manage_error_signal(&mut self, error: ApplicationDownloadError) {
         debug!("got signal Error");
-        if let Some(current_agent) = self.current_download_agent.clone() {
+        if let Some(metadata) = self.download_queue.read().front()
+            && let Some(current_agent) = self.download_agent_registry.get(metadata)
+        {
             current_agent.on_error(&self.app_handle, &error);
 
             self.stop_and_wait_current_download();
-            self.remove_and_cleanup_front_download(&current_agent.metadata());
+            self.remove_and_cleanup_front_download(metadata);
         }
+        self.push_ui_queue_update();
         self.set_status(DownloadManagerStatus::Error);
     }
     fn manage_cancel_signal(&mut self, meta: &DownloadableMetadata) {
         debug!("got signal Cancel");
 
-        if let Some(current_download) = &self.current_download_agent {
-            if &current_download.metadata() == meta {
-                self.set_status(DownloadManagerStatus::Paused);
-                current_download.on_cancelled(&self.app_handle);
-                self.stop_and_wait_current_download();
+        // If the current download is the one we're tryna cancel
+        if let Some(current_metadata) = self.download_queue.read().front()
+            && current_metadata == meta
+            && let Some(current_download) = self.download_agent_registry.get(current_metadata)
+        {
+            self.set_status(DownloadManagerStatus::Paused);
+            current_download.on_cancelled(&self.app_handle);
+            self.stop_and_wait_current_download();
 
-                self.download_queue.pop_front();
+            self.download_queue.pop_front();
 
-                self.cleanup_current_download();
-                debug!("current download queue: {:?}", self.download_queue.read());
-            }
-            // TODO: Collapse these two into a single if statement somehow
-            else if let Some(download_agent) = self.download_agent_registry.get(meta) {
-                let index = self.download_queue.get_by_meta(meta);
-                if let Some(index) = index {
-                    download_agent.on_cancelled(&self.app_handle);
-                    let _ = self.download_queue.edit().remove(index).unwrap();
-                    let removed = self.download_agent_registry.remove(meta);
-                    debug!(
-                        "removed {:?} from queue {:?}",
-                        removed.map(|x| x.metadata()),
-                        self.download_queue.read()
-                    );
-                }
-            }
-        } else if let Some(download_agent) = self.download_agent_registry.get(meta) {
+            self.cleanup_current_download();
+            self.download_agent_registry.remove(meta);
+            debug!("current download queue: {:?}", self.download_queue.read());
+        }
+        // else just cancel it
+        else if let Some(download_agent) = self.download_agent_registry.get(meta) {
             let index = self.download_queue.get_by_meta(meta);
             if let Some(index) = index {
                 download_agent.on_cancelled(&self.app_handle);
-                let _ = self.download_queue.edit().remove(index).unwrap();
+                let _ = self.download_queue.edit().remove(index);
                 let removed = self.download_agent_registry.remove(meta);
                 debug!(
                     "removed {:?} from queue {:?}",
@@ -359,12 +370,13 @@ impl DownloadManagerBuilder {
                 );
             }
         }
+        self.sender.send(DownloadManagerSignal::Go).unwrap();
         self.push_ui_queue_update();
     }
     fn push_ui_stats_update(&self, kbs: usize, time: usize) {
         let event_data = StatsUpdateEvent { speed: kbs, time };
 
-        self.app_handle.emit("update_stats", event_data).unwrap();
+        app_emit!(&self.app_handle, "update_stats", event_data);
     }
     fn push_ui_queue_update(&self) {
         let queue = &self.download_queue.read();
@@ -383,6 +395,6 @@ impl DownloadManagerBuilder {
             .collect();
 
         let event_data = QueueUpdateEvent { queue: queue_objs };
-        self.app_handle.emit("update_queue", event_data).unwrap();
+        app_emit!(&self.app_handle, "update_queue", event_data);
     }
 }

src-tauri/download_manager/src/download_manager_frontend.rs

@@ -3,19 +3,18 @@ use std::{
     collections::VecDeque,
     fmt::Debug,
     sync::{
-        mpsc::{SendError, Sender},
         Mutex, MutexGuard,
+        mpsc::{SendError, Sender},
     },
     thread::JoinHandle,
 };
 
+use database::DownloadableMetadata;
 use log::{debug, info};
 use serde::Serialize;
+use utils::{lock, send};
 
-use crate::{
-    database::models::data::DownloadableMetadata,
-    error::application_download_error::ApplicationDownloadError,
-};
+use crate::error::ApplicationDownloadError;
 
 use super::{
     download_manager_builder::{CurrentProgressObject, DownloadAgent},
@@ -62,7 +61,7 @@ impl Serialize for DownloadManagerStatus {
     }
 }
 
-#[derive(Serialize, Clone, Debug)]
+#[derive(Serialize, Clone, Debug, PartialEq)]
 pub enum DownloadStatus {
     Queued,
     Downloading,
@@ -80,6 +79,7 @@ pub enum DownloadStatus {
 /// The actual download queue may be accessed through the .`edit()` function,
 /// which provides raw access to the underlying queue.
 /// THIS EDITING IS BLOCKING!!!
+#[derive(Debug)]
 pub struct DownloadManager {
     terminator: Mutex<Option<JoinHandle<Result<(), ()>>>>,
     download_queue: Queue,
@@ -119,22 +119,21 @@ impl DownloadManager {
         self.download_queue.read()
     }
     pub fn get_current_download_progress(&self) -> Option<f64> {
-        let progress_object = (*self.progress.lock().unwrap()).clone()?;
+        let progress_object = (*lock!(self.progress)).clone()?;
         Some(progress_object.get_progress())
     }
     pub fn rearrange_string(&self, meta: &DownloadableMetadata, new_index: usize) {
         let mut queue = self.edit();
-        let current_index = get_index_from_id(&mut queue, meta).unwrap();
-        let to_move = queue.remove(current_index).unwrap();
+        let current_index =
+            get_index_from_id(&mut queue, meta).expect("Failed to get meta index from id");
+        let to_move = queue
+            .remove(current_index)
+            .expect("Failed to remove meta at index from queue");
         queue.insert(new_index, to_move);
-        self.command_sender
-            .send(DownloadManagerSignal::UpdateUIQueue)
-            .unwrap();
+        send!(self.command_sender, DownloadManagerSignal::UpdateUIQueue);
     }
     pub fn cancel(&self, meta: DownloadableMetadata) {
-        self.command_sender
-            .send(DownloadManagerSignal::Cancel(meta))
-            .unwrap();
+        send!(self.command_sender, DownloadManagerSignal::Cancel(meta));
     }
     pub fn rearrange(&self, current_index: usize, new_index: usize) {
         if current_index == new_index {
@@ -143,39 +142,31 @@ impl DownloadManager {
 
         let needs_pause = current_index == 0 || new_index == 0;
         if needs_pause {
-            self.command_sender
-                .send(DownloadManagerSignal::Stop)
-                .unwrap();
+            send!(self.command_sender, DownloadManagerSignal::Stop);
         }
 
         debug!("moving download at index {current_index} to index {new_index}");
 
         let mut queue = self.edit();
-        let to_move = queue.remove(current_index).unwrap();
+        let to_move = queue.remove(current_index).expect("Failed to get");
         queue.insert(new_index, to_move);
         drop(queue);
 
         if needs_pause {
-            self.command_sender.send(DownloadManagerSignal::Go).unwrap();
+            send!(self.command_sender, DownloadManagerSignal::Go);
         }
-        self.command_sender
-            .send(DownloadManagerSignal::UpdateUIQueue)
-            .unwrap();
-        self.command_sender.send(DownloadManagerSignal::Go).unwrap();
+        send!(self.command_sender, DownloadManagerSignal::UpdateUIQueue);
+        send!(self.command_sender, DownloadManagerSignal::Go);
     }
     pub fn pause_downloads(&self) {
-        self.command_sender
-            .send(DownloadManagerSignal::Stop)
-            .unwrap();
+        send!(self.command_sender, DownloadManagerSignal::Stop);
     }
     pub fn resume_downloads(&self) {
-        self.command_sender.send(DownloadManagerSignal::Go).unwrap();
+        send!(self.command_sender, DownloadManagerSignal::Go);
     }
     pub fn ensure_terminated(&self) -> Result<Result<(), ()>, Box<dyn Any + Send>> {
-        self.command_sender
-            .send(DownloadManagerSignal::Finish)
-            .unwrap();
-        let terminator = self.terminator.lock().unwrap().take();
+        send!(self.command_sender, DownloadManagerSignal::Finish);
+        let terminator = lock!(self.terminator).take();
         terminator.unwrap().join()
     }
     pub fn get_sender(&self) -> Sender<DownloadManagerSignal> {

src-tauri/download_manager/src/downloadable.rs

@@ -1,17 +1,21 @@
 use std::sync::Arc;
 
+use database::DownloadableMetadata;
 use tauri::AppHandle;
 
-use crate::{
-    database::models::data::DownloadableMetadata,
-    error::application_download_error::ApplicationDownloadError,
-};
+use crate::error::ApplicationDownloadError;
 
 use super::{
     download_manager_frontend::DownloadStatus,
     util::{download_thread_control_flag::DownloadThreadControl, progress_object::ProgressObject},
 };
 
+/**
+ * Downloadables are responsible for managing their specific object's download state
+ * e.g, the GameDownloadAgent is responsible for pushing game updates
+ *
+ * But the download manager manages the queue state
+ */
 pub trait Downloadable: Send + Sync {
     fn download(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError>;
     fn validate(&self, app_handle: &AppHandle) -> Result<bool, ApplicationDownloadError>;
@@ -20,7 +24,7 @@ pub trait Downloadable: Send + Sync {
     fn control_flag(&self) -> DownloadThreadControl;
     fn status(&self) -> DownloadStatus;
     fn metadata(&self) -> DownloadableMetadata;
-    fn on_initialised(&self, app_handle: &AppHandle);
+    fn on_queued(&self, app_handle: &AppHandle);
     fn on_error(&self, app_handle: &AppHandle, error: &ApplicationDownloadError);
     fn on_complete(&self, app_handle: &AppHandle);
     fn on_cancelled(&self, app_handle: &AppHandle);

src-tauri/download_manager/src/error.rs

@@ -0,0 +1,80 @@
+use humansize::{BINARY, format_size};
+use std::{
+    fmt::{Display, Formatter},
+    io,
+    sync::{Arc, mpsc::SendError},
+};
+
+use remote::error::RemoteAccessError;
+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)
+    }
+}
+
+// TODO: Rename / separate from downloads
+#[derive(Debug, SerializeDisplay)]
+pub enum ApplicationDownloadError {
+    NotInitialized,
+    Communication(RemoteAccessError),
+    DiskFull(u64, u64),
+    #[allow(dead_code)]
+    Checksum,
+    Lock,
+    IoError(Arc<io::Error>),
+    DownloadError(RemoteAccessError),
+}
+
+impl Display for ApplicationDownloadError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ApplicationDownloadError::NotInitialized => {
+                write!(f, "Download not initalized, did something go wrong?")
+            }
+            ApplicationDownloadError::DiskFull(required, available) => write!(
+                f,
+                "Game requires {}, {} remaining left on disk.",
+                format_size(*required, BINARY),
+                format_size(*available, BINARY),
+            ),
+            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, "io error: {error}"),
+            ApplicationDownloadError::DownloadError(error) => {
+                write!(f, "Download failed with error {error:?}")
+            }
+        }
+    }
+}
+
+impl From<io::Error> for ApplicationDownloadError {
+    fn from(value: io::Error) -> Self {
+        ApplicationDownloadError::IoError(Arc::new(value))
+    }
+}

src-tauri/download_manager/src/frontend_updates.rs

@@ -0,0 +1,24 @@
+use database::DownloadableMetadata;
+use serde::Serialize;
+
+use crate::download_manager_frontend::DownloadStatus;
+
+#[derive(Serialize, Clone)]
+pub struct QueueUpdateEventQueueData {
+    pub meta: DownloadableMetadata,
+    pub status: DownloadStatus,
+    pub progress: f64,
+    pub current: usize,
+    pub max: usize,
+}
+
+#[derive(Serialize, Clone)]
+pub struct QueueUpdateEvent {
+    pub queue: Vec<QueueUpdateEventQueueData>,
+}
+
+#[derive(Serialize, Clone)]
+pub struct StatsUpdateEvent {
+    pub speed: usize,
+    pub time: usize,
+}

src-tauri/download_manager/src/lib.rs

@@ -0,0 +1,44 @@
+#![feature(duration_millis_float)]
+#![feature(nonpoison_mutex)]
+#![feature(sync_nonpoison)]
+
+use std::{ops::Deref, sync::OnceLock};
+
+use tauri::AppHandle;
+
+use crate::{
+    download_manager_builder::DownloadManagerBuilder, download_manager_frontend::DownloadManager,
+};
+
+pub mod download_manager_builder;
+pub mod download_manager_frontend;
+pub mod downloadable;
+pub mod error;
+pub mod frontend_updates;
+pub mod util;
+
+pub static DOWNLOAD_MANAGER: DownloadManagerWrapper = DownloadManagerWrapper::new();
+
+pub struct DownloadManagerWrapper(OnceLock<DownloadManager>);
+impl DownloadManagerWrapper {
+    const fn new() -> Self {
+        DownloadManagerWrapper(OnceLock::new())
+    }
+    pub fn init(app_handle: AppHandle) {
+        DOWNLOAD_MANAGER
+            .0
+            .set(DownloadManagerBuilder::build(app_handle))
+            .expect("Failed to initialise download manager");
+    }
+}
+
+impl Deref for DownloadManagerWrapper {
+    type Target = DownloadManager;
+
+    fn deref(&self) -> &Self::Target {
+        match self.0.get() {
+            Some(download_manager) => download_manager,
+            None => unreachable!("Download manager should always be initialised"),
+        }
+    }
+}

src-tauri/download_manager/src/util/download_thread_control_flag.rs

@@ -1,6 +1,6 @@
 use std::sync::{
-    atomic::{AtomicBool, Ordering},
     Arc,
+    atomic::{AtomicBool, Ordering},
 };
 
 #[derive(PartialEq, Eq, PartialOrd, Ord)]
@@ -22,7 +22,11 @@ impl From<DownloadThreadControlFlag> for bool {
 /// false => Stop
 impl From<bool> for DownloadThreadControlFlag {
     fn from(value: bool) -> Self {
-        if value { DownloadThreadControlFlag::Go } else { DownloadThreadControlFlag::Stop }
+        if value {
+            DownloadThreadControlFlag::Go
+        } else {
+            DownloadThreadControlFlag::Stop
+        }
     }
 }
 

src-tauri/download_manager/src/util/progress_object.rs

@@ -1,20 +1,21 @@
 use std::{
     sync::{
+        Arc, Mutex,
         atomic::{AtomicUsize, Ordering},
         mpsc::Sender,
-        Arc, Mutex,
     },
     time::{Duration, Instant},
 };
 
 use atomic_instant_full::AtomicInstant;
 use throttle_my_fn::throttle;
+use utils::{lock, send};
 
-use crate::download_manager::download_manager_frontend::DownloadManagerSignal;
+use crate::download_manager_frontend::DownloadManagerSignal;
 
 use super::rolling_progress_updates::RollingProgressWindow;
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct ProgressObject {
     max: Arc<Mutex<usize>>,
     progress_instances: Arc<Mutex<Vec<Arc<AtomicUsize>>>>,
@@ -23,7 +24,7 @@ pub struct ProgressObject {
     //last_update: Arc<RwLock<Instant>>,
     last_update_time: Arc<AtomicInstant>,
     bytes_last_update: Arc<AtomicUsize>,
-    rolling: RollingProgressWindow<250>,
+    rolling: RollingProgressWindow<1000>,
 }
 
 #[derive(Clone)]
@@ -74,12 +75,10 @@ impl ProgressObject {
     }
 
     pub fn set_time_now(&self) {
-        *self.start.lock().unwrap() = Instant::now();
+        *lock!(self.start) = Instant::now();
     }
     pub fn sum(&self) -> usize {
-        self.progress_instances
-            .lock()
-            .unwrap()
+        lock!(self.progress_instances)
             .iter()
             .map(|instance| instance.load(Ordering::Acquire))
             .sum()
@@ -88,27 +87,25 @@ impl ProgressObject {
         self.set_time_now();
         self.bytes_last_update.store(0, Ordering::Release);
         self.rolling.reset();
-        self.progress_instances
-            .lock()
-            .unwrap()
+        lock!(self.progress_instances)
             .iter()
             .for_each(|x| x.store(0, Ordering::SeqCst));
     }
     pub fn get_max(&self) -> usize {
-        *self.max.lock().unwrap()
+        *lock!(self.max)
     }
     pub fn set_max(&self, new_max: usize) {
-        *self.max.lock().unwrap() = new_max;
+        *lock!(self.max) = new_max;
     }
     pub fn set_size(&self, length: usize) {
-        *self.progress_instances.lock().unwrap() =
+        *lock!(self.progress_instances) =
             (0..length).map(|_| Arc::new(AtomicUsize::new(0))).collect();
     }
     pub fn get_progress(&self) -> f64 {
         self.sum() as f64 / self.get_max() as f64
     }
     pub fn get(&self, index: usize) -> Arc<AtomicUsize> {
-        self.progress_instances.lock().unwrap()[index].clone()
+        lock!(self.progress_instances)[index].clone()
     }
     fn update_window(&self, kilobytes_per_second: usize) {
         self.rolling.update(kilobytes_per_second);
@@ -120,7 +117,9 @@ pub fn calculate_update(progress: &ProgressObject) {
     let last_update_time = progress
         .last_update_time
         .swap(Instant::now(), Ordering::SeqCst);
-    let time_since_last_update = Instant::now().duration_since(last_update_time).as_millis();
+    let time_since_last_update = Instant::now()
+        .duration_since(last_update_time)
+        .as_millis_f64();
 
     let current_bytes_downloaded = progress.sum();
     let max = progress.get_max();
@@ -128,17 +127,18 @@ pub fn calculate_update(progress: &ProgressObject) {
         .bytes_last_update
         .swap(current_bytes_downloaded, Ordering::Acquire);
 
-    let bytes_since_last_update = current_bytes_downloaded - bytes_at_last_update;
+    let bytes_since_last_update =
+        current_bytes_downloaded.saturating_sub(bytes_at_last_update) as f64;
 
-    let kilobytes_per_second = bytes_since_last_update / (time_since_last_update as usize).max(1);
+    let kilobytes_per_second = bytes_since_last_update / time_since_last_update;
 
     let bytes_remaining = max.saturating_sub(current_bytes_downloaded); // bytes
 
-    progress.update_window(kilobytes_per_second);
+    progress.update_window(kilobytes_per_second as usize);
     push_update(progress, bytes_remaining);
 }
 
-#[throttle(1, Duration::from_millis(500))]
+#[throttle(1, Duration::from_millis(250))]
 pub fn push_update(progress: &ProgressObject, bytes_remaining: usize) {
     let average_speed = progress.rolling.get_average();
     let time_remaining = (bytes_remaining / 1000) / average_speed.max(1);
@@ -148,18 +148,12 @@ pub fn push_update(progress: &ProgressObject, bytes_remaining: usize) {
 }
 
 fn update_ui(progress_object: &ProgressObject, kilobytes_per_second: usize, time_remaining: usize) {
-    progress_object
-        .sender
-        .send(DownloadManagerSignal::UpdateUIStats(
-            kilobytes_per_second,
-            time_remaining,
-        ))
-        .unwrap();
+    send!(
+        progress_object.sender,
+        DownloadManagerSignal::UpdateUIStats(kilobytes_per_second, time_remaining)
+    );
 }
 
 fn update_queue(progress: &ProgressObject) {
-    progress
-        .sender
-        .send(DownloadManagerSignal::UpdateUIQueue)
-        .unwrap();
+    send!(progress.sender, DownloadManagerSignal::UpdateUIQueue)
 }

src-tauri/download_manager/src/util/queue.rs

@@ -3,9 +3,10 @@ use std::{
     sync::{Arc, Mutex, MutexGuard},
 };
 
-use crate::database::models::data::DownloadableMetadata;
+use database::DownloadableMetadata;
+use utils::lock;
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct Queue {
     inner: Arc<Mutex<VecDeque<DownloadableMetadata>>>,
 }
@@ -24,10 +25,10 @@ impl Queue {
         }
     }
     pub fn read(&self) -> VecDeque<DownloadableMetadata> {
-        self.inner.lock().unwrap().clone()
+        lock!(self.inner).clone()
     }
     pub fn edit(&self) -> MutexGuard<'_, VecDeque<DownloadableMetadata>> {
-        self.inner.lock().unwrap()
+        lock!(self.inner)
     }
     pub fn pop_front(&self) -> Option<DownloadableMetadata> {
         self.edit().pop_front()

src-tauri/download_manager/src/util/rolling_progress_updates.rs

@@ -1,13 +1,19 @@
 use std::sync::{
-    atomic::{AtomicUsize, Ordering},
     Arc,
+    atomic::{AtomicUsize, Ordering},
 };
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct RollingProgressWindow<const S: usize> {
     window: Arc<[AtomicUsize; S]>,
     current: Arc<AtomicUsize>,
 }
+impl<const S: usize> Default for RollingProgressWindow<S> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<const S: usize> RollingProgressWindow<S> {
     pub fn new() -> Self {
         Self {
@@ -22,17 +28,22 @@ impl<const S: usize> RollingProgressWindow<S> {
     }
     pub fn get_average(&self) -> usize {
         let current = self.current.load(Ordering::SeqCst);
-        self.window
+        let valid = self
+            .window
             .iter()
             .enumerate()
             .filter(|(i, _)| i < &current)
             .map(|(_, x)| x.load(Ordering::Acquire))
-            .sum::<usize>()
-            / S
+            .collect::<Vec<usize>>();
+        let amount = valid.len();
+        let sum = valid.into_iter().sum::<usize>();
+
+        sum / amount
     }
     pub fn reset(&self) {
         self.window
             .iter()
             .for_each(|x| x.store(0, Ordering::Release));
+        self.current.store(0, Ordering::Release);
     }
 }

src-tauri/games/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "games"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+atomic-instant-full = "0.1.0"
+bitcode = "0.6.7"
+boxcar = "0.2.14"
+database = { version = "0.1.0", path = "../database" }
+download_manager = { version = "0.1.0", path = "../download_manager" }
+hex = "0.4.3"
+log = "0.4.28"
+md5 = "0.8.0"
+rayon = "1.11.0"
+remote = { version = "0.1.0", path = "../remote" }
+reqwest = "0.12.23"
+rustix = "1.1.2"
+serde = { version = "1.0.228", features = ["derive"] }
+serde_with = "3.15.0"
+sysinfo = "0.37.2"
+tauri = "2.8.5"
+throttle_my_fn = "0.2.6"
+utils = { version = "0.1.0", path = "../utils" }
+native_model = { version = "0.6.4", features = ["rmp_serde_1_3"], git = "https://github.com/Drop-OSS/native_model.git"}
+serde_json = "1.0.145"