diff --git a/apps/app-frontend/src/App.vue b/apps/app-frontend/src/App.vue
index d007db6bb..5ba7311c5 100644
--- a/apps/app-frontend/src/App.vue
+++ b/apps/app-frontend/src/App.vue
@@ -1,5 +1,5 @@
 <script setup>
-import { computed, ref, watch, onMounted } from 'vue'
+import { computed, ref, onMounted } from 'vue'
 import { RouterView, RouterLink, useRouter, useRoute } from 'vue-router'
 import {
   HomeIcon,
@@ -21,11 +21,11 @@ import SplashScreen from '@/components/ui/SplashScreen.vue'
 import ErrorModal from '@/components/ui/ErrorModal.vue'
 import ModrinthLoadingIndicator from '@/components/modrinth-loading-indicator'
 import { handleError, useNotifications } from '@/store/notifications.js'
-import { offline_listener, command_listener, warning_listener } from '@/helpers/events.js'
+import { command_listener, warning_listener } from '@/helpers/events.js'
 import { MinimizeIcon, MaximizeIcon, ChatIcon } from '@/assets/icons'
 import { type } from '@tauri-apps/api/os'
 import { appWindow } from '@tauri-apps/api/window'
-import { isDev, getOS, isOffline, showLauncherLogsFolder } from '@/helpers/utils.js'
+import { isDev, getOS, showLauncherLogsFolder } from '@/helpers/utils.js'
 import {
   mixpanel_track,
   mixpanel_init,
@@ -49,7 +49,14 @@ const themeStore = useTheming()
 const urlModal = ref(null)
 const isLoading = ref(true)
 
-const offline = ref(false)
+const offline = ref(!navigator.onLine)
+window.addEventListener('offline', () => {
+  offline.value = true
+})
+window.addEventListener('online', () => {
+  offline.value = false
+})
+
 const showOnboarding = ref(false)
 const nativeDecorations = ref(false)
 
@@ -96,11 +103,6 @@ defineExpose({
       document.getElementsByTagName('html')[0].classList.add('windows')
     }
 
-    offline.value = await isOffline()
-    await offline_listener((b) => {
-      offline.value = b
-    })
-
     await warning_listener((e) =>
       notificationsWrapper.value.addNotification({
         title: 'Warning',
diff --git a/apps/app-frontend/src/components/ui/ProjectCard.vue b/apps/app-frontend/src/components/ui/ProjectCard.vue
index 6f13772bb..b3e680d61 100644
--- a/apps/app-frontend/src/components/ui/ProjectCard.vue
+++ b/apps/app-frontend/src/components/ui/ProjectCard.vue
@@ -51,9 +51,15 @@ const toTransparent = computed(() => {
 const install = async (e) => {
   e?.stopPropagation()
   installing.value = true
-  await installVersion(props.project.project_id, null, props.instance.path, 'ProjectCard', () => {
-    installing.value = false
-  })
+  await installVersion(
+    props.project.project_id,
+    null,
+    props.instance ? props.instance.path : null,
+    'ProjectCard',
+    () => {
+      installing.value = false
+    },
+  )
 }
 </script>
 
diff --git a/apps/app-frontend/src/components/ui/RunningAppBar.vue b/apps/app-frontend/src/components/ui/RunningAppBar.vue
index ef5248373..13c059ab4 100644
--- a/apps/app-frontend/src/components/ui/RunningAppBar.vue
+++ b/apps/app-frontend/src/components/ui/RunningAppBar.vue
@@ -15,7 +15,7 @@
     </Button>
     <div v-if="offline" class="status">
       <span class="circle stopped" />
-      <div class="running-text clickable" @click="refreshInternet()">
+      <div class="running-text">
         <span> Offline </span>
       </div>
     </div>
@@ -111,10 +111,9 @@ import {
   kill_by_uuid as killProfile,
   get_uuids_by_profile_path as getProfileProcesses,
 } from '@/helpers/process'
-import { loading_listener, process_listener, offline_listener } from '@/helpers/events'
+import { loading_listener, process_listener } from '@/helpers/events'
 import { useRouter } from 'vue-router'
 import { progress_bars_list } from '@/helpers/state.js'
-import { refreshOffline, isOffline } from '@/helpers/utils.js'
 import ProgressBar from '@/components/ui/ProgressBar.vue'
 import { handleError } from '@/store/notifications.js'
 import { mixpanel_track } from '@/helpers/mixpanel'
@@ -132,12 +131,12 @@ const showProfiles = ref(false)
 const currentProcesses = ref(await getRunningProfiles().catch(handleError))
 const selectedProfile = ref(currentProcesses.value[0])
 
-const offline = ref(await isOffline().catch(handleError))
-const refreshInternet = async () => {
-  offline.value = await refreshOffline().catch(handleError)
-}
-const unlistenRefresh = await offline_listener(async (b) => {
-  offline.value = b
+const offline = ref(!navigator.onLine)
+window.addEventListener('offline', () => {
+  offline.value = true
+})
+window.addEventListener('online', () => {
+  offline.value = false
 })
 
 const unlistenProcess = await process_listener(async () => {
@@ -265,7 +264,6 @@ onBeforeUnmount(() => {
   window.removeEventListener('click', handleClickOutsideProfile)
   unlistenProcess()
   unlistenLoading()
-  unlistenRefresh()
 })
 </script>
 
diff --git a/apps/app-frontend/src/helpers/events.js b/apps/app-frontend/src/helpers/events.js
index d8899a78d..3bc07bcb9 100644
--- a/apps/app-frontend/src/helpers/events.js
+++ b/apps/app-frontend/src/helpers/events.js
@@ -17,7 +17,7 @@
         // event.payload is the payload object
         console.log(event)
       })
-      
+
     Putting that in a script will print any emitted signal from rust
 */
 import { listen } from '@tauri-apps/api/event'
@@ -93,15 +93,3 @@ export async function command_listener(callback) {
 export async function warning_listener(callback) {
   return await listen('warning', (event) => callback(event.payload))
 }
-
-/// Payload for the 'offline' event
-/*
-  OfflinePayload {
-    offline: bool, true or false
-  }
-*/
-export async function offline_listener(callback) {
-  return await listen('offline', (event) => {
-    return callback(event.payload)
-  })
-}
diff --git a/apps/app-frontend/src/helpers/jre.js b/apps/app-frontend/src/helpers/jre.js
index 571588443..f490cbf77 100644
--- a/apps/app-frontend/src/helpers/jre.js
+++ b/apps/app-frontend/src/helpers/jre.js
@@ -14,6 +14,14 @@ JavaVersion {
 
 */
 
+export async function get_java_versions() {
+  return await invoke('plugin:jre|get_java_versions')
+}
+
+export async function set_java_version(version) {
+  return await invoke('plugin:jre|set_java_version', { version })
+}
+
 // Finds all the installation of Java 7, if it exists
 // Returns [JavaVersion]
 export async function find_filtered_jres(version) {
diff --git a/apps/app-frontend/src/helpers/utils.js b/apps/app-frontend/src/helpers/utils.js
index 49757ee6e..5432ca710 100644
--- a/apps/app-frontend/src/helpers/utils.js
+++ b/apps/app-frontend/src/helpers/utils.js
@@ -48,22 +48,3 @@ export const releaseColor = (releaseType) => {
       return ''
   }
 }
-
-export const openLink = (url) => {
-  window.__TAURI_INVOKE__('tauri', {
-    __tauriModule: 'Shell',
-    message: {
-      cmd: 'open',
-      path: url,
-    },
-  })
-}
-
-export const refreshOffline = async () => {
-  return await invoke('plugin:utils|refresh_offline', {})
-}
-
-// returns true/false
-export const isOffline = async () => {
-  return await invoke('plugin:utils|is_offline', {})
-}
diff --git a/apps/app-frontend/src/pages/Browse.vue b/apps/app-frontend/src/pages/Browse.vue
index 723efbb8a..bd2163052 100644
--- a/apps/app-frontend/src/pages/Browse.vue
+++ b/apps/app-frontend/src/pages/Browse.vue
@@ -21,22 +21,17 @@ import { useRoute, useRouter } from 'vue-router'
 import SearchCard from '@/components/ui/SearchCard.vue'
 import SplashScreen from '@/components/ui/SplashScreen.vue'
 import { useFetch } from '@/helpers/fetch.js'
-import {
-  check_installed,
-  get,
-  get as getInstance,
-  get_projects as getInstanceProjects,
-} from '@/helpers/profile.js'
+import { get as getInstance, get_projects as getInstanceProjects } from '@/helpers/profile.js'
 import { convertFileSrc } from '@tauri-apps/api/tauri'
-import { isOffline } from '@/helpers/utils'
-import { offline_listener } from '@/helpers/events'
-
 const router = useRouter()
 const route = useRoute()
 
-const offline = ref(await isOffline())
-const unlistenOffline = await offline_listener((b) => {
-  offline.value = b
+const offline = ref(!navigator.onLine)
+window.addEventListener('offline', () => {
+  offline.value = true
+})
+window.addEventListener('online', () => {
+  offline.value = false
 })
 
 const breadcrumbs = useBreadcrumbs()
@@ -527,8 +522,6 @@ const showLoaders = computed(
       instanceContext.value === null) ||
     ignoreInstanceLoaders.value,
 )
-
-onUnmounted(() => unlistenOffline())
 </script>
 
 <template>
diff --git a/apps/app-frontend/src/pages/Index.vue b/apps/app-frontend/src/pages/Index.vue
index 4b902cd23..89856691e 100644
--- a/apps/app-frontend/src/pages/Index.vue
+++ b/apps/app-frontend/src/pages/Index.vue
@@ -3,12 +3,11 @@ import { ref, onUnmounted, shallowRef, computed } from 'vue'
 import { useRoute } from 'vue-router'
 import RowDisplay from '@/components/RowDisplay.vue'
 import { list } from '@/helpers/profile.js'
-import { offline_listener, profile_listener } from '@/helpers/events'
+import { profile_listener } from '@/helpers/events'
 import { useBreadcrumbs } from '@/store/breadcrumbs'
 import { useFetch } from '@/helpers/fetch.js'
 import { handleError } from '@/store/notifications.js'
 import dayjs from 'dayjs'
-import { isOffline } from '@/helpers/utils'
 
 const featuredModpacks = ref({})
 const featuredMods = ref({})
@@ -21,7 +20,13 @@ breadcrumbs.setRootContext({ name: 'Home', link: route.path })
 
 const recentInstances = shallowRef([])
 
-const offline = ref(await isOffline())
+const offline = ref(!navigator.onLine)
+window.addEventListener('offline', () => {
+  offline.value = true
+})
+window.addEventListener('online', () => {
+  offline.value = false
+})
 
 const getInstances = async () => {
   const profiles = await list(true).catch(handleError)
@@ -74,13 +79,6 @@ const unlistenProfile = await profile_listener(async (e) => {
   }
 })
 
-const unlistenOffline = await offline_listener(async (b) => {
-  offline.value = b
-  if (!b) {
-    await Promise.all([getFeaturedModpacks(), getFeaturedMods()])
-  }
-})
-
 // computed sums of recentInstances, featuredModpacks, featuredMods, treating them as arrays if they are not
 const total = computed(() => {
   return (
@@ -92,7 +90,6 @@ const total = computed(() => {
 
 onUnmounted(() => {
   unlistenProfile()
-  unlistenOffline()
 })
 </script>
 
diff --git a/apps/app-frontend/src/pages/Library.vue b/apps/app-frontend/src/pages/Library.vue
index e10a521b1..1902e651f 100644
--- a/apps/app-frontend/src/pages/Library.vue
+++ b/apps/app-frontend/src/pages/Library.vue
@@ -4,13 +4,12 @@ import GridDisplay from '@/components/GridDisplay.vue'
 import { list } from '@/helpers/profile.js'
 import { useRoute } from 'vue-router'
 import { useBreadcrumbs } from '@/store/breadcrumbs'
-import { offline_listener, profile_listener } from '@/helpers/events.js'
+import { profile_listener } from '@/helpers/events.js'
 import { handleError } from '@/store/notifications.js'
 import { Button } from '@modrinth/ui'
 import { PlusIcon } from '@modrinth/assets'
 import InstanceCreationModal from '@/components/ui/InstanceCreationModal.vue'
 import { NewInstanceImage } from '@/assets/icons'
-import { isOffline } from '@/helpers/utils'
 
 const route = useRoute()
 const breadcrumbs = useBreadcrumbs()
@@ -20,9 +19,12 @@ breadcrumbs.setRootContext({ name: 'Library', link: route.path })
 const profiles = await list(true).catch(handleError)
 const instances = shallowRef(Object.values(profiles))
 
-const offline = ref(await isOffline())
-const unlistenOffline = await offline_listener((b) => {
-  offline.value = b
+const offline = ref(!navigator.onLine)
+window.addEventListener('offline', () => {
+  offline.value = true
+})
+window.addEventListener('online', () => {
+  offline.value = false
 })
 
 const unlistenProfile = await profile_listener(async () => {
@@ -31,7 +33,6 @@ const unlistenProfile = await profile_listener(async () => {
 })
 onUnmounted(() => {
   unlistenProfile()
-  unlistenOffline()
 })
 </script>
 
diff --git a/apps/app-frontend/src/pages/Settings.vue b/apps/app-frontend/src/pages/Settings.vue
index 8692714fb..1eb780afb 100644
--- a/apps/app-frontend/src/pages/Settings.vue
+++ b/apps/app-frontend/src/pages/Settings.vue
@@ -31,12 +31,14 @@ const accessSettings = async () => {
 const fetchSettings = await accessSettings().catch(handleError)
 
 const settings = ref(fetchSettings)
+console.log(fetchSettings)
 // const settingsDir = ref(settings.value.loaded_config_dir)
-const maxMemory = ref(Math.floor((await get_max_memory().catch(handleError)) / 1024))
-
+// const maxMemory = ref(Math.floor((await get_max_memory().catch(handleError)) / 1024))
+const maxMemory = ref(100000)
 watch(
   settings,
   async (oldSettings, newSettings) => {
+    console.log('hellooo')
     if (oldSettings.loaded_config_dir !== newSettings.loaded_config_dir) {
       return
     }
@@ -83,14 +85,17 @@ watch(
   { deep: true },
 )
 
+console.log('hellooo')
 const credentials = ref(await getCreds().catch(handleError))
 const loginScreenModal = ref()
 
+console.log('hellooo')
 async function logOut() {
   await logout().catch(handleError)
   credentials.value = await getCreds().catch(handleError)
 }
 
+console.log('hellooo')
 async function signInAfter() {
   loginScreenModal.value.hide()
   credentials.value = await getCreds().catch(handleError)
diff --git a/apps/app-frontend/src/pages/instance/Index.vue b/apps/app-frontend/src/pages/instance/Index.vue
index 35db197aa..217321f0a 100644
--- a/apps/app-frontend/src/pages/instance/Index.vue
+++ b/apps/app-frontend/src/pages/instance/Index.vue
@@ -131,11 +131,11 @@ import {
   get_uuids_by_profile_path,
   kill_by_uuid,
 } from '@/helpers/process'
-import { offline_listener, process_listener, profile_listener } from '@/helpers/events'
+import { process_listener, profile_listener } from '@/helpers/events'
 import { useRoute, useRouter } from 'vue-router'
 import { ref, onUnmounted } from 'vue'
 import { handleError, useBreadcrumbs, useLoading } from '@/store/state'
-import { isOffline, showProfileInFolder } from '@/helpers/utils.js'
+import { showProfileInFolder } from '@/helpers/utils.js'
 import ContextMenu from '@/components/ui/ContextMenu.vue'
 import { mixpanel_track } from '@/helpers/mixpanel'
 import { convertFileSrc } from '@tauri-apps/api/tauri'
@@ -162,7 +162,13 @@ breadcrumbs.setContext({
   query: route.query,
 })
 
-const offline = ref(await isOffline())
+const offline = ref(!navigator.onLine)
+window.addEventListener('offline', () => {
+  offline.value = true
+})
+window.addEventListener('online', () => {
+  offline.value = false
+})
 
 const loadingBar = useLoading()
 
@@ -197,7 +203,7 @@ const checkProcess = async () => {
 
 // Get information on associated modrinth versions, if any
 const modrinthVersions = ref([])
-if (!(await isOffline()) && instance.value.linked_data && instance.value.linked_data.project_id) {
+if (!offline.value && instance.value.linked_data && instance.value.linked_data.project_id) {
   modrinthVersions.value = await useFetch(
     `https://api.modrinth.com/v2/project/${instance.value.linked_data.project_id}/version`,
     'project',
@@ -295,14 +301,9 @@ const unlistenProcesses = await process_listener((e) => {
   if (e.event === 'finished' && uuid.value === e.uuid) playing.value = false
 })
 
-const unlistenOffline = await offline_listener((b) => {
-  offline.value = b
-})
-
 onUnmounted(() => {
   unlistenProcesses()
   unlistenProfiles()
-  unlistenOffline()
 })
 </script>
 
diff --git a/apps/app-frontend/src/pages/instance/Mods.vue b/apps/app-frontend/src/pages/instance/Mods.vue
index 74632d59c..034b8c755 100644
--- a/apps/app-frontend/src/pages/instance/Mods.vue
+++ b/apps/app-frontend/src/pages/instance/Mods.vue
@@ -409,18 +409,17 @@ import { handleError } from '@/store/notifications.js'
 import { mixpanel_track } from '@/helpers/mixpanel'
 import { open } from '@tauri-apps/api/dialog'
 import { listen } from '@tauri-apps/api/event'
-import { convertFileSrc } from '@tauri-apps/api/tauri'
 import { highlightModInProfile } from '@/helpers/utils.js'
 import { MenuIcon, ToggleIcon, TextInputIcon, AddProjectImage, PackageIcon } from '@/assets/icons'
 import ExportModal from '@/components/ui/ExportModal.vue'
 import ModpackVersionModal from '@/components/ui/ModpackVersionModal.vue'
-import { $fetch } from 'ofetch'
 import {
   get_organization_many,
   get_project_many,
   get_team_many,
   get_version_many,
 } from '@/helpers/cache.js'
+import { profile_listener } from '@/helpers/events.js'
 
 const router = useRouter()
 
@@ -449,193 +448,115 @@ const props = defineProps({
   },
 })
 
-const profileProjects = await get_projects(props.instance.path)
-const fetchProjects = []
-const fetchVersions = []
-const selectionMap = ref(new Map())
-
-for (const [key, value] of Object.entries(profileProjects)) {
-  if (value.metadata.type === 'modrinth') {
-    fetchProjects.push(value.metadata.project_id)
-    fetchVersions.push(value.metadata.version_id)
+const unlistenProfiles = await profile_listener(async (event) => {
+  if (
+    event.profile_path_id === props.instance.path &&
+    event.event === 'synced' &&
+    props.instance.install_stage !== 'pack_installing'
+  ) {
+    await initProjects()
   }
-}
-
-const [modrinthProjects, modrinthVersions] = await Promise.all([
-  await get_project_many(fetchProjects).catch(handleError),
-  await get_version_many(fetchVersions).catch(handleError),
-])
-
-const [modrinthTeams, modrinthOrganizations] = await Promise.all([
-  await get_team_many(modrinthProjects.map((x) => x.team)).catch(handleError),
-  await get_organization_many(modrinthProjects.map((x) => x.organization).filter((x) => !!x)).catch(
-    handleError,
-  ),
-])
-
-const projects = ref([])
-for (const [path, file] of Object.entries(profileProjects)) {
-  if (file.metadata.type === 'modrinth') {
-    const project = modrinthProjects.find((x) => file.metadata.project_id === x.id)
-    const version = modrinthVersions.find((x) => file.metadata.version_id === x.id)
-    const org = project.organization
-      ? modrinthOrganizations.find((x) => x.id === project.organization)
-      : null
-
-    const team = modrinthTeams.find((x) => x[0].team_id === project.team)
-
-    let owner = org ? org.name : team.find((x) => x.is_owner).user.username
-
-    console.log(path)
-    console.log(file)
-    console.log(project)
-    console.log(version)
-    console.log(org)
-    console.log(team)
-
-    projects.value.push({
-      path,
-      name: project.title,
-      slug: project.slug,
-      author: owner,
-      version: version.version_number,
-      file_name: file.file_name,
-      icon: project.icon_url,
-      disabled: file.file_name.endsWith('.disabled'),
-      updateVersion: file.update_version_id,
-      outdated: !!file.update_version_id,
-      project_type: project.project_type,
-      id: project.id,
-    })
-
-    continue
-  }
-
-  if (file.metadata.type === 'inferred') {
-    projects.value.push({
-      path,
-      name: file.metadata.title ?? file.file_name,
-      author: file.metadata.authors[0],
-      version: file.metadata.version,
-      file_name: file.file_name,
-      icon: file.metadata.icon ? convertFileSrc(file.metadata.icon) : null,
-      disabled: file.disabled,
-      outdated: false,
-      project_type: file.metadata.project_type,
-    })
-  } else {
-    projects.value.push({
-      path,
-      name: file.file_name.replace('.disabled', ''),
-      author: '',
-      version: null,
-      file_name: file.file_name,
-      icon: null,
-      disabled: file.file_name.endsWith('.disabled'),
-      outdated: false,
-      project_type: null,
-    })
-  }
-}
-
-console.log(projects.value)
+})
 
-const newSelectionMap = new Map()
-for (const project of projects.value) {
-  newSelectionMap.set(
-    project.path,
-    selectionMap.value.get(project.path) ??
-      selectionMap.value.get(project.path.slice(0, -9)) ??
-      selectionMap.value.get(project.path + '.disabled') ??
-      false,
-  )
-}
-selectionMap.value = newSelectionMap
+onUnmounted(() => {
+  unlistenProfiles()
+})
 
 const showingOptions = ref(false)
 const isPackLocked = computed(() => {
   return props.instance.linked_data && props.instance.linked_data.locked
 })
 const canUpdatePack = computed(() => {
-  if (!props.instance.linked_data) return false
-  return props.instance.linked_data.version_id !== props.instance.modrinth_update_version
+  if (!props.instance.linked_data || !props.versions) return false
+  return props.instance.linked_data.version_id !== props.versions[0].id
 })
 const exportModal = ref(null)
 
-const initProjects = (initInstance) => {
-  // projects.value = []
-  // if (!initInstance || !initInstance.projects) return
-  // for (const [path, project] of Object.entries(initInstance.projects)) {
-  //   if (project.metadata.type === 'modrinth' && !props.offline) {
-  //     let owner = project.metadata.members.find((x) => x.role === 'Owner')
-  //     projects.value.push({
-  //       path,
-  //       name: project.metadata.project.title,
-  //       slug: project.metadata.project.slug,
-  //       author: owner ? owner.user.username : null,
-  //       version: project.metadata.version.version_number,
-  //       file_name: project.file_name,
-  //       icon: project.metadata.project.icon_url,
-  //       updateVersion: project.metadata.update_version,
-  //       outdated: !!project.metadata.update_version,
-  //       project_type: project.metadata.project.project_type,
-  //       id: project.metadata.project.id,
-  //     })
-  //   } else if (project.metadata.type === 'inferred') {
-  //     projects.value.push({
-  //       path,
-  //       name: project.metadata.title ?? project.file_name,
-  //       author: project.metadata.authors[0],
-  //       version: project.metadata.version,
-  //       file_name: project.file_name,
-  //       icon: project.metadata.icon ? convertFileSrc(project.metadata.icon) : null,
-  //       disabled: project.disabled,
-  //       outdated: false,
-  //       project_type: project.metadata.project_type,
-  //     })
-  //   } else {
-  //     projects.value.push({
-  //       path,
-  //       name: project.file_name,
-  //       author: '',
-  //       version: null,
-  //       file_name: project.file_name,
-  //       icon: null,
-  //       disabled: project.disabled,
-  //       outdated: false,
-  //       project_type: null,
-  //     })
-  //   }
-  // }
-  //
-  // const newSelectionMap = new Map()
-  // for (const project of projects.value) {
-  //   newSelectionMap.set(
-  //     project.path,
-  //     selectionMap.value.get(project.path) ??
-  //       selectionMap.value.get(project.path.slice(0, -9)) ??
-  //       selectionMap.value.get(project.path + '.disabled') ??
-  //       false,
-  //   )
-  // }
-  // selectionMap.value = newSelectionMap
-}
+const projects = ref([])
+const selectionMap = ref(new Map())
 
-initProjects(props.instance)
+const initProjects = async () => {
+  const newProjects = []
 
-watch(
-  () => props.instance.projects,
-  () => {
-    initProjects(props.instance)
-  },
-)
+  const profileProjects = await get_projects(props.instance.path)
+  const fetchProjects = []
+  const fetchVersions = []
 
-watch(
-  () => props.offline,
-  () => {
-    if (props.instance) initProjects(props.instance)
-  },
-)
+  for (const value of Object.values(profileProjects)) {
+    if (value.metadata.type === 'modrinth') {
+      fetchProjects.push(value.metadata.project_id)
+      fetchVersions.push(value.metadata.version_id)
+    }
+  }
+
+  const [modrinthProjects, modrinthVersions] = await Promise.all([
+    await get_project_many(fetchProjects).catch(handleError),
+    await get_version_many(fetchVersions).catch(handleError),
+  ])
+
+  const [modrinthTeams, modrinthOrganizations] = await Promise.all([
+    await get_team_many(modrinthProjects.map((x) => x.team)).catch(handleError),
+    await get_organization_many(
+      modrinthProjects.map((x) => x.organization).filter((x) => !!x),
+    ).catch(handleError),
+  ])
+
+  for (const [path, file] of Object.entries(profileProjects)) {
+    if (file.metadata.type === 'modrinth') {
+      const project = modrinthProjects.find((x) => file.metadata.project_id === x.id)
+      const version = modrinthVersions.find((x) => file.metadata.version_id === x.id)
+      const org = project.organization
+        ? modrinthOrganizations.find((x) => x.id === project.organization)
+        : null
+
+      const team = modrinthTeams.find((x) => x[0].team_id === project.team)
+
+      let owner = org ? org.name : team.find((x) => x.is_owner).user.username
+
+      newProjects.push({
+        path,
+        name: project.title,
+        slug: project.slug,
+        author: owner,
+        version: version.version_number,
+        file_name: file.file_name,
+        icon: project.icon_url,
+        disabled: file.file_name.endsWith('.disabled'),
+        updateVersion: file.update_version_id,
+        outdated: !!file.update_version_id,
+        project_type: project.project_type,
+        id: project.id,
+      })
+    } else {
+      newProjects.push({
+        path,
+        name: file.file_name.replace('.disabled', ''),
+        author: '',
+        version: null,
+        file_name: file.file_name,
+        icon: null,
+        disabled: file.file_name.endsWith('.disabled'),
+        outdated: false,
+        project_type: file.project_type,
+      })
+    }
+  }
+
+  projects.value = newProjects
+
+  const newSelectionMap = new Map()
+  for (const project of projects.value) {
+    newSelectionMap.set(
+      project.path,
+      selectionMap.value.get(project.path) ??
+        selectionMap.value.get(project.path.slice(0, -9)) ??
+        selectionMap.value.get(project.path + '.disabled') ??
+        false,
+    )
+  }
+  selectionMap.value = newSelectionMap
+}
+await initProjects()
 
 const modpackVersionModal = ref(null)
 const installing = computed(() => props.instance.install_stage !== 'installed')
diff --git a/apps/app-frontend/src/pages/project/Index.vue b/apps/app-frontend/src/pages/project/Index.vue
index 8472140f3..a5ba1f40f 100644
--- a/apps/app-frontend/src/pages/project/Index.vue
+++ b/apps/app-frontend/src/pages/project/Index.vue
@@ -200,7 +200,6 @@
         :project="data"
         :versions="versions"
         :members="members"
-        :dependencies="dependencies"
         :instance="instance"
         :install="install"
         :installed="installed"
@@ -256,7 +255,6 @@ import dayjs from 'dayjs'
 import relativeTime from 'dayjs/plugin/relativeTime'
 import { useRoute } from 'vue-router'
 import { ref, shallowRef, watch } from 'vue'
-import { isOffline } from '@/helpers/utils'
 import { useBreadcrumbs } from '@/store/breadcrumbs'
 import { handleError } from '@/store/notifications.js'
 import { convertFileSrc } from '@tauri-apps/api/tauri'
@@ -274,7 +272,6 @@ const installing = ref(false)
 const data = shallowRef(null)
 const versions = shallowRef([])
 const members = shallowRef([])
-const dependencies = shallowRef([])
 const categories = shallowRef([])
 const instance = ref(null)
 const instanceProjects = ref(null)
@@ -282,8 +279,6 @@ const instanceProjects = ref(null)
 const installed = ref(false)
 const installedVersion = ref(null)
 
-const offline = ref(await isOffline())
-
 async function fetchProjectData() {
   const project = await get_project(route.params.id).catch(handleError)
 
@@ -299,34 +294,6 @@ async function fetchProjectData() {
 
   versions.value = versions.value.sort((a, b) => dayjs(b.date_published) - dayjs(a.date_published))
 
-  const projectIds = new Set()
-  const versionIds = new Set()
-
-  for (const version of versions.value) {
-    if (version.dependencies) {
-      for (const dependency of version.dependencies) {
-        if (dependency.project_id) {
-          projectIds.add(dependency.project_id)
-        }
-        if (dependency.version_id) {
-          versionIds.add(dependency.version_id)
-        }
-      }
-    }
-  }
-
-  if (projectIds.size > 0 || versionIds.size > 0) {
-    const [projectDeps, versionDeps] = await Promise.all([
-      get_project_many([...projectIds]),
-      get_version_many([...versionIds]),
-    ])
-
-    dependencies.value = {
-      projects: projectDeps,
-      versions: versionDeps,
-    }
-  }
-
   if (instanceProjects.value) {
     const installedFile = Object.values(instanceProjects.value).find(
       (x) => x.metadata.type === 'modrinth' && x.metadata.project_id === data.value.id,
@@ -339,7 +306,7 @@ async function fetchProjectData() {
   breadcrumbs.setName('Project', data.value.title)
 }
 
-if (!offline.value) await fetchProjectData()
+await fetchProjectData()
 
 watch(
   () => route.params.id,
diff --git a/apps/app-frontend/src/pages/project/Version.vue b/apps/app-frontend/src/pages/project/Version.vue
index 79c620c0e..4ceea823d 100644
--- a/apps/app-frontend/src/pages/project/Version.vue
+++ b/apps/app-frontend/src/pages/project/Version.vue
@@ -190,6 +190,7 @@ import { ref, watch, computed } from 'vue'
 import { useRoute } from 'vue-router'
 import { useBreadcrumbs } from '@/store/breadcrumbs'
 import { SwapIcon } from '@/assets/icons'
+import { get_project_many, get_version_many } from '@/helpers/cache.js'
 
 const breadcrumbs = useBreadcrumbs()
 
@@ -204,10 +205,6 @@ const props = defineProps({
     type: Array,
     required: true,
   },
-  dependencies: {
-    type: Object,
-    required: true,
-  },
   members: {
     type: Array,
     required: true,
@@ -238,6 +235,7 @@ watch(
   async () => {
     if (route.params.version) {
       version.value = props.versions.find((version) => version.id === route.params.version)
+      await refreshDisplayDependencies()
       breadcrumbs.setName('Version', version.value.name)
     }
   },
@@ -247,11 +245,35 @@ const author = computed(() =>
   props.members.find((member) => member.user.id === version.value.author_id),
 )
 
-const displayDependencies = computed(() =>
-  version.value.dependencies.map((dependency) => {
-    const version = props.dependencies.versions.find((obj) => obj.id === dependency.version_id)
+const displayDependencies = ref({})
+
+async function refreshDisplayDependencies() {
+  const projectIds = new Set()
+  const versionIds = new Set()
+  if (version.value.dependencies) {
+    for (const dependency of version.value.dependencies) {
+      if (dependency.project_id) {
+        projectIds.add(dependency.project_id)
+      }
+      if (dependency.version_id) {
+        versionIds.add(dependency.version_id)
+      }
+    }
+  }
+  const [projectDeps, versionDeps] = await Promise.all([
+    get_project_many([...projectIds]),
+    get_version_many([...versionIds]),
+  ])
+
+  const dependencies = {
+    projects: projectDeps,
+    versions: versionDeps,
+  }
+
+  displayDependencies.value = version.value.dependencies.map((dependency) => {
+    const version = dependencies.versions.find((obj) => obj.id === dependency.version_id)
     if (version) {
-      const project = props.dependencies.projects.find(
+      const project = dependencies.projects.find(
         (obj) => obj.id === version.project_id || obj.id === dependency.project_id,
       )
       return {
@@ -261,7 +283,7 @@ const displayDependencies = computed(() =>
         link: `/project/${project.slug}/version/${version.id}`,
       }
     } else {
-      const project = props.dependencies.projects.find((obj) => obj.id === dependency.project_id)
+      const project = dependencies.projects.find((obj) => obj.id === dependency.project_id)
 
       if (project) {
         return {
@@ -279,8 +301,9 @@ const displayDependencies = computed(() =>
         }
       }
     }
-  }),
-)
+  })
+}
+await refreshDisplayDependencies()
 </script>
 
 <style scoped lang="scss">
diff --git a/apps/app-frontend/src/store/install.js b/apps/app-frontend/src/store/install.js
index 668e63752..559fe0bb4 100644
--- a/apps/app-frontend/src/store/install.js
+++ b/apps/app-frontend/src/store/install.js
@@ -8,10 +8,10 @@ import {
   remove_project,
 } from '@/helpers/profile.js'
 import { handleError } from '@/store/notifications.js'
-import { useFetch } from '@/helpers/fetch.js'
 import { get_project, get_version_many } from '@/helpers/cache.js'
 import { install as packInstall } from '@/helpers/pack.js'
 import { mixpanel_track } from '@/helpers/mixpanel.js'
+import dayjs from 'dayjs'
 
 export const useInstall = defineStore('installStore', {
   state: () => ({
@@ -45,7 +45,7 @@ export const install = async (projectId, versionId, instancePath, source, callba
   const project = await get_project(projectId).catch(handleError)
 
   if (project.project_type === 'modpack') {
-    const version = versionId ?? project.versions[0]
+    const version = versionId ?? project.versions[project.versions.length - 1]
     const packs = Object.values(await list(true).catch(handleError))
 
     if (packs.length === 0 || !packs.find((pack) => pack.linked_data?.project_id === project.id)) {
@@ -65,17 +65,21 @@ export const install = async (projectId, versionId, instancePath, source, callba
     }
   } else {
     if (instancePath) {
-      const [instance, instanceProjects, projectVersions] = await Promise.all([
+      const [instance, instanceProjects, versions] = await Promise.all([
         await get(instancePath).catch(handleError),
         await get_projects(instancePath).catch(handleError),
         await get_version_many(project.versions),
       ])
 
+      const projectVersions = versions.sort(
+        (a, b) => dayjs(b.date_published) - dayjs(a.date_published),
+      )
+
       let version
       if (versionId) {
         version = projectVersions.find((x) => x.id === versionId)
       } else {
-        projectVersions.find(
+        version = projectVersions.find(
           (v) =>
             v.game_versions.includes(instance.game_version) &&
             (project.project_type === 'mod'
@@ -119,7 +123,9 @@ export const install = async (projectId, versionId, instancePath, source, callba
         install.showIncompatibilityWarningModal(instance, project, projectVersions, callback)
       }
     } else {
-      const versions = await get_version_many(project.versions).catch(handleError)
+      const versions = (await get_version_many(project.versions).catch(handleError)).sort(
+        (a, b) => dayjs(b.date_published) - dayjs(a.date_published),
+      )
 
       const install = useInstall()
       install.showModInstallModal(project, versions, callback)
@@ -158,10 +164,13 @@ export const installVersionDependencies = async (profile, version) => {
         (await check_installed(profile.path, dep.project_id).catch(handleError))
       )
         continue
-      const depVersions = await useFetch(
-        `https://api.modrinth.com/v2/project/${dep.project_id}/version`,
-        'dependency versions',
+
+      const depProject = await get_project(dep.project_id).catch(handleError)
+
+      const depVersions = (await get_version_many(depProject.versions).catch(handleError)).sort(
+        (a, b) => dayjs(b.date_published) - dayjs(a.date_published),
       )
+
       const latest = depVersions.find(
         (v) => v.game_versions.includes(profile.game_version) && v.loaders.includes(profile.loader),
       )
diff --git a/apps/app/src/api/jre.rs b/apps/app/src/api/jre.rs
index 89f057513..036d5889b 100644
--- a/apps/app/src/api/jre.rs
+++ b/apps/app/src/api/jre.rs
@@ -1,6 +1,6 @@
-use std::path::PathBuf;
-
 use crate::api::Result;
+use dashmap::DashMap;
+use std::path::PathBuf;
 use tauri::plugin::TauriPlugin;
 use theseus::prelude::JavaVersion;
 use theseus::prelude::*;
@@ -8,6 +8,8 @@ use theseus::prelude::*;
 pub fn init<R: tauri::Runtime>() -> TauriPlugin<R> {
     tauri::plugin::Builder::new("jre")
         .invoke_handler(tauri::generate_handler![
+            get_java_versions,
+            set_java_version,
             jre_find_filtered_jres,
             jre_get_jre,
             jre_test_jre,
@@ -17,6 +19,17 @@ pub fn init<R: tauri::Runtime>() -> TauriPlugin<R> {
         .build()
 }
 
+#[tauri::command]
+pub async fn get_java_versions() -> Result<DashMap<u32, JavaVersion>> {
+    Ok(jre::get_java_versions().await?)
+}
+
+#[tauri::command]
+pub async fn set_java_version(java_version: JavaVersion) -> Result<()> {
+    jre::set_java_version(java_version).await?;
+    Ok(())
+}
+
 // Finds the installation of Java 8, if it exists
 #[tauri::command]
 pub async fn jre_find_filtered_jres(
diff --git a/apps/app/src/api/utils.rs b/apps/app/src/api/utils.rs
index c84312772..f26a50824 100644
--- a/apps/app/src/api/utils.rs
+++ b/apps/app/src/api/utils.rs
@@ -2,7 +2,6 @@ use serde::{Deserialize, Serialize};
 use theseus::{
     handler,
     prelude::{CommandPayload, DirectoryInfo},
-    State,
 };
 
 use crate::api::Result;
@@ -16,9 +15,7 @@ pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
             show_in_folder,
             show_launcher_logs_folder,
             progress_bars_list,
-            get_opening_command,
-            is_offline,
-            refresh_offline
+            get_opening_command
         ])
         .build()
 }
@@ -156,20 +153,3 @@ pub async fn get_opening_command() -> Result<Option<CommandPayload>> {
 pub async fn handle_command(command: String) -> Result<()> {
     Ok(theseus::handler::parse_and_emit_command(&command).await?)
 }
-
-/// Check if theseus is currently in offline mode, without a refresh attempt
-#[tauri::command]
-pub async fn is_offline() -> Result<bool> {
-    let state = State::get().await?;
-    let offline = *state.offline.read().await;
-    Ok(offline)
-}
-
-/// Refreshes whether or not theseus is in offline mode, and returns the new value
-#[tauri::command]
-pub async fn refresh_offline() -> Result<bool> {
-    let state = State::get().await?;
-    state.refresh_offline().await?;
-    let offline = *state.offline.read().await;
-    Ok(offline)
-}
diff --git a/packages/app-lib/Cargo.toml b/packages/app-lib/Cargo.toml
index 315eb64d8..6fa7039fd 100644
--- a/packages/app-lib/Cargo.toml
+++ b/packages/app-lib/Cargo.toml
@@ -59,7 +59,7 @@ dunce = "1.0.3"
 
 whoami = "1.4.0"
 
-discord-rich-presence = "0.2.3"
+discord-rich-presence = "0.2.4"
 
 p256 = { version = "0.13.2", features = ["ecdsa"] }
 rand = "0.8"
diff --git a/packages/app-lib/migrations/20240711194701_init.sql b/packages/app-lib/migrations/20240711194701_init.sql
index ec45e27b2..da8887699 100644
--- a/packages/app-lib/migrations/20240711194701_init.sql
+++ b/packages/app-lib/migrations/20240711194701_init.sql
@@ -87,7 +87,7 @@ CREATE TABLE cache (
     data_type TEXT NOT NULL,
     alias TEXT NULL,
 
-    data JSONB NOT NULL,
+    data JSONB NULL,
     expires INTEGER NOT NULL,
 
     UNIQUE (data_type, alias),
diff --git a/packages/app-lib/src/api/jre.rs b/packages/app-lib/src/api/jre.rs
index 046d36dd1..5741e2df5 100644
--- a/packages/app-lib/src/api/jre.rs
+++ b/packages/app-lib/src/api/jre.rs
@@ -1,11 +1,11 @@
 //! Authentication flow interface
-use reqwest::Method;
-use serde::Deserialize;
-use std::path::PathBuf;
-
 use crate::event::emit::{emit_loading, init_loading};
 use crate::state::JavaVersion;
 use crate::util::fetch::{fetch_advanced, fetch_json};
+use dashmap::DashMap;
+use reqwest::Method;
+use serde::Deserialize;
+use std::path::PathBuf;
 
 use crate::util::io;
 use crate::util::jre::extract_java_majorminor_version;
@@ -14,6 +14,18 @@ use crate::{
     LoadingBarType, State,
 };
 
+pub async fn get_java_versions() -> crate::Result<DashMap<u32, JavaVersion>> {
+    let state = State::get().await?;
+
+    Ok(JavaVersion::get_all(&state.pool).await?)
+}
+
+pub async fn set_java_version(java_version: JavaVersion) -> crate::Result<()> {
+    let state = State::get().await?;
+    java_version.upsert(&state.pool).await?;
+    Ok(())
+}
+
 // Searches for jres on the system given a java version (ex: 1.8, 1.17, 1.18)
 // Allow higher allows for versions higher than the given version to be returned ('at least')
 pub async fn find_filtered_jres(
diff --git a/packages/app-lib/src/api/pack/install_from.rs b/packages/app-lib/src/api/pack/install_from.rs
index 9096bd157..d85c1bab0 100644
--- a/packages/app-lib/src/api/pack/install_from.rs
+++ b/packages/app-lib/src/api/pack/install_from.rs
@@ -1,13 +1,12 @@
-use crate::config::MODRINTH_API_URL;
 use crate::data::ModLoader;
 use crate::event::emit::{emit_loading, init_loading};
 use crate::event::{LoadingBarId, LoadingBarType};
 use crate::state::{
-    LinkedData, ProfileInstallStage, Project as ModrinthProject, SideType,
-    Version as ModrinthVersion,
+    CachedEntry, LinkedData, ProfileInstallStage,
+    SideType
 };
 use crate::util::fetch::{
-    fetch, fetch_advanced, fetch_json, write_cached_icon,
+    fetch, fetch_advanced, write_cached_icon,
 };
 use crate::util::io;
 use crate::State;
@@ -215,14 +214,18 @@ pub async fn generate_pack_from_version_id(
 
     emit_loading(&loading_bar, 0.0, Some("Fetching version")).await?;
     let creds = state.credentials.read().await;
-    let version: ModrinthVersion = fetch_json(
-        Method::GET,
-        &format!("{}version/{}", MODRINTH_API_URL, version_id),
-        None,
+    let version = CachedEntry::get_version(
+        &version_id,
         None,
+        &state.pool,
         &state.fetch_semaphore,
     )
-    .await?;
+    .await?
+    .ok_or_else(|| {
+        crate::ErrorKind::InputError(
+            "Invalid version ID specified!".to_string(),
+        )
+    })?;
     emit_loading(&loading_bar, 10.0, None).await?;
 
     let (url, hash) =
@@ -252,14 +255,18 @@ pub async fn generate_pack_from_version_id(
     .await?;
     emit_loading(&loading_bar, 0.0, Some("Fetching project metadata")).await?;
 
-    let project: ModrinthProject = fetch_json(
-        Method::GET,
-        &format!("{}project/{}", MODRINTH_API_URL, version.project_id),
-        None,
+    let project = CachedEntry::get_project(
+        &version.project_id,
         None,
+        &state.pool,
         &state.fetch_semaphore,
     )
-    .await?;
+    .await?
+    .ok_or_else(|| {
+        crate::ErrorKind::InputError(
+            "Invalid project ID specified!".to_string(),
+        )
+    })?;
 
     emit_loading(&loading_bar, 10.0, Some("Retrieving icon")).await?;
     let icon = if let Some(icon_url) = project.icon_url {
diff --git a/packages/app-lib/src/api/pack/install_mrpack.rs b/packages/app-lib/src/api/pack/install_mrpack.rs
index ff3759532..60932810e 100644
--- a/packages/app-lib/src/api/pack/install_mrpack.rs
+++ b/packages/app-lib/src/api/pack/install_mrpack.rs
@@ -1,4 +1,3 @@
-use crate::config::MODRINTH_API_URL;
 use crate::event::emit::{
     emit_loading, init_or_edit_loading, loading_try_for_each_concurrent,
 };
@@ -6,15 +5,14 @@ use crate::event::LoadingBarType;
 use crate::pack::install_from::{
     set_profile_information, EnvType, PackFile, PackFileHash,
 };
-use crate::state::{ProfileInstallStage, SideType, Version as ModrinthVersion};
-use crate::util::fetch::{fetch_json, fetch_mirrors, write};
+use crate::state::{
+    CacheBehaviour, CachedEntry, FileMetadata, ProfileInstallStage, SideType,
+};
+use crate::util::fetch::{fetch_mirrors, write};
 use crate::util::io;
 use crate::{profile, State};
 use async_zip::base::read::seek::ZipFileReader;
-use reqwest::Method;
-use serde_json::json;
 
-use std::collections::HashMap;
 use std::io::Cursor;
 use std::path::{Component, PathBuf};
 
@@ -336,37 +334,57 @@ pub async fn remove_all_related_files(
         let all_hashes = pack
             .files
             .iter()
-            .filter_map(|f| Some(f.hashes.get(&PackFileHash::Sha512)?.clone()))
+            .filter_map(|f| Some(f.hashes.get(&PackFileHash::Sha1)?.clone()))
             .collect::<Vec<_>>();
-        let creds = state.credentials.read().await;
 
         // First, get project info by hash
-        let files_url = format!("{}version_files", MODRINTH_API_URL);
-
-        let hash_projects = fetch_json::<HashMap<String, ModrinthVersion>>(
-            Method::POST,
-            &files_url,
+        let file_infos = CachedEntry::get_file_many(
+            &all_hashes.iter().map(|x| &**x).collect::<Vec<_>>(),
             None,
-            Some(json!({
-                "hashes": all_hashes,
-                "algorithm": "sha512",
-            })),
+            &state.pool,
             &state.fetch_semaphore,
         )
         .await?;
-        let to_remove = hash_projects
-            .into_values()
-            .map(|p| p.project_id)
+
+        let to_remove = file_infos
+            .into_iter()
+            .filter_map(|p| {
+                if let FileMetadata::Modrinth { project_id, .. } = p.metadata {
+                    Some(project_id)
+                } else {
+                    None
+                }
+            })
             .collect::<Vec<_>>();
+
         let profile = profile::get(&profile_path).await?.ok_or_else(|| {
             crate::ErrorKind::UnmanagedProfileError(profile_path.to_string())
         })?;
+        let profile_full_path = profile::get_full_path(&profile_path).await?;
+
+        for (file_path, project) in profile
+            .get_projects(
+                Some(CacheBehaviour::MustRevalidate),
+                &state.pool,
+                &state.fetch_semaphore,
+            )
+            .await?
+        {
+            if let FileMetadata::Modrinth { project_id, .. } = &project.metadata
+            {
+                if to_remove.contains(&project_id) {
+                    let path = profile_full_path.join(file_path);
+                    if path.exists() {
+                        io::remove_file(&path).await?;
+                    }
+                }
+            }
+        }
 
         // Iterate over all Modrinth project file paths in the json, and remove them
         // (There should be few, but this removes any files the .mrpack intended as Modrinth projects but were unrecognized)
         for file in pack.files {
-            let path: PathBuf =
-                profile::get_full_path(&profile_path).await?.join(file.path);
+            let path: PathBuf = profile_full_path.join(file.path);
             if path.exists() {
                 io::remove_file(&path).await?;
             }
diff --git a/packages/app-lib/src/api/profile/mod.rs b/packages/app-lib/src/api/profile/mod.rs
index 7c1d017f3..00416adaf 100644
--- a/packages/app-lib/src/api/profile/mod.rs
+++ b/packages/app-lib/src/api/profile/mod.rs
@@ -8,8 +8,8 @@ use crate::pack::install_from::{
     EnvType, PackDependency, PackFile, PackFileHash, PackFormat,
 };
 use crate::state::{
-    CachedEntry, Credentials, FileMetadata, JavaVersion, ProfileFile,
-    ProjectType, SideType,
+    CacheBehaviour, CachedEntry, Credentials, FileMetadata, JavaVersion,
+    ProfileFile, ProjectType, SideType,
 };
 
 use crate::util::fetch;
@@ -72,7 +72,7 @@ pub async fn get_projects(
 
     if let Some(profile) = get(path).await? {
         let files = profile
-            .get_projects(&state.pool, &state.fetch_semaphore)
+            .get_projects(None, &state.pool, &state.fetch_semaphore)
             .await?;
 
         Ok(files)
@@ -251,7 +251,11 @@ pub async fn update_all_projects(
 
         let state = State::get().await?;
         let keys = profile
-            .get_projects(&state.pool, &state.fetch_semaphore)
+            .get_projects(
+                Some(CacheBehaviour::MustRevalidate),
+                &state.pool,
+                &state.fetch_semaphore,
+            )
             .await?
             .into_iter()
             .filter(|(_, project)| project.update_version_id.is_some())
@@ -309,7 +313,11 @@ pub async fn update_project(
     if let Some(profile) = get(profile_path).await? {
         let state = State::get().await?;
         if let Some((_, file)) = profile
-            .get_projects(&state.pool, &state.fetch_semaphore)
+            .get_projects(
+                Some(CacheBehaviour::MustRevalidate),
+                &state.pool,
+                &state.fetch_semaphore,
+            )
             .await?
             .remove(project_path)
         {
@@ -551,14 +559,6 @@ pub async fn export_mrpack(
 pub async fn get_pack_export_candidates(
     profile_path: &str,
 ) -> crate::Result<Vec<String>> {
-    // First, get a dummy mrpack json for the files within
-    let profile: Profile = get(profile_path).await?.ok_or_else(|| {
-        crate::ErrorKind::OtherError(format!(
-            "Tried to export a nonexistent or unloaded profile at path {}!",
-            profile_path
-        ))
-    })?;
-
     let mut path_list: Vec<String> = Vec::new();
 
     let profile_base_dir = get_full_path(profile_path).await?;
@@ -746,7 +746,7 @@ pub async fn try_update_playtime(path: &str) -> crate::Result<()> {
         let mut hashmap: HashMap<String, serde_json::Value> = HashMap::new();
 
         for (_, project) in profile
-            .get_projects(&state.pool, &state.fetch_semaphore)
+            .get_projects(None, &state.pool, &state.fetch_semaphore)
             .await?
         {
             if let FileMetadata::Modrinth { version_id, .. } = project.metadata
@@ -817,7 +817,11 @@ pub async fn create_mrpack_json(
 
     let state = State::get().await?;
     let projects = profile
-        .get_projects(&state.pool, &state.fetch_semaphore)
+        .get_projects(
+            Some(CacheBehaviour::MustRevalidate),
+            &state.pool,
+            &state.fetch_semaphore,
+        )
         .await?
         .into_iter()
         .filter_map(|(path, file)| match file.metadata {
diff --git a/packages/app-lib/src/api/profile/update.rs b/packages/app-lib/src/api/profile/update.rs
index d232ebf4f..b84726343 100644
--- a/packages/app-lib/src/api/profile/update.rs
+++ b/packages/app-lib/src/api/profile/update.rs
@@ -1,3 +1,4 @@
+use crate::state::CacheBehaviour;
 use crate::{
     event::{
         emit::{emit_profile, init_loading},
@@ -67,7 +68,11 @@ pub async fn repair_managed_modrinth(profile_path: &str) -> crate::Result<()> {
     // remove relevant projects and not things like save files
     let state = crate::State::get().await?;
     let projects_map = profile
-        .get_projects(&state.pool, &state.fetch_semaphore)
+        .get_projects(
+            Some(CacheBehaviour::MustRevalidate),
+            &state.pool,
+            &state.fetch_semaphore,
+        )
         .await?;
 
     for (file, _) in projects_map {
diff --git a/packages/app-lib/src/api/settings.rs b/packages/app-lib/src/api/settings.rs
index 5bba3473f..736c57f2a 100644
--- a/packages/app-lib/src/api/settings.rs
+++ b/packages/app-lib/src/api/settings.rs
@@ -17,12 +17,6 @@ pub async fn get() -> crate::Result<Settings> {
 #[tracing::instrument]
 pub async fn set(settings: Settings) -> crate::Result<()> {
     let state = State::get().await?;
-    let old_settings = Settings::get(&state.pool).await?;
-
-    if settings.discord_rpc != old_settings.discord_rpc {
-        state.discord_rpc.clear_to_default(true).await?;
-    }
-
     settings.update(&state.pool).await?;
 
     Ok(())
diff --git a/packages/app-lib/src/event/emit.rs b/packages/app-lib/src/event/emit.rs
index 70efcd0d0..304328962 100644
--- a/packages/app-lib/src/event/emit.rs
+++ b/packages/app-lib/src/event/emit.rs
@@ -228,22 +228,6 @@ pub async fn emit_warning(message: &str) -> crate::Result<()> {
     Ok(())
 }
 
-// emit_offline(bool)
-// This is used to emit an event to the frontend that the app is offline after a refresh (or online)
-#[allow(dead_code)]
-#[allow(unused_variables)]
-pub async fn emit_offline(offline: bool) -> crate::Result<()> {
-    #[cfg(feature = "tauri")]
-    {
-        let event_state = crate::EventState::get().await?;
-        event_state
-            .app
-            .emit_all("offline", offline)
-            .map_err(EventError::from)?;
-    }
-    Ok(())
-}
-
 // emit_command(CommandPayload::Something { something })
 // ie: installing a pack, opening an .mrpack, etc
 // Generally used for url deep links and file opens that we we want to handle in the frontend
diff --git a/packages/app-lib/src/launcher/mod.rs b/packages/app-lib/src/launcher/mod.rs
index 508c86a48..d97d4df3d 100644
--- a/packages/app-lib/src/launcher/mod.rs
+++ b/packages/app-lib/src/launcher/mod.rs
@@ -644,13 +644,10 @@ pub async fn launch_minecraft(
         }
     }
 
-    if !*state.offline.read().await {
-        // Add game played to discord rich presence
-        let _ = state
-            .discord_rpc
-            .set_activity(&format!("Playing {}", profile.name), true)
-            .await;
-    }
+    let _ = state
+        .discord_rpc
+        .set_activity(&format!("Playing {}", profile.name), true)
+        .await;
 
     // Create Minecraft child by inserting it into the state
     // This also spawns the process and prepares the subsequent processes
diff --git a/packages/app-lib/src/state/cache.rs b/packages/app-lib/src/state/cache.rs
index ad9b98b74..dd87c2fb3 100644
--- a/packages/app-lib/src/state/cache.rs
+++ b/packages/app-lib/src/state/cache.rs
@@ -78,7 +78,7 @@ impl CacheValueType {
         match self {
             CacheValueType::File => 60 * 60 * 24 * 30, // 30 days
             CacheValueType::FileHash => 60 * 60 * 24 * 30, // 30 days
-            _ => 60 * 60 * 30, // 30 minutes
+            _ => 60 * 60 * 30,                         // 30 minutes
         }
     }
 }
@@ -146,14 +146,6 @@ pub enum FileMetadata {
         project_id: String,
         version_id: String,
     },
-    Inferred {
-        title: Option<String>,
-        description: Option<String>,
-        authors: Vec<String>,
-        version: Option<String>,
-        icon: Option<PathBuf>,
-        project_type: Option<String>,
-    },
     Unknown,
 }
 
@@ -352,6 +344,16 @@ pub struct GameVersion {
 }
 
 impl CacheValue {
+    fn get_entry(self) -> CachedEntry {
+        CachedEntry {
+            id: self.get_key(),
+            alias: self.get_alias(),
+            type_: self.get_type(),
+            expires: Utc::now().timestamp() + self.get_type().expiry(),
+            data: Some(self),
+        }
+    }
+
     fn get_type(&self) -> CacheValueType {
         match self {
             CacheValue::Project(_) => CacheValueType::Project,
@@ -407,11 +409,13 @@ impl CacheValue {
         }
     }
 
-    fn get_alias(&self) -> Option<&str> {
+    fn get_alias(&self) -> Option<String> {
         match self {
-            CacheValue::Project(project) => project.slug.as_deref(),
-            CacheValue::User(user) => Some(&user.username),
-            CacheValue::Organization(org) => Some(&org.slug),
+            CacheValue::Project(project) => {
+                project.slug.clone().map(|x| x.to_lowercase())
+            }
+            CacheValue::User(user) => Some(user.username.to_lowercase()),
+            CacheValue::Organization(org) => Some(org.slug.to_lowercase()),
 
             CacheValue::MinecraftManifest(_)
             | CacheValue::Categories(_)
@@ -429,8 +433,11 @@ impl CacheValue {
     }
 }
 
-#[derive(PartialEq, Eq, Debug)]
+#[derive(PartialEq, Eq, Debug, Copy, Clone)]
 pub enum CacheBehaviour {
+    /// Serve expired data. If fetch fails / launcher is offline, errors are ignored
+    /// and expired data is served
+    StaleWhileRevalidateSkipOffline,
     // Serve expired data, revalidate in background
     StaleWhileRevalidate,
     // Must revalidate if data is expired
@@ -441,7 +448,7 @@ pub enum CacheBehaviour {
 
 impl Default for CacheBehaviour {
     fn default() -> Self {
-        Self::StaleWhileRevalidate
+        Self::StaleWhileRevalidateSkipOffline
     }
 }
 
@@ -451,7 +458,7 @@ pub struct CachedEntry {
     alias: Option<String>,
     #[serde(rename = "data_type")]
     type_: CacheValueType,
-    data: CacheValue,
+    data: Option<CacheValue>,
     expires: i64,
 }
 
@@ -486,7 +493,7 @@ macro_rules! impl_cache_methods {
                         let entry =
                             CachedEntry::get_many(CacheValueType::$variant, ids, cache_behaviour, exec, fetch_semaphore).await?;
 
-                        Ok(entry.into_iter().filter_map(|x| if let CacheValue::$variant(value) = x.data {
+                        Ok(entry.into_iter().filter_map(|x| if let Some(CacheValue::$variant(value)) = x.data {
                             Some(value)
                         } else {
                             None
@@ -515,7 +522,7 @@ macro_rules! impl_cache_method_singular {
                         let entry =
                             CachedEntry::get(CacheValueType::$variant, DEFAULT_ID, cache_behaviour, exec, fetch_semaphore).await?;
 
-                        if let Some(CacheValue::$variant(value)) = entry.map(|x| x.data) {
+                        if let Some(CacheValue::$variant(value)) = entry.map(|x| x.data).flatten() {
                             Ok(Some(value))
                         } else {
                             Ok(None)
@@ -606,46 +613,58 @@ impl CachedEntry {
 
         if cache_behaviour != CacheBehaviour::Bypass {
             let type_ = type_.as_str();
-            let keys = serde_json::to_string(&keys)?;
+            let serialized_keys = serde_json::to_string(&keys)?;
+            let lowercased_keys = serde_json::to_string(
+                &keys.iter().map(|x| x.to_lowercase()).collect::<Vec<_>>(),
+            )?;
 
             // unsupported type NULL of column #3 ("data"), so cannot be compile time type checked
             // https://github.com/launchbadge/sqlx/issues/1979
             let query = sqlx::query!(
                 r#"
-                SELECT id, data_type, json(data) as "data!: serde_json::Value", alias, expires
+                SELECT id, data_type, json(data) as "data?: serde_json::Value", alias, expires
                 FROM cache
                 WHERE data_type = $1 AND (
                     id IN (SELECT value FROM json_each($2))
                     OR
-                    alias IN (SELECT value FROM json_each($2))
+                    alias IN (SELECT value FROM json_each($3))
                 )
                 "#,
                 type_,
-                keys
+                serialized_keys,
+                lowercased_keys
             )
             .fetch_all(&mut *exec)
             .await?;
 
             for row in query {
-                if let Ok(data) = serde_json::from_value(row.data) {
-                    if row.expires <= Utc::now().timestamp() {
-                        if cache_behaviour == CacheBehaviour::MustRevalidate {
-                            continue;
-                        } else {
-                            expired_keys.insert(row.id.clone());
-                        }
+                if row.expires <= Utc::now().timestamp() {
+                    if cache_behaviour == CacheBehaviour::MustRevalidate {
+                        continue;
+                    } else {
+                        expired_keys.insert(row.id.clone());
                     }
+                }
 
-                    remaining_keys.remove(&*row.id);
-                    if let Some(alias) = row.alias.as_deref() {
-                        remaining_keys.remove(alias);
-                    }
+                remaining_keys.retain(|x| {
+                    x != &&*row.id
+                        && !row
+                            .alias
+                            .as_ref()
+                            .map(|y| y.to_lowercase() == x.to_lowercase())
+                            .unwrap_or(false)
+                });
 
+                if let Some(data) = row
+                    .data
+                    .map(|x| serde_json::from_value::<CacheValue>(x).ok())
+                    .flatten()
+                {
                     return_vals.push(Self {
                         id: row.id,
                         alias: row.alias,
                         type_: CacheValueType::from_str(&row.data_type),
-                        data,
+                        data: Some(data),
                         expires: row.expires,
                     });
                 }
@@ -653,19 +672,45 @@ impl CachedEntry {
         }
 
         let time = now.elapsed();
-        println!("query {type_:?} keys: {remaining_keys:?}, elapsed: {:.2?}", time);
+        println!(
+            "query {type_:?} keys: {remaining_keys:?}, elapsed: {:.2?}",
+            time
+        );
         let now = Instant::now();
 
-
         if !remaining_keys.is_empty() {
-            let mut values =
-                Self::fetch_many(type_, remaining_keys, fetch_semaphore)
-                    .await?;
+            let res = Self::fetch_many(
+                type_,
+                remaining_keys.clone(),
+                fetch_semaphore,
+            )
+            .await;
+
+            if res.is_err()
+                && cache_behaviour
+                    == CacheBehaviour::StaleWhileRevalidateSkipOffline
+            {
+                for key in remaining_keys {
+                    expired_keys.insert(key.to_string());
+                }
+            } else {
+                let values = res?;
 
-            if !values.is_empty() {
-                Self::upsert_many(&values, &mut *exec).await?;
+                Self::upsert_many(
+                    &values.iter().map(|x| x.0.clone()).collect::<Vec<_>>(),
+                    &mut *exec,
+                )
+                .await?;
 
-                return_vals.append(&mut values);
+                if !values.is_empty() {
+                    return_vals.append(
+                        &mut values
+                            .into_iter()
+                            .filter(|(_, include)| *include)
+                            .map(|x| x.0)
+                            .collect::<Vec<_>>(),
+                    );
+                }
             }
         }
 
@@ -673,7 +718,9 @@ impl CachedEntry {
         println!("FETCH {type_:?} DONE, elapsed: {:.2?}", time);
 
         if !expired_keys.is_empty()
-            && cache_behaviour == CacheBehaviour::StaleWhileRevalidate
+            && (cache_behaviour == CacheBehaviour::StaleWhileRevalidate
+                || cache_behaviour
+                    == CacheBehaviour::StaleWhileRevalidateSkipOffline)
         {
             tokio::task::spawn(async move {
                 // TODO: if possible- find a way to do this without invoking state get
@@ -684,7 +731,10 @@ impl CachedEntry {
                     expired_keys,
                     &state.fetch_semaphore,
                 )
-                .await?;
+                .await?
+                .into_iter()
+                .map(|x| x.0)
+                .collect::<Vec<_>>();
 
                 if !values.is_empty() {
                     Self::upsert_many(&values, &state.pool).await?;
@@ -701,10 +751,10 @@ impl CachedEntry {
         type_: CacheValueType,
         keys: DashSet<impl Display + Eq + Hash + Serialize>,
         fetch_semaphore: &FetchSemaphore,
-    ) -> crate::Result<Vec<Self>> {
+    ) -> crate::Result<Vec<(Self, bool)>> {
         macro_rules! fetch_original_values {
             ($type:ident, $api_url:expr, $url_suffix:expr, $cache_variant:path) => {{
-                fetch_json::<Vec<_>>(
+                let results = fetch_json::<Vec<_>>(
                     Method::GET,
                     &*format!(
                         "{}{}?ids={}",
@@ -718,29 +768,43 @@ impl CachedEntry {
                 )
                 .await?
                 .into_iter()
-                .map(|x| {
-                    let data = $cache_variant(x);
-
-                    Self {
-                        id: data.get_key().to_string(),
-                        alias: data.get_alias().map(|x| x.to_string()),
-                        type_: CacheValueType::$type,
-                        data,
-                        expires: Utc::now().timestamp()
-                            + CacheValueType::$type.expiry(),
+                .map($cache_variant)
+                .collect::<Vec<_>>();
+
+                let values = dashmap::DashMap::new();
+                for key in keys {
+                    let key = key.to_string();
+                    let lower_case_key = key.to_lowercase();
+                    if let Some(data) = results.iter().find(|x| {
+                        x.get_key() == key
+                            || x.get_alias()
+                                .map(|x| x == lower_case_key)
+                                .unwrap_or(false)
+                    }) {
+                        values.insert(data.get_key(), data.clone().get_entry());
+                    } else {
+                        values.insert(
+                            key.clone(),
+                            Self {
+                                id: key,
+                                alias: None,
+                                type_: CacheValueType::$type,
+                                data: None,
+                                expires: Utc::now().timestamp()
+                                    + CacheValueType::$type.expiry(),
+                            },
+                        );
                     }
-                })
-                .collect()
+                }
+
+                values.into_iter().map(|(_, val)| (val, true)).collect()
             }};
         }
 
         macro_rules! fetch_original_value {
             ($type:ident, $api_url:expr, $url_suffix:expr, $cache_variant:path) => {{
-                vec![Self {
-                    id: DEFAULT_ID.to_string(),
-                    alias: None,
-                    type_: CacheValueType::$type,
-                    data: $cache_variant(
+                vec![(
+                    $cache_variant(
                         fetch_json(
                             Method::GET,
                             &*format!("{}{}", $api_url, $url_suffix),
@@ -749,10 +813,10 @@ impl CachedEntry {
                             &fetch_semaphore,
                         )
                         .await?,
-                    ),
-                    expires: Utc::now().timestamp()
-                        + CacheValueType::$type.expiry(),
-                }]
+                    )
+                    .get_entry(),
+                    true,
+                )]
             }};
         }
 
@@ -782,20 +846,67 @@ impl CachedEntry {
                 )
             }
             CacheValueType::Team => {
-                fetch_original_values!(
-                    Team,
-                    MODRINTH_API_URL_V3,
-                    "teams",
-                    CacheValue::Team
+                let mut values = vec![];
+
+                fetch_json::<Vec<Vec<TeamMember>>>(
+                    Method::GET,
+                    &*format!(
+                        "{MODRINTH_API_URL_V3}teams?ids={}",
+                        serde_json::to_string(&keys)?
+                    ),
+                    None,
+                    None,
+                    &fetch_semaphore,
                 )
+                .await?
+                .into_iter()
+                .for_each(|team| {
+                    for member in &team {
+                        values.push((
+                            CacheValue::User(member.user.clone()).get_entry(),
+                            false,
+                        ));
+                    }
+
+                    values.push((CacheValue::Team(team).get_entry(), true))
+                });
+
+                values
             }
             CacheValueType::Organization => {
-                fetch_original_values!(
-                    Organization,
-                    MODRINTH_API_URL_V3,
-                    "organizations",
-                    CacheValue::Organization
+                let mut values = vec![];
+
+                fetch_json::<Vec<Organization>>(
+                    Method::GET,
+                    &*format!(
+                        "{MODRINTH_API_URL_V3}organizations?ids={}",
+                        serde_json::to_string(&keys)?
+                    ),
+                    None,
+                    None,
+                    &fetch_semaphore,
                 )
+                .await?
+                .into_iter()
+                .for_each(|org| {
+                    for member in &org.members {
+                        values.push((
+                            CacheValue::User(member.user.clone()).get_entry(),
+                            false,
+                        ));
+                    }
+
+                    values.push((
+                        CacheValue::Team(org.members.clone()).get_entry(),
+                        false,
+                    ));
+                    values.push((
+                        CacheValue::Organization(org).get_entry(),
+                        true,
+                    ));
+                });
+
+                values
             }
             CacheValueType::File => {
                 let mut versions = fetch_json::<HashMap<String, Version>>(
@@ -817,22 +928,26 @@ impl CachedEntry {
 
                     let metadata = if let Some(version) = versions.remove(&hash)
                     {
+                        let version_id = version.id.clone();
+                        let project_id = version.project_id.clone();
+                        vals.push((
+                            CacheValue::Version(version).get_entry(),
+                            false,
+                        ));
+
                         FileMetadata::Modrinth {
-                            project_id: version.project_id,
-                            version_id: version.id,
+                            project_id,
+                            version_id,
                         }
                     } else {
                         FileMetadata::Unknown
                     };
 
-                    vals.push(Self {
-                        id: hash.clone(),
-                        alias: None,
-                        type_: CacheValueType::File,
-                        data: CacheValue::File(CachedFile { hash, metadata }),
-                        expires: Utc::now().timestamp()
-                            + CacheValueType::File.expiry(),
-                    })
+                    vals.push((
+                        CacheValue::File(CachedFile { hash, metadata })
+                            .get_entry(),
+                        true,
+                    ))
                 }
 
                 vals
@@ -862,16 +977,15 @@ impl CachedEntry {
                 .await?
                 .into_iter()
                 .enumerate()
-                .map(|(index, metadata)| Self {
-                    id: fetch_urls[index].0.to_string(),
-                    alias: None,
-                    type_: CacheValueType::LoaderManifest,
-                    data: CacheValue::LoaderManifest(CachedLoaderManifest {
-                        loader: fetch_urls[index].0.to_string(),
-                        manifest: metadata,
-                    }),
-                    expires: Utc::now().timestamp()
-                        + CacheValueType::LoaderManifest.expiry(),
+                .map(|(index, metadata)| {
+                    (
+                        CacheValue::LoaderManifest(CachedLoaderManifest {
+                            loader: fetch_urls[index].0.to_string(),
+                            manifest: metadata,
+                        })
+                        .get_entry(),
+                        true,
+                    )
                 })
                 .collect()
             }
@@ -934,7 +1048,7 @@ impl CachedEntry {
                 async fn hash_file(
                     profiles_dir: &Path,
                     key: String,
-                ) -> crate::Result<CachedEntry> {
+                ) -> crate::Result<(CachedEntry, bool)> {
                     let path =
                         key.split_once('-').map(|x| x.1).unwrap_or_default();
 
@@ -957,25 +1071,20 @@ impl CachedEntry {
 
                     let hash = hasher.digest().to_string();
 
-                    let data = CacheValue::FileHash(CachedFileHash {
-                        path: path.to_string(),
-                        file_name: full_path
-                            .file_name()
-                            .and_then(|x| x.to_str())
-                            .unwrap_or_default()
-                            .to_string(),
-                        size,
-                        hash,
-                    });
-
-                    Ok(CachedEntry {
-                        id: key.clone(),
-                        alias: None,
-                        type_: CacheValueType::FileHash,
-                        data,
-                        expires: Utc::now().timestamp()
-                            + CacheValueType::FileHash.expiry(),
-                    })
+                    Ok((
+                        CacheValue::FileHash(CachedFileHash {
+                            path: path.to_string(),
+                            file_name: full_path
+                                .file_name()
+                                .and_then(|x| x.to_str())
+                                .unwrap_or_default()
+                                .to_string(),
+                            size,
+                            hash,
+                        })
+                        .get_entry(),
+                        true,
+                    ))
                 }
 
                 use futures::stream::StreamExt;
@@ -991,6 +1100,8 @@ impl CachedEntry {
                 results
             }
             CacheValueType::FileUpdate => {
+                let mut vals = Vec::new();
+
                 // TODO: switch to update individual once back-end route exists
                 let mut filtered_keys: Vec<((String, String), Vec<String>)> =
                     Vec::new();
@@ -1015,6 +1126,18 @@ impl CachedEntry {
                                 vec![hash.to_string()],
                             ))
                         }
+                    } else {
+                        vals.push((
+                            Self {
+                                id: string,
+                                alias: None,
+                                type_: CacheValueType::FileUpdate,
+                                data: None,
+                                expires: Utc::now().timestamp()
+                                    + CacheValueType::FileUpdate.expiry(),
+                            },
+                            true,
+                        ))
                     }
                 });
 
@@ -1039,31 +1162,36 @@ impl CachedEntry {
                     ))
                     .await?;
 
-                let mut vals = Vec::new();
-
                 for (index, mut variation) in variations.into_iter().enumerate()
                 {
                     let ((loader, game_version), hashes) =
                         &filtered_keys[index];
 
                     for hash in hashes {
-                        let version_id = variation.remove(hash).map(|x| x.id);
-
-                        let data = CacheValue::FileUpdate(CachedFileUpdate {
-                            hash: hash.clone(),
-                            game_version: game_version.clone(),
-                            loader: loader.clone(),
-                            update_version_id: version_id,
-                        });
-
-                        vals.push(Self {
-                            id: data.get_key(),
-                            alias: None,
-                            type_: CacheValueType::FileUpdate,
-                            data,
-                            expires: Utc::now().timestamp()
-                                + CacheValueType::FileUpdate.expiry(),
-                        })
+                        let version = variation.remove(hash);
+
+                        let version_id = if let Some(version) = version {
+                            let version_id = version.id.clone();
+                            vals.push((
+                                CacheValue::Version(version).get_entry(),
+                                false,
+                            ));
+
+                            Some(version_id)
+                        } else {
+                            None
+                        };
+
+                        vals.push((
+                            CacheValue::FileUpdate(CachedFileUpdate {
+                                hash: hash.clone(),
+                                game_version: game_version.clone(),
+                                loader: loader.clone(),
+                                update_version_id: version_id,
+                            })
+                            .get_entry(),
+                            true,
+                        ))
                     }
                 }
 
@@ -1072,18 +1200,7 @@ impl CachedEntry {
         })
     }
 
-    /// Update/sets a value in the cache to the given value. Avoid using if possible:
-    /// stick to `Self::get` and `Self::get_many`.
-    pub(crate) async fn upsert(
-        self,
-        exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite>,
-    ) -> crate::Result<()> {
-        Self::upsert_many(&[self], exec).await
-    }
-
-    /// Update/sets values in the cache to the given values. Avoid using if possible:
-    /// stick to `Self::get` and `Self::get_many`.
-    pub(crate) async fn upsert_many(
+    async fn upsert_many(
         items: &[Self],
         exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite>,
     ) -> crate::Result<()> {
diff --git a/packages/app-lib/src/state/db.rs b/packages/app-lib/src/state/db.rs
index 248322b5c..0d115a4f7 100644
--- a/packages/app-lib/src/state/db.rs
+++ b/packages/app-lib/src/state/db.rs
@@ -1,7 +1,7 @@
 use crate::state::DirectoryInfo;
 use sqlx::migrate::MigrateDatabase;
 use sqlx::sqlite::SqlitePoolOptions;
-use sqlx::{Connection, Pool, Sqlite};
+use sqlx::{Pool, Sqlite};
 
 pub(crate) async fn connect() -> crate::Result<Pool<Sqlite>> {
     let uri =
diff --git a/packages/app-lib/src/state/discord.rs b/packages/app-lib/src/state/discord.rs
index 413c6fe36..4c77703c8 100644
--- a/packages/app-lib/src/state/discord.rs
+++ b/packages/app-lib/src/state/discord.rs
@@ -16,7 +16,7 @@ pub struct DiscordGuard {
 impl DiscordGuard {
     /// Initialize discord IPC client, and attempt to connect to it
     /// If it fails, it will still return a DiscordGuard, but the client will be unconnected
-    pub async fn init(is_offline: bool) -> crate::Result<DiscordGuard> {
+    pub async fn init() -> crate::Result<DiscordGuard> {
         let mut dipc =
             DiscordIpcClient::new("1123683254248148992").map_err(|e| {
                 crate::ErrorKind::OtherError(format!(
@@ -25,13 +25,9 @@ impl DiscordGuard {
                 ))
             })?;
 
-        let connected = if !is_offline {
-            let res = dipc.connect(); // Do not need to connect to Discord to use app
-            if res.is_ok() {
-                Arc::new(AtomicBool::new(true))
-            } else {
-                Arc::new(AtomicBool::new(false))
-            }
+        let res = dipc.connect(); // Do not need to connect to Discord to use app
+        let connected = if res.is_ok() {
+            Arc::new(AtomicBool::new(true))
         } else {
             Arc::new(AtomicBool::new(false))
         };
@@ -56,19 +52,6 @@ impl DiscordGuard {
         true
     }
 
-    // check online
-    pub async fn check_online(&self) -> bool {
-        let state = match State::get().await {
-            Ok(s) => s,
-            Err(_) => return false,
-        };
-        let offline = state.offline.read().await;
-        if *offline {
-            return false;
-        }
-        true
-    }
-
     /// Set the activity to the given message
     /// First checks if discord is disabled, and if so, clear the activity instead
     pub async fn set_activity(
@@ -76,10 +59,6 @@ impl DiscordGuard {
         msg: &str,
         reconnect_if_fail: bool,
     ) -> crate::Result<()> {
-        if !self.check_online().await {
-            return Ok(());
-        }
-
         // Check if discord is disabled, and if so, clear the activity instead
         let state = State::get().await?;
         let settings = crate::state::Settings::get(&state.pool).await?;
@@ -145,7 +124,7 @@ impl DiscordGuard {
         reconnect_if_fail: bool,
     ) -> crate::Result<()> {
         // Attempt to connect if not connected. Do not continue if it fails, as the client.clear_activity can panic if it never was connected
-        if !self.check_online().await || !self.retry_if_not_ready().await {
+        if !self.retry_if_not_ready().await {
             return Ok(());
         }
 
diff --git a/packages/app-lib/src/state/fs_watcher.rs b/packages/app-lib/src/state/fs_watcher.rs
index a40e0416c..d8276d5ed 100644
--- a/packages/app-lib/src/state/fs_watcher.rs
+++ b/packages/app-lib/src/state/fs_watcher.rs
@@ -37,11 +37,15 @@ pub async fn init_watcher() -> crate::Result<FileWatcher> {
                         let mut found = false;
                         for component in e.path.components() {
                             if found {
-                                profile_path = Some(component.as_os_str().to_string_lossy());
+                                profile_path = Some(
+                                    component.as_os_str().to_string_lossy(),
+                                );
                                 break;
                             }
 
-                            if component.as_os_str() == crate::state::dirs::PROFILES_FOLDER_NAME {
+                            if component.as_os_str()
+                                == crate::state::dirs::PROFILES_FOLDER_NAME
+                            {
                                 found = true;
                             }
                         }
@@ -51,19 +55,20 @@ pub async fn init_watcher() -> crate::Result<FileWatcher> {
                                 .components()
                                 .any(|x| x.as_os_str() == "crash-reports")
                                 && e.path
-                                .extension()
-                                .map(|x| x == "txt")
-                                .unwrap_or(false)
+                                    .extension()
+                                    .map(|x| x == "txt")
+                                    .unwrap_or(false)
                             {
                                 crash_task(profile_path.to_string());
-                            } else if !visited_profiles.contains(&profile_path) {
+                            } else if !visited_profiles.contains(&profile_path)
+                            {
                                 let path = profile_path.to_string();
                                 tokio::spawn(async move {
                                     let _ = emit_profile(
                                         &path,
                                         ProfilePayloadType::Synced,
                                     )
-                                        .await;
+                                    .await;
                                 });
                                 visited_profiles.push(profile_path);
                             }
diff --git a/packages/app-lib/src/state/mod.rs b/packages/app-lib/src/state/mod.rs
index 3c23f0a04..785631c64 100644
--- a/packages/app-lib/src/state/mod.rs
+++ b/packages/app-lib/src/state/mod.rs
@@ -1,12 +1,11 @@
 //! Theseus state management system
-use crate::event::emit::{emit_loading, emit_offline, init_loading_unsafe};
+use crate::event::emit::{emit_loading, init_loading_unsafe};
 
 use crate::event::LoadingBarType;
 use crate::loading_join;
 
-use crate::util::fetch::{self, FetchSemaphore, IoSemaphore};
+use crate::util::fetch::{FetchSemaphore, IoSemaphore};
 use std::sync::Arc;
-use std::time::Duration;
 use tokio::sync::{OnceCell, RwLock, Semaphore};
 
 use crate::state::fs_watcher::FileWatcher;
@@ -43,22 +42,15 @@ mod mr_auth;
 
 pub use self::mr_auth::*;
 
-// TODO: possible memcache for cache entries to improve perf
-// TODO: cache children too (ex: version file req should cache version too)
-// TODO: Java Version API
+// TODO: Cache home page queries?
 // TODO: UI: Profile Options
-// TODO: UI: Profile Content Fully Integrate (and improve perf)
 // TODO: UI: Settings Java Versions
 // TODO: pass credentials to modrinth cdn
-// TODO: get rid of unnecessary locking + atomics in discord
 
 // Global state
 // RwLock on state only has concurrent reads, except for config dir change which takes control of the State
 static LAUNCHER_STATE: OnceCell<Arc<State>> = OnceCell::const_new();
 pub struct State {
-    /// Whether or not the launcher is currently operating in 'offline mode'
-    pub offline: RwLock<bool>,
-
     /// Information on the location of files used in the launcher
     pub directories: DirectoryInfo,
 
@@ -132,8 +124,6 @@ impl State {
             IoSemaphore(Semaphore::new(settings.max_concurrent_writes));
         emit_loading(&loading_bar, 10.0, None).await?;
 
-        let is_offline = !fetch::check_internet(3).await;
-
         let users_fut = MinecraftAuthStore::init(&directories, &io_semaphore);
         let creds_fut = CredentialsStore::init(&directories, &io_semaphore);
         // Launcher data
@@ -143,8 +133,8 @@ impl State {
             creds_fut,
         }?;
 
-        let discord_rpc = DiscordGuard::init(is_offline).await?;
-        if settings.discord_rpc && !is_offline {
+        let discord_rpc = DiscordGuard::init().await?;
+        if settings.discord_rpc {
             // Add default Idling to discord rich presence
             // Force add to avoid recursion
             let _ = discord_rpc.force_set_activity("Idling...", true).await;
@@ -155,13 +145,9 @@ impl State {
         let file_watcher = fs_watcher::init_watcher().await?;
         fs_watcher::watch_profiles_init(&file_watcher, &directories).await?;
 
-        // Starts a loop of checking if we are online, and updating
-        Self::offine_check_loop();
-
         emit_loading(&loading_bar, 10.0, None).await?;
 
         Ok(Arc::new(Self {
-            offline: RwLock::new(is_offline),
             directories,
             fetch_semaphore,
             io_semaphore,
@@ -175,46 +161,12 @@ impl State {
         }))
     }
 
-    /// Starts a loop of checking if we are online, and updating
-    pub fn offine_check_loop() {
-        tokio::task::spawn(async {
-            loop {
-                let state = Self::get().await;
-                if let Ok(state) = state {
-                    let _ = state.refresh_offline().await;
-                }
-
-                // Wait 5 seconds
-                tokio::time::sleep(Duration::from_secs(5)).await;
-            }
-        });
-    }
-
     /// Updates state with data from the web, if we are online
     pub fn update() {
         tokio::task::spawn(async {
-            if let Ok(state) = crate::State::get().await {
-                if !*state.offline.read().await {
-                    let res6 = CredentialsStore::update_creds();
+            let res6 = CredentialsStore::update_creds();
 
-                    let _ = res6.await;
-                }
-            }
+            let _ = res6.await;
         });
     }
-
-    /// Refreshes whether or not the launcher should be offline, by whether or not there is an internet connection
-    pub async fn refresh_offline(&self) -> crate::Result<()> {
-        let is_online = fetch::check_internet(3).await;
-
-        let mut offline = self.offline.write().await;
-
-        if *offline != is_online {
-            return Ok(());
-        }
-
-        emit_offline(!is_online).await?;
-        *offline = !is_online;
-        Ok(())
-    }
 }
diff --git a/packages/app-lib/src/state/profiles.rs b/packages/app-lib/src/state/profiles.rs
index bbdc685b5..b583ce2c1 100644
--- a/packages/app-lib/src/state/profiles.rs
+++ b/packages/app-lib/src/state/profiles.rs
@@ -1,5 +1,5 @@
 use super::settings::{Hooks, MemorySettings, WindowSize};
-use crate::state::{CacheBehaviour, CachedEntry, FileMetadata};
+use crate::state::{CacheBehaviour, CachedEntry, CachedFile, FileMetadata};
 use crate::util;
 use crate::util::fetch::{write_cached_icon, FetchSemaphore, IoSemaphore};
 use crate::util::io::{self};
@@ -135,6 +135,7 @@ pub struct ProfileFile {
     pub size: u64,
     pub metadata: FileMetadata,
     pub update_version_id: Option<String>,
+    pub project_type: ProjectType,
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, Copy)]
@@ -536,6 +537,7 @@ impl Profile {
 
     pub async fn get_projects<'a, E>(
         &self,
+        cache_behaviour: Option<CacheBehaviour>,
         exec: E,
         fetch_semaphore: &FetchSemaphore,
     ) -> crate::Result<DashMap<String, ProfileFile>>
@@ -587,7 +589,7 @@ impl Profile {
             }
         }
 
-        let mut file_hashes = CachedEntry::get_file_hash_many(
+        let file_hashes = CachedEntry::get_file_hash_many(
             &keys.iter().map(|s| &*s.cache_key).collect::<Vec<_>>(),
             None,
             exec,
@@ -595,15 +597,7 @@ impl Profile {
         )
         .await?;
 
-        let file_info = CachedEntry::get_file_many(
-            &file_hashes.iter().map(|x| &*x.hash).collect::<Vec<_>>(),
-            None,
-            exec,
-            fetch_semaphore,
-        )
-        .await?;
-
-        let file_updates = file_info
+        let file_updates = file_hashes
             .iter()
             .map(|x| {
                 format!(
@@ -614,62 +608,78 @@ impl Profile {
                 )
             })
             .collect::<Vec<_>>();
-        let file_updates = CachedEntry::get_file_update_many(
-            &file_updates.iter().map(|x| &**x).collect::<Vec<_>>(),
-            None,
-            exec,
-            fetch_semaphore,
-        )
-        .await?;
+
+        let file_hashes_ref =
+            file_hashes.iter().map(|x| &*x.hash).collect::<Vec<_>>();
+        let file_updates_ref =
+            file_updates.iter().map(|x| &**x).collect::<Vec<_>>();
+        let (mut file_info, file_updates) = tokio::try_join!(
+            CachedEntry::get_file_many(
+                &file_hashes_ref,
+                cache_behaviour,
+                exec,
+                fetch_semaphore,
+            ),
+            CachedEntry::get_file_update_many(
+                &file_updates_ref,
+                cache_behaviour,
+                exec,
+                fetch_semaphore,
+            )
+        )?;
 
         let files = DashMap::new();
 
-        for file in file_info {
-            if let Some(hash_index) =
-                file_hashes.iter().position(|x| x.hash == file.hash)
+        for hash in file_hashes {
+            let info_index = file_info.iter().position(|x| x.hash == hash.hash);
+            let file =
+                info_index.map(|x| file_info.remove(x)).unwrap_or_else(|| {
+                    CachedFile {
+                        hash: hash.hash.clone(),
+                        metadata: FileMetadata::Unknown,
+                    }
+                });
+
+            if let Some(initial_file_index) =
+                keys.iter().position(|x| x.file_name == hash.file_name)
             {
-                let hash = file_hashes.remove(hash_index);
+                let initial_file = keys.remove(initial_file_index);
+
+                let path = format!(
+                    "{}/{}",
+                    initial_file.project_type.get_folder(),
+                    initial_file.file_name
+                );
 
-                if let Some(initial_file_index) =
-                    keys.iter().position(|x| x.file_name == hash.file_name)
+                let update_version_id = if let Some(update) = file_updates
+                    .iter()
+                    .find(|x| x.hash == hash.hash)
+                    .and_then(|x| x.update_version_id.as_ref())
                 {
-                    let initial_file = keys.remove(initial_file_index);
-
-                    let path = format!(
-                        "{}/{}",
-                        initial_file.project_type.get_folder(),
-                        initial_file.file_name
-                    );
-
-                    let update_version_id = if let Some(update) = file_updates
-                        .iter()
-                        .find(|x| x.hash == hash.hash)
-                        .and_then(|x| x.update_version_id.as_ref())
+                    if let FileMetadata::Modrinth { version_id, .. } =
+                        &file.metadata
                     {
-                        if let FileMetadata::Modrinth { version_id, .. } =
-                            &file.metadata
-                        {
-                            if version_id != update {
-                                Some(update.clone())
-                            } else {
-                                None
-                            }
+                        if version_id != update {
+                            Some(update.clone())
                         } else {
                             None
                         }
                     } else {
                         None
-                    };
-
-                    let file = ProfileFile {
-                        update_version_id,
-                        hash: hash.hash,
-                        file_name: initial_file.file_name,
-                        size: initial_file.size,
-                        metadata: file.metadata,
-                    };
-                    files.insert(path, file);
-                }
+                    }
+                } else {
+                    None
+                };
+
+                let file = ProfileFile {
+                    update_version_id,
+                    hash: hash.hash,
+                    file_name: initial_file.file_name,
+                    size: initial_file.size,
+                    metadata: file.metadata,
+                    project_type: initial_file.project_type,
+                };
+                files.insert(path, file);
             }
         }
 
diff --git a/packages/app-lib/src/util/fetch.rs b/packages/app-lib/src/util/fetch.rs
index caadc4fca..84b543cc7 100644
--- a/packages/app-lib/src/util/fetch.rs
+++ b/packages/app-lib/src/util/fetch.rs
@@ -8,7 +8,7 @@ use reqwest::Method;
 use serde::de::DeserializeOwned;
 use std::ffi::OsStr;
 use std::path::{Path, PathBuf};
-use std::time::{self, Duration};
+use std::time::{self};
 use tokio::sync::Semaphore;
 use tokio::{fs::File, io::AsyncWriteExt};
 
@@ -191,18 +191,6 @@ pub async fn fetch_mirrors(
     unreachable!()
 }
 
-/// Using labrinth API, checks if an internet response can be found, with a timeout in seconds
-#[tracing::instrument]
-#[theseus_macros::debug_pin]
-pub async fn check_internet(timeout: u64) -> bool {
-    REQWEST_CLIENT
-        .get("https://launcher-files.modrinth.com/detect.txt")
-        .timeout(Duration::from_secs(timeout))
-        .send()
-        .await
-        .is_ok()
-}
-
 /// Posts a JSON to a URL
 #[tracing::instrument(skip(json_body, semaphore))]
 #[theseus_macros::debug_pin]