From 5f64f4fed1a1b2cf0bbc66415d91c7c9a81c4c05 Mon Sep 17 00:00:00 2001
From: Pauline <git@ethanlibs.co>
Date: Thu, 12 Sep 2024 18:32:02 +0200
Subject: [PATCH] =?UTF-8?q?=F0=9F=9A=A7=20wip:=20is=20somebody=20gonna=20m?=
 =?UTF-8?q?atch=20my=20tweaks?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Pauline <git@ethanlibs.co>
---
 Cargo.lock                                    |  62 +++++---
 Cargo.toml                                    |   6 +-
 .../ui/components/content/SearchResults.tsx   |   8 +-
 apps/frontend/src/ui/pages/Home.tsx           |  14 +-
 .../src/ui/pages/cluster/ClusterSettings.tsx  |   6 +-
 .../pages/settings/game/SettingsAccounts.tsx  |   2 +-
 .../pages/settings/game/SettingsMinecraft.tsx |  18 +--
 .../settings/launcher/SettingsAppearance.tsx  |   6 +-
 packages/client/src/utils/highlight.ts        |  13 --
 packages/core/Cargo.toml                      |   5 +-
 packages/core/prisma/schema.prisma            |   2 +-
 .../core/src/api/cluster/content/logger.rs    |  72 +++++-----
 .../core/src/api/cluster/content/package.rs   |  33 +++--
 .../src/api/cluster/content/screenshots.rs    |   2 +-
 .../core/src/api/cluster/content/worlds.rs    |   2 +-
 packages/core/src/api/cluster/create.rs       |  35 ++---
 packages/core/src/api/cluster/mod.rs          |  13 +-
 packages/core/src/api/handler.rs              |   2 +-
 packages/core/src/api/java.rs                 |  32 ++---
 packages/core/src/api/metadata.rs             |  13 +-
 packages/core/src/api/mod.rs                  |   3 +-
 packages/core/src/api/package/content/mod.rs  |  39 ++---
 .../core/src/api/package/content/modrinth.rs  |  57 ++++----
 packages/core/src/api/package/from.rs         |  32 ++---
 .../core/src/api/package/import/atlauncher.rs |  16 +--
 .../core/src/api/package/import/curseforge.rs |  16 +--
 packages/core/src/api/package/import/ftb.rs   |   2 +-
 .../core/src/api/package/import/gdlauncher.rs |  17 ++-
 packages/core/src/api/package/import/mod.rs   |  39 ++---
 .../core/src/api/package/import/modrinth.rs   |   6 +-
 .../core/src/api/package/import/multibased.rs |  27 ++--
 .../core/src/api/package/import/technic.rs    |   2 +-
 .../core/src/api/package/import/tlauncher.rs  |   2 +-
 packages/core/src/api/package/mod.rs          |   4 +-
 packages/core/src/api/package/mrpack.rs       |  15 +-
 packages/core/src/api/proxy/send.rs           |   2 +-
 packages/core/src/api/settings.rs             |  23 +--
 packages/core/src/constants.rs                |   4 +-
 packages/core/src/error.rs                    |  12 +-
 packages/core/src/game/arguments.rs           |  68 ++-------
 packages/core/src/game/metadata.rs            |  17 +--
 packages/core/src/game/mod.rs                 |  61 ++++----
 packages/core/src/lib.rs                      |  38 ++++-
 packages/core/src/logger.rs                   |   9 +-
 packages/core/src/store/clusters.rs           |  46 +++---
 packages/core/src/store/credentials.rs        |  16 +--
 packages/core/src/store/dirs.rs               |   2 +
 packages/core/src/store/discord.rs            |   2 +-
 packages/core/src/store/java_versions.rs      |  14 +-
 packages/core/src/store/metadata.rs           |  23 ++-
 packages/core/src/store/minecraft.rs          |   7 +-
 packages/core/src/store/mod.rs                |  10 +-
 packages/core/src/store/oneconfig.rs          |   6 +-
 packages/core/src/store/package.rs            |  95 ++++++------
 packages/core/src/store/processor.rs          |  79 +++++-----
 packages/core/src/store/settings.rs           |  18 +--
 packages/core/src/utils/http.rs               |  30 ++--
 packages/core/src/utils/java.rs               |  24 ++--
 packages/core/src/utils/mod.rs                |  26 +---
 packages/core/src/utils/watcher.rs            |  13 +-
 packages/gamemode/src/lib.rs                  |  33 +++++
 packages/macros/src/lib.rs                    |  34 ++++-
 packages/prisma/src/lib.rs                    |  11 ++
 packages/utils/Cargo.toml                     |  32 +++++
 packages/{core/src/utils => utils/src}/io.rs  |  21 ++-
 packages/utils/src/lib.rs                     |  82 +++++++++++
 .../{core/src/utils => utils/src}/logging.rs  |  27 ++--
 .../{core/src/utils => utils/src}/platform.rs |  18 +--
 packages/utils/src/prisma.rs                  | 136 ++++++++++++++++++
 69 files changed, 1000 insertions(+), 662 deletions(-)
 create mode 100644 packages/utils/Cargo.toml
 rename packages/{core/src/utils => utils/src}/io.rs (92%)
 create mode 100644 packages/utils/src/lib.rs
 rename packages/{core/src/utils => utils/src}/logging.rs (89%)
 rename packages/{core/src/utils => utils/src}/platform.rs (92%)
 create mode 100644 packages/utils/src/prisma.rs

diff --git a/Cargo.lock b/Cargo.lock
index 66ac7f0a..de85933f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10,9 +10,9 @@ checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3"
 
 [[package]]
 name = "addr2line"
-version = "0.22.0"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678"
+checksum = "f5fb1d8e4442bd405fdfd1dacb42792696b0cf9cb15882e5d097b742a676d375"
 dependencies = [
  "gimli",
 ]
@@ -458,17 +458,17 @@ checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
 
 [[package]]
 name = "backtrace"
-version = "0.3.73"
+version = "0.3.74"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a"
+checksum = "8d82cb332cdfaed17ae235a638438ac4d4839913cc2af585c3c6746e8f8bee1a"
 dependencies = [
  "addr2line",
- "cc",
  "cfg-if",
  "libc",
- "miniz_oxide 0.7.4",
+ "miniz_oxide 0.8.0",
  "object",
  "rustc-demangle",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -1870,9 +1870,9 @@ dependencies = [
 
 [[package]]
 name = "error-code"
-version = "3.2.0"
+version = "3.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0474425d51df81997e2f90a21591180b38eccf27292d755f3e30750225c175b"
+checksum = "a5d9305ccc6942a704f4335694ecd3de2ea531b114ac2d51f5f843750787a92f"
 
 [[package]]
 name = "event-listener"
@@ -2404,9 +2404,9 @@ dependencies = [
 
 [[package]]
 name = "gimli"
-version = "0.29.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
+checksum = "32085ea23f3234fc7846555e85283ba4de91e21016dc0455a16286d87a292d64"
 
 [[package]]
 name = "gio"
@@ -2904,9 +2904,9 @@ dependencies = [
 
 [[package]]
 name = "hyper-util"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cde7055719c54e36e95e8719f95883f22072a48ede39db7fc17a4e1d5281e9b9"
+checksum = "da62f120a8a37763efb0cf8fdf264b884c7b8b9ac8660b900c8661030c00e6ba"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -4350,7 +4350,6 @@ name = "onelauncher"
 version = "1.0.0-alpha.1"
 dependencies = [
  "anyhow",
- "async-compression",
  "async-recursion",
  "async-tungstenite",
  "async_zip",
@@ -4360,19 +4359,18 @@ dependencies = [
  "chrono",
  "dirs 5.0.1",
  "discord-rich-presence",
- "dunce",
  "flate2",
  "futures",
  "indicatif",
  "interpulse",
  "iota_stronghold",
  "lazy_static",
- "nom",
  "notify",
  "notify-debouncer-mini",
  "onelauncher_gamemode",
  "onelauncher_macros",
  "onelauncher_prisma",
+ "onelauncher_utils",
  "p256",
  "paste",
  "rand 0.8.5",
@@ -4384,7 +4382,6 @@ dependencies = [
  "sha1_smol",
  "sha2 0.10.8",
  "specta 2.0.0-rc.20",
- "sys-info",
  "sysinfo",
  "tauri",
  "tauri-specta",
@@ -4483,6 +4480,31 @@ dependencies = [
  "webbrowser",
 ]
 
+[[package]]
+name = "onelauncher_utils"
+version = "1.0.0-alpha.1"
+dependencies = [
+ "async-channel",
+ "async-compression",
+ "chrono",
+ "dunce",
+ "futures",
+ "interpulse",
+ "nom",
+ "onelauncher_prisma",
+ "pin-project-lite",
+ "prisma-client-rust",
+ "regex",
+ "serde",
+ "sys-info",
+ "tempfile",
+ "thiserror",
+ "tokio",
+ "tracing",
+ "uuid 1.10.0",
+ "zip",
+]
+
 [[package]]
 name = "opaque-debug"
 version = "0.3.1"
@@ -6002,9 +6024,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.12"
+version = "0.23.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c58f8c84392efc0a126acce10fa59ff7b3d2ac06ab451a33f2741989b806b044"
+checksum = "f2dabaac7466917e566adb06783a81ca48944c6898a1b08b9374106dd671f4c8"
 dependencies = [
  "once_cell",
  "ring",
@@ -6041,9 +6063,9 @@ checksum = "fc0a2ce646f8655401bb81e7927b812614bd5d91dbc968696be50603510fcaf0"
 
 [[package]]
 name = "rustls-webpki"
-version = "0.102.7"
+version = "0.102.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84678086bd54edf2b415183ed7a94d0efb049f1b646a33e22a36f3794be6ae56"
+checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9"
 dependencies = [
  "ring",
  "rustls-pki-types",
diff --git a/Cargo.toml b/Cargo.toml
index 5a6a035a..b79e71d3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,7 +7,8 @@ members = [
 	"packages/macros", # onelauncher_macros -- utility procedural macros for onelauncher
 	"packages/gamemode", # onelauncher_gamemode -- rust wrapper for feral gamemode
 	"packages/prisma-cli", # onelauncher_prisma_cli -- rust wrapper for prisma cli
-	"packages/prisma" # onelauncher_prisma -- rust client for prisma
+	"packages/prisma", # onelauncher_prisma -- rust client for prisma
+	"packages/utils" # onelauncher_utils -- standard utilities for use within all crates
 ]
 
 [workspace.package] # sets default [package] settings for workspace members
@@ -31,6 +32,7 @@ onelauncher_test = { path = "./apps/testing" }
 onelauncher_gamemode = { path = "./packages/gamemode" }
 onelauncher_prisma = { path = "./packages/prisma" }
 onelauncher_prisma_cli = { path = "./packages/prisma-cli" }
+onelauncher_utils = { path = "./packages/utils" }
 
 # # ============= TAURI ============= # #
 # tauri uses latest crates.io rc channel
@@ -158,6 +160,8 @@ sha2 = { version = "0.10" }
 bytes = { version = "1.7" }
 
 # # ============= UTILITY ============= # #
+async-channel = { version = "2.3" }
+pin-project-lite = { version = "0.2" }
 once_cell = { version = "1.19" }
 quote = { version = "1.0" }
 syn = { version = "2.0", features = [ "full" ] }
diff --git a/apps/frontend/src/ui/components/content/SearchResults.tsx b/apps/frontend/src/ui/components/content/SearchResults.tsx
index 3e4fd812..da7317c8 100644
--- a/apps/frontend/src/ui/components/content/SearchResults.tsx
+++ b/apps/frontend/src/ui/components/content/SearchResults.tsx
@@ -1,11 +1,11 @@
 import { ChevronDownIcon, Download01Icon, HeartIcon } from '@untitled-theme/icons-solid';
-import { For, Match, Show, Switch, createSignal } from 'solid-js';
+import useBrowser from '~ui/hooks/useBrowser';
+import useSettings from '~ui/hooks/useSettings';
+import { abbreviateNumber } from '~utils';
+import { createSignal, For, Match, Show, Switch } from 'solid-js';
 import type { Providers, SearchResult } from '@onelauncher/client/bindings';
 import type { JSX } from 'solid-js';
 import Button from '../base/Button';
-import { abbreviateNumber } from '~utils';
-import useSettings from '~ui/hooks/useSettings';
-import useBrowser from '~ui/hooks/useBrowser';
 
 interface SearchResultsContainerProps {
 	provider: Providers;
diff --git a/apps/frontend/src/ui/pages/Home.tsx b/apps/frontend/src/ui/pages/Home.tsx
index de228faf..96634ac2 100644
--- a/apps/frontend/src/ui/pages/Home.tsx
+++ b/apps/frontend/src/ui/pages/Home.tsx
@@ -6,19 +6,19 @@ import {
 	RefreshCw01Icon,
 	SearchMdIcon,
 } from '@untitled-theme/icons-solid';
-import { For, Show, onMount } from 'solid-js';
-import type { Cluster } from '@onelauncher/client/bindings';
-import BannerBackground from '../../assets/images/header.png';
-import Button from '../components/base/Button';
-import TextField from '../components/base/TextField';
-import ClusterRoot from './cluster/ClusterRoot';
 import { bridge } from '~imports';
-
 import ClusterCover from '~ui/components/game/ClusterCover';
 import { useClusterCreator } from '~ui/components/overlay/cluster/ClusterCreationModal';
 import { useLaunchCluster, useRecentCluster } from '~ui/hooks/useCluster';
 import useCommand from '~ui/hooks/useCommand';
 import { formatAsDuration, upperFirst } from '~utils';
+import { For, onMount, Show } from 'solid-js';
+
+import type { Cluster } from '@onelauncher/client/bindings';
+import BannerBackground from '../../assets/images/header.png';
+import Button from '../components/base/Button';
+import TextField from '../components/base/TextField';
+import ClusterRoot from './cluster/ClusterRoot';
 
 type GroupedClusters = Record<string, Cluster[]>;
 
diff --git a/apps/frontend/src/ui/pages/cluster/ClusterSettings.tsx b/apps/frontend/src/ui/pages/cluster/ClusterSettings.tsx
index 8b9b2b50..4a6efed8 100644
--- a/apps/frontend/src/ui/pages/cluster/ClusterSettings.tsx
+++ b/apps/frontend/src/ui/pages/cluster/ClusterSettings.tsx
@@ -1,13 +1,13 @@
 import { useBeforeLeave } from '@solidjs/router';
-import { type Accessor, Show } from 'solid-js';
-import type { Cluster } from '@onelauncher/client/bindings';
-import { GameSettings, JvmSettings, LauncherSettings, ProcessSettings, createSetting } from '../settings/game/SettingsMinecraft';
 import { bridge } from '~imports';
 import ScrollableContainer from '~ui/components/ScrollableContainer';
 import Sidebar from '~ui/components/Sidebar';
 import useClusterContext from '~ui/hooks/useCluster';
 import { tryResult } from '~ui/hooks/useCommand';
 import useSettings from '~ui/hooks/useSettings';
+import { type Accessor, Show } from 'solid-js';
+import type { Cluster } from '@onelauncher/client/bindings';
+import { createSetting, GameSettings, JvmSettings, LauncherSettings, ProcessSettings } from '../settings/game/SettingsMinecraft';
 
 function ClusterSettings() {
 	const [cluster] = useClusterContext();
diff --git a/apps/frontend/src/ui/pages/settings/game/SettingsAccounts.tsx b/apps/frontend/src/ui/pages/settings/game/SettingsAccounts.tsx
index 116449d8..18381599 100644
--- a/apps/frontend/src/ui/pages/settings/game/SettingsAccounts.tsx
+++ b/apps/frontend/src/ui/pages/settings/game/SettingsAccounts.tsx
@@ -1,11 +1,11 @@
 import { InfoCircleIcon, Trash01Icon, UserPlus02Icon } from '@untitled-theme/icons-solid';
-import { For, Match, Show, Switch, createSignal, mergeProps } from 'solid-js';
 import Button from '~ui/components/base/Button';
 import Tooltip from '~ui/components/base/Tooltip';
 import PlayerHead from '~ui/components/game/PlayerHead';
 import useAccountController from '~ui/components/overlay/account/AddAccountModal';
 import ScrollableContainer from '~ui/components/ScrollableContainer';
 import Sidebar from '~ui/components/Sidebar';
+import { createSignal, For, Match, mergeProps, Show, Switch } from 'solid-js';
 
 function SettingsAccounts() {
 	const controller = useAccountController();
diff --git a/apps/frontend/src/ui/pages/settings/game/SettingsMinecraft.tsx b/apps/frontend/src/ui/pages/settings/game/SettingsMinecraft.tsx
index 97f205cf..bd0bce15 100644
--- a/apps/frontend/src/ui/pages/settings/game/SettingsMinecraft.tsx
+++ b/apps/frontend/src/ui/pages/settings/game/SettingsMinecraft.tsx
@@ -1,15 +1,15 @@
 import { ActivityIcon, CpuChip01Icon, Database01Icon, EyeIcon, FilePlus02Icon, FileX02Icon, LayoutTopIcon, Maximize01Icon, ParagraphWrapIcon, VariableIcon, XIcon } from '@untitled-theme/icons-solid';
-import { type Accessor, For, type Setter, Show, createSignal, onMount, splitProps, untrack } from 'solid-js';
-import type { JavaVersion, JavaVersions, Memory, Resolution } from '@onelauncher/client/bindings';
+import Button from '~ui/components/base/Button';
 import TextField from '~ui/components/base/TextField';
 import Toggle from '~ui/components/base/Toggle';
+import Modal, { createModal } from '~ui/components/overlay/Modal';
 import ScrollableContainer from '~ui/components/ScrollableContainer';
 import BaseSettingsRow, { type SettingsRowProps } from '~ui/components/SettingsRow';
 import Sidebar from '~ui/components/Sidebar';
 import useSettings from '~ui/hooks/useSettings';
 import { asEnvVariables } from '~utils';
-import Modal, { createModal } from '~ui/components/overlay/Modal';
-import Button from '~ui/components/base/Button';
+import { type Accessor, createSignal, For, onMount, type Setter, Show, splitProps, untrack } from 'solid-js';
+import type { JavaVersion, JavaVersions, Memory, Resolution } from '@onelauncher/client/bindings';
 
 function SettingsMinecraft() {
 	return (
@@ -300,14 +300,14 @@ export function JvmSettings(props: {
 }) {
 	const modal = createModal(controller => (
 		<Modal.Simple
-			title="Java Versions"
 			buttons={[
 				<Button
-					onClick={controller.hide}
 					buttonStyle="secondary"
 					children="Close"
+					onClick={controller.hide}
 				/>,
 			]}
+			title="Java Versions"
 			{...controller}
 		>
 			<div class="grid grid-cols-[80px_1fr] items-center gap-y-2">
@@ -318,10 +318,10 @@ export function JvmSettings(props: {
 							<>
 								<span class="capitalize">{prettified}</span>
 								<TextField
-									value={meta.path}
 									onValidSubmit={(value) => {
 										props.javaVersions?.set({ ...props.javaVersions.get(), [version]: { ...meta, path: value } });
 									}}
+									value={meta.path}
 								/>
 							</>
 						);
@@ -343,9 +343,9 @@ export function JvmSettings(props: {
 				title="Version"
 			>
 				<Button
-					onClick={modal.show}
-					iconLeft={<Database01Icon />}
 					children="Configure"
+					iconLeft={<Database01Icon />}
+					onClick={modal.show}
 				/>
 			</SettingsRow>
 
diff --git a/apps/frontend/src/ui/pages/settings/launcher/SettingsAppearance.tsx b/apps/frontend/src/ui/pages/settings/launcher/SettingsAppearance.tsx
index 0ff189f8..da91e5a2 100644
--- a/apps/frontend/src/ui/pages/settings/launcher/SettingsAppearance.tsx
+++ b/apps/frontend/src/ui/pages/settings/launcher/SettingsAppearance.tsx
@@ -1,14 +1,14 @@
 import { useBeforeLeave } from '@solidjs/router';
 import { PackageIcon, Speedometer04Icon } from '@untitled-theme/icons-solid';
-import { For, createSignal } from 'solid-js';
-import SettingsRow from '../../../components/SettingsRow';
 import Dropdown from '~ui/components/base/Dropdown';
 import Toggle from '~ui/components/base/Toggle';
 import ScrollableContainer from '~ui/components/ScrollableContainer';
 import Sidebar from '~ui/components/Sidebar';
 import useSettings from '~ui/hooks/useSettings';
-import { BROWSER_VIEWS } from '~utils/browser';
 import { upperFirst } from '~utils';
+import { BROWSER_VIEWS } from '~utils/browser';
+import { createSignal, For } from 'solid-js';
+import SettingsRow from '../../../components/SettingsRow';
 
 function SettingsAppearance() {
 	const { settings, saveOnLeave } = useSettings();
diff --git a/packages/client/src/utils/highlight.ts b/packages/client/src/utils/highlight.ts
index 6ce0ac67..362074ec 100644
--- a/packages/client/src/utils/highlight.ts
+++ b/packages/client/src/utils/highlight.ts
@@ -1,17 +1,4 @@
 import hljs from 'highlight.js/lib/core';
-// import javascript from 'highlight.js/lib/languages/javascript';
-// import python from 'highlight.js/lib/languages/python';
-// import lua from 'highlight.js/lib/languages/lua';
-// import java from 'highlight.js/lib/languages/java';
-// import kotlin from 'highlight.js/lib/languages/kotlin';
-// import scala from 'highlight.js/lib/languages/scala';
-// import groovy from 'highlight.js/lib/languages/groovy';
-// import gradle from 'highlight.js/lib/languages/gradle';
-// import json from 'highlight.js/lib/languages/json';
-// import ini from 'highlight.js/lib/languages/ini';
-// import yaml from 'highlight.js/lib/languages/yaml';
-// import xml from 'highlight.js/lib/languages/xml';
-// import properties from 'highlight.js/lib/languages/properties';
 import { configuredXss, md, noop } from './markdown';
 
 function langFactory(lang: string) {
diff --git a/packages/core/Cargo.toml b/packages/core/Cargo.toml
index e9cba102..276d8bac 100644
--- a/packages/core/Cargo.toml
+++ b/packages/core/Cargo.toml
@@ -22,6 +22,7 @@ cli = [ "dep:indicatif" ]
 # features[default]
 onelauncher_macros = { workspace = true }
 onelauncher_prisma = { workspace = true }
+onelauncher_utils = { workspace = true }
 interpulse = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
@@ -50,7 +51,6 @@ async_zip = { workspace = true }
 discord-rich-presence = { workspace = true }
 regex = { workspace = true }
 sysinfo = { workspace = true }
-sys-info = { workspace = true }
 whoami = { workspace = true }
 lazy_static = { workspace = true }
 async-tungstenite = { workspace = true }
@@ -58,15 +58,12 @@ async-recursion = { workspace = true }
 tokio-stream = { workspace = true }
 bytes = { workspace = true }
 tempfile = { workspace = true }
-dunce = { workspace = true }
 rand = { workspace = true }
 p256 = { workspace = true }
 byteorder = { workspace = true }
 base64 = { workspace = true }
-async-compression = { workspace = true }
 flate2 = { workspace = true }
 toml = { workspace = true }
-nom = { workspace = true }
 url = { workspace = true }
 
 # features[tauri]
diff --git a/packages/core/prisma/schema.prisma b/packages/core/prisma/schema.prisma
index f6e46af8..0f0b7704 100644
--- a/packages/core/prisma/schema.prisma
+++ b/packages/core/prisma/schema.prisma
@@ -14,7 +14,7 @@ generator client {
 model Settings {
   /// The unique ID associated with this Settings instance.
   id                 Int     @id @unique @default(0)
-  /// A OneLauncher theme managed by the core GUI.
+  /// A OneLauncher theme managed by the core GUI. (system, light, dark, oled, mocha)
   theme              String  @default("dark")
   /// Whether or not ask for confirmation when closing the core GUI.
   hide_close_prompt  Boolean @default(true)
diff --git a/packages/core/src/api/cluster/content/logger.rs b/packages/core/src/api/cluster/content/logger.rs
index c7d55e41..20056f0c 100644
--- a/packages/core/src/api/cluster/content/logger.rs
+++ b/packages/core/src/api/cluster/content/logger.rs
@@ -1,17 +1,17 @@
-//! OneLauncher log management
+//! `OneLauncher` log management
 
 use crate::data::{Credentials, Directories, MinecraftCredentials};
 use crate::prelude::ClusterPath;
 use crate::utils::http;
-use crate::utils::io::{self, IOError};
 use futures::TryFutureExt;
+use onelauncher_utils::io::{self, IOError};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::time::SystemTime;
 use tokio::io::{AsyncReadExt, AsyncSeekExt};
 
 // TODO: put this in the global store
-/// Core logging state and reader for OneLauncher.
+/// Core logging state and reader for `OneLauncher`.
 #[derive(Serialize, Debug)]
 pub struct LogManager {
 	/// Type log type associated with this log file.
@@ -128,7 +128,7 @@ pub async fn delete_logs(cluster_path: ClusterPath) -> crate::Result<()> {
 		let entry = entry.map_err(|e| IOError::with_path(e, &logs_folder))?;
 		let path = entry.path();
 		if path.is_dir() {
-			io::remove_dir_all(&path).await?
+			io::remove_dir_all(&path).await?;
 		}
 	}
 
@@ -170,14 +170,13 @@ pub async fn get_live_log_cursor(
 	mut cursor: u64,
 ) -> crate::Result<LogCursor> {
 	let cluster_path = cluster_path.cluster_path().await?;
-	let state = crate::State::get().await?;
 	let logs_folder = Directories::cluster_logs_dir(&cluster_path).await?;
 	let path = logs_folder.join(log_file);
 	if !path.exists() {
 		return Ok(LogCursor {
 			cursor: 0,
 			new: false,
-			output: LogOutput("".to_string()),
+			output: LogOutput(String::new()),
 		});
 	}
 
@@ -188,12 +187,13 @@ pub async fn get_live_log_cursor(
 		.metadata()
 		.await
 		.map_err(|e| IOError::with_path(e, &path))?;
-	let mut new = false;
 
-	if cursor > metadata.len() {
+	let new = if cursor > metadata.len() {
 		cursor = 0;
-		new = true;
-	}
+		true
+	} else {
+		false
+	};
 
 	let mut buf = Vec::new();
 	file.seek(std::io::SeekFrom::Start(cursor))
@@ -205,7 +205,8 @@ pub async fn get_live_log_cursor(
 		.await?;
 	let output = String::from_utf8_lossy(&buf).to_string();
 	let cursor = cursor + bytes_read as u64;
-	let creds: Vec<MinecraftCredentials> = state
+	let creds: Vec<MinecraftCredentials> = crate::State::get()
+		.await?
 		.users
 		.read()
 		.await
@@ -213,11 +214,11 @@ pub async fn get_live_log_cursor(
 		.clone()
 		.into_values()
 		.collect();
-	let output = LogOutput::censor_secrets(output, &creds, None);
+	let output = LogOutput::censor_secrets(output, &creds, &None);
 	Ok(LogCursor {
 		cursor,
-		new,
 		output,
+		new,
 	})
 }
 
@@ -262,13 +263,13 @@ pub async fn get_output_by_file(
 	log_type: LogType,
 	log_file: &str,
 ) -> crate::Result<LogOutput> {
-	let state = crate::State::get().await?;
 	let logs_folder = match log_type {
 		LogType::Info => Directories::cluster_logs_dir(cluster_path).await?,
 		LogType::Crash => Directories::crash_reports_dir(cluster_path).await?,
 	};
 	let path = logs_folder.join(log_file);
-	let credentials: Vec<MinecraftCredentials> = state
+	let credentials: Vec<MinecraftCredentials> = crate::State::get()
+		.await?
 		.users
 		.read()
 		.await
@@ -279,7 +280,7 @@ pub async fn get_output_by_file(
 
 	let result = read_log_to_string(&path).await?;
 
-	return Ok(LogOutput::censor_secrets(result, &credentials, None));
+	return Ok(LogOutput::censor_secrets(result, &credentials, &None));
 }
 
 /// The log cursor used to parse logs passed into [`LogManager`].
@@ -303,14 +304,14 @@ impl LogOutput {
 	pub fn censor_secrets(
 		mut output: String,
 		credentials: &Vec<MinecraftCredentials>,
-		_credentials_store: Option<Credentials>,
+		_credentials_store: &Option<Credentials>,
 	) -> Self {
 		let username = whoami::username();
 		let realname = whoami::realname();
-		output = output.replace(&format!("/{}/", username), "/{ENV_USERNAME}/");
-		output = output.replace(&format!("\\{}\\", username), "\\{ENV_USERNAME}\\");
-		output = output.replace(&format!("/{}/", realname), "/{ENV_REALNAME}/");
-		output = output.replace(&format!("\\{}\\", realname), "\\{ENV_REALNAME}\\");
+		output = output.replace(&format!("/{username}/"), "/{ENV_USERNAME}/");
+		output = output.replace(&format!("\\{username}\\"), "\\{ENV_USERNAME}\\");
+		output = output.replace(&format!("/{realname}/"), "/{ENV_REALNAME}/");
+		output = output.replace(&format!("\\{realname}\\"), "\\{ENV_REALNAME}\\");
 
 		for cred in credentials {
 			output = output.replace(&cred.access_token, "{MC_ACCESS_TOKEN}");
@@ -323,6 +324,15 @@ impl LogOutput {
 	}
 }
 
+#[derive(serde::Deserialize)]
+struct McLogsResponse {
+	pub success: bool,
+	#[serde(default)]
+	pub id: Option<String>,
+	#[serde(default)]
+	pub error: Option<String>,
+}
+
 /// Upload a log to https://mclo.gs/. If successful, it returns the log id
 #[tracing::instrument]
 pub async fn upload_log(path: &ClusterPath, log: LogOutput) -> crate::Result<String> {
@@ -330,16 +340,7 @@ pub async fn upload_log(path: &ClusterPath, log: LogOutput) -> crate::Result<Str
 	let mut form = HashMap::new();
 	form.insert("content", log);
 
-	#[derive(serde::Deserialize)]
-	struct ResponseBody {
-		pub success: bool,
-		#[serde(default)]
-		pub id: Option<String>,
-		#[serde(default)]
-		pub error: Option<String>,
-	}
-
-	let parsed = serde_json::from_slice::<ResponseBody>(
+	let parsed = serde_json::from_slice::<McLogsResponse>(
 		&http::REQWEST_CLIENT
 			.post(format!("{}/log", crate::constants::MCLOGS_API_URL))
 			.header("Content-Type", "application/x-www-form-urlencoded")
@@ -351,11 +352,10 @@ pub async fn upload_log(path: &ClusterPath, log: LogOutput) -> crate::Result<Str
 	)?;
 
 	if parsed.success {
-		if let Some(id) = parsed.id {
-			Ok(id)
-		} else {
-			Err(anyhow::anyhow!("failed to get log id from mclo.gs").into())
-		}
+		parsed.id.map_or_else(
+			|| Err(anyhow::anyhow!("failed to get log id from mclo.gs").into()),
+			Ok,
+		)
 	} else {
 		Err(anyhow::anyhow!(
 			"failed to upload log to mclo.gs: {}",
diff --git a/packages/core/src/api/cluster/content/package.rs b/packages/core/src/api/cluster/content/package.rs
index 5174858d..ee5457c8 100644
--- a/packages/core/src/api/cluster/content/package.rs
+++ b/packages/core/src/api/cluster/content/package.rs
@@ -1,10 +1,13 @@
+#![allow(clippy::significant_drop_tightening)]
+
 use crate::data::{Loader, ManagedPackage, ManagedVersion, PackageType};
 use crate::prelude::PackagePath;
 use crate::processor::Cluster;
 use crate::proxy::send::send_internet;
 use crate::store::{ClusterPath, ManagedVersionFile, Package, PackageMetadata};
-use crate::utils::{http, io};
+use crate::utils::http;
 use crate::{Result, State};
+use onelauncher_utils::io;
 // TODO: Implement proper error handling
 
 /// Find a managed version using filters
@@ -23,7 +26,7 @@ pub async fn find_managed_version(
 	let versions = provider
 		.get_all_versions(
 			&package.id,
-			game_version.as_ref().map(|v| vec![v.to_owned()]).to_owned(),
+			game_version.as_ref().map(|v| vec![v.to_owned()]).clone(),
 			loader.map(|l| vec![l]).clone(),
 		)
 		.await?;
@@ -45,7 +48,7 @@ pub async fn find_managed_version(
 
 			check_game_version && check_loader && check_package_version
 		})
-		.ok_or(anyhow::anyhow!("no matching version found"))
+		.ok_or_else(|| anyhow::anyhow!("no matching version found"))
 		.cloned()?)
 }
 
@@ -72,14 +75,14 @@ pub async fn download_package(
 	.await?;
 
 	let loader = loader.unwrap_or(cluster.meta.loader);
-	let game_version = game_version.unwrap_or(cluster.meta.mc_version.clone());
+	let game_version = game_version.unwrap_or_else(|| cluster.meta.mc_version.clone());
 
 	let managed_version =
 		find_managed_version(package, Some(game_version), Some(loader), package_version).await?;
 
 	let file = managed_version
 		.get_primary_file()
-		.ok_or(anyhow::anyhow!("no primary file found"))?;
+		.ok_or_else(|| anyhow::anyhow!("no primary file found"))?;
 	tracing::info!(
 		"downloading file '{}' version '{}'",
 		file.file_name,
@@ -91,7 +94,7 @@ pub async fn download_package(
 		.hashes
 		.get("sha512")
 		.unwrap_or(&"unknown".to_string())
-		.to_owned(); // TODO: Figure out sha1
+		.to_owned();
 
 	let package = Package {
 		file_name: file.file_name.clone(),
@@ -122,7 +125,7 @@ async fn download_file(
 	let state = State::get().await?;
 	let bytes = http::fetch(
 		&file.url,
-		file.hashes.get("sha1").map(|s| s.as_str()),
+		file.hashes.get("sha1").map(String::as_str),
 		&state.fetch_semaphore,
 	)
 	.await?;
@@ -135,6 +138,8 @@ async fn download_file(
 		return Err(err);
 	};
 
+	drop(state);
+
 	Ok(path)
 }
 
@@ -150,7 +155,7 @@ pub async fn add_package(
 	let mut manager = state.packages.write().await;
 	let manager = manager
 		.get_mut(cluster_path)
-		.ok_or(anyhow::anyhow!("cluster not found in packages map"))?;
+		.ok_or_else(|| anyhow::anyhow!("cluster not found in packages map"))?;
 
 	manager
 		.add_package(package_path, package, package_type)
@@ -170,7 +175,7 @@ pub async fn remove_package(
 	let mut manager = state.packages.write().await;
 	let manager = manager
 		.get_mut(cluster_path)
-		.ok_or(anyhow::anyhow!("cluster not found in packages map"))?;
+		.ok_or_else(|| anyhow::anyhow!("cluster not found in packages map"))?;
 
 	manager.remove_package(package_path, package_type).await?;
 
@@ -188,14 +193,14 @@ pub async fn get_package(
 	let manager = state.packages.read().await;
 	let manager = manager
 		.get(cluster_path)
-		.ok_or(anyhow::anyhow!("cluster not found in packages map"))?;
+		.ok_or_else(|| anyhow::anyhow!("cluster not found in packages map"))?;
 
 	Ok(manager
 		.get(package_type)
 		.packages
 		.get(package_path)
 		.cloned()
-		.ok_or(anyhow::anyhow!("package not found"))?)
+		.ok_or_else(|| anyhow::anyhow!("package not found"))?)
 }
 
 /// Get packages from a cluster.
@@ -208,7 +213,7 @@ pub async fn get_packages(
 	let manager = state.packages.read().await;
 	let manager = manager
 		.get(cluster_path)
-		.ok_or(anyhow::anyhow!("cluster not found in packages map"))?;
+		.ok_or_else(|| anyhow::anyhow!("cluster not found in packages map"))?;
 
 	Ok(manager
 		.get(package_type)
@@ -225,7 +230,7 @@ pub async fn sync_packages(cluster_path: &ClusterPath) -> Result<()> {
 	let mut manager = state.packages.write().await;
 	let manager = manager
 		.get_mut(cluster_path)
-		.ok_or(anyhow::anyhow!("cluster not found in packages map"))?;
+		.ok_or_else(|| anyhow::anyhow!("cluster not found in packages map"))?;
 
 	manager.sync_packages(&state.directories).await;
 
@@ -242,7 +247,7 @@ pub async fn sync_packages_by_type(
 	let mut manager = state.packages.write().await;
 	let manager = manager
 		.get_mut(cluster_path)
-		.ok_or(anyhow::anyhow!("cluster not found in packages map"))?;
+		.ok_or_else(|| anyhow::anyhow!("cluster not found in packages map"))?;
 
 	manager
 		.sync_packages_by_type(&state.directories, package_type)
diff --git a/packages/core/src/api/cluster/content/screenshots.rs b/packages/core/src/api/cluster/content/screenshots.rs
index ef1bf5b1..e8f9ef79 100644
--- a/packages/core/src/api/cluster/content/screenshots.rs
+++ b/packages/core/src/api/cluster/content/screenshots.rs
@@ -1,5 +1,5 @@
-use crate::utils::io;
 use crate::Result;
+use onelauncher_utils::io;
 
 use crate::store::ClusterPath;
 
diff --git a/packages/core/src/api/cluster/content/worlds.rs b/packages/core/src/api/cluster/content/worlds.rs
index fc8b384e..719a3863 100644
--- a/packages/core/src/api/cluster/content/worlds.rs
+++ b/packages/core/src/api/cluster/content/worlds.rs
@@ -1,5 +1,5 @@
-use crate::utils::io;
 use crate::Result;
+use onelauncher_utils::io;
 
 use crate::store::ClusterPath;
 
diff --git a/packages/core/src/api/cluster/create.rs b/packages/core/src/api/cluster/create.rs
index d6790434..1dd6d715 100644
--- a/packages/core/src/api/cluster/create.rs
+++ b/packages/core/src/api/cluster/create.rs
@@ -5,9 +5,9 @@ use crate::package::from::CreatePackCluster;
 use crate::proxy::send::send_cluster;
 use crate::proxy::ClusterPayloadType;
 pub use crate::store::{Cluster, ClusterPath, JavaOptions, PackageData, State};
-use crate::utils::io::{self, canonicalize};
 use crate::{cluster, package};
 use interpulse::api::modded::LoaderVersion;
+use onelauncher_utils::io::{self, canonicalize};
 use std::path::PathBuf;
 
 /// Creates a [`Cluster`] and adds it to the memory [`State`].
@@ -60,10 +60,10 @@ pub async fn create_cluster(
 		"creating cluster at path {}",
 		&canonicalize(&path)?.display()
 	);
-	let loader = if mod_loader != Loader::Vanilla {
-		get_loader_version(mc_version.clone(), mod_loader, loader_version).await?
-	} else {
+	let loader = if mod_loader == Loader::Vanilla {
 		None
+	} else {
+		get_loader_version(mc_version.clone(), mod_loader, loader_version).await?
 	};
 
 	let mut cluster = Cluster::new(uuid, name, mc_version).await?;
@@ -101,8 +101,10 @@ pub async fn create_cluster(
 		.await?;
 
 		{
-			let mut clusters = state.clusters.write().await;
-			clusters
+			state
+				.clusters
+				.write()
+				.await
 				.insert(cluster.clone(), skip_watch.unwrap_or_default())
 				.await?;
 		}
@@ -129,7 +131,7 @@ pub async fn create_cluster(
 	match result {
 		Ok(cluster) => Ok(cluster),
 		Err(err) => {
-			let _ = crate::api::cluster::remove(&cluster.cluster_path()).await;
+			let _ = cluster::remove(&cluster.cluster_path()).await;
 
 			Err(err)
 		}
@@ -170,11 +172,10 @@ pub async fn create_cluster_from_duplicate(from: ClusterPath) -> crate::Result<C
 	)
 	.await?;
 
-	let state = State::get().await?;
 	let copied = package::import::copy_minecraft(
 		cluster_path.clone(),
 		from.full_path().await?,
-		&state.io_semaphore,
+		&State::get().await?.io_semaphore,
 		None,
 	)
 	.await?;
@@ -221,8 +222,8 @@ pub(crate) async fn get_loader_version(
 		"stable" => it.stable,
 		id => {
 			it.id == *id
-				|| format!("{}-{}", mc_version, id) == it.id
-				|| format!("{}-{}-{}", mc_version, id, mc_version) == it.id
+				|| format!("{mc_version}-{id}") == it.id
+				|| format!("{mc_version}-{id}-{mc_version}") == it.id
 		}
 	};
 
@@ -237,7 +238,7 @@ pub(crate) async fn get_loader_version(
 
 	let loader_meta = loader_meta
 		.to_owned()
-		.ok_or(anyhow::anyhow!("couldn't get game versions"))?;
+		.ok_or_else(|| anyhow::anyhow!("couldn't get game versions"))?;
 
 	let loaders = &loader_meta
 		.game_versions
@@ -256,10 +257,12 @@ pub(crate) async fn get_loader_version(
 		.iter()
 		.find(|&it| filter(it))
 		.cloned()
-		.or(if version == "stable" {
-			loaders.iter().next().cloned()
-		} else {
-			None
+		.or_else(|| {
+			if version == "stable" {
+				loaders.iter().next().cloned()
+			} else {
+				None
+			}
 		})
 		.ok_or_else(|| CreateClusterError::InvalidLoaderVersion(version, loader.to_string()))?;
 
diff --git a/packages/core/src/api/cluster/mod.rs b/packages/core/src/api/cluster/mod.rs
index dfb99127..1fa0ac6e 100644
--- a/packages/core/src/api/cluster/mod.rs
+++ b/packages/core/src/api/cluster/mod.rs
@@ -1,4 +1,4 @@
-//! **OneLauncher Cluster**
+//! **`OneLauncher` Cluster**
 //!
 //! API for creating our managed Minecraft instances, Clusters.
 
@@ -11,7 +11,7 @@ use crate::proxy::ClusterPayloadType;
 pub use crate::store::{Cluster, JavaOptions, State};
 use crate::store::{MinecraftCredentials, ProcessorChild};
 
-use crate::utils::io::{self, IOError};
+use onelauncher_utils::io::{self, IOError};
 
 use std::collections::HashMap;
 use std::future::Future;
@@ -66,7 +66,7 @@ pub async fn list_grouped() -> crate::Result<HashMap<String, Vec<Cluster>>> {
 			.meta
 			.group
 			.clone()
-			.unwrap_or(String::from("Ungrouped"));
+			.unwrap_or_else(|| String::from("Ungrouped"));
 		if let Some(items) = map.get_mut(&group) {
 			items.push(cluster);
 		} else {
@@ -141,7 +141,7 @@ pub async fn run_credentials(
 		if let Some(command) = cmd.next() {
 			let full_path = path.full_path().await?;
 			let result = Command::new(command)
-				.args(cmd.collect::<Vec<&str>>())
+				.args(cmd)
 				.current_dir(&full_path)
 				.spawn()
 				.map_err(|e| IOError::with_path(e, &full_path))?
@@ -359,8 +359,8 @@ pub async fn get_optimal_java_version(path: &ClusterPath) -> crate::Result<Optio
 		let metadata = state.metadata.read().await;
 		let minecraft_metadata = metadata
 			.minecraft
-			.to_owned()
-			.ok_or(anyhow::anyhow!("couldn't get minecraft metadata"))?;
+			.clone()
+			.ok_or_else(|| anyhow::anyhow!("couldn't get minecraft metadata"))?;
 
 		let version = minecraft_metadata
 			.versions
@@ -421,6 +421,7 @@ pub async fn update_playtime(path: &ClusterPath) -> crate::Result<()> {
 }
 
 /// Sanitize a user-inputted [`Cluster`] name.
+#[must_use]
 pub fn sanitize_cluster_name(input: &str) -> String {
 	input.replace(['/', '\\', '?', '*', ':', '\'', '\"', '|', '<', '>'], "_")
 }
diff --git a/packages/core/src/api/handler.rs b/packages/core/src/api/handler.rs
index 378b93fb..cf7fdff6 100644
--- a/packages/core/src/api/handler.rs
+++ b/packages/core/src/api/handler.rs
@@ -2,7 +2,7 @@ use std::path::PathBuf;
 
 use crate::api::prelude::InternetPayload;
 use crate::proxy::send::{send_internet, send_message};
-use crate::utils::io;
+use onelauncher_utils::io;
 
 pub async fn parse_uri(cmd: &str) -> crate::Result<()> {
 	let cmd = handle_cmd(cmd).await?;
diff --git a/packages/core/src/api/java.rs b/packages/core/src/api/java.rs
index 99363f11..692095d2 100644
--- a/packages/core/src/api/java.rs
+++ b/packages/core/src/api/java.rs
@@ -5,9 +5,9 @@ use serde::Deserialize;
 
 use crate::proxy::send::{init_ingress, send_ingress};
 use crate::utils::http::{fetch_advanced, fetch_json};
-use crate::utils::io::{self, IOError};
 use crate::utils::java::{self, get_java_version, JavaVersion};
 use crate::State;
+use onelauncher_utils::io::{self, IOError};
 
 pub async fn filter_java_version(java_version: Option<u32>) -> crate::Result<Vec<JavaVersion>> {
 	let java = java::locate_java().await?;
@@ -15,11 +15,7 @@ pub async fn filter_java_version(java_version: Option<u32>) -> crate::Result<Vec
 		java.into_iter()
 			.filter(|j| {
 				let jre_version = get_java_version(&j.version);
-				if let Ok(jre_version) = jre_version {
-					jre_version.1 == java_version
-				} else {
-					false
-				}
+				jre_version.map_or(false, |jre_version| jre_version.1 == java_version)
 			})
 			.collect()
 	} else {
@@ -27,6 +23,13 @@ pub async fn filter_java_version(java_version: Option<u32>) -> crate::Result<Vec
 	})
 }
 
+#[derive(Deserialize)]
+struct JavaPackage {
+	pub download_url: String,
+	pub name: PathBuf,
+}
+
+// TODO: support more than just zulu ?
 #[onelauncher_macros::memory]
 pub async fn install_java(java_version: u32) -> crate::Result<PathBuf> {
 	let state = State::get().await?;
@@ -40,14 +43,8 @@ pub async fn install_java(java_version: u32) -> crate::Result<PathBuf> {
 	)
 	.await?;
 
-	#[derive(Deserialize)]
-	struct Package {
-		pub download_url: String,
-		pub name: PathBuf,
-	}
-
 	send_ingress(&ingress, 0.0, Some("fetching java api")).await?;
-	let packages = fetch_json::<Vec<Package>>(Method::GET, &format!(
+	let packages = fetch_json::<Vec<JavaPackage>>(Method::GET, &format!(
         "https://api.azul.com/metadata/v1/zulu/packages?arch={}&java_version={}&os={}&archive_type=zip&javafx_bundled=false&java_package_type=jre&page_size=1",
         std::env::consts::ARCH, java_version, std::env::consts::OS,
     ), None, None, &state.fetch_semaphore).await?;
@@ -93,11 +90,11 @@ pub async fn install_java(java_version: u32) -> crate::Result<PathBuf> {
 		#[cfg(target_os = "macos")]
 		{
 			base_path = base_path
-				.join(format!("zulu-{}.jre", java_version))
+				.join(format!("zulu-{java_version}.jre"))
 				.join("Contents")
 				.join("Home")
 				.join("bin")
-				.join("java")
+				.join("java");
 		}
 
 		#[cfg(not(target_os = "macos"))]
@@ -122,9 +119,8 @@ pub async fn check_java(path: PathBuf) -> crate::Result<Option<JavaVersion>> {
 }
 
 pub async fn test_java(path: PathBuf, major: u32) -> crate::Result<bool> {
-	let jvm = match java::check_java_instance(&path).await {
-		Some(jvm) => jvm,
-		None => return Ok(false),
+	let Some(jvm) = java::check_java_instance(&path).await else {
+		return Ok(false);
 	};
 
 	let (maj, _) = get_java_version(&jvm.version)?;
diff --git a/packages/core/src/api/metadata.rs b/packages/core/src/api/metadata.rs
index 9cc749f0..75c6bfee 100644
--- a/packages/core/src/api/metadata.rs
+++ b/packages/core/src/api/metadata.rs
@@ -5,6 +5,7 @@ pub use interpulse::api::minecraft::VersionManifest;
 pub use interpulse::api::modded::Manifest;
 
 // TODO: better error handling (prisma?)
+// TODO: fix this lmao
 
 /// Get a [`VersionManifest`] for all available Minecraft versions.
 #[tracing::instrument]
@@ -16,7 +17,7 @@ pub async fn get_minecraft_versions() -> crate::Result<VersionManifest> {
 		.await
 		.minecraft
 		.clone()
-		.ok_or(anyhow::anyhow!("couldn't get minecraft metadata"))?;
+		.ok_or_else(|| anyhow::anyhow!("couldn't get minecraft metadata"))?;
 
 	Ok(meta)
 }
@@ -31,7 +32,7 @@ pub async fn get_fabric_versions() -> crate::Result<Manifest> {
 		.await
 		.fabric
 		.clone()
-		.ok_or(anyhow::anyhow!("couldn't get fabric metadata"))?;
+		.ok_or_else(|| anyhow::anyhow!("couldn't get fabric metadata"))?;
 
 	Ok(meta)
 }
@@ -46,7 +47,7 @@ pub async fn get_quilt_versions() -> crate::Result<Manifest> {
 		.await
 		.quilt
 		.clone()
-		.ok_or(anyhow::anyhow!("couldn't get quilt metadata"))?;
+		.ok_or_else(|| anyhow::anyhow!("couldn't get quilt metadata"))?;
 
 	Ok(meta)
 }
@@ -61,7 +62,7 @@ pub async fn get_forge_versions() -> crate::Result<Manifest> {
 		.await
 		.forge
 		.clone()
-		.ok_or(anyhow::anyhow!("couldn't get forge metadata"))?;
+		.ok_or_else(|| anyhow::anyhow!("couldn't get forge metadata"))?;
 
 	Ok(meta)
 }
@@ -76,7 +77,7 @@ pub async fn get_neoforge_versions() -> crate::Result<Manifest> {
 		.await
 		.neoforge
 		.clone()
-		.ok_or(anyhow::anyhow!("couldn't get neoforge metadata"))?;
+		.ok_or_else(|| anyhow::anyhow!("couldn't get neoforge metadata"))?;
 
 	Ok(meta)
 }
@@ -91,7 +92,7 @@ pub async fn get_neoforge_versions() -> crate::Result<Manifest> {
 // 		.await
 // 		.legacy_fabric
 // 		.clone()
-// 		.ok_or(anyhow!("missing legacyfabric metadata"))?;
+// 		.ok_or_else(|| anyhow!("missing legacyfabric metadata"))?;
 
 // 	Ok(meta)
 // }
diff --git a/packages/core/src/api/mod.rs b/packages/core/src/api/mod.rs
index 80706aaf..5baf45c5 100644
--- a/packages/core/src/api/mod.rs
+++ b/packages/core/src/api/mod.rs
@@ -1,4 +1,4 @@
-//! **OneLauncher API**
+//! **`OneLauncher` API**
 //!
 //! API for interacting with our Rust core.
 
@@ -26,7 +26,6 @@ pub mod prelude {
 	pub use crate::data::*;
 	pub use crate::proxy::InternetPayload;
 	pub use crate::store::{ClusterPath, JavaVersions, PackageDependency, PackagePath};
-	pub use crate::utils::io::{canonicalize, IOError};
 	pub use crate::utils::java::JavaVersion;
 	pub use crate::{java, metadata, minecraft, package, processor, settings, State};
 }
diff --git a/packages/core/src/api/package/content/mod.rs b/packages/core/src/api/package/content/mod.rs
index 3f4994e3..b2b928b9 100644
--- a/packages/core/src/api/package/content/mod.rs
+++ b/packages/core/src/api/package/content/mod.rs
@@ -1,6 +1,6 @@
-//! **OneLauncher Content Package**
+//! **`OneLauncher` Content Package**
 //!
-//! Utilities for searching and downloading content packages to OneLauncher.
+//! Utilities for searching and downloading content packages to `OneLauncher`.
 
 use modrinth::{Facet, FacetOperation};
 use serde::{Deserialize, Serialize};
@@ -27,19 +27,22 @@ impl std::fmt::Display for Providers {
 
 impl Providers {
 	/// Get the name of the provider
-	pub fn name(&self) -> &str {
+	#[must_use]
+	pub const fn name(&self) -> &str {
 		match self {
-			Providers::Modrinth => "Modrinth",
+			Self::Modrinth => "Modrinth",
 		}
 	}
 
 	/// Get the URL of the provider
-	pub fn url(&self) -> &str {
+	#[must_use]
+	pub const fn url(&self) -> &str {
 		match self {
-			Providers::Modrinth => "https://modrinth.com",
+			Self::Modrinth => "https://modrinth.com",
 		}
 	}
 
+	#[allow(clippy::too_many_arguments)]
 	pub async fn search(
 		&self,
 		query: Option<String>,
@@ -52,7 +55,7 @@ impl Providers {
 		open_source: Option<bool>,
 	) -> Result<ProviderSearchResults> {
 		match self {
-			Providers::Modrinth => modrinth::search(
+			Self::Modrinth => modrinth::search(
 				query,
 				limit,
 				offset,
@@ -112,17 +115,17 @@ impl Providers {
 
 	pub async fn list(&self) -> Result<Vec<ManagedPackage>> {
 		Ok(match self {
-			Providers::Modrinth => modrinth::list(),
+			Self::Modrinth => modrinth::list(),
 		}
 		.await?
 		.into_iter()
-		.map(|p| p.into())
+		.map(Into::into)
 		.collect())
 	}
 
 	pub async fn get(&self, slug_or_id: &str) -> Result<ManagedPackage> {
 		Ok(match self {
-			Providers::Modrinth => modrinth::get(slug_or_id),
+			Self::Modrinth => modrinth::get(slug_or_id),
 		}
 		.await?
 		.into())
@@ -130,11 +133,11 @@ impl Providers {
 
 	pub async fn get_multiple(&self, slug_or_ids: &[String]) -> Result<Vec<ManagedPackage>> {
 		Ok(match self {
-			Providers::Modrinth => modrinth::get_multiple(slug_or_ids),
+			Self::Modrinth => modrinth::get_multiple(slug_or_ids),
 		}
 		.await?
 		.into_iter()
-		.map(|p| p.into())
+		.map(Into::into)
 		.collect())
 	}
 
@@ -145,27 +148,27 @@ impl Providers {
 		loaders: Option<Vec<Loader>>,
 	) -> Result<Vec<ManagedVersion>> {
 		Ok(match self {
-			Providers::Modrinth => modrinth::get_all_versions(project_id, game_versions, loaders),
+			Self::Modrinth => modrinth::get_all_versions(project_id, game_versions, loaders),
 		}
 		.await?
 		.into_iter()
-		.map(|p| p.into())
+		.map(Into::into)
 		.collect())
 	}
 
 	pub async fn get_versions(&self, versions: Vec<String>) -> Result<Vec<ManagedVersion>> {
 		Ok(match self {
-			Providers::Modrinth => modrinth::get_versions(versions),
+			Self::Modrinth => modrinth::get_versions(versions),
 		}
 		.await?
 		.into_iter()
-		.map(|p| p.into())
+		.map(Into::into)
 		.collect())
 	}
 
 	pub async fn get_version(&self, version_id: &str) -> Result<ManagedVersion> {
 		Ok(match self {
-			Providers::Modrinth => modrinth::get_version(version_id),
+			Self::Modrinth => modrinth::get_version(version_id),
 		}
 		.await?
 		.into())
@@ -173,7 +176,7 @@ impl Providers {
 
 	pub async fn get_authors(&self, author: &Author) -> Result<Vec<ManagedUser>> {
 		match self {
-			Providers::Modrinth => modrinth::get_authors(author),
+			Self::Modrinth => modrinth::get_authors(author),
 		}
 		.await
 	}
diff --git a/packages/core/src/api/package/content/modrinth.rs b/packages/core/src/api/package/content/modrinth.rs
index 2d9e70fb..d5d6b050 100644
--- a/packages/core/src/api/package/content/modrinth.rs
+++ b/packages/core/src/api/package/content/modrinth.rs
@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::fmt::{Display, Formatter};
 
 use crate::data::{Loader, ManagedPackage, ManagedUser, ManagedVersion, PackageType};
@@ -14,7 +15,7 @@ use serde_json::Value;
 
 use super::Providers;
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct ModrinthPackage {
 	pub slug: String,
 	pub title: String,
@@ -61,9 +62,9 @@ pub struct ModrinthPackage {
 }
 
 impl From<ModrinthPackage> for ManagedPackage {
-	fn from(value: ModrinthPackage) -> ManagedPackage {
-		ManagedPackage {
-			provider: super::Providers::Modrinth,
+	fn from(value: ModrinthPackage) -> Self {
+		Self {
+			provider: Providers::Modrinth,
 			id: value.id,
 			title: value.title,
 			description: value.description,
@@ -93,14 +94,14 @@ impl From<ModrinthPackage> for ManagedPackage {
 	}
 }
 
-#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct DonationUrl {
 	pub id: String,
 	pub platform: String,
 	pub url: String,
 }
 
-#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Gallery {
 	pub url: String,
 	pub featured: bool,
@@ -119,7 +120,7 @@ struct SearchResults {
 	total_hits: u32,
 }
 
-#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct ModrinthVersion {
 	pub game_versions: Vec<String>,
 	pub loaders: Vec<String>,
@@ -140,7 +141,7 @@ pub struct ModrinthVersion {
 	pub dependencies: Vec<Value>,
 }
 
-#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct File {
 	pub url: String,
 	pub filename: String,
@@ -151,20 +152,20 @@ pub struct File {
 
 impl From<File> for ManagedVersionFile {
 	fn from(value: File) -> Self {
-		ManagedVersionFile {
+		Self {
 			url: value.url,
 			file_name: value.filename,
 			primary: value.primary,
 			size: value.size,
 			file_type: value.file_type,
-			hashes: Default::default(), // TODO
+			hashes: HashMap::default(), // TODO
 		}
 	}
 }
 
 impl From<ModrinthVersion> for ManagedVersion {
 	fn from(value: ModrinthVersion) -> Self {
-		ManagedVersion {
+		Self {
 			id: value.id,
 			package_id: value.project_id,
 			author: value.author_id,
@@ -179,7 +180,7 @@ impl From<ModrinthVersion> for ManagedVersion {
 			downloads: value.downloads,
 			version_type: value.version_type,
 
-			files: value.files.into_iter().map(|f| f.into()).collect(),
+			files: value.files.into_iter().map(Into::into).collect(),
 			deps: vec![], // TODO [`ManagedDependency`]?
 			game_versions: value.game_versions,
 			loaders: value
@@ -204,12 +205,12 @@ pub enum FacetOperation {
 impl Display for FacetOperation {
 	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
 		f.write_str(match self {
-			FacetOperation::NotEq => "!=",
-			FacetOperation::LargeEq => ">=",
-			FacetOperation::Large => ">",
-			FacetOperation::SmallEq => "<=",
-			FacetOperation::Small => "<",
-			FacetOperation::Eq => "=",
+			Self::NotEq => "!=",
+			Self::LargeEq => ">=",
+			Self::Large => ">",
+			Self::SmallEq => "<=",
+			Self::Small => "<",
+			Self::Eq => "=",
 		})
 	}
 }
@@ -217,7 +218,7 @@ impl Display for FacetOperation {
 pub struct Facet(pub String, pub FacetOperation, pub String);
 
 impl Display for Facet {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
 		f.write_str(format!("{}{}{}", self.0, self.1, self.2).as_str())
 	}
 }
@@ -227,8 +228,8 @@ pub struct FacetBuilder {
 }
 
 impl FacetBuilder {
-	pub fn builder() -> Self {
-		FacetBuilder { facets: vec![] }
+	pub const fn builder() -> Self {
+		Self { facets: vec![] }
 	}
 
 	pub fn and(&mut self, facet: Facet) -> &Self {
@@ -253,7 +254,7 @@ impl FacetBuilder {
 				if i != 0 {
 					stringified.push(',');
 				}
-				stringified.push_str(format!("\"{}\"", f.to_string()).as_str());
+				stringified.push_str(format!("\"{f}\"").as_str());
 			}
 			stringified.push(']');
 
@@ -293,7 +294,7 @@ pub async fn get_multiple(ids: &[String]) -> Result<Vec<ModrinthPackage>> {
 			format_url!(
 				"/projects?ids=[{}]",
 				ids.iter()
-					.map(|id| format!("\"{}\"", id))
+					.map(|id| format!("\"{id}\""))
 					.collect::<Vec<String>>()
 					.join(",")
 			)
@@ -335,9 +336,9 @@ where
 				limit.unwrap_or(10),
 				offset.unwrap_or(0),
 				if facets.is_empty() {
-					"".to_string()
+					String::new()
 				} else {
-					format!("&facets=[{}]", facets)
+					format!("&facets=[{facets}]")
 				}
 			)
 			.as_str(),
@@ -456,7 +457,7 @@ pub async fn get_all_versions(
 			"game_versions",
 			&game_versions
 				.iter()
-				.map(|v| format!("\"{}\"", v.to_string()))
+				.map(|v| format!("\"{v}\""))
 				.collect::<Vec<String>>()
 				.join(","),
 		);
@@ -469,7 +470,7 @@ pub async fn get_all_versions(
 				"[{}]",
 				&loaders
 					.iter()
-					.map(|l| format!("\"{}\"", l.to_string()))
+					.map(|l| format!("\"{l}\""))
 					.collect::<Vec<String>>()
 					.join(",")
 			)
@@ -494,7 +495,7 @@ pub async fn get_versions(versions: Vec<String>) -> Result<Vec<ModrinthVersion>>
 				"/versions?ids=[{}]",
 				versions
 					.iter()
-					.map(|v| format!("\"{}\"", v))
+					.map(|v| format!("\"{v}\""))
 					.collect::<Vec<String>>()
 					.join(",")
 			)
diff --git a/packages/core/src/api/package/from.rs b/packages/core/src/api/package/from.rs
index c26c1146..95024ca1 100644
--- a/packages/core/src/api/package/from.rs
+++ b/packages/core/src/api/package/from.rs
@@ -6,8 +6,8 @@ use crate::proxy::send::{init_ingress, send_ingress};
 use crate::proxy::IngressId;
 use crate::store::{ClusterStage, PackageSide};
 use crate::utils::http::{fetch, fetch_advanced, fetch_json, write_icon};
-use crate::utils::io;
 use crate::{IngressType, InnerPathLinux, State};
+use onelauncher_utils::io;
 use reqwest::Method;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -46,9 +46,9 @@ pub enum PackFileHash {
 impl From<String> for PackFileHash {
 	fn from(s: String) -> Self {
 		return match s.as_str() {
-			"sha1" => PackFileHash::Sha1,
-			"sha512" => PackFileHash::Sha512,
-			_ => PackFileHash::Unknown(s),
+			"sha1" => Self::Sha1,
+			"sha512" => Self::Sha512,
+			_ => Self::Unknown(s),
 		};
 	}
 }
@@ -120,7 +120,7 @@ pub struct CreatePackCluster {
 
 impl Default for CreatePackCluster {
 	fn default() -> Self {
-		CreatePackCluster {
+		Self {
 			name: "Untitled".to_string(),
 			mc_version: "1.20.4".to_string(),
 			mod_loader: Loader::Vanilla,
@@ -150,6 +150,7 @@ pub struct CreatePackDescription {
 	pub cluster_path: ClusterPath,
 }
 
+#[must_use]
 pub fn get_cluster_from_pack(location: CreatePackLocation) -> CreatePackCluster {
 	match location {
 		CreatePackLocation::FromModrinth {
@@ -320,11 +321,11 @@ pub async fn generate_pack_from_file(
 /// Sets generated cluster attributes to the pack attributes (using `cluster::edit`).
 /// This includes the pack name, icon, game version, loader version, and loader.
 #[onelauncher_macros::memory]
-pub async fn set_cluster_information(
+pub async fn set_cluster_information<S: ::std::hash::BuildHasher>(
 	cluster_path: ClusterPath,
 	description: &CreatePackDescription,
 	backup_name: &str,
-	deps: &HashMap<PackDependency, String>,
+	deps: &HashMap<PackDependency, String, S>,
 	ignore_lock: bool,
 ) -> crate::Result<()> {
 	let mut game_version: Option<&String> = None;
@@ -353,22 +354,19 @@ pub async fn set_cluster_information(
 		}
 	}
 
-	let game_version = if let Some(game_version) = game_version {
-		game_version
-	} else {
+	let Some(game_version) = game_version else {
 		return Err(anyhow::anyhow!("pack did not specify Minecraft version").into());
 	};
-
 	let mod_loader = mod_loader.unwrap_or(Loader::Vanilla);
-	let loader_version = if mod_loader != Loader::Vanilla {
+	let loader_version = if mod_loader == Loader::Vanilla {
+		None
+	} else {
 		crate::cluster::create::get_loader_version(
 			game_version.clone(),
 			mod_loader,
 			loader_version.cloned(),
 		)
 		.await?
-	} else {
-		None
 	};
 
 	crate::api::cluster::edit(&cluster_path, |cl| {
@@ -384,10 +382,10 @@ pub async fn set_cluster_information(
 			Some(PackageData {
 				package_id,
 				version_id,
-				locked: if !ignore_lock {
-					Some(true)
-				} else {
+				locked: if ignore_lock {
 					cl.meta.package_data.as_ref().and_then(|x| x.locked)
+				} else {
+					Some(true)
 				},
 			})
 		} else {
diff --git a/packages/core/src/api/package/import/atlauncher.rs b/packages/core/src/api/package/import/atlauncher.rs
index 79231703..095ca023 100644
--- a/packages/core/src/api/package/import/atlauncher.rs
+++ b/packages/core/src/api/package/import/atlauncher.rs
@@ -1,5 +1,5 @@
-//! Launcher Import: ATLauncher
-//! Source Code available at https://github.com/ATLauncher/ATLauncher
+//! Launcher Import: `ATLauncher`
+//! Source Code available at <https://github.com/ATLauncher/ATLauncher>
 
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -10,7 +10,7 @@ use crate::package::import::{self, copy_minecraft};
 use crate::package::{self};
 use crate::prelude::{Cluster, ClusterPath, Loader};
 use crate::store::{ClusterStage, PackageData, State};
-use crate::utils::io;
+use onelauncher_utils::io;
 
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -97,7 +97,7 @@ pub struct ATLauncherMod {
 pub async fn is_valid_atlauncher(instance_folder: PathBuf) -> bool {
 	let instance: String = io::read_to_string(&instance_folder.join("instance.json"))
 		.await
-		.unwrap_or("".to_string());
+		.unwrap_or(String::new());
 	let instance: Result<ATInstance, serde_json::Error> =
 		serde_json::from_str::<ATInstance>(&instance);
 	if let Err(e) = instance {
@@ -157,7 +157,7 @@ pub async fn import_atlauncher(
 		cluster_path: cluster_path.clone(),
 	};
 
-	let backup_name = format!("ATLauncher-{}", instance_folder);
+	let backup_name = format!("ATLauncher-{instance_folder}");
 	let minecraft_folder = atlauncher_instance_path;
 
 	import_atlauncher_unmanaged(
@@ -186,15 +186,15 @@ async fn import_atlauncher_unmanaged(
 	let mod_loader: Loader = serde_json::from_str::<Loader>(&mod_loader)?;
 
 	let game_version = atinstance.id;
-	let loader_version = if mod_loader != Loader::Vanilla {
+	let loader_version = if mod_loader == Loader::Vanilla {
+		None
+	} else {
 		crate::cluster::create::get_loader_version(
 			game_version.clone(),
 			mod_loader,
 			Some(atinstance.launcher.loader_version.version.clone()),
 		)
 		.await?
-	} else {
-		None
 	};
 
 	crate::api::cluster::edit(&cluster_path, |cl| {
diff --git a/packages/core/src/api/package/import/curseforge.rs b/packages/core/src/api/package/import/curseforge.rs
index dc8ce911..225b9d36 100644
--- a/packages/core/src/api/package/import/curseforge.rs
+++ b/packages/core/src/api/package/import/curseforge.rs
@@ -1,4 +1,4 @@
-//! Launcher Import: CurseForge
+//! Launcher Import: `CurseForge`
 //! Closed Source, all this information is datamined unfortunately.
 
 use serde::{Deserialize, Serialize};
@@ -8,7 +8,7 @@ use super::{cache_icon, copy_minecraft};
 use crate::prelude::{Cluster, ClusterPath, Loader};
 use crate::store::{ClusterStage, State};
 use crate::utils::http::{fetch, write_icon};
-use crate::utils::io;
+use onelauncher_utils::io;
 
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
@@ -37,12 +37,13 @@ pub async fn is_valid_curseforge(instance_folder: PathBuf) -> bool {
 	let minecraftinstance: String =
 		io::read_to_string(&instance_folder.join("minecraftinstance.json"))
 			.await
-			.unwrap_or("".to_string());
+			.unwrap_or(String::new());
 	let minecraftinstance: Result<MinecraftInstance, serde_json::Error> =
 		serde_json::from_str::<MinecraftInstance>(&minecraftinstance);
 	minecraftinstance.is_ok()
 }
 
+#[allow(clippy::too_many_lines)]
 pub async fn import_curseforge(
 	// The path to the CurseForge instance
 	curseforge_instance_folder: PathBuf,
@@ -58,8 +59,7 @@ pub async fn import_curseforge(
 		"Curseforge-{}",
 		curseforge_instance_folder
 			.file_name()
-			.map(|a| a.to_string_lossy().to_string())
-			.unwrap_or("Unknown".to_string())
+			.map_or("Unknown".to_string(), |a| a.to_string_lossy().to_string())
 	);
 
 	let state = State::get().await?;
@@ -104,15 +104,15 @@ pub async fn import_curseforge(
 		}
 
 		let mod_loader = mod_loader.unwrap_or(Loader::Vanilla);
-		let loader_version = if mod_loader != Loader::Vanilla {
+		let loader_version = if mod_loader == Loader::Vanilla {
+			None
+		} else {
 			crate::cluster::create::get_loader_version(
 				game_version.clone(),
 				mod_loader,
 				loader_version,
 			)
 			.await?
-		} else {
-			None
 		};
 
 		crate::api::cluster::edit(&cluster_path, |cl| {
diff --git a/packages/core/src/api/package/import/ftb.rs b/packages/core/src/api/package/import/ftb.rs
index a266ba99..d842a3a7 100644
--- a/packages/core/src/api/package/import/ftb.rs
+++ b/packages/core/src/api/package/import/ftb.rs
@@ -1,2 +1,2 @@
 //! Launcher Import: FTB App
-//! Source Code available at https://github.com/FTBTeam/FTB-App
+//! Source Code available at <https://github.com/FTBTeam/FTB-App>
diff --git a/packages/core/src/api/package/import/gdlauncher.rs b/packages/core/src/api/package/import/gdlauncher.rs
index 71d9616a..377e3b49 100644
--- a/packages/core/src/api/package/import/gdlauncher.rs
+++ b/packages/core/src/api/package/import/gdlauncher.rs
@@ -1,5 +1,5 @@
-//! Launcher Import: GDLauncher (legacy)
-//! Source Code available at https://github.com/gorilla-devs/GDLauncher
+//! Launcher Import: `GDLauncher` (legacy)
+//! Source Code available at <https://github.com/gorilla-devs/GDLauncher>
 
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
@@ -7,7 +7,7 @@ use std::path::PathBuf;
 use super::{cache_icon, copy_minecraft};
 use crate::prelude::{Cluster, ClusterPath, Loader};
 use crate::store::{ClusterStage, State};
-use crate::utils::io;
+use onelauncher_utils::io;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -30,7 +30,7 @@ pub struct GDLauncherLoader {
 pub async fn is_valid_gdlauncher(instance_folder: PathBuf) -> bool {
 	let config: String = io::read_to_string(&instance_folder.join("config.json"))
 		.await
-		.unwrap_or("".to_string());
+		.unwrap_or(String::new());
 	let config: Result<GDLauncherConfig, serde_json::Error> =
 		serde_json::from_str::<GDLauncherConfig>(&config);
 	config.is_ok()
@@ -48,8 +48,7 @@ pub async fn import_gdlauncher(
 		"GDLauncher-{}",
 		gdlauncher_instance_folder
 			.file_name()
-			.map(|a| a.to_string_lossy().to_string())
-			.unwrap_or("Unknown".to_string())
+			.map_or("Unknown".to_string(), |a| a.to_string_lossy().to_string())
 	);
 
 	let icon = config
@@ -66,11 +65,11 @@ pub async fn import_gdlauncher(
 	let mod_loader = config.loader.loader_type;
 	let loader_version = config.loader.loader_version;
 
-	let loader_version = if mod_loader != Loader::Vanilla {
+	let loader_version = if mod_loader == Loader::Vanilla {
+		None
+	} else {
 		crate::cluster::create::get_loader_version(game_version.clone(), mod_loader, loader_version)
 			.await?
-	} else {
-		None
 	};
 
 	crate::api::cluster::edit(&cluster_path, |cl| {
diff --git a/packages/core/src/api/package/import/mod.rs b/packages/core/src/api/package/import/mod.rs
index 3db6f034..03a3f3c2 100644
--- a/packages/core/src/api/package/import/mod.rs
+++ b/packages/core/src/api/package/import/mod.rs
@@ -6,7 +6,7 @@ use crate::proxy::IngressId;
 
 use crate::store::Clusters;
 use crate::utils::http::{self, IoSemaphore};
-use crate::utils::io::{self, IOError};
+use onelauncher_utils::io::{self, IOError};
 use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::path::{Path, PathBuf};
@@ -24,19 +24,19 @@ pub mod tlauncher;
 #[cfg_attr(feature = "specta", derive(specta::Type))]
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
 pub enum ImportType {
-	/// MultiMC based launchers
+	/// `MultiMC` based launchers
 	MultiMC,
 	/// Prism Launcher has its own category because it has different logic (also is objectively better than mmc)
 	PrismLauncher,
-	/// GDLauncher
+	/// `GDLauncher`
 	GDLauncher,
 	/// Curseforge's launcher
 	Curseforge,
-	/// ATLauncher
+	/// `ATLauncher`
 	ATLauncher,
 	/// Modrinth app.
 	Modrinth,
-	/// TLauncher
+	/// `TLauncher`
 	TLauncher,
 	/// FTB Launcher
 	FTBLauncher,
@@ -50,16 +50,16 @@ pub enum ImportType {
 impl fmt::Display for ImportType {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		match self {
-			ImportType::MultiMC => write!(f, "MultiMC"),
-			ImportType::ATLauncher => write!(f, "ATLauncher"),
-			ImportType::Curseforge => write!(f, "Curseforge"),
-			ImportType::GDLauncher => write!(f, "GDLauncher"),
-			ImportType::Modrinth => write!(f, "Modrinth App"),
-			ImportType::PrismLauncher => write!(f, "PrismLauncher"),
-			ImportType::TLauncher => write!(f, "TLauncher"),
-			ImportType::FTBLauncher => write!(f, "Feed The Beast"),
-			ImportType::Technic => write!(f, "Technic"),
-			ImportType::Unknown => write!(f, "Unknown"),
+			Self::MultiMC => write!(f, "MultiMC"),
+			Self::ATLauncher => write!(f, "ATLauncher"),
+			Self::Curseforge => write!(f, "Curseforge"),
+			Self::GDLauncher => write!(f, "GDLauncher"),
+			Self::Modrinth => write!(f, "Modrinth App"),
+			Self::PrismLauncher => write!(f, "PrismLauncher"),
+			Self::TLauncher => write!(f, "TLauncher"),
+			Self::FTBLauncher => write!(f, "Feed The Beast"),
+			Self::Technic => write!(f, "Technic"),
+			Self::Unknown => write!(f, "Unknown"),
 		}
 	}
 }
@@ -77,9 +77,9 @@ pub async fn import_instances(import: ImportType, path: PathBuf) -> crate::Resul
 				.unwrap_or_else(|| "instances".to_string())
 		}
 		ImportType::Modrinth => "profiles".to_string(),
-		ImportType::TLauncher => "instances".to_string(),
-		ImportType::FTBLauncher => "instances".to_string(),
-		ImportType::Technic => "instances".to_string(),
+		ImportType::TLauncher => "tinstances".to_string(),
+		ImportType::FTBLauncher => "ftbinstances".to_string(),
+		ImportType::Technic => "tecinstances".to_string(),
 		_ => return Err(anyhow::anyhow!("launcher type unknown, cant import").into()),
 	};
 
@@ -152,7 +152,7 @@ pub async fn import_instance(
 	};
 
 	match result {
-		Ok(_) => {}
+		Ok(()) => {}
 		Err(e) => {
 			tracing::warn!("failed to import modpack: {:?}", e);
 			let _ = crate::api::cluster::remove(&cluster_path).await;
@@ -167,6 +167,7 @@ pub async fn import_instance(
 }
 
 /// returns the default path for a given [`ImportType`].
+#[must_use]
 pub fn default_launcher_path(r#type: ImportType) -> Option<PathBuf> {
 	let path = match r#type {
 		ImportType::MultiMC => None, // MultiMC data is in it's application directory
diff --git a/packages/core/src/api/package/import/modrinth.rs b/packages/core/src/api/package/import/modrinth.rs
index e68d771e..8bb632a7 100644
--- a/packages/core/src/api/package/import/modrinth.rs
+++ b/packages/core/src/api/package/import/modrinth.rs
@@ -1,11 +1,11 @@
 //! Launcher Import: Modrinth App
-//! Source Code available at https://github.com/modrinth/code
+//! Source Code available at <https://github.com/modrinth/code>
 
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
 use crate::prelude::ClusterPath;
-use crate::utils::io;
+use onelauncher_utils::io;
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct ModrinthProfile {}
@@ -13,7 +13,7 @@ pub struct ModrinthProfile {}
 pub async fn is_valid_modrinth(instance_folder: PathBuf) -> bool {
 	let config: String = io::read_to_string(&instance_folder.join("profile.json"))
 		.await
-		.unwrap_or("".to_string());
+		.unwrap_or(String::new());
 	let config: Result<ModrinthProfile, serde_json::Error> =
 		serde_json::from_str::<ModrinthProfile>(&config);
 	config.is_ok()
diff --git a/packages/core/src/api/package/import/multibased.rs b/packages/core/src/api/package/import/multibased.rs
index 0dd287c9..4e549b96 100644
--- a/packages/core/src/api/package/import/multibased.rs
+++ b/packages/core/src/api/package/import/multibased.rs
@@ -1,6 +1,6 @@
-//! Launcher Import: MultiMC & Prism Launcher
-//! Source Code available at https://github.com/PrismLauncher/PrismLauncher
-//! Source Code available at https://github.com/MultiMC/Launcher
+//! Launcher Import: `MultiMC` & Prism Launcher
+//! Source Code available at <https://github.com/PrismLauncher/PrismLauncher>
+//! Source Code available at <https://github.com/MultiMC/Launcher>
 
 use serde::{de, Deserialize, Serialize};
 use std::path::{Path, PathBuf};
@@ -8,7 +8,7 @@ use std::path::{Path, PathBuf};
 use crate::package::from::{self, CreatePackDescription, PackDependency};
 use crate::package::import::{self, copy_minecraft};
 use crate::prelude::{Cluster, ClusterPath, State};
-use crate::utils::io;
+use onelauncher_utils::io;
 
 // instance.cfg: https://github.com/PrismLauncher/PrismLauncher/blob/develop/launcher/minecraft/MinecraftInstance.cpp
 #[derive(Serialize, Deserialize, Debug)]
@@ -53,15 +53,14 @@ fn deserialize_optional_bool<'de, D>(deserializer: D) -> Result<Option<bool>, D:
 where
 	D: de::Deserializer<'de>,
 {
-	let s = Option::<String>::deserialize(deserializer)?;
-	match s {
-		Some(string) => match string.as_str() {
+	Option::<String>::deserialize(deserializer)?.map_or_else(
+		|| Ok(None),
+		|string| match string.as_str() {
 			"true" => Ok(Some(true)),
 			"false" => Ok(Some(false)),
 			_ => Err(de::Error::custom("expected 'true' or 'false'")),
 		},
-		None => Ok(None),
-	}
+	)
 }
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -139,10 +138,8 @@ pub struct MMCLauncher {
 pub async fn is_valid_multibased(instance_folder: PathBuf) -> bool {
 	let instance_cfg = instance_folder.join("instance.cfg");
 	let mmc_pack = instance_folder.join("mmc-pack.json");
-
-	let mmc_pack = match io::read_to_string(&mmc_pack).await {
-		Ok(mmc_pack) => mmc_pack,
-		Err(_) => return false,
+	let Ok(mmc_pack) = io::read_to_string(&mmc_pack).await else {
+		return false;
 	};
 
 	load_instance_cfg(&instance_cfg).await.is_ok()
@@ -217,7 +214,7 @@ pub async fn import_mmc(
 				)
 				.await?;
 			}
-			Some(MMCManagedPackType::Flame) | Some(MMCManagedPackType::ATLauncher) => {
+			Some(MMCManagedPackType::Flame | MMCManagedPackType::ATLauncher) => {
 				// Same as unmanaged, but with 'minecraft' folder instead of '.minecraft'
 				let minecraft_folder = mmc_base_path
 					.join("instances")
@@ -313,7 +310,7 @@ async fn import_mmc_unmanaged(
 		})
 		.collect();
 
-	from::set_cluster_information(
+	from::set_cluster_information::<std::hash::RandomState>(
 		cluster_path.clone(),
 		&description,
 		&backup_name,
diff --git a/packages/core/src/api/package/import/technic.rs b/packages/core/src/api/package/import/technic.rs
index 344ef439..0692d725 100644
--- a/packages/core/src/api/package/import/technic.rs
+++ b/packages/core/src/api/package/import/technic.rs
@@ -1,2 +1,2 @@
 //! Launcher Import: Technic Launcher
-//! Source Code available at https://github.com/TechnicPack/LauncherV3
+//! Source Code available at <https://github.com/TechnicPack/LauncherV3>
diff --git a/packages/core/src/api/package/import/tlauncher.rs b/packages/core/src/api/package/import/tlauncher.rs
index e374f874..defc6b3e 100644
--- a/packages/core/src/api/package/import/tlauncher.rs
+++ b/packages/core/src/api/package/import/tlauncher.rs
@@ -1,2 +1,2 @@
-//! Launcher Import: TLauncher
+//! Launcher Import: `TLauncher`
 //! Closed source (technically) ;3
diff --git a/packages/core/src/api/package/mod.rs b/packages/core/src/api/package/mod.rs
index 9d364d21..e4d57166 100644
--- a/packages/core/src/api/package/mod.rs
+++ b/packages/core/src/api/package/mod.rs
@@ -1,6 +1,6 @@
-//! **OneLauncher Package**
+//! **`OneLauncher` Package**
 //!
-//! Utilities for importing packages from and to OneLauncher.
+//! Utilities for importing packages from and to `OneLauncher`.
 
 pub mod content;
 pub mod from;
diff --git a/packages/core/src/api/package/mrpack.rs b/packages/core/src/api/package/mrpack.rs
index 6bbcb805..e66d217f 100644
--- a/packages/core/src/api/package/mrpack.rs
+++ b/packages/core/src/api/package/mrpack.rs
@@ -6,10 +6,11 @@ use crate::proxy::ingress_try_for_each;
 use crate::proxy::send::{init_or_edit_ingress, send_ingress};
 use crate::store::{ClusterStage, Clusters, PackageSide};
 use crate::utils::http::{fetch_from_mirrors, write};
-use crate::utils::io;
 use crate::{cluster, IngressType, State};
 use async_zip::base::read::seek::ZipFileReader;
+use onelauncher_utils::io;
 
+use futures::StreamExt;
 use std::io::Cursor;
 use std::path::{Component, PathBuf};
 
@@ -55,7 +56,7 @@ pub async fn install_zipped_mrpack(
 	match result {
 		Ok(cluster) => Ok(cluster),
 		Err(err) => {
-			let _ = crate::api::cluster::remove(&cluster_path).await;
+			let _ = cluster::remove(&cluster_path).await;
 
 			Err(err)
 		}
@@ -121,7 +122,6 @@ pub async fn install_zipped_mrpack_files(
 		.await?;
 
 		let num_files = pack.files.len();
-		use futures::StreamExt;
 		ingress_try_for_each(
 			futures::stream::iter(pack.files.into_iter()).map(Ok::<PackFile, crate::Error>),
 			None,
@@ -136,8 +136,7 @@ pub async fn install_zipped_mrpack_files(
 					if let Some(env) = pack.env {
 						if env
 							.get(&EnvType::Client)
-							.map(|x| x == &PackageSide::Unsupported)
-							.unwrap_or(false)
+							.is_some_and(|x| x == &PackageSide::Unsupported)
 						{
 							return Ok(());
 						}
@@ -208,8 +207,8 @@ pub async fn install_zipped_mrpack_files(
 
 				send_ingress(
 					&ingress,
-					30.0 / total_len as f64,
-					Some(&format!("extracting override {}/{}", index, total_len)),
+					30.0 / f64::from(total_len),
+					Some(&format!("extracting override {index}/{total_len}")),
 				)
 				.await?;
 			}
@@ -259,7 +258,7 @@ pub async fn remove_all_related_files(
 			return Err(anyhow::anyhow!("pack doesn't support Minecraft").into());
 		}
 
-		crate::api::cluster::edit(&cluster_path, |cl| {
+		cluster::edit(&cluster_path, |cl| {
 			cl.stage = ClusterStage::PackDownloading;
 			async { Ok(()) }
 		})
diff --git a/packages/core/src/api/proxy/send.rs b/packages/core/src/api/proxy/send.rs
index 3694ec39..d72e84dc 100644
--- a/packages/core/src/api/proxy/send.rs
+++ b/packages/core/src/api/proxy/send.rs
@@ -128,7 +128,7 @@ pub async fn send_ingress(
 		{
 			ingress.cli.set_message(
 				message
-					.map(|x| x.to_string())
+					.map(ToString::to_string)
 					.unwrap_or(ingress.message.clone()),
 			);
 			ingress
diff --git a/packages/core/src/api/settings.rs b/packages/core/src/api/settings.rs
index 151e4715..7726113d 100644
--- a/packages/core/src/api/settings.rs
+++ b/packages/core/src/api/settings.rs
@@ -3,6 +3,7 @@
 use crate::proxy::send::{init_ingress, send_ingress};
 use crate::store::{Clusters, Directories, Settings};
 use crate::State;
+use onelauncher_utils::io;
 use std::path::{Path, PathBuf};
 use tokio::sync::RwLock;
 
@@ -91,7 +92,7 @@ pub async fn set_directory(new: PathBuf) -> crate::Result<()> {
 	state_write.watcher = RwLock::new(fs_watcher);
 
 	tracing::trace!("collecting all config files to be transfered");
-	let mut cfg_entries = crate::utils::io::read_dir(&old).await?;
+	let mut cfg_entries = io::read_dir(&old).await?;
 	let across_filesystems = is_different_fs(&old, &new);
 	let mut entries = vec![];
 	let mut cleanable = vec![];
@@ -99,7 +100,7 @@ pub async fn set_directory(new: PathBuf) -> crate::Result<()> {
 	while let Some(e) = cfg_entries
 		.next_entry()
 		.await
-		.map_err(|err| crate::utils::io::IOError::with_path(err, &old))?
+		.map_err(|err| io::IOError::with_path(err, &old))?
 	{
 		let epath = e.path();
 		if let Some(file_name) = epath.file_name() {
@@ -127,7 +128,7 @@ pub async fn set_directory(new: PathBuf) -> crate::Result<()> {
 		if across_filesystems {
 			crate::utils::http::copy(&epath, &newpath, io_semaphore).await?;
 		} else {
-			crate::utils::io::rename(epath.clone(), newpath.clone()).await?;
+			io::rename(epath.clone(), newpath.clone()).await?;
 		}
 
 		send_ingress(&ingress, 80.0 * (1.0 / nentries), None).await?;
@@ -161,7 +162,7 @@ pub async fn set_directory(new: PathBuf) -> crate::Result<()> {
 		tracing::trace!("deleting old config files");
 	}
 	for ce in cleanable {
-		crate::utils::io::remove_dir_all(ce).await?;
+		io::remove_dir_all(ce).await?;
 		send_ingress(&ingress, 10.0 * (1.0 / cleanable_nentries as f64), None).await?;
 	}
 
@@ -181,18 +182,18 @@ pub async fn set_directory(new: PathBuf) -> crate::Result<()> {
 }
 
 /// checks if two paths are on different data storage devices
-fn is_different_fs(a: &Path, b: &Path) -> bool {
-	let roota = a.components().next();
-	let rootb = b.components().next();
-	roota != rootb
+fn is_different_fs(first: &Path, second: &Path) -> bool {
+	let first_root = first.components().next();
+	let second_root = second.components().next();
+	first_root != second_root
 }
 
 /// checks if a [`PathBuf`] is writable or locked.
 pub async fn is_writable(path: PathBuf) -> crate::Result<bool> {
 	let tmp = path.join(".tmp");
-	match crate::utils::io::write(tmp.clone(), "test").await {
-		Ok(_) => {
-			crate::utils::io::remove_file(tmp).await?;
+	match io::write(tmp.clone(), "test").await {
+		Ok(()) => {
+			io::remove_file(tmp).await?;
 			Ok(true)
 		}
 		Err(e) => {
diff --git a/packages/core/src/constants.rs b/packages/core/src/constants.rs
index dce7c9c3..9947246a 100644
--- a/packages/core/src/constants.rs
+++ b/packages/core/src/constants.rs
@@ -1,4 +1,4 @@
-//! **OneLauncher Constants**
+//! **`OneLauncher` Constants**
 //!
 //! Public constant variables and strings that are used throughout the launcher.
 //! Can be shared publically, any secrets should be stored in [`crate::store::credentials`].
@@ -39,7 +39,7 @@ pub const MODRINTH_V3_API_URL: &str = "https://api.modrinth.com/v3";
 pub const CURSEFORGE_API_URL: &str = "https://api.curseforge.com/";
 /// Our metadata API base url.
 pub const METADATA_API_URL: &str = "https://meta.polyfrost.org";
-/// https://mclo.gs/ API base url.
+/// <https://mclo.gs>/ API base url.
 pub const MCLOGS_API_URL: &str = "https://api.mclo.gs/1";
 
 // =========== Paths ===========
diff --git a/packages/core/src/error.rs b/packages/core/src/error.rs
index d19cd694..b701b997 100644
--- a/packages/core/src/error.rs
+++ b/packages/core/src/error.rs
@@ -1,6 +1,6 @@
-//! **OneLauncher Errors**
+//! **`OneLauncher` Errors**
 //!
-//! Public wrappers around common OneLauncher errors.
+//! Public wrappers around common `OneLauncher` errors.
 
 use tracing_error::InstrumentError;
 
@@ -83,7 +83,7 @@ pub enum ErrorKind {
 	#[error("failed to watch file {0}")]
 	NotifyError(#[from] notify::Error),
 
-	/// Wrapper around [`regex::Error`] to handle RegExp errors.
+	/// Wrapper around [`regex::Error`] to handle `RegExp` errors.
 	#[error("string verification with regex failed: {0}")]
 	RegexError(#[from] regex::Error),
 
@@ -99,11 +99,11 @@ pub enum ErrorKind {
 	#[error("checksum {0} did not match {1}!")]
 	HashError(String, String),
 
-	/// Wrapper around [`crate::utils::io::IOError`] to handle wrapped std::io errors.
+	/// Wrapper around [`onelauncher_utils::io::IOError`] to handle wrapped `std::io` errors.
 	#[error("error handling IO operations: {0}")]
-	IOError(#[from] crate::utils::io::IOError),
+	IOError(#[from] onelauncher_utils::io::IOError),
 
-	/// Wrapper around [`std::io::Error`] to handle non-wrapped std::io errors.
+	/// Wrapper around [`std::io::Error`] to handle non-wrapped `std::io` errors.
 	#[error("error handling standard IO operations: {0}")]
 	StdIOError(#[from] std::io::Error),
 
diff --git a/packages/core/src/game/arguments.rs b/packages/core/src/game/arguments.rs
index db87529a..6868abae 100644
--- a/packages/core/src/game/arguments.rs
+++ b/packages/core/src/game/arguments.rs
@@ -11,8 +11,8 @@ use interpulse::utils::get_path_from_artifact;
 
 use crate::constants::DUMMY_REPLACE_NEWLINE;
 use crate::store::{Memory, MinecraftCredentials, Resolution};
-use crate::utils::io::IOError;
-use crate::utils::platform::classpath_separator;
+use onelauncher_utils::io::IOError;
+use onelauncher_utils::platform::classpath_separator;
 
 #[allow(clippy::too_many_arguments)]
 pub fn java_arguments(
@@ -45,7 +45,7 @@ pub fn java_arguments(
 	} else {
 		parsed.push(format!(
 			"-Djava.library.path={}",
-			dunce::canonicalize(natives_path)
+			onelauncher_utils::io::canonicalize(natives_path)
 				.map_err(|_| anyhow::anyhow!(
 					"specified natives path {} not found",
 					natives_path.to_string_lossy()
@@ -146,12 +146,12 @@ pub fn processor_arguments<T: AsRef<str>>(
 					)?
 				} else {
 					entry.client.clone()
-				})
+				});
 			}
 		} else if arg.as_ref().starts_with('[') {
-			parsed.push(get_library(libraries_path, a, true)?)
+			parsed.push(get_library(libraries_path, a, true)?);
 		} else {
-			parsed.push(arg.as_ref().to_string())
+			parsed.push(arg.as_ref().to_string());
 		}
 	}
 
@@ -214,36 +214,15 @@ fn parse_minecraft_argument(
 		.replace("${assets_index_name}", asset_index)
 		.replace(
 			"${game_directory}",
-			&dunce::canonicalize(game_directory)
-				.map_err(|_| {
-					anyhow::anyhow!(
-						"game directory {} doesn't exist",
-						game_directory.to_string_lossy()
-					)
-				})?
-				.to_string_lossy(),
+			&onelauncher_utils::io::canonicalize(game_directory)?.to_string_lossy(),
 		)
 		.replace(
 			"${assets_root}",
-			&dunce::canonicalize(assets_directory)
-				.map_err(|_| {
-					anyhow::anyhow!(
-						"assets directory {} doesn't exist",
-						assets_directory.to_string_lossy()
-					)
-				})?
-				.to_string_lossy(),
+			&onelauncher_utils::io::canonicalize(assets_directory)?.to_string_lossy(),
 		)
 		.replace(
 			"${game_assets}",
-			&dunce::canonicalize(assets_directory)
-				.map_err(|_| {
-					anyhow::anyhow!(
-						"assets directory {} doesn't exist",
-						assets_directory.to_string_lossy()
-					)
-				})?
-				.to_string_lossy(),
+			&onelauncher_utils::io::canonicalize(assets_directory)?.to_string_lossy(),
 		)
 		.replace("${version_type}", version_type.as_str())
 		.replace("${resolution_width}", &resolution.0.to_string())
@@ -263,25 +242,11 @@ fn parse_java_argument(
 	Ok(argument
 		.replace(
 			"${natives_directory}",
-			&dunce::canonicalize(natives_path)
-				.map_err(|_| {
-					anyhow::anyhow!(
-						"natives path {} doesn't exist",
-						natives_path.to_string_lossy()
-					)
-				})?
-				.to_string_lossy(),
+			&onelauncher_utils::io::canonicalize(natives_path)?.to_string_lossy(),
 		)
 		.replace(
 			"${library_directory}",
-			&dunce::canonicalize(libraries_path)
-				.map_err(|_| {
-					anyhow::anyhow!(
-						"libraries path {} doesn't eixst",
-						libraries_path.to_string_lossy()
-					)
-				})?
-				.to_string_lossy(),
+			&onelauncher_utils::io::canonicalize(libraries_path)?.to_string_lossy(),
 		)
 		.replace("${classpath_seperator}", classpath_separator(java_arch))
 		.replace("${launcher_name}", crate::constants::NAME)
@@ -315,13 +280,7 @@ pub fn classpaths(
 		.collect::<Result<HashSet<_>, _>>()?;
 
 	classpaths.insert(
-		dunce::canonicalize(client_path)
-			.map_err(|_| {
-				anyhow::anyhow!(
-					"specified classpath {} not found",
-					client_path.to_string_lossy()
-				)
-			})?
+		onelauncher_utils::io::canonicalize(client_path)?
 			.to_string_lossy()
 			.to_string(),
 	);
@@ -357,8 +316,7 @@ pub fn get_library(
 		return Ok(path.to_string_lossy().to_string());
 	}
 
-	let path = &dunce::canonicalize(&path)
-		.map_err(|_| anyhow::anyhow!("library file {} not found", path.to_string_lossy()))?;
+	let path = &onelauncher_utils::io::canonicalize(&path)?;
 
 	Ok(path.to_string_lossy().to_string())
 }
diff --git a/packages/core/src/game/metadata.rs b/packages/core/src/game/metadata.rs
index 3429dc23..edf88dea 100644
--- a/packages/core/src/game/metadata.rs
+++ b/packages/core/src/game/metadata.rs
@@ -13,9 +13,9 @@ use crate::proxy::send::send_ingress;
 use crate::proxy::utils::ingress_try_for_each;
 use crate::proxy::IngressId;
 use crate::store::State;
-use crate::utils::http::*;
-use crate::utils::io;
-use crate::utils::platform::OsExt;
+use crate::utils::http::{fetch, fetch_json, write};
+use onelauncher_utils::io;
+use onelauncher_utils::platform::OsExt;
 
 #[tracing::instrument(skip(st, version))]
 pub async fn download_minecraft(
@@ -28,12 +28,7 @@ pub async fn download_minecraft(
 ) -> crate::Result<()> {
 	tracing::info!("downloading minecraft version {}", version.id);
 	let assets_index = download_assets_index(st, version, Some(ingress), force).await?;
-	let processors = if version
-		.processors
-		.as_ref()
-		.map(|p| !p.is_empty())
-		.unwrap_or(false)
-	{
+	let processors = if version.processors.as_ref().is_some_and(|p| !p.is_empty()) {
 		25.0
 	} else {
 		40.0
@@ -294,11 +289,11 @@ pub async fn download_libraries(
                             let reader = std::io::Cursor::new(&data);
                             if let Ok(mut archive) = zip::ZipArchive::new(reader) {
                                 match archive.extract(st.directories.version_natives_dir(version).await) {
-                                    Ok(_) => tracing::debug!("downloaded native {}", &lib.name),
+                                    Ok(()) => tracing::debug!("downloaded native {}", &lib.name),
                                     Err(err) => tracing::error!("failed to download native {}: {}", &lib.name, err)
                                 }
                             } else {
-                                tracing::error!("failed to extract native {}", &lib.name)
+                                tracing::error!("failed to extract native {}", &lib.name);
                             }
                         }
                     }
diff --git a/packages/core/src/game/mod.rs b/packages/core/src/game/mod.rs
index c2e60ae0..dff0cef8 100644
--- a/packages/core/src/game/mod.rs
+++ b/packages/core/src/game/mod.rs
@@ -1,4 +1,4 @@
-//! **OneLauncher Game**
+//! **`OneLauncher` Game**
 //!
 //! Manages, installs, and launches the core Minecraft game.
 
@@ -9,7 +9,7 @@ use crate::proxy::{IngressId, IngressType};
 use crate::store::{
 	self as st, Cluster, ClusterStage, MinecraftCredentials, ProcessorChild, State,
 };
-use crate::utils::io::{self, IOError};
+use onelauncher_utils::io::{self, IOError};
 
 use chrono::Utc;
 use interpulse as ip;
@@ -74,7 +74,7 @@ pub async fn install_minecraft(
 	let instance_path = &io::canonicalize(cluster.get_full_path().await?)?;
 	let metadata = state.metadata.read().await;
 
-	let version_manifest = metadata.minecraft.to_owned();
+	let version_manifest = metadata.minecraft.clone();
 	let versions = version_manifest
 		.ok_or(anyhow::anyhow!("couldn't get minecraft manifest"))?
 		.versions;
@@ -108,8 +108,7 @@ pub async fn install_minecraft(
 	let key = version_info
 		.java_version
 		.as_ref()
-		.map(|it| it.major_version)
-		.unwrap_or(8);
+		.map_or(8, |it| it.major_version);
 	let (java_version, set_java) =
 		if let Some(java_version) = java_version_from_cluster(cluster, &version_info).await? {
 			(std::path::PathBuf::from(java_version.path), false)
@@ -177,8 +176,8 @@ pub async fn install_minecraft(
 					}
 				}
 
-				let cp = ref_owned!(cp = processor.classpath.clone() => {
-					cp.push(processor.jar.clone())
+				let cp = onelauncher_utils::ref_owned!(cp = processor.classpath.clone() => {
+					cp.push(processor.jar.clone());
 				});
 
 				let child = Command::new(&java_version.path)
@@ -223,10 +222,7 @@ pub async fn install_minecraft(
 				send_ingress(
 					&ingress,
 					30.0 / total_length as f64,
-					Some(&format!(
-						"running forge processor {}/{}",
-						index, total_length
-					)),
+					Some(&format!("running forge processor {index}/{total_length}")),
 				)
 				.await?;
 			}
@@ -273,7 +269,7 @@ pub async fn launch_minecraft(
 	let instance_path = cluster.get_full_path().await?;
 	let instance_path = &io::canonicalize(instance_path)?;
 
-	let version_manifest = metadata.minecraft.to_owned();
+	let version_manifest = metadata.minecraft.clone();
 	let versions = version_manifest
 		.ok_or(anyhow::anyhow!("couldn't get minecraft manifest"))?
 		.versions;
@@ -316,7 +312,9 @@ pub async fn launch_minecraft(
 		.join(format!("{version_jar}.jar"));
 	let args = version_info.arguments.clone().unwrap_or_default();
 	let mut command = match wrapper {
-		Some(hook) => ref_owned!(it = Command::new(hook) => {it.arg(&java_version.path)}),
+		Some(hook) => {
+			onelauncher_utils::ref_owned!(it = Command::new(hook) => {it.arg(&java_version.path)})
+		}
 		None => Command::new(&java_version.path),
 	};
 	let env_args = Vec::from(env_args);
@@ -335,7 +333,7 @@ pub async fn launch_minecraft(
 		.args(
 			arguments::java_arguments(
 				args.get(&ip::api::minecraft::ArgumentType::Jvm)
-					.map(|x| x.as_slice()),
+					.map(Vec::as_slice),
 				&state.directories.version_natives_dir(&version_jar).await,
 				&state.directories.libraries_dir().await,
 				&arguments::classpaths(
@@ -350,14 +348,13 @@ pub async fn launch_minecraft(
 				Vec::from(java_args),
 				&java_version.arch,
 			)?
-			.into_iter()
-			.collect::<Vec<_>>(),
+			.into_iter(),
 		)
 		.arg(version_info.main_class.clone())
 		.args(
 			arguments::minecraft_arguments(
 				args.get(&ip::api::minecraft::ArgumentType::Game)
-					.map(|a| a.as_slice()),
+					.map(Vec::as_slice),
 				version_info.minecraft_arguments.as_deref(),
 				credentials,
 				&version.id,
@@ -368,8 +365,7 @@ pub async fn launch_minecraft(
 				*resolution,
 				&java_version.arch,
 			)?
-			.into_iter()
-			.collect::<Vec<_>>(),
+			.into_iter(),
 		)
 		.current_dir(instance_path.clone());
 
@@ -393,10 +389,10 @@ pub async fn launch_minecraft(
 		for (key, value) in mc_options {
 			let re = regex::Regex::new(&format!(r"(?m)^{}:.*$", regex::escape(key)))?;
 			if !re.is_match(&options_string) {
-				options_string.push_str(&format!("\n{}:{}", key, value));
+				options_string.push_str(&format!("\n{key}:{value}"));
 			} else {
 				let replaced_string = re
-					.replace_all(&options_string, &format!("{}:{}", key, value))
+					.replace_all(&options_string, &format!("{key}:{value}"))
 					.to_string();
 				options_string = replaced_string;
 			}
@@ -416,16 +412,10 @@ pub async fn launch_minecraft(
 	let mut censors = HashMap::new();
 	let username = whoami::username();
 	let realname = whoami::realname();
-	censors.insert(format!("/{}/", username), "/{ENV_USERNAME}/".to_string());
-	censors.insert(
-		format!("\\{}\\", username),
-		"\\{ENV_USERNAME}\\".to_string(),
-	);
-	censors.insert(format!("/{}/", realname), "/{ENV_REALNAME}/".to_string());
-	censors.insert(
-		format!("\\{}\\", realname),
-		"\\{ENV_REALNAME}\\".to_string(),
-	);
+	censors.insert(format!("/{username}/"), "/{ENV_USERNAME}/".to_string());
+	censors.insert(format!("\\{username}\\"), "\\{ENV_USERNAME}\\".to_string());
+	censors.insert(format!("/{realname}/"), "/{ENV_REALNAME}/".to_string());
+	censors.insert(format!("\\{realname}\\"), "\\{ENV_REALNAME}\\".to_string());
 	censors.insert(
 		credentials.access_token.clone(),
 		"{MC_ACCESS_TOKEN}".to_string(),
@@ -483,10 +473,10 @@ pub fn rules(rules: &[ip::api::minecraft::Rule], java_version: &str, updated: bo
 		.iter()
 		.all(|r| matches!(r.action, RuleAction::Disallow))
 	{
-		rule.push(Some(true))
+		rule.push(Some(true));
 	}
 
-	!(rule.iter().any(|r| r == &Some(false)) || rule.iter().all(|r| r.is_none()))
+	!(rule.iter().any(|r| r == &Some(false)) || rule.iter().all(Option::is_none))
 }
 
 /// Parses a Minecraft library feature or OS rule.
@@ -500,7 +490,7 @@ pub fn rule(rule: &ip::api::minecraft::Rule, java_version: &str, updated: bool)
 	let result = match rule {
 		Rule {
 			os: Some(ref os), ..
-		} => crate::utils::platform::os_rule(os, java_version, updated),
+		} => onelauncher_utils::platform::os_rule(os, java_version, updated),
 		Rule {
 			features: Some(ref features),
 			..
@@ -543,8 +533,7 @@ pub async fn java_version_from_cluster(
 		let key = version_info
 			.java_version
 			.as_ref()
-			.map(|x| x.major_version)
-			.unwrap_or(8);
+			.map_or(8, |x| x.major_version);
 
 		let state = State::get().await?;
 		let settings = state.settings.read().await;
diff --git a/packages/core/src/lib.rs b/packages/core/src/lib.rs
index cde6a305..8b3c8049 100644
--- a/packages/core/src/lib.rs
+++ b/packages/core/src/lib.rs
@@ -1,9 +1,43 @@
-//! # OneLauncher
+//! # `OneLauncher`
 //!
 //! A library used as a core for our launcher and Rust APIs.
 
-#![warn(unused_import_braces)]
+#![warn(
+	clippy::all,
+	clippy::pedantic,
+	clippy::correctness,
+	clippy::perf,
+	clippy::style,
+	clippy::suspicious,
+	clippy::complexity,
+	clippy::nursery,
+	clippy::unwrap_used,
+	unused_qualifications,
+	rust_2018_idioms,
+	trivial_casts,
+	trivial_numeric_casts,
+	unused_allocation,
+	clippy::unnecessary_cast,
+	clippy::cast_lossless,
+	clippy::cast_possible_truncation,
+	clippy::cast_possible_wrap,
+	clippy::cast_sign_loss,
+	clippy::dbg_macro,
+	unused_import_braces,
+	clippy::deprecated_cfg_attr,
+	clippy::separated_literal_suffix,
+	deprecated
+)]
+#![forbid(deprecated_in_future)]
 #![deny(unused_must_use)]
+#![allow(
+	clippy::missing_errors_doc,
+	clippy::future_not_send,
+	clippy::module_name_repetitions,
+	clippy::struct_field_names,
+	clippy::cast_precision_loss,
+	clippy::significant_drop_tightening //tmp
+)]
 
 #[macro_use]
 pub mod utils;
diff --git a/packages/core/src/logger.rs b/packages/core/src/logger.rs
index bb014756..742a37ca 100644
--- a/packages/core/src/logger.rs
+++ b/packages/core/src/logger.rs
@@ -1,9 +1,9 @@
-//! **OneLauncher Logger**
+//! **`OneLauncher` Logger**
 //!
-//! Public utilities for [`tracing`] logging in OneLauncher.
+//! Public utilities for [`tracing`] logging in `OneLauncher`.
 //!
 //! - `RUST_LOG=xxx` is a variable which defines tracing configuration (`ERROR > WARN > INFO > DEBUG > TRACE`)
-//! - `RUST_LOG="onelauncher=trace"` will show **all** mesages from OneLauncher and not other dependencies.
+//! - `RUST_LOG="onelauncher=trace"` will show **all** mesages from `OneLauncher` and not other dependencies.
 //! - `RUST_LOG="info"` will show info, warn, and error logs.
 //!
 //! Errors returned to [`tauri`] are displayed as tracing error logs.
@@ -11,7 +11,7 @@
 //! Tracing errors also provide Sentry metadata to be handled.
 //! To set the environment variable on `unix` you can use the following command: `RUST_LOG="xxx" {your command}`
 //!
-//! The default `RUST_LOG` is `onelauncher=show`, meaning only logs from OneLauncher will be displayed at the info, warn, and error levels.
+//! The default `RUST_LOG` is `onelauncher=show`, meaning only logs from `OneLauncher` will be displayed at the info, warn, and error levels.
 
 use tracing_appender::non_blocking::WorkerGuard;
 
@@ -19,6 +19,7 @@ use tracing_appender::non_blocking::WorkerGuard;
 
 /// Initialize the global [`tracing`] logger in development.
 #[cfg(debug_assertions)]
+#[must_use]
 pub fn start_logger() -> Option<WorkerGuard> {
 	use tracing_subscriber::prelude::*;
 
diff --git a/packages/core/src/store/clusters.rs b/packages/core/src/store/clusters.rs
index 05ef030c..217eeb61 100644
--- a/packages/core/src/store/clusters.rs
+++ b/packages/core/src/store/clusters.rs
@@ -14,14 +14,14 @@ use crate::constants::CLUSTER_FILE;
 use crate::proxy::send::{send_cluster, send_message};
 use crate::proxy::ClusterPayloadType;
 use crate::utils::http::{write_icon, IoSemaphore};
-use crate::utils::io::{self, IOError};
 use crate::utils::java::JavaVersion;
 use crate::State;
+use onelauncher_utils::io::{self, IOError};
 
 use super::{Directories, InitHooks, Memory, PackageType, Resolution};
 
 /// Core Cluster state manager with a [`HashMap<ClusterPath, Cluster>`].
-pub(crate) struct Clusters(pub HashMap<ClusterPath, Cluster>);
+pub struct Clusters(pub HashMap<ClusterPath, Cluster>);
 
 /// Core Cluster stages used in package logic.
 #[cfg_attr(feature = "specta", derive(specta::Type))]
@@ -40,7 +40,8 @@ pub enum ClusterStage {
 }
 
 impl ClusterStage {
-	pub fn as_str(&self) -> &'static str {
+	#[must_use]
+	pub const fn as_str(&self) -> &'static str {
 		match *self {
 			Self::Installed => "installed",
 			Self::Downloading => "downloading",
@@ -73,7 +74,7 @@ pub struct ClusterPath(pub PathBuf);
 impl ClusterPath {
 	/// Get a new [`ClusterPath`] instance from an [`Into<PathBuf>`].
 	pub fn new(path: impl Into<PathBuf>) -> Self {
-		ClusterPath(path.into())
+		Self(path.into())
 	}
 
 	pub async fn find_by_uuid(uuid: Uuid) -> crate::Result<Self> {
@@ -106,7 +107,7 @@ impl ClusterPath {
 	}
 
 	/// Validate the cluster and clone the current [`ClusterPath`].
-	pub async fn cluster_path(&self) -> crate::Result<ClusterPath> {
+	pub async fn cluster_path(&self) -> crate::Result<Self> {
 		if let Some(c) = crate::cluster::get(self).await? {
 			Ok(c.cluster_path())
 		} else {
@@ -146,6 +147,7 @@ pub struct InnerPathLinux(pub String);
 
 impl InnerPathLinux {
 	/// Get the first 2 components of the inner path.
+	#[must_use]
 	pub fn get_components(&self) -> String {
 		self.to_string()
 			.split('/')
@@ -163,7 +165,7 @@ impl std::fmt::Display for InnerPathLinux {
 
 impl From<RawPackagePath> for InnerPathLinux {
 	fn from(value: RawPackagePath) -> Self {
-		InnerPathLinux(value.0.replace('\\', "/"))
+		Self(value.0.replace('\\', "/"))
 	}
 }
 
@@ -174,7 +176,7 @@ struct RawPackagePath(pub String);
 
 impl From<InnerPathLinux> for RawPackagePath {
 	fn from(value: InnerPathLinux) -> Self {
-		RawPackagePath(value.0)
+		Self(value.0)
 	}
 }
 
@@ -210,6 +212,7 @@ impl PackagePath {
 	}
 
 	/// Get the [`InnerPathLinux`] of a [`PackagePath`].
+	#[must_use]
 	pub fn inner_path(&self) -> InnerPathLinux {
 		InnerPathLinux(
 			self.0
@@ -220,9 +223,10 @@ impl PackagePath {
 		)
 	}
 
-	/// Create a new PackagePath from a relative path.
+	/// Create a new `PackagePath` from a relative path.
+	#[must_use]
 	pub fn new(path: &Path) -> Self {
-		PackagePath(PathBuf::from(path))
+		Self(PathBuf::from(path))
 	}
 }
 
@@ -319,7 +323,8 @@ pub struct PackageData {
 	pub locked: Option<bool>,
 }
 
-pub fn default_locked() -> Option<bool> {
+#[must_use]
+pub const fn default_locked() -> Option<bool> {
 	Some(true)
 }
 
@@ -331,11 +336,11 @@ pub enum Loader {
 	/// The default vanilla loader, no modding supported.
 	#[default]
 	Vanilla,
-	/// The MinecraftForge Minecraft mod loader.
+	/// The `MinecraftForge` Minecraft mod loader.
 	Forge,
-	/// The FabircMC Minecraft mod loader.
+	/// The `FabircMC` Minecraft mod loader.
 	Fabric,
-	/// The NeoForge Minecraft mod loader.
+	/// The `NeoForge` Minecraft mod loader.
 	NeoForge,
 	/// The Quilt Minecraft mod loader.
 	Quilt,
@@ -344,7 +349,8 @@ pub enum Loader {
 }
 
 impl Loader {
-	pub fn as_str(&self) -> &'static str {
+	#[must_use]
+	pub const fn as_str(&self) -> &'static str {
 		match *self {
 			Self::Vanilla => "vanilla",
 			Self::Forge => "forge",
@@ -355,7 +361,8 @@ impl Loader {
 		}
 	}
 
-	pub fn as_meta_str(&self) -> &'static str {
+	#[must_use]
+	pub const fn as_meta_str(&self) -> &'static str {
 		match *self {
 			Self::Vanilla => "vanilla",
 			Self::Forge => "forge",
@@ -366,6 +373,7 @@ impl Loader {
 		}
 	}
 
+	#[must_use]
 	pub fn from_string(val: &str) -> Self {
 		match val {
 			"vanilla" => Self::Vanilla,
@@ -377,7 +385,8 @@ impl Loader {
 		}
 	}
 
-	pub fn supports_mods(&self) -> bool {
+	#[must_use]
+	pub const fn supports_mods(&self) -> bool {
 		!matches!(self, Self::Vanilla)
 	}
 }
@@ -463,6 +472,7 @@ impl Cluster {
 
 	/// Get the [`ClusterPath`] of the specified [`Cluster`].
 	#[inline]
+	#[must_use]
 	pub fn cluster_path(&self) -> ClusterPath {
 		ClusterPath::new(&self.path)
 	}
@@ -645,7 +655,7 @@ impl Clusters {
 
 			{
 				let clusters = state.clusters.read().await;
-				for (cluster_path, cluster) in clusters.0.iter() {
+				for (cluster_path, cluster) in &clusters.0 {
 					if let Some(package_data) = &cluster.meta.package_data {
 						if let Some(linked_package) = &package_data.package_id {
 							updateable.push((cluster_path.clone(), linked_package.clone()));
@@ -679,7 +689,7 @@ impl Clusters {
 			cluster.uuid,
 			&cluster.cluster_path(),
 			&cluster.meta.name,
-			crate::proxy::ClusterPayloadType::Inserted,
+			ClusterPayloadType::Inserted,
 		)
 		.await?;
 
diff --git a/packages/core/src/store/credentials.rs b/packages/core/src/store/credentials.rs
index 52ecfa50..220733fd 100644
--- a/packages/core/src/store/credentials.rs
+++ b/packages/core/src/store/credentials.rs
@@ -2,7 +2,7 @@
 
 use super::Directories;
 use crate::utils::http::IoSemaphore;
-use iota_stronghold::{KeyProvider, SnapshotPath};
+use iota_stronghold::{KeyProvider, SnapshotPath, Stronghold};
 use serde::{Serialize, Serializer};
 use std::ops::Deref;
 use std::path::Path;
@@ -11,9 +11,9 @@ use zeroize::Zeroizing;
 /// A K/V encrypted store to handle digital secrets using IOTA Stronghold.
 #[derive(Debug)]
 pub struct Credentials {
-	inner: iota_stronghold::Stronghold,
-	path: iota_stronghold::SnapshotPath,
-	keyprovider: iota_stronghold::KeyProvider,
+	inner: Stronghold,
+	path: SnapshotPath,
+	keyprovider: KeyProvider,
 }
 
 impl Credentials {
@@ -25,7 +25,7 @@ impl Credentials {
 		_io_semaphore: &IoSemaphore,
 	) -> crate::Result<Self> {
 		let path = SnapshotPath::from_path(path);
-		let stronghold = iota_stronghold::Stronghold::default();
+		let stronghold = Stronghold::default();
 		let keyprovider = KeyProvider::try_from(password).map_err(StrongholdError::MemoryError)?;
 		if path.exists() {
 			stronghold
@@ -46,13 +46,13 @@ impl Credentials {
 		Ok(())
 	}
 
-	pub fn inner(&self) -> &iota_stronghold::Stronghold {
+	pub const fn inner(&self) -> &Stronghold {
 		&self.inner
 	}
 }
 
 impl Deref for Credentials {
-	type Target = iota_stronghold::Stronghold;
+	type Target = Stronghold;
 	fn deref(&self) -> &Self::Target {
 		&self.inner
 	}
@@ -71,7 +71,7 @@ pub enum StrongholdError {
 }
 
 impl Serialize for StrongholdError {
-	fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: Serializer,
 	{
diff --git a/packages/core/src/store/dirs.rs b/packages/core/src/store/dirs.rs
index f9dc5cbf..8eab75de 100644
--- a/packages/core/src/store/dirs.rs
+++ b/packages/core/src/store/dirs.rs
@@ -19,6 +19,7 @@ pub struct Directories {
 
 impl Directories {
 	/// Bootstrap the initial settings directory on first startup.
+	#[must_use]
 	pub fn init_settings_dir() -> Option<PathBuf> {
 		Self::env_path("ONELAUNCHER_CONFIG")
 			.or_else(|| Some(dirs::data_dir()?.join(constants::NAME)))
@@ -76,6 +77,7 @@ impl Directories {
 
 	/// Bootstrap the core logs directory and get it as a [`PathBuf`].
 	#[inline]
+	#[must_use]
 	pub fn logs_dir() -> Option<PathBuf> {
 		Self::init_settings_dir().map(|d| d.join("logs"))
 	}
diff --git a/packages/core/src/store/discord.rs b/packages/core/src/store/discord.rs
index 557c292e..2e545376 100644
--- a/packages/core/src/store/discord.rs
+++ b/packages/core/src/store/discord.rs
@@ -36,7 +36,7 @@ impl DiscordRPC {
 		};
 
 		let client = Arc::new(RwLock::new(discord_ipc));
-		Ok(DiscordRPC { client, connected })
+		Ok(Self { client, connected })
 	}
 
 	/// Set the Discord IPC activity with a message and try to reconnect if the initial connection fails.
diff --git a/packages/core/src/store/java_versions.rs b/packages/core/src/store/java_versions.rs
index 7f85febd..2261bd0a 100644
--- a/packages/core/src/store/java_versions.rs
+++ b/packages/core/src/store/java_versions.rs
@@ -7,7 +7,7 @@ use std::path::PathBuf;
 use crate::utils::java;
 use crate::utils::java::JavaVersion;
 
-/// A HashMap of all located and installed available Java versions
+/// A `HashMap` of all located and installed available Java versions
 #[cfg_attr(feature = "specta", derive(specta::Type))]
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct JavaVersions(HashMap<String, JavaVersion>);
@@ -19,9 +19,10 @@ impl Default for JavaVersions {
 }
 
 impl JavaVersions {
-	/// Create an empty JavaVersions `HashMap`.
-	pub fn new() -> JavaVersions {
-		JavaVersions(HashMap::new())
+	/// Create an empty `JavaVersions` `HashMap`.
+	#[must_use]
+	pub fn new() -> Self {
+		Self(HashMap::new())
 	}
 
 	/// Inserts a key-value pair into the map.
@@ -35,6 +36,7 @@ impl JavaVersions {
 	}
 
 	/// Returns a reference to the value corresponding to the key.
+	#[must_use]
 	pub fn get(&self, key: &String) -> Option<&JavaVersion> {
 		self.0.get(key)
 	}
@@ -45,18 +47,20 @@ impl JavaVersions {
 	}
 
 	/// Returns the number of elements in the map.
+	#[must_use]
 	pub fn count(&self) -> usize {
 		self.0.len()
 	}
 
 	/// A collection visiting all keys in arbitrary order.
+	#[must_use]
 	pub fn keys(&self) -> Vec<String> {
 		self.0.keys().cloned().collect()
 	}
 
 	/// Validates all stored java versions.
 	pub async fn validate(&self) -> bool {
-		for (_, java) in self.0.iter() {
+		for java in self.0.values() {
 			let runtime = java::check_java_instance(PathBuf::from(&java.path).as_path()).await;
 			if let Some(runtime) = runtime {
 				if runtime.version != java.version {
diff --git a/packages/core/src/store/metadata.rs b/packages/core/src/store/metadata.rs
index bb8dde6e..488e627d 100644
--- a/packages/core/src/store/metadata.rs
+++ b/packages/core/src/store/metadata.rs
@@ -6,7 +6,6 @@ use serde::{Deserialize, Serialize};
 
 use crate::constants::METADATA_API_URL;
 use crate::utils::http::{fetch, read_json, write, FetchSemaphore, IoSemaphore};
-use crate::utils::io::copy;
 use crate::State;
 
 use super::Directories;
@@ -20,7 +19,7 @@ pub struct Metadata {
 	pub fabric: Option<ModdedManifest>,
 	/// The [`ModdedManifest`] associated with core Quilt versions.
 	pub quilt: Option<ModdedManifest>,
-	/// The [`ModdedManifest`] associated with core NeoForge versions.
+	/// The [`ModdedManifest`] associated with core `NeoForge` versions.
 	pub neoforge: Option<ModdedManifest>,
 	/// The [`ModdedManifest`] associated with core Forge versions.
 	pub forge: Option<ModdedManifest>,
@@ -154,7 +153,7 @@ impl Metadata {
 		let backup = dirs.caches_dir().await.join("metadata.json.bak");
 		let mut should_write = false;
 
-		if let Ok(mut metadata_json) = read_json::<Metadata>(&path, io_semaphore).await {
+		if let Ok(mut metadata_json) = read_json::<Self>(&path, io_semaphore).await {
 			should_write = metadata_json.fetch_errored(fetch_semaphore).await?;
 
 			metadata = Some(metadata_json);
@@ -171,12 +170,12 @@ impl Metadata {
 			match res {
 				Ok(()) => {}
 				Err(err) => {
-					tracing::warn!("failed to fetch metadata: {err}")
+					tracing::warn!("failed to fetch metadata: {err}");
 				}
 			}
-		} else if let Ok(metadata_json) = read_json::<Metadata>(&backup, io_semaphore).await {
+		} else if let Ok(metadata_json) = read_json::<Self>(&backup, io_semaphore).await {
 			metadata = Some(metadata_json);
-			copy(&backup, &path).await?;
+			onelauncher_utils::io::copy(&backup, &path).await?;
 		}
 
 		if should_write {
@@ -205,7 +204,7 @@ impl Metadata {
 	pub async fn update() {
 		let res = async {
 			let state = State::get().await?;
-			let fetch_data = Metadata::fetch(&state.fetch_semaphore).await?;
+			let fetch_data = Self::fetch(&state.fetch_semaphore).await?;
 
 			let path = state.directories.caches_dir().await.join("metadata.json");
 			let backup = state
@@ -215,7 +214,7 @@ impl Metadata {
 				.join("metadata.json.bak");
 
 			if path.exists() {
-				copy(&path, &backup).await?;
+				onelauncher_utils::io::copy(&path, &backup).await?;
 			}
 
 			write(
@@ -235,7 +234,7 @@ impl Metadata {
 		match res {
 			Ok(()) => {}
 			Err(err) => {
-				tracing::warn!("failed to update launcher metadata: {err}")
+				tracing::warn!("failed to update launcher metadata: {err}");
 			}
 		};
 	}
@@ -247,9 +246,8 @@ async fn fetch_version_manifest(
 ) -> crate::Result<MinecraftManifest> {
 	let url = url.unwrap_or(interpulse::api::minecraft::VERSION_MANIFEST_URL);
 	Ok(serde_json::from_slice(
-		&fetch(url, None, semaphore).await.map_err(|err| {
+		&fetch(url, None, semaphore).await.inspect_err(|_| {
 			tracing::error!("couldn't fetch version manifest at '{}'", url);
-			err
 		})?,
 	)?)
 }
@@ -259,9 +257,8 @@ async fn fetch_modded_manifest(
 	semaphore: &FetchSemaphore,
 ) -> crate::Result<ModdedManifest> {
 	Ok(serde_json::from_slice(
-		&fetch(url, None, semaphore).await.map_err(|err| {
+		&fetch(url, None, semaphore).await.inspect_err(|_| {
 			tracing::error!("couldn't fetch modded manifest at '{}'", url);
-			err
 		})?,
 	)?)
 }
diff --git a/packages/core/src/store/minecraft.rs b/packages/core/src/store/minecraft.rs
index 335f4fdb..ad5600d2 100644
--- a/packages/core/src/store/minecraft.rs
+++ b/packages/core/src/store/minecraft.rs
@@ -880,7 +880,7 @@ async fn send_signed_request<T: serde::de::DeserializeOwned>(
 	let auth = authorization.map_or(Vec::new(), |v| v.as_bytes().to_vec());
 	let body = serde_json::to_vec(&raw_body)
 		.map_err(|source| MinecraftAuthError::SerializeError { step, source })?;
-	let time: u128 = { ((current_date.timestamp() as u128) + 11644473600) * 10000000 };
+	let time: u128 = { ((current_date.timestamp() as u128) + 11_644_473_600) * 10_000_000 };
 
 	use byteorder::WriteBytesExt;
 	let mut buffer = Vec::new();
@@ -896,7 +896,7 @@ async fn send_signed_request<T: serde::de::DeserializeOwned>(
 	buffer
 		.write_u8(0)
 		.map_err(|source| MinecraftAuthError::SigningError { step, source })?;
-	buffer.extend_from_slice("POST".as_bytes());
+	buffer.extend_from_slice(b"POST");
 	buffer
 		.write_u8(0)
 		.map_err(|source| MinecraftAuthError::SigningError { step, source })?;
@@ -975,8 +975,7 @@ fn get_date_header(headers: &reqwest::header::HeaderMap) -> DateTime<Utc> {
 		.get(reqwest::header::DATE)
 		.and_then(|x| x.to_str().ok())
 		.and_then(|x| DateTime::parse_from_rfc2822(x).ok())
-		.map(|x| x.with_timezone(&Utc))
-		.unwrap_or(Utc::now())
+		.map_or(Utc::now(), |x| x.with_timezone(&Utc))
 }
 
 #[tracing::instrument]
diff --git a/packages/core/src/store/mod.rs b/packages/core/src/store/mod.rs
index e8720846..45c8af89 100644
--- a/packages/core/src/store/mod.rs
+++ b/packages/core/src/store/mod.rs
@@ -1,4 +1,4 @@
-//! **OneLauncher Store**
+//! **`OneLauncher` Store**
 //!
 //! Core state and storage management for the launcher, managing all states.
 
@@ -49,7 +49,7 @@ pub use self::oneconfig::*;
 /// The static [`OnceCell<RwLock<State>>`] for storing the global runtime launcher state.
 static LAUNCHER_STATE: OnceCell<RwLock<State>> = OnceCell::const_new();
 
-/// The public OneLauncher state structure.
+/// The public `OneLauncher` state structure.
 pub struct State {
 	/// Handles a boolean to check if the launcher is connected to the internet
 	pub offline: RwLock<bool>,
@@ -73,7 +73,7 @@ pub struct State {
 	pub users: RwLock<MinecraftState>,
 	/// Handles processes
 	pub processor: RwLock<Processor>,
-	/// Handles OneConfig integration with [`async-tungstenite`]
+	/// Handles `OneConfig` integration with [`async-tungstenite`]
 	pub oneconfig: RwLock<Option<OneConfig>>,
 	/// Handles secure credential management with [`iota_stronghold`].
 	pub credentials: RwLock<Option<Credentials>>,
@@ -113,7 +113,7 @@ impl State {
 	/// Initializes the core OneLauncher state fully.
 	#[tracing::instrument]
 	#[onelauncher_macros::memory]
-	async fn initialize() -> crate::Result<RwLock<State>> {
+	async fn initialize() -> crate::Result<RwLock<Self>> {
 		let ingress =
 			init_ingress_internal(crate::IngressType::Initialize, 100.0, "initializing state")
 				.await?;
@@ -195,7 +195,7 @@ impl State {
 	/// Updates all data if we are connected to the internet.
 	pub fn update() {
 		tokio::task::spawn(async {
-			if let Ok(state) = crate::State::get().await {
+			if let Ok(state) = Self::get().await {
 				if !*state.offline.read().await {
 					let version_up = Clusters::update_versions();
 					let meta_up = Metadata::update();
diff --git a/packages/core/src/store/oneconfig.rs b/packages/core/src/store/oneconfig.rs
index 758beec9..1057eae3 100644
--- a/packages/core/src/store/oneconfig.rs
+++ b/packages/core/src/store/oneconfig.rs
@@ -1,10 +1,10 @@
-//! OneConfig state using [`async_tungstenite`] to communicate to the OneConfig server
+//! `OneConfig` state using [`async_tungstenite`] to communicate to the `OneConfig` server
 
 use super::ClusterPath;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-/// Wrapper over an [`async_tungstenite::WebSocketStream`] to connect to the OneConfig server.
+/// Wrapper over an [`async_tungstenite::WebSocketStream`] to connect to the `OneConfig` server.
 pub struct OneConfig {
 	/// The public tokio socket connection.
 	pub socket: async_tungstenite::WebSocketStream<async_tungstenite::tokio::ConnectStream>,
@@ -22,7 +22,7 @@ pub struct ModUpdatePacket {
 }
 
 impl OneConfig {
-	/// Initializes a OneConfig socket connection on localhost port `4023`.
+	/// Initializes a `OneConfig` socket connection on localhost port `4023`.
 	pub async fn initialize(cluster: ClusterPath) -> crate::Result<Self> {
 		let (socket, _) = async_tungstenite::tokio::connect_async(format!(
 			"wss://localhost:4023/oneconfig/ws?cluster={cluster}"
diff --git a/packages/core/src/store/package.rs b/packages/core/src/store/package.rs
index 40b202f5..ab78d432 100644
--- a/packages/core/src/store/package.rs
+++ b/packages/core/src/store/package.rs
@@ -3,9 +3,9 @@
 use crate::package::content::Providers;
 use crate::store::Loader;
 use crate::utils::http::{write_icon, IoSemaphore};
-use crate::utils::io;
 use async_zip::tokio::read::fs::ZipFileReader;
 use chrono::{DateTime, Utc};
+use onelauncher_utils::io;
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
 use std::path::{Path, PathBuf};
@@ -34,58 +34,63 @@ pub enum PackageType {
 
 impl PackageType {
 	/// attempt to get a [`PackageType`] from a loader string.
+	#[must_use]
 	pub fn from_loader(loaders: Vec<String>) -> Option<Self> {
 		if loaders
 			.iter()
 			.any(|x| ["fabric", "forge", "quilt"].contains(&&**x))
 		{
-			Some(PackageType::Mod)
+			Some(Self::Mod)
 		} else if loaders.iter().any(|x| x == "datapack") {
-			Some(PackageType::DataPack)
+			Some(Self::DataPack)
 		} else if loaders.iter().any(|x| ["iris", "optifine"].contains(&&**x)) {
-			Some(PackageType::ShaderPack)
+			Some(Self::ShaderPack)
 		} else if loaders
 			.iter()
 			.any(|x| ["vanilla", "canvas", "minecraft"].contains(&&**x))
 		{
-			Some(PackageType::ResourcePack)
+			Some(Self::ResourcePack)
 		} else {
 			None
 		}
 	}
 
+	#[must_use]
 	pub fn from_parent(path: PathBuf) -> Option<Self> {
 		let path = path.parent()?.file_name()?;
 		match path.to_str()? {
-			"mods" => Some(PackageType::Mod),
-			"datapacks" => Some(PackageType::DataPack),
-			"resourcepacks" => Some(PackageType::ResourcePack),
-			"shaderpacks" => Some(PackageType::ShaderPack),
-			"modpack" => Some(PackageType::ModPack),
+			"mods" => Some(Self::Mod),
+			"datapacks" => Some(Self::DataPack),
+			"resourcepacks" => Some(Self::ResourcePack),
+			"shaderpacks" => Some(Self::ShaderPack),
+			"modpack" => Some(Self::ModPack),
 			_ => None,
 		}
 	}
 
-	pub fn get_name(&self) -> &'static str {
+	#[must_use]
+	pub const fn get_name(&self) -> &'static str {
 		match self {
-			PackageType::Mod => "mod",
-			PackageType::DataPack => "datapack",
-			PackageType::ResourcePack => "resourcepack",
-			PackageType::ShaderPack => "shaderpack",
-			PackageType::ModPack => "modpack",
+			Self::Mod => "mod",
+			Self::DataPack => "datapack",
+			Self::ResourcePack => "resourcepack",
+			Self::ShaderPack => "shaderpack",
+			Self::ModPack => "modpack",
 		}
 	}
 
-	pub fn get_folder(&self) -> &'static str {
+	#[must_use]
+	pub const fn get_folder(&self) -> &'static str {
 		match self {
-			PackageType::Mod => "mods",
-			PackageType::DataPack => "datapacks",
-			PackageType::ResourcePack => "resourcepacks",
-			PackageType::ShaderPack => "shaderpacks",
-			PackageType::ModPack => "modpack",
+			Self::Mod => "mods",
+			Self::DataPack => "datapacks",
+			Self::ResourcePack => "resourcepacks",
+			Self::ShaderPack => "shaderpacks",
+			Self::ModPack => "modpack",
 		}
 	}
 
+	#[must_use]
 	pub fn get_meta(&self) -> PathBuf {
 		PathBuf::from(format!(
 			"{}/{}",
@@ -94,6 +99,7 @@ impl PackageType {
 		))
 	}
 
+	#[must_use]
 	pub fn get_meta_file_name(&self) -> String {
 		String::from(".packages.json")
 	}
@@ -104,7 +110,7 @@ impl PackageType {
 		}
 
 		Ok(match self {
-			PackageType::Mod => {
+			Self::Mod => {
 				entry.file_type().await?.is_file()
 					&& entry.path().extension() == Some("jar".as_ref())
 			}
@@ -112,19 +118,19 @@ impl PackageType {
 		})
 	}
 
-	pub fn iterator() -> impl Iterator<Item = PackageType> {
+	pub fn iterator() -> impl Iterator<Item = Self> {
 		[
-			PackageType::Mod,
-			PackageType::DataPack,
-			PackageType::ResourcePack,
-			PackageType::ShaderPack,
+			Self::Mod,
+			Self::DataPack,
+			Self::ResourcePack,
+			Self::ShaderPack,
 		]
 		.iter()
 		.copied()
 	}
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[cfg_attr(feature = "specta", derive(specta::Type))]
 pub struct SearchResult {
 	pub slug: String,
@@ -189,7 +195,7 @@ impl Package {
 
 pub type PackagesMap = HashMap<PackagePath, Package>;
 
-pub(crate) struct Packages {
+pub struct Packages {
 	managers: HashMap<ClusterPath, PackageManager>,
 }
 
@@ -218,6 +224,7 @@ impl Packages {
 		Self { managers }
 	}
 
+	#[must_use]
 	pub fn get(&self, cluster_path: &ClusterPath) -> Option<&PackageManager> {
 		self.managers.get(cluster_path)
 	}
@@ -235,6 +242,7 @@ pub struct PackagesMeta {
 }
 
 impl PackagesMeta {
+	#[must_use]
 	pub fn new(package_type: PackageType) -> Self {
 		Self {
 			packages: PackagesMap::new(),
@@ -260,6 +268,7 @@ impl PackageManager {
 		Ok(manager)
 	}
 
+	#[must_use]
 	pub fn new(cluster_path: ClusterPath) -> Self {
 		Self {
 			cluster_path,
@@ -282,7 +291,8 @@ impl PackageManager {
 			.join(package_type.get_meta()))
 	}
 
-	/// Get the PackagesMeta for a specific package type. Does not sync.
+	/// Get the `PackagesMeta` for a specific package type. Does not sync.
+	#[must_use]
 	pub fn get(&self, package_type: PackageType) -> &PackagesMeta {
 		match package_type {
 			PackageType::Mod => &self.mods,
@@ -293,7 +303,7 @@ impl PackageManager {
 		}
 	}
 
-	/// Get the PackagesMeta for a specific package type. Does not sync.
+	/// Get the `PackagesMeta` for a specific package type. Does not sync.
 	fn get_mut(&mut self, package_type: PackageType) -> &mut PackagesMeta {
 		match package_type {
 			PackageType::Mod => &mut self.mods,
@@ -482,7 +492,7 @@ impl PackageManager {
 		}
 
 		if packages.len() != packages_to_keep.len() {
-			packages.retain(|pkg_path, _| packages_to_keep.contains(pkg_path))
+			packages.retain(|pkg_path, _| packages_to_keep.contains(pkg_path));
 		}
 
 		Ok(())
@@ -538,6 +548,7 @@ pub enum PackageMetadata {
 }
 
 impl PackageMetadata {
+	#[must_use]
 	pub fn from_managed_package(package: ManagedPackage, version: ManagedVersion) -> Self {
 		Self::Managed {
 			package_id: package.id,
@@ -549,11 +560,12 @@ impl PackageMetadata {
 		}
 	}
 
-	pub fn get_package_type(&self) -> Option<PackageType> {
+	#[must_use]
+	pub const fn get_package_type(&self) -> Option<PackageType> {
 		match self {
-			PackageMetadata::Managed { package_type, .. } => Some(*package_type),
-			PackageMetadata::Mapped { package_type, .. } => *package_type,
-			PackageMetadata::Unknown => None,
+			Self::Managed { package_type, .. } => Some(*package_type),
+			Self::Mapped { package_type, .. } => *package_type,
+			Self::Unknown => None,
 		}
 	}
 }
@@ -576,7 +588,7 @@ pub struct ManagedUser {
 	pub role: Option<String>,
 }
 
-fn default_is_organization_user() -> bool {
+const fn default_is_organization_user() -> bool {
 	false
 }
 
@@ -623,7 +635,7 @@ pub struct ManagedPackage {
 }
 
 #[cfg_attr(feature = "specta", derive(specta::Type))]
-#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct License {
 	#[serde(default)]
 	pub id: String,
@@ -658,6 +670,7 @@ pub struct ManagedVersion {
 }
 
 impl ManagedVersion {
+	#[must_use]
 	pub fn get_primary_file(&self) -> Option<&ManagedVersionFile> {
 		self.files.iter().find(|f| f.primary)
 	}
@@ -665,7 +678,7 @@ impl ManagedVersion {
 
 /// Universal interface for managed package files.
 #[cfg_attr(feature = "specta", derive(specta::Type))]
-#[derive(Serialize, Deserialize, PartialEq, Clone, Debug)]
+#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
 pub struct ManagedVersionFile {
 	pub url: String,
 	pub file_name: String,
@@ -709,7 +722,7 @@ pub enum PackageSide {
 
 /// The file type of a [`Package`].
 #[cfg_attr(feature = "specta", derive(specta::Type))]
-#[derive(Serialize, Deserialize, PartialEq, Clone, Debug)]
+#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
 #[serde(rename_all = "snake_case")]
 pub enum PackageFile {
 	RequiredPack,
diff --git a/packages/core/src/store/processor.rs b/packages/core/src/store/processor.rs
index 3e9e2f29..16b6848b 100644
--- a/packages/core/src/store/processor.rs
+++ b/packages/core/src/store/processor.rs
@@ -16,12 +16,12 @@ use crate::constants::PROCESSOR_FILE;
 use crate::proxy::send::send_process;
 use crate::proxy::ProcessPayloadType;
 use crate::utils::http::read_json;
-use crate::utils::io::IOError;
 use crate::State;
+use onelauncher_utils::io::IOError;
 
 use super::{Cluster, ClusterPath};
 
-/// Wrapper over a HashMap of PIDs to ProcessorChildren and unified apis
+/// Wrapper over a `HashMap` of PIDs to `ProcessorChildren` and unified apis
 pub struct Processor(HashMap<Uuid, Arc<RwLock<ProcessorChild>>>);
 
 /// Manager for safe processes like ingress feeds which need to be safely shut down.
@@ -48,13 +48,14 @@ impl Default for IngressProcessor {
 
 impl IngressProcessor {
 	/// Initialize a new ingresss process manager.
-	pub fn new() -> Self {
+	#[must_use]
+	pub const fn new() -> Self {
 		Self {
 			ingress_feeds: Vec::new(),
 		}
 	}
 
-	/// Add an ingress safety process to the HashMap.
+	/// Add an ingress safety process to the `HashMap`.
 	pub async fn add_ingress(r#type: IngressProcessType, uuid: Uuid) -> crate::Result<Uuid> {
 		let state = State::get().await?;
 		let mut ingress_processor = state.ingress_processor.write().await;
@@ -67,7 +68,7 @@ impl IngressProcessor {
 		Ok(uuid)
 	}
 
-	/// Complete and retain an ingress safety process from the HashMap of ingress feeds.
+	/// Complete and retain an ingress safety process from the `HashMap` of ingress feeds.
 	pub async fn finish(r#type: IngressProcessType, uuid: Uuid) -> crate::Result<()> {
 		let state = State::get().await?;
 		let mut ingress_processor = state.ingress_processor.write().await;
@@ -127,15 +128,16 @@ pub struct ProcessorCache {
 }
 
 impl ChildType {
-	/// Get the PID of a specific ChildType process.
+	/// Get the PID of a specific `ChildType` process.
+	#[must_use]
 	pub fn id(&self) -> Option<u32> {
 		match self {
-			ChildType::ChildProcess(child) => child.id(),
-			ChildType::RescuedChild(pid) => Some(*pid),
+			Self::ChildProcess(child) => child.id(),
+			Self::RescuedChild(pid) => Some(*pid),
 		}
 	}
 
-	/// Store a cache of a specific ChildType.
+	/// Store a cache of a specific `ChildType`.
 	pub async fn cache(
 		&self,
 		uuid: Uuid,
@@ -144,11 +146,11 @@ impl ChildType {
 		user: Option<Uuid>,
 	) -> crate::Result<()> {
 		let pid = match self {
-			ChildType::ChildProcess(child) => child.id().unwrap_or(0),
-			ChildType::RescuedChild(pid) => *pid,
+			Self::ChildProcess(child) => child.id().unwrap_or(0),
+			Self::RescuedChild(pid) => *pid,
 		};
 
-		let state = crate::State::get().await?;
+		let state = State::get().await?;
 		let mut system = sysinfo::System::new();
 
 		system.refresh_processes(sysinfo::ProcessesToUpdate::All);
@@ -174,13 +176,9 @@ impl ChildType {
 		};
 
 		let path = state.directories.caches_dir().await.join(PROCESSOR_FILE);
-		let mut caches = if let Ok(proc_json) =
-			read_json::<HashMap<Uuid, ProcessorCache>>(&path, &state.io_semaphore).await
-		{
-			proc_json
-		} else {
-			HashMap::new()
-		};
+		let mut caches = (read_json::<HashMap<Uuid, ProcessorCache>>(&path, &state.io_semaphore)
+			.await)
+			.unwrap_or_default();
 
 		caches.insert(uuid, cached_proccess);
 		crate::utils::http::write(&path, &serde_json::to_vec(&caches)?, &state.io_semaphore)
@@ -191,15 +189,11 @@ impl ChildType {
 
 	/// Remove a child from the global store of processes.
 	pub async fn remove(&self, uuid: Uuid) -> crate::Result<()> {
-		let state = crate::State::get().await?;
+		let state = State::get().await?;
 		let path = state.directories.caches_dir().await.join(PROCESSOR_FILE);
-		let mut caches = if let Ok(proc_json) =
-			read_json::<HashMap<Uuid, ProcessorCache>>(&path, &state.io_semaphore).await
-		{
-			proc_json
-		} else {
-			HashMap::new()
-		};
+		let mut caches = (read_json::<HashMap<Uuid, ProcessorCache>>(&path, &state.io_semaphore)
+			.await)
+			.unwrap_or_default();
 		caches.remove(&uuid);
 		crate::utils::http::write(&path, &serde_json::to_vec(&caches)?, &state.io_semaphore)
 			.await?;
@@ -210,8 +204,8 @@ impl ChildType {
 	/// Kill a process in the global store of processes.
 	pub async fn kill(&mut self) -> crate::Result<()> {
 		match self {
-			ChildType::ChildProcess(child) => Ok(child.kill().await.map_err(IOError::from)?),
-			ChildType::RescuedChild(pid) => {
+			Self::ChildProcess(child) => Ok(child.kill().await.map_err(IOError::from)?),
+			Self::RescuedChild(pid) => {
 				let mut system = sysinfo::System::new();
 				if system.refresh_processes(sysinfo::ProcessesToUpdate::Some(&[
 					sysinfo::Pid::from_u32(*pid),
@@ -230,11 +224,11 @@ impl ChildType {
 	/// Wait for a process to complete.
 	pub async fn try_wait(&mut self) -> crate::Result<Option<i32>> {
 		match self {
-			ChildType::ChildProcess(child) => Ok(child
+			Self::ChildProcess(child) => Ok(child
 				.try_wait()
 				.map_err(IOError::from)?
 				.map(|x| x.code().unwrap_or(0))),
-			ChildType::RescuedChild(pid) => {
+			Self::RescuedChild(pid) => {
 				let mut system = sysinfo::System::new();
 				if system.refresh_processes(sysinfo::ProcessesToUpdate::Some(&[
 					sysinfo::Pid::from_u32(*pid),
@@ -279,18 +273,21 @@ pub struct ProcessorChild {
 
 impl Processor {
 	/// Get a new [`Processor`] instance.
+	#[must_use]
 	pub fn new() -> Self {
-		Processor(HashMap::new())
+		Self(HashMap::new())
 	}
 
 	/// Returns a reference to the value corresponding to the key.
+	#[must_use]
 	pub fn get(&self, uuid: Uuid) -> Option<Arc<RwLock<ProcessorChild>>> {
 		self.0.get(&uuid).cloned()
 	}
 
 	/// An collection visiting all keys in arbitrary order.
+	#[must_use]
 	pub fn keys(&self) -> Vec<Uuid> {
-		self.0.keys().cloned().collect()
+		self.0.keys().copied().collect()
 	}
 
 	/// Get all running processes.
@@ -390,13 +387,12 @@ impl Processor {
 
 	/// restore processes from the cache.
 	pub async fn restore(&mut self) -> crate::Result<()> {
-		let state = crate::State::get().await?;
+		let state = State::get().await?;
 		let processor_path = state.directories.caches_dir().await.join(PROCESSOR_FILE);
 		let mut processor_caches = if let Ok(processes_json) =
-			read_json::<HashMap<uuid::Uuid, ProcessorCache>>(&processor_path, &state.io_semaphore)
-				.await
+			read_json::<HashMap<Uuid, ProcessorCache>>(&processor_path, &state.io_semaphore).await
 		{
-			let zeros = HashMap::<uuid::Uuid, ProcessorCache>::new();
+			let zeros = HashMap::<Uuid, ProcessorCache>::new();
 			crate::utils::http::write(
 				&processor_path,
 				&serde_json::to_vec(&zeros)?,
@@ -469,7 +465,7 @@ impl Processor {
 			} {
 				if let Some(line) = line {
 					let mut censored = line.clone();
-					for (key, value) in censors.iter() {
+					for (key, value) in &censors {
 						censored = censored.replace(key, value);
 					}
 
@@ -521,7 +517,7 @@ impl Processor {
 		&mut self,
 		cache: ProcessorCache,
 	) -> crate::Result<Arc<RwLock<ProcessorChild>>> {
-		let _state = crate::State::get().await?;
+		let _state = State::get().await?;
 
 		// ensure located stray process matches with our pid recorded process
 		{
@@ -680,7 +676,7 @@ impl Processor {
 		});
 
 		tokio::spawn(async {
-			let state = match crate::State::get().await {
+			let state = match State::get().await {
 				Ok(state) => state,
 				Err(err) => {
 					tracing::warn!("failed to get state: {}", err);
@@ -717,8 +713,7 @@ impl Processor {
 			let mut cmd = hook.split(' ');
 			if let Some(c) = cmd.next() {
 				let mut c = Command::new(c);
-				c.args(cmd.collect::<Vec<&str>>())
-					.current_dir(cluster_path.full_path().await?);
+				c.args(cmd).current_dir(cluster_path.full_path().await?);
 				Some(c)
 			} else {
 				None
diff --git a/packages/core/src/store/settings.rs b/packages/core/src/store/settings.rs
index 22450990..4585ed7f 100644
--- a/packages/core/src/store/settings.rs
+++ b/packages/core/src/store/settings.rs
@@ -2,7 +2,7 @@
 
 use super::{Directories, JavaVersions};
 use crate::constants::CURRENT_SETTINGS_FORMAT_VERSION;
-use crate::utils::io;
+use onelauncher_utils::io;
 use serde::{Deserialize, Serialize};
 use std::path::{Path, PathBuf};
 
@@ -10,15 +10,15 @@ use std::path::{Path, PathBuf};
 #[cfg_attr(feature = "specta", derive(specta::Type))]
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Settings {
-	/// A OneLauncher [`Theme`] managed by the core GUI.
+	/// A `OneLauncher` [`Theme`] managed by the core GUI.
 	pub theme: Theme,
-	/// A global browser list view for the OneLauncher GUI.
+	/// A global browser list view for the `OneLauncher` GUI.
 	#[serde(default)]
 	pub browser_list_view: BrowserListView,
-	/// Does not ask for confirmation when closing the OneLauncher GUI
+	/// Does not ask for confirmation when closing the `OneLauncher` GUI
 	#[serde(default)]
 	pub hide_close_prompt: bool,
-	/// Disables animations in the OneLauncher GUI
+	/// Disables animations in the `OneLauncher` GUI
 	#[serde(default)]
 	pub disable_animations: bool,
 	/// A global fullscreen Minecraft state.
@@ -78,7 +78,7 @@ impl Settings {
 			let read_settings = io::read(&file)
 				.await
 				.map_err(|err| anyhow::anyhow!("error reading settings file: {0}", err).into())
-				.and_then(|it| serde_json::from_slice::<Settings>(&it).map_err(crate::Error::from));
+				.and_then(|it| serde_json::from_slice::<Self>(&it).map_err(crate::Error::from));
 
 			if let Err(ref err) = read_settings {
 				tracing::error!("failed to load settings file: {err}.");
@@ -143,7 +143,7 @@ impl Settings {
 	}
 }
 
-/// OneLauncher browser list type.
+/// `OneLauncher` browser list type.
 #[cfg_attr(feature = "specta", derive(specta::Type))]
 #[derive(Default, Debug, Clone, Copy, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -154,7 +154,7 @@ pub enum BrowserListView {
 	Preview,
 }
 
-/// A OneLauncher theme managed by the GUI.
+/// A `OneLauncher` theme managed by the GUI.
 #[cfg_attr(feature = "specta", derive(specta::Type))]
 #[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -164,7 +164,7 @@ pub enum Theme {
 	/// A default Light theme.
 	Light,
 	/// OLED Dark Theme.
-	Contrast,
+	Oled,
 	/// Cute and colorful theme.
 	Cat,
 }
diff --git a/packages/core/src/utils/http.rs b/packages/core/src/utils/http.rs
index bb4900e7..fad80431 100644
--- a/packages/core/src/utils/http.rs
+++ b/packages/core/src/utils/http.rs
@@ -4,7 +4,6 @@
 
 use std::ffi::OsStr;
 use std::path::{Path, PathBuf};
-use std::time::Duration;
 
 use bytes::Bytes;
 use reqwest::Method;
@@ -15,9 +14,9 @@ use tokio::sync::{RwLock, Semaphore};
 use crate::constants::FETCH_ATTEMPTS;
 use crate::proxy::send::send_ingress;
 use crate::proxy::IngressId;
-use crate::utils::io;
 
-use super::io::IOError;
+use onelauncher_utils::io;
+use onelauncher_utils::io::IOError;
 
 /// A [`Semaphore`] used for all I/O operations.
 #[derive(Debug)]
@@ -34,7 +33,7 @@ lazy_static::lazy_static! {
 			"{}/{} (https://polyfrost.org)",
 			crate::constants::NAME,
 			crate::constants::VERSION,
-		)).unwrap();
+		)).expect("failed to build reqwest headers!");
 		headers.insert(reqwest::header::USER_AGENT, header);
 		reqwest::Client::builder()
 			.tcp_keepalive(Some(std::time::Duration::from_secs(15)))
@@ -91,7 +90,7 @@ pub async fn fetch_advanced(
 		let mut req = REQWEST_CLIENT.request(method.clone(), url);
 
 		if let Some(body) = json_body.clone() {
-			req = req.json(&body)
+			req = req.json(&body);
 		}
 
 		if let Some(header) = header {
@@ -120,7 +119,7 @@ pub async fn fetch_advanced(
 							.await?;
 						}
 
-						Ok(bytes::Bytes::from(bytes))
+						Ok(Bytes::from(bytes))
 					} else {
 						x.bytes().await
 					}
@@ -134,14 +133,13 @@ pub async fn fetch_advanced(
 						if &*hash != sha1 {
 							if attempt <= 3 {
 								continue;
-							} else {
-								return Err(anyhow::anyhow!(
-									"hash {0} does not match {1}",
-									sha1.to_string(),
-									hash
-								)
-								.into());
 							}
+							return Err(anyhow::anyhow!(
+								"hash {0} does not match {1}",
+								sha1.to_string(),
+								hash
+							)
+							.into());
 						}
 					}
 
@@ -191,7 +189,7 @@ pub async fn fetch_from_mirrors(
 pub async fn check_internet_connection(timeout: u64) -> bool {
 	REQWEST_CLIENT
 		.get("https://api.polyfrost.org/")
-		.timeout(Duration::from_secs(timeout))
+		.timeout(std::time::Duration::from_secs(timeout))
 		.send()
 		.await
 		.is_ok()
@@ -255,8 +253,8 @@ pub async fn write<'a>(path: &Path, bytes: &[u8], semaphore: &IoSemaphore) -> cr
 
 /// Copy a file from one [`AsRef<Path>`] to another.
 pub async fn copy(
-	src: impl AsRef<std::path::Path>,
-	dest: impl AsRef<std::path::Path>,
+	src: impl AsRef<Path>,
+	dest: impl AsRef<Path>,
 	semaphore: &IoSemaphore,
 ) -> crate::Result<()> {
 	let src = src.as_ref();
diff --git a/packages/core/src/utils/java.rs b/packages/core/src/utils/java.rs
index d333aa70..27ef9eba 100644
--- a/packages/core/src/utils/java.rs
+++ b/packages/core/src/utils/java.rs
@@ -18,14 +18,14 @@ use winreg::{
 	RegKey,
 };
 
-use super::io;
+use onelauncher_utils::io;
 
 /// A struct representing a single version of the Java Runtime Environment.
 /// Use [`locate_java`] to get an array of all located java instances on the machine.
 ///
-/// common java paths from https://github.com/PrismLauncher/PrismLauncher/blob/develop/launcher/java/JavaUtils.cpp under GPL 3.0
+/// common java paths from <https://github.com/PrismLauncher/PrismLauncher/blob/develop/launcher/java/JavaUtils.cpp> under GPL 3.0
 ///
-/// java check functionality from https://github.com/modrinth/theseus/blob/master/theseus/src/util/jre.rs under MIT
+/// java check functionality from <https://github.com/modrinth/theseus/blob/master/theseus/src/util/jre.rs> under MIT
 #[cfg_attr(feature = "specta", derive(specta::Type))]
 #[derive(Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Clone)]
 pub struct JavaVersion {
@@ -192,9 +192,13 @@ pub async fn locate_java() -> Result<Vec<JavaVersion>, JavaError> {
 #[onelauncher_macros::memory]
 async fn locate_installed_java() -> Result<HashSet<PathBuf>, JavaError> {
 	Box::pin(async move {
-		let state = State::get().await.map_err(|_| JavaError::MutexError)?;
 		let mut paths = HashSet::new();
-		let java_base_path = state.directories.java_dir().await;
+		let java_base_path = State::get()
+			.await
+			.map_err(|_| JavaError::MutexError)?
+			.directories
+			.java_dir()
+			.await;
 
 		if java_base_path.is_dir() {
 			if let Ok(dir) = std::fs::read_dir(java_base_path) {
@@ -239,7 +243,7 @@ pub async fn check_java(paths: HashSet<PathBuf>) -> HashSet<JavaVersion> {
 
 	java_instances
 		.into_iter()
-		.flat_map(|p| p.ok())
+		.filter_map(Result::ok)
 		.flatten()
 		.collect()
 }
@@ -253,10 +257,10 @@ pub async fn check_java_instance(path: &Path) -> Option<JavaVersion> {
 	let Ok(path) = io::canonicalize(path) else {
 		return None;
 	};
-	let java = if path.file_name()?.to_str()? != JAVA_BIN {
-		path.join(JAVA_BIN)
-	} else {
+	let java = if path.file_name()?.to_str()? == JAVA_BIN {
 		path
+	} else {
+		path.join(JAVA_BIN)
 	};
 	if !java.exists() {
 		return None;
@@ -277,7 +281,7 @@ pub async fn check_java_instance(path: &Path) -> Option<JavaVersion> {
 
 	let output = Command::new(&java)
 		.arg("-cp")
-		.arg(file_path.parent().unwrap())
+		.arg(file_path.parent().expect("failed to get java parent"))
 		.arg("JavaInfo")
 		.env_remove("_JAVA_OPTIONS")
 		.output()
diff --git a/packages/core/src/utils/mod.rs b/packages/core/src/utils/mod.rs
index 229a8ec0..78d13300 100644
--- a/packages/core/src/utils/mod.rs
+++ b/packages/core/src/utils/mod.rs
@@ -1,32 +1,10 @@
-//! **OneLauncher Utilities**
-//! Standard asynchronous utilities and wrappers for use in the launcher.
+//! **`OneLauncher` Core Utilities**
+//! Standard asynchronous utilities and wrappers for use within the launcher core.
 //!
-//! - [`io`]: Async wrapper around [`tokio::fs`] and [`std::io::Error`] for our error system.
 //! - [`http`]: Async extensions and wrappers around [`reqwest`] functions.
 //! - [`java`]: Async utilities for managing and downloading Java versions.
-//! - [`platform`]: Async utilities for managing OS-specific [`interpulse`] operations and rules.
 //! - [`watcher`]: Async utilities for watching files with [`notify`].
-//! - [`logging`]: Async utilities for log4j parsing with [`nom`].
 
 pub mod http;
-pub mod io;
 pub mod java;
-pub mod logging;
-pub mod platform;
 pub mod watcher;
-
-/// Simple macro that takes a mutable reference and inserts it into a codeblock closure
-/// as an owned reference.
-///
-/// mutable reference gets epically owned by free thinking macro!!!!! (not clickbait)
-/// im going insane insane insane insane insane insane insane insane insane
-macro_rules! ref_owned {
-	($id:ident = $init:expr => $transform:block) => {{
-		let mut it = $init;
-		{
-			let $id = &mut it;
-			$transform;
-		}
-		it
-	}};
-}
diff --git a/packages/core/src/utils/watcher.rs b/packages/core/src/utils/watcher.rs
index 520c7e6e..acaf383b 100644
--- a/packages/core/src/utils/watcher.rs
+++ b/packages/core/src/utils/watcher.rs
@@ -19,8 +19,11 @@ pub async fn initialize_watcher() -> crate::Result<Debouncer<RecommendedWatcher>
 		Duration::from_secs_f32(2.0),
 		move |result: DebounceEventResult| {
 			futures::executor::block_on(async {
-				sender.send(result).await.unwrap();
-			})
+				sender
+					.send(result)
+					.await
+					.expect("failed to send debouse event");
+			});
 		},
 	)?;
 
@@ -34,7 +37,7 @@ pub async fn initialize_watcher() -> crate::Result<Debouncer<RecommendedWatcher>
 				Ok(mut events) => {
 					let mut paths = Vec::new();
 					events.sort_by(|a, b| a.path.cmp(&b.path));
-					events.iter().for_each(|a| {
+					for a in &events {
 						let mut formatted = PathBuf::new();
 						let mut components = a.path.components();
 						let mut matched = false;
@@ -57,7 +60,7 @@ pub async fn initialize_watcher() -> crate::Result<Debouncer<RecommendedWatcher>
 						if a.path
 							.components()
 							.any(|c| c.as_os_str() == crate::constants::CRASH_PATH)
-							&& a.path.extension().map(|e| e == "txt").unwrap_or(false)
+							&& a.path.extension().is_some_and(|e| e == "txt")
 						{
 							Cluster::handle_crash(cluster_path);
 						} else if !paths.contains(&formatted) {
@@ -72,7 +75,7 @@ pub async fn initialize_watcher() -> crate::Result<Debouncer<RecommendedWatcher>
 								Clusters::sync_cluster(cluster_path);
 							}
 						}
-					});
+					}
 				}
 				Err(err) => tracing::warn!("fs watching error: {err}"),
 			}
diff --git a/packages/gamemode/src/lib.rs b/packages/gamemode/src/lib.rs
index 77969b26..7d31cd48 100644
--- a/packages/gamemode/src/lib.rs
+++ b/packages/gamemode/src/lib.rs
@@ -1,4 +1,37 @@
 #![cfg(target_os = "linux")]
+#![warn(
+	clippy::all,
+	clippy::pedantic,
+	clippy::correctness,
+	clippy::perf,
+	clippy::style,
+	clippy::suspicious,
+	clippy::complexity,
+	clippy::nursery,
+	clippy::unwrap_used,
+	unused_qualifications,
+	rust_2018_idioms,
+	trivial_casts,
+	trivial_numeric_casts,
+	unused_allocation,
+	clippy::unnecessary_cast,
+	clippy::cast_lossless,
+	clippy::cast_possible_truncation,
+	clippy::cast_possible_wrap,
+	clippy::cast_sign_loss,
+	clippy::dbg_macro,
+	unused_import_braces,
+	clippy::deprecated_cfg_attr,
+	clippy::separated_literal_suffix,
+	deprecated
+)]
+#![forbid(deprecated_in_future)]
+#![deny(unused_must_use)]
+#![allow(
+	clippy::missing_errors_doc,
+	clippy::future_not_send,
+	clippy::module_name_repetitions
+)]
 
 use libc::pid_t;
 use std::ffi::c_int;
diff --git a/packages/macros/src/lib.rs b/packages/macros/src/lib.rs
index 72fd14a0..ba080f97 100644
--- a/packages/macros/src/lib.rs
+++ b/packages/macros/src/lib.rs
@@ -1,4 +1,36 @@
-extern crate proc_macro;
+#![warn(
+	clippy::all,
+	clippy::pedantic,
+	clippy::correctness,
+	clippy::perf,
+	clippy::style,
+	clippy::suspicious,
+	clippy::complexity,
+	clippy::nursery,
+	clippy::unwrap_used,
+	unused_qualifications,
+	rust_2018_idioms,
+	trivial_casts,
+	trivial_numeric_casts,
+	unused_allocation,
+	clippy::unnecessary_cast,
+	clippy::cast_lossless,
+	clippy::cast_possible_truncation,
+	clippy::cast_possible_wrap,
+	clippy::cast_sign_loss,
+	clippy::dbg_macro,
+	unused_import_braces,
+	clippy::deprecated_cfg_attr,
+	clippy::separated_literal_suffix,
+	deprecated
+)]
+#![forbid(deprecated_in_future)]
+#![deny(unused_must_use)]
+#![allow(
+	clippy::missing_errors_doc,
+	clippy::future_not_send,
+	clippy::module_name_repetitions
+)]
 
 use proc_macro::TokenStream;
 use quote::quote;
diff --git a/packages/prisma/src/lib.rs b/packages/prisma/src/lib.rs
index c8996381..6ab08612 100644
--- a/packages/prisma/src/lib.rs
+++ b/packages/prisma/src/lib.rs
@@ -2,3 +2,14 @@
 #[allow(warnings, unused)]
 #[rustfmt::skip]
 pub mod prisma;
+
+
+pub async fn test_db() -> std::sync::Arc<prisma::PrismaClient> {
+	std::sync::Arc::new(
+		prisma::PrismaClient::_builder()
+			.with_url(format!("file:/tmp/test-db-{}", uuid::Uuid::new_v4()))
+			.build()
+			.await
+			.unwrap(),
+	)
+}
diff --git a/packages/utils/Cargo.toml b/packages/utils/Cargo.toml
new file mode 100644
index 00000000..a8075405
--- /dev/null
+++ b/packages/utils/Cargo.toml
@@ -0,0 +1,32 @@
+[package]
+name = "onelauncher_utils"
+description = "rust utils for onelauncher"
+version = { workspace = true }
+license = { workspace = true }
+edition = { workspace = true }
+repository = { workspace = true }
+documentation = { workspace = true }
+readme = { workspace = true }
+homepage = { workspace = true }
+authors = { workspace = true }
+
+[dependencies]
+onelauncher_prisma = { workspace = true }
+serde = { workspace = true }
+uuid = { workspace = true }
+async-channel = { workspace = true }
+futures = { workspace = true }
+pin-project-lite = { workspace = true }
+tokio = { workspace = true }
+tempfile = { workspace = true }
+sys-info = { workspace = true }
+zip = { workspace = true }
+dunce = { workspace = true }
+async-compression = { workspace = true }
+chrono = { workspace = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }
+nom = { workspace = true }
+prisma-client-rust = { workspace = true }
+regex = { workspace = true }
+interpulse = { workspace = true }
diff --git a/packages/core/src/utils/io.rs b/packages/utils/src/io.rs
similarity index 92%
rename from packages/core/src/utils/io.rs
rename to packages/utils/src/io.rs
index 5d5f690c..68a2b610 100644
--- a/packages/core/src/utils/io.rs
+++ b/packages/utils/src/io.rs
@@ -12,7 +12,7 @@ use tokio::task::spawn_blocking;
 #[derive(Debug, thiserror::Error)]
 pub enum IOError {
 	/// A wrapped [`std::io::Error`] along with the path involved in the error.
-	#[error("{source}, path: {path}")]
+	#[error("error acessing path: {source}, path: {path}")]
 	IOErrorWrapper {
 		#[source]
 		source: std::io::Error,
@@ -26,14 +26,29 @@ pub enum IOError {
 	IOError(#[from] std::io::Error),
 }
 
+impl<P: AsRef<std::path::Path>> From<(P, std::io::Error)> for IOError {
+	fn from((path, source): (P, std::io::Error)) -> Self {
+		Self::IOErrorWrapper {
+			source,
+			path: path.as_ref().to_string_lossy().to_string(),
+		}
+	}
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("received a non UTF-8 path: <lossy_path='{}'>", .0.to_string_lossy())]
+pub struct NonUtf8PathError(pub Box<std::path::Path>);
+
 impl IOError {
 	/// Converts a [`std::io::Error`] into an [`IOError`].
-	pub fn from(source: std::io::Error) -> Self {
+	#[must_use]
+	pub const fn from(source: std::io::Error) -> Self {
 		Self::IOError(source)
 	}
 
 	/// Converts a [`zip::result::ZipError`] into an [`IOError`].
-	pub fn from_zip(source: zip::result::ZipError) -> Self {
+	#[must_use]
+	pub const fn from_zip(source: zip::result::ZipError) -> Self {
 		Self::ZipError(source)
 	}
 
diff --git a/packages/utils/src/lib.rs b/packages/utils/src/lib.rs
new file mode 100644
index 00000000..17ead8de
--- /dev/null
+++ b/packages/utils/src/lib.rs
@@ -0,0 +1,82 @@
+//! **`OneLauncher` Utilities**
+//! Standard utilities for use within all Rust subprojects.
+//!
+//! - [`logging`]: Async utilities for log4j parsing with [`nom`].
+//! - [`platform`]: Async utilities for managing OS-specific [`interpulse`] operations and rules.
+//! - [`io`]: Async wrapper around [`tokio::fs`] and [`std::io::Error`] for our error system.
+
+#![warn(
+	clippy::all,
+	clippy::pedantic,
+	clippy::correctness,
+	clippy::perf,
+	clippy::style,
+	clippy::suspicious,
+	clippy::complexity,
+	clippy::nursery,
+	clippy::unwrap_used,
+	unused_qualifications,
+	rust_2018_idioms,
+	trivial_casts,
+	trivial_numeric_casts,
+	unused_allocation,
+	clippy::unnecessary_cast,
+	clippy::cast_lossless,
+	clippy::cast_possible_truncation,
+	clippy::cast_possible_wrap,
+	clippy::cast_sign_loss,
+	clippy::dbg_macro,
+	unused_import_braces,
+	clippy::deprecated_cfg_attr,
+	clippy::separated_literal_suffix,
+	deprecated
+)]
+#![forbid(deprecated_in_future)]
+#![deny(unused_must_use)]
+#![allow(
+	clippy::missing_errors_doc,
+	clippy::future_not_send,
+	clippy::module_name_repetitions
+)]
+
+pub mod io;
+pub mod logging;
+pub mod platform;
+pub mod prisma;
+
+/// Simple macro that takes a mutable reference and inserts it into a codeblock closure
+/// as an owned reference.
+///
+/// mutable reference gets epically owned by free thinking macro!!!!! (not clickbait)
+/// im going insane insane insane insane insane insane insane insane insane
+#[macro_export]
+macro_rules! ref_owned {
+	($id:ident = $init:expr => $transform:block) => {{
+		let mut it = $init;
+		{
+			let $id = &mut it;
+			$transform;
+		}
+		it
+	}};
+}
+
+/// Combines an iterator of `T` and an iterator of [`Option<T>`],
+/// removing and ensuring the safety of any [`None`] values in the process.
+pub fn chain_iterator<T>(
+	required: impl IntoIterator<Item = T>,
+	optional: impl IntoIterator<Item = Option<T>>,
+) -> Vec<T> {
+	required
+		.into_iter()
+		.map(Some)
+		.chain(optional)
+		.flatten()
+		.collect()
+}
+
+#[inline]
+#[must_use]
+pub fn test_type_of<T>(_: T) -> &'static str {
+	std::any::type_name::<T>()
+}
diff --git a/packages/core/src/utils/logging.rs b/packages/utils/src/logging.rs
similarity index 89%
rename from packages/core/src/utils/logging.rs
rename to packages/utils/src/logging.rs
index 30181b4b..ec64e265 100644
--- a/packages/core/src/utils/logging.rs
+++ b/packages/utils/src/logging.rs
@@ -34,7 +34,7 @@ fn whitespace<'a, O, E: ParseError<&'a str>>(
 	delimited(multispace0, inner, multispace0)
 }
 
-pub fn parse_logentry(input: &str) -> IResult<&str, LogEntry> {
+pub fn parse_logentry(input: &str) -> IResult<&str, LogEntry<'_>> {
 	let (o, (attributes, _, message)) = preceded(
 		multispace0,
 		alt((
@@ -74,7 +74,7 @@ pub struct Attributes<'a> {
 	pub thread_name: &'a str,
 }
 
-fn attributes(input: &str) -> IResult<&str, Attributes> {
+fn attributes(input: &str) -> IResult<&str, Attributes<'_>> {
 	let (o, attributes) = count(whitespace(attribute), 4)(input)?;
 	macro_rules! extract_attribute {
 		($field:ident) => {{
@@ -114,11 +114,11 @@ enum Attribute<'a> {
 	ThreadName(&'a str),
 }
 
-fn attribute(input: &str) -> IResult<&str, Attribute> {
+fn attribute(input: &str) -> IResult<&str, Attribute<'_>> {
 	alt((attr_logger, attr_timestamp, attr_level, attr_thread))(input)
 }
 
-fn attr_logger(input: &str) -> IResult<&str, Attribute> {
+fn attr_logger(input: &str) -> IResult<&str, Attribute<'_>> {
 	map(
 		separated_pair(
 			tag("logger"),
@@ -129,7 +129,7 @@ fn attr_logger(input: &str) -> IResult<&str, Attribute> {
 	)(input)
 }
 
-fn attr_timestamp(input: &str) -> IResult<&str, Attribute> {
+fn attr_timestamp(input: &str) -> IResult<&str, Attribute<'_>> {
 	map(
 		separated_pair(
 			tag("timestamp"),
@@ -140,7 +140,7 @@ fn attr_timestamp(input: &str) -> IResult<&str, Attribute> {
 	)(input)
 }
 
-fn attr_level(input: &str) -> IResult<&str, Attribute> {
+fn attr_level(input: &str) -> IResult<&str, Attribute<'_>> {
 	map(
 		separated_pair(
 			tag("level"),
@@ -151,7 +151,7 @@ fn attr_level(input: &str) -> IResult<&str, Attribute> {
 	)(input)
 }
 
-fn attr_thread(input: &str) -> IResult<&str, Attribute> {
+fn attr_thread(input: &str) -> IResult<&str, Attribute<'_>> {
 	map(
 		separated_pair(
 			tag("thread"),
@@ -185,7 +185,7 @@ fn message(input: &str) -> IResult<&str, &str> {
 	)(input)
 }
 
-fn plain_text(input: &str) -> IResult<&str, (Attributes, &str, &str)> {
+fn plain_text(input: &str) -> IResult<&str, (Attributes<'_>, &str, &str)> {
 	map(take_until("<"), |text| {
 		(
 			Attributes {
@@ -201,15 +201,16 @@ fn plain_text(input: &str) -> IResult<&str, (Attributes, &str, &str)> {
 }
 
 #[cfg(test)]
+#[allow(clippy::unwrap_used)]
 mod tests {
 	use super::*;
 
 	#[test]
 	fn parse_message() {
 		message(
-			r#"<log4j:Message>
+			r"<log4j:Message>
                 <![CDATA[200 Datafixer optimizations took 2000 years]]>
-            </log4j:Message>"#,
+            </log4j:Message>",
 		)
 		.unwrap();
 	}
@@ -232,7 +233,7 @@ mod tests {
 			Attributes {
 				logger: "com.mojang.datafixers.DataFixerBuilder",
 				level: LogLevel::Debug,
-				timestamp: 3213819318239,
+				timestamp: 3_213_819_318_239,
 				thread_name: "Datafixer"
 			}
 		);
@@ -257,7 +258,7 @@ mod tests {
 	#[test]
 	fn parse_timestamp_attribute() {
 		let (_, attr) = attr_timestamp(r#"timestamp="313213473127""#).unwrap();
-		assert_eq!(attr, Attribute::Timestamp(313213473127));
+		assert_eq!(attr, Attribute::Timestamp(313_213_473_127));
 	}
 
 	#[test]
@@ -296,7 +297,7 @@ mod tests {
 			LogEntry {
 				logger: "com.mojang.datafixers.DataFixerBuilder",
 				level: LogLevel::Debug,
-				timestamp: 3213712731731,
+				timestamp: 3_213_712_731_731,
 				thread_name: "Datafixer",
 				message: "200 Datafixer optimizations took 2000 years",
 			}
diff --git a/packages/core/src/utils/platform.rs b/packages/utils/src/platform.rs
similarity index 92%
rename from packages/core/src/utils/platform.rs
rename to packages/utils/src/platform.rs
index a13dd12c..4e078a44 100644
--- a/packages/core/src/utils/platform.rs
+++ b/packages/utils/src/platform.rs
@@ -19,26 +19,26 @@ impl OsExt for Os {
 	fn native_arch(java_arch: &str) -> Self {
 		if std::env::consts::OS == "windows" {
 			if java_arch == "aarch64" {
-				Os::WindowsArm64
+				Self::WindowsArm64
 			} else {
-				Os::Windows
+				Self::Windows
 			}
 		} else if std::env::consts::OS == "linux" {
 			if java_arch == "aarch64" {
-				Os::LinuxArm64
+				Self::LinuxArm64
 			} else if java_arch == "arm" {
-				Os::LinuxArm32
+				Self::LinuxArm32
 			} else {
-				Os::Linux
+				Self::Linux
 			}
 		} else if std::env::consts::OS == "macos" {
 			if java_arch == "aarch64" {
-				Os::OsxArm64
+				Self::OsxArm64
 			} else {
-				Os::Osx
+				Self::Osx
 			}
 		} else {
-			Os::Unknown
+			Self::Unknown
 		}
 	}
 
@@ -53,6 +53,7 @@ impl OsExt for Os {
 }
 
 /// Handles an os-specific [`OsRule`], returning if the [`Os`] matches the rule.
+#[must_use]
 pub fn os_rule(rule: &OsRule, java_arch: &str, updated: bool) -> bool {
 	let mut rule_match = true;
 
@@ -78,6 +79,7 @@ pub fn os_rule(rule: &OsRule, java_arch: &str, updated: bool) -> bool {
 }
 
 /// Gets the seperator between Java classpaths in metadata (`";"` on Windows, `";"` on others).
+#[must_use]
 pub fn classpath_separator(java_arch: &str) -> &'static str {
 	match Os::native_arch(java_arch) {
 		Os::Osx | Os::OsxArm64 | Os::Linux | Os::LinuxArm32 | Os::LinuxArm64 | Os::Unknown => ":",
diff --git a/packages/utils/src/prisma.rs b/packages/utils/src/prisma.rs
new file mode 100644
index 00000000..8bfddf48
--- /dev/null
+++ b/packages/utils/src/prisma.rs
@@ -0,0 +1,136 @@
+use onelauncher_prisma::prisma::PrismaClient;
+use prisma_client_rust::migrations::{DbPushError, MigrateDeployError};
+use prisma_client_rust::NewClientError;
+
+/// Represents an error that occured while opening and running migrations
+/// on the [`prisma_client_rust`] database.
+#[derive(thiserror::Error, Debug)]
+pub enum MigrationError {
+	#[error("failed to initialize a new database connection: {0}")]
+	NewClient(#[from] Box<NewClientError>),
+	#[error("failed to migrate the database: {0}")]
+	MigrateFailed(#[from] MigrateDeployError),
+	#[cfg(debug_assertions)]
+	#[error("failed to migrate the database: {0}")]
+	DbPushFailed(#[from] DbPushError),
+}
+
+/// Loads the database from the given path and migrates it to the latest schema.
+pub async fn load_and_migrate(db_url: &str) -> Result<PrismaClient, MigrationError> {
+	let client = PrismaClient::_builder()
+		.with_url(db_url.to_string())
+		.build()
+		.await
+		.map_err(Box::new)?;
+	client._migrate_deploy().await?;
+
+	#[cfg(debug_assertions)]
+	{
+		let mut builder = client._db_push();
+		if std::env::var("ONELAUNCHER_DO_NOT_USE_THIS")
+			.map(|v| v == "true")
+			.unwrap_or(false)
+		{
+			builder = builder.accept_data_loss();
+		}
+
+		if std::env::var("ONELAUNCHER_FORCE_RESET")
+			.map(|v| v == "true")
+			.unwrap_or(false)
+		{
+			builder = builder.force_reset();
+		}
+
+		let res = builder.await;
+
+		match res {
+			Ok(_) => {}
+			Err(e @ DbPushError::PossibleDataLoss(_)) => {
+				eprintln!("pushing prisma schema may result in data loss. use `ONELAUNCHER_DO_NOT_USE_THIS=true` to force it.");
+				Err(e)?;
+			}
+			Err(e) => Err(e)?,
+		}
+	}
+
+	Ok(client)
+}
+
+/// Construct back an inode after storing it in database
+#[must_use]
+pub const fn inode_from_db(db_inode: &[u8]) -> u64 {
+	u64::from_le_bytes([
+		db_inode[0],
+		db_inode[1],
+		db_inode[2],
+		db_inode[3],
+		db_inode[4],
+		db_inode[5],
+		db_inode[6],
+		db_inode[7],
+	])
+}
+
+#[must_use]
+pub fn inode_to_db(inode: u64) -> Vec<u8> {
+	inode.to_le_bytes().to_vec()
+}
+
+#[must_use]
+pub const fn size_in_bytes_from_db(db_size_in_bytes: &[u8]) -> u64 {
+	u64::from_be_bytes([
+		db_size_in_bytes[0],
+		db_size_in_bytes[1],
+		db_size_in_bytes[2],
+		db_size_in_bytes[3],
+		db_size_in_bytes[4],
+		db_size_in_bytes[5],
+		db_size_in_bytes[6],
+		db_size_in_bytes[7],
+	])
+}
+
+#[must_use]
+pub fn size_in_bytes_to_db(size: u64) -> Vec<u8> {
+	size.to_be_bytes().to_vec()
+}
+
+#[derive(thiserror::Error, Debug)]
+#[error("missing database field {0}")]
+pub struct MissingFieldError(&'static str);
+
+impl MissingFieldError {
+	#[must_use]
+	pub const fn new(value: &'static str) -> Self {
+		Self(value)
+	}
+}
+
+pub trait OptionalField: Sized {
+	type Out;
+
+	fn transform(self) -> Option<Self::Out>;
+}
+
+impl<T> OptionalField for Option<T> {
+	type Out = T;
+
+	fn transform(self) -> Self {
+		self
+	}
+}
+
+impl<'a, T> OptionalField for &'a Option<T> {
+	type Out = &'a T;
+
+	fn transform(self) -> Option<Self::Out> {
+		self.as_ref()
+	}
+}
+
+pub fn maybe_missing<T: OptionalField>(
+	data: T,
+	field: &'static str,
+) -> Result<T::Out, MissingFieldError> {
+	data.transform().ok_or(MissingFieldError(field))
+}