From 8586781a81b11fe7ce7755cd6ff825d2a22b773b Mon Sep 17 00:00:00 2001
From: "Calum H. (IMB11)" <contact@cal.engineer>
Date: Wed, 19 Aug 2026 16:04:58 +0100
Subject: [PATCH] feat: initial start on basic instance file syncing

---
 apps/app-frontend/src/App.vue                 |   18 +-
 .../components/ui/modal/AppSettingsModal.vue  |    8 +-
 .../instances/DefaultInstanceSettings.vue     |  362 -----
 .../instances/InstancesSyncedSettings.vue     |  797 +++++++++++
 .../src/components/ui/world/WorldItem.vue     |   20 +-
 .../ui/world/modal/DesyncServerModal.vue      |   67 +
 apps/app-frontend/src/helpers/instance.ts     |   78 +-
 apps/app-frontend/src/helpers/types.d.ts      |    3 +
 apps/app-frontend/src/helpers/worlds.ts       |   14 +
 .../app-frontend/src/locales/de-CH/index.json |    3 -
 .../app-frontend/src/locales/de-DE/index.json |    3 -
 .../app-frontend/src/locales/en-US/index.json |   91 +-
 .../src/locales/es-419/index.json             |    3 -
 .../app-frontend/src/locales/fr-FR/index.json |    3 -
 .../app-frontend/src/locales/hu-HU/index.json |    3 -
 .../app-frontend/src/locales/it-IT/index.json |    3 -
 .../app-frontend/src/locales/ja-JP/index.json |    3 -
 .../app-frontend/src/locales/ko-KR/index.json |    3 -
 .../app-frontend/src/locales/nl-NL/index.json |    3 -
 .../app-frontend/src/locales/pl-PL/index.json |    3 -
 .../app-frontend/src/locales/pt-BR/index.json |    3 -
 .../app-frontend/src/locales/ru-RU/index.json |    3 -
 .../app-frontend/src/locales/sv-SE/index.json |    3 -
 .../app-frontend/src/locales/uk-UA/index.json |    3 -
 .../app-frontend/src/locales/zh-CN/index.json |    3 -
 .../app-frontend/src/locales/zh-TW/index.json |    3 -
 .../settings-modal/hooks-settings.vue         |  135 +-
 .../components/settings-modal/index.vue       |   30 -
 .../settings-modal/java-settings.vue          |  284 ++--
 .../synced-options-settings.vue               |  150 +-
 .../settings-modal/window-settings.vue        |  109 +-
 .../src/pages/instance/worlds/index.vue       |   12 +
 apps/app/build.rs                             |   11 +
 apps/app/src/api/instance.rs                  |   90 ++
 apps/app/src/api/worlds.rs                    |   10 +
 ...acdd6586cfcea44c88152dc44d26f21332910.json |   12 +
 ...1b92e6abffdcad59050db59a0fcbace5b5f26.json |   20 +
 ...454c0cd8d49040bcb4a73c48cf044b3ecac89.json |   20 +
 ...ac1bafff2c46863e844a1f4ea5501eedb9ad4.json |   12 +
 ...0f4f6039574975f61747d3dd21bf57eda238a.json |   32 +
 ...7297c3e78428e58589586d65b62e917ee6ab3.json |   12 +
 ...68650ea8c5c8c45d267c3398d338e17cff239.json |   20 +
 ...175d493be079b599d5ac168988f0612ab563d.json |   12 +
 ...80f9bde067f3ac15aa40d15c19d217639b605.json |   12 +
 ...5a9eafcfbfdf7b98df1f838ba9af56695d7a4.json |   26 +
 ...f616424ecdb687b38fbbca4673ad5cdf24dd9.json |   12 +
 ...0a21ad800b41f69deda4ac6f4c6ca87428a14.json |   12 +
 ...74d295cfb808c03033e552928c3cf7347b6ad.json |   12 +
 ...da1f5c94fdf0db098072c4a138fe31932c370.json |   26 +
 ...55a6a7c6dbad8f7975973e2614441301bec23.json |   20 +
 ...f27e3ad2de43eebb2ee226497580d8ff69176.json |   20 +
 ...a4e314a4fc07eb8236f4bf35fd60db0605655.json |   12 +
 ...27d6e5e2c586da9cdcde53614a33320837dac.json |   20 +
 ...6ccd5b0ea889166672fedb26811ebb324c62f.json |   12 +
 ...60b48b538e41dca1a1e850a03f8b95ad9a34a.json |   44 +
 ...c7a0bd79be3d5b0836676073dc56355f87bc0.json |   12 +
 ...e461b77671619a65fb809bd9b8ed9ab71baaa.json |   20 +
 ...20260819120000_instance-synced-options.sql |   53 +
 packages/app-lib/src/api/instance.rs          |   21 +
 .../app-lib/src/api/instance/lifecycle.rs     |   13 +-
 .../src/api/instance/synced_options.rs        | 1245 +++++++++++++++++
 .../src/api/instance/synced_servers.rs        | 1185 ++++++++++++++++
 .../app-lib/src/api/pack/install_mrpack.rs    |   21 +
 packages/app-lib/src/api/worlds.rs            |  179 +--
 packages/app-lib/src/state/dirs.rs            |    7 +
 .../adapters/sqlite/instance_rows.rs          |  105 +-
 .../instances/commands/create_instance.rs     |    2 +
 .../src/state/instances/model/instance.rs     |   22 +-
 .../app-lib/src/state/instances/watcher.rs    |   28 +-
 packages/app-lib/src/state/mod.rs             |    8 +
 packages/app-lib/src/state/process.rs         |   14 +
 packages/ui/src/utils/ace-mode-mcfunction.ts  |  106 ++
 72 files changed, 4836 insertions(+), 910 deletions(-)
 delete mode 100644 apps/app-frontend/src/components/ui/settings/instances/DefaultInstanceSettings.vue
 create mode 100644 apps/app-frontend/src/components/ui/settings/instances/InstancesSyncedSettings.vue
 create mode 100644 apps/app-frontend/src/components/ui/world/modal/DesyncServerModal.vue
 create mode 100644 packages/app-lib/.sqlx/query-025bdcd737cd08b4111946dc28cacdd6586cfcea44c88152dc44d26f21332910.json
 create mode 100644 packages/app-lib/.sqlx/query-0bb6b572586c47253e224af9bee1b92e6abffdcad59050db59a0fcbace5b5f26.json
 create mode 100644 packages/app-lib/.sqlx/query-0e12f60511e37652760cac595e7454c0cd8d49040bcb4a73c48cf044b3ecac89.json
 create mode 100644 packages/app-lib/.sqlx/query-1cdee99e388ed61a0d57a61ded6ac1bafff2c46863e844a1f4ea5501eedb9ad4.json
 create mode 100644 packages/app-lib/.sqlx/query-21463a2bec47047d05d9bdb2dac0f4f6039574975f61747d3dd21bf57eda238a.json
 create mode 100644 packages/app-lib/.sqlx/query-30694d61cfc967df2bc22341e127297c3e78428e58589586d65b62e917ee6ab3.json
 create mode 100644 packages/app-lib/.sqlx/query-42c6505cc670cca48934a9f3fe768650ea8c5c8c45d267c3398d338e17cff239.json
 create mode 100644 packages/app-lib/.sqlx/query-6f7d5d7df89066764e809f4d299175d493be079b599d5ac168988f0612ab563d.json
 create mode 100644 packages/app-lib/.sqlx/query-8f09e98c6b8e0f1d5444aabbf2a80f9bde067f3ac15aa40d15c19d217639b605.json
 create mode 100644 packages/app-lib/.sqlx/query-9d60938be8573be0f82cac164245a9eafcfbfdf7b98df1f838ba9af56695d7a4.json
 create mode 100644 packages/app-lib/.sqlx/query-a73b1547db507fc88dbeccb332af616424ecdb687b38fbbca4673ad5cdf24dd9.json
 create mode 100644 packages/app-lib/.sqlx/query-a90cef7f12500b65bb8a6ea070b0a21ad800b41f69deda4ac6f4c6ca87428a14.json
 create mode 100644 packages/app-lib/.sqlx/query-b9e21c3aa7ebb21db77c1b02a2274d295cfb808c03033e552928c3cf7347b6ad.json
 create mode 100644 packages/app-lib/.sqlx/query-c4f24e497f828d629498bc5c022da1f5c94fdf0db098072c4a138fe31932c370.json
 create mode 100644 packages/app-lib/.sqlx/query-d0620336091b153f01448417ca655a6a7c6dbad8f7975973e2614441301bec23.json
 create mode 100644 packages/app-lib/.sqlx/query-da27707b85df33ee2024216aa3df27e3ad2de43eebb2ee226497580d8ff69176.json
 create mode 100644 packages/app-lib/.sqlx/query-db7e6a3711ec75599be7b20ad31a4e314a4fc07eb8236f4bf35fd60db0605655.json
 create mode 100644 packages/app-lib/.sqlx/query-dc41f40aaad8fe8f379ca4b595127d6e5e2c586da9cdcde53614a33320837dac.json
 create mode 100644 packages/app-lib/.sqlx/query-e626908e7d94188472f78c82a286ccd5b0ea889166672fedb26811ebb324c62f.json
 create mode 100644 packages/app-lib/.sqlx/query-e6f5817e75f03035f327211cf7460b48b538e41dca1a1e850a03f8b95ad9a34a.json
 create mode 100644 packages/app-lib/.sqlx/query-fb55bb9d1e72cc4fa87ab6d851dc7a0bd79be3d5b0836676073dc56355f87bc0.json
 create mode 100644 packages/app-lib/.sqlx/query-fc91a68aaf7e6762d3bddbd4fe4e461b77671619a65fb809bd9b8ed9ab71baaa.json
 create mode 100644 packages/app-lib/src/api/instance/synced_options.rs
 create mode 100644 packages/app-lib/src/api/instance/synced_servers.rs
 create mode 100644 packages/ui/src/utils/ace-mode-mcfunction.ts

diff --git a/apps/app-frontend/src/App.vue b/apps/app-frontend/src/App.vue
index f6333d2a56..13737b1aa5 100644
--- a/apps/app-frontend/src/App.vue
+++ b/apps/app-frontend/src/App.vue
@@ -108,7 +108,12 @@ import { debugAnalytics, initAnalytics, trackEvent } from '@/helpers/analytics'
 import { check_reachable } from '@/helpers/auth.js'
 import { get_user, get_version } from '@/helpers/cache.js'
 import { install_create_modpack_instance, install_get_modpack_preview } from '@/helpers/install'
-import { can_current_user_use_shared_instances, get as getInstance, run } from '@/helpers/instance'
+import {
+	can_current_user_use_shared_instances,
+	get as getInstance,
+	get_global_synced_options,
+	run,
+} from '@/helpers/instance'
 import { get as getCreds, login, logout } from '@/helpers/mr_auth.ts'
 import { mergeUrlQuery, parseModrinthLink } from '@/helpers/project-links.ts'
 import { get as getSettings, set as setSettings } from '@/helpers/settings.ts'
@@ -419,6 +424,11 @@ const os = ref('')
 const isDevEnvironment = ref(false)
 
 const stateInitialized = ref(false)
+const globalSyncedOptionsQuery = useQuery({
+	queryKey: ['global-synced-options'],
+	queryFn: get_global_synced_options,
+	enabled: computed(() => stateInitialized.value),
+})
 
 const criticalErrorMessage = ref()
 
@@ -1717,7 +1727,11 @@ provideAppUpdateDownloadProgress(appUpdateDownload)
 			<NavButton v-tooltip.right="formatMessage(appMessages.skinSelectorLabel)" to="/skins">
 				<ShirtIcon />
 			</NavButton>
-			<NavButton v-tooltip.right="formatMessage(messages.screenshots)" to="/screenshots">
+			<NavButton
+				v-if="globalSyncedOptionsQuery.data.value?.screenshots"
+				v-tooltip.right="formatMessage(messages.screenshots)"
+				to="/screenshots"
+			>
 				<ImagesIcon />
 			</NavButton>
 			<NavButton
diff --git a/apps/app-frontend/src/components/ui/modal/AppSettingsModal.vue b/apps/app-frontend/src/components/ui/modal/AppSettingsModal.vue
index 90f4b25499..91d21e38d9 100644
--- a/apps/app-frontend/src/components/ui/modal/AppSettingsModal.vue
+++ b/apps/app-frontend/src/components/ui/modal/AppSettingsModal.vue
@@ -33,7 +33,7 @@ import AppearanceSettings from '@/components/ui/settings/display/AppearanceSetti
 import BehaviorSettings from '@/components/ui/settings/display/BehaviorSettings.vue'
 import FeatureFlagSettings from '@/components/ui/settings/display/FeatureFlagSettings.vue'
 import LanguageSettings from '@/components/ui/settings/display/LanguageSettings.vue'
-import DefaultInstanceSettings from '@/components/ui/settings/instances/DefaultInstanceSettings.vue'
+import InstancesSyncedSettings from '@/components/ui/settings/instances/InstancesSyncedSettings.vue'
 import JavaSettings from '@/components/ui/settings/instances/JavaSettings.vue'
 import ResourceManagementSettings from '@/components/ui/settings/instances/ResourceManagementSettings.vue'
 import { get, set } from '@/helpers/settings.ts'
@@ -130,12 +130,12 @@ const tabs = [
 	},
 	{
 		name: defineMessage({
-			id: 'app.settings.tabs.default-instance-options',
-			defaultMessage: 'Default game options',
+			id: 'app.settings.tabs.synced-options',
+			defaultMessage: 'Synced options',
 		}),
 		category: tabCategories.instances,
 		icon: GameIcon,
-		content: DefaultInstanceSettings,
+		content: InstancesSyncedSettings,
 	},
 	{
 		name: defineMessage({
diff --git a/apps/app-frontend/src/components/ui/settings/instances/DefaultInstanceSettings.vue b/apps/app-frontend/src/components/ui/settings/instances/DefaultInstanceSettings.vue
deleted file mode 100644
index e8b39a6def..0000000000
--- a/apps/app-frontend/src/components/ui/settings/instances/DefaultInstanceSettings.vue
+++ /dev/null
@@ -1,362 +0,0 @@
-<script setup lang="ts">
-import {
-	defineMessages,
-	injectNotificationManager,
-	Slider,
-	StyledInput,
-	Toggle,
-	useVIntl,
-} from '@modrinth/ui'
-import { ref, watch } from 'vue'
-
-import useMemorySlider from '@/composables/useMemorySlider'
-import { get, parseEnvVars, serializeEnvVars, set } from '@/helpers/settings.ts'
-
-const { handleError } = injectNotificationManager()
-const { formatMessage } = useVIntl()
-
-const messages = defineMessages({
-	fullscreenTitle: {
-		id: 'app.settings.default-instance-options.fullscreen.title',
-		defaultMessage: 'Fullscreen',
-	},
-	fullscreenDescription: {
-		id: 'app.settings.default-instance-options.fullscreen.description',
-		defaultMessage: 'Start instances in fullscreen by updating their options.txt file.',
-	},
-	widthTitle: {
-		id: 'app.settings.default-instance-options.width.title',
-		defaultMessage: 'Width',
-	},
-	widthDescription: {
-		id: 'app.settings.default-instance-options.width.description',
-		defaultMessage: 'The width of the game window when launched.',
-	},
-	widthPlaceholder: {
-		id: 'app.settings.default-instance-options.width.placeholder',
-		defaultMessage: 'Enter width...',
-	},
-	heightTitle: {
-		id: 'app.settings.default-instance-options.height.title',
-		defaultMessage: 'Height',
-	},
-	heightDescription: {
-		id: 'app.settings.default-instance-options.height.description',
-		defaultMessage: 'The height of the game window when launched.',
-	},
-	heightPlaceholder: {
-		id: 'app.settings.default-instance-options.height.placeholder',
-		defaultMessage: 'Enter height...',
-	},
-	memoryAllocationTitle: {
-		id: 'app.settings.default-instance-options.memory-allocation.title',
-		defaultMessage: 'Memory allocation',
-	},
-	memoryAllocationDescription: {
-		id: 'app.settings.default-instance-options.memory-allocation.description',
-		defaultMessage: 'Maximum memory available to each instance.',
-	},
-	javaArgumentsTitle: {
-		id: 'app.settings.default-instance-options.java-arguments.title',
-		defaultMessage: 'Java arguments',
-	},
-	javaArgumentsPlaceholder: {
-		id: 'app.settings.default-instance-options.java-arguments.placeholder',
-		defaultMessage: 'Enter Java arguments...',
-	},
-	javaArgumentsDescription: {
-		id: 'app.settings.default-instance-options.java-arguments.description',
-		defaultMessage: 'Arguments passed to Java when launching an instance.',
-	},
-	environmentVariablesTitle: {
-		id: 'app.settings.default-instance-options.environment-variables.title',
-		defaultMessage: 'Environment variables',
-	},
-	environmentVariablesPlaceholder: {
-		id: 'app.settings.default-instance-options.environment-variables.placeholder',
-		defaultMessage: 'Enter environment variables...',
-	},
-	environmentVariablesDescription: {
-		id: 'app.settings.default-instance-options.environment-variables.description',
-		defaultMessage: 'Environment variables set when launching an instance.',
-	},
-	preLaunchHookTitle: {
-		id: 'app.settings.default-instance-options.pre-launch-hook.title',
-		defaultMessage: 'Pre-launch hook',
-	},
-	preLaunchHookPlaceholder: {
-		id: 'app.settings.default-instance-options.pre-launch-hook.placeholder',
-		defaultMessage: 'Enter pre-launch command...',
-	},
-	preLaunchHookDescription: {
-		id: 'app.settings.default-instance-options.pre-launch-hook.description',
-		defaultMessage: 'Runs before the instance starts.',
-	},
-	wrapperHookTitle: {
-		id: 'app.settings.default-instance-options.wrapper-hook.title',
-		defaultMessage: 'Wrapper hook',
-	},
-	wrapperHookPlaceholder: {
-		id: 'app.settings.default-instance-options.wrapper-hook.placeholder',
-		defaultMessage: 'Enter wrapper command...',
-	},
-	wrapperHookDescription: {
-		id: 'app.settings.default-instance-options.wrapper-hook.description',
-		defaultMessage: 'Command used to wrap the Minecraft launch process.',
-	},
-	postExitHookTitle: {
-		id: 'app.settings.default-instance-options.post-exit-hook.title',
-		defaultMessage: 'Post-exit hook',
-	},
-	postExitHookPlaceholder: {
-		id: 'app.settings.default-instance-options.post-exit-hook.placeholder',
-		defaultMessage: 'Enter post-exit command...',
-	},
-	postExitHookDescription: {
-		id: 'app.settings.default-instance-options.post-exit-hook.description',
-		defaultMessage: 'Runs after the game closes.',
-	},
-	hookVariablesDescription: {
-		id: 'instance.settings.tabs.hooks.variables.description',
-		defaultMessage:
-			'Hooks run in the working directory of the instance, with the following variables:',
-	},
-	instanceNameDescription: {
-		id: 'instance.settings.tabs.hooks.variables.inst-name.description',
-		defaultMessage: '$INST_NAME: The name of the instance',
-	},
-	instanceIdDescription: {
-		id: 'instance.settings.tabs.hooks.variables.inst-id.description',
-		defaultMessage: "$INST_ID: The name of the instance's folder",
-	},
-	instanceDirDescription: {
-		id: 'instance.settings.tabs.hooks.variables.inst-dir.description',
-		defaultMessage: "$INST_DIR: The absolute path to the instance's folder",
-	},
-	instanceMcDirDescription: {
-		id: 'instance.settings.tabs.hooks.variables.inst-mc-dir.description',
-		defaultMessage: '$INST_MC_DIR: An alias for $INST_DIR',
-	},
-	instanceJavaDescription: {
-		id: 'instance.settings.tabs.hooks.variables.inst-java.description',
-		defaultMessage: '$INST_JAVA: The absolute path to the java binary',
-	},
-	instanceJavaArgsDescription: {
-		id: 'instance.settings.tabs.hooks.variables.inst-java-args.description',
-		defaultMessage: '$INST_JAVA_ARGS: The JVM Arguments provided to the game',
-	},
-})
-
-const fetchSettings = await get()
-fetchSettings.launchArgs = fetchSettings.extra_launch_args.join(' ')
-fetchSettings.envVars = serializeEnvVars(fetchSettings.custom_env_vars)
-
-const settings = ref(fetchSettings)
-
-const { maxMemory, snapPoints } = (await useMemorySlider().catch(handleError)) as unknown as {
-	maxMemory: number
-	snapPoints: number[]
-}
-
-watch(
-	settings,
-	async () => {
-		const setSettings = JSON.parse(JSON.stringify(settings.value))
-
-		setSettings.extra_launch_args = setSettings.launchArgs.trim().split(/\s+/).filter(Boolean)
-		setSettings.custom_env_vars = parseEnvVars(setSettings.envVars)
-		delete setSettings.launchArgs
-		delete setSettings.envVars
-
-		if (!setSettings.custom_dir) {
-			setSettings.custom_dir = null
-		}
-
-		await set(setSettings).catch(handleError)
-	},
-	{ deep: true },
-)
-</script>
-
-<template>
-	<div>
-		<div class="flex flex-col gap-6">
-			<div class="flex items-center justify-between gap-4">
-				<div class="flex flex-col gap-1">
-					<h3 class="m-0 text-lg font-semibold text-contrast">
-						{{ formatMessage(messages.fullscreenTitle) }}
-					</h3>
-					<p class="m-0 leading-tight">
-						{{ formatMessage(messages.fullscreenDescription) }}
-					</p>
-				</div>
-
-				<Toggle id="fullscreen" v-model="settings.force_fullscreen" />
-			</div>
-
-			<div class="flex items-center justify-between gap-4">
-				<div class="flex flex-col gap-1">
-					<h3 class="m-0 text-lg font-semibold text-contrast">
-						{{ formatMessage(messages.widthTitle) }}
-					</h3>
-					<p class="m-0 leading-tight">
-						{{ formatMessage(messages.widthDescription) }}
-					</p>
-				</div>
-
-				<StyledInput
-					id="width"
-					v-model="settings.game_resolution[0]"
-					:disabled="settings.force_fullscreen"
-					autocomplete="off"
-					type="number"
-					:placeholder="formatMessage(messages.widthPlaceholder)"
-				/>
-			</div>
-
-			<div class="flex items-center justify-between gap-4">
-				<div class="flex flex-col gap-1">
-					<h3 class="m-0 text-lg font-semibold text-contrast">
-						{{ formatMessage(messages.heightTitle) }}
-					</h3>
-					<p class="m-0 leading-tight">
-						{{ formatMessage(messages.heightDescription) }}
-					</p>
-				</div>
-
-				<StyledInput
-					id="height"
-					v-model="settings.game_resolution[1]"
-					:disabled="settings.force_fullscreen"
-					autocomplete="off"
-					type="number"
-					:placeholder="formatMessage(messages.heightPlaceholder)"
-				/>
-			</div>
-		</div>
-
-		<hr class="my-6 bg-button-border border-none h-[1px]" />
-
-		<div class="flex flex-col gap-6">
-			<div class="flex flex-col gap-2.5">
-				<h2 class="m-0 text-lg font-semibold text-contrast">
-					{{ formatMessage(messages.memoryAllocationTitle) }}
-				</h2>
-				<Slider
-					id="max-memory"
-					v-model="settings.memory.maximum"
-					:min="512"
-					:max="maxMemory"
-					:step="64"
-					:snap-points="snapPoints"
-					:snap-range="512"
-					unit="MB"
-				/>
-				<p class="m-0 mt-1 leading-tight">
-					{{ formatMessage(messages.memoryAllocationDescription) }}
-				</p>
-			</div>
-
-			<div class="flex flex-col gap-2.5">
-				<h2 class="m-0 text-lg font-semibold text-contrast">
-					{{ formatMessage(messages.javaArgumentsTitle) }}
-				</h2>
-				<StyledInput
-					id="java-args"
-					v-model="settings.launchArgs"
-					autocomplete="off"
-					type="text"
-					:placeholder="formatMessage(messages.javaArgumentsPlaceholder)"
-					wrapper-class="w-full"
-				/>
-				<p class="m-0 leading-tight">
-					{{ formatMessage(messages.javaArgumentsDescription) }}
-				</p>
-			</div>
-
-			<div class="flex flex-col gap-2.5">
-				<h2 class="m-0 text-lg font-semibold text-contrast">
-					{{ formatMessage(messages.environmentVariablesTitle) }}
-				</h2>
-				<StyledInput
-					id="env-vars"
-					v-model="settings.envVars"
-					autocomplete="off"
-					type="text"
-					:placeholder="formatMessage(messages.environmentVariablesPlaceholder)"
-					wrapper-class="w-full"
-				/>
-				<p class="m-0 leading-tight">
-					{{ formatMessage(messages.environmentVariablesDescription) }}
-				</p>
-			</div>
-		</div>
-
-		<hr class="my-6 bg-button-border border-none h-[1px]" />
-
-		<div class="flex flex-col gap-6">
-			<div class="flex flex-col gap-2.5">
-				<h3 class="m-0 text-lg font-semibold text-contrast">
-					{{ formatMessage(messages.preLaunchHookTitle) }}
-				</h3>
-				<StyledInput
-					id="pre-launch"
-					v-model="settings.hooks.pre_launch"
-					autocomplete="off"
-					type="text"
-					:placeholder="formatMessage(messages.preLaunchHookPlaceholder)"
-					wrapper-class="w-full"
-				/>
-				<p class="m-0 leading-tight">
-					{{ formatMessage(messages.preLaunchHookDescription) }}
-				</p>
-			</div>
-
-			<div class="flex flex-col gap-2.5">
-				<h3 class="m-0 text-lg font-semibold text-contrast">
-					{{ formatMessage(messages.wrapperHookTitle) }}
-				</h3>
-				<StyledInput
-					id="wrapper"
-					v-model="settings.hooks.wrapper"
-					autocomplete="off"
-					type="text"
-					:placeholder="formatMessage(messages.wrapperHookPlaceholder)"
-					wrapper-class="w-full"
-				/>
-				<p class="m-0 leading-tight">
-					{{ formatMessage(messages.wrapperHookDescription) }}
-				</p>
-			</div>
-
-			<div class="flex flex-col gap-2.5">
-				<h3 class="m-0 text-lg font-semibold text-contrast">
-					{{ formatMessage(messages.postExitHookTitle) }}
-				</h3>
-				<StyledInput
-					id="post-exit"
-					v-model="settings.hooks.post_exit"
-					autocomplete="off"
-					type="text"
-					:placeholder="formatMessage(messages.postExitHookPlaceholder)"
-					wrapper-class="w-full"
-				/>
-				<p class="m-0 leading-tight">
-					{{ formatMessage(messages.postExitHookDescription) }}
-				</p>
-			</div>
-
-			<div class="m-0 leading-tight">
-				{{ formatMessage(messages.hookVariablesDescription) }}
-				<ul>
-					<li>{{ formatMessage(messages.instanceNameDescription) }}</li>
-					<li>{{ formatMessage(messages.instanceIdDescription) }}</li>
-					<li>{{ formatMessage(messages.instanceDirDescription) }}</li>
-					<li>{{ formatMessage(messages.instanceMcDirDescription) }}</li>
-					<li>{{ formatMessage(messages.instanceJavaDescription) }}</li>
-					<li>{{ formatMessage(messages.instanceJavaArgsDescription) }}</li>
-				</ul>
-			</div>
-		</div>
-	</div>
-</template>
diff --git a/apps/app-frontend/src/components/ui/settings/instances/InstancesSyncedSettings.vue b/apps/app-frontend/src/components/ui/settings/instances/InstancesSyncedSettings.vue
new file mode 100644
index 0000000000..3a5169b146
--- /dev/null
+++ b/apps/app-frontend/src/components/ui/settings/instances/InstancesSyncedSettings.vue
@@ -0,0 +1,797 @@
+<script setup lang="ts">
+import { EditIcon, FolderOpenIcon, SaveIcon, TrashIcon, XIcon } from '@modrinth/assets'
+import {
+	Button,
+	commonMessages,
+	defineMessages,
+	IconButton,
+	injectNotificationManager,
+	NewModal,
+	Slider,
+	StyledInput,
+	Toggle,
+	useVIntl,
+} from '@modrinth/ui'
+import { useQueryClient } from '@tanstack/vue-query'
+import type { Component } from 'vue'
+import { ref, shallowRef, watch } from 'vue'
+
+import useMemorySlider from '@/composables/useMemorySlider'
+import {
+	get_command_history,
+	get_global_synced_options,
+	type GlobalSyncedOptions,
+	list as listInstances,
+	list_synced_servers,
+	open_synced_options_folder,
+	remove_synced_server,
+	set_command_history,
+	set_global_synced_option,
+	type SyncedOption,
+	type SyncedServer,
+	update_synced_server,
+} from '@/helpers/instance'
+import { get, parseEnvVars, serializeEnvVars, set } from '@/helpers/settings.ts'
+import { instanceKeys, screenshotKeys } from '@/pages/instance/query-options'
+
+const { handleError } = injectNotificationManager()
+const { formatMessage } = useVIntl()
+const queryClient = useQueryClient()
+
+const messages = defineMessages({
+	syncedDescription: {
+		id: 'app.settings.synced-options.description',
+		defaultMessage:
+			'Sync options and config across instances so you don’t have to set them up every time.',
+	},
+	syncedFolder: {
+		id: 'app.settings.synced-options.folder',
+		defaultMessage: 'Synced folder',
+	},
+	multiplayerServers: {
+		id: 'app.settings.synced-options.multiplayer-servers',
+		defaultMessage: 'Multiplayer servers',
+	},
+	commandHistory: {
+		id: 'app.settings.synced-options.command-history',
+		defaultMessage: 'Command history',
+	},
+	creativeHotbars: {
+		id: 'app.settings.synced-options.creative-hotbars',
+		defaultMessage: 'Saved creative hotbars',
+	},
+	screenshots: {
+		id: 'app.settings.synced-options.screenshots',
+		defaultMessage: 'Screenshots',
+	},
+	screenshotsDescription: {
+		id: 'app.settings.synced-options.screenshots.description',
+		defaultMessage: 'View screenshots from all your instances in one place.',
+	},
+	chooseBaseTitle: {
+		id: 'app.settings.synced-options.choose-base.title',
+		defaultMessage: 'Choose a base instance',
+	},
+	chooseBaseDescription: {
+		id: 'app.settings.synced-options.choose-base.description',
+		defaultMessage: 'The current data from this instance will become the initial synced version.',
+	},
+	baseInstance: {
+		id: 'app.settings.synced-options.choose-base.instance',
+		defaultMessage: 'Base instance',
+	},
+	enableSyncing: {
+		id: 'app.settings.synced-options.choose-base.enable',
+		defaultMessage: 'Enable syncing',
+	},
+	commandHistoryEditorTitle: {
+		id: 'app.settings.synced-options.command-history.editor-title',
+		defaultMessage: 'Edit command history',
+	},
+	serverEditorTitle: {
+		id: 'app.settings.synced-options.multiplayer-servers.editor-title',
+		defaultMessage: 'Edit synced servers',
+	},
+	serverName: {
+		id: 'app.settings.synced-options.multiplayer-servers.name',
+		defaultMessage: 'Server name',
+	},
+	serverAddress: {
+		id: 'app.settings.synced-options.multiplayer-servers.address',
+		defaultMessage: 'Server address',
+	},
+	noSyncedServers: {
+		id: 'app.settings.synced-options.multiplayer-servers.empty',
+		defaultMessage: 'No user-added servers are currently synced.',
+	},
+	noServersSyncedYet: {
+		id: 'app.settings.synced-options.multiplayer-servers.none-synced-yet',
+		defaultMessage: 'No servers synced yet',
+	},
+	fullscreenTitle: {
+		id: 'app.settings.default-instance-options.fullscreen.title',
+		defaultMessage: 'Fullscreen',
+	},
+	fullscreenDescription: {
+		id: 'app.settings.default-instance-options.fullscreen.description',
+		defaultMessage: 'Start instances in fullscreen by updating their options.txt file.',
+	},
+	widthTitle: {
+		id: 'app.settings.default-instance-options.width.title',
+		defaultMessage: 'Width',
+	},
+	widthDescription: {
+		id: 'app.settings.default-instance-options.width.description',
+		defaultMessage: 'The width of the game window when launched.',
+	},
+	widthPlaceholder: {
+		id: 'app.settings.default-instance-options.width.placeholder',
+		defaultMessage: 'Enter width...',
+	},
+	heightTitle: {
+		id: 'app.settings.default-instance-options.height.title',
+		defaultMessage: 'Height',
+	},
+	heightDescription: {
+		id: 'app.settings.default-instance-options.height.description',
+		defaultMessage: 'The height of the game window when launched.',
+	},
+	heightPlaceholder: {
+		id: 'app.settings.default-instance-options.height.placeholder',
+		defaultMessage: 'Enter height...',
+	},
+	memoryAllocationTitle: {
+		id: 'app.settings.default-instance-options.memory-allocation.title',
+		defaultMessage: 'Memory allocation',
+	},
+	memoryAllocationDescription: {
+		id: 'app.settings.default-instance-options.memory-allocation.description',
+		defaultMessage: 'Maximum memory available to each instance.',
+	},
+	javaArgumentsTitle: {
+		id: 'app.settings.default-instance-options.java-arguments.title',
+		defaultMessage: 'Java arguments',
+	},
+	javaArgumentsPlaceholder: {
+		id: 'app.settings.default-instance-options.java-arguments.placeholder',
+		defaultMessage: 'Enter Java arguments...',
+	},
+	javaArgumentsDescription: {
+		id: 'app.settings.default-instance-options.java-arguments.description',
+		defaultMessage: 'Arguments passed to Java when launching an instance.',
+	},
+	environmentVariablesTitle: {
+		id: 'app.settings.default-instance-options.environment-variables.title',
+		defaultMessage: 'Environment variables',
+	},
+	environmentVariablesPlaceholder: {
+		id: 'app.settings.default-instance-options.environment-variables.placeholder',
+		defaultMessage: 'Enter environment variables...',
+	},
+	environmentVariablesDescription: {
+		id: 'app.settings.default-instance-options.environment-variables.description',
+		defaultMessage: 'Environment variables set when launching an instance.',
+	},
+	preLaunchHookTitle: {
+		id: 'app.settings.default-instance-options.pre-launch-hook.title',
+		defaultMessage: 'Pre-launch hook',
+	},
+	preLaunchHookPlaceholder: {
+		id: 'app.settings.default-instance-options.pre-launch-hook.placeholder',
+		defaultMessage: 'Enter pre-launch command...',
+	},
+	preLaunchHookDescription: {
+		id: 'app.settings.default-instance-options.pre-launch-hook.description',
+		defaultMessage: 'Runs before the instance starts.',
+	},
+	wrapperHookTitle: {
+		id: 'app.settings.default-instance-options.wrapper-hook.title',
+		defaultMessage: 'Wrapper hook',
+	},
+	wrapperHookPlaceholder: {
+		id: 'app.settings.default-instance-options.wrapper-hook.placeholder',
+		defaultMessage: 'Enter wrapper command...',
+	},
+	wrapperHookDescription: {
+		id: 'app.settings.default-instance-options.wrapper-hook.description',
+		defaultMessage: 'Command used to wrap the Minecraft launch process.',
+	},
+	postExitHookTitle: {
+		id: 'app.settings.default-instance-options.post-exit-hook.title',
+		defaultMessage: 'Post-exit hook',
+	},
+	postExitHookPlaceholder: {
+		id: 'app.settings.default-instance-options.post-exit-hook.placeholder',
+		defaultMessage: 'Enter post-exit command...',
+	},
+	postExitHookDescription: {
+		id: 'app.settings.default-instance-options.post-exit-hook.description',
+		defaultMessage: 'Runs after the game closes.',
+	},
+	hookVariablesDescription: {
+		id: 'instance.settings.tabs.hooks.variables.description',
+		defaultMessage:
+			'Hooks run in the working directory of the instance, with the following variables:',
+	},
+	instanceNameDescription: {
+		id: 'instance.settings.tabs.hooks.variables.inst-name.description',
+		defaultMessage: '$INST_NAME: The name of the instance',
+	},
+	instanceIdDescription: {
+		id: 'instance.settings.tabs.hooks.variables.inst-id.description',
+		defaultMessage: "$INST_ID: The name of the instance's folder",
+	},
+	instanceDirDescription: {
+		id: 'instance.settings.tabs.hooks.variables.inst-dir.description',
+		defaultMessage: "$INST_DIR: The absolute path to the instance's folder",
+	},
+	instanceMcDirDescription: {
+		id: 'instance.settings.tabs.hooks.variables.inst-mc-dir.description',
+		defaultMessage: '$INST_MC_DIR: An alias for $INST_DIR',
+	},
+	instanceJavaDescription: {
+		id: 'instance.settings.tabs.hooks.variables.inst-java.description',
+		defaultMessage: '$INST_JAVA: The absolute path to the java binary',
+	},
+	instanceJavaArgsDescription: {
+		id: 'instance.settings.tabs.hooks.variables.inst-java-args.description',
+		defaultMessage: '$INST_JAVA_ARGS: The JVM Arguments provided to the game',
+	},
+})
+
+const globalRows: Array<{
+	option: SyncedOption
+	title: keyof typeof messages
+	description?: keyof typeof messages
+	editable?: 'servers' | 'commands'
+}> = [
+	{
+		option: 'multiplayer_servers',
+		title: 'multiplayerServers',
+		editable: 'servers',
+	},
+	{
+		option: 'command_history',
+		title: 'commandHistory',
+		editable: 'commands',
+	},
+	{
+		option: 'creative_hotbars',
+		title: 'creativeHotbars',
+	},
+	{
+		option: 'screenshots',
+		title: 'screenshots',
+		description: 'screenshotsDescription',
+	},
+]
+
+const globalOptions = ref<GlobalSyncedOptions>(
+	(await get_global_synced_options().catch(handleError)) ?? {
+		command_history: false,
+		multiplayer_servers: false,
+		creative_hotbars: false,
+		screenshots: false,
+	},
+)
+const instances = ref(await listInstances().catch(() => []))
+const pendingGlobalOption = ref<SyncedOption | null>(null)
+const baseOption = ref<SyncedOption | null>(null)
+const baseInstanceId = ref(instances.value[0]?.id ?? '')
+const baseModal = ref<InstanceType<typeof NewModal> | null>(null)
+const commandHistoryModal = ref<InstanceType<typeof NewModal> | null>(null)
+const serverEditorModal = ref<InstanceType<typeof NewModal> | null>(null)
+const commandHistory = ref('')
+const syncedServers = ref<SyncedServer[]>(
+	(await list_synced_servers().catch((error) => {
+		handleError(error)
+		return []
+	})) ?? [],
+)
+const editorComponent = shallowRef<Component | null>(null)
+
+async function invalidateSyncedOptions() {
+	await Promise.all([
+		queryClient.invalidateQueries({ queryKey: instanceKeys.all }),
+		queryClient.invalidateQueries({ queryKey: ['instance-synced-options'] }),
+		queryClient.invalidateQueries({ queryKey: ['global-synced-options'] }),
+		queryClient.invalidateQueries({ queryKey: screenshotKeys.all }),
+	])
+}
+
+async function applyGlobalOption(option: SyncedOption, enabled: boolean, baseId?: string) {
+	pendingGlobalOption.value = option
+	try {
+		globalOptions.value = await set_global_synced_option(option, enabled, baseId)
+		await invalidateSyncedOptions()
+	} catch (error) {
+		handleError(error)
+	} finally {
+		pendingGlobalOption.value = null
+	}
+}
+
+function toggleGlobalOption(option: SyncedOption, enabled: boolean) {
+	if (enabled && option !== 'screenshots') {
+		baseOption.value = option
+		baseInstanceId.value = instances.value[0]?.id ?? ''
+		baseModal.value?.show()
+		return
+	}
+	void applyGlobalOption(option, enabled)
+}
+
+async function confirmBaseInstance() {
+	if (!baseOption.value || !baseInstanceId.value) return
+	baseModal.value?.hide()
+	await applyGlobalOption(baseOption.value, true, baseInstanceId.value)
+}
+
+async function openCommandHistoryEditor() {
+	commandHistory.value = await get_command_history().catch((error) => {
+		handleError(error)
+		return ''
+	})
+	if (!editorComponent.value) {
+		const [editor] = await Promise.all([
+			import('vue3-ace-editor'),
+			import('@modrinth/ui/src/utils/ace-theme'),
+			import('@modrinth/ui/src/utils/ace-mode-mcfunction'),
+		])
+		editorComponent.value = editor.VAceEditor
+	}
+	commandHistoryModal.value?.show()
+}
+
+async function saveCommandHistory() {
+	try {
+		commandHistory.value = await set_command_history(commandHistory.value)
+		commandHistoryModal.value?.hide()
+	} catch (error) {
+		handleError(error)
+	}
+}
+
+async function openServerEditor() {
+	syncedServers.value = await list_synced_servers().catch((error) => {
+		handleError(error)
+		return []
+	})
+	serverEditorModal.value?.show()
+}
+
+async function saveSyncedServers() {
+	try {
+		for (const server of syncedServers.value) {
+			await update_synced_server(server)
+		}
+		serverEditorModal.value?.hide()
+		await queryClient.invalidateQueries({ queryKey: ['worlds'] })
+	} catch (error) {
+		handleError(error)
+	}
+}
+
+async function removeSyncedServer(serverId: string) {
+	try {
+		await remove_synced_server(serverId)
+		syncedServers.value = syncedServers.value.filter((server) => server.id !== serverId)
+		await queryClient.invalidateQueries({ queryKey: ['worlds'] })
+	} catch (error) {
+		handleError(error)
+	}
+}
+
+const fetchSettings = await get()
+fetchSettings.launchArgs = fetchSettings.extra_launch_args.join(' ')
+fetchSettings.envVars = serializeEnvVars(fetchSettings.custom_env_vars)
+
+const settings = ref(fetchSettings)
+
+const { maxMemory, snapPoints } = (await useMemorySlider().catch(handleError)) as unknown as {
+	maxMemory: number
+	snapPoints: number[]
+}
+
+watch(
+	settings,
+	async () => {
+		const setSettings = JSON.parse(JSON.stringify(settings.value))
+
+		setSettings.extra_launch_args = setSettings.launchArgs.trim().split(/\s+/).filter(Boolean)
+		setSettings.custom_env_vars = parseEnvVars(setSettings.envVars)
+		delete setSettings.launchArgs
+		delete setSettings.envVars
+
+		if (!setSettings.custom_dir) {
+			setSettings.custom_dir = null
+		}
+
+		await set(setSettings).catch(handleError)
+	},
+	{ deep: true },
+)
+</script>
+
+<template>
+	<div>
+		<NewModal ref="baseModal" :header="formatMessage(messages.chooseBaseTitle)" max-width="500px">
+			<div class="flex flex-col gap-4">
+				<p class="m-0 text-secondary">
+					{{ formatMessage(messages.chooseBaseDescription) }}
+				</p>
+				<label class="flex flex-col gap-2 font-semibold text-contrast">
+					{{ formatMessage(messages.baseInstance) }}
+					<select
+						v-model="baseInstanceId"
+						class="h-10 rounded-xl border border-solid border-button-border bg-button-bg px-3 text-contrast"
+					>
+						<option v-for="instance in instances" :key="instance.id" :value="instance.id">
+							{{ instance.name }} — {{ instance.game_version }}
+						</option>
+					</select>
+				</label>
+			</div>
+			<template #actions>
+				<div class="flex justify-end gap-2">
+					<Button type="outlined" @click="baseModal?.hide()">
+						<XIcon />
+						{{ formatMessage(commonMessages.cancelButton) }}
+					</Button>
+					<Button
+						type="colored"
+						color="brand"
+						:disabled="!baseInstanceId"
+						@click="confirmBaseInstance"
+					>
+						{{ formatMessage(messages.enableSyncing) }}
+					</Button>
+				</div>
+			</template>
+		</NewModal>
+
+		<NewModal
+			ref="commandHistoryModal"
+			:header="formatMessage(messages.commandHistoryEditorTitle)"
+			class="command-history-modal"
+			max-width="700px"
+			width="700px"
+		>
+			<component
+				:is="editorComponent"
+				v-if="editorComponent"
+				v-model:value="commandHistory"
+				lang="mcfunction"
+				theme="modrinth"
+				:print-margin="false"
+				class="command-history-editor ace-modrinth rounded-[20px] !border !border-solid !border-surface-5"
+				style="height: 420px; font-size: 0.875rem"
+			/>
+			<template #actions>
+				<div class="flex justify-end gap-2">
+					<Button type="outlined" @click="commandHistoryModal?.hide()">
+						<XIcon />
+						{{ formatMessage(commonMessages.cancelButton) }}
+					</Button>
+					<Button type="colored" color="brand" @click="saveCommandHistory">
+						<SaveIcon />
+						{{ formatMessage(commonMessages.saveButton) }}
+					</Button>
+				</div>
+			</template>
+		</NewModal>
+
+		<NewModal
+			ref="serverEditorModal"
+			:header="formatMessage(messages.serverEditorTitle)"
+			max-width="650px"
+			width="650px"
+		>
+			<p v-if="syncedServers.length === 0" class="m-0 text-secondary">
+				{{ formatMessage(messages.noSyncedServers) }}
+			</p>
+			<div v-else class="flex flex-col gap-4">
+				<div
+					v-for="server in syncedServers"
+					:key="server.id"
+					class="grid grid-cols-[1fr_1fr_auto] items-end gap-2"
+				>
+					<label class="flex min-w-0 flex-col gap-1 text-sm font-semibold text-contrast">
+						{{ formatMessage(messages.serverName) }}
+						<StyledInput v-model="server.name" autocomplete="off" />
+					</label>
+					<label class="flex min-w-0 flex-col gap-1 text-sm font-semibold text-contrast">
+						{{ formatMessage(messages.serverAddress) }}
+						<StyledInput v-model="server.address" autocomplete="off" />
+					</label>
+					<Button
+						v-tooltip="formatMessage(commonMessages.removeButton)"
+						type="outlined"
+						:aria-label="formatMessage(commonMessages.removeButton)"
+						@click="removeSyncedServer(server.id)"
+					>
+						<TrashIcon />
+					</Button>
+				</div>
+			</div>
+			<template #actions>
+				<div class="flex justify-end gap-2">
+					<Button type="outlined" @click="serverEditorModal?.hide()">
+						<XIcon />
+						{{ formatMessage(commonMessages.cancelButton) }}
+					</Button>
+					<Button type="colored" color="brand" @click="saveSyncedServers">
+						<SaveIcon />
+						{{ formatMessage(commonMessages.saveButton) }}
+					</Button>
+				</div>
+			</template>
+		</NewModal>
+
+		<div class="flex flex-col gap-6">
+			<div class="flex items-center justify-between gap-4">
+				<p class="m-0 text-secondary">{{ formatMessage(messages.syncedDescription) }}</p>
+				<Button @click="open_synced_options_folder().catch(handleError)">
+					<FolderOpenIcon />
+					{{ formatMessage(messages.syncedFolder) }}
+				</Button>
+			</div>
+
+			<div class="flex flex-col gap-4">
+				<div
+					v-for="row in globalRows"
+					:key="row.option"
+					class="flex items-center justify-between gap-6"
+				>
+					<div class="flex min-w-0 flex-col gap-1">
+						<h2 class="m-0 text-lg font-semibold text-contrast">
+							{{ formatMessage(messages[row.title]) }}
+						</h2>
+						<p v-if="row.description" class="m-0 text-secondary">
+							{{ formatMessage(messages[row.description]) }}
+						</p>
+					</div>
+					<div class="flex shrink-0 items-center gap-2">
+						<span
+							v-if="row.editable"
+							v-tooltip="
+								row.editable === 'servers' && syncedServers.length === 0
+									? formatMessage(messages.noServersSyncedYet)
+									: formatMessage(commonMessages.editButton)
+							"
+							class="flex"
+						>
+							<IconButton
+								type="outlined"
+								circular
+								:disabled="
+									!globalOptions[row.option] ||
+									(row.editable === 'servers' && syncedServers.length === 0)
+								"
+								:label="formatMessage(commonMessages.editButton)"
+								@click="
+									row.editable === 'commands' ? openCommandHistoryEditor() : openServerEditor()
+								"
+							>
+								<EditIcon />
+							</IconButton>
+						</span>
+						<Toggle
+							:id="`global-sync-${row.option}`"
+							:model-value="globalOptions[row.option]"
+							:disabled="pendingGlobalOption !== null"
+							@update:model-value="(enabled) => toggleGlobalOption(row.option, enabled)"
+						/>
+					</div>
+				</div>
+			</div>
+		</div>
+
+		<hr class="my-6 h-px border-none bg-button-border" />
+
+		<div class="flex flex-col gap-6">
+			<div class="flex items-center justify-between gap-4">
+				<div class="flex flex-col gap-1">
+					<h3 class="m-0 text-lg font-semibold text-contrast">
+						{{ formatMessage(messages.fullscreenTitle) }}
+					</h3>
+					<p class="m-0 leading-tight">
+						{{ formatMessage(messages.fullscreenDescription) }}
+					</p>
+				</div>
+
+				<Toggle id="fullscreen" v-model="settings.force_fullscreen" />
+			</div>
+
+			<div class="flex items-center justify-between gap-4">
+				<div class="flex flex-col gap-1">
+					<h3 class="m-0 text-lg font-semibold text-contrast">
+						{{ formatMessage(messages.widthTitle) }}
+					</h3>
+					<p class="m-0 leading-tight">
+						{{ formatMessage(messages.widthDescription) }}
+					</p>
+				</div>
+
+				<StyledInput
+					id="width"
+					v-model="settings.game_resolution[0]"
+					:disabled="settings.force_fullscreen"
+					autocomplete="off"
+					type="number"
+					:placeholder="formatMessage(messages.widthPlaceholder)"
+				/>
+			</div>
+
+			<div class="flex items-center justify-between gap-4">
+				<div class="flex flex-col gap-1">
+					<h3 class="m-0 text-lg font-semibold text-contrast">
+						{{ formatMessage(messages.heightTitle) }}
+					</h3>
+					<p class="m-0 leading-tight">
+						{{ formatMessage(messages.heightDescription) }}
+					</p>
+				</div>
+
+				<StyledInput
+					id="height"
+					v-model="settings.game_resolution[1]"
+					:disabled="settings.force_fullscreen"
+					autocomplete="off"
+					type="number"
+					:placeholder="formatMessage(messages.heightPlaceholder)"
+				/>
+			</div>
+		</div>
+
+		<hr class="my-6 bg-button-border border-none h-[1px]" />
+
+		<div class="flex flex-col gap-6">
+			<div class="flex flex-col gap-2.5">
+				<h2 class="m-0 text-lg font-semibold text-contrast">
+					{{ formatMessage(messages.memoryAllocationTitle) }}
+				</h2>
+				<Slider
+					id="max-memory"
+					v-model="settings.memory.maximum"
+					:min="512"
+					:max="maxMemory"
+					:step="64"
+					:snap-points="snapPoints"
+					:snap-range="512"
+					unit="MB"
+				/>
+				<p class="m-0 mt-1 leading-tight">
+					{{ formatMessage(messages.memoryAllocationDescription) }}
+				</p>
+			</div>
+
+			<div class="flex flex-col gap-2.5">
+				<h2 class="m-0 text-lg font-semibold text-contrast">
+					{{ formatMessage(messages.javaArgumentsTitle) }}
+				</h2>
+				<StyledInput
+					id="java-args"
+					v-model="settings.launchArgs"
+					autocomplete="off"
+					type="text"
+					:placeholder="formatMessage(messages.javaArgumentsPlaceholder)"
+					wrapper-class="w-full"
+				/>
+				<p class="m-0 leading-tight">
+					{{ formatMessage(messages.javaArgumentsDescription) }}
+				</p>
+			</div>
+
+			<div class="flex flex-col gap-2.5">
+				<h2 class="m-0 text-lg font-semibold text-contrast">
+					{{ formatMessage(messages.environmentVariablesTitle) }}
+				</h2>
+				<StyledInput
+					id="env-vars"
+					v-model="settings.envVars"
+					autocomplete="off"
+					type="text"
+					:placeholder="formatMessage(messages.environmentVariablesPlaceholder)"
+					wrapper-class="w-full"
+				/>
+				<p class="m-0 leading-tight">
+					{{ formatMessage(messages.environmentVariablesDescription) }}
+				</p>
+			</div>
+		</div>
+
+		<hr class="my-6 bg-button-border border-none h-[1px]" />
+
+		<div class="flex flex-col gap-6">
+			<div class="flex flex-col gap-2.5">
+				<h3 class="m-0 text-lg font-semibold text-contrast">
+					{{ formatMessage(messages.preLaunchHookTitle) }}
+				</h3>
+				<StyledInput
+					id="pre-launch"
+					v-model="settings.hooks.pre_launch"
+					autocomplete="off"
+					type="text"
+					:placeholder="formatMessage(messages.preLaunchHookPlaceholder)"
+					wrapper-class="w-full"
+				/>
+				<p class="m-0 leading-tight">
+					{{ formatMessage(messages.preLaunchHookDescription) }}
+				</p>
+			</div>
+
+			<div class="flex flex-col gap-2.5">
+				<h3 class="m-0 text-lg font-semibold text-contrast">
+					{{ formatMessage(messages.wrapperHookTitle) }}
+				</h3>
+				<StyledInput
+					id="wrapper"
+					v-model="settings.hooks.wrapper"
+					autocomplete="off"
+					type="text"
+					:placeholder="formatMessage(messages.wrapperHookPlaceholder)"
+					wrapper-class="w-full"
+				/>
+				<p class="m-0 leading-tight">
+					{{ formatMessage(messages.wrapperHookDescription) }}
+				</p>
+			</div>
+
+			<div class="flex flex-col gap-2.5">
+				<h3 class="m-0 text-lg font-semibold text-contrast">
+					{{ formatMessage(messages.postExitHookTitle) }}
+				</h3>
+				<StyledInput
+					id="post-exit"
+					v-model="settings.hooks.post_exit"
+					autocomplete="off"
+					type="text"
+					:placeholder="formatMessage(messages.postExitHookPlaceholder)"
+					wrapper-class="w-full"
+				/>
+				<p class="m-0 leading-tight">
+					{{ formatMessage(messages.postExitHookDescription) }}
+				</p>
+			</div>
+
+			<div class="m-0 leading-tight">
+				{{ formatMessage(messages.hookVariablesDescription) }}
+				<ul>
+					<li>{{ formatMessage(messages.instanceNameDescription) }}</li>
+					<li>{{ formatMessage(messages.instanceIdDescription) }}</li>
+					<li>{{ formatMessage(messages.instanceDirDescription) }}</li>
+					<li>{{ formatMessage(messages.instanceMcDirDescription) }}</li>
+					<li>{{ formatMessage(messages.instanceJavaDescription) }}</li>
+					<li>{{ formatMessage(messages.instanceJavaArgsDescription) }}</li>
+				</ul>
+			</div>
+		</div>
+	</div>
+</template>
+
+<style>
+.command-history-editor.ace-modrinth {
+	background-color: var(--surface-2);
+}
+
+.command-history-editor.ace-modrinth .ace_gutter {
+	background: var(--surface-1);
+}
+
+.command-history-editor.ace-modrinth .ace_marker-layer .ace_active-line {
+	background: var(--surface-2-5);
+}
+
+.command-history-editor.ace-modrinth .ace_gutter-active-line {
+	background-color: var(--surface-1-5);
+}
+
+.command-history-editor.ace-modrinth.ace_multiselect .ace_selection.ace_start {
+	box-shadow: 0 0 3px 0 var(--surface-2);
+}
+
+.command-history-modal > [data-modal-content] {
+	padding-bottom: 0;
+}
+</style>
diff --git a/apps/app-frontend/src/components/ui/world/WorldItem.vue b/apps/app-frontend/src/components/ui/world/WorldItem.vue
index 8147d0bce0..b1e1ebac41 100644
--- a/apps/app-frontend/src/components/ui/world/WorldItem.vue
+++ b/apps/app-frontend/src/components/ui/world/WorldItem.vue
@@ -66,7 +66,7 @@ const router = useRouter()
 const { addNotification } = injectNotificationManager()
 
 const emit = defineEmits<{
-	(e: 'play' | 'play-instance' | 'update' | 'stop' | 'refresh' | 'edit' | 'delete'): void
+	(e: 'play' | 'play-instance' | 'update' | 'stop' | 'refresh' | 'edit' | 'delete' | 'desync'): void
 	(e: 'open-folder', world: SingleplayerWorld): void
 }>()
 
@@ -217,6 +217,10 @@ const messages = defineMessages({
 		id: 'instance.worlds.copy_address',
 		defaultMessage: 'Copy address',
 	},
+	desync: {
+		id: 'instance.worlds.desync_server',
+		defaultMessage: 'Desync',
+	},
 	viewInstance: {
 		id: 'instance.worlds.view_instance',
 		defaultMessage: 'View instance',
@@ -500,6 +504,16 @@ const messages = defineMessages({
 							shown: world.type === 'server',
 							action: () => copyToClipboard((world as ServerWorld).address),
 						},
+						{
+							id: 'desync',
+							label: formatMessage(messages.desync),
+							action: () => emit('desync'),
+							shown:
+								!instanceId &&
+								world.type === 'server' &&
+								(world as ServerWorld).source === 'user_synced' &&
+								!!(world as ServerWorld).server_id,
+						},
 						{
 							id: 'edit',
 							label: formatMessage(commonMessages.editButton),
@@ -577,6 +591,10 @@ const messages = defineMessages({
 						<EditIcon aria-hidden="true" />
 						{{ formatMessage(commonMessages.editButton) }}
 					</template>
+					<template #desync>
+						<XIcon aria-hidden="true" />
+						{{ formatMessage(messages.desync) }}
+					</template>
 					<template #open-folder>
 						<FolderOpenIcon aria-hidden="true" />
 						{{ formatMessage(commonMessages.openFolderButton) }}
diff --git a/apps/app-frontend/src/components/ui/world/modal/DesyncServerModal.vue b/apps/app-frontend/src/components/ui/world/modal/DesyncServerModal.vue
new file mode 100644
index 0000000000..d78a55754e
--- /dev/null
+++ b/apps/app-frontend/src/components/ui/world/modal/DesyncServerModal.vue
@@ -0,0 +1,67 @@
+<script setup lang="ts">
+import { XIcon } from '@modrinth/assets'
+import { Button, commonMessages, defineMessages, NewModal, useVIntl } from '@modrinth/ui'
+import { ref } from 'vue'
+
+import type { DesyncServerMode, ServerWorld } from '@/helpers/worlds'
+
+const { formatMessage } = useVIntl()
+const modal = ref<InstanceType<typeof NewModal> | null>(null)
+const server = ref<ServerWorld | null>(null)
+
+const emit = defineEmits<{
+	confirm: [server: ServerWorld, mode: DesyncServerMode]
+}>()
+
+const messages = defineMessages({
+	title: {
+		id: 'instance.worlds.desync-server.title',
+		defaultMessage: 'Desync server',
+	},
+	description: {
+		id: 'instance.worlds.desync-server.description',
+		defaultMessage:
+			'Do you want to keep this server in other synced instances, or remove it from them?',
+	},
+	keep: {
+		id: 'instance.worlds.desync-server.keep',
+		defaultMessage: 'Keep in other instances',
+	},
+	remove: {
+		id: 'instance.worlds.desync-server.remove',
+		defaultMessage: 'Remove from other instances',
+	},
+})
+
+function show(value: ServerWorld) {
+	server.value = value
+	modal.value?.show()
+}
+
+function confirm(mode: DesyncServerMode) {
+	if (server.value) emit('confirm', server.value, mode)
+	modal.value?.hide()
+}
+
+defineExpose({ show })
+</script>
+
+<template>
+	<NewModal ref="modal" :header="formatMessage(messages.title)" max-width="540px">
+		<p class="m-0 text-secondary">{{ formatMessage(messages.description) }}</p>
+		<template #actions>
+			<div class="flex flex-wrap justify-end gap-2">
+				<Button type="outlined" @click="modal?.hide()">
+					<XIcon />
+					{{ formatMessage(commonMessages.cancelButton) }}
+				</Button>
+				<Button type="outlined" @click="confirm('keep_in_other_instances')">
+					{{ formatMessage(messages.keep) }}
+				</Button>
+				<Button type="colored" color="red" @click="confirm('remove_from_other_instances')">
+					{{ formatMessage(messages.remove) }}
+				</Button>
+			</div>
+		</template>
+	</NewModal>
+</template>
diff --git a/apps/app-frontend/src/helpers/instance.ts b/apps/app-frontend/src/helpers/instance.ts
index e99a179bfe..15b5d89e78 100644
--- a/apps/app-frontend/src/helpers/instance.ts
+++ b/apps/app-frontend/src/helpers/instance.ts
@@ -263,7 +263,7 @@ export async function open_screenshot(key: ScreenshotKey): Promise<void> {
 
 export async function set_synced_option(
 	instanceId: string,
-	option: 'screenshots',
+	option: SyncedOption,
 	enabled: boolean,
 ): Promise<GameInstance> {
 	return await invoke('plugin:instance|instance_set_synced_option', {
@@ -273,6 +273,82 @@ export async function set_synced_option(
 	})
 }
 
+export type SyncedOption =
+	| 'command_history'
+	| 'multiplayer_servers'
+	| 'creative_hotbars'
+	| 'screenshots'
+
+export type GlobalSyncedOptions = Record<SyncedOption, boolean>
+
+export type SyncedOptionCapability = {
+	option: SyncedOption
+	supported: boolean
+	disabled_reason?: string | null
+}
+
+export type SyncedOptionsOverview = {
+	global_options: GlobalSyncedOptions
+	capabilities: SyncedOptionCapability[]
+}
+
+export async function get_synced_options_overview(
+	instanceId: string,
+): Promise<SyncedOptionsOverview> {
+	return await invoke('plugin:instance|instance_get_synced_options_overview', { instanceId })
+}
+
+export async function get_global_synced_options(): Promise<GlobalSyncedOptions> {
+	return await invoke('plugin:instance|instance_get_global_synced_options')
+}
+
+export async function set_global_synced_option(
+	option: SyncedOption,
+	enabled: boolean,
+	baseInstanceId?: string,
+): Promise<GlobalSyncedOptions> {
+	return await invoke('plugin:instance|instance_set_global_synced_option', {
+		option,
+		enabled,
+		baseInstanceId,
+	})
+}
+
+export async function get_command_history(): Promise<string> {
+	return await invoke('plugin:instance|instance_get_command_history')
+}
+
+export async function set_command_history(contents: string): Promise<string> {
+	return await invoke('plugin:instance|instance_set_command_history', { contents })
+}
+
+export async function open_synced_options_folder(): Promise<void> {
+	return await invoke('plugin:instance|instance_open_synced_options_folder')
+}
+
+export type SyncedServer = {
+	id: string
+	name: string
+	address: string
+	accept_textures?: boolean | null
+}
+
+export async function list_synced_servers(): Promise<SyncedServer[]> {
+	return await invoke('plugin:instance|instance_list_synced_servers')
+}
+
+export async function update_synced_server(server: SyncedServer): Promise<void> {
+	return await invoke('plugin:instance|instance_update_synced_server', { server })
+}
+
+export async function remove_synced_server(serverId: string): Promise<void> {
+	return await invoke('plugin:instance|instance_remove_synced_server', { serverId })
+}
+
+export async function rebuild_synced_options(instanceId?: string): Promise<void> {
+	return await invoke('plugin:instance|instance_rebuild_synced_options', { instanceId })
+}
+
 export interface JavaVersion {
 	parsed_version: number
 	version: string
diff --git a/apps/app-frontend/src/helpers/types.d.ts b/apps/app-frontend/src/helpers/types.d.ts
index 388a6c939c..f5e39df150 100644
--- a/apps/app-frontend/src/helpers/types.d.ts
+++ b/apps/app-frontend/src/helpers/types.d.ts
@@ -17,6 +17,9 @@ export type GameInstance = {
 
 	group_ids: string[]
 	synced_options: {
+		command_history: boolean
+		multiplayer_servers: boolean
+		creative_hotbars: boolean
 		screenshots: boolean
 	}
 
diff --git a/apps/app-frontend/src/helpers/worlds.ts b/apps/app-frontend/src/helpers/worlds.ts
index 4403149c7a..62b59149e4 100644
--- a/apps/app-frontend/src/helpers/worlds.ts
+++ b/apps/app-frontend/src/helpers/worlds.ts
@@ -29,12 +29,18 @@ export type SingleplayerWorld = BaseWorld & {
 export type ServerWorld = BaseWorld & {
 	type: 'server'
 	index: number
+	server_id?: string
+	source?: ServerSource
 	address: string
 	pack_status: ServerPackStatus
 	project_id?: string
 	content_kind?: string
 }
 
+export type ServerSource = 'user_synced' | 'modpack' | 'linked_server_project' | 'local_desynced'
+
+export type DesyncServerMode = 'keep_in_other_instances' | 'remove_from_other_instances'
+
 export type World = SingleplayerWorld | ServerWorld
 
 export type WorldWithInstance = {
@@ -44,6 +50,14 @@ export type WorldWithInstance = {
 export type SingleplayerGameMode = 'survival' | 'creative' | 'adventure' | 'spectator'
 export type ServerPackStatus = 'enabled' | 'disabled' | 'prompt'
 
+export async function desync_server(
+	instanceId: string,
+	serverId: string,
+	mode: DesyncServerMode,
+): Promise<void> {
+	return await invoke('plugin:worlds|desync_server', { instanceId, serverId, mode })
+}
+
 export type ServerStatus = {
 	// https://minecraft.wiki/w/Text_component_format
 	description?: string | Chat
diff --git a/apps/app-frontend/src/locales/de-CH/index.json b/apps/app-frontend/src/locales/de-CH/index.json
index e55bad3b8d..5642240e61 100644
--- a/apps/app-frontend/src/locales/de-CH/index.json
+++ b/apps/app-frontend/src/locales/de-CH/index.json
@@ -980,9 +980,6 @@
   "app.settings.tabs.behavior": {
     "message": "Verhalten"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "Standard-Spieloptionen"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Java Installationen"
   },
diff --git a/apps/app-frontend/src/locales/de-DE/index.json b/apps/app-frontend/src/locales/de-DE/index.json
index 043b4e6eb8..b6de1dcdf6 100644
--- a/apps/app-frontend/src/locales/de-DE/index.json
+++ b/apps/app-frontend/src/locales/de-DE/index.json
@@ -980,9 +980,6 @@
   "app.settings.tabs.behavior": {
     "message": "Verhalten"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "Standard-Spieloptionen"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Java-Installationen"
   },
diff --git a/apps/app-frontend/src/locales/en-US/index.json b/apps/app-frontend/src/locales/en-US/index.json
index bc4d94f144..2de1d8d3a7 100644
--- a/apps/app-frontend/src/locales/en-US/index.json
+++ b/apps/app-frontend/src/locales/en-US/index.json
@@ -1655,15 +1655,60 @@
   "app.settings.sidebar.label.instances": {
     "message": "Instances"
   },
+  "app.settings.synced-options.choose-base.description": {
+    "message": "The current data from this instance will become the initial synced version."
+  },
+  "app.settings.synced-options.choose-base.enable": {
+    "message": "Enable syncing"
+  },
+  "app.settings.synced-options.choose-base.instance": {
+    "message": "Base instance"
+  },
+  "app.settings.synced-options.choose-base.title": {
+    "message": "Choose a base instance"
+  },
+  "app.settings.synced-options.command-history": {
+    "message": "Command history"
+  },
+  "app.settings.synced-options.command-history.editor-title": {
+    "message": "Edit command history"
+  },
+  "app.settings.synced-options.creative-hotbars": {
+    "message": "Saved creative hotbars"
+  },
+  "app.settings.synced-options.description": {
+    "message": "Sync options and config across instances so you don’t have to set them up every time."
+  },
+  "app.settings.synced-options.folder": {
+    "message": "Synced folder"
+  },
+  "app.settings.synced-options.multiplayer-servers": {
+    "message": "Multiplayer servers"
+  },
+  "app.settings.synced-options.multiplayer-servers.address": {
+    "message": "Server address"
+  },
+  "app.settings.synced-options.multiplayer-servers.editor-title": {
+    "message": "Edit synced servers"
+  },
+  "app.settings.synced-options.multiplayer-servers.empty": {
+    "message": "No user-added servers are currently synced."
+  },
+  "app.settings.synced-options.multiplayer-servers.name": {
+    "message": "Server name"
+  },
+  "app.settings.synced-options.screenshots": {
+    "message": "Screenshots"
+  },
+  "app.settings.synced-options.screenshots.description": {
+    "message": "View screenshots from all your instances in one place."
+  },
   "app.settings.tabs.appearance": {
     "message": "Appearance"
   },
   "app.settings.tabs.behavior": {
     "message": "Behavior"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "Default game options"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Java installations"
   },
@@ -1676,6 +1721,9 @@
   "app.settings.tabs.resource-management": {
     "message": "Resource management"
   },
+  "app.settings.tabs.synced-options": {
+    "message": "Synced options"
+  },
   "app.sidebar.playing-as": {
     "message": "Playing as"
   },
@@ -2588,14 +2636,32 @@
   "instance.settings.tabs.synced-options": {
     "message": "Synced options"
   },
+  "instance.settings.tabs.synced-options.command-history": {
+    "message": "Command history"
+  },
+  "instance.settings.tabs.synced-options.command-history.description": {
+    "message": "Share the latest commands entered in Minecraft."
+  },
+  "instance.settings.tabs.synced-options.creative-hotbars": {
+    "message": "Saved creative hotbars"
+  },
+  "instance.settings.tabs.synced-options.creative-hotbars.description": {
+    "message": "Share saved creative-mode toolbar slots across compatible versions."
+  },
   "instance.settings.tabs.synced-options.description": {
-    "message": "Choose which content from this instance appears across the app."
+    "message": "Override synced options for this instance."
+  },
+  "instance.settings.tabs.synced-options.multiplayer-servers": {
+    "message": "Multiplayer servers"
+  },
+  "instance.settings.tabs.synced-options.multiplayer-servers.description": {
+    "message": "Keep user-added multiplayer servers consistent across instances."
   },
   "instance.settings.tabs.synced-options.screenshots": {
     "message": "Screenshots"
   },
   "instance.settings.tabs.synced-options.screenshots.description": {
-    "message": "Show screenshots from this instance in the global Screenshots page. Turn this off to use an instance-only Screenshots tab."
+    "message": "Show screenshots from this instance in the global Screenshots page."
   },
   "instance.settings.tabs.window": {
     "message": "Window"
@@ -2696,6 +2762,21 @@
   "instance.worlds.create_shortcut": {
     "message": "Create shortcut"
   },
+  "instance.worlds.desync-server.description": {
+    "message": "Do you want to keep this server in other synced instances, or remove it from them?"
+  },
+  "instance.worlds.desync-server.keep": {
+    "message": "Keep in other instances"
+  },
+  "instance.worlds.desync-server.remove": {
+    "message": "Remove from other instances"
+  },
+  "instance.worlds.desync-server.title": {
+    "message": "Desync server"
+  },
+  "instance.worlds.desync_server": {
+    "message": "Desync"
+  },
   "instance.worlds.dont_show_on_home": {
     "message": "Don't show on Home"
   },
diff --git a/apps/app-frontend/src/locales/es-419/index.json b/apps/app-frontend/src/locales/es-419/index.json
index 44c5f555c0..bcea119d51 100644
--- a/apps/app-frontend/src/locales/es-419/index.json
+++ b/apps/app-frontend/src/locales/es-419/index.json
@@ -980,9 +980,6 @@
   "app.settings.tabs.behavior": {
     "message": "Comportamiento"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "Opciones por defecto del juego"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Instalaciones de Java"
   },
diff --git a/apps/app-frontend/src/locales/fr-FR/index.json b/apps/app-frontend/src/locales/fr-FR/index.json
index 4ffb047de4..017fac693d 100644
--- a/apps/app-frontend/src/locales/fr-FR/index.json
+++ b/apps/app-frontend/src/locales/fr-FR/index.json
@@ -980,9 +980,6 @@
   "app.settings.tabs.behavior": {
     "message": "Comportement"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "Options de jeu par défaut"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Installations de Java"
   },
diff --git a/apps/app-frontend/src/locales/hu-HU/index.json b/apps/app-frontend/src/locales/hu-HU/index.json
index e947d24768..091f2e3b08 100644
--- a/apps/app-frontend/src/locales/hu-HU/index.json
+++ b/apps/app-frontend/src/locales/hu-HU/index.json
@@ -980,9 +980,6 @@
   "app.settings.tabs.behavior": {
     "message": "Működés"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "A játék alapbeállításai"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Telepített Java példányok"
   },
diff --git a/apps/app-frontend/src/locales/it-IT/index.json b/apps/app-frontend/src/locales/it-IT/index.json
index 57d902ac9c..cd27d068c1 100644
--- a/apps/app-frontend/src/locales/it-IT/index.json
+++ b/apps/app-frontend/src/locales/it-IT/index.json
@@ -977,9 +977,6 @@
   "app.settings.tabs.behavior": {
     "message": "Comportamento"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "Opzioni di gioco predefinite"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Installazioni Java"
   },
diff --git a/apps/app-frontend/src/locales/ja-JP/index.json b/apps/app-frontend/src/locales/ja-JP/index.json
index b999c783bc..6cdff2632e 100644
--- a/apps/app-frontend/src/locales/ja-JP/index.json
+++ b/apps/app-frontend/src/locales/ja-JP/index.json
@@ -980,9 +980,6 @@
   "app.settings.tabs.behavior": {
     "message": "動作"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "デフォルトのゲーム設定"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Javaのインストール設定"
   },
diff --git a/apps/app-frontend/src/locales/ko-KR/index.json b/apps/app-frontend/src/locales/ko-KR/index.json
index 525248e3b2..301561779f 100644
--- a/apps/app-frontend/src/locales/ko-KR/index.json
+++ b/apps/app-frontend/src/locales/ko-KR/index.json
@@ -977,9 +977,6 @@
   "app.settings.tabs.behavior": {
     "message": "동작"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "기본 게임 옵션"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Java 설치"
   },
diff --git a/apps/app-frontend/src/locales/nl-NL/index.json b/apps/app-frontend/src/locales/nl-NL/index.json
index fc67b5ff57..53fc33c5f7 100644
--- a/apps/app-frontend/src/locales/nl-NL/index.json
+++ b/apps/app-frontend/src/locales/nl-NL/index.json
@@ -980,9 +980,6 @@
   "app.settings.tabs.behavior": {
     "message": "Gedrag"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "Standaard spelopties"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Java installaties"
   },
diff --git a/apps/app-frontend/src/locales/pl-PL/index.json b/apps/app-frontend/src/locales/pl-PL/index.json
index 7e1bd4bae1..251fe16d10 100644
--- a/apps/app-frontend/src/locales/pl-PL/index.json
+++ b/apps/app-frontend/src/locales/pl-PL/index.json
@@ -866,9 +866,6 @@
   "app.settings.tabs.behavior": {
     "message": "Zachowanie"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "Domyślne opcje gry"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Instalacje Java"
   },
diff --git a/apps/app-frontend/src/locales/pt-BR/index.json b/apps/app-frontend/src/locales/pt-BR/index.json
index 4d3959f58e..bfa5bbf68c 100644
--- a/apps/app-frontend/src/locales/pt-BR/index.json
+++ b/apps/app-frontend/src/locales/pt-BR/index.json
@@ -980,9 +980,6 @@
   "app.settings.tabs.behavior": {
     "message": "Comportamento"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "Configurações padrão do jogo"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Instalações Java"
   },
diff --git a/apps/app-frontend/src/locales/ru-RU/index.json b/apps/app-frontend/src/locales/ru-RU/index.json
index 6fd2a36fbf..fa26b68c10 100644
--- a/apps/app-frontend/src/locales/ru-RU/index.json
+++ b/apps/app-frontend/src/locales/ru-RU/index.json
@@ -971,9 +971,6 @@
   "app.settings.tabs.behavior": {
     "message": "Поведение"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "Предустановки игры"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Расположение Java"
   },
diff --git a/apps/app-frontend/src/locales/sv-SE/index.json b/apps/app-frontend/src/locales/sv-SE/index.json
index bddb1feab2..69384ad458 100644
--- a/apps/app-frontend/src/locales/sv-SE/index.json
+++ b/apps/app-frontend/src/locales/sv-SE/index.json
@@ -875,9 +875,6 @@
   "app.settings.tabs.behavior": {
     "message": "Beteende"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "Standard spelinställningar"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Java-installationer"
   },
diff --git a/apps/app-frontend/src/locales/uk-UA/index.json b/apps/app-frontend/src/locales/uk-UA/index.json
index f2f02758b7..e3aebd7941 100644
--- a/apps/app-frontend/src/locales/uk-UA/index.json
+++ b/apps/app-frontend/src/locales/uk-UA/index.json
@@ -980,9 +980,6 @@
   "app.settings.tabs.behavior": {
     "message": "Поведінка"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "Стандартні параметри гри"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Інсталяції Java"
   },
diff --git a/apps/app-frontend/src/locales/zh-CN/index.json b/apps/app-frontend/src/locales/zh-CN/index.json
index ac83dc137a..7d540af580 100644
--- a/apps/app-frontend/src/locales/zh-CN/index.json
+++ b/apps/app-frontend/src/locales/zh-CN/index.json
@@ -980,9 +980,6 @@
   "app.settings.tabs.behavior": {
     "message": "行为"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "默认游戏选项"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Java 管理"
   },
diff --git a/apps/app-frontend/src/locales/zh-TW/index.json b/apps/app-frontend/src/locales/zh-TW/index.json
index bd4d82f1ca..4cf5054939 100644
--- a/apps/app-frontend/src/locales/zh-TW/index.json
+++ b/apps/app-frontend/src/locales/zh-TW/index.json
@@ -980,9 +980,6 @@
   "app.settings.tabs.behavior": {
     "message": "行為"
   },
-  "app.settings.tabs.default-instance-options": {
-    "message": "預設遊戲選項"
-  },
   "app.settings.tabs.java-installations": {
     "message": "Java 安裝"
   },
diff --git a/apps/app-frontend/src/pages/instance/components/settings-modal/hooks-settings.vue b/apps/app-frontend/src/pages/instance/components/settings-modal/hooks-settings.vue
index 86e08ba3a8..a7275e47b6 100644
--- a/apps/app-frontend/src/pages/instance/components/settings-modal/hooks-settings.vue
+++ b/apps/app-frontend/src/pages/instance/components/settings-modal/hooks-settings.vue
@@ -1,9 +1,9 @@
 <script setup lang="ts">
 import {
-	Checkbox,
 	defineMessages,
 	injectNotificationManager,
 	StyledInput,
+	Toggle,
 	useVIntl,
 } from '@modrinth/ui'
 import { computed, ref, watch } from 'vue'
@@ -21,12 +21,12 @@ const { instance } = injectInstanceSettings()
 
 const globalSettings = (await get().catch(handleError)) as AppSettings
 
-const overrideHooks = ref(
+const hasCustomHooks =
 	!!instance.value.hooks.pre_launch ||
-		!!instance.value.hooks.wrapper ||
-		!!instance.value.hooks.post_exit,
-)
-const hooksRaw = instance.value.hooks ?? globalSettings.hooks
+	!!instance.value.hooks.wrapper ||
+	!!instance.value.hooks.post_exit
+const overrideHooks = ref(hasCustomHooks)
+const hooksRaw = hasCustomHooks ? instance.value.hooks : globalSettings.hooks
 const hooks = ref({
 	pre_launch: hooksRaw.pre_launch ?? '',
 	wrapper: hooksRaw.wrapper ?? '',
@@ -93,10 +93,6 @@ const messages = defineMessages({
 		id: 'instance.settings.tabs.hooks.variables.inst-java-args.description',
 		defaultMessage: '$INST_JAVA_ARGS: The JVM Arguments provided to the game',
 	},
-	customHooks: {
-		id: 'instance.settings.tabs.hooks.custom-hooks',
-		defaultMessage: 'Custom launch hooks',
-	},
 	preLaunch: {
 		id: 'instance.settings.tabs.hooks.pre-launch',
 		defaultMessage: 'Pre-launch',
@@ -138,69 +134,70 @@ const messages = defineMessages({
 
 <template>
 	<div>
-		<h2 class="m-0 m-0 text-lg font-semibold text-contrast">
-			{{ formatMessage(messages.hooks) }}
-		</h2>
-		<Checkbox v-model="overrideHooks" :label="formatMessage(messages.customHooks)" class="my-2.5" />
-		<p class="m-0">
-			{{ formatMessage(messages.hooksDescription) }}
-		</p>
+		<div class="flex items-center justify-between gap-4">
+			<div class="flex min-w-0 flex-col gap-1">
+				<h2 class="m-0 text-lg font-semibold text-contrast">
+					{{ formatMessage(messages.hooks) }}
+				</h2>
+				<p class="m-0">{{ formatMessage(messages.hooksDescription) }}</p>
+			</div>
+			<Toggle id="override-launch-hooks" v-model="overrideHooks" />
+		</div>
 
-		<h2 class="mt-6 m-0 text-lg font-semibold text-contrast">
-			{{ formatMessage(messages.preLaunch) }}
-		</h2>
-		<StyledInput
-			id="pre-launch"
-			v-model="hooks.pre_launch"
-			autocomplete="off"
-			:disabled="!overrideHooks"
-			:placeholder="formatMessage(messages.preLaunchEnter)"
-			wrapper-class="w-full my-2.5"
-		/>
-		<p class="m-0">
-			{{ formatMessage(messages.preLaunchDescription) }}
-		</p>
+		<div v-if="overrideHooks">
+			<h2 class="mt-6 m-0 text-lg font-semibold text-contrast">
+				{{ formatMessage(messages.preLaunch) }}
+			</h2>
+			<StyledInput
+				id="pre-launch"
+				v-model="hooks.pre_launch"
+				autocomplete="off"
+				:placeholder="formatMessage(messages.preLaunchEnter)"
+				wrapper-class="w-full my-2.5"
+			/>
+			<p class="m-0">
+				{{ formatMessage(messages.preLaunchDescription) }}
+			</p>
 
-		<h2 class="mt-6 m-0 text-lg font-semibold text-contrast">
-			{{ formatMessage(messages.wrapper) }}
-		</h2>
-		<StyledInput
-			id="wrapper"
-			v-model="hooks.wrapper"
-			autocomplete="off"
-			:disabled="!overrideHooks"
-			:placeholder="formatMessage(messages.wrapperEnter)"
-			wrapper-class="w-full my-2.5"
-		/>
-		<p class="m-0">
-			{{ formatMessage(messages.wrapperDescription) }}
-		</p>
+			<h2 class="mt-6 m-0 text-lg font-semibold text-contrast">
+				{{ formatMessage(messages.wrapper) }}
+			</h2>
+			<StyledInput
+				id="wrapper"
+				v-model="hooks.wrapper"
+				autocomplete="off"
+				:placeholder="formatMessage(messages.wrapperEnter)"
+				wrapper-class="w-full my-2.5"
+			/>
+			<p class="m-0">
+				{{ formatMessage(messages.wrapperDescription) }}
+			</p>
 
-		<h2 class="mt-6 m-0 text-lg font-semibold text-contrast">
-			{{ formatMessage(messages.postExit) }}
-		</h2>
-		<StyledInput
-			id="post-exit"
-			v-model="hooks.post_exit"
-			autocomplete="off"
-			:disabled="!overrideHooks"
-			:placeholder="formatMessage(messages.postExitEnter)"
-			wrapper-class="w-full my-2.5"
-		/>
-		<p class="m-0">
-			{{ formatMessage(messages.postExitDescription) }}
-		</p>
+			<h2 class="mt-6 m-0 text-lg font-semibold text-contrast">
+				{{ formatMessage(messages.postExit) }}
+			</h2>
+			<StyledInput
+				id="post-exit"
+				v-model="hooks.post_exit"
+				autocomplete="off"
+				:placeholder="formatMessage(messages.postExitEnter)"
+				wrapper-class="w-full my-2.5"
+			/>
+			<p class="m-0">
+				{{ formatMessage(messages.postExitDescription) }}
+			</p>
 
-		<div class="m-0 mt-6">
-			{{ formatMessage(messages.hookVariablesDescription) }}
+			<div class="m-0 mt-6">
+				{{ formatMessage(messages.hookVariablesDescription) }}
+			</div>
+			<ul class="m-0 mt-2">
+				<li>{{ formatMessage(messages.instanceNameDescription) }}</li>
+				<li>{{ formatMessage(messages.instanceIdDescription) }}</li>
+				<li>{{ formatMessage(messages.instanceDirDescription) }}</li>
+				<li>{{ formatMessage(messages.instanceMcDirDescription) }}</li>
+				<li>{{ formatMessage(messages.instanceJavaDescription) }}</li>
+				<li>{{ formatMessage(messages.instanceJavaArgsDescription) }}</li>
+			</ul>
 		</div>
-		<ul class="m-0 mt-2">
-			<li>{{ formatMessage(messages.instanceNameDescription) }}</li>
-			<li>{{ formatMessage(messages.instanceIdDescription) }}</li>
-			<li>{{ formatMessage(messages.instanceDirDescription) }}</li>
-			<li>{{ formatMessage(messages.instanceMcDirDescription) }}</li>
-			<li>{{ formatMessage(messages.instanceJavaDescription) }}</li>
-			<li>{{ formatMessage(messages.instanceJavaArgsDescription) }}</li>
-		</ul>
 	</div>
 </template>
diff --git a/apps/app-frontend/src/pages/instance/components/settings-modal/index.vue b/apps/app-frontend/src/pages/instance/components/settings-modal/index.vue
index 4890ef0250..855b63c2b9 100644
--- a/apps/app-frontend/src/pages/instance/components/settings-modal/index.vue
+++ b/apps/app-frontend/src/pages/instance/components/settings-modal/index.vue
@@ -2,10 +2,7 @@
 import type { Labrinth } from '@modrinth/api-client'
 import {
 	ChevronRightIcon,
-	CodeIcon,
-	CoffeeIcon,
 	InfoIcon,
-	MonitorIcon,
 	RefreshCwIcon,
 	UsersIcon,
 	WrenchIcon,
@@ -29,13 +26,10 @@ import { get_game_versions, get_loaders } from '@/helpers/tags'
 import type { GameInstance } from '@/helpers/types'
 
 import GeneralSettings from './general-settings.vue'
-import HooksSettings from './hooks-settings.vue'
 import InstallationSettings from './installation-settings.vue'
 import { provideInstanceSettings } from './instance-settings-context.ts'
-import JavaSettings from './java-settings.vue'
 import SharingSettings from './sharing-settings.vue'
 import SyncedOptionsSettings from './synced-options-settings.vue'
-import WindowSettings from './window-settings.vue'
 
 const { formatMessage } = useVIntl()
 const queryClient = useQueryClient()
@@ -117,30 +111,6 @@ const tabs = computed<TabbedModalTab[]>(() => [
 		content: SharingSettings,
 		shown: props.instance.shared_instance?.role === 'owner' && !props.instance.quarantined,
 	},
-	{
-		name: defineMessage({
-			id: 'instance.settings.tabs.window',
-			defaultMessage: 'Window',
-		}),
-		icon: MonitorIcon,
-		content: WindowSettings,
-	},
-	{
-		name: defineMessage({
-			id: 'instance.settings.tabs.java',
-			defaultMessage: 'Java and memory',
-		}),
-		icon: CoffeeIcon,
-		content: JavaSettings,
-	},
-	{
-		name: defineMessage({
-			id: 'instance.settings.tabs.hooks',
-			defaultMessage: 'Launch hooks',
-		}),
-		icon: CodeIcon,
-		content: HooksSettings,
-	},
 ])
 
 function getSupportedModpackLoaders() {
diff --git a/apps/app-frontend/src/pages/instance/components/settings-modal/java-settings.vue b/apps/app-frontend/src/pages/instance/components/settings-modal/java-settings.vue
index 3c1786ac06..150875c2a2 100644
--- a/apps/app-frontend/src/pages/instance/components/settings-modal/java-settings.vue
+++ b/apps/app-frontend/src/pages/instance/components/settings-modal/java-settings.vue
@@ -10,11 +10,11 @@ import {
 } from '@modrinth/assets'
 import {
 	Button,
-	Checkbox,
 	defineMessages,
 	injectNotificationManager,
 	Slider,
 	StyledInput,
+	Toggle,
 	useVIntl,
 } from '@modrinth/ui'
 import { open } from '@tauri-apps/plugin-dialog'
@@ -41,9 +41,7 @@ const optimalJava = readonly(await get_optimal_jre_key(instance.value.id).catch(
 const overrideJavaInstall = ref(!!instance.value.java_path)
 const javaPath = ref(instance.value.java_path ?? optimalJava?.path ?? '')
 
-const activePath = computed(() =>
-	overrideJavaInstall.value ? javaPath.value : (optimalJava?.path ?? ''),
-)
+const activePath = computed(() => (overrideJavaInstall.value ? javaPath.value : ''))
 
 watch(overrideJavaInstall, (enabled) => {
 	if (enabled && !javaPath.value) {
@@ -186,144 +184,162 @@ const messages = defineMessages({
 </script>
 
 <template>
-	<div>
+	<div class="flex flex-col gap-6">
 		<JavaDetectionModal ref="javaDetectionModal" @submit="(val) => (javaPath = val.path)" />
-		<h2 class="m-0 mb-2 text-lg font-extrabold text-contrast block">
-			{{ formatMessage(messages.javaInstallation) }}
-		</h2>
-		<Checkbox
-			v-model="overrideJavaInstall"
-			:label="formatMessage(messages.customJavaInstallation)"
-			class="mb-2"
-		/>
-		<div class="flex gap-4 p-4 bg-bg rounded-2xl">
-			<div class="flex gap-3 items-start flex-1 min-w-0">
-				<div
-					class="w-10 h-10 flex items-center justify-center rounded-full bg-button-bg border-solid border-[1px] border-button-border p-2 mt-1 shrink-0 [&_svg]:h-full [&_svg]:w-full"
-				>
-					<CoffeeIcon />
+
+		<section class="flex flex-col gap-3">
+			<div class="flex items-center justify-between gap-4">
+				<div class="flex min-w-0 flex-col gap-1">
+					<h2 class="m-0 text-lg font-semibold text-contrast">
+						{{ formatMessage(messages.javaInstallation) }}
+					</h2>
+					<p class="m-0">{{ formatMessage(messages.customJavaInstallation) }}</p>
 				</div>
-				<div class="flex flex-col gap-2 flex-1 min-w-0">
-					<span class="font-semibold leading-none mt-2"
-						>Java {{ optimalJava?.parsed_version }}</span
+				<Toggle id="override-java-installation" v-model="overrideJavaInstall" />
+			</div>
+			<div v-if="overrideJavaInstall" class="flex gap-4 rounded-2xl bg-bg p-4">
+				<div class="flex gap-3 items-start flex-1 min-w-0">
+					<div
+						class="w-10 h-10 flex items-center justify-center rounded-full bg-button-bg border-solid border-[1px] border-button-border p-2 mt-1 shrink-0 [&_svg]:h-full [&_svg]:w-full"
 					>
-					<div class="flex gap-2 items-center">
-						<StyledInput
-							:model-value="activePath"
-							:disabled="!overrideJavaInstall"
-							autocomplete="off"
-							:placeholder="formatMessage(messages.javaPathPlaceholder)"
-							wrapper-class="flex-1 min-w-0"
-							@update:model-value="(val) => (javaPath = String(val))"
-						/>
-						<Button
-							type="quiet"
-							:color="
-								!hoveringTest && !testingJava
-									? javaTestResult === true
-										? 'green'
-										: 'red'
-									: undefined
-							"
-							:disabled="!overrideJavaInstall || testingJava"
-							:style="{
-								'--legacy-button-color':
-									(!hoveringTest && !testingJava
-										? javaTestResult === true
-											? 'green'
-											: 'red'
-										: 'standard') &&
-									(!hoveringTest && !testingJava
+						<CoffeeIcon />
+					</div>
+					<div class="flex flex-col gap-2 flex-1 min-w-0">
+						<span class="font-semibold leading-none mt-2"
+							>Java {{ optimalJava?.parsed_version }}</span
+						>
+						<div class="flex gap-2 items-center">
+							<StyledInput
+								:model-value="activePath"
+								autocomplete="off"
+								:placeholder="formatMessage(messages.javaPathPlaceholder)"
+								wrapper-class="flex-1 min-w-0"
+								@update:model-value="(val) => (javaPath = String(val))"
+							/>
+							<Button
+								type="quiet"
+								:color="
+									!hoveringTest && !testingJava
 										? javaTestResult === true
 											? 'green'
 											: 'red'
-										: 'standard') !== 'standard'
-										? `var(--color-${
-												!hoveringTest && !testingJava
-													? javaTestResult === true
-														? 'green'
-														: 'red'
-													: 'standard'
-											})`
-										: undefined,
-							}"
-							class="!text-[var(--legacy-button-color,var(--color-base))] [&>svg]:!text-[var(--legacy-button-color,var(--color-primary))]"
-							@click="testJavaInstallation(activePath, optimalJava?.parsed_version, true)"
-							@mouseenter="overrideJavaInstall && (hoveringTest = true)"
-							@mouseleave="hoveringTest = false"
-						>
-							<SpinnerIcon v-if="testingJava" class="animate-spin h-4 w-4" />
-							<CheckCircleIcon
-								v-else-if="javaTestResult === true && !hoveringTest"
-								class="h-4 w-4"
-							/>
-							<XCircleIcon v-else-if="javaTestResult !== true && !hoveringTest" class="h-4 w-4" />
-							<RefreshCwIcon v-else-if="overrideJavaInstall" class="h-4 w-4" />
-						</Button>
-					</div>
-					<div v-if="overrideJavaInstall" class="flex gap-2">
-						<Button @click="handleDetectJava">
-							<SearchIcon />
-							Detect
-						</Button>
-						<Button @click="handleBrowseJava">
-							<FolderSearchIcon />
-							Browse
-						</Button>
+										: undefined
+								"
+								:disabled="testingJava"
+								:style="{
+									'--legacy-button-color':
+										(!hoveringTest && !testingJava
+											? javaTestResult === true
+												? 'green'
+												: 'red'
+											: 'standard') &&
+										(!hoveringTest && !testingJava
+											? javaTestResult === true
+												? 'green'
+												: 'red'
+											: 'standard') !== 'standard'
+											? `var(--color-${
+													!hoveringTest && !testingJava
+														? javaTestResult === true
+															? 'green'
+															: 'red'
+														: 'standard'
+												})`
+											: undefined,
+								}"
+								class="!text-[var(--legacy-button-color,var(--color-base))] [&>svg]:!text-[var(--legacy-button-color,var(--color-primary))]"
+								@click="testJavaInstallation(activePath, optimalJava?.parsed_version, true)"
+								@mouseenter="hoveringTest = true"
+								@mouseleave="hoveringTest = false"
+							>
+								<SpinnerIcon v-if="testingJava" class="animate-spin h-4 w-4" />
+								<CheckCircleIcon
+									v-else-if="javaTestResult === true && !hoveringTest"
+									class="h-4 w-4"
+								/>
+								<XCircleIcon
+									v-else-if="javaTestResult !== true && !hoveringTest"
+									class="h-4 w-4"
+								/>
+								<RefreshCwIcon v-else class="h-4 w-4" />
+							</Button>
+						</div>
+						<div class="flex gap-2">
+							<Button @click="handleDetectJava">
+								<SearchIcon />
+								Detect
+							</Button>
+							<Button @click="handleBrowseJava">
+								<FolderSearchIcon />
+								Browse
+							</Button>
+						</div>
 					</div>
 				</div>
 			</div>
-		</div>
-		<h2 class="mt-4 mb-1 text-lg font-extrabold text-contrast block">
-			{{ formatMessage(messages.javaMemory) }}
-		</h2>
-		<Checkbox
-			v-model="overrideMemorySettings"
-			:label="formatMessage(messages.customMemoryAllocation)"
-			class="mb-2"
-		/>
-		<Slider
-			id="max-memory"
-			v-model="memory.maximum"
-			:disabled="!overrideMemorySettings"
-			:min="512"
-			:max="maxMemory"
-			:step="64"
-			:snap-points="snapPoints"
-			:snap-range="512"
-			unit="MB"
-		/>
-		<h2 class="mt-4 mb-1 text-lg font-extrabold text-contrast block">
-			{{ formatMessage(messages.javaArguments) }}
-		</h2>
-		<Checkbox
-			v-model="overrideJavaArgs"
-			:label="formatMessage(messages.customJavaArguments)"
-			class="my-2"
-		/>
-		<StyledInput
-			id="java-args"
-			v-model="javaArgs"
-			autocomplete="off"
-			:disabled="!overrideJavaArgs"
-			:placeholder="formatMessage(messages.enterJavaArguments)"
-			wrapper-class="w-full"
-		/>
-		<h2 class="mt-4 mb-1 text-lg font-extrabold text-contrast block">
-			{{ formatMessage(messages.javaEnvironmentVariables) }}
-		</h2>
-		<Checkbox
-			v-model="overrideEnvVars"
-			:label="formatMessage(messages.customEnvironmentVariables)"
-			class="mb-2"
-		/>
-		<StyledInput
-			id="env-vars"
-			v-model="envVars"
-			autocomplete="off"
-			:disabled="!overrideEnvVars"
-			:placeholder="formatMessage(messages.enterEnvironmentVariables)"
-			wrapper-class="w-full"
-		/>
+		</section>
+
+		<section class="flex flex-col gap-3">
+			<div class="flex items-center justify-between gap-4">
+				<div class="flex min-w-0 flex-col gap-1">
+					<h2 class="m-0 text-lg font-semibold text-contrast">
+						{{ formatMessage(messages.javaMemory) }}
+					</h2>
+					<p class="m-0">{{ formatMessage(messages.customMemoryAllocation) }}</p>
+				</div>
+				<Toggle id="override-memory-allocation" v-model="overrideMemorySettings" />
+			</div>
+			<Slider
+				v-if="overrideMemorySettings"
+				id="max-memory"
+				v-model="memory.maximum"
+				:min="512"
+				:max="maxMemory"
+				:step="64"
+				:snap-points="snapPoints"
+				:snap-range="512"
+				unit="MB"
+			/>
+		</section>
+
+		<section class="flex flex-col gap-3">
+			<div class="flex items-center justify-between gap-4">
+				<div class="flex min-w-0 flex-col gap-1">
+					<h2 class="m-0 text-lg font-semibold text-contrast">
+						{{ formatMessage(messages.javaArguments) }}
+					</h2>
+					<p class="m-0">{{ formatMessage(messages.customJavaArguments) }}</p>
+				</div>
+				<Toggle id="override-java-arguments" v-model="overrideJavaArgs" />
+			</div>
+			<StyledInput
+				v-if="overrideJavaArgs"
+				id="java-args"
+				v-model="javaArgs"
+				autocomplete="off"
+				:placeholder="formatMessage(messages.enterJavaArguments)"
+				wrapper-class="w-full"
+			/>
+		</section>
+
+		<section class="flex flex-col gap-3">
+			<div class="flex items-center justify-between gap-4">
+				<div class="flex min-w-0 flex-col gap-1">
+					<h2 class="m-0 text-lg font-semibold text-contrast">
+						{{ formatMessage(messages.javaEnvironmentVariables) }}
+					</h2>
+					<p class="m-0">{{ formatMessage(messages.customEnvironmentVariables) }}</p>
+				</div>
+				<Toggle id="override-environment-variables" v-model="overrideEnvVars" />
+			</div>
+			<StyledInput
+				v-if="overrideEnvVars"
+				id="env-vars"
+				v-model="envVars"
+				autocomplete="off"
+				:placeholder="formatMessage(messages.enterEnvironmentVariables)"
+				wrapper-class="w-full"
+			/>
+		</section>
 	</div>
 </template>
diff --git a/apps/app-frontend/src/pages/instance/components/settings-modal/synced-options-settings.vue b/apps/app-frontend/src/pages/instance/components/settings-modal/synced-options-settings.vue
index d73f413fd8..999743b182 100644
--- a/apps/app-frontend/src/pages/instance/components/settings-modal/synced-options-settings.vue
+++ b/apps/app-frontend/src/pages/instance/components/settings-modal/synced-options-settings.vue
@@ -1,14 +1,22 @@
 <script setup lang="ts">
 import { SpinnerIcon } from '@modrinth/assets'
 import { defineMessages, injectNotificationManager, Toggle, useVIntl } from '@modrinth/ui'
-import { useMutation, useQueryClient } from '@tanstack/vue-query'
+import { useMutation, useQuery, useQueryClient } from '@tanstack/vue-query'
+import { computed } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
 
-import { set_synced_option } from '@/helpers/instance'
+import {
+	get_synced_options_overview,
+	set_synced_option,
+	type SyncedOption,
+} from '@/helpers/instance'
 import type { GameInstance } from '@/helpers/types'
 
 import { instanceKeys, screenshotKeys } from '../../query-options'
+import HooksSettings from './hooks-settings.vue'
 import { injectInstanceSettings } from './instance-settings-context'
+import JavaSettings from './java-settings.vue'
+import WindowSettings from './window-settings.vue'
 
 const { instance } = injectInstanceSettings()
 const { formatMessage } = useVIntl()
@@ -20,7 +28,20 @@ const router = useRouter()
 const messages = defineMessages({
 	description: {
 		id: 'instance.settings.tabs.synced-options.description',
-		defaultMessage: 'Choose which content from this instance appears across the app.',
+		defaultMessage:
+			'Sync this instance’s options and config with other instances so you don’t have to set them up every time.',
+	},
+	multiplayerServers: {
+		id: 'instance.settings.tabs.synced-options.multiplayer-servers',
+		defaultMessage: 'Multiplayer servers',
+	},
+	commandHistory: {
+		id: 'instance.settings.tabs.synced-options.command-history',
+		defaultMessage: 'Command history',
+	},
+	creativeHotbars: {
+		id: 'instance.settings.tabs.synced-options.creative-hotbars',
+		defaultMessage: 'Saved creative hotbars',
 	},
 	screenshots: {
 		id: 'instance.settings.tabs.synced-options.screenshots',
@@ -28,24 +49,76 @@ const messages = defineMessages({
 	},
 	screenshotsDescription: {
 		id: 'instance.settings.tabs.synced-options.screenshots.description',
-		defaultMessage:
-			'Show screenshots from this instance in the global Screenshots page. Turn this off to use an instance-only Screenshots tab.',
+		defaultMessage: 'View this instance’s screenshots alongside all your others.',
 	},
 })
 
+const rows: Array<{
+	option: SyncedOption
+	title: keyof typeof messages
+	description?: keyof typeof messages
+}> = [
+	{
+		option: 'multiplayer_servers',
+		title: 'multiplayerServers',
+	},
+	{
+		option: 'command_history',
+		title: 'commandHistory',
+	},
+	{
+		option: 'creative_hotbars',
+		title: 'creativeHotbars',
+	},
+	{
+		option: 'screenshots',
+		title: 'screenshots',
+		description: 'screenshotsDescription',
+	},
+]
+
+const overviewQuery = useQuery(
+	computed(() => ({
+		queryKey: ['instance-synced-options', instance.value.id],
+		queryFn: () => get_synced_options_overview(instance.value.id),
+	})),
+)
+
+const capabilities = computed(
+	() =>
+		new Map(
+			overviewQuery.data.value?.capabilities.map((capability) => [capability.option, capability]) ??
+				[],
+		),
+)
+
+function enabled(option: SyncedOption): boolean {
+	return instance.value.synced_options[option]
+}
+
+function disabledReason(option: SyncedOption): string | undefined {
+	return capabilities.value.get(option)?.disabled_reason ?? undefined
+}
+
 const mutation = useMutation({
-	mutationFn: (enabled: boolean) => set_synced_option(instance.value.id, 'screenshots', enabled),
-	onSuccess: async (updatedInstance) => {
+	mutationFn: ({ option, enabled }: { option: SyncedOption; enabled: boolean }) =>
+		set_synced_option(instance.value.id, option, enabled),
+	onSuccess: async (updatedInstance, variables) => {
 		queryClient.setQueryData(instanceKeys.detail(updatedInstance.id), updatedInstance)
 		queryClient.setQueryData<GameInstance[]>(instanceKeys.list(), (instances) =>
 			instances?.map((candidate) =>
 				candidate.id === updatedInstance.id ? updatedInstance : candidate,
 			),
 		)
-		await queryClient.invalidateQueries({ queryKey: screenshotKeys.all })
+		await queryClient.invalidateQueries({
+			queryKey: ['instance-synced-options', updatedInstance.id],
+		})
 
-		if (updatedInstance.synced_options.screenshots && route.name === 'InstanceScreenshots') {
-			await router.replace(`/instance/${encodeURIComponent(updatedInstance.id)}`)
+		if (variables.option === 'screenshots') {
+			await queryClient.invalidateQueries({ queryKey: screenshotKeys.all })
+			if (variables.enabled && route.name === 'InstanceScreenshots') {
+				await router.replace(`/instance/${encodeURIComponent(updatedInstance.id)}`)
+			}
 		}
 	},
 	onError: handleError,
@@ -55,24 +128,47 @@ const mutation = useMutation({
 <template>
 	<div class="flex flex-col gap-6">
 		<p class="m-0 text-secondary">{{ formatMessage(messages.description) }}</p>
-		<div class="flex items-center justify-between gap-6">
-			<div class="flex min-w-0 flex-col gap-1">
-				<h2 class="m-0 text-lg font-semibold text-contrast">
-					{{ formatMessage(messages.screenshots) }}
-				</h2>
-				<p class="m-0 text-secondary">
-					{{ formatMessage(messages.screenshotsDescription) }}
-				</p>
-			</div>
-			<div class="flex shrink-0 items-center gap-2">
-				<SpinnerIcon v-if="mutation.isPending.value" class="size-5 animate-spin" />
-				<Toggle
-					id="sync-screenshots"
-					:model-value="instance.synced_options.screenshots"
-					:disabled="mutation.isPending.value"
-					@update:model-value="mutation.mutate"
-				/>
+		<div class="flex flex-col gap-4">
+			<div v-for="row in rows" :key="row.option" class="flex items-center justify-between gap-6">
+				<div class="flex min-w-0 flex-col gap-1">
+					<h2 class="m-0 text-lg font-semibold text-contrast">
+						{{ formatMessage(messages[row.title]) }}
+					</h2>
+					<p v-if="row.description" class="m-0 text-secondary">
+						{{ formatMessage(messages[row.description]) }}
+					</p>
+				</div>
+				<div class="flex shrink-0 items-center gap-2">
+					<SpinnerIcon
+						v-if="mutation.isPending.value && mutation.variables.value?.option === row.option"
+						class="size-5 animate-spin"
+					/>
+					<span v-tooltip="disabledReason(row.option)" class="flex">
+						<Toggle
+							:id="`sync-${row.option}`"
+							:model-value="enabled(row.option)"
+							:disabled="
+								mutation.isPending.value ||
+								overviewQuery.isPending.value ||
+								!!disabledReason(row.option)
+							"
+							@update:model-value="(next) => mutation.mutate({ option: row.option, enabled: next })"
+						/>
+					</span>
+				</div>
 			</div>
 		</div>
+
+		<hr class="m-0 h-px border-none bg-button-border" />
+
+		<WindowSettings />
+
+		<hr class="m-0 h-px border-none bg-button-border" />
+
+		<JavaSettings />
+
+		<hr class="m-0 h-px border-none bg-button-border" />
+
+		<HooksSettings />
 	</div>
 </template>
diff --git a/apps/app-frontend/src/pages/instance/components/settings-modal/window-settings.vue b/apps/app-frontend/src/pages/instance/components/settings-modal/window-settings.vue
index 5e6a662366..0caf7f5754 100644
--- a/apps/app-frontend/src/pages/instance/components/settings-modal/window-settings.vue
+++ b/apps/app-frontend/src/pages/instance/components/settings-modal/window-settings.vue
@@ -1,6 +1,5 @@
 <script setup lang="ts">
 import {
-	Checkbox,
 	defineMessages,
 	injectNotificationManager,
 	StyledInput,
@@ -54,6 +53,10 @@ watch(
 )
 
 const messages = defineMessages({
+	window: {
+		id: 'instance.settings.tabs.window',
+		defaultMessage: 'Window',
+	},
 	customWindowSettings: {
 		id: 'instance.settings.tabs.window.custom-window-settings',
 		defaultMessage: 'Custom window settings',
@@ -95,67 +98,65 @@ const messages = defineMessages({
 
 <template>
 	<div class="flex flex-col gap-6">
-		<Checkbox
-			v-model="overrideWindowSettings"
-			:label="formatMessage(messages.customWindowSettings)"
-		/>
-		<div class="flex items-center gap-4 justify-between">
-			<div class="flex flex-col gap-1">
+		<div class="flex items-center justify-between gap-4">
+			<div class="flex min-w-0 flex-col gap-1">
 				<h2 class="m-0 text-lg font-semibold text-contrast">
-					{{ formatMessage(messages.fullscreen) }}
+					{{ formatMessage(messages.window) }}
 				</h2>
-				<p class="m-0">
-					{{ formatMessage(messages.fullscreenDescription) }}
-				</p>
+				<p class="m-0">{{ formatMessage(messages.customWindowSettings) }}</p>
 			</div>
-			<Toggle
-				id="fullscreen"
-				:model-value="overrideWindowSettings ? fullscreenSetting : globalSettings.force_fullscreen"
-				:disabled="!overrideWindowSettings"
-				@update:model-value="
-					(e) => {
-						fullscreenSetting = e
-					}
-				"
-			/>
+			<Toggle id="override-window-settings" v-model="overrideWindowSettings" />
 		</div>
+		<div v-if="overrideWindowSettings" class="flex flex-col gap-6">
+			<div class="flex items-center gap-4 justify-between">
+				<div class="flex flex-col gap-1">
+					<h2 class="m-0 text-lg font-semibold text-contrast">
+						{{ formatMessage(messages.fullscreen) }}
+					</h2>
+					<p class="m-0">
+						{{ formatMessage(messages.fullscreenDescription) }}
+					</p>
+				</div>
+				<Toggle id="fullscreen" v-model="fullscreenSetting" />
+			</div>
 
-		<div class="flex items-center gap-4 justify-between">
-			<div class="flex flex-col gap-1">
-				<h2 class="m-0 text-lg font-semibold text-contrast">
-					{{ formatMessage(messages.width) }}
-				</h2>
-				<p class="m-0">
-					{{ formatMessage(messages.widthDescription) }}
-				</p>
+			<div class="flex items-center gap-4 justify-between">
+				<div class="flex flex-col gap-1">
+					<h2 class="m-0 text-lg font-semibold text-contrast">
+						{{ formatMessage(messages.width) }}
+					</h2>
+					<p class="m-0">
+						{{ formatMessage(messages.widthDescription) }}
+					</p>
+				</div>
+				<StyledInput
+					id="width"
+					v-model="resolution[0]"
+					autocomplete="off"
+					:disabled="fullscreenSetting"
+					type="number"
+					:placeholder="formatMessage(messages.enterWidth)"
+				/>
 			</div>
-			<StyledInput
-				id="width"
-				v-model="resolution[0]"
-				autocomplete="off"
-				:disabled="!overrideWindowSettings || fullscreenSetting"
-				type="number"
-				:placeholder="formatMessage(messages.enterWidth)"
-			/>
-		</div>
 
-		<div class="flex items-center gap-4 justify-between">
-			<div class="flex flex-col gap-1">
-				<h2 class="m-0 text-lg font-semibold text-contrast">
-					{{ formatMessage(messages.height) }}
-				</h2>
-				<p class="m-0">
-					{{ formatMessage(messages.heightDescription) }}
-				</p>
+			<div class="flex items-center gap-4 justify-between">
+				<div class="flex flex-col gap-1">
+					<h2 class="m-0 text-lg font-semibold text-contrast">
+						{{ formatMessage(messages.height) }}
+					</h2>
+					<p class="m-0">
+						{{ formatMessage(messages.heightDescription) }}
+					</p>
+				</div>
+				<StyledInput
+					id="height"
+					v-model="resolution[1]"
+					autocomplete="off"
+					:disabled="fullscreenSetting"
+					type="number"
+					:placeholder="formatMessage(messages.enterHeight)"
+				/>
 			</div>
-			<StyledInput
-				id="height"
-				v-model="resolution[1]"
-				autocomplete="off"
-				:disabled="!overrideWindowSettings || fullscreenSetting"
-				type="number"
-				:placeholder="formatMessage(messages.enterHeight)"
-			/>
 		</div>
 	</div>
 </template>
diff --git a/apps/app-frontend/src/pages/instance/worlds/index.vue b/apps/app-frontend/src/pages/instance/worlds/index.vue
index 3539b608ca..2cd54642da 100644
--- a/apps/app-frontend/src/pages/instance/worlds/index.vue
+++ b/apps/app-frontend/src/pages/instance/worlds/index.vue
@@ -18,6 +18,7 @@
 		:world="worldToRemove"
 		@confirm="proceedRemoveWorld"
 	/>
+	<DesyncServerModal ref="desyncServerModal" @confirm="confirmDesyncServer" />
 	<ReadyTransition :pending="worldsReadyPending">
 		<div v-if="dedupedWorlds.length > 0" class="flex flex-col gap-4">
 			<div class="flex flex-wrap items-center gap-2">
@@ -108,6 +109,7 @@
 									: editServerModal?.show(world)
 					"
 					@delete="() => !isManagedServerWorld(world) && promptToRemoveWorld(world)"
+					@desync="() => world.type === 'server' && desyncServerModal?.show(world as ServerWorld)"
 					@open-folder="(world: SingleplayerWorld) => showWorldInFolder(instance.id, world.path)"
 				/>
 			</div>
@@ -153,6 +155,7 @@ import { useRoute } from 'vue-router'
 
 import AddServerModal from '@/components/ui/world/modal/AddServerModal.vue'
 import ConfirmRemoveWorldModal from '@/components/ui/world/modal/ConfirmRemoveWorldModal.vue'
+import DesyncServerModal from '@/components/ui/world/modal/DesyncServerModal.vue'
 import EditServerModal from '@/components/ui/world/modal/EditServerModal.vue'
 import EditWorldModal from '@/components/ui/world/modal/EditSingleplayerWorldModal.vue'
 import WorldItem from '@/components/ui/world/WorldItem.vue'
@@ -163,6 +166,8 @@ import { get_game_versions } from '@/helpers/tags'
 import { ensureManagedServerWorldExists, getServerAddress } from '@/helpers/worlds'
 import {
 	delete_world,
+	desync_server,
+	type DesyncServerMode,
 	get_instance_protocol_version,
 	getServerDomainKey,
 	getWorldIdentifier,
@@ -244,6 +249,7 @@ const addServerModal = ref<InstanceType<typeof AddServerModal>>()
 const editServerModal = ref<InstanceType<typeof EditServerModal>>()
 const editWorldModal = ref<InstanceType<typeof EditWorldModal>>()
 const removeWorldModal = ref<InstanceType<typeof ConfirmRemoveWorldModal>>()
+const desyncServerModal = ref<InstanceType<typeof DesyncServerModal>>()
 
 const worldToRemove = ref<World | null>(null)
 
@@ -507,6 +513,12 @@ async function removeServer(server: ServerWorld) {
 	}
 }
 
+async function confirmDesyncServer(server: ServerWorld, mode: DesyncServerMode) {
+	if (!server.server_id) return
+	await desync_server(instance.value.id, server.server_id, mode).catch(handleError)
+	await refreshAllWorlds()
+}
+
 async function editWorld(path: string, name: string, removeIcon: boolean) {
 	const world = worlds.value.find((world) => world.type === 'singleplayer' && world.path === path)
 	if (world) {
diff --git a/apps/app/build.rs b/apps/app/build.rs
index 2f7ce70457..323a61075e 100644
--- a/apps/app/build.rs
+++ b/apps/app/build.rs
@@ -229,6 +229,16 @@ fn main() {
                         "instance_move_screenshots",
                         "instance_open_screenshot",
                         "instance_set_synced_option",
+                        "instance_get_synced_options_overview",
+                        "instance_get_global_synced_options",
+                        "instance_set_global_synced_option",
+                        "instance_get_command_history",
+                        "instance_set_command_history",
+                        "instance_open_synced_options_folder",
+                        "instance_list_synced_servers",
+                        "instance_update_synced_server",
+                        "instance_remove_synced_server",
+                        "instance_rebuild_synced_options",
                         "instance_list",
                         "instance_list_groups",
                         "instance_create_group",
@@ -405,6 +415,7 @@ fn main() {
                         "add_server_to_instance",
                         "edit_server_in_instance",
                         "remove_server_from_instance",
+                        "desync_server",
                         "get_instance_protocol_version",
                         "get_server_status",
                         "start_join_singleplayer_world",
diff --git a/apps/app/src/api/instance.rs b/apps/app/src/api/instance.rs
index c01aa58931..cc6c47fe73 100644
--- a/apps/app/src/api/instance.rs
+++ b/apps/app/src/api/instance.rs
@@ -60,6 +60,16 @@ pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
             instance_move_screenshots,
             instance_open_screenshot,
             instance_set_synced_option,
+            instance_get_synced_options_overview,
+            instance_get_global_synced_options,
+            instance_set_global_synced_option,
+            instance_get_command_history,
+            instance_set_command_history,
+            instance_open_synced_options_folder,
+            instance_list_synced_servers,
+            instance_update_synced_server,
+            instance_remove_synced_server,
+            instance_rebuild_synced_options,
             instance_check_installed,
             instance_update_all,
             instance_update_project,
@@ -780,6 +790,86 @@ pub async fn instance_set_synced_option(
     ))
 }
 
+#[tauri::command]
+pub async fn instance_get_synced_options_overview(
+    instance_id: &str,
+) -> Result<theseus::instance::SyncedOptionsOverview> {
+    Ok(theseus::instance::get_synced_options_overview(instance_id).await?)
+}
+
+#[tauri::command]
+pub async fn instance_get_global_synced_options()
+-> Result<theseus::instance::GlobalSyncedOptions> {
+    Ok(theseus::instance::get_global_synced_options().await?)
+}
+
+#[tauri::command]
+pub async fn instance_set_global_synced_option(
+    option: InstanceSyncedOption,
+    enabled: bool,
+    base_instance_id: Option<&str>,
+) -> Result<theseus::instance::GlobalSyncedOptions> {
+    Ok(theseus::instance::set_global_synced_option(
+        option,
+        enabled,
+        base_instance_id,
+    )
+    .await?)
+}
+
+#[tauri::command]
+pub async fn instance_get_command_history() -> Result<String> {
+    Ok(theseus::instance::get_command_history().await?)
+}
+
+#[tauri::command]
+pub async fn instance_set_command_history(contents: &str) -> Result<String> {
+    Ok(theseus::instance::set_command_history(contents).await?)
+}
+
+#[tauri::command]
+pub async fn instance_open_synced_options_folder<R: Runtime>(
+    app_handle: AppHandle<R>,
+) -> Result<()> {
+    let path = theseus::instance::get_synced_options_folder().await?;
+    app_handle
+        .opener()
+        .open_path(path.to_string_lossy(), None::<&str>)
+        .map_err(|error| std::io::Error::other(error.to_string()))?;
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn instance_list_synced_servers()
+-> Result<Vec<theseus::instance::SyncedServer>> {
+    Ok(theseus::instance::list_synced_servers().await?)
+}
+
+#[tauri::command]
+pub async fn instance_update_synced_server(
+    server: theseus::instance::SyncedServer,
+) -> Result<()> {
+    Ok(theseus::instance::update_synced_server(server).await?)
+}
+
+#[tauri::command]
+pub async fn instance_remove_synced_server(server_id: &str) -> Result<()> {
+    Ok(theseus::instance::remove_synced_server(server_id).await?)
+}
+
+#[tauri::command]
+pub async fn instance_rebuild_synced_options(
+    instance_id: Option<&str>,
+) -> Result<()> {
+    if let Some(instance_id) = instance_id {
+        theseus::instance::reconcile_instance_synced_options(instance_id)
+            .await?;
+    } else {
+        theseus::instance::reconcile_all_synced_options().await?;
+    }
+    Ok(())
+}
+
 fn serialize_screenshots<R: Runtime>(
     app_handle: &AppHandle<R>,
     screenshots: Vec<theseus::instance::InstanceScreenshot>,
diff --git a/apps/app/src/api/worlds.rs b/apps/app/src/api/worlds.rs
index afa743e0eb..56dcdd091b 100644
--- a/apps/app/src/api/worlds.rs
+++ b/apps/app/src/api/worlds.rs
@@ -25,6 +25,7 @@ pub fn init<R: Runtime>() -> tauri::plugin::TauriPlugin<R> {
             add_server_to_instance,
             edit_server_in_instance,
             remove_server_from_instance,
+            desync_server,
             get_instance_protocol_version,
             get_server_status,
             start_join_singleplayer_world,
@@ -193,6 +194,15 @@ pub async fn remove_server_from_instance(
     Ok(())
 }
 
+#[tauri::command]
+pub async fn desync_server(
+    instance_id: &str,
+    server_id: &str,
+    mode: theseus::instance::DesyncServerMode,
+) -> Result<()> {
+    Ok(theseus::instance::desync_server(instance_id, server_id, mode).await?)
+}
+
 #[tauri::command]
 pub async fn get_instance_protocol_version(
     instance_id: &str,
diff --git a/packages/app-lib/.sqlx/query-025bdcd737cd08b4111946dc28cacdd6586cfcea44c88152dc44d26f21332910.json b/packages/app-lib/.sqlx/query-025bdcd737cd08b4111946dc28cacdd6586cfcea44c88152dc44d26f21332910.json
new file mode 100644
index 0000000000..34ded8ef71
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-025bdcd737cd08b4111946dc28cacdd6586cfcea44c88152dc44d26f21332910.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\tINSERT INTO instance_server_entries\n\t\t\t\t(instance_id, id, source, canonical_id, nbt, position)\n\t\t\tVALUES (?, ?, ?, ?, ?, ?)\n\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 6
+    },
+    "nullable": []
+  },
+  "hash": "025bdcd737cd08b4111946dc28cacdd6586cfcea44c88152dc44d26f21332910"
+}
diff --git a/packages/app-lib/.sqlx/query-0bb6b572586c47253e224af9bee1b92e6abffdcad59050db59a0fcbace5b5f26.json b/packages/app-lib/.sqlx/query-0bb6b572586c47253e224af9bee1b92e6abffdcad59050db59a0fcbace5b5f26.json
new file mode 100644
index 0000000000..b29bddf113
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-0bb6b572586c47253e224af9bee1b92e6abffdcad59050db59a0fcbace5b5f26.json
@@ -0,0 +1,20 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tSELECT version_id\n\t\tFROM instance_server_baselines\n\t\tWHERE instance_id = ?\n\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "version_id",
+        "ordinal": 0,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      true
+    ]
+  },
+  "hash": "0bb6b572586c47253e224af9bee1b92e6abffdcad59050db59a0fcbace5b5f26"
+}
diff --git a/packages/app-lib/.sqlx/query-0e12f60511e37652760cac595e7454c0cd8d49040bcb4a73c48cf044b3ecac89.json b/packages/app-lib/.sqlx/query-0e12f60511e37652760cac595e7454c0cd8d49040bcb4a73c48cf044b3ecac89.json
new file mode 100644
index 0000000000..61ed333367
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-0e12f60511e37652760cac595e7454c0cd8d49040bcb4a73c48cf044b3ecac89.json
@@ -0,0 +1,20 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tSELECT option\n\t\tFROM instance_synced_options\n\t\tWHERE instance_id = ? AND enabled = 1\n\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "option",
+        "ordinal": 0,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "0e12f60511e37652760cac595e7454c0cd8d49040bcb4a73c48cf044b3ecac89"
+}
diff --git a/packages/app-lib/.sqlx/query-1cdee99e388ed61a0d57a61ded6ac1bafff2c46863e844a1f4ea5501eedb9ad4.json b/packages/app-lib/.sqlx/query-1cdee99e388ed61a0d57a61ded6ac1bafff2c46863e844a1f4ea5501eedb9ad4.json
new file mode 100644
index 0000000000..a77cdc605c
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-1cdee99e388ed61a0d57a61ded6ac1bafff2c46863e844a1f4ea5501eedb9ad4.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\tINSERT INTO instance_server_snapshots\n\t\t\t\t(instance_id, server_id, source, nbt, position)\n\t\t\tVALUES (?, ?, ?, ?, ?)\n\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 5
+    },
+    "nullable": []
+  },
+  "hash": "1cdee99e388ed61a0d57a61ded6ac1bafff2c46863e844a1f4ea5501eedb9ad4"
+}
diff --git a/packages/app-lib/.sqlx/query-21463a2bec47047d05d9bdb2dac0f4f6039574975f61747d3dd21bf57eda238a.json b/packages/app-lib/.sqlx/query-21463a2bec47047d05d9bdb2dac0f4f6039574975f61747d3dd21bf57eda238a.json
new file mode 100644
index 0000000000..218e4a2836
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-21463a2bec47047d05d9bdb2dac0f4f6039574975f61747d3dd21bf57eda238a.json
@@ -0,0 +1,32 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tSELECT server_id, source, nbt\n\t\tFROM instance_server_snapshots\n\t\tWHERE instance_id = ?\n\t\tORDER BY position\n\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "server_id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "source",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "nbt",
+        "ordinal": 2,
+        "type_info": "Blob"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "21463a2bec47047d05d9bdb2dac0f4f6039574975f61747d3dd21bf57eda238a"
+}
diff --git a/packages/app-lib/.sqlx/query-30694d61cfc967df2bc22341e127297c3e78428e58589586d65b62e917ee6ab3.json b/packages/app-lib/.sqlx/query-30694d61cfc967df2bc22341e127297c3e78428e58589586d65b62e917ee6ab3.json
new file mode 100644
index 0000000000..75639959f9
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-30694d61cfc967df2bc22341e127297c3e78428e58589586d65b62e917ee6ab3.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tINSERT INTO instance_synced_options (instance_id, option, enabled)\n\t\tSELECT ?, option, enabled\n\t\tFROM global_synced_options_overrides\n\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": []
+  },
+  "hash": "30694d61cfc967df2bc22341e127297c3e78428e58589586d65b62e917ee6ab3"
+}
diff --git a/packages/app-lib/.sqlx/query-42c6505cc670cca48934a9f3fe768650ea8c5c8c45d267c3398d338e17cff239.json b/packages/app-lib/.sqlx/query-42c6505cc670cca48934a9f3fe768650ea8c5c8c45d267c3398d338e17cff239.json
new file mode 100644
index 0000000000..03f83d5282
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-42c6505cc670cca48934a9f3fe768650ea8c5c8c45d267c3398d338e17cff239.json
@@ -0,0 +1,20 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tSELECT expected_sha1 FROM synced_option_materializations\n\t\tWHERE instance_id = ? AND option = 'multiplayer_servers' AND family = ''\n\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "expected_sha1",
+        "ordinal": 0,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      true
+    ]
+  },
+  "hash": "42c6505cc670cca48934a9f3fe768650ea8c5c8c45d267c3398d338e17cff239"
+}
diff --git a/packages/app-lib/.sqlx/query-6f7d5d7df89066764e809f4d299175d493be079b599d5ac168988f0612ab563d.json b/packages/app-lib/.sqlx/query-6f7d5d7df89066764e809f4d299175d493be079b599d5ac168988f0612ab563d.json
new file mode 100644
index 0000000000..ea15015c52
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-6f7d5d7df89066764e809f4d299175d493be079b599d5ac168988f0612ab563d.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "DELETE FROM instance_server_entries WHERE instance_id = ?",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": []
+  },
+  "hash": "6f7d5d7df89066764e809f4d299175d493be079b599d5ac168988f0612ab563d"
+}
diff --git a/packages/app-lib/.sqlx/query-8f09e98c6b8e0f1d5444aabbf2a80f9bde067f3ac15aa40d15c19d217639b605.json b/packages/app-lib/.sqlx/query-8f09e98c6b8e0f1d5444aabbf2a80f9bde067f3ac15aa40d15c19d217639b605.json
new file mode 100644
index 0000000000..0858139d16
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-8f09e98c6b8e0f1d5444aabbf2a80f9bde067f3ac15aa40d15c19d217639b605.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tINSERT INTO instance_server_baselines\n\t\t\t(instance_id, version_id, reconstructed)\n\t\tVALUES (?, ?, ?)\n\t\tON CONFLICT(instance_id) DO UPDATE SET\n\t\t\tversion_id = excluded.version_id,\n\t\t\treconstructed = excluded.reconstructed\n\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": []
+  },
+  "hash": "8f09e98c6b8e0f1d5444aabbf2a80f9bde067f3ac15aa40d15c19d217639b605"
+}
diff --git a/packages/app-lib/.sqlx/query-9d60938be8573be0f82cac164245a9eafcfbfdf7b98df1f838ba9af56695d7a4.json b/packages/app-lib/.sqlx/query-9d60938be8573be0f82cac164245a9eafcfbfdf7b98df1f838ba9af56695d7a4.json
new file mode 100644
index 0000000000..82eb86e53b
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-9d60938be8573be0f82cac164245a9eafcfbfdf7b98df1f838ba9af56695d7a4.json
@@ -0,0 +1,26 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tSELECT instance_id, option\n\t\tFROM instance_synced_options\n\t\tWHERE enabled = 1\n\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "instance_id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "option",
+        "ordinal": 1,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false,
+      false
+    ]
+  },
+  "hash": "9d60938be8573be0f82cac164245a9eafcfbfdf7b98df1f838ba9af56695d7a4"
+}
diff --git a/packages/app-lib/.sqlx/query-a73b1547db507fc88dbeccb332af616424ecdb687b38fbbca4673ad5cdf24dd9.json b/packages/app-lib/.sqlx/query-a73b1547db507fc88dbeccb332af616424ecdb687b38fbbca4673ad5cdf24dd9.json
new file mode 100644
index 0000000000..ee5628c21a
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-a73b1547db507fc88dbeccb332af616424ecdb687b38fbbca4673ad5cdf24dd9.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tINSERT INTO synced_option_materializations\n\t\t\t(instance_id, option, family, expected_sha1, link_mode)\n\t\tVALUES (?, ?, ?, ?, ?)\n\t\tON CONFLICT(instance_id, option, family) DO UPDATE SET\n\t\t\texpected_sha1 = excluded.expected_sha1,\n\t\t\tlink_mode = excluded.link_mode\n\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 5
+    },
+    "nullable": []
+  },
+  "hash": "a73b1547db507fc88dbeccb332af616424ecdb687b38fbbca4673ad5cdf24dd9"
+}
diff --git a/packages/app-lib/.sqlx/query-a90cef7f12500b65bb8a6ea070b0a21ad800b41f69deda4ac6f4c6ca87428a14.json b/packages/app-lib/.sqlx/query-a90cef7f12500b65bb8a6ea070b0a21ad800b41f69deda4ac6f4c6ca87428a14.json
new file mode 100644
index 0000000000..6a0b0d02d6
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-a90cef7f12500b65bb8a6ea070b0a21ad800b41f69deda4ac6f4c6ca87428a14.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\tINSERT INTO instance_server_entries\n\t\t\t\t(instance_id, id, source, canonical_id, nbt, position)\n\t\t\tVALUES (?, ?, ?, NULL, ?, ?)\n\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 5
+    },
+    "nullable": []
+  },
+  "hash": "a90cef7f12500b65bb8a6ea070b0a21ad800b41f69deda4ac6f4c6ca87428a14"
+}
diff --git a/packages/app-lib/.sqlx/query-b9e21c3aa7ebb21db77c1b02a2274d295cfb808c03033e552928c3cf7347b6ad.json b/packages/app-lib/.sqlx/query-b9e21c3aa7ebb21db77c1b02a2274d295cfb808c03033e552928c3cf7347b6ad.json
new file mode 100644
index 0000000000..c90b4b3acb
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-b9e21c3aa7ebb21db77c1b02a2274d295cfb808c03033e552928c3cf7347b6ad.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tINSERT INTO global_synced_options_overrides (option, enabled)\n\t\tVALUES (?, ?)\n\t\tON CONFLICT(option) DO UPDATE SET enabled = excluded.enabled\n\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": []
+  },
+  "hash": "b9e21c3aa7ebb21db77c1b02a2274d295cfb808c03033e552928c3cf7347b6ad"
+}
diff --git a/packages/app-lib/.sqlx/query-c4f24e497f828d629498bc5c022da1f5c94fdf0db098072c4a138fe31932c370.json b/packages/app-lib/.sqlx/query-c4f24e497f828d629498bc5c022da1f5c94fdf0db098072c4a138fe31932c370.json
new file mode 100644
index 0000000000..4a19411e3f
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-c4f24e497f828d629498bc5c022da1f5c94fdf0db098072c4a138fe31932c370.json
@@ -0,0 +1,26 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tSELECT option, enabled AS \"enabled!: bool\"\n\t\tFROM global_synced_options_overrides\n\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "option",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "enabled!: bool",
+        "ordinal": 1,
+        "type_info": "Integer"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false,
+      false
+    ]
+  },
+  "hash": "c4f24e497f828d629498bc5c022da1f5c94fdf0db098072c4a138fe31932c370"
+}
diff --git a/packages/app-lib/.sqlx/query-d0620336091b153f01448417ca655a6a7c6dbad8f7975973e2614441301bec23.json b/packages/app-lib/.sqlx/query-d0620336091b153f01448417ca655a6a7c6dbad8f7975973e2614441301bec23.json
new file mode 100644
index 0000000000..79ecee9765
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-d0620336091b153f01448417ca655a6a7c6dbad8f7975973e2614441301bec23.json
@@ -0,0 +1,20 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tSELECT expected_sha1\n\t\tFROM synced_option_materializations\n\t\tWHERE instance_id = ? AND option = ? AND family = ?\n\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "expected_sha1",
+        "ordinal": 0,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": [
+      true
+    ]
+  },
+  "hash": "d0620336091b153f01448417ca655a6a7c6dbad8f7975973e2614441301bec23"
+}
diff --git a/packages/app-lib/.sqlx/query-da27707b85df33ee2024216aa3df27e3ad2de43eebb2ee226497580d8ff69176.json b/packages/app-lib/.sqlx/query-da27707b85df33ee2024216aa3df27e3ad2de43eebb2ee226497580d8ff69176.json
new file mode 100644
index 0000000000..4407924ce5
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-da27707b85df33ee2024216aa3df27e3ad2de43eebb2ee226497580d8ff69176.json
@@ -0,0 +1,20 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tSELECT EXISTS(\n\t\t\tSELECT 1 FROM global_synced_options_overrides\n\t\t\tWHERE option = 'multiplayer_servers' AND enabled = 1\n\t\t) AS \"enabled!: bool\"\n\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "enabled!: bool",
+        "ordinal": 0,
+        "type_info": "Integer"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "da27707b85df33ee2024216aa3df27e3ad2de43eebb2ee226497580d8ff69176"
+}
diff --git a/packages/app-lib/.sqlx/query-db7e6a3711ec75599be7b20ad31a4e314a4fc07eb8236f4bf35fd60db0605655.json b/packages/app-lib/.sqlx/query-db7e6a3711ec75599be7b20ad31a4e314a4fc07eb8236f4bf35fd60db0605655.json
new file mode 100644
index 0000000000..2027e740c0
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-db7e6a3711ec75599be7b20ad31a4e314a4fc07eb8236f4bf35fd60db0605655.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "DELETE FROM instance_server_snapshots WHERE instance_id = ?",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": []
+  },
+  "hash": "db7e6a3711ec75599be7b20ad31a4e314a4fc07eb8236f4bf35fd60db0605655"
+}
diff --git a/packages/app-lib/.sqlx/query-dc41f40aaad8fe8f379ca4b595127d6e5e2c586da9cdcde53614a33320837dac.json b/packages/app-lib/.sqlx/query-dc41f40aaad8fe8f379ca4b595127d6e5e2c586da9cdcde53614a33320837dac.json
new file mode 100644
index 0000000000..524704f7eb
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-dc41f40aaad8fe8f379ca4b595127d6e5e2c586da9cdcde53614a33320837dac.json
@@ -0,0 +1,20 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tSELECT reconstructed AS \"reconstructed!: bool\"\n\t\tFROM instance_server_baselines\n\t\tWHERE instance_id = ?\n\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "reconstructed!: bool",
+        "ordinal": 0,
+        "type_info": "Integer"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "dc41f40aaad8fe8f379ca4b595127d6e5e2c586da9cdcde53614a33320837dac"
+}
diff --git a/packages/app-lib/.sqlx/query-e626908e7d94188472f78c82a286ccd5b0ea889166672fedb26811ebb324c62f.json b/packages/app-lib/.sqlx/query-e626908e7d94188472f78c82a286ccd5b0ea889166672fedb26811ebb324c62f.json
new file mode 100644
index 0000000000..bc8e25c587
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-e626908e7d94188472f78c82a286ccd5b0ea889166672fedb26811ebb324c62f.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "DELETE FROM instance_server_entries WHERE instance_id = ? AND source = 'modpack'",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": []
+  },
+  "hash": "e626908e7d94188472f78c82a286ccd5b0ea889166672fedb26811ebb324c62f"
+}
diff --git a/packages/app-lib/.sqlx/query-e6f5817e75f03035f327211cf7460b48b538e41dca1a1e850a03f8b95ad9a34a.json b/packages/app-lib/.sqlx/query-e6f5817e75f03035f327211cf7460b48b538e41dca1a1e850a03f8b95ad9a34a.json
new file mode 100644
index 0000000000..b0d246d40e
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-e6f5817e75f03035f327211cf7460b48b538e41dca1a1e850a03f8b95ad9a34a.json
@@ -0,0 +1,44 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tSELECT id, source, canonical_id, nbt, position\n\t\tFROM instance_server_entries\n\t\tWHERE instance_id = ?\n\t\tORDER BY position\n\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "source",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "canonical_id",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "nbt",
+        "ordinal": 3,
+        "type_info": "Blob"
+      },
+      {
+        "name": "position",
+        "ordinal": 4,
+        "type_info": "Integer"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      true,
+      false,
+      false
+    ]
+  },
+  "hash": "e6f5817e75f03035f327211cf7460b48b538e41dca1a1e850a03f8b95ad9a34a"
+}
diff --git a/packages/app-lib/.sqlx/query-fb55bb9d1e72cc4fa87ab6d851dc7a0bd79be3d5b0836676073dc56355f87bc0.json b/packages/app-lib/.sqlx/query-fb55bb9d1e72cc4fa87ab6d851dc7a0bd79be3d5b0836676073dc56355f87bc0.json
new file mode 100644
index 0000000000..8d7652305a
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-fb55bb9d1e72cc4fa87ab6d851dc7a0bd79be3d5b0836676073dc56355f87bc0.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tINSERT INTO instance_synced_options (instance_id, option, enabled)\n\t\tVALUES (?, ?, ?)\n\t\tON CONFLICT (instance_id, option) DO UPDATE SET\n\t\t\tenabled = excluded.enabled\n\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": []
+  },
+  "hash": "fb55bb9d1e72cc4fa87ab6d851dc7a0bd79be3d5b0836676073dc56355f87bc0"
+}
diff --git a/packages/app-lib/.sqlx/query-fc91a68aaf7e6762d3bddbd4fe4e461b77671619a65fb809bd9b8ed9ab71baaa.json b/packages/app-lib/.sqlx/query-fc91a68aaf7e6762d3bddbd4fe4e461b77671619a65fb809bd9b8ed9ab71baaa.json
new file mode 100644
index 0000000000..5b2dcbb69b
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-fc91a68aaf7e6762d3bddbd4fe4e461b77671619a65fb809bd9b8ed9ab71baaa.json
@@ -0,0 +1,20 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tSELECT EXISTS(SELECT 1 FROM instances WHERE id = ?)\n\t\t\tAS \"exists!: bool\"\n\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "exists!: bool",
+        "ordinal": 0,
+        "type_info": "Integer"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "fc91a68aaf7e6762d3bddbd4fe4e461b77671619a65fb809bd9b8ed9ab71baaa"
+}
diff --git a/packages/app-lib/migrations/20260819120000_instance-synced-options.sql b/packages/app-lib/migrations/20260819120000_instance-synced-options.sql
index ffb4d3f901..7c62d32cd5 100644
--- a/packages/app-lib/migrations/20260819120000_instance-synced-options.sql
+++ b/packages/app-lib/migrations/20260819120000_instance-synced-options.sql
@@ -9,3 +9,56 @@ CREATE TABLE instance_synced_options (
 
 CREATE INDEX instance_synced_options_option_enabled
 	ON instance_synced_options(option, enabled);
+
+CREATE TABLE global_synced_options_overrides (
+	option TEXT PRIMARY KEY NOT NULL,
+	enabled INTEGER NOT NULL CHECK (enabled IN (0, 1))
+);
+
+INSERT INTO global_synced_options_overrides (option, enabled)
+VALUES
+	('command_history', CASE WHEN EXISTS(SELECT 1 FROM instances) THEN 0 ELSE 1 END),
+	('multiplayer_servers', CASE WHEN EXISTS(SELECT 1 FROM instances) THEN 0 ELSE 1 END),
+	('creative_hotbars', CASE WHEN EXISTS(SELECT 1 FROM instances) THEN 0 ELSE 1 END),
+	('screenshots', CASE WHEN EXISTS(SELECT 1 FROM instances) THEN 0 ELSE 1 END);
+
+CREATE TABLE synced_option_materializations (
+	instance_id TEXT NOT NULL,
+	option TEXT NOT NULL,
+	family TEXT NOT NULL DEFAULT '',
+	expected_sha1 TEXT,
+	link_mode TEXT NOT NULL DEFAULT 'copy',
+	PRIMARY KEY (instance_id, option, family),
+	FOREIGN KEY (instance_id) REFERENCES instances(id) ON DELETE CASCADE
+);
+
+CREATE TABLE instance_server_entries (
+	instance_id TEXT NOT NULL,
+	id TEXT NOT NULL,
+	source TEXT NOT NULL,
+	canonical_id TEXT,
+	nbt BLOB NOT NULL,
+	position INTEGER NOT NULL,
+	PRIMARY KEY (instance_id, id),
+	FOREIGN KEY (instance_id) REFERENCES instances(id) ON DELETE CASCADE
+);
+
+CREATE INDEX instance_server_entries_source
+	ON instance_server_entries(instance_id, source, position);
+
+CREATE TABLE instance_server_snapshots (
+	instance_id TEXT NOT NULL,
+	server_id TEXT NOT NULL,
+	source TEXT NOT NULL,
+	nbt BLOB NOT NULL,
+	position INTEGER NOT NULL,
+	PRIMARY KEY (instance_id, server_id),
+	FOREIGN KEY (instance_id) REFERENCES instances(id) ON DELETE CASCADE
+);
+
+CREATE TABLE instance_server_baselines (
+	instance_id TEXT PRIMARY KEY NOT NULL,
+	version_id TEXT,
+	reconstructed INTEGER NOT NULL CHECK (reconstructed IN (0, 1)),
+	FOREIGN KEY (instance_id) REFERENCES instances(id) ON DELETE CASCADE
+);
diff --git a/packages/app-lib/src/api/instance.rs b/packages/app-lib/src/api/instance.rs
index 99b59e97f4..485e289b1e 100644
--- a/packages/app-lib/src/api/instance.rs
+++ b/packages/app-lib/src/api/instance.rs
@@ -14,6 +14,8 @@ mod run;
 mod screenshot_groups;
 mod screenshots;
 mod shared;
+mod synced_options;
+pub(crate) mod synced_servers;
 
 pub use self::content::{
     get_content_items, get_dependencies_as_content_items,
@@ -88,3 +90,22 @@ pub use self::shared::{
     remove_shared_instance_users, revoke_shared_instance_invite,
     unlink_shared_instance, unpublish_shared_instance, update_shared_instance,
 };
+pub use self::synced_options::{
+    GlobalSyncedOptions, SyncedOptionCapability, SyncedOptionsOverview,
+    get_capabilities as get_synced_option_capabilities, get_command_history,
+    get_global_options as get_global_synced_options,
+    get_overview as get_synced_options_overview, get_synced_options_folder,
+    set_command_history, set_global_option as set_global_synced_option,
+};
+pub(crate) use self::synced_options::{
+    prepare_instance_update,
+    reconcile_changed_file as reconcile_synced_option_file,
+};
+pub use self::synced_options::{
+    reconcile_all as reconcile_all_synced_options,
+    reconcile_instance as reconcile_instance_synced_options,
+};
+pub use self::synced_servers::{
+    DesyncServerMode, ServerSource, SyncedServer, desync_server,
+    list_synced_servers, remove_synced_server, update_synced_server,
+};
diff --git a/packages/app-lib/src/api/instance/lifecycle.rs b/packages/app-lib/src/api/instance/lifecycle.rs
index d5b8813631..69882efd15 100644
--- a/packages/app-lib/src/api/instance/lifecycle.rs
+++ b/packages/app-lib/src/api/instance/lifecycle.rs
@@ -77,6 +77,8 @@ pub async fn edit(
                 .as_error()
         })?;
 
+    super::reconcile_instance_synced_options(instance_id).await?;
+
     emit_instance(&instance.instance.id, InstancePayloadType::Edited).await?;
 
     Ok(instance)
@@ -87,22 +89,13 @@ pub async fn set_synced_option(
     option: InstanceSyncedOption,
     enabled: bool,
 ) -> crate::Result<InstanceMetadata> {
-    let state = State::get().await?;
-    instance_rows::set_instance_synced_option(
+    let instance = super::synced_options::set_instance_option(
         instance_id,
         option,
         enabled,
-        &state.pool,
     )
     .await?;
 
-    let instance = crate::state::get_instance(instance_id, &state.pool)
-        .await?
-        .ok_or_else(|| {
-            crate::ErrorKind::InputError("Unknown instance".to_string())
-                .as_error()
-        })?;
-
     emit_instance(&instance.instance.id, InstancePayloadType::Edited).await?;
 
     Ok(instance)
diff --git a/packages/app-lib/src/api/instance/synced_options.rs b/packages/app-lib/src/api/instance/synced_options.rs
new file mode 100644
index 0000000000..d8e57990f4
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options.rs
@@ -0,0 +1,1245 @@
+use crate::state::instances::adapters::sqlite::instance_rows;
+use crate::state::{
+    InstanceInstallStage, InstanceLink, InstanceMetadata, SyncedOption,
+};
+use crate::util::io;
+use crate::{ErrorKind, State};
+use quartz_nbt::{NbtCompound, NbtList, NbtTag};
+use serde::{Deserialize, Serialize};
+use sha1_smol::Sha1;
+use std::io::Cursor;
+use std::path::{Path, PathBuf};
+
+const COMMAND_HISTORY_FILE: &str = "command_history.txt";
+const HOTBAR_FILE: &str = "hotbar.nbt";
+const COMMAND_HISTORY_LIMIT: usize = 50;
+
+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]
+pub struct GlobalSyncedOptions {
+    pub command_history: bool,
+    pub multiplayer_servers: bool,
+    pub creative_hotbars: bool,
+    pub screenshots: bool,
+}
+
+impl GlobalSyncedOptions {
+    pub fn get(self, option: SyncedOption) -> bool {
+        match option {
+            SyncedOption::CommandHistory => self.command_history,
+            SyncedOption::MultiplayerServers => self.multiplayer_servers,
+            SyncedOption::CreativeHotbars => self.creative_hotbars,
+            SyncedOption::Screenshots => self.screenshots,
+        }
+    }
+
+    fn set(&mut self, option: SyncedOption, enabled: bool) {
+        match option {
+            SyncedOption::CommandHistory => self.command_history = enabled,
+            SyncedOption::MultiplayerServers => {
+                self.multiplayer_servers = enabled
+            }
+            SyncedOption::CreativeHotbars => self.creative_hotbars = enabled,
+            SyncedOption::Screenshots => self.screenshots = enabled,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct SyncedOptionCapability {
+    pub option: SyncedOption,
+    pub supported: bool,
+    pub disabled_reason: Option<String>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct SyncedOptionsOverview {
+    pub global_options: GlobalSyncedOptions,
+    pub capabilities: Vec<SyncedOptionCapability>,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum HotbarFamily {
+    Legacy,
+    Components,
+}
+
+impl HotbarFamily {
+    fn as_str(self) -> &'static str {
+        match self {
+            Self::Legacy => "legacy",
+            Self::Components => "components",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub(super) enum LinkMode {
+    Symbolic,
+    #[cfg(windows)]
+    Hard,
+    #[cfg(windows)]
+    Copy,
+}
+
+impl LinkMode {
+    fn as_str(self) -> &'static str {
+        match self {
+            Self::Symbolic => "symbolic",
+            #[cfg(windows)]
+            Self::Hard => "hard",
+            #[cfg(windows)]
+            Self::Copy => "copy",
+        }
+    }
+}
+
+pub async fn get_global_options() -> crate::Result<GlobalSyncedOptions> {
+    let state = State::get().await?;
+    get_global_options_with_state(&state).await
+}
+
+pub async fn get_synced_options_folder() -> crate::Result<PathBuf> {
+    let state = State::get().await?;
+    create_synced_directories(&state).await?;
+    Ok(synced_options_path(&state))
+}
+
+async fn get_global_options_with_state(
+    state: &State,
+) -> crate::Result<GlobalSyncedOptions> {
+    let mut options = GlobalSyncedOptions::default();
+	let rows = sqlx::query!(
+		r#"
+		SELECT option, enabled AS "enabled!: bool"
+		FROM global_synced_options_overrides
+		"#,
+	)
+	.fetch_all(&state.pool)
+	.await?;
+
+	for row in rows {
+		if let Some(option) = option_from_str(&row.option) {
+			options.set(option, row.enabled);
+        }
+    }
+
+    Ok(options)
+}
+
+pub async fn get_overview(
+    instance_id: &str,
+) -> crate::Result<SyncedOptionsOverview> {
+    let state = State::get().await?;
+    let global_options = get_global_options_with_state(&state).await?;
+    let metadata = crate::state::get_instance(instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| ErrorKind::InputError("Unknown instance".to_string()))?;
+    let mut capabilities = Vec::with_capacity(SyncedOption::ALL.len());
+
+    for option in SyncedOption::ALL {
+        capabilities.push(
+            capability(&metadata, option, global_options.get(option), &state)
+                .await,
+        );
+    }
+
+    Ok(SyncedOptionsOverview {
+        global_options,
+        capabilities,
+    })
+}
+
+pub async fn get_capabilities(
+    instance_id: &str,
+) -> crate::Result<Vec<SyncedOptionCapability>> {
+    Ok(get_overview(instance_id).await?.capabilities)
+}
+
+async fn capability(
+    metadata: &InstanceMetadata,
+    option: SyncedOption,
+    global_enabled: bool,
+    state: &State,
+) -> SyncedOptionCapability {
+    let version_reason = version_disabled_reason(metadata, option, state).await;
+    let linked_reason = (option == SyncedOption::MultiplayerServers
+		&& is_linked_server_project(&metadata.link))
+	.then(|| {
+		"Multiplayer server syncing is unavailable for linked server-project instances."
+			.to_string()
+	});
+    let global_reason = (!global_enabled).then(|| {
+        "This option is disabled in the app's synced options settings."
+            .to_string()
+    });
+    let disabled_reason = version_reason.or(linked_reason).or(global_reason);
+
+    SyncedOptionCapability {
+        option,
+        supported: disabled_reason.is_none(),
+        disabled_reason,
+    }
+}
+
+async fn version_disabled_reason(
+    metadata: &InstanceMetadata,
+    option: SyncedOption,
+    state: &State,
+) -> Option<String> {
+    if option == SyncedOption::Screenshots {
+        return None;
+    }
+
+    let game_version = &metadata.applied_content_set.game_version;
+    let Ok((manifest, version_index)) =
+        crate::launcher::resolve_minecraft_manifest(game_version, state).await
+    else {
+        return Some(
+			"This instance’s Minecraft version could not be verified, so syncing is unavailable."
+				.to_string(),
+		);
+    };
+    let cutoff_id = match option {
+        // Mojang's manifest does not include Beta 1.8 Pre-release as a
+        // separate entry, so b1.8 is the first resolvable version at that
+        // boundary.
+        SyncedOption::MultiplayerServers => "b1.8",
+        SyncedOption::CreativeHotbars => "1.12",
+        SyncedOption::CommandHistory => "1.20.2",
+        SyncedOption::Screenshots => return None,
+    };
+    let Some(cutoff) =
+        manifest.versions.iter().find(|item| item.id == cutoff_id)
+    else {
+        return Some(
+			"This instance’s Minecraft version could not be verified, so syncing is unavailable."
+				.to_string(),
+		);
+    };
+
+    let version = &manifest.versions[version_index];
+    let release_only_option = matches!(
+        option,
+        SyncedOption::CreativeHotbars | SyncedOption::CommandHistory
+    );
+    let is_supported_release =
+        matches!(&version.type_, daedalus::minecraft::VersionType::Release);
+
+    if version.release_time >= cutoff.release_time
+        && (!release_only_option || is_supported_release)
+    {
+        return None;
+    }
+
+    Some(
+		match option {
+			SyncedOption::MultiplayerServers => {
+				"Multiplayer server syncing requires Minecraft Beta 1.8 Pre-release or newer."
+			}
+			SyncedOption::CreativeHotbars => {
+				"Saved creative hotbars require Minecraft 1.12 or newer."
+			}
+			SyncedOption::CommandHistory => {
+				"Command history syncing requires Minecraft 1.20.2 or newer."
+			}
+			SyncedOption::Screenshots => unreachable!(),
+		}
+		.to_string(),
+	)
+}
+
+async fn hotbar_family(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<HotbarFamily> {
+    let (manifest, version_index) =
+        crate::launcher::resolve_minecraft_manifest(
+            &metadata.applied_content_set.game_version,
+            state,
+        )
+        .await?;
+    let cutoff = manifest
+        .versions
+        .iter()
+        .find(|item| item.id == "1.20.5")
+        .ok_or_else(|| {
+            ErrorKind::LauncherError(
+                "Minecraft 1.20.5 is missing from the version manifest"
+                    .to_string(),
+            )
+        })?;
+    Ok(
+        if manifest.versions[version_index].release_time >= cutoff.release_time
+        {
+            HotbarFamily::Components
+        } else {
+            HotbarFamily::Legacy
+        },
+    )
+}
+
+pub async fn set_global_option(
+    option: SyncedOption,
+    enabled: bool,
+    base_instance_id: Option<&str>,
+) -> crate::Result<GlobalSyncedOptions> {
+    let state = State::get().await?;
+    if enabled && option != SyncedOption::Screenshots {
+        let base_instance_id = base_instance_id.ok_or_else(|| {
+            ErrorKind::InputError(
+                "Choose a base instance before enabling a synced option."
+                    .to_string(),
+            )
+        })?;
+        let metadata =
+            crate::state::get_instance(base_instance_id, &state.pool)
+                .await?
+                .ok_or_else(|| {
+                    ErrorKind::InputError("Unknown instance".to_string())
+                })?;
+        let base_capability = capability(&metadata, option, true, &state).await;
+        if !base_capability.supported {
+            return Err(ErrorKind::InputError(
+                base_capability.disabled_reason.unwrap_or_default(),
+            )
+            .into());
+        }
+        seed_from_instance(&metadata, option, &state).await?;
+    }
+
+	let option_name = option.as_str();
+	sqlx::query!(
+		"
+		INSERT INTO global_synced_options_overrides (option, enabled)
+		VALUES (?, ?)
+		ON CONFLICT(option) DO UPDATE SET enabled = excluded.enabled
+		",
+		option_name,
+		enabled,
+	)
+	.execute(&state.pool)
+    .await?;
+
+    let instances = crate::state::list_instances(&state.pool).await?;
+    for metadata in instances {
+        let supported = enabled
+            && capability(&metadata, option, true, &state).await.supported;
+        instance_rows::set_instance_synced_option(
+            &metadata.instance.id,
+            option,
+            supported,
+            &state.pool,
+        )
+        .await?;
+        if supported {
+            ensure_option(&metadata, option, &state).await?;
+        } else {
+            detach_option(&metadata, option, &state).await?;
+        }
+    }
+
+    get_global_options_with_state(&state).await
+}
+
+pub async fn set_instance_option(
+    instance_id: &str,
+    option: SyncedOption,
+    enabled: bool,
+) -> crate::Result<InstanceMetadata> {
+    let state = State::get().await?;
+    let metadata = crate::state::get_instance(instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| ErrorKind::InputError("Unknown instance".to_string()))?;
+    let global = get_global_options_with_state(&state).await?;
+    if enabled {
+        let eligibility =
+            capability(&metadata, option, global.get(option), &state).await;
+        if !eligibility.supported {
+            return Err(ErrorKind::InputError(
+                eligibility.disabled_reason.unwrap_or_default(),
+            )
+            .into());
+        }
+        if !canonical_exists(option, &state) {
+            seed_from_instance(&metadata, option, &state).await?;
+        }
+    }
+
+    instance_rows::set_instance_synced_option(
+        instance_id,
+        option,
+        enabled,
+        &state.pool,
+    )
+    .await?;
+    if enabled {
+        ensure_option(&metadata, option, &state).await?;
+    } else {
+        detach_option(&metadata, option, &state).await?;
+    }
+
+    crate::state::get_instance(instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| {
+            ErrorKind::InputError("Unknown instance".to_string()).into()
+        })
+}
+
+pub async fn reconcile_all() -> crate::Result<()> {
+    let state = State::get().await?;
+    create_synced_directories(&state).await?;
+    let instances = crate::state::list_instances(&state.pool).await?;
+    for metadata in instances {
+        if let Err(error) =
+            reconcile_instance_with_state(&metadata, &state).await
+        {
+            tracing::warn!(
+                "Failed to reconcile synced options for {}: {error}",
+                metadata.instance.id
+            );
+        }
+    }
+    Ok(())
+}
+
+pub async fn reconcile_instance(instance_id: &str) -> crate::Result<()> {
+    let state = State::get().await?;
+    let metadata = crate::state::get_instance(instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| ErrorKind::InputError("Unknown instance".to_string()))?;
+    reconcile_instance_with_state(&metadata, &state).await
+}
+
+pub(crate) async fn prepare_instance_update(
+    instance_id: &str,
+) -> crate::Result<()> {
+    let state = State::get().await?;
+    let metadata = crate::state::get_instance(instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| ErrorKind::InputError("Unknown instance".to_string()))?;
+    for option in [
+        SyncedOption::CommandHistory,
+        SyncedOption::CreativeHotbars,
+        SyncedOption::MultiplayerServers,
+    ] {
+        if instance_option_enabled(&metadata, option) {
+            detach_option(&metadata, option, &state).await?;
+        }
+    }
+    Ok(())
+}
+
+async fn reconcile_instance_with_state(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<()> {
+    if sync_files_are_protected(metadata)
+        || instance_is_running(metadata, state)
+    {
+        return Ok(());
+    }
+    let global = get_global_options_with_state(state).await?;
+    for option in SyncedOption::ALL {
+        let participating = instance_option_enabled(metadata, option);
+        let eligible = capability(metadata, option, global.get(option), state)
+            .await
+            .supported;
+        if participating && eligible {
+            match option {
+                SyncedOption::CommandHistory => {
+                    reconcile_command_history(metadata, state).await?
+                }
+                SyncedOption::CreativeHotbars => {
+                    reconcile_hotbar(metadata, state).await?
+                }
+                SyncedOption::MultiplayerServers => {
+                    super::synced_servers::reconcile_servers(metadata, state)
+                        .await?
+                }
+                SyncedOption::Screenshots => {}
+            }
+        } else if participating {
+            instance_rows::set_instance_synced_option(
+                &metadata.instance.id,
+                option,
+                false,
+                &state.pool,
+            )
+            .await?;
+            detach_option(metadata, option, state).await?;
+        }
+    }
+    Ok(())
+}
+
+pub async fn reconcile_changed_file(
+    instance_id: &str,
+    file_name: &str,
+) -> crate::Result<()> {
+    let state = State::get().await?;
+    let metadata = crate::state::get_instance(instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| ErrorKind::InputError("Unknown instance".to_string()))?;
+    if sync_files_are_protected(&metadata) {
+        return Ok(());
+    }
+    match file_name {
+        COMMAND_HISTORY_FILE => {
+            reconcile_command_history(&metadata, &state).await
+        }
+        HOTBAR_FILE => reconcile_hotbar(&metadata, &state).await,
+        "servers.dat" => {
+            super::synced_servers::reconcile_servers(&metadata, &state).await
+        }
+        _ => Ok(()),
+    }
+}
+
+pub async fn get_command_history() -> crate::Result<String> {
+    let state = State::get().await?;
+    let path = command_history_path(&state);
+    if !path.exists() {
+        return Ok(String::new());
+    }
+    Ok(String::from_utf8_lossy(&io::read(path).await?).into_owned())
+}
+
+pub async fn set_command_history(contents: &str) -> crate::Result<String> {
+    let state = State::get().await?;
+    create_synced_directories(&state).await?;
+    let normalized = normalize_command_history(contents);
+    io::write(command_history_path(&state), normalized.as_bytes()).await?;
+    refresh_command_history_links(&state).await?;
+    Ok(normalized)
+}
+
+pub fn synced_options_path(state: &State) -> PathBuf {
+    state.directories.synced_options_dir()
+}
+
+async fn create_synced_directories(state: &State) -> crate::Result<()> {
+    for path in [
+        synced_options_path(state),
+        synced_options_path(state).join("hotbars/generated/legacy"),
+        synced_options_path(state).join("hotbars/generated/components"),
+        synced_options_path(state).join("servers/generated"),
+    ] {
+        io::create_dir_all(path).await?;
+    }
+    Ok(())
+}
+
+async fn seed_from_instance(
+    metadata: &InstanceMetadata,
+    option: SyncedOption,
+    state: &State,
+) -> crate::Result<()> {
+    create_synced_directories(state).await?;
+    let instance_dir = instance_dir(metadata, state);
+    match option {
+        SyncedOption::CommandHistory => {
+            let path = instance_dir.join(COMMAND_HISTORY_FILE);
+            let contents = if path.exists() {
+                String::from_utf8_lossy(&io::read(path).await?).into_owned()
+            } else {
+                String::new()
+            };
+            io::write(
+                command_history_path(state),
+                normalize_command_history(&contents),
+            )
+            .await?;
+        }
+        SyncedOption::CreativeHotbars => {
+            let path = instance_dir.join(HOTBAR_FILE);
+            let family = hotbar_family(metadata, state).await?;
+            let root = if path.exists() {
+                read_nbt_file(&path).await?
+            } else {
+                empty_hotbar_root()
+            };
+            let mut sync_state = read_hotbar_state(state).await?;
+            merge_hotbar_family(&mut sync_state, family, root);
+            write_hotbar_state(state, &sync_state).await?;
+            regenerate_hotbars(state).await?;
+        }
+        SyncedOption::MultiplayerServers => {
+            super::synced_servers::seed_servers(metadata, state).await?;
+        }
+        SyncedOption::Screenshots => {}
+    }
+    Ok(())
+}
+
+async fn ensure_option(
+    metadata: &InstanceMetadata,
+    option: SyncedOption,
+    state: &State,
+) -> crate::Result<()> {
+    match option {
+        SyncedOption::CommandHistory => {
+            ensure_command_history(metadata, state).await
+        }
+        SyncedOption::CreativeHotbars => ensure_hotbar(metadata, state).await,
+        SyncedOption::MultiplayerServers => {
+            super::synced_servers::ensure_servers(metadata, state).await
+        }
+        SyncedOption::Screenshots => Ok(()),
+    }
+}
+
+async fn detach_option(
+    metadata: &InstanceMetadata,
+    option: SyncedOption,
+    state: &State,
+) -> crate::Result<()> {
+    let instance_dir = instance_dir(metadata, state);
+    match option {
+        SyncedOption::CommandHistory => {
+            detach_link(
+                &command_history_path(state),
+                &instance_dir.join(COMMAND_HISTORY_FILE),
+            )
+            .await
+        }
+        SyncedOption::CreativeHotbars => {
+            let family = hotbar_family(metadata, state).await.ok();
+            let source = family.map(|family| {
+                generated_hotbar_path(state, family, &metadata.instance.id)
+            });
+            if let Some(source) = source {
+                detach_link(&source, &instance_dir.join(HOTBAR_FILE)).await?;
+            }
+            Ok(())
+        }
+        SyncedOption::MultiplayerServers => {
+            super::synced_servers::detach_servers(metadata, state).await
+        }
+        SyncedOption::Screenshots => Ok(()),
+    }
+}
+
+fn canonical_exists(option: SyncedOption, state: &State) -> bool {
+    match option {
+        SyncedOption::CommandHistory => command_history_path(state).exists(),
+        SyncedOption::CreativeHotbars => hotbar_state_path(state).exists(),
+        SyncedOption::MultiplayerServers => synced_options_path(state)
+            .join("servers/canonical.nbt")
+            .exists(),
+        SyncedOption::Screenshots => true,
+    }
+}
+
+async fn ensure_command_history(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<()> {
+    create_synced_directories(state).await?;
+    let canonical = command_history_path(state);
+    if !canonical.exists() {
+        let local = instance_dir(metadata, state).join(COMMAND_HISTORY_FILE);
+        let contents = if local.exists() {
+            String::from_utf8_lossy(&io::read(&local).await?).into_owned()
+        } else {
+            String::new()
+        };
+        io::write(&canonical, normalize_command_history(&contents)).await?;
+    }
+    let target = instance_dir(metadata, state).join(COMMAND_HISTORY_FILE);
+    let mode = ensure_link(&canonical, &target).await?;
+    record_materialization(
+        &metadata.instance.id,
+        SyncedOption::CommandHistory,
+        "",
+        Some(&sha1_file(&canonical).await?),
+        mode,
+        state,
+    )
+    .await
+}
+
+async fn reconcile_command_history(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<()> {
+    if !option_effective(metadata, SyncedOption::CommandHistory, state).await? {
+        return Ok(());
+    }
+    let local = instance_dir(metadata, state).join(COMMAND_HISTORY_FILE);
+    if !local.exists() {
+        return ensure_command_history(metadata, state).await;
+    }
+    let symlink = tokio::fs::symlink_metadata(&local)
+        .await
+        .map(|metadata| metadata.file_type().is_symlink())
+        .unwrap_or(false);
+    let expected = materialization_hash(
+        &metadata.instance.id,
+        SyncedOption::CommandHistory,
+        "",
+        state,
+    )
+    .await?;
+    let actual = sha1_file(&local).await?;
+    if !symlink && expected.as_deref() != Some(actual.as_str()) {
+        let contents =
+            String::from_utf8_lossy(&io::read(&local).await?).into_owned();
+        io::write(
+            command_history_path(state),
+            normalize_command_history(&contents),
+        )
+        .await?;
+        refresh_command_history_links(state).await?;
+    } else {
+        ensure_command_history(metadata, state).await?;
+    }
+    Ok(())
+}
+
+async fn refresh_command_history_links(state: &State) -> crate::Result<()> {
+    let instances = crate::state::list_instances(&state.pool).await?;
+    for metadata in instances {
+        if option_effective(&metadata, SyncedOption::CommandHistory, state)
+            .await?
+        {
+            ensure_command_history(&metadata, state).await?;
+        }
+    }
+    Ok(())
+}
+
+fn normalize_command_history(contents: &str) -> String {
+    let lines = contents.lines().collect::<Vec<_>>();
+    let start = lines.len().saturating_sub(COMMAND_HISTORY_LIMIT);
+    let mut normalized = lines[start..].join("\n");
+    if !normalized.is_empty() {
+        normalized.push('\n');
+    }
+    normalized
+}
+
+async fn ensure_hotbar(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<()> {
+    create_synced_directories(state).await?;
+    if !hotbar_state_path(state).exists() {
+        seed_from_instance(metadata, SyncedOption::CreativeHotbars, state)
+            .await?;
+    }
+    materialize_hotbars_for_instance(metadata, state).await
+}
+
+async fn reconcile_hotbar(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<()> {
+    if !option_effective(metadata, SyncedOption::CreativeHotbars, state).await?
+    {
+        return Ok(());
+    }
+    let local = instance_dir(metadata, state).join(HOTBAR_FILE);
+    if !local.exists() {
+        return ensure_hotbar(metadata, state).await;
+    }
+    let family = hotbar_family(metadata, state).await?;
+    let expected = materialization_hash(
+        &metadata.instance.id,
+        SyncedOption::CreativeHotbars,
+        family.as_str(),
+        state,
+    )
+    .await?;
+    let actual = sha1_file(&local).await?;
+    if expected.as_deref() == Some(actual.as_str()) {
+        return Ok(());
+    }
+
+    let changed = read_nbt_file(&local).await?;
+    let mut sync_state = read_hotbar_state(state).await?;
+    merge_hotbar_family(&mut sync_state, family, changed);
+    write_hotbar_state(state, &sync_state).await?;
+    regenerate_hotbars(state).await
+}
+
+fn merge_hotbar_family(
+    state: &mut NbtCompound,
+    family: HotbarFamily,
+    changed: NbtCompound,
+) {
+    let family_key = family_state_key(family);
+    let previous = state
+        .get::<_, &NbtCompound>(family_key)
+        .ok()
+        .cloned()
+        .unwrap_or_else(empty_hotbar_root);
+    let other_family = match family {
+        HotbarFamily::Legacy => HotbarFamily::Components,
+        HotbarFamily::Components => HotbarFamily::Legacy,
+    };
+    let other_key = family_state_key(other_family);
+    let mut other = state.get::<_, &NbtCompound>(other_key).ok().cloned();
+
+    let seed_components_with_legacy =
+        other.is_none() && family == HotbarFamily::Legacy;
+    if seed_components_with_legacy {
+        other = Some(changed.clone());
+    }
+    let mut other_root = other.unwrap_or_else(empty_hotbar_root);
+    let mut revisions = state
+        .get::<_, &NbtCompound>("Revisions")
+        .ok()
+        .cloned()
+        .unwrap_or_default();
+
+    for slot in 0..81 {
+        let old_slot = hotbar_slot(&previous, slot);
+        let new_slot = hotbar_slot(&changed, slot);
+        if old_slot == new_slot {
+            continue;
+        }
+        let revision = revisions
+            .get::<_, i64>(&slot.to_string())
+            .unwrap_or(0)
+            .saturating_add(1);
+        revisions.insert(slot.to_string(), revision);
+        if let Some(slot_value) = (!seed_components_with_legacy)
+            .then_some(new_slot)
+            .flatten()
+            .and_then(|value| convert_hotbar_slot(value, family, other_family))
+        {
+            set_hotbar_slot(&mut other_root, slot, slot_value);
+        }
+    }
+
+    state.insert(family_key, changed);
+    state.insert(other_key, other_root);
+    state.insert("Revisions", revisions);
+}
+
+fn convert_hotbar_slot(
+    value: NbtTag,
+    from: HotbarFamily,
+    to: HotbarFamily,
+) -> Option<NbtTag> {
+    if from == to {
+        return Some(value);
+    }
+    let NbtTag::Compound(item) = value else {
+        return None;
+    };
+    if item.is_empty() {
+        return Some(NbtCompound::new().into());
+    }
+    let id = item.get::<_, &str>("id").ok()?.to_string();
+
+    match (from, to) {
+        (HotbarFamily::Legacy, HotbarFamily::Components) => {
+            if item.contains_key("tag") {
+                return None;
+            }
+            let count = item
+                .get::<_, i8>("Count")
+                .map(i32::from)
+                .or_else(|_| item.get::<_, i32>("Count"))
+                .unwrap_or(1);
+            let mut converted = NbtCompound::new();
+            converted.insert("id", id);
+            converted.insert("count", count);
+            Some(converted.into())
+        }
+        (HotbarFamily::Components, HotbarFamily::Legacy) => {
+            if item
+                .get::<_, &NbtCompound>("components")
+                .is_ok_and(|components| !components.is_empty())
+            {
+                return None;
+            }
+            let count = item.get::<_, i32>("count").unwrap_or(1);
+            let count = i8::try_from(count).ok()?;
+            let mut converted = NbtCompound::new();
+            converted.insert("id", id);
+            converted.insert("Count", count);
+            Some(converted.into())
+        }
+        _ => Some(item.into()),
+    }
+}
+
+fn hotbar_slot(root: &NbtCompound, slot: usize) -> Option<NbtTag> {
+    let toolbar = (slot / 9).to_string();
+    let position = slot % 9;
+    root.get::<_, &NbtList>(&toolbar)
+        .ok()
+        .and_then(|list| list.iter().nth(position).cloned())
+}
+
+fn set_hotbar_slot(root: &mut NbtCompound, slot: usize, value: NbtTag) {
+    let toolbar = (slot / 9).to_string();
+    let position = slot % 9;
+    let mut list = root
+        .get::<_, &NbtList>(&toolbar)
+        .ok()
+        .cloned()
+        .unwrap_or_default();
+    while list.len() < 9 {
+        list.push(NbtCompound::new());
+    }
+    list[position] = value;
+    root.insert(toolbar, list);
+}
+
+async fn regenerate_hotbars(state: &State) -> crate::Result<()> {
+    let instances = crate::state::list_instances(&state.pool).await?;
+    for metadata in instances {
+        if option_effective(&metadata, SyncedOption::CreativeHotbars, state)
+            .await?
+        {
+            materialize_hotbars_for_instance(&metadata, state).await?;
+        }
+    }
+    Ok(())
+}
+
+async fn materialize_hotbars_for_instance(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<()> {
+    let sync_state = read_hotbar_state(state).await?;
+    let legacy = sync_state
+        .get::<_, &NbtCompound>("Legacy")
+        .ok()
+        .cloned()
+        .unwrap_or_else(empty_hotbar_root);
+    let components = sync_state
+        .get::<_, &NbtCompound>("Components")
+        .ok()
+        .cloned()
+        .unwrap_or_else(|| legacy.clone());
+
+    for (family, root) in [
+        (HotbarFamily::Legacy, legacy),
+        (HotbarFamily::Components, components),
+    ] {
+        let path = generated_hotbar_path(state, family, &metadata.instance.id);
+        if let Some(parent) = path.parent() {
+            io::create_dir_all(parent).await?;
+        }
+        write_nbt_file(&path, &root).await?;
+    }
+
+    let family = hotbar_family(metadata, state).await?;
+    let generated = generated_hotbar_path(state, family, &metadata.instance.id);
+    let local = instance_dir(metadata, state).join(HOTBAR_FILE);
+    let mode = ensure_link(&generated, &local).await?;
+    record_materialization(
+        &metadata.instance.id,
+        SyncedOption::CreativeHotbars,
+        family.as_str(),
+        Some(&sha1_file(&generated).await?),
+        mode,
+        state,
+    )
+    .await
+}
+
+fn empty_hotbar_root() -> NbtCompound {
+    let mut root = NbtCompound::new();
+    for toolbar in 0..9 {
+        let mut items = NbtList::new();
+        for _ in 0..9 {
+            items.push(NbtCompound::new());
+        }
+        root.insert(toolbar.to_string(), items);
+    }
+    root
+}
+
+async fn read_hotbar_state(state: &State) -> crate::Result<NbtCompound> {
+    let path = hotbar_state_path(state);
+    if !path.exists() {
+        let mut root = NbtCompound::new();
+        root.insert("Version", 1_i32);
+        return Ok(root);
+    }
+    read_nbt_file(&path).await
+}
+
+async fn write_hotbar_state(
+    state: &State,
+    root: &NbtCompound,
+) -> crate::Result<()> {
+    write_nbt_file(&hotbar_state_path(state), root).await
+}
+
+fn family_state_key(family: HotbarFamily) -> &'static str {
+    match family {
+        HotbarFamily::Legacy => "Legacy",
+        HotbarFamily::Components => "Components",
+    }
+}
+
+fn command_history_path(state: &State) -> PathBuf {
+    synced_options_path(state).join(COMMAND_HISTORY_FILE)
+}
+
+fn hotbar_state_path(state: &State) -> PathBuf {
+    synced_options_path(state).join("hotbars/state.nbt")
+}
+
+fn generated_hotbar_path(
+    state: &State,
+    family: HotbarFamily,
+    instance_id: &str,
+) -> PathBuf {
+    synced_options_path(state)
+        .join("hotbars/generated")
+        .join(family.as_str())
+        .join(safe_instance_id(instance_id))
+        .join(HOTBAR_FILE)
+}
+
+pub(super) fn safe_instance_id(instance_id: &str) -> String {
+    instance_id.replace([':', '/', '\\'], "_")
+}
+
+pub(super) fn instance_dir(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> PathBuf {
+    state
+        .directories
+        .instances_dir()
+        .join(&metadata.instance.path)
+}
+
+async fn option_effective(
+    metadata: &InstanceMetadata,
+    option: SyncedOption,
+    state: &State,
+) -> crate::Result<bool> {
+    if sync_files_are_protected(metadata)
+        || instance_is_running(metadata, state)
+    {
+        return Ok(false);
+    }
+    let global = get_global_options_with_state(state).await?;
+    Ok(instance_option_enabled(metadata, option)
+        && capability(metadata, option, global.get(option), state)
+            .await
+            .supported)
+}
+
+pub(super) fn sync_files_are_protected(metadata: &InstanceMetadata) -> bool {
+    matches!(
+        metadata.instance.install_stage,
+        InstanceInstallStage::MinecraftInstalling
+            | InstanceInstallStage::PackInstalling
+    )
+}
+
+pub(super) fn instance_is_running(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> bool {
+    state
+        .process_manager
+        .get_all()
+        .iter()
+        .any(|process| process.instance_id == metadata.instance.id)
+}
+
+pub(super) fn instance_option_enabled(
+    metadata: &InstanceMetadata,
+    option: SyncedOption,
+) -> bool {
+    match option {
+        SyncedOption::CommandHistory => metadata.synced_options.command_history,
+        SyncedOption::MultiplayerServers => {
+            metadata.synced_options.multiplayer_servers
+        }
+        SyncedOption::CreativeHotbars => {
+            metadata.synced_options.creative_hotbars
+        }
+        SyncedOption::Screenshots => metadata.synced_options.screenshots,
+    }
+}
+
+fn is_linked_server_project(link: &InstanceLink) -> bool {
+    matches!(
+        link,
+        InstanceLink::ServerProject { .. }
+            | InstanceLink::ServerProjectModpack { .. }
+            | InstanceLink::ModrinthHosting { .. }
+    )
+}
+
+fn option_from_str(value: &str) -> Option<SyncedOption> {
+    match value {
+        "command_history" => Some(SyncedOption::CommandHistory),
+        "multiplayer_servers" => Some(SyncedOption::MultiplayerServers),
+        "creative_hotbars" => Some(SyncedOption::CreativeHotbars),
+        "screenshots" => Some(SyncedOption::Screenshots),
+        _ => None,
+    }
+}
+
+pub(super) async fn ensure_link(
+    source: &Path,
+    target: &Path,
+) -> crate::Result<LinkMode> {
+    if let Some(parent) = target.parent() {
+        io::create_dir_all(parent).await?;
+    }
+    if tokio::fs::symlink_metadata(target)
+        .await
+        .is_ok_and(|metadata| metadata.file_type().is_symlink())
+        && tokio::fs::read_link(target)
+            .await
+            .is_ok_and(|current| current == source)
+    {
+        return Ok(LinkMode::Symbolic);
+    }
+    if tokio::fs::symlink_metadata(target).await.is_ok() {
+        io::remove_file(target).await?;
+    }
+
+    #[cfg(unix)]
+    {
+        tokio::fs::symlink(source, target).await?;
+        Ok(LinkMode::Symbolic)
+    }
+    #[cfg(windows)]
+    {
+        if tokio::fs::symlink_file(source, target).await.is_ok() {
+            return Ok(LinkMode::Symbolic);
+        }
+        if tokio::fs::hard_link(source, target).await.is_ok() {
+            return Ok(LinkMode::Hard);
+        }
+        io::copy(source, target).await?;
+        Ok(LinkMode::Copy)
+    }
+}
+
+pub(super) async fn detach_link(
+    source: &Path,
+    target: &Path,
+) -> crate::Result<()> {
+    let contents = if source.exists() {
+        Some(io::read(source).await?)
+    } else if target.exists() {
+        Some(io::read(target).await?)
+    } else {
+        None
+    };
+    if tokio::fs::symlink_metadata(target).await.is_ok() {
+        io::remove_file(target).await?;
+    }
+    if let Some(contents) = contents {
+        io::write(target, contents).await?;
+    }
+    Ok(())
+}
+
+pub(super) async fn record_materialization(
+    instance_id: &str,
+    option: SyncedOption,
+    family: &str,
+    expected_sha1: Option<&str>,
+    mode: LinkMode,
+    state: &State,
+) -> crate::Result<()> {
+	let option_name = option.as_str();
+	let link_mode = mode.as_str();
+	sqlx::query!(
+		"
+		INSERT INTO synced_option_materializations
+			(instance_id, option, family, expected_sha1, link_mode)
+		VALUES (?, ?, ?, ?, ?)
+		ON CONFLICT(instance_id, option, family) DO UPDATE SET
+			expected_sha1 = excluded.expected_sha1,
+			link_mode = excluded.link_mode
+		",
+		instance_id,
+		option_name,
+		family,
+		expected_sha1,
+		link_mode,
+	)
+	.execute(&state.pool)
+    .await?;
+    Ok(())
+}
+
+async fn materialization_hash(
+    instance_id: &str,
+    option: SyncedOption,
+    family: &str,
+    state: &State,
+) -> crate::Result<Option<String>> {
+	let option_name = option.as_str();
+	Ok(sqlx::query_scalar!(
+		"
+		SELECT expected_sha1
+		FROM synced_option_materializations
+		WHERE instance_id = ? AND option = ? AND family = ?
+		",
+		instance_id,
+		option_name,
+		family,
+	)
+	.fetch_optional(&state.pool)
+	.await?
+	.flatten())
+}
+
+pub(super) async fn sha1_file(path: &Path) -> crate::Result<String> {
+    Ok(Sha1::from(io::read(path).await?).digest().to_string())
+}
+
+pub(super) async fn read_nbt_file(path: &Path) -> crate::Result<NbtCompound> {
+    let bytes = io::read(path).await?;
+    let (root, _) = quartz_nbt::io::read_nbt(
+        &mut Cursor::new(bytes),
+        quartz_nbt::io::Flavor::Uncompressed,
+    )?;
+    Ok(root)
+}
+
+pub(super) async fn write_nbt_file(
+    path: &Path,
+    root: &NbtCompound,
+) -> crate::Result<()> {
+    if let Some(parent) = path.parent() {
+        io::create_dir_all(parent).await?;
+    }
+    let mut bytes = Vec::new();
+    quartz_nbt::io::write_nbt(
+        &mut bytes,
+        None,
+        root,
+        quartz_nbt::io::Flavor::Uncompressed,
+    )?;
+    io::write(path, bytes).await?;
+    Ok(())
+}
+
+pub(super) fn nbt_to_bytes(root: &NbtCompound) -> crate::Result<Vec<u8>> {
+    let mut bytes = Vec::new();
+    quartz_nbt::io::write_nbt(
+        &mut bytes,
+        None,
+        root,
+        quartz_nbt::io::Flavor::Uncompressed,
+    )?;
+    Ok(bytes)
+}
+
+pub(super) fn nbt_from_bytes(bytes: Vec<u8>) -> crate::Result<NbtCompound> {
+    let (root, _) = quartz_nbt::io::read_nbt(
+        &mut Cursor::new(bytes),
+        quartz_nbt::io::Flavor::Uncompressed,
+    )?;
+    Ok(root)
+}
diff --git a/packages/app-lib/src/api/instance/synced_servers.rs b/packages/app-lib/src/api/instance/synced_servers.rs
new file mode 100644
index 0000000000..51095250a5
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_servers.rs
@@ -0,0 +1,1185 @@
+use super::synced_options::{
+    detach_link, ensure_link, instance_dir, instance_is_running,
+    instance_option_enabled, nbt_from_bytes, nbt_to_bytes, read_nbt_file,
+    record_materialization, safe_instance_id, sha1_file,
+    sync_files_are_protected, synced_options_path, write_nbt_file,
+};
+use crate::state::{CachedEntry, InstanceLink, InstanceMetadata, SyncedOption};
+use crate::util::fetch::{DownloadMeta, DownloadReason, fetch_mirrors};
+use crate::{ErrorKind, State};
+use async_zip::base::read::seek::ZipFileReader;
+use quartz_nbt::{NbtCompound, NbtList, NbtTag};
+use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
+use std::io::Cursor;
+use std::path::{Path, PathBuf};
+use uuid::Uuid;
+
+const SERVERS_FILE: &str = "servers.dat";
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ServerSource {
+    UserSynced,
+    Modpack,
+    LinkedServerProject,
+    LocalDesynced,
+}
+
+impl ServerSource {
+    fn as_str(self) -> &'static str {
+        match self {
+            Self::UserSynced => "user_synced",
+            Self::Modpack => "modpack",
+            Self::LinkedServerProject => "linked_server_project",
+            Self::LocalDesynced => "local_desynced",
+        }
+    }
+
+    fn from_str(value: &str) -> Option<Self> {
+        match value {
+            "user_synced" => Some(Self::UserSynced),
+            "modpack" => Some(Self::Modpack),
+            "linked_server_project" => Some(Self::LinkedServerProject),
+            "local_desynced" => Some(Self::LocalDesynced),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum DesyncServerMode {
+    KeepInOtherInstances,
+    RemoveFromOtherInstances,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct SyncedServer {
+    pub id: String,
+    pub name: String,
+    pub address: String,
+    pub accept_textures: Option<bool>,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct ServerRecord {
+    pub id: String,
+    pub source: ServerSource,
+    pub data: NbtCompound,
+}
+
+impl ServerRecord {
+    pub fn name(&self) -> String {
+        self.data
+            .get::<_, &str>("name")
+            .unwrap_or_default()
+            .to_string()
+    }
+
+    pub fn address(&self) -> String {
+        self.data
+            .get::<_, &str>("ip")
+            .unwrap_or_default()
+            .to_string()
+    }
+
+    pub fn icon(&self) -> Option<String> {
+        self.data.get::<_, &str>("icon").ok().map(ToOwned::to_owned)
+    }
+
+    pub fn hidden(&self) -> bool {
+        self.data.get::<_, i8>("hidden").unwrap_or(0) != 0
+    }
+
+    pub fn accept_textures(&self) -> Option<bool> {
+        self.data
+            .get::<_, i8>("acceptTextures")
+            .ok()
+            .map(|value| value != 0)
+    }
+}
+
+#[derive(Clone)]
+struct CanonicalServer {
+    id: String,
+    data: NbtCompound,
+}
+
+#[derive(Clone)]
+struct LocalServer {
+    id: String,
+    source: ServerSource,
+    canonical_id: Option<String>,
+    data: NbtCompound,
+    position: i64,
+}
+
+#[derive(Clone)]
+struct SnapshotServer {
+    id: String,
+    source: ServerSource,
+    data: NbtCompound,
+}
+
+pub(super) async fn seed_servers(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<()> {
+    if is_modpack_link(&metadata.link)
+        && (!baseline_matches_link(metadata, state).await?
+            || !baseline_was_reconstructed(&metadata.instance.id, state)
+                .await?)
+    {
+        if let Err(error) = reconstruct_modpack_servers(metadata, state).await {
+            tracing::warn!(
+                "Failed to reconstruct the server baseline for {}: {error}",
+                metadata.instance.id
+            );
+        }
+    }
+    let local_entries = load_local(&metadata.instance.id, state).await?;
+    if is_modpack_link(&metadata.link)
+        && !baseline_was_reconstructed(&metadata.instance.id, state).await?
+    {
+        return Err(ErrorKind::InputError(
+			"This linked modpack cannot be used as the multiplayer base until its supplied server list has been reconstructed. Choose an unmanaged instance instead."
+				.to_string(),
+		)
+		.into());
+    }
+    let path = instance_dir(metadata, state).join(SERVERS_FILE);
+    let mut servers = read_servers(&path).await?;
+    if is_modpack_link(&metadata.link) {
+        for local in &local_entries {
+            if let Some(index) = servers.iter().position(|data| {
+                data == &local.data
+                    || server_address(data) == server_address(&local.data)
+            }) {
+                servers.remove(index);
+            }
+        }
+    } else {
+		sqlx::query!(
+			"DELETE FROM instance_server_entries WHERE instance_id = ?",
+			metadata.instance.id,
+		)
+		.execute(&state.pool)
+		.await?;
+	}
+	sqlx::query!(
+		"DELETE FROM instance_server_snapshots WHERE instance_id = ?",
+		metadata.instance.id,
+	)
+		.execute(&state.pool)
+        .await?;
+    let canonical = servers
+        .into_iter()
+        .map(|data| CanonicalServer {
+            id: Uuid::new_v4().to_string(),
+            data,
+        })
+        .collect::<Vec<_>>();
+    write_canonical(state, &canonical).await?;
+    regenerate_servers(state).await
+}
+
+pub(super) async fn ensure_servers(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<()> {
+    if is_modpack_link(&metadata.link)
+        && !baseline_matches_link(metadata, state).await?
+        && let Err(error) = reconstruct_modpack_servers(metadata, state).await
+    {
+        tracing::warn!(
+            "Failed to reconstruct the server baseline for {}; preserving its current server list locally: {error}",
+            metadata.instance.id
+        );
+        let path = instance_dir(metadata, state).join(SERVERS_FILE);
+        let servers = read_servers(&path).await?;
+        replace_modpack_servers(metadata, servers, false, state).await?;
+    }
+    let canonical_path = canonical_path(state);
+    if !canonical_path.exists() {
+        if !is_modpack_link(&metadata.link) {
+            let servers =
+                read_servers(&instance_dir(metadata, state).join(SERVERS_FILE))
+                    .await?;
+            let canonical = servers
+                .into_iter()
+                .map(|data| CanonicalServer {
+                    id: Uuid::new_v4().to_string(),
+                    data,
+                })
+                .collect::<Vec<_>>();
+            write_canonical(state, &canonical).await?;
+        } else {
+            write_canonical(state, &[]).await?;
+        }
+    }
+    compose_instance(metadata, state).await
+}
+
+pub(super) async fn detach_servers(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<()> {
+    let generated = generated_path(state, &metadata.instance.id);
+    let local = instance_dir(metadata, state).join(SERVERS_FILE);
+    detach_link(&generated, &local).await
+}
+
+pub async fn capture_modpack_servers(instance_id: &str) -> crate::Result<()> {
+    let state = State::get().await?;
+    let metadata = crate::state::get_instance(instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| ErrorKind::InputError("Unknown instance".to_string()))?;
+    let path = instance_dir(&metadata, &state).join(SERVERS_FILE);
+    let servers = read_servers(&path).await?;
+    replace_modpack_servers(&metadata, servers, true, &state).await?;
+    if effective(&metadata, &state).await? {
+        compose_instance(&metadata, &state).await?;
+    }
+    Ok(())
+}
+
+pub async fn clear_modpack_servers(instance_id: &str) -> crate::Result<()> {
+    let state = State::get().await?;
+    let metadata = crate::state::get_instance(instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| ErrorKind::InputError("Unknown instance".to_string()))?;
+    replace_modpack_servers(&metadata, Vec::new(), true, &state).await?;
+    if effective(&metadata, &state).await? {
+        compose_instance(&metadata, &state).await?;
+    }
+    Ok(())
+}
+
+async fn replace_modpack_servers(
+    metadata: &InstanceMetadata,
+    servers: Vec<NbtCompound>,
+    reconstructed: bool,
+    state: &State,
+) -> crate::Result<()> {
+    let mut tx = state.pool.begin().await?;
+	sqlx::query!(
+		"DELETE FROM instance_server_entries WHERE instance_id = ? AND source = 'modpack'",
+		metadata.instance.id,
+	)
+	.execute(&mut *tx)
+	.await?;
+	for (position, server) in servers.into_iter().enumerate() {
+		let id = Uuid::new_v4().to_string();
+		let source = ServerSource::Modpack.as_str();
+		let nbt = nbt_to_bytes(&server)?;
+		let position = position as i64;
+		sqlx::query!(
+			"
+			INSERT INTO instance_server_entries
+				(instance_id, id, source, canonical_id, nbt, position)
+			VALUES (?, ?, ?, NULL, ?, ?)
+			",
+			metadata.instance.id,
+			id,
+			source,
+			nbt,
+			position,
+		)
+		.execute(&mut *tx)
+        .await?;
+    }
+	let version_id = modpack_version_id(&metadata.link);
+	sqlx::query!(
+		"
+		INSERT INTO instance_server_baselines
+			(instance_id, version_id, reconstructed)
+		VALUES (?, ?, ?)
+		ON CONFLICT(instance_id) DO UPDATE SET
+			version_id = excluded.version_id,
+			reconstructed = excluded.reconstructed
+		",
+		metadata.instance.id,
+		version_id,
+		reconstructed,
+	)
+	.execute(&mut *tx)
+    .await?;
+    tx.commit().await?;
+    Ok(())
+}
+
+async fn baseline_matches_link(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<bool> {
+	let row = sqlx::query!(
+		"
+		SELECT version_id
+		FROM instance_server_baselines
+		WHERE instance_id = ?
+		",
+		metadata.instance.id,
+	)
+	.fetch_optional(&state.pool)
+	.await?;
+	Ok(row.is_some_and(|row| {
+		row.version_id.as_deref() == modpack_version_id(&metadata.link)
+	}))
+}
+
+async fn baseline_was_reconstructed(
+    instance_id: &str,
+    state: &State,
+) -> crate::Result<bool> {
+	Ok(sqlx::query_scalar!(
+		r#"
+		SELECT reconstructed AS "reconstructed!: bool"
+		FROM instance_server_baselines
+		WHERE instance_id = ?
+		"#,
+		instance_id,
+	)
+	.fetch_optional(&state.pool)
+    .await?
+    .unwrap_or(false))
+}
+
+async fn reconstruct_modpack_servers(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<()> {
+    let version_id = modpack_version_id(&metadata.link).ok_or_else(|| {
+        ErrorKind::InputError(
+            "This modpack does not have a recoverable Modrinth version."
+                .to_string(),
+        )
+    })?;
+    let version = CachedEntry::get_version(
+        version_id,
+        None,
+        &state.pool,
+        &state.api_semaphore,
+    )
+    .await?
+    .ok_or_else(|| {
+        ErrorKind::InputError(format!(
+            "Modpack version {version_id} could not be found"
+        ))
+    })?;
+    let primary_file = version
+        .files
+        .iter()
+        .find(|file| file.primary)
+        .or_else(|| version.files.first())
+        .ok_or_else(|| {
+            ErrorKind::InputError(format!(
+                "Modpack version {version_id} has no downloadable file"
+            ))
+        })?;
+    let download_meta = DownloadMeta {
+        reason: DownloadReason::Modpack,
+        game_version: metadata.applied_content_set.game_version.clone(),
+        loader: metadata.applied_content_set.loader.as_str().to_string(),
+        dependent_on: Some(version_id.to_string()),
+    };
+    let mrpack = fetch_mirrors(
+        &[&primary_file.url],
+        primary_file.hashes.get("sha1").map(String::as_str),
+        Some(&download_meta),
+        None,
+        &state.api_semaphore,
+        &state.pool,
+    )
+    .await?;
+    let mut archive = ZipFileReader::with_tokio(Cursor::new(&mrpack)).await?;
+    let mut selected = None;
+    for (index, entry) in archive.file().entries().iter().enumerate() {
+        let Ok(filename) = entry.filename().as_str() else {
+            continue;
+        };
+        let priority = if filename == "client-overrides/servers.dat" {
+            2
+        } else if filename == "overrides/servers.dat" {
+            1
+        } else {
+            continue;
+        };
+        if selected
+            .is_none_or(|(selected_priority, _)| priority >= selected_priority)
+        {
+            selected = Some((priority, index));
+        }
+    }
+
+    let servers = if let Some((_, index)) = selected {
+        let mut bytes = Vec::new();
+        let mut reader = archive.reader_with_entry(index).await?;
+        reader.read_to_end_checked(&mut bytes).await?;
+        servers_from_bytes(bytes)?
+    } else {
+        Vec::new()
+    };
+    replace_modpack_servers(metadata, servers, true, state).await
+}
+
+pub(super) async fn reconcile_servers(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<()> {
+    if !effective(metadata, state).await? {
+        return Ok(());
+    }
+    let local_path = instance_dir(metadata, state).join(SERVERS_FILE);
+    if !local_path.exists() {
+        return compose_instance(metadata, state).await;
+    }
+	let expected = sqlx::query_scalar!(
+		"
+		SELECT expected_sha1 FROM synced_option_materializations
+		WHERE instance_id = ? AND option = 'multiplayer_servers' AND family = ''
+		",
+		metadata.instance.id,
+	)
+	.fetch_optional(&state.pool)
+	.await?
+	.flatten();
+    let actual = sha1_file(&local_path).await?;
+    if expected.as_deref() == Some(actual.as_str()) {
+        return Ok(());
+    }
+
+    let current = read_servers(&local_path).await?;
+    let snapshots = load_snapshots(&metadata.instance.id, state).await?;
+    let mut matched = HashSet::new();
+    let mut canonical = read_canonical(state).await?;
+    let mut locals = load_local(&metadata.instance.id, state).await?;
+
+    for (position, data) in current.into_iter().enumerate() {
+        let snapshot = snapshots
+            .iter()
+            .filter(|snapshot| !matched.contains(&snapshot.id))
+            .find(|snapshot| snapshot.data == data)
+            .or_else(|| {
+                snapshots
+                    .iter()
+                    .filter(|snapshot| !matched.contains(&snapshot.id))
+                    .find(|snapshot| {
+                        server_address(&snapshot.data) == server_address(&data)
+                    })
+            })
+            .or_else(|| snapshots.get(position));
+
+        if let Some(snapshot) = snapshot {
+            matched.insert(snapshot.id.clone());
+            match snapshot.source {
+                ServerSource::UserSynced => {
+                    if let Some(server) = canonical
+                        .iter_mut()
+                        .find(|server| server.id == snapshot.id)
+                    {
+                        server.data = data;
+                    }
+                }
+                _ => {
+                    if let Some(server) = locals
+                        .iter_mut()
+                        .find(|server| server.id == snapshot.id)
+                    {
+                        server.data = data;
+                        server.position = position as i64;
+                    }
+                }
+            }
+        } else {
+            canonical.push(CanonicalServer {
+                id: Uuid::new_v4().to_string(),
+                data,
+            });
+        }
+    }
+
+    canonical.retain(|server| {
+        !snapshots.iter().any(|snapshot| {
+            snapshot.source == ServerSource::UserSynced
+                && snapshot.id == server.id
+                && !matched.contains(&snapshot.id)
+        })
+    });
+    write_canonical(state, &canonical).await?;
+    write_local(&metadata.instance.id, &locals, state).await?;
+    regenerate_servers(state).await
+}
+
+pub(crate) async fn list_server_records(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<Vec<ServerRecord>> {
+    if effective(metadata, state).await? {
+        let snapshots = load_snapshots(&metadata.instance.id, state).await?;
+        if !snapshots.is_empty() {
+            return Ok(snapshots
+                .into_iter()
+                .map(|snapshot| ServerRecord {
+                    id: snapshot.id,
+                    source: snapshot.source,
+                    data: snapshot.data,
+                })
+                .collect());
+        }
+    }
+    Ok(
+        read_servers(&instance_dir(metadata, state).join(SERVERS_FILE))
+            .await?
+            .into_iter()
+            .map(|data| ServerRecord {
+                id: Uuid::new_v4().to_string(),
+                source: ServerSource::LocalDesynced,
+                data,
+            })
+            .collect(),
+    )
+}
+
+pub(crate) async fn add_user_server(
+    metadata: &InstanceMetadata,
+    mut data: NbtCompound,
+    state: &State,
+) -> crate::Result<String> {
+    let id = Uuid::new_v4().to_string();
+    if effective(metadata, state).await? {
+        let mut canonical = read_canonical(state).await?;
+        canonical.push(CanonicalServer {
+            id: id.clone(),
+            data,
+        });
+        write_canonical(state, &canonical).await?;
+        regenerate_servers(state).await?;
+    } else {
+        let path = instance_dir(metadata, state).join(SERVERS_FILE);
+        let mut servers = read_servers(&path).await?;
+        let insert_index = servers
+            .iter()
+            .position(server_hidden)
+            .unwrap_or(servers.len());
+        servers.insert(insert_index, std::mem::take(&mut data));
+        write_servers(&path, &servers).await?;
+    }
+    Ok(id)
+}
+
+pub(crate) async fn update_server(
+    metadata: &InstanceMetadata,
+    server_id: &str,
+    data: NbtCompound,
+    state: &State,
+) -> crate::Result<()> {
+    if effective(metadata, state).await? {
+        let snapshots = load_snapshots(&metadata.instance.id, state).await?;
+        let snapshot = snapshots
+            .iter()
+            .find(|snapshot| snapshot.id == server_id)
+            .ok_or_else(|| {
+                ErrorKind::InputError("Unknown server".to_string())
+            })?;
+        if snapshot.source == ServerSource::UserSynced {
+            let mut canonical = read_canonical(state).await?;
+            let server = canonical
+                .iter_mut()
+                .find(|server| server.id == server_id)
+                .ok_or_else(|| {
+                    ErrorKind::InputError("Unknown server".to_string())
+                })?;
+            server.data = data;
+            write_canonical(state, &canonical).await?;
+        } else {
+            let mut locals = load_local(&metadata.instance.id, state).await?;
+            let server = locals
+                .iter_mut()
+                .find(|server| server.id == server_id)
+                .ok_or_else(|| {
+                    ErrorKind::InputError("Unknown server".to_string())
+                })?;
+            server.data = data;
+            write_local(&metadata.instance.id, &locals, state).await?;
+        }
+        regenerate_servers(state).await?;
+        return Ok(());
+    }
+    Err(ErrorKind::InputError(
+        "Stable server editing requires multiplayer syncing for this instance."
+            .to_string(),
+    )
+    .into())
+}
+
+pub(crate) async fn update_server_by_index(
+    metadata: &InstanceMetadata,
+    index: usize,
+    name: String,
+    address: String,
+    accept_textures: Option<bool>,
+    state: &State,
+) -> crate::Result<()> {
+    if effective(metadata, state).await? {
+        let records = list_server_records(metadata, state).await?;
+        let record = records
+            .get(index)
+            .filter(|record| !record.hidden())
+            .ok_or_else(|| {
+                ErrorKind::InputError(format!(
+                    "No editable server at index {index}"
+                ))
+            })?;
+        let mut data = record.data.clone();
+        update_server_data(&mut data, name, address, accept_textures);
+        return update_server(metadata, &record.id, data, state).await;
+    }
+    let path = instance_dir(metadata, state).join(SERVERS_FILE);
+    let mut servers = read_servers(&path).await?;
+    let server = servers
+        .get_mut(index)
+        .filter(|server| !server_hidden(server))
+        .ok_or_else(|| {
+            ErrorKind::InputError(format!(
+                "No editable server at index {index}"
+            ))
+        })?;
+    update_server_data(server, name, address, accept_textures);
+    write_servers(&path, &servers).await
+}
+
+pub(crate) async fn remove_server(
+    metadata: &InstanceMetadata,
+    server_id: &str,
+    state: &State,
+) -> crate::Result<()> {
+    if !effective(metadata, state).await? {
+        return Err(ErrorKind::InputError(
+			"Stable server removal requires multiplayer syncing for this instance."
+				.to_string(),
+		)
+		.into());
+    }
+    let snapshots = load_snapshots(&metadata.instance.id, state).await?;
+    let snapshot = snapshots
+        .iter()
+        .find(|snapshot| snapshot.id == server_id)
+        .ok_or_else(|| {
+        ErrorKind::InputError("Unknown server".to_string())
+    })?;
+    if snapshot.source == ServerSource::UserSynced {
+        let mut canonical = read_canonical(state).await?;
+        canonical.retain(|server| server.id != server_id);
+        write_canonical(state, &canonical).await?;
+    } else {
+        let mut locals = load_local(&metadata.instance.id, state).await?;
+        locals.retain(|server| server.id != server_id);
+        write_local(&metadata.instance.id, &locals, state).await?;
+    }
+    regenerate_servers(state).await
+}
+
+pub(crate) async fn remove_server_by_index(
+    metadata: &InstanceMetadata,
+    index: usize,
+    state: &State,
+) -> crate::Result<()> {
+    if effective(metadata, state).await? {
+        let records = list_server_records(metadata, state).await?;
+        let record = records
+            .get(index)
+            .filter(|record| !record.hidden())
+            .ok_or_else(|| {
+                ErrorKind::InputError(format!(
+                    "No removable server at index {index}"
+                ))
+            })?;
+        return remove_server(metadata, &record.id, state).await;
+    }
+    let path = instance_dir(metadata, state).join(SERVERS_FILE);
+    let mut servers = read_servers(&path).await?;
+    if servers.get(index).is_none_or(server_hidden) {
+        return Err(ErrorKind::InputError(format!(
+            "No removable server at index {index}"
+        ))
+        .into());
+    }
+    servers.remove(index);
+    write_servers(&path, &servers).await
+}
+
+pub async fn desync_server(
+    instance_id: &str,
+    server_id: &str,
+    mode: DesyncServerMode,
+) -> crate::Result<()> {
+    let state = State::get().await?;
+    let metadata = crate::state::get_instance(instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| ErrorKind::InputError("Unknown instance".to_string()))?;
+    let mut canonical = read_canonical(&state).await?;
+    let server = canonical
+        .iter()
+        .find(|server| server.id == server_id)
+        .cloned()
+        .ok_or_else(|| {
+            ErrorKind::InputError(
+                "Only a synced user server can be desynced.".to_string(),
+            )
+        })?;
+    let mut locals = load_local(instance_id, &state).await?;
+    locals.push(LocalServer {
+        id: Uuid::new_v4().to_string(),
+        source: ServerSource::LocalDesynced,
+        canonical_id: (mode == DesyncServerMode::KeepInOtherInstances)
+            .then(|| server.id.clone()),
+        data: server.data,
+        position: locals.len() as i64,
+    });
+    if mode == DesyncServerMode::RemoveFromOtherInstances {
+        canonical.retain(|candidate| candidate.id != server_id);
+        write_canonical(&state, &canonical).await?;
+    }
+    write_local(instance_id, &locals, &state).await?;
+    regenerate_servers(&state).await?;
+    let _ = metadata;
+    Ok(())
+}
+
+pub async fn list_synced_servers() -> crate::Result<Vec<SyncedServer>> {
+    let state = State::get().await?;
+    Ok(read_canonical(&state)
+        .await?
+        .into_iter()
+        .map(|server| {
+            let CanonicalServer { id, data } = server;
+            SyncedServer {
+                id,
+                name: data
+                    .get::<_, &str>("name")
+                    .unwrap_or_default()
+                    .to_string(),
+                address: server_address(&data),
+                accept_textures: data
+                    .get::<_, i8>("acceptTextures")
+                    .ok()
+                    .map(|value| value != 0),
+            }
+        })
+        .collect())
+}
+
+pub async fn update_synced_server(server: SyncedServer) -> crate::Result<()> {
+    let state = State::get().await?;
+    let mut canonical = read_canonical(&state).await?;
+    let target = canonical
+        .iter_mut()
+        .find(|candidate| candidate.id == server.id)
+        .ok_or_else(|| {
+            ErrorKind::InputError("Unknown synced server".to_string())
+        })?;
+    update_server_data(
+        &mut target.data,
+        server.name,
+        server.address,
+        server.accept_textures,
+    );
+    write_canonical(&state, &canonical).await?;
+    regenerate_servers(&state).await
+}
+
+pub async fn remove_synced_server(server_id: &str) -> crate::Result<()> {
+    let state = State::get().await?;
+    let mut canonical = read_canonical(&state).await?;
+    let previous_len = canonical.len();
+    canonical.retain(|server| server.id != server_id);
+    if canonical.len() == previous_len {
+        return Err(
+            ErrorKind::InputError("Unknown synced server".to_string()).into()
+        );
+    }
+    write_canonical(&state, &canonical).await?;
+    regenerate_servers(&state).await
+}
+
+async fn compose_instance(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<()> {
+    let canonical = read_canonical(state).await?;
+    let locals = load_local(&metadata.instance.id, state).await?;
+    let exclusions = locals
+        .iter()
+        .filter_map(|server| server.canonical_id.as_deref())
+        .collect::<HashSet<_>>();
+    let mut records = canonical
+        .into_iter()
+        .filter(|server| !exclusions.contains(server.id.as_str()))
+        .map(|server| ServerRecord {
+            id: server.id,
+            source: ServerSource::UserSynced,
+            data: server.data,
+        })
+        .collect::<Vec<_>>();
+    let mut locals = locals;
+    locals.sort_by_key(|server| server.position);
+    records.extend(locals.into_iter().map(|server| ServerRecord {
+        id: server.id,
+        source: server.source,
+        data: server.data,
+    }));
+
+    let generated = generated_path(state, &metadata.instance.id);
+    write_servers(
+        &generated,
+        &records
+            .iter()
+            .map(|record| record.data.clone())
+            .collect::<Vec<_>>(),
+    )
+    .await?;
+    write_snapshots(&metadata.instance.id, &records, state).await?;
+    let target = instance_dir(metadata, state).join(SERVERS_FILE);
+    let mode = ensure_link(&generated, &target).await?;
+    record_materialization(
+        &metadata.instance.id,
+        SyncedOption::MultiplayerServers,
+        "",
+        Some(&sha1_file(&generated).await?),
+        mode,
+        state,
+    )
+    .await
+}
+
+async fn regenerate_servers(state: &State) -> crate::Result<()> {
+    for metadata in crate::state::list_instances(&state.pool).await? {
+        if effective(&metadata, state).await? {
+            compose_instance(&metadata, state).await?;
+        }
+    }
+    Ok(())
+}
+
+async fn effective(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<bool> {
+    if sync_files_are_protected(metadata)
+        || instance_is_running(metadata, state)
+        || !instance_option_enabled(metadata, SyncedOption::MultiplayerServers)
+        || is_linked_server_project(&metadata.link)
+    {
+        return Ok(false);
+    }
+	Ok(sqlx::query_scalar!(
+		r#"
+		SELECT EXISTS(
+			SELECT 1 FROM global_synced_options_overrides
+			WHERE option = 'multiplayer_servers' AND enabled = 1
+		) AS "enabled!: bool"
+		"#,
+	)
+    .fetch_one(&state.pool)
+    .await?)
+}
+
+async fn read_canonical(state: &State) -> crate::Result<Vec<CanonicalServer>> {
+    let path = canonical_path(state);
+    if !path.exists() {
+        return Ok(Vec::new());
+    }
+    let root = read_nbt_file(&path).await?;
+    let Some(list) = root.get::<_, &NbtList>("Servers").ok() else {
+        return Ok(Vec::new());
+    };
+    Ok(list
+        .iter()
+        .filter_map(|tag| {
+            let NbtTag::Compound(record) = tag else {
+                return None;
+            };
+            Some(CanonicalServer {
+                id: record.get::<_, &str>("Id").ok()?.to_string(),
+                data: record.get::<_, &NbtCompound>("Data").ok()?.clone(),
+            })
+        })
+        .collect())
+}
+
+async fn write_canonical(
+    state: &State,
+    servers: &[CanonicalServer],
+) -> crate::Result<()> {
+    let mut list = NbtList::new();
+    for server in servers {
+        let mut record = NbtCompound::new();
+        record.insert("Id", server.id.clone());
+        record.insert("Data", server.data.clone());
+        list.push(record);
+    }
+    let mut root = NbtCompound::new();
+    root.insert("Version", 1_i32);
+    root.insert("Servers", list);
+    write_nbt_file(&canonical_path(state), &root).await
+}
+
+pub(crate) async fn read_servers(
+    path: &Path,
+) -> crate::Result<Vec<NbtCompound>> {
+    if !path.exists() {
+        return Ok(Vec::new());
+    }
+    servers_from_root(read_nbt_file(path).await?)
+}
+
+fn servers_from_bytes(bytes: Vec<u8>) -> crate::Result<Vec<NbtCompound>> {
+    servers_from_root(nbt_from_bytes(bytes)?)
+}
+
+fn servers_from_root(root: NbtCompound) -> crate::Result<Vec<NbtCompound>> {
+    let Some(list) = root.get::<_, &NbtList>("servers").ok() else {
+        return Ok(Vec::new());
+    };
+    Ok(list
+        .iter()
+        .filter_map(|tag| match tag {
+            NbtTag::Compound(compound) => Some(compound.clone()),
+            _ => None,
+        })
+        .collect())
+}
+
+pub(crate) async fn write_servers(
+    path: &Path,
+    servers: &[NbtCompound],
+) -> crate::Result<()> {
+    let mut list = NbtList::new();
+    for server in servers {
+        list.push(server.clone());
+    }
+    let mut root = NbtCompound::new();
+    root.insert("servers", list);
+    write_nbt_file(path, &root).await
+}
+
+pub(crate) fn server_data(
+    name: String,
+    address: String,
+    accept_textures: Option<bool>,
+) -> NbtCompound {
+    let mut server = NbtCompound::new();
+    server.insert("name", name);
+    server.insert("ip", address);
+    if let Some(accept_textures) = accept_textures {
+        server.insert("acceptTextures", i8::from(accept_textures));
+    }
+    server.insert("hidden", 0_i8);
+    server
+}
+
+pub(crate) fn update_server_data(
+    server: &mut NbtCompound,
+    name: String,
+    address: String,
+    accept_textures: Option<bool>,
+) {
+    server.insert("name", name);
+    server.insert("ip", address);
+    match accept_textures {
+        Some(value) => server.insert("acceptTextures", i8::from(value)),
+        None => {
+            server.inner_mut().remove("acceptTextures");
+        }
+    }
+}
+
+fn server_hidden(server: &NbtCompound) -> bool {
+    server.get::<_, i8>("hidden").unwrap_or(0) != 0
+}
+
+fn server_address(server: &NbtCompound) -> String {
+    server.get::<_, &str>("ip").unwrap_or_default().to_string()
+}
+
+async fn load_local(
+    instance_id: &str,
+    state: &State,
+) -> crate::Result<Vec<LocalServer>> {
+	let rows = sqlx::query!(
+		"
+		SELECT id, source, canonical_id, nbt, position
+		FROM instance_server_entries
+		WHERE instance_id = ?
+		ORDER BY position
+		",
+		instance_id,
+	)
+		.fetch_all(&state.pool)
+		.await?;
+	rows.into_iter()
+		.map(|row| {
+			Ok(LocalServer {
+				id: row.id,
+				source: ServerSource::from_str(&row.source).ok_or_else(|| {
+					ErrorKind::InputError(format!(
+						"Unknown server source {}",
+						row.source
+					))
+				})?,
+				canonical_id: row.canonical_id,
+				data: nbt_from_bytes(row.nbt)?,
+				position: row.position,
+			})
+        })
+        .collect()
+}
+
+async fn write_local(
+    instance_id: &str,
+    servers: &[LocalServer],
+    state: &State,
+) -> crate::Result<()> {
+    let mut tx = state.pool.begin().await?;
+	sqlx::query!(
+		"DELETE FROM instance_server_entries WHERE instance_id = ?",
+		instance_id,
+	)
+		.execute(&mut *tx)
+	.await?;
+	for server in servers {
+		let source = server.source.as_str();
+		let nbt = nbt_to_bytes(&server.data)?;
+		sqlx::query!(
+			"
+			INSERT INTO instance_server_entries
+				(instance_id, id, source, canonical_id, nbt, position)
+			VALUES (?, ?, ?, ?, ?, ?)
+			",
+			instance_id,
+			server.id,
+			source,
+			server.canonical_id,
+			nbt,
+			server.position,
+		)
+		.execute(&mut *tx)
+        .await?;
+    }
+    tx.commit().await?;
+    Ok(())
+}
+
+async fn load_snapshots(
+    instance_id: &str,
+    state: &State,
+) -> crate::Result<Vec<SnapshotServer>> {
+	let rows = sqlx::query!(
+		"
+		SELECT server_id, source, nbt
+		FROM instance_server_snapshots
+		WHERE instance_id = ?
+		ORDER BY position
+		",
+		instance_id,
+	)
+	.fetch_all(&state.pool)
+	.await?;
+	rows.into_iter()
+		.map(|row| {
+			Ok(SnapshotServer {
+				id: row.server_id,
+				source: ServerSource::from_str(&row.source).ok_or_else(|| {
+					ErrorKind::InputError(format!(
+						"Unknown server source {}",
+						row.source
+					))
+				})?,
+				data: nbt_from_bytes(row.nbt)?,
+			})
+        })
+        .collect()
+}
+
+async fn write_snapshots(
+    instance_id: &str,
+    servers: &[ServerRecord],
+    state: &State,
+) -> crate::Result<()> {
+    let mut tx = state.pool.begin().await?;
+	sqlx::query!(
+		"DELETE FROM instance_server_snapshots WHERE instance_id = ?",
+		instance_id,
+	)
+		.execute(&mut *tx)
+	.await?;
+	for (position, server) in servers.iter().enumerate() {
+		let source = server.source.as_str();
+		let nbt = nbt_to_bytes(&server.data)?;
+		let position = position as i64;
+		sqlx::query!(
+			"
+			INSERT INTO instance_server_snapshots
+				(instance_id, server_id, source, nbt, position)
+			VALUES (?, ?, ?, ?, ?)
+			",
+			instance_id,
+			server.id,
+			source,
+			nbt,
+			position,
+		)
+		.execute(&mut *tx)
+        .await?;
+    }
+    tx.commit().await?;
+    Ok(())
+}
+
+fn canonical_path(state: &State) -> PathBuf {
+    synced_options_path(state).join("servers/canonical.nbt")
+}
+
+fn generated_path(state: &State, instance_id: &str) -> PathBuf {
+    synced_options_path(state)
+        .join("servers/generated")
+        .join(safe_instance_id(instance_id))
+        .join(SERVERS_FILE)
+}
+
+fn is_linked_server_project(link: &InstanceLink) -> bool {
+    matches!(
+        link,
+        InstanceLink::ServerProject { .. }
+            | InstanceLink::ServerProjectModpack { .. }
+            | InstanceLink::ModrinthHosting { .. }
+    )
+}
+
+fn is_modpack_link(link: &InstanceLink) -> bool {
+    matches!(
+        link,
+        InstanceLink::ModrinthModpack { .. }
+            | InstanceLink::ImportedModpack { .. }
+            | InstanceLink::SharedInstance { .. }
+    )
+}
+
+fn modpack_version_id(link: &InstanceLink) -> Option<&str> {
+    match link {
+        InstanceLink::ModrinthModpack { version_id, .. } => Some(version_id),
+        InstanceLink::ServerProjectModpack {
+            content_version_id, ..
+        } => Some(content_version_id),
+        InstanceLink::ImportedModpack {
+            version_id: Some(version_id),
+            ..
+        } => Some(version_id),
+        InstanceLink::SharedInstance {
+            modpack_version_id: Some(version_id),
+            ..
+        } => Some(version_id),
+        _ => None,
+    }
+}
diff --git a/packages/app-lib/src/api/pack/install_mrpack.rs b/packages/app-lib/src/api/pack/install_mrpack.rs
index b1a44c5130..c70b472113 100644
--- a/packages/app-lib/src/api/pack/install_mrpack.rs
+++ b/packages/app-lib/src/api/pack/install_mrpack.rs
@@ -630,6 +630,8 @@ pub(crate) async fn install_zipped_mrpack_files_with_reporter(
         );
     }
 
+    crate::api::instance::prepare_instance_update(&instance_id).await?;
+
     set_instance_information(
         instance_id.clone(),
         &description,
@@ -972,6 +974,11 @@ pub(crate) async fn install_zipped_mrpack_files_with_reporter(
         .iter()
         .map(|(_, file)| file.uncompressed_size())
         .sum::<u64>();
+    let has_servers_override = override_file_entries.iter().any(|(_, file)| {
+        let filename = file.filename().as_str().unwrap_or_default();
+        filename == "overrides/servers.dat"
+            || filename == "client-overrides/servers.dat"
+    });
     let progress = (override_total_bytes > 0).then_some(InstallProgress {
         current: 0,
         total: override_total_bytes,
@@ -1123,6 +1130,20 @@ pub(crate) async fn install_zipped_mrpack_files_with_reporter(
         }
     }
 
+    if has_servers_override {
+        crate::api::instance::synced_servers::capture_modpack_servers(
+            &instance_id,
+        )
+        .await?;
+    } else {
+        crate::api::instance::synced_servers::clear_modpack_servers(
+            &instance_id,
+        )
+        .await?;
+    }
+    crate::api::instance::reconcile_instance_synced_options(&instance_id)
+        .await?;
+
     // If the icon doesn't exist, we expect icon.png to be a potential icon.
     // If it doesn't exist, and an override to icon.png exists, cache and use that
     let potential_icon = instance_full_path.join("icon.png");
diff --git a/packages/app-lib/src/api/worlds.rs b/packages/app-lib/src/api/worlds.rs
index 03efec7036..a4d7e77df7 100644
--- a/packages/app-lib/src/api/worlds.rs
+++ b/packages/app-lib/src/api/worlds.rs
@@ -140,6 +140,8 @@ pub enum WorldDetails {
     },
     Server {
         index: usize,
+        server_id: String,
+        source: crate::api::instance::ServerSource,
         address: String,
         pack_status: ServerPackStatus,
         #[serde(skip_serializing_if = "Option::is_none")]
@@ -448,35 +450,43 @@ fn read_hardcore(data: &NbtCompound) -> bool {
 
 async fn get_server_worlds_in_instance(
     instance_id: &str,
-    instance_dir: &Path,
+    _instance_dir: &Path,
     worlds: &mut Vec<World>,
 ) -> Result<()> {
-    let servers = servers_data::read(instance_dir).await?;
+    let state = State::get().await?;
+    let metadata = crate::state::get_instance(instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| ErrorKind::InputError("Unknown instance".to_string()))?;
+    let servers = crate::api::instance::synced_servers::list_server_records(
+        &metadata, &state,
+    )
+    .await?;
     if servers.is_empty() {
         return Ok(());
     }
 
-    let state = State::get().await?;
     let join_log = server_join_log::get_joins(instance_id, &state.pool)
         .await
         .ok();
 
     for (index, server) in servers.into_iter().enumerate() {
-        if server.hidden {
+        if server.hidden() {
             // TODO: Figure out whether we want to hide or show direct connect servers
             continue;
         }
+        let address = server.address();
+        let server_id = server.id.clone();
         let world = World {
-            name: server.name,
+            name: server.name(),
             last_played: join_log
                 .as_ref()
                 .and_then(|log| {
-                    let (host, port) = parse_server_address(&server.ip).ok()?;
+                    let (host, port) = parse_server_address(&address).ok()?;
                     log.get(&(host.to_owned(), port))
                 })
                 .copied(),
             icon: server
-                .icon
+                .icon()
                 .and_then(|icon| {
                     Url::parse(&format!("data:image/png;base64,{icon}")).ok()
                 })
@@ -484,8 +494,10 @@ async fn get_server_worlds_in_instance(
             display_status: DisplayStatus::Normal,
             details: WorldDetails::Server {
                 index,
-                address: server.ip,
-                pack_status: server.accept_textures.into(),
+                server_id,
+                source: server.source,
+                address,
+                pack_status: server.accept_textures().into(),
                 project_id: None,
                 content_kind: None,
             },
@@ -766,25 +778,28 @@ pub async fn add_server_to_instance(
     content_kind: Option<String>,
 ) -> Result<usize> {
     let state = State::get().await?;
-    let (instance_id, instance_path) =
+    let (instance_id, _) =
         resolve_instance_identity(instance_id, &state).await?;
-    let instance_dir = state.directories.instances_dir().join(instance_path);
-    let mut servers = servers_data::read(&instance_dir).await?;
-    let insert_index = servers
-        .iter()
-        .position(|x| x.hidden)
-        .unwrap_or(servers.len());
-    servers.insert(
-        insert_index,
-        servers_data::ServerData {
-            name,
-            ip: address.clone(),
-            accept_textures: pack_status.into(),
-            hidden: false,
-            icon: None,
-        },
+    let metadata = crate::state::get_instance(&instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| ErrorKind::InputError("Unknown instance".to_string()))?;
+    let data = crate::api::instance::synced_servers::server_data(
+        name,
+        address.clone(),
+        pack_status.into(),
     );
-    servers_data::write(&instance_dir, &servers).await?;
+    let server_id = crate::api::instance::synced_servers::add_user_server(
+        &metadata, data, &state,
+    )
+    .await?;
+    let insert_index =
+        crate::api::instance::synced_servers::list_server_records(
+            &metadata, &state,
+        )
+        .await?
+        .iter()
+        .position(|server| server.id == server_id)
+        .unwrap_or(0);
 
     if project_id.is_some() || content_kind.is_some() {
         if let Some(project_id) = &project_id {
@@ -820,25 +835,20 @@ pub async fn edit_server_in_instance(
     pack_status: ServerPackStatus,
 ) -> Result<()> {
     let state = State::get().await?;
-    let (_, instance_path) =
+    let (instance_id, _) =
         resolve_instance_identity(instance_id, &state).await?;
-    let instance_dir = state.directories.instances_dir().join(instance_path);
-    let mut servers = servers_data::read(&instance_dir).await?;
-    let server =
-        servers
-            .get_mut(index)
-            .filter(|x| !x.hidden)
-            .ok_or_else(|| {
-                ErrorKind::InputError(format!(
-                    "No editable server at index {index}"
-                ))
-                .as_error()
-            })?;
-    server.name = name;
-    server.ip = address;
-    server.accept_textures = pack_status.into();
-    servers_data::write(&instance_dir, &servers).await?;
-    Ok(())
+    let metadata = crate::state::get_instance(&instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| ErrorKind::InputError("Unknown instance".to_string()))?;
+    crate::api::instance::synced_servers::update_server_by_index(
+        &metadata,
+        index,
+        name,
+        address,
+        pack_status.into(),
+        &state,
+    )
+    .await
 }
 
 pub async fn remove_server_from_instance(
@@ -846,80 +856,15 @@ pub async fn remove_server_from_instance(
     index: usize,
 ) -> Result<()> {
     let state = State::get().await?;
-    let (_, instance_path) =
+    let (instance_id, _) =
         resolve_instance_identity(instance_id, &state).await?;
-    let instance_dir = state.directories.instances_dir().join(instance_path);
-    let mut servers = servers_data::read(&instance_dir).await?;
-    if servers.get(index).as_ref().is_none_or(|x| x.hidden) {
-        return Err(ErrorKind::InputError(format!(
-            "No removable server at index {index}"
-        ))
-        .into());
-    }
-    servers.remove(index);
-    servers_data::write(&instance_dir, &servers).await?;
-    Ok(())
-}
-
-mod servers_data {
-    use crate::Result;
-    use crate::util::io;
-    use serde::{Deserialize, Serialize};
-    use std::path::Path;
-
-    #[derive(Serialize, Deserialize, Debug, Clone)]
-    #[serde(rename_all = "camelCase")]
-    pub struct ServerData {
-        #[serde(default)]
-        pub hidden: bool,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub icon: Option<String>,
-        #[serde(default)]
-        pub ip: String,
-        #[serde(default)]
-        pub name: String,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub accept_textures: Option<bool>,
-    }
-
-    pub async fn read(instance_dir: &Path) -> Result<Vec<ServerData>> {
-        #[derive(Deserialize, Debug)]
-        struct ServersData {
-            #[serde(default)]
-            servers: Vec<ServerData>,
-        }
-
-        let servers_dat_path = instance_dir.join("servers.dat");
-        if !servers_dat_path.exists() {
-            return Ok(vec![]);
-        }
-        let servers_data = io::read(servers_dat_path).await?;
-        let servers_data: ServersData = quartz_nbt::serde::deserialize(
-            &servers_data,
-            quartz_nbt::io::Flavor::Uncompressed,
-        )?
-        .0;
-        Ok(servers_data.servers)
-    }
-
-    pub async fn write(
-        instance_dir: &Path,
-        servers: &[ServerData],
-    ) -> Result<()> {
-        #[derive(Serialize, Debug)]
-        struct ServersData<'a> {
-            servers: &'a [ServerData],
-        }
-
-        let servers_dat_path = instance_dir.join("servers.dat");
-        let data = quartz_nbt::serde::serialize(
-            &ServersData { servers },
-            None,
-            quartz_nbt::io::Flavor::Uncompressed,
-        )?;
-        io::write(servers_dat_path, data).await?;
-        Ok(())
-    }
+    let metadata = crate::state::get_instance(&instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| ErrorKind::InputError("Unknown instance".to_string()))?;
+    crate::api::instance::synced_servers::remove_server_by_index(
+        &metadata, index, &state,
+    )
+    .await
 }
 
 pub async fn get_instance_protocol_version(
diff --git a/packages/app-lib/src/state/dirs.rs b/packages/app-lib/src/state/dirs.rs
index e3fb378608..f3416bbc9c 100644
--- a/packages/app-lib/src/state/dirs.rs
+++ b/packages/app-lib/src/state/dirs.rs
@@ -13,6 +13,7 @@ pub const CACHES_FOLDER_NAME: &str = "caches";
 pub const LAUNCHER_LOGS_FOLDER_NAME: &str = "launcher_logs";
 pub const INSTANCES_FOLDER_NAME: &str = "profiles";
 pub const METADATA_FOLDER_NAME: &str = "meta";
+pub const SYNCED_OPTIONS_FOLDER_NAME: &str = "synced-options";
 
 #[derive(Debug)]
 pub struct DirectoryInfo {
@@ -154,6 +155,11 @@ impl DirectoryInfo {
         self.config_dir.join(INSTANCES_FOLDER_NAME)
     }
 
+    #[inline]
+    pub fn synced_options_dir(&self) -> PathBuf {
+        self.config_dir.join(SYNCED_OPTIONS_FOLDER_NAME)
+    }
+
     /// Gets the logs dir for a given instance path
     #[inline]
     pub fn instance_logs_dir(&self, instance_path: &str) -> PathBuf {
@@ -269,6 +275,7 @@ impl DirectoryInfo {
                     CACHES_FOLDER_NAME,
                     INSTANCES_FOLDER_NAME,
                     METADATA_FOLDER_NAME,
+                    SYNCED_OPTIONS_FOLDER_NAME,
                 ];
 
                 struct MovePath {
diff --git a/packages/app-lib/src/state/instances/adapters/sqlite/instance_rows.rs b/packages/app-lib/src/state/instances/adapters/sqlite/instance_rows.rs
index 85c5791eef..c86fb6d8f8 100644
--- a/packages/app-lib/src/state/instances/adapters/sqlite/instance_rows.rs
+++ b/packages/app-lib/src/state/instances/adapters/sqlite/instance_rows.rs
@@ -534,44 +534,60 @@ pub(crate) async fn get_instance_synced_options(
     instance_id: &str,
     pool: &SqlitePool,
 ) -> crate::Result<InstanceSyncedOptions> {
-    let screenshots = sqlx::query_scalar::<_, bool>(
-        "
-		SELECT EXISTS(
-			SELECT 1
-			FROM instance_synced_options
-			WHERE instance_id = ?
-				AND option = 'screenshots'
-				AND enabled = 1
-		)
+	let enabled = sqlx::query_scalar!(
+		"
+		SELECT option
+		FROM instance_synced_options
+		WHERE instance_id = ? AND enabled = 1
 		",
-    )
-    .bind(instance_id)
-    .fetch_one(pool)
-    .await?;
+		instance_id,
+	)
+	.fetch_all(pool)
+    .await?
+    .into_iter()
+    .collect::<HashSet<_>>();
 
-    Ok(InstanceSyncedOptions { screenshots })
+    Ok(InstanceSyncedOptions {
+        command_history: enabled.contains("command_history"),
+        multiplayer_servers: enabled.contains("multiplayer_servers"),
+        creative_hotbars: enabled.contains("creative_hotbars"),
+        screenshots: enabled.contains("screenshots"),
+    })
 }
 
 async fn attach_synced_options(
     records: &mut [InstanceMetadataRecord],
     pool: &SqlitePool,
 ) -> crate::Result<()> {
-    let screenshot_instance_ids = sqlx::query_scalar::<_, String>(
-        "
-		SELECT instance_id
+	let enabled_options = sqlx::query!(
+		"
+		SELECT instance_id, option
 		FROM instance_synced_options
-		WHERE option = 'screenshots'
-			AND enabled = 1
+		WHERE enabled = 1
 		",
     )
     .fetch_all(pool)
-    .await?
-    .into_iter()
-    .collect::<HashSet<_>>();
+    .await?;
 
     for record in records {
-        record.synced_options.screenshots =
-            screenshot_instance_ids.contains(&record.instance.id);
+		for row in enabled_options
+			.iter()
+			.filter(|row| row.instance_id == record.instance.id)
+		{
+			match row.option.as_str() {
+                "command_history" => {
+                    record.synced_options.command_history = true
+                }
+                "multiplayer_servers" => {
+                    record.synced_options.multiplayer_servers = true
+                }
+                "creative_hotbars" => {
+                    record.synced_options.creative_hotbars = true
+                }
+                "screenshots" => record.synced_options.screenshots = true,
+                _ => {}
+            }
+        }
     }
 
     Ok(())
@@ -1268,11 +1284,14 @@ pub(crate) async fn set_instance_synced_option(
     enabled: bool,
     pool: &SqlitePool,
 ) -> crate::Result<()> {
-    let instance_exists = sqlx::query_scalar::<_, bool>(
-        "SELECT EXISTS(SELECT 1 FROM instances WHERE id = ?)",
-    )
-    .bind(instance_id)
-    .fetch_one(pool)
+	let instance_exists = sqlx::query_scalar!(
+		r#"
+		SELECT EXISTS(SELECT 1 FROM instances WHERE id = ?)
+			AS "exists!: bool"
+		"#,
+		instance_id,
+	)
+	.fetch_one(pool)
     .await?;
 
     if !instance_exists {
@@ -1282,18 +1301,19 @@ pub(crate) async fn set_instance_synced_option(
         .into());
     }
 
-    sqlx::query(
-        "
+	let option_name = option.as_str();
+	sqlx::query!(
+		"
 		INSERT INTO instance_synced_options (instance_id, option, enabled)
 		VALUES (?, ?, ?)
 		ON CONFLICT (instance_id, option) DO UPDATE SET
 			enabled = excluded.enabled
 		",
-    )
-    .bind(instance_id)
-    .bind(option.as_str())
-    .bind(enabled)
-    .execute(pool)
+		instance_id,
+		option_name,
+		enabled,
+	)
+	.execute(pool)
     .await?;
 
     Ok(())
@@ -1303,14 +1323,15 @@ pub(crate) async fn insert_default_instance_synced_options(
     instance_id: &str,
     tx: &mut Transaction<'_, Sqlite>,
 ) -> crate::Result<()> {
-    sqlx::query(
-        "
+	sqlx::query!(
+		"
 		INSERT INTO instance_synced_options (instance_id, option, enabled)
-		VALUES (?, 'screenshots', 1)
+		SELECT ?, option, enabled
+		FROM global_synced_options_overrides
 		",
-    )
-    .bind(instance_id)
-    .execute(&mut **tx)
+		instance_id,
+	)
+	.execute(&mut **tx)
     .await?;
 
     Ok(())
diff --git a/packages/app-lib/src/state/instances/commands/create_instance.rs b/packages/app-lib/src/state/instances/commands/create_instance.rs
index 204221b745..e115833485 100644
--- a/packages/app-lib/src/state/instances/commands/create_instance.rs
+++ b/packages/app-lib/src/state/instances/commands/create_instance.rs
@@ -130,6 +130,8 @@ pub(crate) async fn create_instance(
             &state.directories,
         )
         .await;
+        crate::api::instance::reconcile_instance_synced_options(&instance.id)
+            .await?;
 
         Ok(instance)
     }
diff --git a/packages/app-lib/src/state/instances/model/instance.rs b/packages/app-lib/src/state/instances/model/instance.rs
index 33a4d4204b..8c2f157e6c 100644
--- a/packages/app-lib/src/state/instances/model/instance.rs
+++ b/packages/app-lib/src/state/instances/model/instance.rs
@@ -27,23 +27,41 @@ pub struct InstanceIconConfig {
     Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, Deserialize,
 )]
 pub struct InstanceSyncedOptions {
+    pub command_history: bool,
+    pub multiplayer_servers: bool,
+    pub creative_hotbars: bool,
     pub screenshots: bool,
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
-pub enum InstanceSyncedOption {
+pub enum SyncedOption {
+    CommandHistory,
+    MultiplayerServers,
+    CreativeHotbars,
     Screenshots,
 }
 
-impl InstanceSyncedOption {
+impl SyncedOption {
     pub fn as_str(self) -> &'static str {
         match self {
+            Self::CommandHistory => "command_history",
+            Self::MultiplayerServers => "multiplayer_servers",
+            Self::CreativeHotbars => "creative_hotbars",
             Self::Screenshots => "screenshots",
         }
     }
+
+    pub const ALL: [Self; 4] = [
+        Self::CommandHistory,
+        Self::MultiplayerServers,
+        Self::CreativeHotbars,
+        Self::Screenshots,
+    ];
 }
 
+pub type InstanceSyncedOption = SyncedOption;
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Instance {
     pub id: String,
diff --git a/packages/app-lib/src/state/instances/watcher.rs b/packages/app-lib/src/state/instances/watcher.rs
index 5166e1942b..02112f1ac0 100644
--- a/packages/app-lib/src/state/instances/watcher.rs
+++ b/packages/app-lib/src/state/instances/watcher.rs
@@ -169,6 +169,18 @@ pub async fn init_watcher() -> crate::Result<FileWatcher> {
                                                 },
                                             )
                                         });
+                                    let synced_option_file = first_file_name
+                                        .as_ref()
+                                        .and_then(|name| name.to_str())
+                                        .filter(|name| {
+                                            matches!(
+                                                *name,
+                                                "command_history.txt"
+                                                    | "hotbar.nbt"
+                                                    | "servers.dat"
+                                            )
+                                        })
+                                        .map(ToOwned::to_owned);
                                     tokio::spawn(async move {
                                         if sync_content
                                             && let Ok(state) =
@@ -179,11 +191,23 @@ pub async fn init_watcher() -> crate::Result<FileWatcher> {
                                                     &state,
                                                 )
                                                 .await
-                                        {
+										{
                                             tracing::error!(
                                                 "Failed to sync instance content after filesystem change: {error}"
                                             );
-                                        }
+										}
+                                        if let Some(file_name) = synced_option_file
+											&& let Err(error) =
+												crate::api::instance::reconcile_synced_option_file(
+													&emit_instance_id,
+													&file_name,
+												)
+												.await
+										{
+											tracing::error!(
+												"Failed to reconcile {file_name} after filesystem change: {error}"
+											);
+										}
                                         if reconcile_screenshots
                                             && let Err(error) =
                                                 crate::api::instance::reconcile_screenshots(
diff --git a/packages/app-lib/src/state/mod.rs b/packages/app-lib/src/state/mod.rs
index b428d2d036..cf8f56409a 100644
--- a/packages/app-lib/src/state/mod.rs
+++ b/packages/app-lib/src/state/mod.rs
@@ -169,6 +169,14 @@ impl State {
             )
             .await;
 
+            if let Err(error) =
+                crate::api::instance::reconcile_all_synced_options().await
+            {
+                tracing::error!(
+                    "Failed to reconcile instance synced options during startup: {error}"
+                );
+            }
+
             if let Err(e) = crate::api::instance::migrate_legacy_icons().await {
                 tracing::error!("Error migrating legacy instance icons: {e}");
             }
diff --git a/packages/app-lib/src/state/process.rs b/packages/app-lib/src/state/process.rs
index 87aa50f972..b43aae3411 100644
--- a/packages/app-lib/src/state/process.rs
+++ b/packages/app-lib/src/state/process.rs
@@ -823,6 +823,20 @@ impl Process {
         // Now fully complete- update playtime one last time
         update_playtime(&mut last_updated_playtime, &instance_id, true).await;
 
+        let reconcile_instance_id = instance_id.clone();
+        tokio::spawn(async move {
+            if let Err(error) =
+                crate::api::instance::reconcile_instance_synced_options(
+                    &reconcile_instance_id,
+                )
+                .await
+            {
+                tracing::warn!(
+                    "Failed to reconcile synced options after Minecraft exited for {reconcile_instance_id}: {error}"
+                );
+            }
+        });
+
         // Publish play time update
         // Allow failure, it will be stored locally and sent next time
         // Sent in another thread as first call may take a couple seconds and hold up process ending
diff --git a/packages/ui/src/utils/ace-mode-mcfunction.ts b/packages/ui/src/utils/ace-mode-mcfunction.ts
new file mode 100644
index 0000000000..06a430712c
--- /dev/null
+++ b/packages/ui/src/utils/ace-mode-mcfunction.ts
@@ -0,0 +1,106 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import ace from 'ace-builds'
+
+ace['define'](
+	'ace/mode/mcfunction_highlight_rules',
+	['require', 'exports', 'ace/lib/oop', 'ace/mode/text_highlight_rules'],
+	function (require: any, exports: any) {
+		const oop = require('ace/lib/oop')
+		const TextHighlightRules = require('ace/mode/text_highlight_rules').TextHighlightRules
+
+		const McfunctionHighlightRules = function (this: any) {
+			this.$rules = {
+				start: [
+					{
+						token: 'comment.doc',
+						regex: /^\s*#>.*$/.source,
+					},
+					{
+						token: 'comment',
+						regex: /^\s*#!.*$/.source,
+					},
+					{
+						token: 'comment',
+						regex: /^\s*##.*$/.source,
+					},
+					{
+						token: 'comment',
+						regex: /^\s*#(?![a-z0-9_.]+:).*$/i.source,
+					},
+					{
+						token: 'string',
+						regex: /"(?:\\.|[^"\\])*"/.source,
+					},
+					{
+						token: 'string',
+						regex: /'(?:\\.|[^'\\])*'/.source,
+					},
+					{
+						token: 'variable',
+						regex: /\$\([a-zA-Z0-9_]+\)/.source,
+					},
+					{
+						token: 'constant.language',
+						regex: /@[apers]\b/i.source,
+					},
+					{
+						token: 'constant.language',
+						regex: /\b[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}\b/i.source,
+					},
+					{
+						token: 'support.constant',
+						regex: /#?[a-z0-9_.]+:[a-z0-9_./-]+/i.source,
+					},
+					{
+						token: 'keyword',
+						regex: /\brun\s+\/?[a-z][a-z0-9_]*/i.source,
+					},
+					{
+						token: 'constant.numeric',
+						regex: /[~^]-?(?:\d*\.)?\d+/.source,
+					},
+					{
+						token: 'keyword.operator',
+						regex: /[~^]/.source,
+					},
+					{
+						token: 'constant.numeric',
+						regex: /-?(?:\d*\.)?\d+[bdfils]?\b/i.source,
+					},
+					{
+						token: 'constant.language',
+						regex: /\.\.|\b(?:true|false)\b/i.source,
+					},
+					{
+						token: 'keyword',
+						regex: /^\s*\/?[a-z][a-z0-9_]*/i.source,
+					},
+				],
+			}
+			this.normalizeRules()
+		}
+
+		oop.inherits(McfunctionHighlightRules, TextHighlightRules)
+		exports.McfunctionHighlightRules = McfunctionHighlightRules
+	},
+)
+
+ace['define'](
+	'ace/mode/mcfunction',
+	['require', 'exports', 'ace/lib/oop', 'ace/mode/text', 'ace/mode/mcfunction_highlight_rules'],
+	function (require: any, exports: any) {
+		const oop = require('ace/lib/oop')
+		const TextMode = require('ace/mode/text').Mode
+		const McfunctionHighlightRules = require(
+			'ace/mode/mcfunction_highlight_rules',
+		).McfunctionHighlightRules
+
+		const Mode = function (this: any) {
+			this.HighlightRules = McfunctionHighlightRules
+			this.$id = 'ace/mode/mcfunction'
+		}
+
+		oop.inherits(Mode, TextMode)
+		exports.Mode = Mode
+	},
+)