diff --git a/apps/app-frontend/src/components/ui/settings/instances/InstancesSyncedSettings.vue b/apps/app-frontend/src/components/ui/settings/instances/InstancesSyncedSettings.vue
index 548abba7af..e137305098 100644
--- a/apps/app-frontend/src/components/ui/settings/instances/InstancesSyncedSettings.vue
+++ b/apps/app-frontend/src/components/ui/settings/instances/InstancesSyncedSettings.vue
@@ -23,10 +23,15 @@ import {
 } from '@modrinth/ui'
 import { useMutation, useQuery, useQueryClient } from '@tanstack/vue-query'
 import type { Component } from 'vue'
-import { computed, ref, shallowRef, watch } from 'vue'
+import { computed, nextTick, ref, shallowRef, watch } from 'vue'
 
+import GameSettingsModal from '@/components/ui/settings/instances/game-settings/GameSettingsModal.vue'
 import WorldItem from '@/components/ui/world/WorldItem.vue'
 import useMemorySlider from '@/composables/useMemorySlider'
+import {
+	type GameOptionsSourceCandidate,
+	list_game_options_sync_sources,
+} from '@/helpers/game-options'
 import {
 	get_command_history,
 	get_global_synced_options,
@@ -65,6 +70,23 @@ const messages = defineMessages({
 	// 	id: 'app.settings.synced-options.folder',
 	// 	defaultMessage: 'Synced folder',
 	// },
+	gameSettings: {
+		id: 'app.settings.synced-options.game-settings',
+		defaultMessage: 'Sync game options',
+	},
+	gameSettingsDescription: {
+		id: 'app.settings.synced-options.game-settings.description',
+		defaultMessage:
+			'Use the same graphics, keybinds, and other game settings across your instances.',
+	},
+	gameSettingsButton: {
+		id: 'app.settings.synced-options.game-settings.button',
+		defaultMessage: 'Edit game settings',
+	},
+	gameSettingsDisabledTooltip: {
+		id: 'app.settings.synced-options.game-settings.disabled-tooltip',
+		defaultMessage: 'Enable game settings sync before choosing individual settings.',
+	},
 	multiplayerServers: {
 		id: 'app.settings.synced-options.multiplayer-servers',
 		defaultMessage: 'Sync multiplayer servers',
@@ -105,6 +127,10 @@ const messages = defineMessages({
 		id: 'app.settings.synced-options.choose-sync-source.creative-hotbars-description',
 		defaultMessage: 'Pick the instance whose saved creative hotbars become the shared copy.',
 	},
+	gameSettingsSyncSourceDescription: {
+		id: 'app.settings.synced-options.choose-sync-source.game-settings-description',
+		defaultMessage: 'Choose which instance to copy game settings from.',
+	},
 	searchInstance: {
 		id: 'app.settings.synced-options.choose-sync-source.search-placeholder',
 		defaultMessage: 'Search instance',
@@ -292,8 +318,14 @@ const globalRows: Array<{
 	option: SyncedOption
 	title: keyof typeof messages
 	description?: keyof typeof messages
-	editable?: 'servers' | 'commands'
+	editable?: 'game-settings' | 'servers' | 'commands'
 }> = [
+	{
+		option: 'game_options',
+		title: 'gameSettings',
+		description: 'gameSettingsDescription',
+		editable: 'game-settings',
+	},
 	{
 		option: 'multiplayer_servers',
 		title: 'multiplayerServers',
@@ -316,6 +348,7 @@ const globalRows: Array<{
 const globalSyncedOptionsQueryKey = ['global-synced-options'] as const
 const globalSyncedOptionsMutationKey = ['global-synced-options', 'set'] as const
 const defaultGlobalOptions: GlobalSyncedOptions = {
+	game_options: false,
 	command_history: false,
 	multiplayer_servers: false,
 	creative_hotbars: false,
@@ -332,6 +365,7 @@ const baseOption = ref<SyncedOption | null>(null)
 const baseInstanceId = ref(instances.value[0]?.id ?? '')
 const baseInstanceSearch = ref('')
 const baseModal = ref<InstanceType<typeof NewModal> | null>(null)
+const gameSettingsModal = ref<InstanceType<typeof GameSettingsModal> | null>(null)
 const commandHistoryModal = ref<InstanceType<typeof NewModal> | null>(null)
 const serverEditorModal = ref<InstanceType<typeof NewModal> | null>(null)
 const editServerModal = ref<InstanceType<typeof NewModal> | null>(null)
@@ -345,6 +379,16 @@ const syncedServers = ref<SyncedServer[]>(
 const editedServer = ref<SyncedServer | null>(null)
 const serverData = ref<Record<string, ServerData>>({})
 const editorComponent = shallowRef<Component | null>(null)
+const gameOptionSources = ref<GameOptionsSourceCandidate[]>([])
+const baseSourcesLoading = ref(false)
+let baseSourceGeneration = 0
+
+type BaseSourceCandidate = {
+	id: string
+	name: string
+	icon_path?: string | null
+	eligible: boolean
+}
 
 const syncedServerCards = computed(() =>
 	syncedServers.value.map((server, index) => ({
@@ -368,6 +412,8 @@ const syncedServerCards = computed(() =>
 
 const baseInstanceDescription = computed(() => {
 	switch (baseOption.value) {
+		case 'game_options':
+			return formatMessage(messages.gameSettingsSyncSourceDescription)
 		case 'multiplayer_servers':
 			return formatMessage(messages.multiplayerServersSyncSourceDescription)
 		case 'command_history':
@@ -381,8 +427,22 @@ const baseInstanceDescription = computed(() => {
 
 const filteredBaseInstances = computed(() => {
 	const search = baseInstanceSearch.value.trim().toLowerCase()
-	if (!search) return instances.value
-	return instances.value.filter((instance) => instance.name.toLowerCase().includes(search))
+	const candidates: BaseSourceCandidate[] =
+		baseOption.value === 'game_options'
+			? gameOptionSources.value.map((source) => ({
+					id: source.source_id,
+					name: source.name,
+					icon_path: source.icon_path,
+					eligible: source.eligible,
+				}))
+			: instances.value.map((instance) => ({
+					id: instance.id,
+					name: instance.name,
+					icon_path: instance.icon_path,
+					eligible: true,
+				}))
+	if (!search) return candidates
+	return candidates.filter((instance) => instance.name.toLowerCase().includes(search))
 })
 
 async function invalidateSyncedOptions() {
@@ -407,10 +467,12 @@ const globalOptionMutation = useMutation({
 		await queryClient.cancelQueries({ queryKey: globalSyncedOptionsQueryKey })
 		const previous = globalOptions.value[option]
 
-		queryClient.setQueryData<GlobalSyncedOptions>(globalSyncedOptionsQueryKey, (current) => ({
-			...(current ?? defaultGlobalOptions),
-			[option]: enabled,
-		}))
+		if (option !== 'game_options' || !enabled) {
+			queryClient.setQueryData<GlobalSyncedOptions>(globalSyncedOptionsQueryKey, (current) => ({
+				...(current ?? defaultGlobalOptions),
+				[option]: enabled,
+			}))
+		}
 
 		return { previous }
 	},
@@ -421,8 +483,11 @@ const globalOptionMutation = useMutation({
 		}))
 		handleError(error)
 	},
-	onSuccess: async (_options, { option, enabled }) => {
-		if (enabled) baseModal.value?.hide()
+	onSuccess: async (options, { option, enabled }) => {
+		queryClient.setQueryData(globalSyncedOptionsQueryKey, options)
+		if (option === 'game_options') {
+			await refreshSettings()
+		}
 		if (enabled && option === 'multiplayer_servers') {
 			syncedServers.value = await list_synced_servers().catch((error) => {
 				handleError(error)
@@ -441,21 +506,71 @@ function applyGlobalOption(option: SyncedOption, enabled: boolean, baseInstanceI
 	globalOptionMutation.mutate({ option, enabled, baseInstanceId })
 }
 
-function toggleGlobalOption(option: SyncedOption, enabled: boolean) {
-	if (!enabled) {
-		applyGlobalOption(option, false)
+async function chooseBaseInstance(option: SyncedOption) {
+	const generation = ++baseSourceGeneration
+	baseOption.value = option
+	baseInstanceSearch.value = ''
+	baseSourcesLoading.value = option === 'game_options'
+
+	if (option === 'game_options') {
+		try {
+			const sources = await list_game_options_sync_sources()
+			if (generation !== baseSourceGeneration || baseOption.value !== option) return
+			gameOptionSources.value = sources
+			baseInstanceId.value =
+				gameOptionSources.value.find((source) => source.eligible)?.source_id ?? ''
+		} catch (error) {
+			if (generation !== baseSourceGeneration || baseOption.value !== option) return
+			gameOptionSources.value = []
+			baseInstanceId.value = ''
+			handleError(error)
+			return
+		} finally {
+			if (generation === baseSourceGeneration && baseOption.value === option) {
+				baseSourcesLoading.value = false
+			}
+		}
+		if (!baseInstanceId.value) {
+			applyGlobalOption(option, true)
+			return
+		}
+		baseModal.value?.show()
 		return
 	}
 
-	baseOption.value = option
+	if (instances.value.length === 0) {
+		applyGlobalOption(option, true)
+		return
+	}
 	baseInstanceId.value = instances.value[0]?.id ?? ''
-	baseInstanceSearch.value = ''
 	baseModal.value?.show()
 }
 
-function confirmBaseInstance() {
+function toggleGlobalOption(option: SyncedOption, enabled: boolean) {
+	if (enabled && option !== 'screenshots') {
+		void chooseBaseInstance(option)
+		return
+	}
+	applyGlobalOption(option, enabled)
+}
+
+async function confirmBaseInstance() {
 	if (!baseOption.value || !baseInstanceId.value) return
-	applyGlobalOption(baseOption.value, true, baseInstanceId.value)
+	try {
+		await globalOptionMutation.mutateAsync({
+			option: baseOption.value,
+			enabled: true,
+			baseInstanceId: baseInstanceId.value,
+		})
+		await nextTick()
+		baseModal.value?.hide()
+	} catch {
+		return
+	}
+}
+
+function openGameSettings() {
+	gameSettingsModal.value?.show()
 }
 
 async function openCommandHistoryEditor() {
@@ -536,11 +651,32 @@ async function removeSyncedServer(serverId: string) {
 	}
 }
 
-const fetchSettings = await get()
-fetchSettings.launchArgs = fetchSettings.extra_launch_args.join(' ')
-fetchSettings.envVars = serializeEnvVars(fetchSettings.custom_env_vars)
+function addEditableSettingsFields(fetchSettings: Awaited<ReturnType<typeof get>>) {
+	return Object.assign(fetchSettings, {
+		launchArgs: fetchSettings.extra_launch_args.join(' '),
+		envVars: serializeEnvVars(fetchSettings.custom_env_vars),
+	})
+}
+
+const settings = ref(addEditableSettingsFields(await get()))
+let applyingFetchedSettings = false
 
-const settings = ref(fetchSettings)
+async function refreshSettings() {
+	try {
+		const refreshedSettings = addEditableSettingsFields(await get())
+		applyingFetchedSettings = true
+		settings.value = refreshedSettings
+		await nextTick()
+	} catch (error) {
+		handleError(error)
+	} finally {
+		applyingFetchedSettings = false
+	}
+}
+
+async function handleGameSettingsSaved() {
+	await Promise.all([invalidateSyncedOptions(), refreshSettings()])
+}
 
 const { maxMemory, snapPoints } = (await useMemorySlider().catch(handleError)) as unknown as {
 	maxMemory: number
@@ -550,6 +686,7 @@ const { maxMemory, snapPoints } = (await useMemorySlider().catch(handleError)) a
 watch(
 	settings,
 	async () => {
+		if (applyingFetchedSettings) return
 		const setSettings = JSON.parse(JSON.stringify(settings.value))
 
 		setSettings.extra_launch_args = setSettings.launchArgs.trim().split(/\s+/).filter(Boolean)
@@ -569,6 +706,8 @@ watch(
 
 <template>
 	<div>
+		<GameSettingsModal ref="gameSettingsModal" @saved="handleGameSettingsSaved" />
+
 		<NewModal
 			ref="baseModal"
 			:header="formatMessage(messages.chooseSyncSourceTitle)"
@@ -576,6 +715,7 @@ watch(
 			actions-divider
 			max-width="560px"
 			width="560px"
+			:disable-close="globalOptionMutation.isPending.value"
 		>
 			<p class="m-0 border-0 border-b border-solid border-surface-5 p-6 text-primary">
 				{{ baseInstanceDescription }}
@@ -591,8 +731,11 @@ watch(
 					class="shrink-0"
 				/>
 
+				<div v-if="baseSourcesLoading" class="flex flex-1 items-center justify-center">
+					<RefreshCwIcon class="size-5 animate-spin text-secondary" />
+				</div>
 				<div
-					v-if="filteredBaseInstances.length === 0"
+					v-else-if="filteredBaseInstances.length === 0"
 					class="flex flex-1 items-center justify-center text-secondary"
 				>
 					{{ formatMessage(messages.noInstancesFound) }}
@@ -607,8 +750,9 @@ watch(
 						v-for="instance in filteredBaseInstances"
 						:key="instance.id"
 						:checked="baseInstanceId === instance.id"
-						class="h-10"
-						@click="baseInstanceId = instance.id"
+						:disabled="!instance.eligible"
+						class="min-h-10"
+						@click="instance.eligible && (baseInstanceId = instance.id)"
 					>
 						<span class="size-5 shrink-0 overflow-hidden rounded-[6px]">
 							<Avatar
@@ -619,23 +763,30 @@ watch(
 								no-shadow
 							/>
 						</span>
-						<span class="truncate">{{ instance.name }}</span>
+						<span class="min-w-0 flex-1 truncate">{{ instance.name }}</span>
 					</CheckCircleButton>
 				</div>
 			</div>
 			<template #actions>
 				<div class="flex justify-end gap-2 p-2">
-					<Button type="outlined" @click="baseModal?.hide()">
+					<Button
+						type="outlined"
+						:disabled="globalOptionMutation.isPending.value"
+						@click="baseModal?.hide()"
+					>
 						<XIcon />
 						{{ formatMessage(commonMessages.cancelButton) }}
 					</Button>
 					<Button
 						type="colored"
 						color="brand"
-						:disabled="!baseInstanceId || globalOptionMutation.isPending.value"
+						:disabled="
+							!baseInstanceId || baseSourcesLoading || globalOptionMutation.isPending.value
+						"
+						:loading="globalOptionMutation.isPending.value"
 						@click="confirmBaseInstance"
 					>
-						<RefreshCwIcon />
+						<RefreshCwIcon v-if="!globalOptionMutation.isPending.value" />
 						{{ formatMessage(messages.syncButton) }}
 					</Button>
 				</div>
@@ -774,7 +925,26 @@ watch(
 						</div>
 						<div class="flex shrink-0 items-center gap-2">
 							<span
-								v-if="row.editable"
+								v-if="row.editable === 'game-settings'"
+								v-tooltip="
+									!globalOptions.game_options
+										? formatMessage(messages.gameSettingsDisabledTooltip)
+										: formatMessage(messages.gameSettingsButton)
+								"
+								class="flex"
+							>
+								<IconButton
+									type="outlined"
+									circular
+									:disabled="!globalOptions.game_options || globalOptionMutation.isPending.value"
+									:label="formatMessage(messages.gameSettingsButton)"
+									@click="openGameSettings"
+								>
+									<EditIcon />
+								</IconButton>
+							</span>
+							<span
+								v-else-if="row.editable"
 								v-tooltip="
 									row.editable === 'servers' && syncedServers.length === 0
 										? formatMessage(messages.noServersSyncedYet)
@@ -800,6 +970,7 @@ watch(
 							<Toggle
 								:id="`global-sync-${row.option}`"
 								:model-value="globalOptions[row.option]"
+								:disabled="globalOptionMutation.isPending.value"
 								@update:model-value="(enabled) => toggleGlobalOption(row.option, enabled)"
 							/>
 						</div>
diff --git a/apps/app-frontend/src/components/ui/settings/instances/game-settings/GameKeybindInput.vue b/apps/app-frontend/src/components/ui/settings/instances/game-settings/GameKeybindInput.vue
new file mode 100644
index 0000000000..e77d04f838
--- /dev/null
+++ b/apps/app-frontend/src/components/ui/settings/instances/game-settings/GameKeybindInput.vue
@@ -0,0 +1,242 @@
+<script setup lang="ts">
+import { TriangleAlertIcon } from '@modrinth/assets'
+import { Button, defineMessages, useVIntl } from '@modrinth/ui'
+import { computed, onBeforeUnmount, ref, useId } from 'vue'
+
+import {
+	activateKeybindRecording,
+	deactivateKeybindRecording,
+	formatMinecraftKeybind,
+	minecraftKeyTokenFromKeyboardEvent,
+	minecraftMouseTokenFromButton,
+} from './game-keybinds'
+
+const props = withDefaults(
+	defineProps<{
+		modelValue: string
+		settingLabel: string
+		conflicts?: string[]
+		mixed?: boolean
+		disabled?: boolean
+	}>(),
+	{
+		conflicts: () => [],
+		mixed: false,
+		disabled: false,
+	},
+)
+
+const emit = defineEmits<{
+	'update:model-value': [value: string]
+}>()
+
+const { formatMessage, locale } = useVIntl()
+const statusId = useId()
+const recording = ref(false)
+const statusMessage = ref('')
+const controlElement = ref<HTMLElement | null>(null)
+let suppressNextClick = false
+
+const messages = defineMessages({
+	listen: {
+		id: 'app.settings.game-options.keybind.listen',
+		defaultMessage: 'Press a key…',
+	},
+	choose: {
+		id: 'app.settings.game-options.keybind.choose',
+		defaultMessage: 'Choose a key',
+	},
+	mixed: {
+		id: 'app.settings.game-options.keybind.mixed',
+		defaultMessage: 'Different across instances',
+	},
+	change: {
+		id: 'app.settings.game-options.keybind.change',
+		defaultMessage: '{setting}: {binding}. Activate to change the binding.',
+	},
+	listeningStatus: {
+		id: 'app.settings.game-options.keybind.listening-status',
+		defaultMessage: 'Listening for a key or mouse button. Press Escape to clear this binding.',
+	},
+	unsupportedStatus: {
+		id: 'app.settings.game-options.keybind.unsupported-status',
+		defaultMessage: 'That input cannot be used by Minecraft. Press another key.',
+	},
+	cancelledStatus: {
+		id: 'app.settings.game-options.keybind.cancelled-status',
+		defaultMessage: 'Key binding change cancelled.',
+	},
+	assignedStatus: {
+		id: 'app.settings.game-options.keybind.assigned-status',
+		defaultMessage: '{setting} is now bound to {binding}.',
+	},
+	conflict: {
+		id: 'app.settings.game-options.keybind.conflict',
+		defaultMessage: 'This key is also used for {settings}.',
+	},
+})
+
+const isMac = /Mac|iPhone|iPad|iPod/.test(navigator.platform)
+const bindingLabel = computed(() => {
+	if (props.mixed) return formatMessage(messages.mixed)
+	if (!props.modelValue) return formatMessage(messages.choose)
+	return formatMinecraftKeybind(formatMessage, props.modelValue, isMac)
+})
+const visibleLabel = computed(() =>
+	recording.value ? formatMessage(messages.listen) : bindingLabel.value,
+)
+const conflictSettings = computed(() =>
+	new Intl.ListFormat(locale.value, { style: 'long', type: 'conjunction' }).format(props.conflicts),
+)
+const conflictMessage = computed(() =>
+	props.conflicts.length
+		? formatMessage(messages.conflict, { settings: conflictSettings.value })
+		: '',
+)
+const accessibleLabel = computed(() => {
+	if (recording.value) {
+		return `${props.settingLabel}. ${formatMessage(messages.listeningStatus)}`
+	}
+	const change = formatMessage(messages.change, {
+		setting: props.settingLabel,
+		binding: bindingLabel.value,
+	})
+	return conflictMessage.value ? `${change} ${conflictMessage.value}` : change
+})
+
+function startRecording() {
+	if (props.disabled || recording.value) return
+	activateKeybindRecording(cancelRecording)
+	recording.value = true
+	statusMessage.value = formatMessage(messages.listeningStatus)
+	window.addEventListener('keydown', handleKeydown, true)
+	window.addEventListener('pointerdown', handlePointerDown, true)
+}
+
+function stopRecording() {
+	recording.value = false
+	window.removeEventListener('keydown', handleKeydown, true)
+	window.removeEventListener('pointerdown', handlePointerDown, true)
+	deactivateKeybindRecording(cancelRecording)
+}
+
+function cancelRecording() {
+	if (!recording.value) return
+	stopRecording()
+	statusMessage.value = formatMessage(messages.cancelledStatus)
+}
+
+function assign(value: string) {
+	if (!recording.value) return
+	stopRecording()
+	emit('update:model-value', value)
+	statusMessage.value = formatMessage(messages.assignedStatus, {
+		setting: props.settingLabel,
+		binding: formatMinecraftKeybind(formatMessage, value, isMac),
+	})
+}
+
+function handleClick(event: MouseEvent) {
+	if (suppressNextClick) {
+		suppressNextClick = false
+		event.preventDefault()
+		event.stopPropagation()
+		return
+	}
+	startRecording()
+}
+
+function handleKeydown(event: KeyboardEvent) {
+	if (!recording.value) return
+
+	event.preventDefault()
+	event.stopPropagation()
+	if (event.code === 'Escape') {
+		assign('key.keyboard.unknown')
+		return
+	}
+	if (event.repeat) return
+
+	const token = event.isComposing ? null : minecraftKeyTokenFromKeyboardEvent(event)
+	if (!token) {
+		statusMessage.value = formatMessage(messages.unsupportedStatus)
+		return
+	}
+	assign(token)
+}
+
+function handlePointerDown(event: PointerEvent) {
+	if (!recording.value) return
+	if (event.pointerType !== 'mouse') return
+	const otherKeybindControl =
+		event.target instanceof Element
+			? event.target.closest<HTMLElement>('[data-game-keybind-control]')
+			: null
+	if (otherKeybindControl && otherKeybindControl !== controlElement.value) return
+
+	event.preventDefault()
+	event.stopPropagation()
+	const token = minecraftMouseTokenFromButton(event.button)
+	if (!token) {
+		statusMessage.value = formatMessage(messages.unsupportedStatus)
+		return
+	}
+	suppressNextClick = event.button === 0 && otherKeybindControl === controlElement.value
+	assign(token)
+}
+
+onBeforeUnmount(cancelRecording)
+</script>
+
+<template>
+	<div class="flex w-full min-w-0 items-center gap-1.5">
+		<span
+			ref="controlElement"
+			v-tooltip="!recording && conflictMessage ? conflictMessage : undefined"
+			data-game-keybind-control
+			class="flex min-w-0 flex-1"
+		>
+			<Button
+				type="base"
+				size="lg"
+				:disabled="disabled"
+				:aria-label="accessibleLabel"
+				:aria-describedby="recording ? statusId : undefined"
+				class="keybind-button !w-full overflow-hidden"
+				:class="{
+					'!bg-brand-highlight !text-brand !shadow-[inset_0_0_0_1px_var(--color-brand)]': recording,
+					'keybind-button--conflict': !recording && conflicts.length,
+					'!bg-transparent': !recording && !conflicts.length,
+				}"
+				@click="handleClick"
+				@contextmenu.prevent.stop
+				@auxclick.prevent.stop
+			>
+				<span class="flex min-w-0 flex-row items-center justify-center gap-2">
+					<TriangleAlertIcon
+						v-if="!recording && conflicts.length"
+						class="keybind-conflict-icon order-first size-4 shrink-0"
+						aria-hidden="true"
+					/>
+					<span class="order-last min-w-0 truncate">{{ visibleLabel }}</span>
+				</span>
+			</Button>
+		</span>
+
+		<span :id="statusId" class="visually-hidden" role="status" aria-live="polite">
+			{{ statusMessage }}
+		</span>
+	</div>
+</template>
+
+<style scoped>
+.keybind-button.keybind-button--conflict {
+	background-color: var(--color-orange-highlight) !important;
+	color: var(--color-orange) !important;
+	box-shadow: inset 0 0 0 1px var(--color-orange) !important;
+}
+
+.keybind-button.keybind-button--conflict .keybind-conflict-icon {
+	color: var(--color-orange) !important;
+}
+</style>
diff --git a/apps/app-frontend/src/components/ui/settings/instances/game-settings/GameSettingRow.vue b/apps/app-frontend/src/components/ui/settings/instances/game-settings/GameSettingRow.vue
new file mode 100644
index 0000000000..3970cffde1
--- /dev/null
+++ b/apps/app-frontend/src/components/ui/settings/instances/game-settings/GameSettingRow.vue
@@ -0,0 +1,318 @@
+<script setup lang="ts">
+import { LinkIcon, UnknownIcon, UnlinkIcon } from '@modrinth/assets'
+import {
+	Combobox,
+	type ComboboxOption,
+	defineMessages,
+	IconButton,
+	Input,
+	Slider,
+	truncatedTooltip,
+	useVIntl,
+} from '@modrinth/ui'
+import { computed, ref } from 'vue'
+
+import type { EditableGameSetting, GameOptionCanonicalValue } from '@/helpers/game-options'
+
+import GameSettingBooleanControl from './game-setting-boolean-control.vue'
+import {
+	canonicalBooleanValue,
+	canonicalValueFromInput,
+	canonicalValueText,
+} from './game-setting-editors'
+import {
+	formatCompatibilityTooltip,
+	formatGameSettingChoice,
+	formatGameSettingDescription,
+	formatGameSettingLabel,
+	formatGameSettingValidation,
+	presentationMessages,
+	shouldShowCompatibilityIndicator,
+} from './game-setting-messages'
+import GameKeybindInput from './GameKeybindInput.vue'
+
+const props = withDefaults(
+	defineProps<{
+		setting: EditableGameSetting
+		keybindConflicts?: string[]
+		disabled?: boolean
+		showSyncToggle?: boolean
+	}>(),
+	{
+		keybindConflicts: () => [],
+		disabled: false,
+		showSyncToggle: true,
+	},
+)
+
+const emit = defineEmits<{
+	'update:sync-enabled': [enabled: boolean]
+	'update:canonical-value': [value: GameOptionCanonicalValue | null]
+}>()
+
+const { formatMessage } = useVIntl()
+const settingLabelRef = ref<HTMLElement | null>(null)
+
+const messages = defineMessages({
+	valueLabel: {
+		id: 'app.settings.synced-options.game-settings.value-label',
+		defaultMessage: 'Value',
+	},
+	on: {
+		id: 'app.settings.synced-options.game-settings.value-on',
+		defaultMessage: 'On',
+	},
+	off: {
+		id: 'app.settings.synced-options.game-settings.value-off',
+		defaultMessage: 'Off',
+	},
+	mixed: {
+		id: 'app.settings.synced-options.game-settings.value-mixed',
+		defaultMessage: 'Different across instances',
+	},
+	unset: {
+		id: 'app.settings.synced-options.game-settings.value-unset',
+		defaultMessage: 'Choose a value',
+	},
+	compatibilityDetails: {
+		id: 'app.settings.synced-options.game-settings.compatibility-details',
+		defaultMessage: 'Why this setting may not sync',
+	},
+	syncSetting: {
+		id: 'app.settings.synced-options.game-settings.sync-setting',
+		defaultMessage: 'Sync {setting} across instances',
+	},
+	unsyncSetting: {
+		id: 'app.settings.synced-options.game-settings.unsync-setting',
+		defaultMessage: 'Stop syncing {setting} across instances',
+	},
+})
+
+const settingLabel = computed(() => formatGameSettingLabel(formatMessage, props.setting))
+const settingDescription = computed(() =>
+	formatGameSettingDescription(formatMessage, props.setting),
+)
+const valueText = computed(() => canonicalValueText(props.setting))
+const enumOptions = computed<ComboboxOption<string>[]>(() =>
+	(props.setting.editor.choices ?? []).map((choice) => ({
+		value: choice.value,
+		label: formatGameSettingChoice(formatMessage, props.setting.option_id, choice.value),
+	})),
+)
+const isVolumeSlider = computed(
+	() =>
+		props.setting.category_id === 'music_and_sound' &&
+		props.setting.editor.unit === 'percent' &&
+		props.setting.editor.type === 'decimal',
+)
+const booleanValue = computed(() => canonicalBooleanValue(props.setting))
+const numberScale = computed(() => (props.setting.editor.unit === 'percent' ? 100 : 1))
+const inputMin = computed(() =>
+	props.setting.editor.min === null || props.setting.editor.min === undefined
+		? undefined
+		: props.setting.editor.min * numberScale.value,
+)
+const inputMax = computed(() =>
+	props.setting.editor.max === null || props.setting.editor.max === undefined
+		? undefined
+		: props.setting.editor.max * numberScale.value,
+)
+const inputStep = computed(() =>
+	props.setting.editor.step === null || props.setting.editor.step === undefined
+		? undefined
+		: props.setting.editor.step * numberScale.value,
+)
+const sliderValue = computed(() => {
+	const value = Number(valueText.value)
+	return Number.isFinite(value) ? value : (inputMin.value ?? 0)
+})
+const editorDisabled = computed(
+	() =>
+		props.disabled ||
+		props.setting.controlled ||
+		(props.showSyncToggle && !props.setting.sync_enabled),
+)
+const syncToggleDisabled = computed(
+	() =>
+		props.disabled ||
+		props.setting.controlled ||
+		(!props.setting.sync_enabled &&
+			(!!props.setting.validation_error ||
+				['mixed', 'unset', 'invalid'].includes(props.setting.value_state) ||
+				(props.setting.compatibility.total_participating > 0 &&
+					props.setting.compatibility.will_receive === 0))),
+)
+const placeholder = computed(() => {
+	if (props.setting.value_state === 'mixed') return formatMessage(messages.mixed)
+	if (props.setting.value_state === 'unset') return formatMessage(messages.unset)
+	if (props.setting.editor.type === 'external_raw') {
+		return formatMessage(presentationMessages.customValuePlaceholder)
+	}
+	return undefined
+})
+const compatibilityTooltip = computed(() =>
+	formatCompatibilityTooltip(formatMessage, props.setting),
+)
+const validationMessage = computed(() =>
+	formatGameSettingValidation(formatMessage, props.setting.validation_error),
+)
+const detailsTooltip = computed(() => validationMessage.value ?? compatibilityTooltip.value)
+const compatibilityTone = computed(() =>
+	validationMessage.value || props.setting.compatibility.left_local > 0
+		? 'text-orange'
+		: 'text-secondary',
+)
+const syncDisabledReason = computed(() => {
+	if (validationMessage.value) return validationMessage.value
+	if (props.setting.value_state === 'invalid') {
+		return formatMessage(presentationMessages.validationInvalidValue)
+	}
+	if (props.setting.value_state === 'mixed' || props.setting.value_state === 'unset') {
+		return formatMessage(presentationMessages.validationMissingValue)
+	}
+	if (props.setting.controlled) {
+		return formatMessage(presentationMessages.bucketLauncherControlled, { count: 1 })
+	}
+	if (
+		props.setting.compatibility.total_participating > 0 &&
+		props.setting.compatibility.will_receive === 0
+	) {
+		return formatMessage(presentationMessages.compatibilityNone)
+	}
+	return undefined
+})
+const syncActionLabel = computed(() =>
+	formatMessage(props.setting.sync_enabled ? messages.unsyncSetting : messages.syncSetting, {
+		setting: settingLabel.value,
+	}),
+)
+
+function updateValue(value: string | number | boolean | undefined) {
+	emit('update:canonical-value', canonicalValueFromInput(props.setting, value))
+}
+</script>
+
+<template>
+	<div
+		class="grid min-h-[54px] min-w-0 items-center gap-2"
+		:class="
+			isVolumeSlider
+				? showSyncToggle
+					? 'grid-cols-[minmax(10rem,0.65fr)_minmax(0,1.35fr)_2.25rem]'
+					: 'grid-cols-[minmax(10rem,0.65fr)_minmax(0,1.35fr)]'
+				: showSyncToggle
+					? 'grid-cols-[minmax(0,1fr)_12rem_2.25rem]'
+					: 'grid-cols-[minmax(0,1fr)_12rem]'
+		"
+	>
+		<div class="min-w-0">
+			<div class="flex items-center gap-2">
+				<h3
+					ref="settingLabelRef"
+					v-tooltip="truncatedTooltip(settingLabelRef, settingLabel)"
+					class="m-0 truncate text-lg font-semibold text-contrast"
+				>
+					{{ settingLabel }}
+				</h3>
+				<span
+					v-if="validationMessage || shouldShowCompatibilityIndicator(setting)"
+					v-tooltip="detailsTooltip"
+					tabindex="0"
+					role="img"
+					:aria-label="formatMessage(messages.compatibilityDetails)"
+					class="flex shrink-0 rounded-md outline-none focus-visible:ring-4 focus-visible:ring-brand-shadow"
+					:class="compatibilityTone"
+				>
+					<UnknownIcon class="size-4" aria-hidden="true" />
+				</span>
+			</div>
+			<p v-if="settingDescription" class="m-0 mt-0.5 text-primary">
+				{{ settingDescription }}
+			</p>
+		</div>
+
+		<div class="flex min-w-0 items-center justify-end">
+			<Slider
+				v-if="isVolumeSlider"
+				:model-value="sliderValue"
+				:min="inputMin ?? 0"
+				:max="inputMax ?? 100"
+				:step="inputStep ?? 1"
+				:snap-points="[0, 50, 100]"
+				:snap-range="5"
+				:disabled="editorDisabled"
+				@update:model-value="updateValue"
+			/>
+
+			<GameSettingBooleanControl
+				v-else-if="setting.editor.type === 'bool'"
+				:model-value="booleanValue"
+				:label="formatMessage(messages.valueLabel)"
+				:on-label="formatMessage(messages.on)"
+				:off-label="formatMessage(messages.off)"
+				:placeholder="placeholder"
+				:disabled="editorDisabled"
+				@update:model-value="updateValue"
+			/>
+
+			<Combobox
+				v-else-if="setting.editor.type === 'enum'"
+				:model-value="valueText"
+				:options="enumOptions"
+				:placeholder="placeholder"
+				:disabled="editorDisabled"
+				:aria-label="formatMessage(messages.valueLabel)"
+				trigger-class="!bg-transparent"
+				class="min-w-0"
+				@update:model-value="updateValue"
+			/>
+
+			<GameKeybindInput
+				v-else-if="setting.editor.type === 'key_binding'"
+				:model-value="valueText"
+				:setting-label="settingLabel"
+				:conflicts="keybindConflicts"
+				:mixed="setting.value_state === 'mixed'"
+				:disabled="editorDisabled"
+				@update:model-value="updateValue"
+			/>
+
+			<Input
+				v-else
+				:model-value="valueText"
+				:type="
+					setting.editor.type === 'integer' || setting.editor.type === 'decimal' ? 'number' : 'text'
+				"
+				:min="inputMin"
+				:max="inputMax"
+				:step="inputStep"
+				:placeholder="placeholder"
+				:disabled="editorDisabled"
+				:aria-label="formatMessage(messages.valueLabel)"
+				wrapper-class="w-full !bg-transparent"
+				@update:model-value="updateValue"
+			/>
+		</div>
+
+		<span
+			v-if="showSyncToggle"
+			v-tooltip="syncToggleDisabled ? syncDisabledReason : undefined"
+			class="flex justify-center"
+		>
+			<IconButton
+				:label="syncActionLabel"
+				:disabled="syncToggleDisabled"
+				:aria-pressed="setting.sync_enabled"
+				:class="
+					setting.sync_enabled
+						? '!bg-highlight-green !text-green !shadow-[inset_0_0_0_1px_var(--color-green)] [&>svg]:!text-green'
+						: ''
+				"
+				@click="emit('update:sync-enabled', !setting.sync_enabled)"
+			>
+				<LinkIcon v-if="setting.sync_enabled" />
+				<UnlinkIcon v-else />
+			</IconButton>
+		</span>
+	</div>
+</template>
diff --git a/apps/app-frontend/src/components/ui/settings/instances/game-settings/GameSettingsModal.vue b/apps/app-frontend/src/components/ui/settings/instances/game-settings/GameSettingsModal.vue
new file mode 100644
index 0000000000..583fbede14
--- /dev/null
+++ b/apps/app-frontend/src/components/ui/settings/instances/game-settings/GameSettingsModal.vue
@@ -0,0 +1,746 @@
+<script setup lang="ts">
+import {
+	EyeIcon,
+	LanguagesIcon,
+	LinkIcon,
+	MessageIcon,
+	MonitorIcon,
+	RefreshCwIcon,
+	SaveIcon,
+	SearchIcon,
+	SettingsIcon,
+	ShirtIcon,
+	SpinnerIcon,
+	TagCategoryAudioIcon,
+	TagCategoryGamepad2Icon,
+	UnlinkIcon,
+	WrenchIcon,
+	XIcon,
+} from '@modrinth/assets'
+import {
+	Button,
+	commonMessages,
+	ConfirmLeaveModal,
+	defineMessages,
+	FloatingActionBar,
+	injectNotificationManager,
+	Input,
+	TabbedModal,
+	type TabbedModalTab,
+	useVIntl,
+} from '@modrinth/ui'
+import type { Component } from 'vue'
+import { computed, onUnmounted, ref } from 'vue'
+
+import {
+	type EditableGameSetting,
+	type GameOptionCanonicalValue,
+	type GameSettingCategory,
+	type GameSettingsEditorState,
+	get_local_game_options_config,
+	get_synced_game_options_config,
+	preview_local_game_option_changes,
+	preview_synced_game_option_changes,
+	save_local_game_option_changes,
+	save_synced_game_option_changes,
+	type UpdateGameSettingsRequest,
+} from '@/helpers/game-options'
+
+import { minecraftKeybindConflictKey } from './game-keybinds'
+import {
+	canonicalValuesEqual,
+	cloneGameSettingsState,
+	gameSettingChanges,
+	settingCanBeEnabled,
+	settingSearchText,
+} from './game-setting-editors'
+import {
+	formatGameSettingDescription,
+	formatGameSettingLabel,
+	gameSettingCategoryMessage,
+} from './game-setting-messages'
+import GameSettingRow from './GameSettingRow.vue'
+
+const props = defineProps<{
+	instanceId?: string
+}>()
+
+const emit = defineEmits<{
+	saved: []
+}>()
+
+const { formatMessage } = useVIntl()
+const { addNotification, handleError } = injectNotificationManager()
+
+const messages = defineMessages({
+	title: {
+		id: 'app.settings.synced-options.game-settings.title',
+		defaultMessage: 'Game settings',
+	},
+	syncTitle: {
+		id: 'app.settings.synced-options.game-settings.sync-title',
+		defaultMessage: 'Sync game settings',
+	},
+	syncedOptionsDescription: {
+		id: 'app.settings.synced-options.game-settings.description',
+		defaultMessage:
+			'Synced options are applied to every instance and override the values included with a modpack.',
+	},
+	search: {
+		id: 'app.settings.synced-options.game-settings.search',
+		defaultMessage: 'Search settings...',
+	},
+	enableAll: {
+		id: 'app.settings.synced-options.game-settings.enable-all',
+		defaultMessage: 'Sync tab',
+	},
+	disableAll: {
+		id: 'app.settings.synced-options.game-settings.disable-all',
+		defaultMessage: 'Unsync all',
+	},
+	customEmpty: {
+		id: 'app.settings.synced-options.game-settings.custom-empty',
+		defaultMessage:
+			'Settings added by mods will appear here after Modrinth finds them in one of your instances.',
+	},
+	empty: {
+		id: 'app.settings.synced-options.game-settings.empty',
+		defaultMessage: 'No settings match your search or filter.',
+	},
+	loading: {
+		id: 'app.settings.synced-options.game-settings.loading',
+		defaultMessage: 'Loading settings...',
+	},
+	loadFailed: {
+		id: 'app.settings.synced-options.game-settings.load-failed',
+		defaultMessage: 'We couldn’t load your game settings.',
+	},
+	retry: {
+		id: 'app.settings.synced-options.game-settings.retry',
+		defaultMessage: 'Retry',
+	},
+	saveSettings: {
+		id: 'app.settings.synced-options.game-settings.save',
+		defaultMessage: 'Save settings',
+	},
+	unsavedChanges: {
+		id: 'app.settings.synced-options.game-settings.unsaved-changes',
+		defaultMessage: 'You have unsaved changes.',
+	},
+	saved: {
+		id: 'app.settings.synced-options.game-settings.saved',
+		defaultMessage: 'Game settings updated',
+	},
+	savedSummary: {
+		id: 'app.settings.synced-options.game-settings.saved-summary',
+		defaultMessage: 'Your changes were saved.',
+	},
+	savedLater: {
+		id: 'app.settings.synced-options.game-settings.saved-later',
+		defaultMessage:
+			'Your changes were saved and will finish syncing when your instances are ready.',
+	},
+	savedWithProblems: {
+		id: 'app.settings.synced-options.game-settings.saved-with-problems',
+		defaultMessage: 'Your changes were saved, but some instances could not be updated.',
+	},
+	conflictTitle: {
+		id: 'app.settings.synced-options.game-settings.conflict-title',
+		defaultMessage: 'These settings changed elsewhere',
+	},
+	conflictText: {
+		id: 'app.settings.synced-options.game-settings.conflict-text',
+		defaultMessage: 'We loaded the latest settings. Check your changes, then save again.',
+	},
+})
+
+const modal = ref<InstanceType<typeof TabbedModal> | null>(null)
+const confirmLeaveModal = ref<InstanceType<typeof ConfirmLeaveModal> | null>(null)
+const baseState = ref<GameSettingsEditorState | null>(null)
+const draftState = ref<GameSettingsEditorState | null>(null)
+const activeCategoryId = ref('')
+const search = ref('')
+const loading = ref(false)
+const saving = ref(false)
+const loadError = ref(false)
+const touchedValueOptionIds = ref<Set<string>>(new Set())
+let allowClose = false
+let previewTimer: ReturnType<typeof setTimeout> | null = null
+let previewGeneration = 0
+let loadGeneration = 0
+
+const isLocalEditor = computed(() => !!props.instanceId)
+
+const categoryIcons: Record<string, Component> = {
+	skin_customization: ShirtIcon,
+	video: MonitorIcon,
+	video_settings: MonitorIcon,
+	language: LanguagesIcon,
+	music_and_sound: TagCategoryAudioIcon,
+	controls: TagCategoryGamepad2Icon,
+	chat: MessageIcon,
+	chat_settings: MessageIcon,
+	accessibility: EyeIcon,
+	custom: WrenchIcon,
+	custom_settings: WrenchIcon,
+}
+
+const categories = computed<GameSettingCategory[]>(() => {
+	if (!draftState.value) return []
+
+	const settings = draftState.value.settings
+	const visible = draftState.value.categories.filter(
+		(category) =>
+			category.is_custom || settings.some((setting) => setting.category_id === category.id),
+	)
+	if (!visible.some((category) => category.is_custom || category.id === 'custom_settings')) {
+		visible.push({
+			id: 'custom_settings',
+			is_custom: true,
+		})
+	}
+	return visible
+})
+
+const categoryTabs = computed<TabbedModalTab[]>(() =>
+	categories.value.map((category) => ({
+		name: gameSettingCategoryMessage(category),
+		icon: categoryIcon(category),
+	})),
+)
+
+const activeCategory = computed(() =>
+	categories.value.find((category) => category.id === activeCategoryId.value),
+)
+
+const categorySettings = computed(() => {
+	if (!draftState.value) return []
+
+	const query = search.value.trim().toLocaleLowerCase()
+	return draftState.value.settings.filter((setting) => {
+		if (!query && setting.category_id !== activeCategoryId.value) return false
+		if (
+			query &&
+			!settingSearchText(
+				setting,
+				formatGameSettingLabel(formatMessage, setting),
+				formatGameSettingDescription(formatMessage, setting),
+			).includes(query)
+		)
+			return false
+		return true
+	})
+})
+
+const keybindConflicts = computed(() => {
+	if (!draftState.value) return new Map<string, string[]>()
+
+	const bindings = new Map<string, EditableGameSetting[]>()
+	for (const setting of draftState.value.settings) {
+		if (setting.editor.type !== 'key_binding' || setting.canonical_value?.type !== 'key_binding')
+			continue
+		const key = minecraftKeybindConflictKey(setting.canonical_value.value)
+		if (!key) continue
+		bindings.set(key, [...(bindings.get(key) ?? []), setting])
+	}
+
+	const conflicts = new Map<string, string[]>()
+	for (const settings of bindings.values()) {
+		if (settings.length < 2) continue
+		for (const setting of settings) {
+			conflicts.set(
+				setting.option_id,
+				settings
+					.filter((candidate) => candidate.option_id !== setting.option_id)
+					.map((candidate) => formatGameSettingLabel(formatMessage, candidate)),
+			)
+		}
+	}
+	return conflicts
+})
+
+const dirtyChanges = computed(() =>
+	gameSettingChanges(baseState.value, draftState.value, touchedValueOptionIds.value),
+)
+const isDirty = computed(() => dirtyChanges.value.length > 0)
+const dirtyOptionIds = computed(() => new Set(dirtyChanges.value.map((change) => change.option_id)))
+const hasBlockingDraft = computed(
+	() =>
+		draftState.value?.settings.some(
+			(setting) =>
+				dirtyOptionIds.value.has(setting.option_id) &&
+				(isLocalEditor.value || setting.sync_enabled) &&
+				(!!setting.validation_error || ['mixed', 'unset', 'invalid'].includes(setting.value_state)),
+		) ?? false,
+)
+const enableCandidates = computed(() =>
+	categorySettings.value.filter((setting) => !setting.sync_enabled && settingCanBeEnabled(setting)),
+)
+const disableCandidates = computed(() =>
+	categorySettings.value.filter((setting) => setting.sync_enabled && !setting.controlled),
+)
+const toggleableCategorySettings = computed(() =>
+	categorySettings.value.filter((setting) => !setting.controlled),
+)
+const allCategorySettingsSynced = computed(
+	() =>
+		toggleableCategorySettings.value.length > 0 &&
+		toggleableCategorySettings.value.every((setting) => setting.sync_enabled),
+)
+const modalTitle = computed(() =>
+	formatMessage(isLocalEditor.value ? messages.title : messages.syncTitle),
+)
+
+function categoryIcon(category: GameSettingCategory): Component {
+	return categoryIcons[category.id] ?? SettingsIcon
+}
+
+function changeCategory(_fromIndex: number, toIndex: number): boolean {
+	const category = categories.value[toIndex]
+	if (!category) return false
+	activeCategoryId.value = category.id
+	search.value = ''
+	return true
+}
+
+function editorRequest(): UpdateGameSettingsRequest | null {
+	if (!baseState.value || !draftState.value) return null
+	return {
+		expected_summary_revision: draftState.value.summary_revision,
+		expected_canonical_revision: draftState.value.canonical_revision,
+		expected_catalog_revision: draftState.value.catalog_revision,
+		changes: dirtyChanges.value,
+	}
+}
+
+async function load() {
+	const generation = ++loadGeneration
+	previewGeneration++
+	loading.value = true
+	loadError.value = false
+	try {
+		const state = props.instanceId
+			? await get_local_game_options_config(props.instanceId)
+			: await get_synced_game_options_config()
+		if (generation !== loadGeneration) return
+		baseState.value = cloneGameSettingsState(state)
+		draftState.value = cloneGameSettingsState(state)
+		touchedValueOptionIds.value = new Set()
+		const currentCategoryExists = categories.value.some(
+			(category) => category.id === activeCategoryId.value,
+		)
+		if (!currentCategoryExists)
+			activeCategoryId.value = categories.value[0]?.id ?? 'custom_settings'
+		const activeCategoryIndex = categories.value.findIndex(
+			(category) => category.id === activeCategoryId.value,
+		)
+		if (activeCategoryIndex >= 0) modal.value?.setTab(activeCategoryIndex)
+	} catch (error) {
+		if (generation !== loadGeneration) return
+		loadError.value = true
+		handleError(error)
+	} finally {
+		if (generation === loadGeneration) loading.value = false
+	}
+}
+
+function show() {
+	allowClose = false
+	search.value = ''
+	modal.value?.show()
+	void load()
+}
+
+function hide() {
+	modal.value?.hide()
+}
+
+function reset() {
+	if (previewTimer) clearTimeout(previewTimer)
+	previewTimer = null
+	previewGeneration++
+	loadGeneration++
+	baseState.value = null
+	draftState.value = null
+	loading.value = false
+	saving.value = false
+	loadError.value = false
+	touchedValueOptionIds.value = new Set()
+	allowClose = false
+}
+
+function beforeHide(): boolean {
+	if (allowClose || !isDirty.value) return true
+	void confirmDiscard()
+	return false
+}
+
+async function confirmDiscard() {
+	const discard = await confirmLeaveModal.value?.prompt()
+	if (!discard) return
+	allowClose = true
+	modal.value?.hide()
+}
+
+function cancelChanges() {
+	if (saving.value || !baseState.value) return
+	if (previewTimer) clearTimeout(previewTimer)
+	previewTimer = null
+	previewGeneration++
+	draftState.value = cloneGameSettingsState(baseState.value)
+	touchedValueOptionIds.value = new Set()
+}
+
+function settingById(optionId: string): EditableGameSetting | undefined {
+	return draftState.value?.settings.find((setting) => setting.option_id === optionId)
+}
+
+function setSyncEnabled(optionId: string, enabled: boolean) {
+	if (!draftState.value) return
+	draftState.value.settings = draftState.value.settings.map((setting) =>
+		setting.option_id === optionId
+			? { ...setting, sync_enabled: enabled, validation_error: null }
+			: setting,
+	)
+	schedulePreview()
+}
+
+function setCanonicalValue(optionId: string, value: GameOptionCanonicalValue | null) {
+	if (!draftState.value) return
+	const currentSetting = settingById(optionId)
+	const baseSetting = baseState.value?.settings.find((setting) => setting.option_id === optionId)
+	if (!currentSetting) return
+
+	const revertedToBase =
+		!!baseSetting &&
+		!canonicalValuesEqual(currentSetting.canonical_value, baseSetting.canonical_value) &&
+		canonicalValuesEqual(value, baseSetting.canonical_value)
+	const touchedOptionIds = new Set(touchedValueOptionIds.value)
+	if (revertedToBase) {
+		touchedOptionIds.delete(optionId)
+	} else {
+		touchedOptionIds.add(optionId)
+	}
+	touchedValueOptionIds.value = touchedOptionIds
+	draftState.value.settings = draftState.value.settings.map((setting) =>
+		setting.option_id === optionId
+			? {
+					...setting,
+					canonical_value: value,
+					value_state: revertedToBase ? baseSetting.value_state : value ? 'canonical' : 'unset',
+					validation_error: revertedToBase ? baseSetting.validation_error : null,
+				}
+			: setting,
+	)
+	schedulePreview()
+}
+
+function enableVisible() {
+	if (saving.value || !draftState.value) return
+	const optionIds = new Set(enableCandidates.value.map((setting) => setting.option_id))
+	draftState.value.settings = draftState.value.settings.map((setting) =>
+		optionIds.has(setting.option_id)
+			? { ...setting, sync_enabled: true, validation_error: null }
+			: setting,
+	)
+	schedulePreview()
+}
+
+function disableVisible() {
+	if (saving.value || !draftState.value) return
+	const optionIds = new Set(disableCandidates.value.map((setting) => setting.option_id))
+	draftState.value.settings = draftState.value.settings.map((setting) =>
+		optionIds.has(setting.option_id)
+			? { ...setting, sync_enabled: false, validation_error: null }
+			: setting,
+	)
+	schedulePreview()
+}
+
+function toggleVisibleSync() {
+	if (allCategorySettingsSynced.value) {
+		disableVisible()
+	} else {
+		enableVisible()
+	}
+}
+
+function schedulePreview() {
+	previewGeneration++
+	if (previewTimer) clearTimeout(previewTimer)
+	previewTimer = setTimeout(() => void preview(), 350)
+}
+
+function mergePreview(preview: GameSettingsEditorState) {
+	if (!baseState.value || !draftState.value) return
+	const previousBase = cloneGameSettingsState(baseState.value)
+	const previousDraft = cloneGameSettingsState(draftState.value)
+	const dirtyIds = new Set(
+		gameSettingChanges(previousBase, previousDraft, touchedValueOptionIds.value).map(
+			(change) => change.option_id,
+		),
+	)
+	const stagedSettings = new Map(
+		previousDraft.settings
+			.filter((setting) => dirtyIds.has(setting.option_id))
+			.map((setting) => [setting.option_id, setting]),
+	)
+	const previousBaseSettings = new Map(
+		previousBase.settings.map((setting) => [setting.option_id, setting]),
+	)
+	const nextBase = cloneGameSettingsState(preview)
+	const nextDraft = cloneGameSettingsState(preview)
+	nextBase.settings = nextBase.settings.map((setting) =>
+		dirtyIds.has(setting.option_id)
+			? { ...(previousBaseSettings.get(setting.option_id) ?? setting) }
+			: setting,
+	)
+	nextDraft.settings = nextDraft.settings.map((setting) => {
+		const staged = stagedSettings.get(setting.option_id)
+		if (!staged) return setting
+		return {
+			...setting,
+			sync_enabled: staged.sync_enabled,
+			canonical_value: staged.canonical_value,
+			option_revision: staged.option_revision,
+		}
+	})
+	baseState.value = nextBase
+	draftState.value = nextDraft
+}
+
+async function preview() {
+	const request = editorRequest()
+	if (!request || request.changes.length === 0) {
+		previewGeneration++
+		if (baseState.value) draftState.value = cloneGameSettingsState(baseState.value)
+		return
+	}
+
+	const generation = ++previewGeneration
+	try {
+		const previewState = props.instanceId
+			? await preview_local_game_option_changes(props.instanceId, request)
+			: await preview_synced_game_option_changes(request)
+		if (generation !== previewGeneration) return
+		mergePreview(previewState)
+	} catch {
+		return
+	}
+}
+
+async function save() {
+	const request = editorRequest()
+	if (!request || request.changes.length === 0) return
+
+	if (previewTimer) clearTimeout(previewTimer)
+	previewTimer = null
+	previewGeneration++
+	saving.value = true
+	try {
+		const result = props.instanceId
+			? await save_local_game_option_changes(props.instanceId, request)
+			: await save_synced_game_option_changes(request)
+		if (result.conflicts?.length) {
+			const refreshed =
+				result.state ??
+				(props.instanceId
+					? await get_local_game_options_config(props.instanceId)
+					: await get_synced_game_options_config())
+			const previousDraft = draftState.value
+			const stagedChanges = new Map(request.changes.map((change) => [change.option_id, change]))
+			const conflicts = new Set(result.conflicts)
+			baseState.value = cloneGameSettingsState(refreshed)
+			draftState.value = cloneGameSettingsState(refreshed)
+
+			for (const setting of draftState.value.settings) {
+				const previous = previousDraft?.settings.find(
+					(candidate) => candidate.option_id === setting.option_id,
+				)
+				if (conflicts.has(setting.option_id)) {
+					setting.validation_error = 'changed_since_opened'
+					continue
+				}
+				const change = stagedChanges.get(setting.option_id)
+				if (!change || !previous) continue
+				if (change.sync_enabled !== undefined) setting.sync_enabled = previous.sync_enabled
+				if (change.canonical_value !== undefined) {
+					setting.canonical_value = previous.canonical_value
+					setting.value_state = previous.value_state
+				}
+			}
+
+			addNotification({
+				type: 'warning',
+				title: formatMessage(messages.conflictTitle),
+				text: formatMessage(messages.conflictText),
+			})
+			if (
+				gameSettingChanges(baseState.value, draftState.value, touchedValueOptionIds.value).length >
+				0
+			) {
+				schedulePreview()
+			}
+			return
+		}
+
+		const savedWithProblems = result.failed > 0 || result.unsupported > 0
+		addNotification({
+			type: savedWithProblems ? 'warning' : 'success',
+			title: formatMessage(messages.saved),
+			text: formatMessage(
+				savedWithProblems
+					? messages.savedWithProblems
+					: result.deferred > 0
+						? messages.savedLater
+						: messages.savedSummary,
+			),
+		})
+		const refreshed =
+			result.state ??
+			(props.instanceId
+				? await get_local_game_options_config(props.instanceId)
+				: await get_synced_game_options_config())
+		baseState.value = cloneGameSettingsState(refreshed)
+		draftState.value = cloneGameSettingsState(refreshed)
+		touchedValueOptionIds.value = new Set()
+		emit('saved')
+	} catch (error) {
+		handleError(error)
+	} finally {
+		saving.value = false
+	}
+}
+
+onUnmounted(() => {
+	if (previewTimer) clearTimeout(previewTimer)
+})
+
+defineExpose({ show, hide })
+</script>
+
+<template>
+	<TabbedModal
+		ref="modal"
+		:tabs="categoryTabs"
+		:header="modalTitle"
+		:before-hide="beforeHide"
+		:before-tab-change="changeCategory"
+		:on-after-hide="reset"
+		:disable-close="saving"
+		:floating-action-bar-shown="isDirty"
+		:max-width="'min(1080px, calc(95vw - 2rem))'"
+		:width="'min(1080px, calc(95vw - 2rem))'"
+	>
+		<template #sidebar-header>
+			<div class="pb-4">
+				<Input
+					v-model="search"
+					:icon="SearchIcon"
+					type="search"
+					autocomplete="off"
+					:placeholder="formatMessage(messages.search)"
+					wrapper-class="w-full shrink-0"
+				/>
+			</div>
+		</template>
+
+		<template #content>
+			<div class="flex min-h-full min-w-0 flex-col">
+				<div
+					v-if="!isLocalEditor"
+					class="flex shrink-0 flex-wrap items-start justify-between gap-4 pb-4"
+				>
+					<p class="m-0 min-w-60 flex-1 text-primary">
+						{{ formatMessage(messages.syncedOptionsDescription) }}
+					</p>
+					<Button
+						class="w-48 justify-center"
+						size="lg"
+						:disabled="
+							saving ||
+							(allCategorySettingsSynced
+								? disableCandidates.length === 0
+								: enableCandidates.length === 0)
+						"
+						@click="toggleVisibleSync"
+					>
+						<LinkIcon v-if="allCategorySettingsSynced" />
+						<UnlinkIcon v-else />
+						{{
+							formatMessage(allCategorySettingsSynced ? messages.disableAll : messages.enableAll)
+						}}
+					</Button>
+				</div>
+
+				<div
+					v-if="loading"
+					class="flex min-h-40 flex-1 items-center justify-center gap-2 text-secondary"
+				>
+					<SpinnerIcon class="size-5 animate-spin" />
+					{{ formatMessage(messages.loading) }}
+				</div>
+				<div
+					v-else-if="loadError"
+					class="flex min-h-40 flex-1 flex-col items-center justify-center gap-3 text-secondary"
+				>
+					<p class="m-0">{{ formatMessage(messages.loadFailed) }}</p>
+					<Button @click="load">
+						<RefreshCwIcon />
+						{{ formatMessage(messages.retry) }}
+					</Button>
+				</div>
+				<div v-else class="min-h-0 flex-1">
+					<div
+						v-if="categorySettings.length === 0"
+						class="flex h-full min-h-40 items-center justify-center px-8 text-center text-secondary"
+					>
+						{{
+							activeCategory?.is_custom && !search
+								? formatMessage(messages.customEmpty)
+								: formatMessage(messages.empty)
+						}}
+					</div>
+					<div v-else class="flex flex-col gap-4">
+						<GameSettingRow
+							v-for="setting in categorySettings"
+							:key="setting.option_id"
+							:setting="setting"
+							:keybind-conflicts="keybindConflicts.get(setting.option_id)"
+							:disabled="saving"
+							:show-sync-toggle="!isLocalEditor"
+							@update:sync-enabled="setSyncEnabled(setting.option_id, $event)"
+							@update:canonical-value="setCanonicalValue(setting.option_id, $event)"
+						/>
+					</div>
+				</div>
+			</div>
+		</template>
+
+		<template #floating-action-bar>
+			<FloatingActionBar v-if="isDirty" :shown="true" :inline="true" :aria-label="modalTitle">
+				<p class="m-0 text-sm font-semibold md:text-base">
+					{{ formatMessage(messages.unsavedChanges) }}
+				</p>
+				<div class="ml-auto flex gap-2">
+					<Button type="outlined" :disabled="saving" @click="cancelChanges">
+						<XIcon />
+						{{ formatMessage(commonMessages.cancelButton) }}
+					</Button>
+					<Button
+						type="colored"
+						color="brand"
+						:disabled="!isDirty || loading || saving || hasBlockingDraft"
+						:loading="saving"
+						@click="save"
+					>
+						<SaveIcon v-if="!saving" />
+						{{ formatMessage(messages.saveSettings) }}
+					</Button>
+				</div>
+			</FloatingActionBar>
+		</template>
+	</TabbedModal>
+
+	<ConfirmLeaveModal ref="confirmLeaveModal" />
+</template>
diff --git a/apps/app-frontend/src/components/ui/settings/instances/game-settings/game-keybinds.ts b/apps/app-frontend/src/components/ui/settings/instances/game-settings/game-keybinds.ts
new file mode 100644
index 0000000000..dd05a361cf
--- /dev/null
+++ b/apps/app-frontend/src/components/ui/settings/instances/game-settings/game-keybinds.ts
@@ -0,0 +1,421 @@
+import { defineMessages, type MessageDescriptor, type VIntlFormatters } from '@modrinth/ui'
+
+type FormatMessage = VIntlFormatters['formatMessage']
+
+type StopKeybindRecording = () => void
+let stopActiveKeybindRecording: StopKeybindRecording | null = null
+
+export function activateKeybindRecording(stop: StopKeybindRecording) {
+	if (stopActiveKeybindRecording === stop) return
+	const stopPrevious = stopActiveKeybindRecording
+	stopActiveKeybindRecording = stop
+	stopPrevious?.()
+}
+
+export function deactivateKeybindRecording(stop: StopKeybindRecording) {
+	if (stopActiveKeybindRecording === stop) {
+		stopActiveKeybindRecording = null
+	}
+}
+
+const keyMessages = defineMessages({
+	unbound: {
+		id: 'app.settings.game-options.keybind.key.unbound',
+		defaultMessage: 'Unbound',
+	},
+	escape: {
+		id: 'app.settings.game-options.keybind.key.escape',
+		defaultMessage: 'Escape',
+	},
+	backspace: {
+		id: 'app.settings.game-options.keybind.key.backspace',
+		defaultMessage: 'Backspace',
+	},
+	tab: {
+		id: 'app.settings.game-options.keybind.key.tab',
+		defaultMessage: 'Tab',
+	},
+	enter: {
+		id: 'app.settings.game-options.keybind.key.enter',
+		defaultMessage: 'Enter',
+	},
+	leftControl: {
+		id: 'app.settings.game-options.keybind.key.left-control',
+		defaultMessage: 'Left Ctrl',
+	},
+	rightControl: {
+		id: 'app.settings.game-options.keybind.key.right-control',
+		defaultMessage: 'Right Ctrl',
+	},
+	leftShift: {
+		id: 'app.settings.game-options.keybind.key.left-shift',
+		defaultMessage: 'Left Shift',
+	},
+	rightShift: {
+		id: 'app.settings.game-options.keybind.key.right-shift',
+		defaultMessage: 'Right Shift',
+	},
+	leftAlt: {
+		id: 'app.settings.game-options.keybind.key.left-alt',
+		defaultMessage: 'Left Alt',
+	},
+	rightAlt: {
+		id: 'app.settings.game-options.keybind.key.right-alt',
+		defaultMessage: 'Right Alt',
+	},
+	space: {
+		id: 'app.settings.game-options.keybind.key.space',
+		defaultMessage: 'Space',
+	},
+	capsLock: {
+		id: 'app.settings.game-options.keybind.key.caps-lock',
+		defaultMessage: 'Caps Lock',
+	},
+	numLock: {
+		id: 'app.settings.game-options.keybind.key.num-lock',
+		defaultMessage: 'Num Lock',
+	},
+	scrollLock: {
+		id: 'app.settings.game-options.keybind.key.scroll-lock',
+		defaultMessage: 'Scroll Lock',
+	},
+	printScreen: {
+		id: 'app.settings.game-options.keybind.key.print-screen',
+		defaultMessage: 'Print Screen',
+	},
+	pause: {
+		id: 'app.settings.game-options.keybind.key.pause',
+		defaultMessage: 'Pause',
+	},
+	home: {
+		id: 'app.settings.game-options.keybind.key.home',
+		defaultMessage: 'Home',
+	},
+	end: {
+		id: 'app.settings.game-options.keybind.key.end',
+		defaultMessage: 'End',
+	},
+	pageUp: {
+		id: 'app.settings.game-options.keybind.key.page-up',
+		defaultMessage: 'Page Up',
+	},
+	pageDown: {
+		id: 'app.settings.game-options.keybind.key.page-down',
+		defaultMessage: 'Page Down',
+	},
+	insert: {
+		id: 'app.settings.game-options.keybind.key.insert',
+		defaultMessage: 'Insert',
+	},
+	delete: {
+		id: 'app.settings.game-options.keybind.key.delete',
+		defaultMessage: 'Delete',
+	},
+	arrowUp: {
+		id: 'app.settings.game-options.keybind.key.arrow-up',
+		defaultMessage: 'Up Arrow',
+	},
+	arrowDown: {
+		id: 'app.settings.game-options.keybind.key.arrow-down',
+		defaultMessage: 'Down Arrow',
+	},
+	arrowLeft: {
+		id: 'app.settings.game-options.keybind.key.arrow-left',
+		defaultMessage: 'Left Arrow',
+	},
+	arrowRight: {
+		id: 'app.settings.game-options.keybind.key.arrow-right',
+		defaultMessage: 'Right Arrow',
+	},
+	leftSuper: {
+		id: 'app.settings.game-options.keybind.key.left-super',
+		defaultMessage: 'Left Super',
+	},
+	rightSuper: {
+		id: 'app.settings.game-options.keybind.key.right-super',
+		defaultMessage: 'Right Super',
+	},
+	leftCommand: {
+		id: 'app.settings.game-options.keybind.key.left-command',
+		defaultMessage: 'Left Command',
+	},
+	rightCommand: {
+		id: 'app.settings.game-options.keybind.key.right-command',
+		defaultMessage: 'Right Command',
+	},
+	menu: {
+		id: 'app.settings.game-options.keybind.key.menu',
+		defaultMessage: 'Menu',
+	},
+	keypadKey: {
+		id: 'app.settings.game-options.keybind.key.keypad-key',
+		defaultMessage: 'Numpad {key}',
+	},
+	leftMouse: {
+		id: 'app.settings.game-options.keybind.mouse.left',
+		defaultMessage: 'Left Mouse',
+	},
+	rightMouse: {
+		id: 'app.settings.game-options.keybind.mouse.right',
+		defaultMessage: 'Right Mouse',
+	},
+	middleMouse: {
+		id: 'app.settings.game-options.keybind.mouse.middle',
+		defaultMessage: 'Middle Mouse',
+	},
+	mouseButton: {
+		id: 'app.settings.game-options.keybind.mouse.button',
+		defaultMessage: 'Mouse {button}',
+	},
+	scancode: {
+		id: 'app.settings.game-options.keybind.scancode',
+		defaultMessage: 'Scancode {code}',
+	},
+	unknownKey: {
+		id: 'app.settings.game-options.keybind.key.unknown',
+		defaultMessage: 'Unknown key',
+	},
+	controlModifier: {
+		id: 'app.settings.game-options.keybind.modifier.control',
+		defaultMessage: 'Ctrl',
+	},
+	shiftModifier: {
+		id: 'app.settings.game-options.keybind.modifier.shift',
+		defaultMessage: 'Shift',
+	},
+	altModifier: {
+		id: 'app.settings.game-options.keybind.modifier.alt',
+		defaultMessage: 'Alt',
+	},
+	commandModifier: {
+		id: 'app.settings.game-options.keybind.modifier.command',
+		defaultMessage: 'Command',
+	},
+	superModifier: {
+		id: 'app.settings.game-options.keybind.modifier.super',
+		defaultMessage: 'Super',
+	},
+})
+
+const keyboardCodeTokens: Record<string, string> = {
+	Escape: 'escape',
+	Minus: 'minus',
+	Equal: 'equal',
+	Backspace: 'backspace',
+	Tab: 'tab',
+	BracketLeft: 'left.bracket',
+	BracketRight: 'right.bracket',
+	Enter: 'enter',
+	ControlLeft: 'left.control',
+	Semicolon: 'semicolon',
+	Quote: 'apostrophe',
+	Backquote: 'grave.accent',
+	ShiftLeft: 'left.shift',
+	Backslash: 'backslash',
+	Comma: 'comma',
+	Period: 'period',
+	Slash: 'slash',
+	ShiftRight: 'right.shift',
+	AltLeft: 'left.alt',
+	Space: 'space',
+	CapsLock: 'caps.lock',
+	NumLock: 'num.lock',
+	ScrollLock: 'scroll.lock',
+	NumpadSubtract: 'keypad.subtract',
+	NumpadAdd: 'keypad.add',
+	NumpadDecimal: 'keypad.decimal',
+	NumpadComma: 'keypad.decimal',
+	NumpadEqual: 'keypad.equal',
+	NumpadEnter: 'keypad.enter',
+	ControlRight: 'right.control',
+	NumpadDivide: 'keypad.divide',
+	NumpadMultiply: 'keypad.multiply',
+	PrintScreen: 'print.screen',
+	AltRight: 'right.alt',
+	Pause: 'pause',
+	Home: 'home',
+	ArrowUp: 'up',
+	PageUp: 'page.up',
+	ArrowLeft: 'left',
+	ArrowRight: 'right',
+	End: 'end',
+	ArrowDown: 'down',
+	PageDown: 'page.down',
+	Insert: 'insert',
+	Delete: 'delete',
+	MetaLeft: 'left.win',
+	MetaRight: 'right.win',
+	ContextMenu: 'menu',
+}
+
+const keyboardLabels: Record<string, MessageDescriptor | string> = {
+	escape: keyMessages.escape,
+	minus: '-',
+	equal: '=',
+	backspace: keyMessages.backspace,
+	tab: keyMessages.tab,
+	'left.bracket': '[',
+	'right.bracket': ']',
+	enter: keyMessages.enter,
+	'left.control': keyMessages.leftControl,
+	semicolon: ';',
+	apostrophe: "'",
+	'grave.accent': '`',
+	'left.shift': keyMessages.leftShift,
+	backslash: '\\',
+	comma: ',',
+	period: '.',
+	slash: '/',
+	'right.shift': keyMessages.rightShift,
+	'left.alt': keyMessages.leftAlt,
+	space: keyMessages.space,
+	'caps.lock': keyMessages.capsLock,
+	'num.lock': keyMessages.numLock,
+	'scroll.lock': keyMessages.scrollLock,
+	'keypad.subtract': '-',
+	'keypad.add': '+',
+	'keypad.decimal': '.',
+	'keypad.equal': '=',
+	'keypad.enter': keyMessages.enter,
+	'right.control': keyMessages.rightControl,
+	'keypad.divide': '/',
+	'keypad.multiply': '*',
+	'print.screen': keyMessages.printScreen,
+	'right.alt': keyMessages.rightAlt,
+	pause: keyMessages.pause,
+	home: keyMessages.home,
+	up: keyMessages.arrowUp,
+	'page.up': keyMessages.pageUp,
+	left: keyMessages.arrowLeft,
+	right: keyMessages.arrowRight,
+	end: keyMessages.end,
+	down: keyMessages.arrowDown,
+	'page.down': keyMessages.pageDown,
+	insert: keyMessages.insert,
+	delete: keyMessages.delete,
+	menu: keyMessages.menu,
+}
+
+function splitKeybind(value: string): [key: string, modifier?: string] {
+	const separator = value.indexOf(':')
+	return separator === -1 ? [value] : [value.slice(0, separator), value.slice(separator + 1)]
+}
+
+function keyboardIdentifierFromCode(code: string): string | null {
+	const letter = /^Key([A-Z])$/.exec(code)
+	if (letter) return letter[1].toLowerCase()
+
+	const digit = /^Digit([0-9])$/.exec(code)
+	if (digit) return digit[1]
+
+	const functionKey = /^F([1-9]|1[0-9]|2[0-5])$/.exec(code)
+	if (functionKey) return `f${functionKey[1]}`
+
+	const keypadDigit = /^Numpad([0-9])$/.exec(code)
+	if (keypadDigit) return `keypad.${keypadDigit[1]}`
+
+	return keyboardCodeTokens[code] ?? null
+}
+
+export function minecraftKeyTokenFromKeyboardEvent(event: KeyboardEvent): string | null {
+	const identifier = keyboardIdentifierFromCode(event.code)
+	return identifier ? `key.keyboard.${identifier}` : null
+}
+
+export function minecraftMouseTokenFromButton(button: number): string | null {
+	if (!Number.isInteger(button) || button < 0 || button > 15) return null
+	if (button === 0) return 'key.mouse.left'
+	if (button === 1) return 'key.mouse.middle'
+	if (button === 2) return 'key.mouse.right'
+	return `key.mouse.${button + 1}`
+}
+
+function formatKeyboardLabel(
+	formatMessage: FormatMessage,
+	identifier: string,
+	isMac: boolean,
+): string {
+	if (identifier === 'unknown') return formatMessage(keyMessages.unbound)
+	if (/^[a-z]$/.test(identifier)) return identifier.toUpperCase()
+	if (/^[0-9]$/.test(identifier)) return identifier
+	if (/^f([1-9]|1[0-9]|2[0-5])$/.test(identifier)) return identifier.toUpperCase()
+
+	const keypad = /^keypad\.(.+)$/.exec(identifier)
+	if (keypad) {
+		const label = keyboardLabels[identifier]
+		const key = typeof label === 'string' ? label : label ? formatMessage(label) : keypad[1]
+		return formatMessage(keyMessages.keypadKey, { key })
+	}
+
+	if (identifier === 'left.win') {
+		return formatMessage(isMac ? keyMessages.leftCommand : keyMessages.leftSuper)
+	}
+	if (identifier === 'right.win') {
+		return formatMessage(isMac ? keyMessages.rightCommand : keyMessages.rightSuper)
+	}
+
+	const label = keyboardLabels[identifier]
+	if (typeof label === 'string') return label
+	if (label) return formatMessage(label)
+	return identifier
+		.split('.')
+		.map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
+		.join(' ')
+}
+
+function formatModifier(formatMessage: FormatMessage, modifier: string, isMac: boolean): string {
+	switch (modifier.toUpperCase()) {
+		case 'CONTROL':
+		case 'CTRL':
+			return formatMessage(keyMessages.controlModifier)
+		case 'SHIFT':
+			return formatMessage(keyMessages.shiftModifier)
+		case 'ALT':
+			return formatMessage(keyMessages.altModifier)
+		case 'META':
+		case 'SUPER':
+			return formatMessage(isMac ? keyMessages.commandModifier : keyMessages.superModifier)
+		default:
+			return modifier
+	}
+}
+
+export function formatMinecraftKeybind(
+	formatMessage: FormatMessage,
+	value: string,
+	isMac: boolean,
+): string {
+	const [key, modifier] = splitKeybind(value)
+	let label: string
+
+	if (key.startsWith('key.keyboard.')) {
+		label = formatKeyboardLabel(formatMessage, key.slice('key.keyboard.'.length), isMac)
+	} else if (key === 'key.mouse.left') {
+		label = formatMessage(keyMessages.leftMouse)
+	} else if (key === 'key.mouse.right') {
+		label = formatMessage(keyMessages.rightMouse)
+	} else if (key === 'key.mouse.middle') {
+		label = formatMessage(keyMessages.middleMouse)
+	} else if (key.startsWith('key.mouse.')) {
+		label = formatMessage(keyMessages.mouseButton, {
+			button: key.slice('key.mouse.'.length),
+		})
+	} else if (key.startsWith('scancode.')) {
+		label = formatMessage(keyMessages.scancode, { code: key.slice('scancode.'.length) })
+	} else {
+		label = formatMessage(keyMessages.unknownKey)
+	}
+
+	if (!modifier || key === 'key.keyboard.unknown') return label
+	const modifiers = modifier
+		.split(/[+:]/)
+		.filter(Boolean)
+		.map((part) => formatModifier(formatMessage, part, isMac))
+	return [...modifiers, label].join(' + ')
+}
+
+export function minecraftKeybindConflictKey(value: string): string | null {
+	const normalized = value.trim().toLowerCase()
+	if (!normalized || normalized === 'key.keyboard.unknown') return null
+	return normalized
+}
diff --git a/apps/app-frontend/src/components/ui/settings/instances/game-settings/game-setting-boolean-control.vue b/apps/app-frontend/src/components/ui/settings/instances/game-settings/game-setting-boolean-control.vue
new file mode 100644
index 0000000000..c3cb41cd89
--- /dev/null
+++ b/apps/app-frontend/src/components/ui/settings/instances/game-settings/game-setting-boolean-control.vue
@@ -0,0 +1,53 @@
+<script setup lang="ts">
+defineProps<{
+	modelValue?: boolean
+	disabled?: boolean
+	label: string
+	onLabel: string
+	offLabel: string
+	placeholder?: string
+}>()
+
+const emit = defineEmits<{
+	'update:model-value': [value: boolean]
+}>()
+</script>
+
+<template>
+	<div
+		v-tooltip="modelValue === undefined ? placeholder : undefined"
+		role="group"
+		:aria-label="label"
+		class="inline-flex h-9 items-center gap-0.5 rounded-xl border border-solid border-surface-5 bg-transparent p-px shadow-sm"
+		:class="disabled ? 'opacity-50' : ''"
+	>
+		<button
+			type="button"
+			:aria-pressed="modelValue === true"
+			:disabled="disabled"
+			class="flex h-8 cursor-pointer items-center rounded-[10px] border border-solid px-3 text-base font-medium leading-5 text-contrast transition-all active:scale-[0.97] focus-visible:outline-none focus-visible:ring-4 focus-visible:ring-brand-shadow disabled:cursor-not-allowed"
+			:class="
+				modelValue === true
+					? 'border-green bg-highlight-green text-green'
+					: 'border-transparent bg-transparent hover:bg-surface-4'
+			"
+			@click="emit('update:model-value', true)"
+		>
+			{{ onLabel }}
+		</button>
+		<button
+			type="button"
+			:aria-pressed="modelValue === false"
+			:disabled="disabled"
+			class="flex h-8 cursor-pointer items-center rounded-[10px] border border-solid px-3 text-base font-medium leading-5 text-contrast transition-all active:scale-[0.97] focus-visible:outline-none focus-visible:ring-4 focus-visible:ring-brand-shadow disabled:cursor-not-allowed"
+			:class="
+				modelValue === false
+					? 'border-surface-5 bg-surface-4'
+					: 'border-transparent bg-transparent hover:bg-surface-4'
+			"
+			@click="emit('update:model-value', false)"
+		>
+			{{ offLabel }}
+		</button>
+	</div>
+</template>
diff --git a/apps/app-frontend/src/components/ui/settings/instances/game-settings/game-setting-editors.ts b/apps/app-frontend/src/components/ui/settings/instances/game-settings/game-setting-editors.ts
new file mode 100644
index 0000000000..d7da23253d
--- /dev/null
+++ b/apps/app-frontend/src/components/ui/settings/instances/game-settings/game-setting-editors.ts
@@ -0,0 +1,140 @@
+import { toRaw } from 'vue'
+
+import type {
+	EditableGameSetting,
+	GameOptionCanonicalValue,
+	GameSettingChange,
+	GameSettingsEditorState,
+} from '@/helpers/game-options'
+
+export function cloneGameSettingsState(state: GameSettingsEditorState): GameSettingsEditorState {
+	return structuredClone(toRaw(state))
+}
+
+export function canonicalValuesEqual(
+	left: GameOptionCanonicalValue | null | undefined,
+	right: GameOptionCanonicalValue | null | undefined,
+): boolean {
+	return JSON.stringify(left ?? null) === JSON.stringify(right ?? null)
+}
+
+export function gameSettingChanges(
+	base: GameSettingsEditorState | null,
+	draft: GameSettingsEditorState | null,
+	forcedValueOptionIds: ReadonlySet<string> = new Set(),
+): GameSettingChange[] {
+	if (!base || !draft) return []
+
+	const baseSettings = new Map(base.settings.map((setting) => [setting.option_id, setting]))
+	return draft.settings.flatMap((setting) => {
+		const previous = baseSettings.get(setting.option_id)
+		if (!previous) return []
+
+		const syncChanged = previous.sync_enabled !== setting.sync_enabled
+		const valueChanged = !canonicalValuesEqual(previous.canonical_value, setting.canonical_value)
+		const promoteLocalValue =
+			forcedValueOptionIds.has(setting.option_id) &&
+			previous.value_state !== 'canonical' &&
+			setting.canonical_value !== null &&
+			setting.canonical_value !== undefined
+		if (!syncChanged && !valueChanged && !promoteLocalValue) return []
+
+		return [
+			{
+				option_id: setting.option_id,
+				base_option_revision: previous.option_revision,
+				...(syncChanged ? { sync_enabled: setting.sync_enabled } : {}),
+				...(valueChanged || promoteLocalValue
+					? { canonical_value: setting.canonical_value ?? null }
+					: {}),
+			},
+		]
+	})
+}
+
+export function canonicalValueText(setting: EditableGameSetting): string {
+	const value = setting.canonical_value
+	if (!value) return ''
+
+	switch (value.type) {
+		case 'bool':
+			return value.value ? 'true' : 'false'
+		case 'integer':
+			return String(value.value)
+		case 'decimal':
+			return setting.editor.unit === 'percent'
+				? (Number(value.value) * 100).toFixed(0)
+				: value.value
+		case 'string_list':
+			return value.value.join(', ')
+		default:
+			return value.value
+	}
+}
+
+export function canonicalBooleanValue(setting: EditableGameSetting): boolean | undefined {
+	return setting.canonical_value?.type === 'bool' ? setting.canonical_value.value : undefined
+}
+
+export function canonicalValueFromInput(
+	setting: EditableGameSetting,
+	value: string | number | boolean | undefined,
+): GameOptionCanonicalValue | null {
+	if (value === undefined || value === '') return null
+
+	switch (setting.editor.type) {
+		case 'bool':
+			return { type: 'bool', value: Boolean(value) }
+		case 'integer': {
+			const parsed = Number(value)
+			return Number.isSafeInteger(parsed) ? { type: 'integer', value: parsed } : null
+		}
+		case 'decimal': {
+			const parsed = Number(value)
+			if (!Number.isFinite(parsed)) return null
+			return {
+				type: 'decimal',
+				value:
+					setting.editor.unit === 'percent'
+						? String(Number((parsed / 100).toFixed(8)))
+						: String(value),
+			}
+		}
+		case 'enum':
+			return { type: 'enum', value: String(value) }
+		case 'string_list':
+			return {
+				type: 'string_list',
+				value: String(value)
+					.split(',')
+					.map((item) => item.trim())
+					.filter(Boolean),
+			}
+		case 'key_binding':
+			return { type: 'key_binding', value: String(value) }
+		case 'external_raw':
+			return { type: 'external_raw', value: String(value) }
+		default:
+			return { type: 'text', value: String(value) }
+	}
+}
+
+export function settingSearchText(
+	setting: EditableGameSetting,
+	label: string,
+	description: string,
+): string {
+	return [label, description, setting.option_id, setting.raw_key]
+		.filter(Boolean)
+		.join(' ')
+		.toLocaleLowerCase()
+}
+
+export function settingCanBeEnabled(setting: EditableGameSetting): boolean {
+	return (
+		!setting.controlled &&
+		!setting.validation_error &&
+		!['mixed', 'unset', 'invalid'].includes(setting.value_state) &&
+		(setting.compatibility.total_participating === 0 || setting.compatibility.will_receive > 0)
+	)
+}
diff --git a/apps/app-frontend/src/components/ui/settings/instances/game-settings/game-setting-messages.ts b/apps/app-frontend/src/components/ui/settings/instances/game-settings/game-setting-messages.ts
new file mode 100644
index 0000000000..7887ad8d7e
--- /dev/null
+++ b/apps/app-frontend/src/components/ui/settings/instances/game-settings/game-setting-messages.ts
@@ -0,0 +1,920 @@
+import { defineMessages, type MessageDescriptor, type VIntlFormatters } from '@modrinth/ui'
+
+import type {
+	EditableGameSetting,
+	GameOptionsSourceCandidate,
+	GameOptionsSourceDisabledReason,
+	GameOptionValidationError,
+	GameSettingCategory,
+} from '@/helpers/game-options'
+
+type FormatMessage = VIntlFormatters['formatMessage']
+
+const settingMessages = defineMessages({
+	fovLabel: { id: 'app.settings.game-options.setting.fov.label', defaultMessage: 'Field of view' },
+	graphicsLabel: {
+		id: 'app.settings.game-options.setting.graphics.label',
+		defaultMessage: 'Graphics',
+	},
+	graphicsDescription: {
+		id: 'app.settings.game-options.setting.graphics.description',
+		defaultMessage: 'Controls visual quality and performance.',
+	},
+	ambientOcclusionLabel: {
+		id: 'app.settings.game-options.setting.ambient-occlusion.label',
+		defaultMessage: 'Smooth lighting',
+	},
+	renderDistanceLabel: {
+		id: 'app.settings.game-options.setting.render-distance.label',
+		defaultMessage: 'Render distance',
+	},
+	simulationDistanceLabel: {
+		id: 'app.settings.game-options.setting.simulation-distance.label',
+		defaultMessage: 'Simulation distance',
+	},
+	simulationDistanceDescription: {
+		id: 'app.settings.game-options.setting.simulation-distance.description',
+		defaultMessage: 'How far away entities update and blocks and fluids tick.',
+	},
+	guiScaleLabel: {
+		id: 'app.settings.game-options.setting.gui-scale.label',
+		defaultMessage: 'GUI scale',
+	},
+	guiScaleDescription: {
+		id: 'app.settings.game-options.setting.gui-scale.description',
+		defaultMessage: 'The size of the game interface and HUD.',
+	},
+	particlesLabel: {
+		id: 'app.settings.game-options.setting.particles.label',
+		defaultMessage: 'Particles',
+	},
+	cloudsLabel: { id: 'app.settings.game-options.setting.clouds.label', defaultMessage: 'Clouds' },
+	entityShadowsLabel: {
+		id: 'app.settings.game-options.setting.entity-shadows.label',
+		defaultMessage: 'Entity shadows',
+	},
+	viewBobbingLabel: {
+		id: 'app.settings.game-options.setting.view-bobbing.label',
+		defaultMessage: 'View bobbing',
+	},
+	viewBobbingDescription: {
+		id: 'app.settings.game-options.setting.view-bobbing.description',
+		defaultMessage: 'Add a bobbing motion to the camera while walking.',
+	},
+	vsyncLabel: { id: 'app.settings.game-options.setting.vsync.label', defaultMessage: 'VSync' },
+	vsyncDescription: {
+		id: 'app.settings.game-options.setting.vsync.description',
+		defaultMessage: 'Limit the frame rate to the display refresh rate to prevent screen tearing.',
+	},
+	fullscreenLabel: {
+		id: 'app.settings.game-options.setting.fullscreen.label',
+		defaultMessage: 'Fullscreen',
+	},
+	maxFramerateLabel: {
+		id: 'app.settings.game-options.setting.max-framerate.label',
+		defaultMessage: 'Maximum framerate',
+	},
+	mipmapLevelsLabel: {
+		id: 'app.settings.game-options.setting.mipmap-levels.label',
+		defaultMessage: 'Mipmap levels',
+	},
+	mipmapLevelsDescription: {
+		id: 'app.settings.game-options.setting.mipmap-levels.description',
+		defaultMessage: 'Texture smoothing at a distance.',
+	},
+	biomeBlendRadiusLabel: {
+		id: 'app.settings.game-options.setting.biome-blend-radius.label',
+		defaultMessage: 'Biome blend',
+	},
+	biomeBlendRadiusDescription: {
+		id: 'app.settings.game-options.setting.biome-blend-radius.description',
+		defaultMessage: 'The distance over which biome colors transition.',
+	},
+	languageLabel: {
+		id: 'app.settings.game-options.setting.language.label',
+		defaultMessage: 'Language',
+	},
+	masterVolumeLabel: {
+		id: 'app.settings.game-options.setting.master-volume.label',
+		defaultMessage: 'Master volume',
+	},
+	musicVolumeLabel: {
+		id: 'app.settings.game-options.setting.music-volume.label',
+		defaultMessage: 'Music',
+	},
+	musicToastLabel: {
+		id: 'app.settings.game-options.setting.music-toast.label',
+		defaultMessage: 'Music notification',
+	},
+	musicToastDescription: {
+		id: 'app.settings.game-options.setting.music-toast.description',
+		defaultMessage: 'Choose whether music titles appear in the pause menu and as toasts.',
+	},
+	recordVolumeLabel: {
+		id: 'app.settings.game-options.setting.record-volume.label',
+		defaultMessage: 'Jukebox/Note Blocks',
+	},
+	weatherVolumeLabel: {
+		id: 'app.settings.game-options.setting.weather-volume.label',
+		defaultMessage: 'Weather',
+	},
+	blocksVolumeLabel: {
+		id: 'app.settings.game-options.setting.blocks-volume.label',
+		defaultMessage: 'Blocks',
+	},
+	hostileVolumeLabel: {
+		id: 'app.settings.game-options.setting.hostile-volume.label',
+		defaultMessage: 'Hostile creatures',
+	},
+	neutralVolumeLabel: {
+		id: 'app.settings.game-options.setting.neutral-volume.label',
+		defaultMessage: 'Friendly creatures',
+	},
+	playersVolumeLabel: {
+		id: 'app.settings.game-options.setting.players-volume.label',
+		defaultMessage: 'Players',
+	},
+	ambientVolumeLabel: {
+		id: 'app.settings.game-options.setting.ambient-volume.label',
+		defaultMessage: 'Ambient/Environment',
+	},
+	voiceVolumeLabel: {
+		id: 'app.settings.game-options.setting.voice-volume.label',
+		defaultMessage: 'Voice and speech',
+	},
+	uiVolumeLabel: {
+		id: 'app.settings.game-options.setting.ui-volume.label',
+		defaultMessage: 'UI',
+	},
+	sensitivityLabel: {
+		id: 'app.settings.game-options.setting.sensitivity.label',
+		defaultMessage: 'Mouse sensitivity',
+	},
+	invertMouseLabel: {
+		id: 'app.settings.game-options.setting.invert-mouse.label',
+		defaultMessage: 'Invert mouse',
+	},
+	invertMouseDescription: {
+		id: 'app.settings.game-options.setting.invert-mouse.description',
+		defaultMessage: 'Invert vertical mouse movement.',
+	},
+	autoJumpLabel: {
+		id: 'app.settings.game-options.setting.auto-jump.label',
+		defaultMessage: 'Auto-jump',
+	},
+	autoJumpDescription: {
+		id: 'app.settings.game-options.setting.auto-jump.description',
+		defaultMessage: 'Automatically jump up one-block-high obstacles.',
+	},
+	toggleCrouchLabel: {
+		id: 'app.settings.game-options.setting.toggle-crouch.label',
+		defaultMessage: 'Toggle crouch',
+	},
+	toggleCrouchDescription: {
+		id: 'app.settings.game-options.setting.toggle-crouch.description',
+		defaultMessage: 'Press once to remain crouched.',
+	},
+	toggleSprintLabel: {
+		id: 'app.settings.game-options.setting.toggle-sprint.label',
+		defaultMessage: 'Toggle sprint',
+	},
+	toggleSprintDescription: {
+		id: 'app.settings.game-options.setting.toggle-sprint.description',
+		defaultMessage: 'Press once to remain sprinting.',
+	},
+	discreteMouseScrollLabel: {
+		id: 'app.settings.game-options.setting.discrete-mouse-scroll.label',
+		defaultMessage: 'Discrete scrolling',
+	},
+	discreteMouseScrollDescription: {
+		id: 'app.settings.game-options.setting.discrete-mouse-scroll.description',
+		defaultMessage: 'Treat each mouse-wheel input as a single scroll step.',
+	},
+	keyForwardLabel: {
+		id: 'app.settings.game-options.setting.key-forward.label',
+		defaultMessage: 'Move forward',
+	},
+	keyLeftLabel: {
+		id: 'app.settings.game-options.setting.key-left.label',
+		defaultMessage: 'Strafe left',
+	},
+	keyBackLabel: {
+		id: 'app.settings.game-options.setting.key-back.label',
+		defaultMessage: 'Move backward',
+	},
+	keyRightLabel: {
+		id: 'app.settings.game-options.setting.key-right.label',
+		defaultMessage: 'Strafe right',
+	},
+	keyJumpLabel: { id: 'app.settings.game-options.setting.key-jump.label', defaultMessage: 'Jump' },
+	keySneakLabel: {
+		id: 'app.settings.game-options.setting.key-sneak.label',
+		defaultMessage: 'Sneak',
+	},
+	keySprintLabel: {
+		id: 'app.settings.game-options.setting.key-sprint.label',
+		defaultMessage: 'Sprint',
+	},
+	keyInventoryLabel: {
+		id: 'app.settings.game-options.setting.key-inventory.label',
+		defaultMessage: 'Inventory',
+	},
+	keySwapOffhandLabel: {
+		id: 'app.settings.game-options.setting.key-swap-offhand.label',
+		defaultMessage: 'Swap offhand',
+	},
+	keyDropLabel: {
+		id: 'app.settings.game-options.setting.key-drop.label',
+		defaultMessage: 'Drop item',
+	},
+	keyUseLabel: {
+		id: 'app.settings.game-options.setting.key-use.label',
+		defaultMessage: 'Use item',
+	},
+	keyAttackLabel: {
+		id: 'app.settings.game-options.setting.key-attack.label',
+		defaultMessage: 'Attack',
+	},
+	keyPickItemLabel: {
+		id: 'app.settings.game-options.setting.key-pick-item.label',
+		defaultMessage: 'Pick block',
+	},
+	keyChatLabel: {
+		id: 'app.settings.game-options.setting.key-chat.label',
+		defaultMessage: 'Open chat',
+	},
+	keyPlayerListLabel: {
+		id: 'app.settings.game-options.setting.key-player-list.label',
+		defaultMessage: 'Player list',
+	},
+	keyCommandLabel: {
+		id: 'app.settings.game-options.setting.key-command.label',
+		defaultMessage: 'Command',
+	},
+	keyScreenshotLabel: {
+		id: 'app.settings.game-options.setting.key-screenshot.label',
+		defaultMessage: 'Screenshot',
+	},
+	keyPerspectiveLabel: {
+		id: 'app.settings.game-options.setting.key-perspective.label',
+		defaultMessage: 'Change perspective',
+	},
+	keyFullscreenLabel: {
+		id: 'app.settings.game-options.setting.key-fullscreen.label',
+		defaultMessage: 'Toggle fullscreen',
+	},
+	keyAdvancementsLabel: {
+		id: 'app.settings.game-options.setting.key-advancements.label',
+		defaultMessage: 'Advancements',
+	},
+	chatVisibilityLabel: {
+		id: 'app.settings.game-options.setting.chat-visibility.label',
+		defaultMessage: 'Chat visibility',
+	},
+	chatColorsLabel: {
+		id: 'app.settings.game-options.setting.chat-colors.label',
+		defaultMessage: 'Chat colors',
+	},
+	chatLinksLabel: {
+		id: 'app.settings.game-options.setting.chat-links.label',
+		defaultMessage: 'Web links',
+	},
+	chatLinksDescription: {
+		id: 'app.settings.game-options.setting.chat-links.description',
+		defaultMessage: 'Allow web links in chat to be opened.',
+	},
+	chatLinksPromptLabel: {
+		id: 'app.settings.game-options.setting.chat-links-prompt.label',
+		defaultMessage: 'Prompt on links',
+	},
+	chatLinksPromptDescription: {
+		id: 'app.settings.game-options.setting.chat-links-prompt.description',
+		defaultMessage: 'Ask before opening links from chat.',
+	},
+	chatOpacityLabel: {
+		id: 'app.settings.game-options.setting.chat-opacity.label',
+		defaultMessage: 'Chat opacity',
+	},
+	chatOpacityDescription: {
+		id: 'app.settings.game-options.setting.chat-opacity.description',
+		defaultMessage: 'The opacity of chat text.',
+	},
+	chatScaleLabel: {
+		id: 'app.settings.game-options.setting.chat-scale.label',
+		defaultMessage: 'Chat scale',
+	},
+	narratorLabel: {
+		id: 'app.settings.game-options.setting.narrator.label',
+		defaultMessage: 'Narrator',
+	},
+	narratorDescription: {
+		id: 'app.settings.game-options.setting.narrator.description',
+		defaultMessage: 'Choose what the narrator reads.',
+	},
+	subtitlesLabel: {
+		id: 'app.settings.game-options.setting.subtitles.label',
+		defaultMessage: 'Subtitles',
+	},
+	subtitlesDescription: {
+		id: 'app.settings.game-options.setting.subtitles.description',
+		defaultMessage: 'Show captions for sounds played in the game.',
+	},
+	highContrastLabel: {
+		id: 'app.settings.game-options.setting.high-contrast.label',
+		defaultMessage: 'High contrast',
+	},
+	highContrastDescription: {
+		id: 'app.settings.game-options.setting.high-contrast.description',
+		defaultMessage: 'Enhance the contrast of interface elements.',
+	},
+	darkSplashLabel: {
+		id: 'app.settings.game-options.setting.dark-splash.label',
+		defaultMessage: 'Monochrome logo',
+	},
+	darkSplashDescription: {
+		id: 'app.settings.game-options.setting.dark-splash.description',
+		defaultMessage: 'Change the Mojang Studios loading screen from red to black.',
+	},
+	notificationTimeLabel: {
+		id: 'app.settings.game-options.setting.notification-time.label',
+		defaultMessage: 'Notification time',
+	},
+	notificationTimeDescription: {
+		id: 'app.settings.game-options.setting.notification-time.description',
+		defaultMessage: 'How long toast notifications remain visible.',
+	},
+	mainHandLabel: {
+		id: 'app.settings.game-options.setting.main-hand.label',
+		defaultMessage: 'Main hand',
+	},
+	mainHandDescription: {
+		id: 'app.settings.game-options.setting.main-hand.description',
+		defaultMessage: 'Choose whether the main hand is left or right.',
+	},
+	capeLabel: { id: 'app.settings.game-options.setting.cape.label', defaultMessage: 'Cape' },
+	capeDescription: {
+		id: 'app.settings.game-options.setting.cape.description',
+		defaultMessage: "Show the player's cape, including its elytra texture.",
+	},
+	hatLabel: { id: 'app.settings.game-options.setting.hat.label', defaultMessage: 'Hat' },
+	hatDescription: {
+		id: 'app.settings.game-options.setting.hat.description',
+		defaultMessage: 'Show the hat skin layer.',
+	},
+	jacketLabel: { id: 'app.settings.game-options.setting.jacket.label', defaultMessage: 'Jacket' },
+	jacketDescription: {
+		id: 'app.settings.game-options.setting.jacket.description',
+		defaultMessage: 'Show the jacket skin layer.',
+	},
+	allowServerListingLabel: {
+		id: 'app.settings.game-options.setting.allow-server-listing.label',
+		defaultMessage: 'Server listings',
+	},
+	allowServerListingDescription: {
+		id: 'app.settings.game-options.setting.allow-server-listing.description',
+		defaultMessage: "Allow the player's name to appear in server listings.",
+	},
+	realmsNotificationsLabel: {
+		id: 'app.settings.game-options.setting.realms-notifications.label',
+		defaultMessage: 'Realms notifications',
+	},
+})
+
+const categoryMessages = defineMessages({
+	skinCustomizationLabel: {
+		id: 'app.settings.game-options.category.skin-customization.label',
+		defaultMessage: 'Skin customization',
+	},
+	skinCustomizationDescription: {
+		id: 'app.settings.game-options.category.skin-customization.description',
+		defaultMessage: 'Skin layers and main hand',
+	},
+	videoLabel: { id: 'app.settings.game-options.category.video.label', defaultMessage: 'Video' },
+	videoDescription: {
+		id: 'app.settings.game-options.category.video.description',
+		defaultMessage: 'Camera and display settings',
+	},
+	languageLabel: {
+		id: 'app.settings.game-options.category.language.label',
+		defaultMessage: 'Language',
+	},
+	languageDescription: {
+		id: 'app.settings.game-options.category.language.description',
+		defaultMessage: 'Game language',
+	},
+	musicAndSoundLabel: {
+		id: 'app.settings.game-options.category.music-and-sound.label',
+		defaultMessage: 'Music and sound',
+	},
+	musicAndSoundDescription: {
+		id: 'app.settings.game-options.category.music-and-sound.description',
+		defaultMessage: 'Volume and audio preferences',
+	},
+	controlsLabel: {
+		id: 'app.settings.game-options.category.controls.label',
+		defaultMessage: 'Controls',
+	},
+	controlsDescription: {
+		id: 'app.settings.game-options.category.controls.description',
+		defaultMessage: 'Mouse, movement, and key bindings',
+	},
+	chatLabel: { id: 'app.settings.game-options.category.chat.label', defaultMessage: 'Chat' },
+	chatDescription: {
+		id: 'app.settings.game-options.category.chat.description',
+		defaultMessage: 'Chat visibility and appearance',
+	},
+	accessibilityLabel: {
+		id: 'app.settings.game-options.category.accessibility.label',
+		defaultMessage: 'Accessibility',
+	},
+	accessibilityDescription: {
+		id: 'app.settings.game-options.category.accessibility.description',
+		defaultMessage: 'Accessibility preferences',
+	},
+	onlineLabel: { id: 'app.settings.game-options.category.online.label', defaultMessage: 'Online' },
+	onlineDescription: {
+		id: 'app.settings.game-options.category.online.description',
+		defaultMessage: 'Online and Realms preferences',
+	},
+	customLabel: {
+		id: 'app.settings.game-options.category.custom.label',
+		defaultMessage: 'Custom settings',
+	},
+	customDescription: {
+		id: 'app.settings.game-options.category.custom.description',
+		defaultMessage: 'Settings added by mods',
+	},
+})
+
+const choiceMessages = defineMessages({
+	fast: { id: 'app.settings.game-options.choice.fast', defaultMessage: 'Fast' },
+	fancy: { id: 'app.settings.game-options.choice.fancy', defaultMessage: 'Fancy' },
+	fabulous: { id: 'app.settings.game-options.choice.fabulous', defaultMessage: 'Fabulous' },
+	custom: { id: 'app.settings.game-options.choice.custom', defaultMessage: 'Custom' },
+	left: { id: 'app.settings.game-options.choice.left', defaultMessage: 'Left' },
+	right: { id: 'app.settings.game-options.choice.right', defaultMessage: 'Right' },
+	shown: { id: 'app.settings.game-options.choice.shown', defaultMessage: 'Shown' },
+	commandsOnly: {
+		id: 'app.settings.game-options.choice.commands-only',
+		defaultMessage: 'Commands only',
+	},
+	hidden: { id: 'app.settings.game-options.choice.hidden', defaultMessage: 'Hidden' },
+	all: { id: 'app.settings.game-options.choice.all', defaultMessage: 'All' },
+	decreased: { id: 'app.settings.game-options.choice.decreased', defaultMessage: 'Decreased' },
+	minimal: { id: 'app.settings.game-options.choice.minimal', defaultMessage: 'Minimal' },
+	off: { id: 'app.settings.game-options.choice.off', defaultMessage: 'Off' },
+	chat: { id: 'app.settings.game-options.choice.chat', defaultMessage: 'Chat' },
+	system: { id: 'app.settings.game-options.choice.system', defaultMessage: 'System' },
+	on: { id: 'app.settings.game-options.choice.on', defaultMessage: 'On' },
+	minimum: { id: 'app.settings.game-options.choice.minimum', defaultMessage: 'Minimum' },
+	maximum: { id: 'app.settings.game-options.choice.maximum', defaultMessage: 'Maximum' },
+	never: { id: 'app.settings.game-options.choice.never', defaultMessage: 'Never' },
+	pause: { id: 'app.settings.game-options.choice.pause', defaultMessage: 'Pause menu' },
+	pauseAndToast: {
+		id: 'app.settings.game-options.choice.pause-and-toast',
+		defaultMessage: 'Pause menu and toast',
+	},
+})
+
+export const presentationMessages = defineMessages({
+	customValuePlaceholder: {
+		id: 'app.settings.game-options.custom-value.placeholder',
+		defaultMessage: 'Enter a value',
+	},
+	validationLocalValueNeedsSaving: {
+		id: 'app.settings.game-options.validation.local-value-needs-saving',
+		defaultMessage: 'Save this value before turning sync back on.',
+	},
+	validationMissingValue: {
+		id: 'app.settings.game-options.validation.missing-value',
+		defaultMessage: 'Choose a value first.',
+	},
+	validationNoCompatibleInstances: {
+		id: 'app.settings.game-options.validation.no-compatible-instances',
+		defaultMessage: 'Some of your instances cannot use this setting',
+	},
+	validationInvalidValue: {
+		id: 'app.settings.game-options.validation.invalid-value',
+		defaultMessage: 'Choose a valid value.',
+	},
+	validationChangedSinceOpened: {
+		id: 'app.settings.game-options.validation.changed-since-opened',
+		defaultMessage: 'This setting changed elsewhere. Check it and try again.',
+	},
+	compatibilityNoParticipants: {
+		id: 'app.settings.game-options.compatibility.no-participants',
+		defaultMessage: 'Add an instance to start syncing',
+	},
+	compatibilityNone: {
+		id: 'app.settings.game-options.compatibility.none',
+		defaultMessage: 'Some of your instances cannot use this setting',
+	},
+	compatibilityAll: {
+		id: 'app.settings.game-options.compatibility.all',
+		defaultMessage: 'Syncs to {count, plural, one {# instance} other {# instances}}',
+	},
+	compatibilityAllDisabled: {
+		id: 'app.settings.game-options.compatibility.all-disabled',
+		defaultMessage: 'Sync is off',
+	},
+	compatibilitySome: {
+		id: 'app.settings.game-options.compatibility.some',
+		defaultMessage: 'Some of your instances cannot use this setting',
+	},
+	compatibilitySomeDisabled: {
+		id: 'app.settings.game-options.compatibility.some-disabled',
+		defaultMessage: 'Some of your instances cannot use this setting',
+	},
+	compatibilityTooltipNoParticipants: {
+		id: 'app.settings.game-options.compatibility.tooltip.no-participants',
+		defaultMessage: 'Add an instance to start syncing this setting.',
+	},
+	compatibilityTooltipAll: {
+		id: 'app.settings.game-options.compatibility.tooltip.all',
+		defaultMessage: 'All of your instances can use this setting.',
+	},
+	compatibilityTooltipLimited: {
+		id: 'app.settings.game-options.compatibility.tooltip.recipients',
+		defaultMessage: 'Some of your instances cannot use this setting',
+	},
+	compatibilityTooltipWaiting: {
+		id: 'app.settings.game-options.compatibility.tooltip.waiting',
+		defaultMessage:
+			'{count, plural, one {Launch this instance once before syncing this setting.} other {Launch these instances once before syncing this setting.}}',
+	},
+	bucketLauncherControlled: {
+		id: 'app.settings.game-options.compatibility.reason.launcher-controlled',
+		defaultMessage: 'This setting is managed by Modrinth’s launch settings.',
+	},
+	sourceInstallingOrUpdating: {
+		id: 'app.settings.game-options.source.disabled.installing-or-updating',
+		defaultMessage: 'Installing or updating',
+	},
+	sourceUnsupportedVersion: {
+		id: 'app.settings.game-options.source.disabled.unsupported-version',
+		defaultMessage: 'Unsupported Minecraft version',
+	},
+	sourceMissingOptionsFile: {
+		id: 'app.settings.game-options.source.disabled.missing-options-file',
+		defaultMessage: 'No options.txt file',
+	},
+	sourceNoSyncableSettings: {
+		id: 'app.settings.game-options.source.disabled.no-syncable-settings',
+		defaultMessage: 'No syncable settings found',
+	},
+	sourceUnreadableOptionsFile: {
+		id: 'app.settings.game-options.source.disabled.unreadable-options-file',
+		defaultMessage: 'options.txt could not be read',
+	},
+	sourceSettingsSummary: {
+		id: 'app.settings.game-options.source.settings-summary',
+		defaultMessage:
+			'{recognized, plural, one {# recognized setting} other {# recognized settings}}, {custom, plural, one {# custom setting} other {# custom settings}}',
+	},
+})
+
+const knownSettings: Record<string, { label: MessageDescriptor; description?: MessageDescriptor }> =
+	{
+		fov: { label: settingMessages.fovLabel },
+		graphics: {
+			label: settingMessages.graphicsLabel,
+			description: settingMessages.graphicsDescription,
+		},
+		ambient_occlusion: { label: settingMessages.ambientOcclusionLabel },
+		render_distance: { label: settingMessages.renderDistanceLabel },
+		simulation_distance: {
+			label: settingMessages.simulationDistanceLabel,
+			description: settingMessages.simulationDistanceDescription,
+		},
+		gui_scale: {
+			label: settingMessages.guiScaleLabel,
+			description: settingMessages.guiScaleDescription,
+		},
+		particles: { label: settingMessages.particlesLabel },
+		clouds: { label: settingMessages.cloudsLabel },
+		entity_shadows: { label: settingMessages.entityShadowsLabel },
+		view_bobbing: {
+			label: settingMessages.viewBobbingLabel,
+			description: settingMessages.viewBobbingDescription,
+		},
+		vsync: { label: settingMessages.vsyncLabel, description: settingMessages.vsyncDescription },
+		fullscreen: { label: settingMessages.fullscreenLabel },
+		max_framerate: { label: settingMessages.maxFramerateLabel },
+		mipmap_levels: {
+			label: settingMessages.mipmapLevelsLabel,
+			description: settingMessages.mipmapLevelsDescription,
+		},
+		biome_blend_radius: {
+			label: settingMessages.biomeBlendRadiusLabel,
+			description: settingMessages.biomeBlendRadiusDescription,
+		},
+		language: { label: settingMessages.languageLabel },
+		master_volume: { label: settingMessages.masterVolumeLabel },
+		music_volume: { label: settingMessages.musicVolumeLabel },
+		music_toast: {
+			label: settingMessages.musicToastLabel,
+			description: settingMessages.musicToastDescription,
+		},
+		record_volume: { label: settingMessages.recordVolumeLabel },
+		weather_volume: { label: settingMessages.weatherVolumeLabel },
+		blocks_volume: { label: settingMessages.blocksVolumeLabel },
+		hostile_volume: { label: settingMessages.hostileVolumeLabel },
+		neutral_volume: { label: settingMessages.neutralVolumeLabel },
+		players_volume: { label: settingMessages.playersVolumeLabel },
+		ambient_volume: { label: settingMessages.ambientVolumeLabel },
+		voice_volume: { label: settingMessages.voiceVolumeLabel },
+		ui_volume: { label: settingMessages.uiVolumeLabel },
+		sensitivity: { label: settingMessages.sensitivityLabel },
+		invert_mouse: {
+			label: settingMessages.invertMouseLabel,
+			description: settingMessages.invertMouseDescription,
+		},
+		auto_jump: {
+			label: settingMessages.autoJumpLabel,
+			description: settingMessages.autoJumpDescription,
+		},
+		toggle_crouch: {
+			label: settingMessages.toggleCrouchLabel,
+			description: settingMessages.toggleCrouchDescription,
+		},
+		toggle_sprint: {
+			label: settingMessages.toggleSprintLabel,
+			description: settingMessages.toggleSprintDescription,
+		},
+		discrete_mouse_scroll: {
+			label: settingMessages.discreteMouseScrollLabel,
+			description: settingMessages.discreteMouseScrollDescription,
+		},
+		'key.forward': { label: settingMessages.keyForwardLabel },
+		'key.left': { label: settingMessages.keyLeftLabel },
+		'key.back': { label: settingMessages.keyBackLabel },
+		'key.right': { label: settingMessages.keyRightLabel },
+		'key.jump': { label: settingMessages.keyJumpLabel },
+		'key.sneak': { label: settingMessages.keySneakLabel },
+		'key.sprint': { label: settingMessages.keySprintLabel },
+		'key.inventory': { label: settingMessages.keyInventoryLabel },
+		'key.swap_offhand': { label: settingMessages.keySwapOffhandLabel },
+		'key.drop': { label: settingMessages.keyDropLabel },
+		'key.use': { label: settingMessages.keyUseLabel },
+		'key.attack': { label: settingMessages.keyAttackLabel },
+		'key.pick_item': { label: settingMessages.keyPickItemLabel },
+		'key.chat': { label: settingMessages.keyChatLabel },
+		'key.player_list': { label: settingMessages.keyPlayerListLabel },
+		'key.command': { label: settingMessages.keyCommandLabel },
+		'key.screenshot': { label: settingMessages.keyScreenshotLabel },
+		'key.perspective': { label: settingMessages.keyPerspectiveLabel },
+		'key.fullscreen': { label: settingMessages.keyFullscreenLabel },
+		'key.advancements': { label: settingMessages.keyAdvancementsLabel },
+		chat_visibility: { label: settingMessages.chatVisibilityLabel },
+		chat_colors: { label: settingMessages.chatColorsLabel },
+		chat_links: {
+			label: settingMessages.chatLinksLabel,
+			description: settingMessages.chatLinksDescription,
+		},
+		chat_links_prompt: {
+			label: settingMessages.chatLinksPromptLabel,
+			description: settingMessages.chatLinksPromptDescription,
+		},
+		chat_opacity: {
+			label: settingMessages.chatOpacityLabel,
+			description: settingMessages.chatOpacityDescription,
+		},
+		chat_scale: { label: settingMessages.chatScaleLabel },
+		narrator: {
+			label: settingMessages.narratorLabel,
+			description: settingMessages.narratorDescription,
+		},
+		subtitles: {
+			label: settingMessages.subtitlesLabel,
+			description: settingMessages.subtitlesDescription,
+		},
+		high_contrast: {
+			label: settingMessages.highContrastLabel,
+			description: settingMessages.highContrastDescription,
+		},
+		dark_splash: {
+			label: settingMessages.darkSplashLabel,
+			description: settingMessages.darkSplashDescription,
+		},
+		notification_time: {
+			label: settingMessages.notificationTimeLabel,
+			description: settingMessages.notificationTimeDescription,
+		},
+		main_hand: {
+			label: settingMessages.mainHandLabel,
+			description: settingMessages.mainHandDescription,
+		},
+		cape: { label: settingMessages.capeLabel, description: settingMessages.capeDescription },
+		hat: { label: settingMessages.hatLabel, description: settingMessages.hatDescription },
+		jacket: { label: settingMessages.jacketLabel, description: settingMessages.jacketDescription },
+		allow_server_listing: {
+			label: settingMessages.allowServerListingLabel,
+			description: settingMessages.allowServerListingDescription,
+		},
+		realms_notifications: { label: settingMessages.realmsNotificationsLabel },
+	}
+
+const categories: Record<string, { label: MessageDescriptor; description: MessageDescriptor }> = {
+	skin_customization: {
+		label: categoryMessages.skinCustomizationLabel,
+		description: categoryMessages.skinCustomizationDescription,
+	},
+	video: { label: categoryMessages.videoLabel, description: categoryMessages.videoDescription },
+	video_settings: {
+		label: categoryMessages.videoLabel,
+		description: categoryMessages.videoDescription,
+	},
+	language: {
+		label: categoryMessages.languageLabel,
+		description: categoryMessages.languageDescription,
+	},
+	music_and_sound: {
+		label: categoryMessages.musicAndSoundLabel,
+		description: categoryMessages.musicAndSoundDescription,
+	},
+	controls: {
+		label: categoryMessages.controlsLabel,
+		description: categoryMessages.controlsDescription,
+	},
+	chat: { label: categoryMessages.chatLabel, description: categoryMessages.chatDescription },
+	chat_settings: {
+		label: categoryMessages.chatLabel,
+		description: categoryMessages.chatDescription,
+	},
+	accessibility: {
+		label: categoryMessages.accessibilityLabel,
+		description: categoryMessages.accessibilityDescription,
+	},
+	online: { label: categoryMessages.onlineLabel, description: categoryMessages.onlineDescription },
+	custom: { label: categoryMessages.customLabel, description: categoryMessages.customDescription },
+	custom_settings: {
+		label: categoryMessages.customLabel,
+		description: categoryMessages.customDescription,
+	},
+}
+
+const choices: Record<string, MessageDescriptor> = {
+	'graphics:fast': choiceMessages.fast,
+	'graphics:fancy': choiceMessages.fancy,
+	'graphics:fabulous': choiceMessages.fabulous,
+	'graphics:custom': choiceMessages.custom,
+	'main_hand:left': choiceMessages.left,
+	'main_hand:right': choiceMessages.right,
+	'chat_visibility:0': choiceMessages.shown,
+	'chat_visibility:1': choiceMessages.commandsOnly,
+	'chat_visibility:2': choiceMessages.hidden,
+	'particles:0': choiceMessages.all,
+	'particles:1': choiceMessages.decreased,
+	'particles:2': choiceMessages.minimal,
+	'narrator:0': choiceMessages.off,
+	'narrator:1': choiceMessages.all,
+	'narrator:2': choiceMessages.chat,
+	'narrator:3': choiceMessages.system,
+	'clouds:false': choiceMessages.off,
+	'clouds:fast': choiceMessages.fast,
+	'clouds:true': choiceMessages.fancy,
+	'ambient_occlusion:off': choiceMessages.off,
+	'ambient_occlusion:on': choiceMessages.on,
+	'ambient_occlusion:minimum': choiceMessages.minimum,
+	'ambient_occlusion:maximum': choiceMessages.maximum,
+	'music_toast:never': choiceMessages.never,
+	'music_toast:pause': choiceMessages.pause,
+	'music_toast:pause_and_toast': choiceMessages.pauseAndToast,
+}
+
+const validationMessages: Record<GameOptionValidationError, MessageDescriptor> = {
+	local_value_needs_saving: presentationMessages.validationLocalValueNeedsSaving,
+	missing_value: presentationMessages.validationMissingValue,
+	no_compatible_instances: presentationMessages.validationNoCompatibleInstances,
+	invalid_value: presentationMessages.validationInvalidValue,
+	changed_since_opened: presentationMessages.validationChangedSinceOpened,
+}
+
+const sourceDisabledMessages: Record<GameOptionsSourceDisabledReason, MessageDescriptor> = {
+	installing_or_updating: presentationMessages.sourceInstallingOrUpdating,
+	unsupported_version: presentationMessages.sourceUnsupportedVersion,
+	missing_options_file: presentationMessages.sourceMissingOptionsFile,
+	no_syncable_settings: presentationMessages.sourceNoSyncableSettings,
+	unreadable_options_file: presentationMessages.sourceUnreadableOptionsFile,
+}
+
+export function formatGameSettingLabel(
+	formatMessage: FormatMessage,
+	setting: EditableGameSetting,
+): string {
+	if (setting.kind === 'external') return setting.raw_key ?? setting.option_id
+	const definition = knownSettings[setting.option_id]
+	return definition ? formatMessage(definition.label) : setting.option_id
+}
+
+export function formatGameSettingDescription(
+	formatMessage: FormatMessage,
+	setting: EditableGameSetting,
+): string {
+	if (setting.kind === 'external') return ''
+	const definition = knownSettings[setting.option_id]
+	return definition?.description ? formatMessage(definition.description) : ''
+}
+
+export function gameSettingCategoryMessage(category: GameSettingCategory): MessageDescriptor {
+	return (
+		categories[category.id]?.label ?? {
+			id: `app.settings.game-options.category.${category.id}.label`,
+			defaultMessage: category.id,
+		}
+	)
+}
+
+export function formatGameSettingCategory(
+	formatMessage: FormatMessage,
+	category: GameSettingCategory,
+): string {
+	return formatMessage(gameSettingCategoryMessage(category))
+}
+
+export function formatGameSettingChoice(
+	formatMessage: FormatMessage,
+	optionId: string,
+	value: string,
+): string {
+	const message = choices[`${optionId}:${value}`]
+	return message ? formatMessage(message) : value
+}
+
+export function formatGameSettingValidation(
+	formatMessage: FormatMessage,
+	error: GameOptionValidationError | null | undefined,
+): string | null {
+	return error ? formatMessage(validationMessages[error]) : null
+}
+
+export function formatCompatibilitySubtitle(
+	formatMessage: FormatMessage,
+	setting: EditableGameSetting,
+): string {
+	const { total_participating: total, will_receive: recipients } = setting.compatibility
+	if (total === 0) return formatMessage(presentationMessages.compatibilityNoParticipants)
+	if (recipients === 0) return formatMessage(presentationMessages.compatibilityNone)
+	if (recipients === total) {
+		return formatMessage(
+			setting.sync_enabled
+				? presentationMessages.compatibilityAll
+				: presentationMessages.compatibilityAllDisabled,
+			{ count: total },
+		)
+	}
+	return formatMessage(
+		setting.sync_enabled
+			? presentationMessages.compatibilitySome
+			: presentationMessages.compatibilitySomeDisabled,
+		{ recipients, total },
+	)
+}
+
+export function formatCompatibilityTooltip(
+	formatMessage: FormatMessage,
+	setting: EditableGameSetting,
+): string {
+	const summary = setting.compatibility
+	if (summary.total_participating === 0) {
+		return formatMessage(presentationMessages.compatibilityTooltipNoParticipants)
+	}
+	if (summary.left_local > 0) {
+		return formatMessage(presentationMessages.compatibilityTooltipLimited)
+	}
+	const waiting = summary.buckets
+		.filter(
+			(bucket) => bucket.status === 'waiting_for_file' || bucket.status === 'waiting_for_base',
+		)
+		.reduce((count, bucket) => count + bucket.instance_count, 0)
+	if (waiting > 0) {
+		return formatMessage(presentationMessages.compatibilityTooltipWaiting, { count: waiting })
+	}
+	return formatMessage(presentationMessages.compatibilityTooltipAll)
+}
+
+export function shouldShowCompatibilityIndicator(setting: EditableGameSetting): boolean {
+	return (
+		setting.compatibility.left_local > 0 ||
+		setting.compatibility.buckets.some(
+			(bucket) => bucket.status === 'waiting_for_file' || bucket.status === 'waiting_for_base',
+		)
+	)
+}
+
+export function formatSourceDisabledReason(
+	formatMessage: FormatMessage,
+	reason: GameOptionsSourceDisabledReason | null | undefined,
+): string | null {
+	return reason ? formatMessage(sourceDisabledMessages[reason]) : null
+}
+
+export function formatSourceSettingsSummary(
+	formatMessage: FormatMessage,
+	source: Pick<GameOptionsSourceCandidate, 'recognized_setting_count' | 'custom_setting_count'>,
+): string {
+	return formatMessage(presentationMessages.sourceSettingsSummary, {
+		recognized: source.recognized_setting_count,
+		custom: source.custom_setting_count,
+	})
+}
diff --git a/apps/app-frontend/src/helpers/game-options.ts b/apps/app-frontend/src/helpers/game-options.ts
new file mode 100644
index 0000000000..2ddefffa5e
--- /dev/null
+++ b/apps/app-frontend/src/helpers/game-options.ts
@@ -0,0 +1,201 @@
+import { invoke } from '@tauri-apps/api/core'
+
+export type GameOptionCanonicalValue =
+	| { type: 'bool'; value: boolean }
+	| { type: 'integer'; value: number }
+	| { type: 'decimal'; value: string }
+	| { type: 'enum'; value: string }
+	| { type: 'text'; value: string }
+	| { type: 'string_list'; value: string[] }
+	| { type: 'key_binding'; value: string }
+	| { type: 'external_raw'; value: string }
+
+export type GameOptionValueState = 'canonical' | 'uniform_local' | 'mixed' | 'unset' | 'invalid'
+
+export type GameOptionCompatibilityStatus =
+	| 'ready'
+	| 'deferred'
+	| 'waiting_for_file'
+	| 'waiting_for_base'
+	| 'not_available'
+	| 'unsupported_value'
+	| 'unmappable'
+	| 'catalog_uncovered'
+	| 'controlled'
+	| 'degraded'
+
+export type GameOptionMappingKind = 'direct' | 'legacy' | 'migrated' | 'lossless' | 'lossy'
+
+export type GameOptionCompatibilityReason =
+	| 'launcher_controlled'
+	| 'catalog_uncovered'
+	| 'inspection_failed'
+	| 'waiting_for_options_file'
+	| 'unsupported_value'
+	| 'migrates_on_write'
+	| 'waiting_for_compatible_base'
+	| 'missing_setting'
+
+export type GameOptionCompatibilityBucket = {
+	instance_count: number
+	write_keys: string[]
+	eventual_keys: string[]
+	game_versions: string[]
+	status: GameOptionCompatibilityStatus
+	mapping?: GameOptionMappingKind | null
+	reason?: GameOptionCompatibilityReason | null
+}
+
+export type GameOptionCompatibilitySummary = {
+	total_participating: number
+	will_receive: number
+	write_now: number
+	left_local: number
+	buckets: GameOptionCompatibilityBucket[]
+}
+
+export type GameOptionEditorChoice = {
+	value: string
+}
+
+export type GameOptionEditor = {
+	type:
+		| 'bool'
+		| 'integer'
+		| 'decimal'
+		| 'enum'
+		| 'text'
+		| 'string_list'
+		| 'key_binding'
+		| 'external_raw'
+	min?: number | null
+	max?: number | null
+	step?: number | null
+	unit?: string | null
+	choices?: GameOptionEditorChoice[]
+}
+
+export type GameSettingCategory = {
+	id: string
+	is_custom?: boolean
+}
+
+export type GameOptionValidationError =
+	| 'local_value_needs_saving'
+	| 'missing_value'
+	| 'no_compatible_instances'
+	| 'invalid_value'
+	| 'changed_since_opened'
+
+export type EditableGameSetting = {
+	option_id: string
+	category_id: string
+	kind: 'vanilla' | 'external'
+	raw_key?: string | null
+	sync_enabled: boolean
+	canonical_value?: GameOptionCanonicalValue | null
+	value_state: GameOptionValueState
+	option_revision: number
+	editor: GameOptionEditor
+	compatibility: GameOptionCompatibilitySummary
+	validation_error?: GameOptionValidationError | null
+	controlled?: boolean
+}
+
+export type GameSettingsEditorState = {
+	summary_revision: string
+	canonical_revision: number
+	catalog_revision: number
+	total_participating: number
+	categories: GameSettingCategory[]
+	settings: EditableGameSetting[]
+}
+
+export type GameSettingChange = {
+	option_id: string
+	base_option_revision: number
+	sync_enabled?: boolean
+	canonical_value?: GameOptionCanonicalValue | null
+}
+
+export type UpdateGameSettingsRequest = {
+	expected_summary_revision: string
+	expected_canonical_revision: number
+	expected_catalog_revision: number
+	changes: GameSettingChange[]
+}
+
+export type GameOptionsSourceCandidate = {
+	source_id: string
+	instance_id: string
+	name: string
+	icon_path?: string | null
+	game_version?: string | null
+	eligible: boolean
+	disabled_reason?: GameOptionsSourceDisabledReason | null
+	recognized_setting_count: number
+	custom_setting_count: number
+}
+
+export type GameOptionsSourceDisabledReason =
+	| 'installing_or_updating'
+	| 'unsupported_version'
+	| 'missing_options_file'
+	| 'no_syncable_settings'
+	| 'unreadable_options_file'
+
+export type SaveGameSettingsResult = {
+	state?: GameSettingsEditorState
+	applied: number
+	migrated: number
+	deferred: number
+	unsupported: number
+	failed: number
+	conflicts?: string[]
+}
+
+export async function list_game_options_sync_sources(): Promise<GameOptionsSourceCandidate[]> {
+	return await invoke('plugin:instance|instance_list_game_options_sync_sources')
+}
+
+export async function get_synced_game_options_config(): Promise<GameSettingsEditorState> {
+	return await invoke('plugin:instance|instance_get_synced_game_options_config')
+}
+
+export async function preview_synced_game_option_changes(
+	request: UpdateGameSettingsRequest,
+): Promise<GameSettingsEditorState> {
+	return await invoke('plugin:instance|instance_preview_synced_game_option_changes', { request })
+}
+
+export async function save_synced_game_option_changes(
+	request: UpdateGameSettingsRequest,
+): Promise<SaveGameSettingsResult> {
+	return await invoke('plugin:instance|instance_save_synced_game_option_changes', { request })
+}
+
+export async function get_local_game_options_config(
+	instanceId: string,
+): Promise<GameSettingsEditorState> {
+	return await invoke('plugin:instance|instance_get_local_game_options_config', { instanceId })
+}
+
+export async function preview_local_game_option_changes(
+	instanceId: string,
+	request: UpdateGameSettingsRequest,
+): Promise<GameSettingsEditorState> {
+	return await invoke('plugin:instance|instance_preview_local_game_option_changes', {
+		instanceId,
+		request,
+	})
+}
+
+export async function save_local_game_option_changes(
+	instanceId: string,
+	request: UpdateGameSettingsRequest,
+): Promise<SaveGameSettingsResult> {
+	return await invoke('plugin:instance|instance_save_local_game_option_changes', {
+		instanceId,
+		request,
+	})
+}
diff --git a/apps/app-frontend/src/helpers/instance.ts b/apps/app-frontend/src/helpers/instance.ts
index 49297e1699..417b010c71 100644
--- a/apps/app-frontend/src/helpers/instance.ts
+++ b/apps/app-frontend/src/helpers/instance.ts
@@ -289,6 +289,7 @@ export async function set_synced_option(
 }
 
 export type SyncedOption =
+	| 'game_options'
 	| 'command_history'
 	| 'multiplayer_servers'
 	| 'creative_hotbars'
@@ -347,6 +348,8 @@ export async function set_global_synced_option(
 	})
 }
 
+export * from './game-options'
+
 export async function get_command_history(): Promise<string> {
 	return await invoke('plugin:instance|instance_get_command_history')
 }
diff --git a/apps/app-frontend/src/helpers/types.d.ts b/apps/app-frontend/src/helpers/types.d.ts
index 1a4b78908b..4972790ebb 100644
--- a/apps/app-frontend/src/helpers/types.d.ts
+++ b/apps/app-frontend/src/helpers/types.d.ts
@@ -17,6 +17,7 @@ export type GameInstance = {
 
 	group_ids: string[]
 	synced_options: {
+		game_options: boolean
 		command_history: boolean
 		multiplayer_servers: boolean
 		creative_hotbars: boolean
diff --git a/apps/app-frontend/src/locales/en-US/index.json b/apps/app-frontend/src/locales/en-US/index.json
index ae7fcb2314..66ad06bc1c 100644
--- a/apps/app-frontend/src/locales/en-US/index.json
+++ b/apps/app-frontend/src/locales/en-US/index.json
@@ -1619,6 +1619,630 @@
   "app.settings.downloading": {
     "message": "Downloading v{version}"
   },
+  "app.settings.game-options.category.accessibility.description": {
+    "message": "Accessibility preferences"
+  },
+  "app.settings.game-options.category.accessibility.label": {
+    "message": "Accessibility"
+  },
+  "app.settings.game-options.category.chat.description": {
+    "message": "Chat visibility and appearance"
+  },
+  "app.settings.game-options.category.chat.label": {
+    "message": "Chat"
+  },
+  "app.settings.game-options.category.controls.description": {
+    "message": "Mouse, movement, and key bindings"
+  },
+  "app.settings.game-options.category.controls.label": {
+    "message": "Controls"
+  },
+  "app.settings.game-options.category.custom.description": {
+    "message": "Settings added by mods"
+  },
+  "app.settings.game-options.category.custom.label": {
+    "message": "Custom settings"
+  },
+  "app.settings.game-options.category.language.description": {
+    "message": "Game language"
+  },
+  "app.settings.game-options.category.language.label": {
+    "message": "Language"
+  },
+  "app.settings.game-options.category.music-and-sound.description": {
+    "message": "Volume and audio preferences"
+  },
+  "app.settings.game-options.category.music-and-sound.label": {
+    "message": "Music and sound"
+  },
+  "app.settings.game-options.category.online.description": {
+    "message": "Online and Realms preferences"
+  },
+  "app.settings.game-options.category.online.label": {
+    "message": "Online"
+  },
+  "app.settings.game-options.category.skin-customization.description": {
+    "message": "Skin layers and main hand"
+  },
+  "app.settings.game-options.category.skin-customization.label": {
+    "message": "Skin customization"
+  },
+  "app.settings.game-options.category.video.description": {
+    "message": "Camera and display settings"
+  },
+  "app.settings.game-options.category.video.label": {
+    "message": "Video"
+  },
+  "app.settings.game-options.choice.all": {
+    "message": "All"
+  },
+  "app.settings.game-options.choice.chat": {
+    "message": "Chat"
+  },
+  "app.settings.game-options.choice.commands-only": {
+    "message": "Commands only"
+  },
+  "app.settings.game-options.choice.custom": {
+    "message": "Custom"
+  },
+  "app.settings.game-options.choice.decreased": {
+    "message": "Decreased"
+  },
+  "app.settings.game-options.choice.fabulous": {
+    "message": "Fabulous"
+  },
+  "app.settings.game-options.choice.fancy": {
+    "message": "Fancy"
+  },
+  "app.settings.game-options.choice.fast": {
+    "message": "Fast"
+  },
+  "app.settings.game-options.choice.hidden": {
+    "message": "Hidden"
+  },
+  "app.settings.game-options.choice.left": {
+    "message": "Left"
+  },
+  "app.settings.game-options.choice.maximum": {
+    "message": "Maximum"
+  },
+  "app.settings.game-options.choice.minimal": {
+    "message": "Minimal"
+  },
+  "app.settings.game-options.choice.minimum": {
+    "message": "Minimum"
+  },
+  "app.settings.game-options.choice.never": {
+    "message": "Never"
+  },
+  "app.settings.game-options.choice.off": {
+    "message": "Off"
+  },
+  "app.settings.game-options.choice.on": {
+    "message": "On"
+  },
+  "app.settings.game-options.choice.pause": {
+    "message": "Pause menu"
+  },
+  "app.settings.game-options.choice.pause-and-toast": {
+    "message": "Pause menu and toast"
+  },
+  "app.settings.game-options.choice.right": {
+    "message": "Right"
+  },
+  "app.settings.game-options.choice.shown": {
+    "message": "Shown"
+  },
+  "app.settings.game-options.choice.system": {
+    "message": "System"
+  },
+  "app.settings.game-options.compatibility.all": {
+    "message": "Syncs to {count, plural, one {# instance} other {# instances}}"
+  },
+  "app.settings.game-options.compatibility.all-disabled": {
+    "message": "Sync is off"
+  },
+  "app.settings.game-options.compatibility.no-participants": {
+    "message": "Add an instance to start syncing"
+  },
+  "app.settings.game-options.compatibility.none": {
+    "message": "Some of your instances cannot use this setting"
+  },
+  "app.settings.game-options.compatibility.reason.launcher-controlled": {
+    "message": "This setting is managed by Modrinth’s launch settings."
+  },
+  "app.settings.game-options.compatibility.some": {
+    "message": "Some of your instances cannot use this setting"
+  },
+  "app.settings.game-options.compatibility.some-disabled": {
+    "message": "Some of your instances cannot use this setting"
+  },
+  "app.settings.game-options.compatibility.tooltip.all": {
+    "message": "All of your instances can use this setting."
+  },
+  "app.settings.game-options.compatibility.tooltip.no-participants": {
+    "message": "Add an instance to start syncing this setting."
+  },
+  "app.settings.game-options.compatibility.tooltip.recipients": {
+    "message": "Some of your instances cannot use this setting"
+  },
+  "app.settings.game-options.compatibility.tooltip.waiting": {
+    "message": "{count, plural, one {Launch this instance once before syncing this setting.} other {Launch these instances once before syncing this setting.}}"
+  },
+  "app.settings.game-options.custom-value.placeholder": {
+    "message": "Enter a value"
+  },
+  "app.settings.game-options.keybind.assigned-status": {
+    "message": "{setting} is now bound to {binding}."
+  },
+  "app.settings.game-options.keybind.cancelled-status": {
+    "message": "Key binding change cancelled."
+  },
+  "app.settings.game-options.keybind.change": {
+    "message": "{setting}: {binding}. Activate to change the binding."
+  },
+  "app.settings.game-options.keybind.choose": {
+    "message": "Choose a key"
+  },
+  "app.settings.game-options.keybind.conflict": {
+    "message": "This key is also used for {settings}."
+  },
+  "app.settings.game-options.keybind.key.arrow-down": {
+    "message": "Down Arrow"
+  },
+  "app.settings.game-options.keybind.key.arrow-left": {
+    "message": "Left Arrow"
+  },
+  "app.settings.game-options.keybind.key.arrow-right": {
+    "message": "Right Arrow"
+  },
+  "app.settings.game-options.keybind.key.arrow-up": {
+    "message": "Up Arrow"
+  },
+  "app.settings.game-options.keybind.key.backspace": {
+    "message": "Backspace"
+  },
+  "app.settings.game-options.keybind.key.caps-lock": {
+    "message": "Caps Lock"
+  },
+  "app.settings.game-options.keybind.key.delete": {
+    "message": "Delete"
+  },
+  "app.settings.game-options.keybind.key.end": {
+    "message": "End"
+  },
+  "app.settings.game-options.keybind.key.enter": {
+    "message": "Enter"
+  },
+  "app.settings.game-options.keybind.key.escape": {
+    "message": "Escape"
+  },
+  "app.settings.game-options.keybind.key.home": {
+    "message": "Home"
+  },
+  "app.settings.game-options.keybind.key.insert": {
+    "message": "Insert"
+  },
+  "app.settings.game-options.keybind.key.keypad-key": {
+    "message": "Numpad {key}"
+  },
+  "app.settings.game-options.keybind.key.left-alt": {
+    "message": "Left Alt"
+  },
+  "app.settings.game-options.keybind.key.left-command": {
+    "message": "Left Command"
+  },
+  "app.settings.game-options.keybind.key.left-control": {
+    "message": "Left Ctrl"
+  },
+  "app.settings.game-options.keybind.key.left-shift": {
+    "message": "Left Shift"
+  },
+  "app.settings.game-options.keybind.key.left-super": {
+    "message": "Left Super"
+  },
+  "app.settings.game-options.keybind.key.menu": {
+    "message": "Menu"
+  },
+  "app.settings.game-options.keybind.key.num-lock": {
+    "message": "Num Lock"
+  },
+  "app.settings.game-options.keybind.key.page-down": {
+    "message": "Page Down"
+  },
+  "app.settings.game-options.keybind.key.page-up": {
+    "message": "Page Up"
+  },
+  "app.settings.game-options.keybind.key.pause": {
+    "message": "Pause"
+  },
+  "app.settings.game-options.keybind.key.print-screen": {
+    "message": "Print Screen"
+  },
+  "app.settings.game-options.keybind.key.right-alt": {
+    "message": "Right Alt"
+  },
+  "app.settings.game-options.keybind.key.right-command": {
+    "message": "Right Command"
+  },
+  "app.settings.game-options.keybind.key.right-control": {
+    "message": "Right Ctrl"
+  },
+  "app.settings.game-options.keybind.key.right-shift": {
+    "message": "Right Shift"
+  },
+  "app.settings.game-options.keybind.key.right-super": {
+    "message": "Right Super"
+  },
+  "app.settings.game-options.keybind.key.scroll-lock": {
+    "message": "Scroll Lock"
+  },
+  "app.settings.game-options.keybind.key.space": {
+    "message": "Space"
+  },
+  "app.settings.game-options.keybind.key.tab": {
+    "message": "Tab"
+  },
+  "app.settings.game-options.keybind.key.unbound": {
+    "message": "Unbound"
+  },
+  "app.settings.game-options.keybind.key.unknown": {
+    "message": "Unknown key"
+  },
+  "app.settings.game-options.keybind.listen": {
+    "message": "Press a key…"
+  },
+  "app.settings.game-options.keybind.listening-status": {
+    "message": "Listening for a key or mouse button. Press Escape to clear this binding."
+  },
+  "app.settings.game-options.keybind.mixed": {
+    "message": "Different across instances"
+  },
+  "app.settings.game-options.keybind.modifier.alt": {
+    "message": "Alt"
+  },
+  "app.settings.game-options.keybind.modifier.command": {
+    "message": "Command"
+  },
+  "app.settings.game-options.keybind.modifier.control": {
+    "message": "Ctrl"
+  },
+  "app.settings.game-options.keybind.modifier.shift": {
+    "message": "Shift"
+  },
+  "app.settings.game-options.keybind.modifier.super": {
+    "message": "Super"
+  },
+  "app.settings.game-options.keybind.mouse.button": {
+    "message": "Mouse {button}"
+  },
+  "app.settings.game-options.keybind.mouse.left": {
+    "message": "Left Mouse"
+  },
+  "app.settings.game-options.keybind.mouse.middle": {
+    "message": "Middle Mouse"
+  },
+  "app.settings.game-options.keybind.mouse.right": {
+    "message": "Right Mouse"
+  },
+  "app.settings.game-options.keybind.scancode": {
+    "message": "Scancode {code}"
+  },
+  "app.settings.game-options.keybind.unsupported-status": {
+    "message": "That input cannot be used by Minecraft. Press another key."
+  },
+  "app.settings.game-options.setting.allow-server-listing.description": {
+    "message": "Allow the player's name to appear in server listings."
+  },
+  "app.settings.game-options.setting.allow-server-listing.label": {
+    "message": "Server listings"
+  },
+  "app.settings.game-options.setting.ambient-occlusion.label": {
+    "message": "Smooth lighting"
+  },
+  "app.settings.game-options.setting.auto-jump.description": {
+    "message": "Automatically jump up one-block-high obstacles."
+  },
+  "app.settings.game-options.setting.auto-jump.label": {
+    "message": "Auto-jump"
+  },
+  "app.settings.game-options.setting.biome-blend-radius.description": {
+    "message": "The distance over which biome colors transition."
+  },
+  "app.settings.game-options.setting.biome-blend-radius.label": {
+    "message": "Biome blend"
+  },
+  "app.settings.game-options.setting.blocks-volume.label": {
+    "message": "Blocks"
+  },
+  "app.settings.game-options.setting.cape.description": {
+    "message": "Show the player's cape, including its elytra texture."
+  },
+  "app.settings.game-options.setting.cape.label": {
+    "message": "Cape"
+  },
+  "app.settings.game-options.setting.chat-colors.label": {
+    "message": "Chat colors"
+  },
+  "app.settings.game-options.setting.chat-links-prompt.description": {
+    "message": "Ask before opening links from chat."
+  },
+  "app.settings.game-options.setting.chat-links-prompt.label": {
+    "message": "Prompt on links"
+  },
+  "app.settings.game-options.setting.chat-links.description": {
+    "message": "Allow web links in chat to be opened."
+  },
+  "app.settings.game-options.setting.chat-links.label": {
+    "message": "Web links"
+  },
+  "app.settings.game-options.setting.chat-opacity.description": {
+    "message": "The opacity of chat text."
+  },
+  "app.settings.game-options.setting.chat-opacity.label": {
+    "message": "Chat opacity"
+  },
+  "app.settings.game-options.setting.chat-scale.label": {
+    "message": "Chat scale"
+  },
+  "app.settings.game-options.setting.chat-visibility.label": {
+    "message": "Chat visibility"
+  },
+  "app.settings.game-options.setting.clouds.label": {
+    "message": "Clouds"
+  },
+  "app.settings.game-options.setting.dark-splash.description": {
+    "message": "Change the Mojang Studios loading screen from red to black."
+  },
+  "app.settings.game-options.setting.dark-splash.label": {
+    "message": "Monochrome logo"
+  },
+  "app.settings.game-options.setting.discrete-mouse-scroll.description": {
+    "message": "Treat each mouse-wheel input as a single scroll step."
+  },
+  "app.settings.game-options.setting.discrete-mouse-scroll.label": {
+    "message": "Discrete scrolling"
+  },
+  "app.settings.game-options.setting.entity-shadows.label": {
+    "message": "Entity shadows"
+  },
+  "app.settings.game-options.setting.fov.label": {
+    "message": "Field of view"
+  },
+  "app.settings.game-options.setting.fullscreen.label": {
+    "message": "Fullscreen"
+  },
+  "app.settings.game-options.setting.graphics.description": {
+    "message": "Controls visual quality and performance."
+  },
+  "app.settings.game-options.setting.graphics.label": {
+    "message": "Graphics"
+  },
+  "app.settings.game-options.setting.gui-scale.description": {
+    "message": "The size of the game interface and HUD."
+  },
+  "app.settings.game-options.setting.gui-scale.label": {
+    "message": "GUI scale"
+  },
+  "app.settings.game-options.setting.hat.description": {
+    "message": "Show the hat skin layer."
+  },
+  "app.settings.game-options.setting.hat.label": {
+    "message": "Hat"
+  },
+  "app.settings.game-options.setting.high-contrast.description": {
+    "message": "Enhance the contrast of interface elements."
+  },
+  "app.settings.game-options.setting.high-contrast.label": {
+    "message": "High contrast"
+  },
+  "app.settings.game-options.setting.hostile-volume.label": {
+    "message": "Hostile creatures"
+  },
+  "app.settings.game-options.setting.invert-mouse.description": {
+    "message": "Invert vertical mouse movement."
+  },
+  "app.settings.game-options.setting.invert-mouse.label": {
+    "message": "Invert mouse"
+  },
+  "app.settings.game-options.setting.jacket.description": {
+    "message": "Show the jacket skin layer."
+  },
+  "app.settings.game-options.setting.jacket.label": {
+    "message": "Jacket"
+  },
+  "app.settings.game-options.setting.key-advancements.label": {
+    "message": "Advancements"
+  },
+  "app.settings.game-options.setting.key-attack.label": {
+    "message": "Attack"
+  },
+  "app.settings.game-options.setting.key-back.label": {
+    "message": "Move backward"
+  },
+  "app.settings.game-options.setting.key-chat.label": {
+    "message": "Open chat"
+  },
+  "app.settings.game-options.setting.key-command.label": {
+    "message": "Command"
+  },
+  "app.settings.game-options.setting.key-drop.label": {
+    "message": "Drop item"
+  },
+  "app.settings.game-options.setting.key-forward.label": {
+    "message": "Move forward"
+  },
+  "app.settings.game-options.setting.key-fullscreen.label": {
+    "message": "Toggle fullscreen"
+  },
+  "app.settings.game-options.setting.key-inventory.label": {
+    "message": "Inventory"
+  },
+  "app.settings.game-options.setting.key-jump.label": {
+    "message": "Jump"
+  },
+  "app.settings.game-options.setting.key-left.label": {
+    "message": "Strafe left"
+  },
+  "app.settings.game-options.setting.key-perspective.label": {
+    "message": "Change perspective"
+  },
+  "app.settings.game-options.setting.key-pick-item.label": {
+    "message": "Pick block"
+  },
+  "app.settings.game-options.setting.key-player-list.label": {
+    "message": "Player list"
+  },
+  "app.settings.game-options.setting.key-right.label": {
+    "message": "Strafe right"
+  },
+  "app.settings.game-options.setting.key-screenshot.label": {
+    "message": "Screenshot"
+  },
+  "app.settings.game-options.setting.key-sneak.label": {
+    "message": "Sneak"
+  },
+  "app.settings.game-options.setting.key-sprint.label": {
+    "message": "Sprint"
+  },
+  "app.settings.game-options.setting.key-swap-offhand.label": {
+    "message": "Swap offhand"
+  },
+  "app.settings.game-options.setting.key-use.label": {
+    "message": "Use item"
+  },
+  "app.settings.game-options.setting.language.label": {
+    "message": "Language"
+  },
+  "app.settings.game-options.setting.main-hand.description": {
+    "message": "Choose whether the main hand is left or right."
+  },
+  "app.settings.game-options.setting.main-hand.label": {
+    "message": "Main hand"
+  },
+  "app.settings.game-options.setting.master-volume.label": {
+    "message": "Master volume"
+  },
+  "app.settings.game-options.setting.max-framerate.label": {
+    "message": "Maximum framerate"
+  },
+  "app.settings.game-options.setting.mipmap-levels.description": {
+    "message": "Texture smoothing at a distance."
+  },
+  "app.settings.game-options.setting.mipmap-levels.label": {
+    "message": "Mipmap levels"
+  },
+  "app.settings.game-options.setting.music-toast.description": {
+    "message": "Choose whether music titles appear in the pause menu and as toasts."
+  },
+  "app.settings.game-options.setting.music-toast.label": {
+    "message": "Music notification"
+  },
+  "app.settings.game-options.setting.music-volume.label": {
+    "message": "Music"
+  },
+  "app.settings.game-options.setting.narrator.description": {
+    "message": "Choose what the narrator reads."
+  },
+  "app.settings.game-options.setting.narrator.label": {
+    "message": "Narrator"
+  },
+  "app.settings.game-options.setting.notification-time.description": {
+    "message": "How long toast notifications remain visible."
+  },
+  "app.settings.game-options.setting.notification-time.label": {
+    "message": "Notification time"
+  },
+  "app.settings.game-options.setting.particles.label": {
+    "message": "Particles"
+  },
+  "app.settings.game-options.setting.players-volume.label": {
+    "message": "Players"
+  },
+  "app.settings.game-options.setting.realms-notifications.label": {
+    "message": "Realms notifications"
+  },
+  "app.settings.game-options.setting.render-distance.label": {
+    "message": "Render distance"
+  },
+  "app.settings.game-options.setting.sensitivity.label": {
+    "message": "Mouse sensitivity"
+  },
+  "app.settings.game-options.setting.simulation-distance.description": {
+    "message": "How far away entities update and blocks and fluids tick."
+  },
+  "app.settings.game-options.setting.simulation-distance.label": {
+    "message": "Simulation distance"
+  },
+  "app.settings.game-options.setting.subtitles.description": {
+    "message": "Show captions for sounds played in the game."
+  },
+  "app.settings.game-options.setting.subtitles.label": {
+    "message": "Subtitles"
+  },
+  "app.settings.game-options.setting.toggle-crouch.description": {
+    "message": "Press once to remain crouched."
+  },
+  "app.settings.game-options.setting.toggle-crouch.label": {
+    "message": "Toggle crouch"
+  },
+  "app.settings.game-options.setting.toggle-sprint.description": {
+    "message": "Press once to remain sprinting."
+  },
+  "app.settings.game-options.setting.toggle-sprint.label": {
+    "message": "Toggle sprint"
+  },
+  "app.settings.game-options.setting.view-bobbing.description": {
+    "message": "Add a bobbing motion to the camera while walking."
+  },
+  "app.settings.game-options.setting.view-bobbing.label": {
+    "message": "View bobbing"
+  },
+  "app.settings.game-options.setting.voice-volume.label": {
+    "message": "Voice and speech"
+  },
+  "app.settings.game-options.setting.vsync.description": {
+    "message": "Limit the frame rate to the display refresh rate to prevent screen tearing."
+  },
+  "app.settings.game-options.setting.vsync.label": {
+    "message": "VSync"
+  },
+  "app.settings.game-options.source.disabled.installing-or-updating": {
+    "message": "Installing or updating"
+  },
+  "app.settings.game-options.source.disabled.missing-options-file": {
+    "message": "No options.txt file"
+  },
+  "app.settings.game-options.source.disabled.no-syncable-settings": {
+    "message": "No syncable settings found"
+  },
+  "app.settings.game-options.source.disabled.running": {
+    "message": "Currently running"
+  },
+  "app.settings.game-options.source.disabled.unreadable-options-file": {
+    "message": "options.txt could not be read"
+  },
+  "app.settings.game-options.source.disabled.unsupported-version": {
+    "message": "Unsupported Minecraft version"
+  },
+  "app.settings.game-options.source.settings-summary": {
+    "message": "{recognized, plural, one {# recognized setting} other {# recognized settings}}, {custom, plural, one {# custom setting} other {# custom settings}}"
+  },
+  "app.settings.game-options.validation.changed-since-opened": {
+    "message": "This setting changed elsewhere. Check it and try again."
+  },
+  "app.settings.game-options.validation.invalid-value": {
+    "message": "Choose a valid value."
+  },
+  "app.settings.game-options.validation.local-value-needs-saving": {
+    "message": "Save this value before turning sync back on."
+  },
+  "app.settings.game-options.validation.missing-value": {
+    "message": "Choose a value first."
+  },
+  "app.settings.game-options.validation.no-compatible-instances": {
+    "message": "Some of your instances cannot use this setting"
+  },
   "app.settings.java-installations.location.title": {
     "message": "Java {version, number} location"
   },
@@ -1703,6 +2327,9 @@
   "app.settings.synced-options.choose-sync-source.creative-hotbars-description": {
     "message": "Pick the instance whose saved creative hotbars become the shared copy."
   },
+  "app.settings.synced-options.choose-sync-source.game-settings-description": {
+    "message": "Choose which instance to copy game settings from."
+  },
   "app.settings.synced-options.choose-sync-source.multiplayer-servers-description": {
     "message": "Pick the instance whose multiplayer servers become the shared copy."
   },
@@ -1733,6 +2360,96 @@
   "app.settings.synced-options.creative-hotbars.description": {
     "message": "Use the same saved creative hotbars across your instances."
   },
+  "app.settings.synced-options.game-settings": {
+    "message": "Sync game options"
+  },
+  "app.settings.synced-options.game-settings.button": {
+    "message": "Edit game settings"
+  },
+  "app.settings.synced-options.game-settings.compatibility-details": {
+    "message": "Why this setting may not sync"
+  },
+  "app.settings.synced-options.game-settings.conflict-text": {
+    "message": "We loaded the latest settings. Check your changes, then save again."
+  },
+  "app.settings.synced-options.game-settings.conflict-title": {
+    "message": "These settings changed elsewhere"
+  },
+  "app.settings.synced-options.game-settings.custom-empty": {
+    "message": "Settings added by mods will appear here after Modrinth finds them in one of your instances."
+  },
+  "app.settings.synced-options.game-settings.description": {
+    "message": "Synced options are applied to every instance and override the values included with a modpack."
+  },
+  "app.settings.synced-options.game-settings.disable-all": {
+    "message": "Unsync all"
+  },
+  "app.settings.synced-options.game-settings.disabled-tooltip": {
+    "message": "Enable game settings sync before choosing individual settings."
+  },
+  "app.settings.synced-options.game-settings.empty": {
+    "message": "No settings match your search or filter."
+  },
+  "app.settings.synced-options.game-settings.enable-all": {
+    "message": "Sync tab"
+  },
+  "app.settings.synced-options.game-settings.load-failed": {
+    "message": "We couldn’t load your game settings."
+  },
+  "app.settings.synced-options.game-settings.loading": {
+    "message": "Loading settings..."
+  },
+  "app.settings.synced-options.game-settings.retry": {
+    "message": "Retry"
+  },
+  "app.settings.synced-options.game-settings.save": {
+    "message": "Save settings"
+  },
+  "app.settings.synced-options.game-settings.saved": {
+    "message": "Game settings updated"
+  },
+  "app.settings.synced-options.game-settings.saved-later": {
+    "message": "Your changes were saved and will finish syncing when your instances are ready."
+  },
+  "app.settings.synced-options.game-settings.saved-summary": {
+    "message": "Your changes were saved."
+  },
+  "app.settings.synced-options.game-settings.saved-with-problems": {
+    "message": "Your changes were saved, but some instances could not be updated."
+  },
+  "app.settings.synced-options.game-settings.search": {
+    "message": "Search settings..."
+  },
+  "app.settings.synced-options.game-settings.sync-setting": {
+    "message": "Sync {setting} across instances"
+  },
+  "app.settings.synced-options.game-settings.sync-title": {
+    "message": "Sync game settings"
+  },
+  "app.settings.synced-options.game-settings.title": {
+    "message": "Game settings"
+  },
+  "app.settings.synced-options.game-settings.unsaved-changes": {
+    "message": "You have unsaved changes."
+  },
+  "app.settings.synced-options.game-settings.unsync-setting": {
+    "message": "Stop syncing {setting} across instances"
+  },
+  "app.settings.synced-options.game-settings.value-label": {
+    "message": "Value"
+  },
+  "app.settings.synced-options.game-settings.value-mixed": {
+    "message": "Different across instances"
+  },
+  "app.settings.synced-options.game-settings.value-off": {
+    "message": "Off"
+  },
+  "app.settings.synced-options.game-settings.value-on": {
+    "message": "On"
+  },
+  "app.settings.synced-options.game-settings.value-unset": {
+    "message": "Choose a value"
+  },
   "app.settings.synced-options.multiplayer-servers": {
     "message": "Sync multiplayer servers"
   },
@@ -2726,6 +3443,15 @@
   "instance.settings.tabs.synced-options.creative-hotbars.override-description": {
     "message": "Keep this instance's saved creative hotbars separate from synced hotbars."
   },
+  "instance.settings.tabs.synced-options.game-settings": {
+    "message": "Unsync game settings"
+  },
+  "instance.settings.tabs.synced-options.game-settings.description": {
+    "message": "Keep this instance's options.txt separate from the synced copy"
+  },
+  "instance.settings.tabs.synced-options.game-settings.disabled-in-app": {
+    "message": "Game settings syncing is turned off in app settings."
+  },
   "instance.settings.tabs.synced-options.hotbars-conflict.backup-description": {
     "message": "The version being replaced will be backed up before anything changes."
   },
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 ac96db7719..b04e73c82c 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
@@ -49,9 +49,17 @@ const handleUnlinked = () => emit('unlinked')
 
 const instanceRef = computed(() => props.instance)
 const tabbedModal = ref<InstanceType<typeof TabbedModal> | null>(null)
+let onAfterClose: (() => void) | undefined
 
-function hide() {
-	tabbedModal.value?.hide()
+function hide(callback?: () => void) {
+	onAfterClose = callback
+	if (!tabbedModal.value?.hide()) onAfterClose = undefined
+}
+
+function handleAfterHide() {
+	const callback = onAfterClose
+	onAfterClose = undefined
+	callback?.()
 }
 
 provideInstanceSettings({
@@ -181,6 +189,7 @@ defineExpose({ show, hide })
 	<TabbedModal
 		ref="tabbedModal"
 		:tabs="tabs"
+		:on-after-hide="handleAfterHide"
 		:max-width="'min(928px, calc(95vw - 10rem))'"
 		:width="'min(928px, calc(95vw - 10rem))'"
 	>
diff --git a/apps/app-frontend/src/pages/instance/components/settings-modal/instance-settings-context.ts b/apps/app-frontend/src/pages/instance/components/settings-modal/instance-settings-context.ts
index d6aa632d57..543fd81052 100644
--- a/apps/app-frontend/src/pages/instance/components/settings-modal/instance-settings-context.ts
+++ b/apps/app-frontend/src/pages/instance/components/settings-modal/instance-settings-context.ts
@@ -8,7 +8,7 @@ export interface InstanceSettingsContext {
 	offline?: boolean
 	isMinecraftServer: Ref<boolean>
 	onUnlinked: () => void
-	closeModal?: () => void
+	closeModal?: (onAfterClose?: () => void) => void
 }
 
 export const [injectInstanceSettings, provideInstanceSettings] =
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 3410a58c7b..c433a3dc13 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
@@ -4,6 +4,7 @@ import {
 	Button,
 	commonMessages,
 	defineMessages,
+	IconButton,
 	injectNotificationManager,
 	NewModal,
 	Toggle,
@@ -12,6 +13,7 @@ import {
 import { useMutation, useQuery, useQueryClient } from '@tanstack/vue-query'
 import { computed, inject, ref } from 'vue'
 
+import GameSettingsModal from '@/components/ui/settings/instances/game-settings/GameSettingsModal.vue'
 import {
 	get_synced_option_join_preview,
 	get_synced_options_overview,
@@ -43,6 +45,22 @@ const messages = defineMessages({
 		id: 'instance.settings.tabs.synced-options.open-app-settings',
 		defaultMessage: 'Manage synced settings',
 	},
+	gameSettings: {
+		id: 'instance.settings.tabs.synced-options.game-settings',
+		defaultMessage: 'Unsync game settings',
+	},
+	gameSettingsDescription: {
+		id: 'instance.settings.tabs.synced-options.game-settings.description',
+		defaultMessage: "Keep this instance's options.txt separate from the synced copy",
+	},
+	editGameSettings: {
+		id: 'app.settings.synced-options.game-settings.button',
+		defaultMessage: 'Edit game settings',
+	},
+	gameSettingsDisabled: {
+		id: 'instance.settings.tabs.synced-options.game-settings.disabled-in-app',
+		defaultMessage: 'Game settings syncing is turned off in app settings.',
+	},
 	multiplayerServers: {
 		id: 'instance.settings.tabs.synced-options.multiplayer-servers',
 		defaultMessage: 'Unsync multiplayer servers',
@@ -105,6 +123,7 @@ const messages = defineMessages({
 type InstanceSyncedOption = Exclude<SyncedOption, 'screenshots'>
 
 const globalDisabledMessages: Record<InstanceSyncedOption, keyof typeof messages> = {
+	game_options: 'gameSettingsDisabled',
 	multiplayer_servers: 'multiplayerServersDisabled',
 	command_history: 'commandHistoryDisabled',
 	creative_hotbars: 'creativeHotbarsDisabled',
@@ -115,6 +134,11 @@ const rows: Array<{
 	title: keyof typeof messages
 	description?: keyof typeof messages
 }> = [
+	{
+		option: 'game_options',
+		title: 'gameSettings',
+		description: 'gameSettingsDescription',
+	},
 	{
 		option: 'multiplayer_servers',
 		title: 'multiplayerServers',
@@ -146,10 +170,17 @@ const capabilities = computed(
 				[],
 		),
 )
+const gameSettingsModal = ref<InstanceType<typeof GameSettingsModal> | null>(null)
 const hotbarResolutionModal = ref<InstanceType<typeof NewModal> | null>(null)
 const previewingOption = ref<InstanceSyncedOption | null>(null)
 const previewExcluded = ref<Partial<Record<InstanceSyncedOption, boolean>>>({})
 
+const gameSettingsInstanceId = computed(() =>
+	overviewQuery.data.value?.global_options.game_options && enabled('game_options')
+		? undefined
+		: instance.value.id,
+)
+
 function excluded(option: InstanceSyncedOption): boolean {
 	const preview = previewExcluded.value[option]
 	if (preview !== undefined) return preview
@@ -160,6 +191,10 @@ function excluded(option: InstanceSyncedOption): boolean {
 	)
 }
 
+function enabled(option: InstanceSyncedOption): boolean {
+	return instance.value.synced_options[option]
+}
+
 function setPreviewExcluded(option: InstanceSyncedOption, value?: boolean) {
 	if (value === undefined) {
 		const { [option]: _, ...next } = previewExcluded.value
@@ -177,8 +212,22 @@ function disabledReason(option: InstanceSyncedOption): string | undefined {
 }
 
 function showAppSyncedOptions(): void {
-	closeModal?.()
-	openAppSettingsSyncedOptions()
+	if (closeModal) {
+		closeModal(openAppSettingsSyncedOptions)
+	} else {
+		openAppSettingsSyncedOptions()
+	}
+}
+
+function openGameSettings(): void {
+	gameSettingsModal.value?.show()
+}
+
+async function handleGameSettingsSaved(): Promise<void> {
+	await Promise.all([
+		queryClient.invalidateQueries({ queryKey: instanceKeys.all }),
+		queryClient.invalidateQueries({ queryKey: ['instance-synced-options'] }),
+	])
 }
 
 type SyncedOptionMutationVariables = {
@@ -304,6 +353,12 @@ function resolveHotbars(resolution: SyncedOptionJoinResolution) {
 
 <template>
 	<div class="flex flex-col gap-6">
+		<GameSettingsModal
+			ref="gameSettingsModal"
+			:instance-id="gameSettingsInstanceId"
+			@saved="handleGameSettingsSaved"
+		/>
+
 		<NewModal
 			ref="hotbarResolutionModal"
 			:header="formatMessage(messages.hotbarConflictTitle)"
@@ -375,7 +430,22 @@ function resolveHotbars(resolution: SyncedOptionJoinResolution) {
 						{{ formatMessage(messages[row.description]) }}
 					</p>
 				</div>
-				<div class="flex shrink-0 items-center">
+				<div class="flex shrink-0 items-center gap-2">
+					<span
+						v-if="row.option === 'game_options'"
+						v-tooltip="formatMessage(messages.editGameSettings)"
+						class="flex"
+					>
+						<IconButton
+							type="outlined"
+							circular
+							:disabled="mutation.isPending.value || overviewQuery.isPending.value"
+							:label="formatMessage(messages.editGameSettings)"
+							@click="openGameSettings"
+						>
+							<EditIcon />
+						</IconButton>
+					</span>
 					<span v-tooltip="disabledReason(row.option)" class="flex">
 						<Toggle
 							:id="`exclude-${row.option}`"
@@ -383,7 +453,7 @@ function resolveHotbars(resolution: SyncedOptionJoinResolution) {
 							:disabled="
 								previewingOption !== null ||
 								overviewQuery.isPending.value ||
-								!!disabledReason(row.option)
+								(!!disabledReason(row.option) && !enabled(row.option))
 							"
 							@update:model-value="(excluded) => setExcluded(row.option, excluded)"
 						/>
diff --git a/apps/app/build.rs b/apps/app/build.rs
index 41f80995c5..46c2d2ef8f 100644
--- a/apps/app/build.rs
+++ b/apps/app/build.rs
@@ -237,6 +237,13 @@ fn main() {
                         "instance_get_synced_options_overview",
                         "instance_get_global_synced_options",
                         "instance_set_global_synced_option",
+                        "instance_list_game_options_sync_sources",
+                        "instance_get_synced_game_options_config",
+                        "instance_preview_synced_game_option_changes",
+                        "instance_save_synced_game_option_changes",
+                        "instance_get_local_game_options_config",
+                        "instance_preview_local_game_option_changes",
+                        "instance_save_local_game_option_changes",
                         "instance_get_command_history",
                         "instance_set_command_history",
                         "instance_open_synced_options_folder",
diff --git a/apps/app/src/api/instance.rs b/apps/app/src/api/instance.rs
index c536756ee8..7273247f73 100644
--- a/apps/app/src/api/instance.rs
+++ b/apps/app/src/api/instance.rs
@@ -66,6 +66,13 @@ pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
             instance_get_synced_options_overview,
             instance_get_global_synced_options,
             instance_set_global_synced_option,
+            instance_list_game_options_sync_sources,
+            instance_get_synced_game_options_config,
+            instance_preview_synced_game_option_changes,
+            instance_save_synced_game_option_changes,
+            instance_get_local_game_options_config,
+            instance_preview_local_game_option_changes,
+            instance_save_local_game_option_changes,
             instance_get_command_history,
             instance_set_command_history,
             instance_open_synced_options_folder,
@@ -854,6 +861,67 @@ pub async fn instance_set_global_synced_option(
     .await?)
 }
 
+#[tauri::command]
+pub async fn instance_list_game_options_sync_sources()
+-> Result<Vec<theseus::instance::GameOptionsSourceCandidate>> {
+    Ok(theseus::instance::list_game_options_sync_sources().await?)
+}
+
+#[tauri::command]
+pub async fn instance_get_synced_game_options_config()
+-> Result<theseus::instance::GameSettingsEditorState> {
+    Ok(theseus::instance::get_synced_game_options_config().await?)
+}
+
+#[tauri::command]
+pub async fn instance_preview_synced_game_option_changes(
+    request: theseus::instance::UpdateGameSettingsRequest,
+) -> Result<theseus::instance::GameSettingsEditorState> {
+    Ok(theseus::instance::preview_synced_game_option_changes(request).await?)
+}
+
+#[tauri::command]
+pub async fn instance_save_synced_game_option_changes(
+    request: theseus::instance::UpdateGameSettingsRequest,
+) -> Result<theseus::instance::SaveGameSettingsResult> {
+    Ok(theseus::instance::save_synced_game_option_changes(request).await?)
+}
+
+#[tauri::command]
+pub async fn instance_get_local_game_options_config(
+    instance_id: &str,
+) -> Result<theseus::instance::GameSettingsEditorState> {
+    Ok(theseus::instance::get_local_game_options_config(instance_id).await?)
+}
+
+#[tauri::command]
+pub async fn instance_preview_local_game_option_changes(
+    instance_id: &str,
+    request: theseus::instance::UpdateGameSettingsRequest,
+) -> Result<theseus::instance::GameSettingsEditorState> {
+    Ok(
+        theseus::instance::preview_local_game_option_changes(
+            instance_id,
+            request,
+        )
+        .await?,
+    )
+}
+
+#[tauri::command]
+pub async fn instance_save_local_game_option_changes(
+    instance_id: &str,
+    request: theseus::instance::UpdateGameSettingsRequest,
+) -> Result<theseus::instance::SaveGameSettingsResult> {
+    Ok(
+        theseus::instance::save_local_game_option_changes(
+            instance_id,
+            request,
+        )
+        .await?,
+    )
+}
+
 #[tauri::command]
 pub async fn instance_get_command_history() -> Result<String> {
     Ok(theseus::instance::get_command_history().await?)
diff --git a/packages/app-lib/.sqlx/query-006f7c73e672da9d9d607e58ce0926ef4cd958146c16797d589f347626dbab7e.json b/packages/app-lib/.sqlx/query-006f7c73e672da9d9d607e58ce0926ef4cd958146c16797d589f347626dbab7e.json
new file mode 100644
index 0000000000..febf70e225
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-006f7c73e672da9d9d607e58ce0926ef4cd958146c16797d589f347626dbab7e.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\t\tUPDATE synced_game_option_values\n\t\t\t\tSET seeded = 0, revision = ?, updated_at = ?\n\t\t\t\tWHERE option_id = ?\n\t\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": []
+  },
+  "hash": "006f7c73e672da9d9d607e58ce0926ef4cd958146c16797d589f347626dbab7e"
+}
diff --git a/packages/app-lib/.sqlx/query-06e155e02c8d097e32f18b161b3fbd69200515a3e90400d7d002acd86cf03a8c.json b/packages/app-lib/.sqlx/query-06e155e02c8d097e32f18b161b3fbd69200515a3e90400d7d002acd86cf03a8c.json
new file mode 100644
index 0000000000..6a55bbe060
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-06e155e02c8d097e32f18b161b3fbd69200515a3e90400d7d002acd86cf03a8c.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\tINSERT INTO synced_game_option_values\n\t\t\t\t(option_id, kind, raw_key, canonical_type,\n\t\t\t\t canonical_value_json, value_codec, seeded, revision, origin,\n\t\t\t\t source_game_version, source_instance_id, updated_at)\n\t\t\tVALUES (?, 'vanilla', NULL, ?, ?, 'catalog', 1, ?,\n\t\t\t\t'source_seed', ?, ?, ?)\n\t\t\tON CONFLICT(option_id) DO UPDATE SET\n\t\t\t\tkind = 'vanilla', raw_key = NULL,\n\t\t\t\tcanonical_type = excluded.canonical_type,\n\t\t\t\tcanonical_value_json = excluded.canonical_value_json,\n\t\t\t\tvalue_codec = excluded.value_codec, seeded = 1,\n\t\t\t\trevision = excluded.revision, origin = 'source_seed',\n\t\t\t\tsource_game_version = excluded.source_game_version,\n\t\t\t\tsource_instance_id = excluded.source_instance_id,\n\t\t\t\tupdated_at = excluded.updated_at\n\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 7
+    },
+    "nullable": []
+  },
+  "hash": "06e155e02c8d097e32f18b161b3fbd69200515a3e90400d7d002acd86cf03a8c"
+}
diff --git a/packages/app-lib/.sqlx/query-083e4766729cc70fd43bcc2b920165d10b9a34a68eb4e85b7380eee167db92b0.json b/packages/app-lib/.sqlx/query-083e4766729cc70fd43bcc2b920165d10b9a34a68eb4e85b7380eee167db92b0.json
new file mode 100644
index 0000000000..13c3f23991
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-083e4766729cc70fd43bcc2b920165d10b9a34a68eb4e85b7380eee167db92b0.json
@@ -0,0 +1,50 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tSELECT option_id, kind, raw_key, canonical_value_json,\n\t\t\tseeded AS \"seeded!: bool\", revision AS \"revision!: i64\"\n\t\tFROM synced_game_option_values\n\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "option_id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "kind",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "raw_key",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "canonical_value_json",
+        "ordinal": 3,
+        "type_info": "Text"
+      },
+      {
+        "name": "seeded!: bool",
+        "ordinal": 4,
+        "type_info": "Integer"
+      },
+      {
+        "name": "revision!: i64",
+        "ordinal": 5,
+        "type_info": "Integer"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false,
+      false,
+      true,
+      true,
+      false,
+      false
+    ]
+  },
+  "hash": "083e4766729cc70fd43bcc2b920165d10b9a34a68eb4e85b7380eee167db92b0"
+}
diff --git a/packages/app-lib/.sqlx/query-117563d32f10e1e0f678d606aa5edac01d302922e9f44c4375046cc7ab5c367b.json b/packages/app-lib/.sqlx/query-117563d32f10e1e0f678d606aa5edac01d302922e9f44c4375046cc7ab5c367b.json
new file mode 100644
index 0000000000..ed1f3b3d6b
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-117563d32f10e1e0f678d606aa5edac01d302922e9f44c4375046cc7ab5c367b.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "UPDATE synced_game_option_values\n\t\t SET seeded = 0, revision = revision + 1, updated_at = ?",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": []
+  },
+  "hash": "117563d32f10e1e0f678d606aa5edac01d302922e9f44c4375046cc7ab5c367b"
+}
diff --git a/packages/app-lib/.sqlx/query-1499ce88ed936711e88354f6123f719165ad8b7fe31ec84b8a6b31a45a00e634.json b/packages/app-lib/.sqlx/query-1499ce88ed936711e88354f6123f719165ad8b7fe31ec84b8a6b31a45a00e634.json
new file mode 100644
index 0000000000..c45e5afbd2
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-1499ce88ed936711e88354f6123f719165ad8b7fe31ec84b8a6b31a45a00e634.json
@@ -0,0 +1,26 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\tSELECT had_file AS \"had_file!: bool\", document\n\t\t\tFROM instance_game_option_update_state\n\t\t\tWHERE instance_id = ?\n\t\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "had_file!: bool",
+        "ordinal": 0,
+        "type_info": "Integer"
+      },
+      {
+        "name": "document",
+        "ordinal": 1,
+        "type_info": "Blob"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      true
+    ]
+  },
+  "hash": "1499ce88ed936711e88354f6123f719165ad8b7fe31ec84b8a6b31a45a00e634"
+}
diff --git a/packages/app-lib/.sqlx/query-1d66f3fb56c2e74146f8bc3b2985ed33f902980977f795d38f062bf7438c8334.json b/packages/app-lib/.sqlx/query-1d66f3fb56c2e74146f8bc3b2985ed33f902980977f795d38f062bf7438c8334.json
new file mode 100644
index 0000000000..a2107b6181
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-1d66f3fb56c2e74146f8bc3b2985ed33f902980977f795d38f062bf7438c8334.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tINSERT INTO instance_sync_preferences (instance_id, feature, enabled)\n\t\tVALUES (?, 'game_options', 1)\n\t\tON CONFLICT(instance_id, feature) DO UPDATE SET enabled = 1\n\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": []
+  },
+  "hash": "1d66f3fb56c2e74146f8bc3b2985ed33f902980977f795d38f062bf7438c8334"
+}
diff --git a/packages/app-lib/.sqlx/query-1fb66446c3ba0f52e682f8aae4b80a97310f308b3aa25c322d499b32d549f7b7.json b/packages/app-lib/.sqlx/query-1fb66446c3ba0f52e682f8aae4b80a97310f308b3aa25c322d499b32d549f7b7.json
deleted file mode 100644
index 9d10b4b7be..0000000000
--- a/packages/app-lib/.sqlx/query-1fb66446c3ba0f52e682f8aae4b80a97310f308b3aa25c322d499b32d549f7b7.json
+++ /dev/null
@@ -1,32 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "\n\t\tSELECT instances.id, instances.name, instances.path\n\t\tFROM instances\n\t\tINNER JOIN instance_sync_preferences preferences\n\t\t\tON preferences.instance_id = instances.id\n\t\tWHERE preferences.feature = 'screenshots'\n\t\t\tAND preferences.enabled = 1\n\t\t\tAND EXISTS (\n\t\t\t\tSELECT 1\n\t\t\t\tFROM sync_feature_settings\n\t\t\t\tWHERE feature = 'screenshots' AND globally_enabled = 1\n\t\t\t)\n\t\tORDER BY instances.name, instances.id\n\t\t",
-  "describe": {
-    "columns": [
-      {
-        "name": "id",
-        "ordinal": 0,
-        "type_info": "Text"
-      },
-      {
-        "name": "name",
-        "ordinal": 1,
-        "type_info": "Text"
-      },
-      {
-        "name": "path",
-        "ordinal": 2,
-        "type_info": "Text"
-      }
-    ],
-    "parameters": {
-      "Right": 0
-    },
-    "nullable": [
-      false,
-      false,
-      false
-    ]
-  },
-  "hash": "1fb66446c3ba0f52e682f8aae4b80a97310f308b3aa25c322d499b32d549f7b7"
-}
diff --git a/packages/app-lib/.sqlx/query-253ab2ee7d3504fbc1b098739d06c0c2b1a888ea6c6c0542f4713b03bbafea7b.json b/packages/app-lib/.sqlx/query-253ab2ee7d3504fbc1b098739d06c0c2b1a888ea6c6c0542f4713b03bbafea7b.json
new file mode 100644
index 0000000000..23c97c1373
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-253ab2ee7d3504fbc1b098739d06c0c2b1a888ea6c6c0542f4713b03bbafea7b.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\tINSERT INTO synced_game_option_state (singleton, revision, catalog_revision)\n\t\t\tVALUES (1, ?, ?)\n\t\t\tON CONFLICT(singleton) DO UPDATE SET\n\t\t\t\trevision = excluded.revision,\n\t\t\t\tcatalog_revision = excluded.catalog_revision\n\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": []
+  },
+  "hash": "253ab2ee7d3504fbc1b098739d06c0c2b1a888ea6c6c0542f4713b03bbafea7b"
+}
diff --git a/packages/app-lib/.sqlx/query-27958cce6c5ed137310edc76fd113d164438273c75ad4f22a4b81003e737da67.json b/packages/app-lib/.sqlx/query-27958cce6c5ed137310edc76fd113d164438273c75ad4f22a4b81003e737da67.json
new file mode 100644
index 0000000000..8a610b1624
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-27958cce6c5ed137310edc76fd113d164438273c75ad4f22a4b81003e737da67.json
@@ -0,0 +1,32 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tSELECT option_id, enabled AS \"enabled!: bool\",\n\t\t\trevision AS \"revision!: i64\"\n\t\tFROM synced_game_option_preferences\n\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "option_id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "enabled!: bool",
+        "ordinal": 1,
+        "type_info": "Integer"
+      },
+      {
+        "name": "revision!: i64",
+        "ordinal": 2,
+        "type_info": "Integer"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "27958cce6c5ed137310edc76fd113d164438273c75ad4f22a4b81003e737da67"
+}
diff --git a/packages/app-lib/.sqlx/query-39459b06ceb9ca531c476c6a77e40087e771dfafc968144db5978c570e68a884.json b/packages/app-lib/.sqlx/query-39459b06ceb9ca531c476c6a77e40087e771dfafc968144db5978c570e68a884.json
new file mode 100644
index 0000000000..47604ee881
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-39459b06ceb9ca531c476c6a77e40087e771dfafc968144db5978c570e68a884.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\t\tINSERT INTO synced_game_option_values\n\t\t\t\t\t(option_id, kind, raw_key, canonical_type,\n\t\t\t\t\t canonical_value_json, value_codec, seeded, revision, origin,\n\t\t\t\t\t source_game_version, source_instance_id, updated_at)\n\t\t\t\tVALUES (?, 'vanilla', NULL, ?, ?, 'catalog', 1, 1,\n\t\t\t\t\t'instance', ?, ?, ?)\n\t\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 6
+    },
+    "nullable": []
+  },
+  "hash": "39459b06ceb9ca531c476c6a77e40087e771dfafc968144db5978c570e68a884"
+}
diff --git a/packages/app-lib/.sqlx/query-465bc85ac3abc47c9179cf2f09e55a1a303360c04d865980ce37248b05ea3994.json b/packages/app-lib/.sqlx/query-465bc85ac3abc47c9179cf2f09e55a1a303360c04d865980ce37248b05ea3994.json
new file mode 100644
index 0000000000..3b9d6a7504
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-465bc85ac3abc47c9179cf2f09e55a1a303360c04d865980ce37248b05ea3994.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tINSERT INTO instance_game_option_pack_bases\n\t\t\t(instance_id, pack_version_id, source, sha1, encoding, document)\n\t\tVALUES (?, ?, ?, ?, ?, ?)\n\t\tON CONFLICT(instance_id) DO UPDATE SET\n\t\t\tpack_version_id = excluded.pack_version_id,\n\t\t\tsource = excluded.source, sha1 = excluded.sha1,\n\t\t\tencoding = excluded.encoding, document = excluded.document\n\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 6
+    },
+    "nullable": []
+  },
+  "hash": "465bc85ac3abc47c9179cf2f09e55a1a303360c04d865980ce37248b05ea3994"
+}
diff --git a/packages/app-lib/.sqlx/query-51adcaf25852937edaf46a304e85dcf59f91565296e9ae97d210249cdcc29cfc.json b/packages/app-lib/.sqlx/query-51adcaf25852937edaf46a304e85dcf59f91565296e9ae97d210249cdcc29cfc.json
new file mode 100644
index 0000000000..15b644e71a
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-51adcaf25852937edaf46a304e85dcf59f91565296e9ae97d210249cdcc29cfc.json
@@ -0,0 +1,26 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tSELECT revision AS \"revision!: i64\",\n\t\t\tcatalog_revision AS \"catalog_revision!: i64\"\n\t\tFROM synced_game_option_state\n\t\tWHERE singleton = 1\n\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "revision!: i64",
+        "ordinal": 0,
+        "type_info": "Integer"
+      },
+      {
+        "name": "catalog_revision!: i64",
+        "ordinal": 1,
+        "type_info": "Integer"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false,
+      false
+    ]
+  },
+  "hash": "51adcaf25852937edaf46a304e85dcf59f91565296e9ae97d210249cdcc29cfc"
+}
diff --git a/packages/app-lib/.sqlx/query-58dbcc46287aa386bb87bebc0a94bbbe293834ffd7b86b260a7bccb6c8028d92.json b/packages/app-lib/.sqlx/query-58dbcc46287aa386bb87bebc0a94bbbe293834ffd7b86b260a7bccb6c8028d92.json
new file mode 100644
index 0000000000..aedb979da8
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-58dbcc46287aa386bb87bebc0a94bbbe293834ffd7b86b260a7bccb6c8028d92.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\t\t\tUPDATE synced_game_option_values\n\t\t\t\t\tSET canonical_value_json = NULL, seeded = 0, revision = ?,\n\t\t\t\t\t\torigin = 'app_editor', source_game_version = NULL,\n\t\t\t\t\t\tsource_instance_id = NULL, updated_at = ?\n\t\t\t\t\tWHERE option_id = ?\n\t\t\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": []
+  },
+  "hash": "58dbcc46287aa386bb87bebc0a94bbbe293834ffd7b86b260a7bccb6c8028d92"
+}
diff --git a/packages/app-lib/.sqlx/query-6b6645cbfb273b6c37f4c472d5df2dcb14f952cc7bcbb4661ff8abd4e168ee1c.json b/packages/app-lib/.sqlx/query-6b6645cbfb273b6c37f4c472d5df2dcb14f952cc7bcbb4661ff8abd4e168ee1c.json
new file mode 100644
index 0000000000..2ade965808
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-6b6645cbfb273b6c37f4c472d5df2dcb14f952cc7bcbb4661ff8abd4e168ee1c.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\tINSERT INTO synced_game_option_values\n\t\t\t\t(option_id, kind, raw_key, canonical_type,\n\t\t\t\t canonical_value_json, value_codec, seeded, revision, origin,\n\t\t\t\t source_game_version, source_instance_id, updated_at)\n\t\t\tVALUES (?, 'external', ?, 'external_raw', ?, 'exact_raw',\n\t\t\t\t1, ?, 'instance', ?, ?, ?)\n\t\t\tON CONFLICT(option_id) DO UPDATE SET\n\t\t\t\traw_key = excluded.raw_key,\n\t\t\t\tcanonical_value_json = excluded.canonical_value_json,\n\t\t\t\tseeded = 1, revision = excluded.revision,\n\t\t\t\torigin = 'instance',\n\t\t\t\tsource_game_version = excluded.source_game_version,\n\t\t\t\tsource_instance_id = excluded.source_instance_id,\n\t\t\t\tupdated_at = excluded.updated_at\n\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 7
+    },
+    "nullable": []
+  },
+  "hash": "6b6645cbfb273b6c37f4c472d5df2dcb14f952cc7bcbb4661ff8abd4e168ee1c"
+}
diff --git a/packages/app-lib/.sqlx/query-6d7ebc0f233dc730fa8c99c750421065f5e35f321954a9d5ae9cde907d5ce823.json b/packages/app-lib/.sqlx/query-6d7ebc0f233dc730fa8c99c750421065f5e35f321954a9d5ae9cde907d5ce823.json
deleted file mode 100644
index 2826fb40ac..0000000000
--- a/packages/app-lib/.sqlx/query-6d7ebc0f233dc730fa8c99c750421065f5e35f321954a9d5ae9cde907d5ce823.json
+++ /dev/null
@@ -1,38 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "\n            SELECT\n                id, active, session_id, expires\n            FROM modrinth_users\n            ",
-  "describe": {
-    "columns": [
-      {
-        "name": "id",
-        "ordinal": 0,
-        "type_info": "Text"
-      },
-      {
-        "name": "active",
-        "ordinal": 1,
-        "type_info": "Integer"
-      },
-      {
-        "name": "session_id",
-        "ordinal": 2,
-        "type_info": "Text"
-      },
-      {
-        "name": "expires",
-        "ordinal": 3,
-        "type_info": "Integer"
-      }
-    ],
-    "parameters": {
-      "Right": 0
-    },
-    "nullable": [
-      false,
-      false,
-      false,
-      false
-    ]
-  },
-  "hash": "6d7ebc0f233dc730fa8c99c750421065f5e35f321954a9d5ae9cde907d5ce823"
-}
diff --git a/packages/app-lib/.sqlx/query-6f17b1880668e6efb235eaa3808bd64a1c6bb5fc5f3c0082500afdcfa7340efa.json b/packages/app-lib/.sqlx/query-6f17b1880668e6efb235eaa3808bd64a1c6bb5fc5f3c0082500afdcfa7340efa.json
index f702c75af1..c59ac318b0 100644
--- a/packages/app-lib/.sqlx/query-6f17b1880668e6efb235eaa3808bd64a1c6bb5fc5f3c0082500afdcfa7340efa.json
+++ b/packages/app-lib/.sqlx/query-6f17b1880668e6efb235eaa3808bd64a1c6bb5fc5f3c0082500afdcfa7340efa.json
@@ -3,17 +3,60 @@
   "query": "\n\t\tSELECT\n\t\t\tscreenshots.id,\n\t\t\tscreenshots.instance_id,\n\t\t\tscreenshots.file_name,\n\t\t\tscreenshots.content_hash,\n\t\t\tscreenshots.file_size,\n\t\t\tscreenshots.modified_at,\n\t\t\tscreenshots.created_at,\n\t\t\tmemberships.group_id AS \"group_id?\"\n\t\tFROM screenshots\n\t\tLEFT JOIN screenshot_group_memberships memberships\n\t\t\tON memberships.screenshot_id = screenshots.id\n\t\tWHERE screenshots.instance_id = ? AND screenshots.file_name = ?\n\t\t",
   "describe": {
     "columns": [
-      { "name": "id", "ordinal": 0, "type_info": "Text" },
-      { "name": "instance_id", "ordinal": 1, "type_info": "Text" },
-      { "name": "file_name", "ordinal": 2, "type_info": "Text" },
-      { "name": "content_hash", "ordinal": 3, "type_info": "Text" },
-      { "name": "file_size", "ordinal": 4, "type_info": "Integer" },
-      { "name": "modified_at", "ordinal": 5, "type_info": "Integer" },
-      { "name": "created_at", "ordinal": 6, "type_info": "Integer" },
-      { "name": "group_id?", "ordinal": 7, "type_info": "Text" }
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "instance_id",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "file_name",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "content_hash",
+        "ordinal": 3,
+        "type_info": "Text"
+      },
+      {
+        "name": "file_size",
+        "ordinal": 4,
+        "type_info": "Integer"
+      },
+      {
+        "name": "modified_at",
+        "ordinal": 5,
+        "type_info": "Integer"
+      },
+      {
+        "name": "created_at",
+        "ordinal": 6,
+        "type_info": "Integer"
+      },
+      {
+        "name": "group_id?",
+        "ordinal": 7,
+        "type_info": "Text"
+      }
     ],
-    "parameters": { "Right": 2 },
-    "nullable": [false, false, false, false, false, false, false, false]
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false
+    ]
   },
   "hash": "6f17b1880668e6efb235eaa3808bd64a1c6bb5fc5f3c0082500afdcfa7340efa"
 }
diff --git a/packages/app-lib/.sqlx/query-7062aaed9cde80d865cf4c845cb40fb48d24b62a5ddddfc6de2f14b80d2bfc7c.json b/packages/app-lib/.sqlx/query-7062aaed9cde80d865cf4c845cb40fb48d24b62a5ddddfc6de2f14b80d2bfc7c.json
new file mode 100644
index 0000000000..e75f23a5df
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-7062aaed9cde80d865cf4c845cb40fb48d24b62a5ddddfc6de2f14b80d2bfc7c.json
@@ -0,0 +1,20 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tSELECT EXISTS(\n\t\t\tSELECT 1 FROM synced_game_option_state WHERE singleton = 1\n\t\t) AS \"exists!: bool\"\n\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "exists!: bool",
+        "ordinal": 0,
+        "type_info": "Integer"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "7062aaed9cde80d865cf4c845cb40fb48d24b62a5ddddfc6de2f14b80d2bfc7c"
+}
diff --git a/packages/app-lib/.sqlx/query-71952a8ac14cf790a5b93eb722efa810ad8ca5f246c4d81ad4bcd5866ee10f2c.json b/packages/app-lib/.sqlx/query-71952a8ac14cf790a5b93eb722efa810ad8ca5f246c4d81ad4bcd5866ee10f2c.json
new file mode 100644
index 0000000000..14c51887ab
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-71952a8ac14cf790a5b93eb722efa810ad8ca5f246c4d81ad4bcd5866ee10f2c.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tINSERT INTO instance_game_option_update_state\n\t\t\t(instance_id, had_file, sha1, document)\n\t\tVALUES (?, ?, ?, ?)\n\t\tON CONFLICT(instance_id) DO UPDATE SET\n\t\t\thad_file = excluded.had_file, sha1 = excluded.sha1,\n\t\t\tdocument = excluded.document\n\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 4
+    },
+    "nullable": []
+  },
+  "hash": "71952a8ac14cf790a5b93eb722efa810ad8ca5f246c4d81ad4bcd5866ee10f2c"
+}
diff --git a/packages/app-lib/.sqlx/query-738203b62c0c38211bb535a3595f046e42ee66e31d99b8ff28917f58b4a937f6.json b/packages/app-lib/.sqlx/query-738203b62c0c38211bb535a3595f046e42ee66e31d99b8ff28917f58b4a937f6.json
new file mode 100644
index 0000000000..8a7b463f43
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-738203b62c0c38211bb535a3595f046e42ee66e31d99b8ff28917f58b4a937f6.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\tUPDATE synced_game_option_state\n\t\t\tSET revision = ?, catalog_revision = ?\n\t\t\tWHERE singleton = 1\n\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": []
+  },
+  "hash": "738203b62c0c38211bb535a3595f046e42ee66e31d99b8ff28917f58b4a937f6"
+}
diff --git a/packages/app-lib/.sqlx/query-7874719d05692b28b1c2cdbd6f208acd794a400abeca0027cc6b21f5bd466e79.json b/packages/app-lib/.sqlx/query-7874719d05692b28b1c2cdbd6f208acd794a400abeca0027cc6b21f5bd466e79.json
new file mode 100644
index 0000000000..5fd42152fa
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-7874719d05692b28b1c2cdbd6f208acd794a400abeca0027cc6b21f5bd466e79.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\t\tINSERT INTO synced_game_option_preferences\n\t\t\t\t\t(option_id, enabled, source, revision)\n\t\t\t\tVALUES (?, ?, ?, ?)\n\t\t\t\tON CONFLICT(option_id) DO UPDATE SET\n\t\t\t\t\tenabled = excluded.enabled, source = 'user',\n\t\t\t\t\trevision = excluded.revision\n\t\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 4
+    },
+    "nullable": []
+  },
+  "hash": "7874719d05692b28b1c2cdbd6f208acd794a400abeca0027cc6b21f5bd466e79"
+}
diff --git a/packages/app-lib/.sqlx/query-7a91c72a32d0d8cf712ddcbe9746d3d8c7b10211f275e0db81fa1eda5196c2e5.json b/packages/app-lib/.sqlx/query-7a91c72a32d0d8cf712ddcbe9746d3d8c7b10211f275e0db81fa1eda5196c2e5.json
new file mode 100644
index 0000000000..9428856bff
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-7a91c72a32d0d8cf712ddcbe9746d3d8c7b10211f275e0db81fa1eda5196c2e5.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "DELETE FROM instance_game_option_update_state WHERE instance_id = ?",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": []
+  },
+  "hash": "7a91c72a32d0d8cf712ddcbe9746d3d8c7b10211f275e0db81fa1eda5196c2e5"
+}
diff --git a/packages/app-lib/.sqlx/query-838b438f2dfa21885848b2eaf013a4767d4e9a28626c754bb4e8e7030b73ead7.json b/packages/app-lib/.sqlx/query-838b438f2dfa21885848b2eaf013a4767d4e9a28626c754bb4e8e7030b73ead7.json
new file mode 100644
index 0000000000..e3b11b7fb6
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-838b438f2dfa21885848b2eaf013a4767d4e9a28626c754bb4e8e7030b73ead7.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\t\tUPDATE synced_game_option_preferences\n\t\t\t\tSET enabled = 0, source = 'catalog_default', revision = ?\n\t\t\t\tWHERE option_id = ?\n\t\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": []
+  },
+  "hash": "838b438f2dfa21885848b2eaf013a4767d4e9a28626c754bb4e8e7030b73ead7"
+}
diff --git a/packages/app-lib/.sqlx/query-8aae262e7a2e6375164af3b296465d017d21a6c6476d0f2ae09c076d75f0dda3.json b/packages/app-lib/.sqlx/query-8aae262e7a2e6375164af3b296465d017d21a6c6476d0f2ae09c076d75f0dda3.json
index be54b69428..792ed44226 100644
--- a/packages/app-lib/.sqlx/query-8aae262e7a2e6375164af3b296465d017d21a6c6476d0f2ae09c076d75f0dda3.json
+++ b/packages/app-lib/.sqlx/query-8aae262e7a2e6375164af3b296465d017d21a6c6476d0f2ae09c076d75f0dda3.json
@@ -3,7 +3,9 @@
   "query": "\n\t\tUPDATE screenshots\n\t\tSET\n\t\t\tinstance_id = ?,\n\t\t\tfile_name = ?,\n\t\t\tcontent_hash = ?,\n\t\t\tfile_size = ?,\n\t\t\tmodified_at = ?,\n\t\t\tcreated_at = ?\n\t\tWHERE id = ?\n\t\t",
   "describe": {
     "columns": [],
-    "parameters": { "Right": 7 },
+    "parameters": {
+      "Right": 7
+    },
     "nullable": []
   },
   "hash": "8aae262e7a2e6375164af3b296465d017d21a6c6476d0f2ae09c076d75f0dda3"
diff --git a/packages/app-lib/.sqlx/query-8e5cb4f707e7adae2d7fce146402335be017bc4398a15149753bf31b2acac938.json b/packages/app-lib/.sqlx/query-8e5cb4f707e7adae2d7fce146402335be017bc4398a15149753bf31b2acac938.json
new file mode 100644
index 0000000000..abda3d314d
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-8e5cb4f707e7adae2d7fce146402335be017bc4398a15149753bf31b2acac938.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\t\tUPDATE synced_game_option_values\n\t\t\t\tSET canonical_type = ?, canonical_value_json = ?, seeded = 1,\n\t\t\t\t\trevision = ?, origin = 'instance', source_game_version = ?,\n\t\t\t\t\tsource_instance_id = ?, updated_at = ?\n\t\t\t\tWHERE option_id = ? AND revision = ?\n\t\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 8
+    },
+    "nullable": []
+  },
+  "hash": "8e5cb4f707e7adae2d7fce146402335be017bc4398a15149753bf31b2acac938"
+}
diff --git a/packages/app-lib/.sqlx/query-91c09c88e89aadbf34fd823f119ca83c2626f097de53ec537f59b76fdb21eccb.json b/packages/app-lib/.sqlx/query-91c09c88e89aadbf34fd823f119ca83c2626f097de53ec537f59b76fdb21eccb.json
new file mode 100644
index 0000000000..8e3e5f818d
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-91c09c88e89aadbf34fd823f119ca83c2626f097de53ec537f59b76fdb21eccb.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\t\tINSERT INTO synced_game_option_values\n\t\t\t\t\t(option_id, kind, raw_key, canonical_type,\n\t\t\t\t\t canonical_value_json, value_codec, seeded, revision, origin,\n\t\t\t\t\t source_game_version, source_instance_id, updated_at)\n\t\t\t\tVALUES (?, ?, ?, ?, ?, ?, 1, ?, 'app_editor', ?, NULL, ?)\n\t\t\t\tON CONFLICT(option_id) DO UPDATE SET\n\t\t\t\t\tkind = excluded.kind, raw_key = excluded.raw_key,\n\t\t\t\t\tcanonical_type = excluded.canonical_type,\n\t\t\t\t\tcanonical_value_json = excluded.canonical_value_json,\n\t\t\t\t\tvalue_codec = excluded.value_codec, seeded = 1,\n\t\t\t\t\trevision = excluded.revision, origin = 'app_editor',\n\t\t\t\t\tsource_game_version = NULL, source_instance_id = NULL,\n\t\t\t\t\tupdated_at = excluded.updated_at\n\t\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 9
+    },
+    "nullable": []
+  },
+  "hash": "91c09c88e89aadbf34fd823f119ca83c2626f097de53ec537f59b76fdb21eccb"
+}
diff --git a/packages/app-lib/.sqlx/query-a83e168791306f30ee6f03a274398455c6db66d485824f27ab198c3f00de1770.json b/packages/app-lib/.sqlx/query-a83e168791306f30ee6f03a274398455c6db66d485824f27ab198c3f00de1770.json
index 96a168d698..42a1914756 100644
--- a/packages/app-lib/.sqlx/query-a83e168791306f30ee6f03a274398455c6db66d485824f27ab198c3f00de1770.json
+++ b/packages/app-lib/.sqlx/query-a83e168791306f30ee6f03a274398455c6db66d485824f27ab198c3f00de1770.json
@@ -3,17 +3,60 @@
   "query": "\n\t\tSELECT\n\t\t\tscreenshots.id,\n\t\t\tscreenshots.instance_id,\n\t\t\tscreenshots.file_name,\n\t\t\tscreenshots.content_hash,\n\t\t\tscreenshots.file_size,\n\t\t\tscreenshots.modified_at,\n\t\t\tscreenshots.created_at,\n\t\t\tmemberships.group_id AS \"group_id?\"\n\t\tFROM screenshots\n\t\tLEFT JOIN screenshot_group_memberships memberships\n\t\t\tON memberships.screenshot_id = screenshots.id\n\t\tWHERE screenshots.instance_id = ?\n\t\tORDER BY screenshots.file_name, screenshots.id\n\t\t",
   "describe": {
     "columns": [
-      { "name": "id", "ordinal": 0, "type_info": "Text" },
-      { "name": "instance_id", "ordinal": 1, "type_info": "Text" },
-      { "name": "file_name", "ordinal": 2, "type_info": "Text" },
-      { "name": "content_hash", "ordinal": 3, "type_info": "Text" },
-      { "name": "file_size", "ordinal": 4, "type_info": "Integer" },
-      { "name": "modified_at", "ordinal": 5, "type_info": "Integer" },
-      { "name": "created_at", "ordinal": 6, "type_info": "Integer" },
-      { "name": "group_id?", "ordinal": 7, "type_info": "Text" }
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "instance_id",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "file_name",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "content_hash",
+        "ordinal": 3,
+        "type_info": "Text"
+      },
+      {
+        "name": "file_size",
+        "ordinal": 4,
+        "type_info": "Integer"
+      },
+      {
+        "name": "modified_at",
+        "ordinal": 5,
+        "type_info": "Integer"
+      },
+      {
+        "name": "created_at",
+        "ordinal": 6,
+        "type_info": "Integer"
+      },
+      {
+        "name": "group_id?",
+        "ordinal": 7,
+        "type_info": "Text"
+      }
     ],
-    "parameters": { "Right": 1 },
-    "nullable": [false, false, false, false, false, false, false, false]
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false
+    ]
   },
   "hash": "a83e168791306f30ee6f03a274398455c6db66d485824f27ab198c3f00de1770"
 }
diff --git a/packages/app-lib/.sqlx/query-aaaf087deec439148bc1aa7365913a985f60f680c77885917f560760b5818b71.json b/packages/app-lib/.sqlx/query-aaaf087deec439148bc1aa7365913a985f60f680c77885917f560760b5818b71.json
new file mode 100644
index 0000000000..9d86ed1c80
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-aaaf087deec439148bc1aa7365913a985f60f680c77885917f560760b5818b71.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\tINSERT INTO synced_game_option_preferences\n\t\t\t\t(option_id, enabled, source, revision)\n\t\t\tVALUES (?, 1, 'discovery_default', ?)\n\t\t\tON CONFLICT(option_id) DO NOTHING\n\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": []
+  },
+  "hash": "aaaf087deec439148bc1aa7365913a985f60f680c77885917f560760b5818b71"
+}
diff --git a/packages/app-lib/.sqlx/query-aabd92c612d1c2b66c50385cb7a513dca33a6931b29489f59afddfc325d6258a.json b/packages/app-lib/.sqlx/query-aabd92c612d1c2b66c50385cb7a513dca33a6931b29489f59afddfc325d6258a.json
new file mode 100644
index 0000000000..62468c4072
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-aabd92c612d1c2b66c50385cb7a513dca33a6931b29489f59afddfc325d6258a.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tINSERT INTO synced_game_option_state (singleton, revision, catalog_revision)\n\t\tVALUES (1, 0, ?)\n\t\tON CONFLICT(singleton) DO UPDATE SET\n\t\t\tcatalog_revision = excluded.catalog_revision\n\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": []
+  },
+  "hash": "aabd92c612d1c2b66c50385cb7a513dca33a6931b29489f59afddfc325d6258a"
+}
diff --git a/packages/app-lib/.sqlx/query-b6583d5f711af94f3f21c0fbd6d1f2783cbdd25a4c65031de3c0b2ed78acc0a2.json b/packages/app-lib/.sqlx/query-b6583d5f711af94f3f21c0fbd6d1f2783cbdd25a4c65031de3c0b2ed78acc0a2.json
new file mode 100644
index 0000000000..98379f4567
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-b6583d5f711af94f3f21c0fbd6d1f2783cbdd25a4c65031de3c0b2ed78acc0a2.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tDELETE FROM instance_sync_checkpoints\n\t\tWHERE instance_id = ? AND feature = ?\n\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": []
+  },
+  "hash": "b6583d5f711af94f3f21c0fbd6d1f2783cbdd25a4c65031de3c0b2ed78acc0a2"
+}
diff --git a/packages/app-lib/.sqlx/query-c4c56a28a27c15ef48df89f5145b977c166ea70f3ec8f5a2aa8f067fa2f44733.json b/packages/app-lib/.sqlx/query-c4c56a28a27c15ef48df89f5145b977c166ea70f3ec8f5a2aa8f067fa2f44733.json
new file mode 100644
index 0000000000..e66fc41ac2
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-c4c56a28a27c15ef48df89f5145b977c166ea70f3ec8f5a2aa8f067fa2f44733.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\tINSERT INTO synced_game_option_preferences\n\t\t\t\t(option_id, enabled, source, revision)\n\t\t\tVALUES (?, ?, 'catalog_default', ?)\n\t\t\tON CONFLICT(option_id) DO NOTHING\n\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": []
+  },
+  "hash": "c4c56a28a27c15ef48df89f5145b977c166ea70f3ec8f5a2aa8f067fa2f44733"
+}
diff --git a/packages/app-lib/.sqlx/query-c640d4a60e6eb04fb484e3c99bfed581944cc9d9c335d1bc1c070863f93b276f.json b/packages/app-lib/.sqlx/query-c640d4a60e6eb04fb484e3c99bfed581944cc9d9c335d1bc1c070863f93b276f.json
new file mode 100644
index 0000000000..4cd45d9eb4
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-c640d4a60e6eb04fb484e3c99bfed581944cc9d9c335d1bc1c070863f93b276f.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tINSERT INTO sync_feature_settings\n\t\t\t(feature, globally_enabled, new_instance_default)\n\t\tVALUES ('game_options', 1, 1)\n\t\tON CONFLICT(feature) DO UPDATE SET globally_enabled = 1\n\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": []
+  },
+  "hash": "c640d4a60e6eb04fb484e3c99bfed581944cc9d9c335d1bc1c070863f93b276f"
+}
diff --git a/packages/app-lib/.sqlx/query-c6eb6fd3bd76b37eacf442bdc1a0ce434011c2e6bf3b76e0f8dd7d162ebb95ae.json b/packages/app-lib/.sqlx/query-c6eb6fd3bd76b37eacf442bdc1a0ce434011c2e6bf3b76e0f8dd7d162ebb95ae.json
new file mode 100644
index 0000000000..6f8f90cc3f
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-c6eb6fd3bd76b37eacf442bdc1a0ce434011c2e6bf3b76e0f8dd7d162ebb95ae.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tUPDATE synced_game_option_state\n\t\tSET revision = ?, catalog_revision = ?\n\t\tWHERE singleton = 1\n\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": []
+  },
+  "hash": "c6eb6fd3bd76b37eacf442bdc1a0ce434011c2e6bf3b76e0f8dd7d162ebb95ae"
+}
diff --git a/packages/app-lib/.sqlx/query-d125cb88ef6a465b49ae207f5abf5fe9c28436566c4d7b74bbcb9a82cb553959.json b/packages/app-lib/.sqlx/query-d125cb88ef6a465b49ae207f5abf5fe9c28436566c4d7b74bbcb9a82cb553959.json
new file mode 100644
index 0000000000..49ede7fd95
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-d125cb88ef6a465b49ae207f5abf5fe9c28436566c4d7b74bbcb9a82cb553959.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\t\tINSERT INTO synced_game_option_preferences\n\t\t\t\t\t(option_id, enabled, source, revision)\n\t\t\t\tVALUES (?, ?, 'catalog_default', 1)\n\t\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": []
+  },
+  "hash": "d125cb88ef6a465b49ae207f5abf5fe9c28436566c4d7b74bbcb9a82cb553959"
+}
diff --git a/packages/app-lib/.sqlx/query-d642bafe7282bde2908f9add0ad8ee2852552b5b06a38deb6311a3bf2098cee8.json b/packages/app-lib/.sqlx/query-d642bafe7282bde2908f9add0ad8ee2852552b5b06a38deb6311a3bf2098cee8.json
new file mode 100644
index 0000000000..bcc43e347e
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-d642bafe7282bde2908f9add0ad8ee2852552b5b06a38deb6311a3bf2098cee8.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\t\tUPDATE synced_game_option_state\n\t\t\t\tSET revision = ?, catalog_revision = ?\n\t\t\t\tWHERE singleton = 1\n\t\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": []
+  },
+  "hash": "d642bafe7282bde2908f9add0ad8ee2852552b5b06a38deb6311a3bf2098cee8"
+}
diff --git a/packages/app-lib/.sqlx/query-d808d8eded7c18861d5e865bda7d55605696d030a31be35669d8d0ee129c3f49.json b/packages/app-lib/.sqlx/query-d808d8eded7c18861d5e865bda7d55605696d030a31be35669d8d0ee129c3f49.json
new file mode 100644
index 0000000000..2a540dc417
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-d808d8eded7c18861d5e865bda7d55605696d030a31be35669d8d0ee129c3f49.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tUPDATE instance_sync_checkpoints\n\t\tSET status = 'ready', link_mode = NULL\n\t\tWHERE instance_id = ? AND feature = ? AND variant = ?\n\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": []
+  },
+  "hash": "d808d8eded7c18861d5e865bda7d55605696d030a31be35669d8d0ee129c3f49"
+}
diff --git a/packages/app-lib/.sqlx/query-ec00a599037bcf5fb080eb0f7cab1beaaca1254a4abcf2955c7af3bc5086f9cc.json b/packages/app-lib/.sqlx/query-ec00a599037bcf5fb080eb0f7cab1beaaca1254a4abcf2955c7af3bc5086f9cc.json
new file mode 100644
index 0000000000..c62a0ff0ca
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-ec00a599037bcf5fb080eb0f7cab1beaaca1254a4abcf2955c7af3bc5086f9cc.json
@@ -0,0 +1,20 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\tSELECT globally_enabled AS \"globally_enabled!: bool\"\n\t\tFROM sync_feature_settings\n\t\tWHERE feature = 'game_options'\n\t\t",
+  "describe": {
+    "columns": [
+      {
+        "name": "globally_enabled!: bool",
+        "ordinal": 0,
+        "type_info": "Integer"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "ec00a599037bcf5fb080eb0f7cab1beaaca1254a4abcf2955c7af3bc5086f9cc"
+}
diff --git a/packages/app-lib/.sqlx/query-fc51a02b2fa872f4b105b0eb25f9103b04b9e94bbd663ec205002e3ab2ff6756.json b/packages/app-lib/.sqlx/query-fc51a02b2fa872f4b105b0eb25f9103b04b9e94bbd663ec205002e3ab2ff6756.json
new file mode 100644
index 0000000000..1b53825df0
--- /dev/null
+++ b/packages/app-lib/.sqlx/query-fc51a02b2fa872f4b105b0eb25f9103b04b9e94bbd663ec205002e3ab2ff6756.json
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n\t\t\tINSERT INTO synced_game_option_values\n\t\t\t\t(option_id, kind, raw_key, canonical_type,\n\t\t\t\t canonical_value_json, value_codec, seeded, revision, origin,\n\t\t\t\t source_game_version, source_instance_id, updated_at)\n\t\t\tVALUES (?, 'external', ?, 'external_raw', ?, 'exact_raw',\n\t\t\t\t1, ?, 'source_seed', ?, ?, ?)\n\t\t\tON CONFLICT(option_id) DO UPDATE SET\n\t\t\t\traw_key = excluded.raw_key,\n\t\t\t\tcanonical_value_json = excluded.canonical_value_json,\n\t\t\t\tseeded = 1, revision = excluded.revision,\n\t\t\t\torigin = 'source_seed',\n\t\t\t\tsource_game_version = excluded.source_game_version,\n\t\t\t\tsource_instance_id = excluded.source_instance_id,\n\t\t\t\tupdated_at = excluded.updated_at\n\t\t\t",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 7
+    },
+    "nullable": []
+  },
+  "hash": "fc51a02b2fa872f4b105b0eb25f9103b04b9e94bbd663ec205002e3ab2ff6756"
+}
diff --git a/packages/app-lib/migrations/20260827120000_game-options-sync.sql b/packages/app-lib/migrations/20260827120000_game-options-sync.sql
new file mode 100644
index 0000000000..93529e7502
--- /dev/null
+++ b/packages/app-lib/migrations/20260827120000_game-options-sync.sql
@@ -0,0 +1,65 @@
+-- Game-settings sync starts off. The user must choose which instance supplies
+-- the initial values before it can be enabled.
+INSERT INTO sync_feature_settings
+	(feature, globally_enabled, new_instance_default)
+VALUES ('game_options', 0, 1);
+
+INSERT INTO instance_sync_preferences (instance_id, feature, enabled)
+SELECT id, 'game_options', 0
+FROM instances;
+
+-- Tracks changes to the shared values. The catalog revision changes when we add
+-- or update support for Minecraft versions.
+CREATE TABLE synced_game_option_state (
+	singleton INTEGER PRIMARY KEY NOT NULL CHECK (singleton = 1),
+	revision INTEGER NOT NULL CHECK (revision >= 0),
+	catalog_revision INTEGER NOT NULL CHECK (catalog_revision >= 1)
+);
+
+-- Stores the value shared for each setting, including settings added by mods.
+-- A NULL value means the setting was found but has no shared value yet.
+CREATE TABLE synced_game_option_values (
+	option_id TEXT PRIMARY KEY NOT NULL,
+	kind TEXT NOT NULL CHECK (kind IN ('vanilla', 'external')),
+	raw_key TEXT,
+	canonical_type TEXT NOT NULL,
+	canonical_value_json TEXT,
+	value_codec TEXT NOT NULL,
+	seeded INTEGER NOT NULL CHECK (seeded IN (0, 1)),
+	revision INTEGER NOT NULL CHECK (revision >= 0),
+	origin TEXT NOT NULL CHECK (origin IN ('app_editor', 'instance', 'source_seed')),
+	source_game_version TEXT,
+	source_instance_id TEXT,
+	updated_at INTEGER NOT NULL
+);
+
+-- Stores which settings the user chose to sync. This is separate from the values
+-- so turning a setting off does not forget its last value.
+CREATE TABLE synced_game_option_preferences (
+	option_id TEXT PRIMARY KEY NOT NULL,
+	enabled INTEGER NOT NULL CHECK (enabled IN (0, 1)),
+	source TEXT NOT NULL CHECK (source IN ('catalog_default', 'discovery_default', 'user')),
+	revision INTEGER NOT NULL CHECK (revision >= 0)
+);
+
+-- Keeps the options.txt supplied by the installed modpack. After a pack update,
+-- the user's shared settings are applied to this file again.
+CREATE TABLE instance_game_option_pack_bases (
+	instance_id TEXT PRIMARY KEY NOT NULL,
+	pack_version_id TEXT,
+	source TEXT NOT NULL CHECK (source IN ('client_overrides', 'overrides', 'none')),
+	sha1 TEXT,
+	encoding TEXT,
+	document BLOB,
+	FOREIGN KEY (instance_id) REFERENCES instances (id) ON DELETE CASCADE
+);
+
+-- Temporarily keeps the local options.txt while the installer removes the old
+-- pack. It is restored when the new pack does not include its own options.txt.
+CREATE TABLE instance_game_option_update_state (
+	instance_id TEXT PRIMARY KEY NOT NULL,
+	had_file INTEGER NOT NULL CHECK (had_file IN (0, 1)),
+	sha1 TEXT,
+	document BLOB,
+	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 1b5f1baf68..7b7f198c07 100644
--- a/packages/app-lib/src/api/instance.rs
+++ b/packages/app-lib/src/api/instance.rs
@@ -91,6 +91,30 @@ 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::game_options::{
+    CanonicalValue as GameOptionCanonicalValue, EditableGameSetting,
+    GameOptionCompatibility, GameOptionCompatibilityBucket,
+    GameOptionCompatibilityReason, GameOptionCompatibilityStatus,
+    GameOptionEditorChoice, GameOptionEditorDefinition, GameOptionKind,
+    GameOptionMappingKind, GameOptionValidationIssue, GameOptionValueState,
+    GameOptionsPackSource, GameOptionsSourceCandidate, GameOptionsSourceIssue,
+    GameSettingCategory, GameSettingChange, GameSettingsEditorState,
+    SaveGameSettingsResult, UpdateGameSettingsRequest,
+    apply_launcher_overrides as apply_game_options_launcher_overrides,
+    capture_pack_base as capture_game_options_pack_base,
+    get_config as get_synced_game_options_config,
+    get_local_config as get_local_game_options_config,
+    list_sync_sources as list_game_options_sync_sources,
+    preview_local_changes as preview_local_game_option_changes,
+    preview_changes as preview_synced_game_option_changes,
+    save_local_changes as save_local_game_option_changes,
+    save_changes as save_synced_game_option_changes,
+    sync_before_launch as sync_game_options_before_launch,
+};
+pub(crate) use self::synced_options::game_options::{
+    shared_fullscreen_value, sync_all_participating_instances,
+    update_shared_fullscreen_from_app,
+};
 pub use self::synced_options::{
     GlobalSyncedOptions, SyncedOptionCapability, SyncedOptionJoinAction,
     SyncedOptionJoinPreview, SyncedOptionJoinResolution, SyncedOptionsOverview,
@@ -103,7 +127,7 @@ pub use self::synced_options::{
 pub(crate) use self::synced_options::{
     monitor_persisted_processes, prepare_instance_update,
     reconcile_changed_file as reconcile_synced_option_file,
-    remove_generated_instance_files,
+    reconcile_instance_after_pack_update, remove_generated_instance_files,
 };
 pub use self::synced_options::{
     reconcile_all as reconcile_all_synced_options,
diff --git a/packages/app-lib/src/api/instance/run.rs b/packages/app-lib/src/api/instance/run.rs
index 17de3a88f3..25626c1db3 100644
--- a/packages/app-lib/src/api/instance/run.rs
+++ b/packages/app-lib/src/api/instance/run.rs
@@ -2,6 +2,7 @@ use super::content::get_projects;
 use crate::server_address::ServerAddress;
 use crate::state::{
     Credentials, InstanceLink, ProcessMetadata, Settings, State,
+    game_options_sync_is_enabled, load_game_option_preferences,
 };
 use crate::util::fetch;
 use crate::util::io::IOError;
@@ -67,6 +68,19 @@ async fn run_credentials(
                 "Tried to run a nonexistent instance {instance_id}!"
             ))
         })?;
+    let instance_sync_preferences =
+        crate::state::instances::adapters::sqlite::instance_rows::get_instance_sync_preferences(
+            instance_id,
+            &state.pool,
+        )
+        .await?;
+    let fullscreen_is_shared = game_options_sync_is_enabled(&state.pool)
+        .await?
+        && instance_sync_preferences.game_options
+        && load_game_option_preferences(&state.pool)
+            .await?
+            .get("fullscreen")
+            .is_some_and(|preference| preference.enabled);
     if crate::state::instances::adapters::sqlite::instance_rows::is_instance_quarantined(
         instance_id,
         &state.pool,
@@ -214,7 +228,7 @@ async fn run_credentials(
     let mut mc_set_options: Vec<(String, String)> = vec![];
     if let Some(fullscreen) = context.launch_overrides.force_fullscreen {
         mc_set_options.push(("fullscreen".to_string(), fullscreen.to_string()));
-    } else if settings.force_fullscreen {
+    } else if settings.force_fullscreen && !fullscreen_is_shared {
         mc_set_options.push(("fullscreen".to_string(), "true".to_string()));
     }
 
diff --git a/packages/app-lib/src/api/instance/synced_options/files.rs b/packages/app-lib/src/api/instance/synced_options/files.rs
index 92c457894b..23ff80fc41 100644
--- a/packages/app-lib/src/api/instance/synced_options/files.rs
+++ b/packages/app-lib/src/api/instance/synced_options/files.rs
@@ -87,6 +87,7 @@ pub(in crate::api::instance) fn instance_option_enabled(
     option: SyncedOption,
 ) -> bool {
     match option {
+        SyncedOption::GameOptions => metadata.synced_options.game_options,
         SyncedOption::CommandHistory => metadata.synced_options.command_history,
         SyncedOption::MultiplayerServers => {
             metadata.synced_options.multiplayer_servers
@@ -217,6 +218,28 @@ pub(in crate::api::instance) async fn finish_checkpoint(
     Ok(())
 }
 
+pub(in crate::api::instance) async fn finish_plain_checkpoint(
+    instance_id: &str,
+    option: SyncedOption,
+    variant: &str,
+    state: &State,
+) -> crate::Result<()> {
+    let option_name = option.as_str();
+    sqlx::query!(
+        "
+		UPDATE instance_sync_checkpoints
+		SET status = 'ready', link_mode = NULL
+		WHERE instance_id = ? AND feature = ? AND variant = ?
+		",
+        instance_id,
+        option_name,
+        variant,
+    )
+    .execute(&state.pool)
+    .await?;
+    Ok(())
+}
+
 pub(in crate::api::instance) async fn checkpoint(
     instance_id: &str,
     option: SyncedOption,
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/api_types.rs b/packages/app-lib/src/api/instance/synced_options/game_options/api_types.rs
new file mode 100644
index 0000000000..478d3ddd9b
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/api_types.rs
@@ -0,0 +1,204 @@
+use crate::state::{CanonicalValue, GameOptionKind};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum GameOptionsSourceIssue {
+    InstallingOrUpdating,
+    UnsupportedVersion,
+    MissingOptionsFile,
+    NoSyncableSettings,
+    UnreadableOptionsFile,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct GameOptionsSourceCandidate {
+    pub source_id: String,
+    pub instance_id: String,
+    pub name: String,
+    pub icon_path: Option<String>,
+    pub game_version: Option<String>,
+    pub eligible: bool,
+    pub disabled_reason: Option<GameOptionsSourceIssue>,
+    pub recognized_setting_count: u32,
+    pub custom_setting_count: u32,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct GameSettingCategory {
+    pub id: String,
+    pub is_custom: bool,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct GameOptionEditorDefinition {
+    #[serde(rename = "type")]
+    pub type_: String,
+    pub min: Option<f64>,
+    pub max: Option<f64>,
+    pub step: Option<f64>,
+    pub unit: Option<String>,
+    pub choices: Vec<GameOptionEditorChoice>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct GameOptionEditorChoice {
+    pub value: String,
+}
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum GameOptionCompatibilityStatus {
+    Ready,
+    Deferred,
+    WaitingForFile,
+    WaitingForBase,
+    NotAvailable,
+    UnsupportedValue,
+    Unmappable,
+    CatalogUncovered,
+    Controlled,
+    Degraded,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum GameOptionMappingKind {
+    Direct,
+    Legacy,
+    Migrated,
+    Lossless,
+    Lossy,
+}
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum GameOptionCompatibilityReason {
+    LauncherControlled,
+    CatalogUncovered,
+    InspectionFailed,
+    WaitingForOptionsFile,
+    UnsupportedValue,
+    MigratesOnWrite,
+    WaitingForCompatibleBase,
+    MissingSetting,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct GameOptionCompatibilityBucket {
+    pub instance_count: u32,
+    pub write_keys: Vec<String>,
+    pub eventual_keys: Vec<String>,
+    pub game_versions: Vec<String>,
+    pub status: GameOptionCompatibilityStatus,
+    pub mapping: Option<GameOptionMappingKind>,
+    pub reason: Option<GameOptionCompatibilityReason>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct GameOptionCompatibility {
+    pub total_participating: u32,
+    pub will_receive: u32,
+    pub write_now: u32,
+    pub left_local: u32,
+    pub buckets: Vec<GameOptionCompatibilityBucket>,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum GameOptionValueState {
+    Canonical,
+    UniformLocal,
+    Mixed,
+    Unset,
+    Invalid,
+}
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum GameOptionValidationIssue {
+    LocalValueNeedsSaving,
+    MissingValue,
+    NoCompatibleInstances,
+    InvalidValue,
+    ChangedSinceOpened,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct EditableGameSetting {
+    pub option_id: String,
+    pub category_id: String,
+    pub kind: GameOptionKind,
+    pub raw_key: Option<String>,
+    pub sync_enabled: bool,
+    pub canonical_value: Option<CanonicalValue>,
+    pub value_state: GameOptionValueState,
+    pub option_revision: u64,
+    pub editor: GameOptionEditorDefinition,
+    pub compatibility: GameOptionCompatibility,
+    pub validation_error: Option<GameOptionValidationIssue>,
+    pub controlled: bool,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct GameSettingsEditorState {
+    pub summary_revision: String,
+    pub canonical_revision: u64,
+    pub catalog_revision: u32,
+    pub total_participating: u32,
+    pub categories: Vec<GameSettingCategory>,
+    pub settings: Vec<EditableGameSetting>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct UpdateGameSettingsRequest {
+    pub expected_summary_revision: String,
+    pub expected_canonical_revision: u64,
+    pub expected_catalog_revision: u32,
+    pub changes: Vec<GameSettingChange>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct GameSettingChange {
+    pub option_id: String,
+    pub base_option_revision: u64,
+    pub sync_enabled: Option<bool>,
+    #[serde(
+        default,
+        with = "serde_with::rust::double_option",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub canonical_value: Option<Option<CanonicalValue>>,
+}
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+pub struct SaveGameSettingsResult {
+    pub state: Option<GameSettingsEditorState>,
+    pub applied: u32,
+    pub migrated: u32,
+    pub deferred: u32,
+    pub unsupported: u32,
+    pub failed: u32,
+    pub conflicts: Vec<String>,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) enum SyncOutcome {
+    Applied,
+    Migrated,
+    Unchanged,
+    Deferred,
+    WaitingForFile,
+}
+
+pub(super) fn canonical_values_equal(
+    left: &CanonicalValue,
+    right: &CanonicalValue,
+) -> bool {
+    match (left, right) {
+        (CanonicalValue::Decimal(left), CanonicalValue::Decimal(right)) => {
+            left.parse::<f64>().ok() == right.parse::<f64>().ok()
+        }
+        _ => left == right,
+    }
+}
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/catalog/README.md b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/README.md
new file mode 100644
index 0000000000..1bc263fbcf
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/README.md
@@ -0,0 +1,758 @@
+# Minecraft `options.txt` history
+
+Generated using `optionstxt_diff_calc.py` in `scripts` folder.
+
+## Summary
+
+|   # | Version                        | Supported keys | Fresh keys | Supported + | Supported − | Type Δ |  Fresh + | Fresh − |
+| --: | ------------------------------ | -------------: | ---------: | ----------: | ----------: | -----: | -------: | ------: |
+|   1 | <code>1.0</code>               |             32 |         32 |    baseline |           — |      — | baseline |       — |
+|   2 | <code>1.1</code>               |             33 |         33 |           1 |           0 |      0 |        1 |       0 |
+|   3 | <code>1.2.1</code>             |             33 |         33 |           0 |           0 |      0 |        0 |       0 |
+|   4 | <code>1.2.2</code>             |             33 |         33 |           0 |           0 |      0 |        0 |       0 |
+|   5 | <code>1.2.3</code>             |             33 |         33 |           0 |           0 |      0 |        0 |       0 |
+|   6 | <code>1.2.4</code>             |             33 |         33 |           0 |           0 |      0 |        0 |       0 |
+|   7 | <code>1.2.5</code>             |             33 |         33 |           0 |           0 |      0 |        0 |       0 |
+|   8 | <code>1.3.1</code>             |             43 |         43 |          10 |           0 |      0 |       10 |       0 |
+|   9 | <code>1.3.2</code>             |             44 |         44 |           1 |           0 |      0 |        1 |       0 |
+|  10 | <code>1.4.2</code>             |             47 |         47 |           3 |           0 |      0 |        3 |       0 |
+|  11 | <code>1.4.4</code>             |             48 |         48 |           1 |           0 |      0 |        1 |       0 |
+|  12 | <code>1.4.5</code>             |             48 |         48 |           0 |           0 |      0 |        0 |       0 |
+|  13 | <code>1.4.6</code>             |             51 |         51 |           3 |           0 |      0 |        3 |       0 |
+|  14 | <code>1.4.7</code>             |             51 |         51 |           0 |           0 |      0 |        0 |       0 |
+|  15 | <code>1.5.1</code>             |             55 |         55 |           4 |           0 |      1 |        4 |       0 |
+|  16 | <code>1.5.2</code>             |             55 |         55 |           0 |           0 |      0 |        0 |       0 |
+|  17 | <code>1.6.1</code>             |             55 |         55 |           0 |           0 |      0 |        0 |       0 |
+|  18 | <code>1.6.2</code>             |             55 |         55 |           0 |           0 |      0 |        0 |       0 |
+|  19 | <code>1.6.4</code>             |             55 |         55 |           0 |           0 |      0 |        0 |       0 |
+|  20 | <code>1.7.2</code>             |             81 |         81 |          31 |           5 |      0 |       31 |       5 |
+|  21 | <code>1.7.3</code>             |             97 |         97 |          16 |           0 |      0 |       16 |       0 |
+|  22 | <code>1.7.4</code>             |             97 |         97 |           0 |           0 |      0 |        0 |       0 |
+|  23 | <code>1.7.5</code>             |             97 |         97 |           0 |           0 |      0 |        0 |       0 |
+|  24 | <code>1.7.6</code>             |             96 |         96 |           0 |           1 |      0 |        0 |       1 |
+|  25 | <code>1.7.7</code>             |             96 |         96 |           0 |           0 |      0 |        0 |       0 |
+|  26 | <code>1.7.8</code>             |             96 |         96 |           0 |           0 |      0 |        0 |       0 |
+|  27 | <code>1.7.9</code>             |             96 |         96 |           0 |           0 |      0 |        0 |       0 |
+|  28 | <code>1.7.10</code>            |             96 |         96 |           0 |           0 |      0 |        0 |       0 |
+|  29 | <code>1.8</code>               |            104 |        104 |          12 |           4 |      0 |       12 |       4 |
+|  30 | <code>1.8.1</code>             |            106 |        106 |           2 |           0 |      1 |        2 |       0 |
+|  31 | <code>1.8.2</code>             |            106 |        106 |           0 |           0 |      0 |        0 |       0 |
+|  32 | <code>1.8.3</code>             |            106 |        106 |           0 |           0 |      0 |        0 |       0 |
+|  33 | <code>1.8.4</code>             |            106 |        106 |           0 |           0 |      0 |        0 |       0 |
+|  34 | <code>1.8.5</code>             |            106 |        106 |           0 |           0 |      0 |        0 |       0 |
+|  35 | <code>1.8.6</code>             |            106 |        106 |           0 |           0 |      0 |        0 |       0 |
+|  36 | <code>1.8.7</code>             |            106 |        106 |           0 |           0 |      0 |        0 |       0 |
+|  37 | <code>1.8.8</code>             |            107 |        107 |           1 |           0 |      0 |        1 |       0 |
+|  38 | <code>1.8.9</code>             |            108 |        108 |           1 |           0 |      0 |        1 |       0 |
+|  39 | <code>1.9</code>               |             97 |         97 |           5 |          16 |      0 |        5 |      16 |
+|  40 | <code>1.9.1</code>             |             98 |         98 |           1 |           0 |      0 |        1 |       0 |
+|  41 | <code>1.9.2</code>             |             98 |         98 |           0 |           0 |      0 |        0 |       0 |
+|  42 | <code>1.9.3</code>             |             98 |         98 |           0 |           0 |      0 |        0 |       0 |
+|  43 | <code>1.9.4</code>             |             98 |         98 |           0 |           0 |      0 |        0 |       0 |
+|  44 | <code>1.10</code>              |            100 |        100 |           2 |           0 |      0 |        2 |       0 |
+|  45 | <code>1.10.1</code>            |            100 |        100 |           0 |           0 |      0 |        0 |       0 |
+|  46 | <code>1.10.2</code>            |            100 |        100 |           0 |           0 |      0 |        0 |       0 |
+|  47 | <code>1.11</code>              |            100 |        100 |           0 |           0 |      0 |        0 |       0 |
+|  48 | <code>1.11.1</code>            |            100 |        100 |           0 |           0 |      0 |        0 |       0 |
+|  49 | <code>1.11.2</code>            |            100 |        100 |           0 |           0 |      0 |        0 |       0 |
+|  50 | <code>1.12</code>              |            104 |        104 |           5 |           1 |      0 |        5 |       1 |
+|  51 | <code>1.12.1</code>            |            104 |        104 |           0 |           0 |      0 |        0 |       0 |
+|  52 | <code>1.12.2</code>            |            104 |        104 |           0 |           0 |      0 |        0 |       0 |
+|  53 | <code>1.13</code>              |            108 |        107 |           5 |           1 |      1 |        4 |       1 |
+|  54 | <code>1.13.1</code>            |            108 |        107 |           0 |           0 |      0 |        0 |       0 |
+|  55 | <code>1.13.2</code>            |            108 |        107 |           0 |           0 |      0 |        0 |       0 |
+|  56 | <code>1.14</code>              |            108 |        106 |           3 |           3 |      0 |        3 |       4 |
+|  57 | <code>1.14.1</code>            |            108 |        106 |           0 |           0 |      0 |        0 |       0 |
+|  58 | <code>1.14.2</code>            |            108 |        106 |           0 |           0 |      0 |        0 |       0 |
+|  59 | <code>1.14.3</code>            |            108 |        106 |           0 |           0 |      0 |        0 |       0 |
+|  60 | <code>1.14.4</code>            |            109 |        107 |           1 |           0 |      0 |        1 |       0 |
+|  61 | <code>1.15</code>              |            111 |        109 |           2 |           0 |      0 |        2 |       0 |
+|  62 | <code>1.15.1</code>            |            111 |        109 |           0 |           0 |      0 |        0 |       0 |
+|  63 | <code>1.15.2</code>            |            112 |        110 |           1 |           0 |      0 |        1 |       0 |
+|  64 | <code>1.16</code>              |            118 |        114 |           6 |           0 |      0 |        6 |       2 |
+|  65 | <code>1.16.1</code>            |            118 |        114 |           0 |           0 |      0 |        0 |       0 |
+|  66 | <code>1.16.2</code>            |            120 |        116 |           2 |           0 |      0 |        2 |       0 |
+|  67 | <code>1.16.3</code>            |            120 |        116 |           0 |           0 |      0 |        0 |       0 |
+|  68 | <code>1.16.4</code>            |            123 |        119 |           3 |           0 |      0 |        3 |       0 |
+|  69 | <code>1.16.5</code>            |            123 |        119 |           0 |           0 |      0 |        0 |       0 |
+|  70 | <code>1.17</code>              |            125 |        121 |           2 |           0 |      0 |        2 |       0 |
+|  71 | <code>1.17.1</code>            |            125 |        121 |           0 |           0 |      0 |        0 |       0 |
+|  72 | <code>1.18</code>              |            130 |        126 |           6 |           1 |      0 |        6 |       1 |
+|  73 | <code>1.18.1</code>            |            130 |        126 |           0 |           0 |      0 |        0 |       0 |
+|  74 | <code>1.18.2</code>            |            131 |        127 |           1 |           0 |      0 |        1 |       0 |
+|  75 | <code>1.19</code>              |            134 |        130 |           4 |           1 |      1 |        4 |       1 |
+|  76 | <code>1.19.1</code>            |            134 |        130 |           0 |           0 |      1 |        0 |       0 |
+|  77 | <code>1.19.2</code>            |            134 |        130 |           0 |           0 |      0 |        0 |       0 |
+|  78 | <code>1.19.3</code>            |            136 |        132 |           3 |           1 |      1 |        3 |       1 |
+|  79 | <code>1.19.4</code>            |            141 |        137 |           6 |           1 |      0 |        6 |       1 |
+|  80 | <code>1.20</code>              |            141 |        137 |           0 |           0 |      0 |        0 |       0 |
+|  81 | <code>1.20.1</code>            |            141 |        137 |           0 |           0 |      0 |        0 |       0 |
+|  82 | <code>1.20.2</code>            |            142 |        138 |           1 |           0 |      0 |        1 |       0 |
+|  83 | <code>1.20.3</code>            |            143 |        139 |           1 |           0 |      0 |        1 |       0 |
+|  84 | <code>1.20.4</code>            |            143 |        139 |           0 |           0 |      0 |        0 |       0 |
+|  85 | <code>1.20.5</code>            |            144 |        140 |           2 |           1 |      0 |        2 |       1 |
+|  86 | <code>1.20.6</code>            |            144 |        140 |           0 |           0 |      0 |        0 |       0 |
+|  87 | <code>1.21</code>              |            144 |        140 |           0 |           0 |      1 |        0 |       0 |
+|  88 | <code>1.21.1</code>            |            144 |        140 |           0 |           0 |      0 |        0 |       0 |
+|  89 | <code>1.21.2</code>            |            146 |        142 |           3 |           1 |      0 |        3 |       1 |
+|  90 | <code>1.21.3</code>            |            146 |        142 |           0 |           0 |      0 |        0 |       0 |
+|  91 | <code>1.21.4</code>            |            146 |        142 |           0 |           0 |      0 |        0 |       0 |
+|  92 | <code>1.21.5</code>            |            147 |        143 |           1 |           0 |      0 |        1 |       0 |
+|  93 | <code>1.21.6</code>            |            152 |        148 |           5 |           0 |      0 |        5 |       0 |
+|  94 | <code>1.21.7</code>            |            152 |        148 |           0 |           0 |      0 |        0 |       0 |
+|  95 | <code>1.21.8</code>            |            152 |        148 |           0 |           0 |      0 |        0 |       0 |
+|  96 | <code>1.21.9</code>            |            159 |        155 |           7 |           0 |      0 |        7 |       0 |
+|  97 | <code>1.21.10</code>           |            159 |        155 |           0 |           0 |      0 |        0 |       0 |
+|  98 | <code>1.21.11</code>           |            191 |        185 |          32 |           0 |      0 |       32 |       2 |
+|  99 | <code>26.1</code>              |            193 |        187 |           2 |           0 |      0 |        2 |       0 |
+| 100 | <code>26.1.1</code>            |            193 |        187 |           0 |           0 |      0 |        0 |       0 |
+| 101 | <code>26.1.2</code>            |            193 |        187 |           0 |           0 |      0 |        0 |       0 |
+| 102 | <code>26.2</code>              |            196 |        190 |           4 |           1 |      0 |        4 |       1 |
+| 103 | <code>26.3 (26.3-pre-1)</code> |            200 |        194 |           5 |           1 |      0 |        5 |       1 |
+
+## Changes
+
+<details>
+<summary>1.0 (baseline)</summary>
+
+- Baseline supported entries: <code>advancedOpengl</code>, <code>anaglyph3d</code>, <code>ao</code>, <code>bobView</code>, <code>clouds</code>, <code>difficulty</code>, <code>fancyGraphics</code>, <code>fov</code>, <code>fpsLimit</code>, <code>gamma</code>, <code>guiScale</code>, <code>invertYMouse</code>, <code>key_key.attack</code>, <code>key_key.back</code>, <code>key_key.chat</code>, <code>key_key.drop</code>, <code>key_key.forward</code>, <code>key_key.inventory</code>, <code>key_key.jump</code>, <code>key_key.left</code>, <code>key_key.pickItem</code>, <code>key_key.playerlist</code>, <code>key_key.right</code>, <code>key_key.sneak</code>, <code>key_key.use</code>, <code>lastServer</code>, <code>mouseSensitivity</code>, <code>music</code>, <code>particles</code>, <code>skin</code>, <code>sound</code>, <code>viewDistance</code>
+- Baseline fresh-file entries: <code>advancedOpengl</code>, <code>anaglyph3d</code>, <code>ao</code>, <code>bobView</code>, <code>clouds</code>, <code>difficulty</code>, <code>fancyGraphics</code>, <code>fov</code>, <code>fpsLimit</code>, <code>gamma</code>, <code>guiScale</code>, <code>invertYMouse</code>, <code>key_key.attack</code>, <code>key_key.back</code>, <code>key_key.chat</code>, <code>key_key.drop</code>, <code>key_key.forward</code>, <code>key_key.inventory</code>, <code>key_key.jump</code>, <code>key_key.left</code>, <code>key_key.pickItem</code>, <code>key_key.playerlist</code>, <code>key_key.right</code>, <code>key_key.sneak</code>, <code>key_key.use</code>, <code>lastServer</code>, <code>mouseSensitivity</code>, <code>music</code>, <code>particles</code>, <code>skin</code>, <code>sound</code>, <code>viewDistance</code>
+
+</details>
+
+<details>
+<summary>1.1 (from 1.0)</summary>
+
+- Supported entries added: <code>lang</code>
+- Fresh file added: <code>lang</code>
+
+</details>
+
+<details>
+<summary>1.3.1 (from 1.2.5)</summary>
+
+- Supported entries added: <code>chatColors</code>, <code>chatLinks</code>, <code>chatLinksPrompt</code>, <code>chatOpacity</code>, <code>chatVisibility</code>, <code>enableVsync</code>, <code>fullscreen</code>, <code>key_key.command</code>, <code>serverTextures</code>, <code>snooperEnabled</code>
+- Fresh file added: <code>chatColors</code>, <code>chatLinks</code>, <code>chatLinksPrompt</code>, <code>chatOpacity</code>, <code>chatVisibility</code>, <code>enableVsync</code>, <code>fullscreen</code>, <code>key_key.command</code>, <code>serverTextures</code>, <code>snooperEnabled</code>
+
+</details>
+
+<details>
+<summary>1.3.2 (from 1.3.1)</summary>
+
+- Supported entries added: <code>hideServerAddress</code>
+- Fresh file added: <code>hideServerAddress</code>
+
+</details>
+
+<details>
+<summary>1.4.2 (from 1.3.2)</summary>
+
+- Supported entries added: <code>advancedItemTooltips</code>, <code>pauseOnLostFocus</code>, <code>showCape</code>
+- Fresh file added: <code>advancedItemTooltips</code>, <code>pauseOnLostFocus</code>, <code>showCape</code>
+
+</details>
+
+<details>
+<summary>1.4.4 (from 1.4.2)</summary>
+
+- Supported entries added: <code>touchscreen</code>
+- Fresh file added: <code>touchscreen</code>
+
+</details>
+
+<details>
+<summary>1.4.6 (from 1.4.5)</summary>
+
+- Supported entries added: <code>heldItemTooltips</code>, <code>overrideHeight</code>, <code>overrideWidth</code>
+- Fresh file added: <code>heldItemTooltips</code>, <code>overrideHeight</code>, <code>overrideWidth</code>
+
+</details>
+
+<details>
+<summary>1.5.1 (from 1.4.7)</summary>
+
+- Supported entries added: <code>chatHeightFocused</code>, <code>chatHeightUnfocused</code>, <code>chatScale</code>, <code>chatWidth</code>
+- Type changed: <code>ao</code> — <code>boolean</code> → <code>enum</code>
+- Fresh file added: <code>chatHeightFocused</code>, <code>chatHeightUnfocused</code>, <code>chatScale</code>, <code>chatWidth</code>
+
+</details>
+
+<details>
+<summary>1.7.2 (from 1.6.4)</summary>
+
+- Supported entries added: <code>anisotropicFiltering</code>, <code>fboEnable</code>, <code>forceUnicodeFont</code>, <code>key_key.hotbar.1</code>, <code>key_key.hotbar.2</code>, <code>key_key.hotbar.3</code>, <code>key_key.hotbar.4</code>, <code>key_key.hotbar.5</code>, <code>key_key.hotbar.6</code>, <code>key_key.hotbar.7</code>, <code>key_key.hotbar.8</code>, <code>key_key.hotbar.9</code>, <code>key_key.screenshot</code>, <code>key_key.smoothCamera</code>, <code>key_key.sprint</code>, <code>key_key.togglePerspective</code>, <code>maxFps</code>, <code>mipmapLevels</code>, <code>renderDistance</code>, <code>resourcePacks</code>, <code>saturation</code>, <code>showInventoryAchievementHint</code>, <code>soundCategory_ambient</code>, <code>soundCategory_block</code>, <code>soundCategory_hostile</code>, <code>soundCategory_master</code>, <code>soundCategory_music</code>, <code>soundCategory_neutral</code>, <code>soundCategory_player</code>, <code>soundCategory_record</code>, <code>soundCategory_weather</code>
+- Supported entries removed: <code>fpsLimit</code>, <code>music</code>, <code>skin</code>, <code>sound</code>, <code>viewDistance</code>
+- Fresh file added: <code>anisotropicFiltering</code>, <code>fboEnable</code>, <code>forceUnicodeFont</code>, <code>key_key.hotbar.1</code>, <code>key_key.hotbar.2</code>, <code>key_key.hotbar.3</code>, <code>key_key.hotbar.4</code>, <code>key_key.hotbar.5</code>, <code>key_key.hotbar.6</code>, <code>key_key.hotbar.7</code>, <code>key_key.hotbar.8</code>, <code>key_key.hotbar.9</code>, <code>key_key.screenshot</code>, <code>key_key.smoothCamera</code>, <code>key_key.sprint</code>, <code>key_key.togglePerspective</code>, <code>maxFps</code>, <code>mipmapLevels</code>, <code>renderDistance</code>, <code>resourcePacks</code>, <code>saturation</code>, <code>showInventoryAchievementHint</code>, <code>soundCategory_ambient</code>, <code>soundCategory_block</code>, <code>soundCategory_hostile</code>, <code>soundCategory_master</code>, <code>soundCategory_music</code>, <code>soundCategory_neutral</code>, <code>soundCategory_player</code>, <code>soundCategory_record</code>, <code>soundCategory_weather</code>
+- Fresh file removed: <code>fpsLimit</code>, <code>music</code>, <code>skin</code>, <code>sound</code>, <code>viewDistance</code>
+
+</details>
+
+<details>
+<summary>1.7.3 (from 1.7.2)</summary>
+
+- Supported entries added: <code>key_key.fullscreen</code>, <code>key_key.streamCommercial</code>, <code>key_key.streamPauseUnpause</code>, <code>key_key.streamStartStop</code>, <code>key_key.streamToggleMic</code>, <code>streamBytesPerPixel</code>, <code>streamChatEnabled</code>, <code>streamChatUserFilter</code>, <code>streamCompression</code>, <code>streamFps</code>, <code>streamKbps</code>, <code>streamMicToggleBehavior</code>, <code>streamMicVolume</code>, <code>streamPreferredServer</code>, <code>streamSendMetadata</code>, <code>streamSystemVolume</code>
+- Fresh file added: <code>key_key.fullscreen</code>, <code>key_key.streamCommercial</code>, <code>key_key.streamPauseUnpause</code>, <code>key_key.streamStartStop</code>, <code>key_key.streamToggleMic</code>, <code>streamBytesPerPixel</code>, <code>streamChatEnabled</code>, <code>streamChatUserFilter</code>, <code>streamCompression</code>, <code>streamFps</code>, <code>streamKbps</code>, <code>streamMicToggleBehavior</code>, <code>streamMicVolume</code>, <code>streamPreferredServer</code>, <code>streamSendMetadata</code>, <code>streamSystemVolume</code>
+
+</details>
+
+<details>
+<summary>1.7.6 (from 1.7.5)</summary>
+
+- Supported entries removed: <code>serverTextures</code>
+- Fresh file removed: <code>serverTextures</code>
+
+</details>
+
+<details>
+<summary>1.8 (from 1.7.10)</summary>
+
+- Supported entries added: <code>allowBlockAlternatives</code>, <code>key_key.spectatorOutlines</code>, <code>modelPart_cape</code>, <code>modelPart_hat</code>, <code>modelPart_jacket</code>, <code>modelPart_left_pants_leg</code>, <code>modelPart_left_sleeve</code>, <code>modelPart_right_pants_leg</code>, <code>modelPart_right_sleeve</code>, <code>reducedDebugInfo</code>, <code>renderClouds</code>, <code>useVbo</code>
+- Supported entries removed: <code>advancedOpengl</code>, <code>anisotropicFiltering</code>, <code>clouds</code>, <code>showCape</code>
+- Fresh file added: <code>allowBlockAlternatives</code>, <code>key_key.spectatorOutlines</code>, <code>modelPart_cape</code>, <code>modelPart_hat</code>, <code>modelPart_jacket</code>, <code>modelPart_left_pants_leg</code>, <code>modelPart_left_sleeve</code>, <code>modelPart_right_pants_leg</code>, <code>modelPart_right_sleeve</code>, <code>reducedDebugInfo</code>, <code>renderClouds</code>, <code>useVbo</code>
+- Fresh file removed: <code>advancedOpengl</code>, <code>anisotropicFiltering</code>, <code>clouds</code>, <code>showCape</code>
+
+</details>
+
+<details>
+<summary>1.8.1 (from 1.8)</summary>
+
+- Supported entries added: <code>entityShadows</code>, <code>useNativeTransport</code>
+- Type changed: <code>renderClouds</code> — <code>boolean</code> → <code>enum</code>
+- Fresh file added: <code>entityShadows</code>, <code>useNativeTransport</code>
+
+</details>
+
+<details>
+<summary>1.8.8 (from 1.8.7)</summary>
+
+- Supported entries added: <code>incompatibleResourcePacks</code>
+- Fresh file added: <code>incompatibleResourcePacks</code>
+
+</details>
+
+<details>
+<summary>1.8.9 (from 1.8.8)</summary>
+
+- Supported entries added: <code>realmsNotifications</code>
+- Fresh file added: <code>realmsNotifications</code>
+
+</details>
+
+<details>
+<summary>1.9 (from 1.8.9)</summary>
+
+- Supported entries added: <code>attackIndicator</code>, <code>key_key.swapHands</code>, <code>mainHand</code>, <code>showSubtitles</code>, <code>soundCategory_voice</code>
+- Supported entries removed: <code>allowBlockAlternatives</code>, <code>key_key.streamCommercial</code>, <code>key_key.streamPauseUnpause</code>, <code>key_key.streamStartStop</code>, <code>key_key.streamToggleMic</code>, <code>streamBytesPerPixel</code>, <code>streamChatEnabled</code>, <code>streamChatUserFilter</code>, <code>streamCompression</code>, <code>streamFps</code>, <code>streamKbps</code>, <code>streamMicToggleBehavior</code>, <code>streamMicVolume</code>, <code>streamPreferredServer</code>, <code>streamSendMetadata</code>, <code>streamSystemVolume</code>
+- Fresh file added: <code>attackIndicator</code>, <code>key_key.swapHands</code>, <code>mainHand</code>, <code>showSubtitles</code>, <code>soundCategory_voice</code>
+- Fresh file removed: <code>allowBlockAlternatives</code>, <code>key_key.streamCommercial</code>, <code>key_key.streamPauseUnpause</code>, <code>key_key.streamStartStop</code>, <code>key_key.streamToggleMic</code>, <code>streamBytesPerPixel</code>, <code>streamChatEnabled</code>, <code>streamChatUserFilter</code>, <code>streamCompression</code>, <code>streamFps</code>, <code>streamKbps</code>, <code>streamMicToggleBehavior</code>, <code>streamMicVolume</code>, <code>streamPreferredServer</code>, <code>streamSendMetadata</code>, <code>streamSystemVolume</code>
+
+</details>
+
+<details>
+<summary>1.9.1 (from 1.9)</summary>
+
+- Supported entries added: <code>enableWeakAttacks</code>
+- Fresh file added: <code>enableWeakAttacks</code>
+
+</details>
+
+<details>
+<summary>1.10 (from 1.9.4)</summary>
+
+- Supported entries added: <code>autoJump</code>, <code>version</code>
+- Fresh file added: <code>autoJump</code>, <code>version</code>
+
+</details>
+
+<details>
+<summary>1.12 (from 1.11.2)</summary>
+
+- Supported entries added: <code>key_key.advancements</code>, <code>key_key.loadToolbarActivator</code>, <code>key_key.saveToolbarActivator</code>, <code>narrator</code>, <code>tutorialStep</code>
+- Supported entries removed: <code>showInventoryAchievementHint</code>
+- Fresh file added: <code>key_key.advancements</code>, <code>key_key.loadToolbarActivator</code>, <code>key_key.saveToolbarActivator</code>, <code>narrator</code>, <code>tutorialStep</code>
+- Fresh file removed: <code>showInventoryAchievementHint</code>
+
+</details>
+
+<details>
+<summary>1.13 (from 1.12.2)</summary>
+
+- Supported entries added: <code>autoSuggestions</code>, <code>biomeBlendRadius</code>, <code>fullscreenResolution</code>, <code>glDebugVerbosity</code>, <code>mouseWheelSensitivity</code>
+- Supported entries removed: <code>anaglyph3d</code>
+- Type changed: <code>guiScale</code> — <code>enum</code> → <code>integer</code>
+- Fresh file added: <code>autoSuggestions</code>, <code>biomeBlendRadius</code>, <code>glDebugVerbosity</code>, <code>mouseWheelSensitivity</code>
+- Fresh file removed: <code>anaglyph3d</code>
+
+</details>
+
+<details>
+<summary>1.14 (from 1.13.2)</summary>
+
+- Supported entries added: <code>backgroundForChatOnly</code>, <code>discrete_mouse_scroll</code>, <code>textBackgroundOpacity</code>
+- Supported entries removed: <code>enableWeakAttacks</code>, <code>fboEnable</code>, <code>saturation</code>
+- Fresh file added: <code>backgroundForChatOnly</code>, <code>discrete_mouse_scroll</code>, <code>textBackgroundOpacity</code>
+- Fresh file removed: <code>enableWeakAttacks</code>, <code>fboEnable</code>, <code>saturation</code>, <code>useVbo</code>
+
+</details>
+
+<details>
+<summary>1.14.4 (from 1.14.3)</summary>
+
+- Supported entries added: <code>rawMouseInput</code>
+- Fresh file added: <code>rawMouseInput</code>
+
+</details>
+
+<details>
+<summary>1.15 (from 1.14.4)</summary>
+
+- Supported entries added: <code>toggleCrouch</code>, <code>toggleSprint</code>
+- Fresh file added: <code>toggleCrouch</code>, <code>toggleSprint</code>
+
+</details>
+
+<details>
+<summary>1.15.2 (from 1.15.1)</summary>
+
+- Supported entries added: <code>skipMultiplayerWarning</code>
+- Fresh file added: <code>skipMultiplayerWarning</code>
+
+</details>
+
+<details>
+<summary>1.16 (from 1.15.2)</summary>
+
+- Supported entries added: <code>chatDelay</code>, <code>chatLineSpacing</code>, <code>entityDistanceScaling</code>, <code>graphicsMode</code>, <code>key_key.swapOffhand</code>, <code>syncChunkWrites</code>
+- Fresh file added: <code>chatDelay</code>, <code>chatLineSpacing</code>, <code>entityDistanceScaling</code>, <code>graphicsMode</code>, <code>key_key.swapOffhand</code>, <code>syncChunkWrites</code>
+- Fresh file removed: <code>fancyGraphics</code>, <code>key_key.swapHands</code>
+
+</details>
+
+<details>
+<summary>1.16.2 (from 1.16.1)</summary>
+
+- Supported entries added: <code>fovEffectScale</code>, <code>screenEffectScale</code>
+- Fresh file added: <code>fovEffectScale</code>, <code>screenEffectScale</code>
+
+</details>
+
+<details>
+<summary>1.16.4 (from 1.16.3)</summary>
+
+- Supported entries added: <code>hideMatchedNames</code>, <code>joinedFirstServer</code>, <code>key_key.socialInteractions</code>
+- Fresh file added: <code>hideMatchedNames</code>, <code>joinedFirstServer</code>, <code>key_key.socialInteractions</code>
+
+</details>
+
+<details>
+<summary>1.17 (from 1.16.5)</summary>
+
+- Supported entries added: <code>darkMojangStudiosBackground</code>, <code>hideBundleTutorial</code>
+- Fresh file added: <code>darkMojangStudiosBackground</code>, <code>hideBundleTutorial</code>
+
+</details>
+
+<details>
+<summary>1.18 (from 1.17.1)</summary>
+
+- Supported entries added: <code>allowServerListing</code>, <code>hideLightningFlashes</code>, <code>prioritizeChunkUpdates</code>, <code>showAutosaveIndicator</code>, <code>simulationDistance</code>, <code>soundDevice</code>
+- Supported entries removed: <code>snooperEnabled</code>
+- Fresh file added: <code>allowServerListing</code>, <code>hideLightningFlashes</code>, <code>prioritizeChunkUpdates</code>, <code>showAutosaveIndicator</code>, <code>simulationDistance</code>, <code>soundDevice</code>
+- Fresh file removed: <code>snooperEnabled</code>
+
+</details>
+
+<details>
+<summary>1.18.2 (from 1.18.1)</summary>
+
+- Supported entries added: <code>skipRealms32bitWarning</code>
+- Fresh file added: <code>skipRealms32bitWarning</code>
+
+</details>
+
+<details>
+<summary>1.19 (from 1.18.2)</summary>
+
+- Supported entries added: <code>chatPreview</code>, <code>darknessEffectScale</code>, <code>directionalAudio</code>, <code>onlyShowSecureChat</code>
+- Supported entries removed: <code>difficulty</code>
+- Type changed: <code>fov</code> — <code>decimal</code> → <code>integer</code>
+- Fresh file added: <code>chatPreview</code>, <code>darknessEffectScale</code>, <code>directionalAudio</code>, <code>onlyShowSecureChat</code>
+- Fresh file removed: <code>difficulty</code>
+
+</details>
+
+<details>
+<summary>1.19.1 (from 1.19)</summary>
+
+- Type changed: <code>chatPreview</code> — <code>boolean</code> → <code>enum</code>
+
+</details>
+
+<details>
+<summary>1.19.3 (from 1.19.2)</summary>
+
+- Supported entries added: <code>operatorItemsTab</code>, <code>panoramaScrollSpeed</code>, <code>telemetryOptInExtra</code>
+- Supported entries removed: <code>chatPreview</code>
+- Type changed: <code>ao</code> — <code>enum</code> → <code>boolean</code>
+- Fresh file added: <code>operatorItemsTab</code>, <code>panoramaScrollSpeed</code>, <code>telemetryOptInExtra</code>
+- Fresh file removed: <code>chatPreview</code>
+
+</details>
+
+<details>
+<summary>1.19.4 (from 1.19.3)</summary>
+
+- Supported entries added: <code>damageTiltStrength</code>, <code>glintSpeed</code>, <code>glintStrength</code>, <code>highContrast</code>, <code>notificationDisplayTime</code>, <code>onboardAccessibility</code>
+- Supported entries removed: <code>heldItemTooltips</code>
+- Fresh file added: <code>damageTiltStrength</code>, <code>glintSpeed</code>, <code>glintStrength</code>, <code>highContrast</code>, <code>notificationDisplayTime</code>, <code>onboardAccessibility</code>
+- Fresh file removed: <code>heldItemTooltips</code>
+
+</details>
+
+<details>
+<summary>1.20.2 (from 1.20.1)</summary>
+
+- Supported entries added: <code>narratorHotkey</code>
+- Fresh file added: <code>narratorHotkey</code>
+
+</details>
+
+<details>
+<summary>1.20.3 (from 1.20.2)</summary>
+
+- Supported entries added: <code>hideSplashTexts</code>
+- Fresh file added: <code>hideSplashTexts</code>
+
+</details>
+
+<details>
+<summary>1.20.5 (from 1.20.4)</summary>
+
+- Supported entries added: <code>japaneseGlyphVariants</code>, <code>menuBackgroundBlurriness</code>
+- Supported entries removed: <code>skipRealms32bitWarning</code>
+- Fresh file added: <code>japaneseGlyphVariants</code>, <code>menuBackgroundBlurriness</code>
+- Fresh file removed: <code>skipRealms32bitWarning</code>
+
+</details>
+
+<details>
+<summary>1.21 (from 1.20.6)</summary>
+
+- Type changed: <code>menuBackgroundBlurriness</code> — <code>decimal</code> → <code>integer</code>
+
+</details>
+
+<details>
+<summary>1.21.2 (from 1.21.1)</summary>
+
+- Supported entries added: <code>highContrastBlockOutline</code>, <code>inactivityFpsLimit</code>, <code>rotateWithMinecart</code>
+- Supported entries removed: <code>hideBundleTutorial</code>
+- Fresh file added: <code>highContrastBlockOutline</code>, <code>inactivityFpsLimit</code>, <code>rotateWithMinecart</code>
+- Fresh file removed: <code>hideBundleTutorial</code>
+
+</details>
+
+<details>
+<summary>1.21.5 (from 1.21.4)</summary>
+
+- Supported entries added: <code>startedCleanly</code>
+- Fresh file added: <code>startedCleanly</code>
+
+</details>
+
+<details>
+<summary>1.21.6 (from 1.21.5)</summary>
+
+- Supported entries added: <code>cloudRange</code>, <code>key_key.quickActions</code>, <code>musicFrequency</code>, <code>showNowPlayingToast</code>, <code>soundCategory_ui</code>
+- Fresh file added: <code>cloudRange</code>, <code>key_key.quickActions</code>, <code>musicFrequency</code>, <code>showNowPlayingToast</code>, <code>soundCategory_ui</code>
+
+</details>
+
+<details>
+<summary>1.21.9 (from 1.21.8)</summary>
+
+- Supported entries added: <code>allowCursorChanges</code>, <code>invertXMouse</code>, <code>key_key.spectatorHotbar</code>, <code>saveChatDrafts</code>, <code>sprintWindow</code>, <code>toggleAttack</code>, <code>toggleUse</code>
+- Fresh file added: <code>allowCursorChanges</code>, <code>invertXMouse</code>, <code>key_key.spectatorHotbar</code>, <code>saveChatDrafts</code>, <code>sprintWindow</code>, <code>toggleAttack</code>, <code>toggleUse</code>
+
+</details>
+
+<details>
+<summary>1.21.11 (from 1.21.10)</summary>
+
+- Supported entries added: <code>chunkSectionFadeInTime</code>, <code>cutoutLeaves</code>, <code>graphicsPreset</code>, <code>improvedTransparency</code>, <code>key_key.debug.clearChat</code>, <code>key_key.debug.copyLocation</code>, <code>key_key.debug.copyRecreateCommand</code>, <code>key_key.debug.crash</code>, <code>key_key.debug.debugOptions</code>, <code>key_key.debug.dumpDynamicTextures</code>, <code>key_key.debug.dumpVersion</code>, <code>key_key.debug.focusPause</code>, <code>key_key.debug.fpsCharts</code>, <code>key_key.debug.modifier</code>, <code>key_key.debug.networkCharts</code>, <code>key_key.debug.overlay</code>, <code>key_key.debug.profiling</code>, <code>key_key.debug.profilingChart</code>, <code>key_key.debug.reloadChunk</code>, <code>key_key.debug.reloadResourcePacks</code>, <code>key_key.debug.showAdvancedTooltips</code>, <code>key_key.debug.showChunkBorders</code>, <code>key_key.debug.showHitboxes</code>, <code>key_key.debug.spectate</code>, <code>key_key.debug.switchGameMode</code>, <code>key_key.toggleGui</code>, <code>key_key.toggleSpectatorShaderEffects</code>, <code>maxAnisotropyBit</code>, <code>musicToast</code>, <code>textureFiltering</code>, <code>vignette</code>, <code>weatherRadius</code>
+- Fresh file added: <code>chunkSectionFadeInTime</code>, <code>cutoutLeaves</code>, <code>graphicsPreset</code>, <code>improvedTransparency</code>, <code>key_key.debug.clearChat</code>, <code>key_key.debug.copyLocation</code>, <code>key_key.debug.copyRecreateCommand</code>, <code>key_key.debug.crash</code>, <code>key_key.debug.debugOptions</code>, <code>key_key.debug.dumpDynamicTextures</code>, <code>key_key.debug.dumpVersion</code>, <code>key_key.debug.focusPause</code>, <code>key_key.debug.fpsCharts</code>, <code>key_key.debug.modifier</code>, <code>key_key.debug.networkCharts</code>, <code>key_key.debug.overlay</code>, <code>key_key.debug.profiling</code>, <code>key_key.debug.profilingChart</code>, <code>key_key.debug.reloadChunk</code>, <code>key_key.debug.reloadResourcePacks</code>, <code>key_key.debug.showAdvancedTooltips</code>, <code>key_key.debug.showChunkBorders</code>, <code>key_key.debug.showHitboxes</code>, <code>key_key.debug.spectate</code>, <code>key_key.debug.switchGameMode</code>, <code>key_key.toggleGui</code>, <code>key_key.toggleSpectatorShaderEffects</code>, <code>maxAnisotropyBit</code>, <code>musicToast</code>, <code>textureFiltering</code>, <code>vignette</code>, <code>weatherRadius</code>
+- Fresh file removed: <code>graphicsMode</code>, <code>showNowPlayingToast</code>
+
+</details>
+
+<details>
+<summary>26.1 (from 1.21.11)</summary>
+
+- Supported entries added: <code>exclusiveFullscreen</code>, <code>key_key.debug.lightmapTexture</code>
+- Fresh file added: <code>exclusiveFullscreen</code>, <code>key_key.debug.lightmapTexture</code>
+
+</details>
+
+<details>
+<summary>26.2 (from 26.1.2)</summary>
+
+- Supported entries added: <code>inGameNotification</code>, <code>key_key.friends</code>, <code>preferredGraphicsBackend</code>, <code>sharePresence</code>
+- Supported entries removed: <code>touchscreen</code>
+- Fresh file added: <code>inGameNotification</code>, <code>key_key.friends</code>, <code>preferredGraphicsBackend</code>, <code>sharePresence</code>
+- Fresh file removed: <code>touchscreen</code>
+
+</details>
+
+<details>
+<summary>26.3 (from 26.2)</summary>
+
+- Supported entries added: <code>ctrlClickEmulatesRightClick</code>, <code>debugGuiScale</code>, <code>key_key.debug.improvedTransparency</code>, <code>macFullscreenMenuVisibility</code>, <code>quitShortcuts</code>
+- Supported entries removed: <code>rawMouseInput</code>
+- Fresh file added: <code>ctrlClickEmulatesRightClick</code>, <code>debugGuiScale</code>, <code>key_key.debug.improvedTransparency</code>, <code>macFullscreenMenuVisibility</code>, <code>quitShortcuts</code>
+- Fresh file removed: <code>rawMouseInput</code>
+
+</details>
+
+## Option type history
+
+| Key                                               | Version range and type                                                                                                                         | Observed versions           |
+| ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------- |
+| <code>advancedItemTooltips</code>                 | <code>1.4.2–26.3</code>: <code>boolean</code>                                                                                                  | <code>1.4.2–26.3</code>     |
+| <code>advancedOpengl</code>                       | <code>1.0–1.7.10</code>: <code>boolean</code>                                                                                                  | <code>1.0–1.7.10</code>     |
+| <code>allowBlockAlternatives</code>               | <code>1.8–1.8.9</code>: <code>boolean</code>                                                                                                   | <code>1.8–1.8.9</code>      |
+| <code>allowCursorChanges</code>                   | <code>1.21.9–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.21.9–26.3</code>    |
+| <code>allowServerListing</code>                   | <code>1.18–26.3</code>: <code>boolean</code>                                                                                                   | <code>1.18–26.3</code>      |
+| <code>anaglyph3d</code>                           | <code>1.0–1.12.2</code>: <code>boolean</code>                                                                                                  | <code>1.0–1.12.2</code>     |
+| <code>anisotropicFiltering</code>                 | <code>1.7.2–1.7.10</code>: <code>integer</code>                                                                                                | <code>1.7.2–1.7.10</code>   |
+| <code>ao</code>                                   | <code>1.0–1.4.7</code>: <code>boolean</code><br><code>1.5.1–1.19.2</code>: <code>enum (0, 1, 2)</code><br><code>1.19.3–26.3</code>: <code>boolean</code> | <code>1.0–26.3</code>       |
+| <code>attackIndicator</code>                      | <code>1.9–26.3</code>: <code>enum (0, 1, 2)</code>                                                                                                       | <code>1.9–26.3</code>       |
+| <code>autoJump</code>                             | <code>1.10–26.3</code>: <code>boolean</code>                                                                                                   | <code>1.10–26.3</code>      |
+| <code>autoSuggestions</code>                      | <code>1.13–26.3</code>: <code>boolean</code>                                                                                                   | <code>1.13–26.3</code>      |
+| <code>backgroundForChatOnly</code>                | <code>1.14–26.3</code>: <code>boolean</code>                                                                                                   | <code>1.14–26.3</code>      |
+| <code>biomeBlendRadius</code>                     | <code>1.13–26.3</code>: <code>integer</code>                                                                                                   | <code>1.13–26.3</code>      |
+| <code>bobView</code>                              | <code>1.0–26.3</code>: <code>boolean</code>                                                                                                    | <code>1.0–26.3</code>       |
+| <code>chatColors</code>                           | <code>1.3.1–26.3</code>: <code>boolean</code>                                                                                                  | <code>1.3.1–26.3</code>     |
+| <code>chatDelay</code>                            | <code>1.16–26.3</code>: <code>decimal</code>                                                                                                   | <code>1.16–26.3</code>      |
+| <code>chatHeightFocused</code>                    | <code>1.5.1–26.3</code>: <code>decimal</code>                                                                                                  | <code>1.5.1–26.3</code>     |
+| <code>chatHeightUnfocused</code>                  | <code>1.5.1–26.3</code>: <code>decimal</code>                                                                                                  | <code>1.5.1–26.3</code>     |
+| <code>chatLineSpacing</code>                      | <code>1.16–26.3</code>: <code>decimal</code>                                                                                                   | <code>1.16–26.3</code>      |
+| <code>chatLinks</code>                            | <code>1.3.1–26.3</code>: <code>boolean</code>                                                                                                  | <code>1.3.1–26.3</code>     |
+| <code>chatLinksPrompt</code>                      | <code>1.3.1–26.3</code>: <code>boolean</code>                                                                                                  | <code>1.3.1–26.3</code>     |
+| <code>chatOpacity</code>                          | <code>1.3.1–26.3</code>: <code>decimal</code>                                                                                                  | <code>1.3.1–26.3</code>     |
+| <code>chatPreview</code>                          | <code>1.19</code>: <code>boolean</code><br><code>1.19.1–1.19.2</code>: <code>enum (0, 1, 2)</code>                                                       | <code>1.19–1.19.2</code>    |
+| <code>chatScale</code>                            | <code>1.5.1–26.3</code>: <code>decimal</code>                                                                                                  | <code>1.5.1–26.3</code>     |
+| <code>chatVisibility</code>                       | <code>1.3.1–26.3</code>: <code>enum (0, 1, 2)</code>                                                                                                     | <code>1.3.1–26.3</code>     |
+| <code>chatWidth</code>                            | <code>1.5.1–26.3</code>: <code>decimal</code>                                                                                                  | <code>1.5.1–26.3</code>     |
+| <code>chunkSectionFadeInTime</code>               | <code>1.21.11–26.3</code>: <code>decimal</code>                                                                                                | <code>1.21.11–26.3</code>   |
+| <code>cloudRange</code>                           | <code>1.21.6–26.3</code>: <code>integer</code>                                                                                                 | <code>1.21.6–26.3</code>    |
+| <code>clouds</code>                               | <code>1.0–1.7.10</code>: <code>boolean</code>                                                                                                  | <code>1.0–1.7.10</code>     |
+| <code>ctrlClickEmulatesRightClick</code>          | <code>26.3</code>: <code>boolean</code>                                                                                                        | <code>26.3</code>           |
+| <code>cutoutLeaves</code>                         | <code>1.21.11–26.3</code>: <code>boolean</code>                                                                                                | <code>1.21.11–26.3</code>   |
+| <code>damageTiltStrength</code>                   | <code>1.19.4–26.3</code>: <code>decimal</code>                                                                                                 | <code>1.19.4–26.3</code>    |
+| <code>darkMojangStudiosBackground</code>          | <code>1.17–26.3</code>: <code>boolean</code>                                                                                                   | <code>1.17–26.3</code>      |
+| <code>darknessEffectScale</code>                  | <code>1.19–26.3</code>: <code>decimal</code>                                                                                                   | <code>1.19–26.3</code>      |
+| <code>debugGuiScale</code>                        | <code>26.3</code>: <code>integer</code>                                                                                                        | <code>26.3</code>           |
+| <code>difficulty</code>                           | <code>1.0–1.18.2</code>: <code>enum (0, 1, 2, 3)</code>                                                                                                     | <code>1.0–1.18.2</code>     |
+| <code>directionalAudio</code>                     | <code>1.19–26.3</code>: <code>boolean</code>                                                                                                   | <code>1.19–26.3</code>      |
+| <code>discrete_mouse_scroll</code>                | <code>1.14–26.3</code>: <code>boolean</code>                                                                                                   | <code>1.14–26.3</code>      |
+| <code>enableVsync</code>                          | <code>1.3.1–26.3</code>: <code>boolean</code>                                                                                                  | <code>1.3.1–26.3</code>     |
+| <code>enableWeakAttacks</code>                    | <code>1.9.1–1.13.2</code>: <code>boolean</code>                                                                                                | <code>1.9.1–1.13.2</code>   |
+| <code>entityDistanceScaling</code>                | <code>1.16–26.3</code>: <code>decimal</code>                                                                                                   | <code>1.16–26.3</code>      |
+| <code>entityShadows</code>                        | <code>1.8.1–26.3</code>: <code>boolean</code>                                                                                                  | <code>1.8.1–26.3</code>     |
+| <code>exclusiveFullscreen</code>                  | <code>26.1–26.3</code>: <code>boolean</code>                                                                                                   | <code>26.1–26.3</code>      |
+| <code>fancyGraphics</code>                        | <code>1.0–26.3</code>: <code>boolean</code>                                                                                                    | <code>1.0–1.15.2</code>     |
+| <code>fboEnable</code>                            | <code>1.7.2–1.13.2</code>: <code>boolean</code>                                                                                                | <code>1.7.2–1.13.2</code>   |
+| <code>forceUnicodeFont</code>                     | <code>1.7.2–26.3</code>: <code>boolean</code>                                                                                                  | <code>1.7.2–26.3</code>     |
+| <code>fov</code>                                  | <code>1.0–1.18.2</code>: <code>decimal</code><br><code>1.19–26.3</code>: <code>integer</code>                                                  | <code>1.0–26.3</code>       |
+| <code>fovEffectScale</code>                       | <code>1.16.2–26.3</code>: <code>decimal</code>                                                                                                 | <code>1.16.2–26.3</code>    |
+| <code>fpsLimit</code>                             | <code>1.0–1.6.4</code>: <code>enum (0, 1, 2)</code>                                                                                                      | <code>1.0–1.6.4</code>      |
+| <code>fullscreen</code>                           | <code>1.3.1–26.3</code>: <code>boolean</code>                                                                                                  | <code>1.3.1–26.3</code>     |
+| <code>fullscreenResolution</code>                 | <code>1.13–26.3</code>: <code>compound</code>                                                                                                  | —                           |
+| <code>gamma</code>                                | <code>1.0–26.3</code>: <code>decimal</code>                                                                                                    | <code>1.0–26.3</code>       |
+| <code>glDebugVerbosity</code>                     | <code>1.13–26.3</code>: <code>integer</code>                                                                                                   | <code>1.13–26.3</code>      |
+| <code>glintSpeed</code>                           | <code>1.19.4–26.3</code>: <code>decimal</code>                                                                                                 | <code>1.19.4–26.3</code>    |
+| <code>glintStrength</code>                        | <code>1.19.4–26.3</code>: <code>decimal</code>                                                                                                 | <code>1.19.4–26.3</code>    |
+| <code>graphicsMode</code>                         | <code>1.16–26.3</code>: <code>enum (0, 1, 2)</code>                                                                                                      | <code>1.16–1.21.10</code>   |
+| <code>graphicsPreset</code>                       | <code>1.21.11–26.3</code>: <code>enum (custom, fabulous, fancy, fast)</code>                                                                                                   | <code>1.21.11–26.3</code>   |
+| <code>guiScale</code>                             | <code>1.0–1.12.2</code>: <code>enum (0, 1, 2, 3)</code><br><code>1.13–26.3</code>: <code>integer</code>                                                     | <code>1.0–26.3</code>       |
+| <code>heldItemTooltips</code>                     | <code>1.4.6–1.19.3</code>: <code>boolean</code>                                                                                                | <code>1.4.6–1.19.3</code>   |
+| <code>hideBundleTutorial</code>                   | <code>1.17–1.21.1</code>: <code>boolean</code>                                                                                                 | <code>1.17–1.21.1</code>    |
+| <code>hideLightningFlashes</code>                 | <code>1.18–26.3</code>: <code>boolean</code>                                                                                                   | <code>1.18–26.3</code>      |
+| <code>hideMatchedNames</code>                     | <code>1.16.4–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.16.4–26.3</code>    |
+| <code>hideServerAddress</code>                    | <code>1.3.2–26.3</code>: <code>boolean</code>                                                                                                  | <code>1.3.2–26.3</code>     |
+| <code>hideSplashTexts</code>                      | <code>1.20.3–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.20.3–26.3</code>    |
+| <code>highContrast</code>                         | <code>1.19.4–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.19.4–26.3</code>    |
+| <code>highContrastBlockOutline</code>             | <code>1.21.2–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.21.2–26.3</code>    |
+| <code>improvedTransparency</code>                 | <code>1.21.11–26.3</code>: <code>boolean</code>                                                                                                | <code>1.21.11–26.3</code>   |
+| <code>inGameNotification</code>                   | <code>26.2–26.3</code>: <code>boolean</code>                                                                                                   | <code>26.2–26.3</code>      |
+| <code>inactivityFpsLimit</code>                   | <code>1.21.2–26.3</code>: <code>enum (afk, minimized)</code>                                                                                                    | <code>1.21.2–26.3</code>    |
+| <code>incompatibleResourcePacks</code>            | <code>1.8.8–26.3</code>: <code>string_list</code>                                                                                              | <code>1.8.8–26.3</code>     |
+| <code>invertXMouse</code>                         | <code>1.21.9–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.21.9–26.3</code>    |
+| <code>invertYMouse</code>                         | <code>1.0–26.3</code>: <code>boolean</code>                                                                                                    | <code>1.0–26.3</code>       |
+| <code>japaneseGlyphVariants</code>                | <code>1.20.5–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.20.5–26.3</code>    |
+| <code>joinedFirstServer</code>                    | <code>1.16.4–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.16.4–26.3</code>    |
+| <code>key_key.advancements</code>                 | <code>1.12–26.3</code>: <code>key_binding</code>                                                                                               | <code>1.12–26.3</code>      |
+| <code>key_key.attack</code>                       | <code>1.0–26.3</code>: <code>key_binding</code>                                                                                                | <code>1.0–26.3</code>       |
+| <code>key_key.back</code>                         | <code>1.0–26.3</code>: <code>key_binding</code>                                                                                                | <code>1.0–26.3</code>       |
+| <code>key_key.chat</code>                         | <code>1.0–26.3</code>: <code>key_binding</code>                                                                                                | <code>1.0–26.3</code>       |
+| <code>key_key.command</code>                      | <code>1.3.1–26.3</code>: <code>key_binding</code>                                                                                              | <code>1.3.1–26.3</code>     |
+| <code>key_key.debug.clearChat</code>              | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.copyLocation</code>           | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.copyRecreateCommand</code>    | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.crash</code>                  | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.debugOptions</code>           | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.dumpDynamicTextures</code>    | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.dumpVersion</code>            | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.focusPause</code>             | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.fpsCharts</code>              | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.improvedTransparency</code>   | <code>26.3</code>: <code>key_binding</code>                                                                                                    | <code>26.3</code>           |
+| <code>key_key.debug.lightmapTexture</code>        | <code>26.1–26.3</code>: <code>key_binding</code>                                                                                               | <code>26.1–26.3</code>      |
+| <code>key_key.debug.modifier</code>               | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.networkCharts</code>          | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.overlay</code>                | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.profiling</code>              | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.profilingChart</code>         | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.reloadChunk</code>            | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.reloadResourcePacks</code>    | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.showAdvancedTooltips</code>   | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.showChunkBorders</code>       | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.showHitboxes</code>           | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.spectate</code>               | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.debug.switchGameMode</code>         | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.drop</code>                         | <code>1.0–26.3</code>: <code>key_binding</code>                                                                                                | <code>1.0–26.3</code>       |
+| <code>key_key.forward</code>                      | <code>1.0–26.3</code>: <code>key_binding</code>                                                                                                | <code>1.0–26.3</code>       |
+| <code>key_key.friends</code>                      | <code>26.2–26.3</code>: <code>key_binding</code>                                                                                               | <code>26.2–26.3</code>      |
+| <code>key_key.fullscreen</code>                   | <code>1.7.3–26.3</code>: <code>key_binding</code>                                                                                              | <code>1.7.3–26.3</code>     |
+| <code>key_key.hotbar.1</code>                     | <code>1.7.2–26.3</code>: <code>key_binding</code>                                                                                              | <code>1.7.2–26.3</code>     |
+| <code>key_key.hotbar.2</code>                     | <code>1.7.2–26.3</code>: <code>key_binding</code>                                                                                              | <code>1.7.2–26.3</code>     |
+| <code>key_key.hotbar.3</code>                     | <code>1.7.2–26.3</code>: <code>key_binding</code>                                                                                              | <code>1.7.2–26.3</code>     |
+| <code>key_key.hotbar.4</code>                     | <code>1.7.2–26.3</code>: <code>key_binding</code>                                                                                              | <code>1.7.2–26.3</code>     |
+| <code>key_key.hotbar.5</code>                     | <code>1.7.2–26.3</code>: <code>key_binding</code>                                                                                              | <code>1.7.2–26.3</code>     |
+| <code>key_key.hotbar.6</code>                     | <code>1.7.2–26.3</code>: <code>key_binding</code>                                                                                              | <code>1.7.2–26.3</code>     |
+| <code>key_key.hotbar.7</code>                     | <code>1.7.2–26.3</code>: <code>key_binding</code>                                                                                              | <code>1.7.2–26.3</code>     |
+| <code>key_key.hotbar.8</code>                     | <code>1.7.2–26.3</code>: <code>key_binding</code>                                                                                              | <code>1.7.2–26.3</code>     |
+| <code>key_key.hotbar.9</code>                     | <code>1.7.2–26.3</code>: <code>key_binding</code>                                                                                              | <code>1.7.2–26.3</code>     |
+| <code>key_key.inventory</code>                    | <code>1.0–26.3</code>: <code>key_binding</code>                                                                                                | <code>1.0–26.3</code>       |
+| <code>key_key.jump</code>                         | <code>1.0–26.3</code>: <code>key_binding</code>                                                                                                | <code>1.0–26.3</code>       |
+| <code>key_key.left</code>                         | <code>1.0–26.3</code>: <code>key_binding</code>                                                                                                | <code>1.0–26.3</code>       |
+| <code>key_key.loadToolbarActivator</code>         | <code>1.12–26.3</code>: <code>key_binding</code>                                                                                               | <code>1.12–26.3</code>      |
+| <code>key_key.pickItem</code>                     | <code>1.0–26.3</code>: <code>key_binding</code>                                                                                                | <code>1.0–26.3</code>       |
+| <code>key_key.playerlist</code>                   | <code>1.0–26.3</code>: <code>key_binding</code>                                                                                                | <code>1.0–26.3</code>       |
+| <code>key_key.quickActions</code>                 | <code>1.21.6–26.3</code>: <code>key_binding</code>                                                                                             | <code>1.21.6–26.3</code>    |
+| <code>key_key.right</code>                        | <code>1.0–26.3</code>: <code>key_binding</code>                                                                                                | <code>1.0–26.3</code>       |
+| <code>key_key.saveToolbarActivator</code>         | <code>1.12–26.3</code>: <code>key_binding</code>                                                                                               | <code>1.12–26.3</code>      |
+| <code>key_key.screenshot</code>                   | <code>1.7.2–26.3</code>: <code>key_binding</code>                                                                                              | <code>1.7.2–26.3</code>     |
+| <code>key_key.smoothCamera</code>                 | <code>1.7.2–26.3</code>: <code>key_binding</code>                                                                                              | <code>1.7.2–26.3</code>     |
+| <code>key_key.sneak</code>                        | <code>1.0–26.3</code>: <code>key_binding</code>                                                                                                | <code>1.0–26.3</code>       |
+| <code>key_key.socialInteractions</code>           | <code>1.16.4–26.3</code>: <code>key_binding</code>                                                                                             | <code>1.16.4–26.3</code>    |
+| <code>key_key.spectatorHotbar</code>              | <code>1.21.9–26.3</code>: <code>key_binding</code>                                                                                             | <code>1.21.9–26.3</code>    |
+| <code>key_key.spectatorOutlines</code>            | <code>1.8–26.3</code>: <code>key_binding</code>                                                                                                | <code>1.8–26.3</code>       |
+| <code>key_key.sprint</code>                       | <code>1.7.2–26.3</code>: <code>key_binding</code>                                                                                              | <code>1.7.2–26.3</code>     |
+| <code>key_key.streamCommercial</code>             | <code>1.7.3–1.8.9</code>: <code>key_binding</code>                                                                                             | <code>1.7.3–1.8.9</code>    |
+| <code>key_key.streamPauseUnpause</code>           | <code>1.7.3–1.8.9</code>: <code>key_binding</code>                                                                                             | <code>1.7.3–1.8.9</code>    |
+| <code>key_key.streamStartStop</code>              | <code>1.7.3–1.8.9</code>: <code>key_binding</code>                                                                                             | <code>1.7.3–1.8.9</code>    |
+| <code>key_key.streamToggleMic</code>              | <code>1.7.3–1.8.9</code>: <code>key_binding</code>                                                                                             | <code>1.7.3–1.8.9</code>    |
+| <code>key_key.swapHands</code>                    | <code>1.9–26.3</code>: <code>key_binding</code>                                                                                                | <code>1.9–1.15.2</code>     |
+| <code>key_key.swapOffhand</code>                  | <code>1.16–26.3</code>: <code>key_binding</code>                                                                                               | <code>1.16–26.3</code>      |
+| <code>key_key.toggleGui</code>                    | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.togglePerspective</code>            | <code>1.7.2–26.3</code>: <code>key_binding</code>                                                                                              | <code>1.7.2–26.3</code>     |
+| <code>key_key.toggleSpectatorShaderEffects</code> | <code>1.21.11–26.3</code>: <code>key_binding</code>                                                                                            | <code>1.21.11–26.3</code>   |
+| <code>key_key.use</code>                          | <code>1.0–26.3</code>: <code>key_binding</code>                                                                                                | <code>1.0–26.3</code>       |
+| <code>lang</code>                                 | <code>1.1–26.3</code>: <code>string</code>                                                                                                     | <code>1.1–26.3</code>       |
+| <code>lastServer</code>                           | <code>1.0–26.3</code>: <code>string</code>                                                                                                     | <code>1.0–26.3</code>       |
+| <code>macFullscreenMenuVisibility</code>          | <code>26.3</code>: <code>boolean</code>                                                                                                        | <code>26.3</code>           |
+| <code>mainHand</code>                             | <code>1.9–26.3</code>: <code>enum (left, right)</code>                                                                                                       | <code>1.9–26.3</code>       |
+| <code>maxAnisotropyBit</code>                     | <code>1.21.11–26.3</code>: <code>integer</code>                                                                                                | <code>1.21.11–26.3</code>   |
+| <code>maxFps</code>                               | <code>1.7.2–26.3</code>: <code>integer</code>                                                                                                  | <code>1.7.2–26.3</code>     |
+| <code>menuBackgroundBlurriness</code>             | <code>1.20.5–1.20.6</code>: <code>decimal</code><br><code>1.21–26.3</code>: <code>integer</code>                                               | <code>1.20.5–26.3</code>    |
+| <code>mipmapLevels</code>                         | <code>1.7.2–26.3</code>: <code>integer</code>                                                                                                  | <code>1.7.2–26.3</code>     |
+| <code>modelPart_cape</code>                       | <code>1.8–26.3</code>: <code>boolean</code>                                                                                                    | <code>1.8–26.3</code>       |
+| <code>modelPart_hat</code>                        | <code>1.8–26.3</code>: <code>boolean</code>                                                                                                    | <code>1.8–26.3</code>       |
+| <code>modelPart_jacket</code>                     | <code>1.8–26.3</code>: <code>boolean</code>                                                                                                    | <code>1.8–26.3</code>       |
+| <code>modelPart_left_pants_leg</code>             | <code>1.8–26.3</code>: <code>boolean</code>                                                                                                    | <code>1.8–26.3</code>       |
+| <code>modelPart_left_sleeve</code>                | <code>1.8–26.3</code>: <code>boolean</code>                                                                                                    | <code>1.8–26.3</code>       |
+| <code>modelPart_right_pants_leg</code>            | <code>1.8–26.3</code>: <code>boolean</code>                                                                                                    | <code>1.8–26.3</code>       |
+| <code>modelPart_right_sleeve</code>               | <code>1.8–26.3</code>: <code>boolean</code>                                                                                                    | <code>1.8–26.3</code>       |
+| <code>mouseSensitivity</code>                     | <code>1.0–26.3</code>: <code>decimal</code>                                                                                                    | <code>1.0–26.3</code>       |
+| <code>mouseWheelSensitivity</code>                | <code>1.13–26.3</code>: <code>decimal</code>                                                                                                   | <code>1.13–26.3</code>      |
+| <code>music</code>                                | <code>1.0–1.6.4</code>: <code>decimal</code>                                                                                                   | <code>1.0–1.6.4</code>      |
+| <code>musicFrequency</code>                       | <code>1.21.6–26.3</code>: <code>enum (CONSTANT, DEFAULT, FREQUENT)</code>                                                                                                    | <code>1.21.6–26.3</code>    |
+| <code>musicToast</code>                           | <code>1.21.11–26.3</code>: <code>enum (never, pause, pause_and_toast)</code>                                                                                                   | <code>1.21.11–26.3</code>   |
+| <code>narrator</code>                             | <code>1.12–26.3</code>: <code>enum (0, 1, 2, 3)</code>                                                                                                      | <code>1.12–26.3</code>      |
+| <code>narratorHotkey</code>                       | <code>1.20.2–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.20.2–26.3</code>    |
+| <code>notificationDisplayTime</code>              | <code>1.19.4–26.3</code>: <code>decimal</code>                                                                                                 | <code>1.19.4–26.3</code>    |
+| <code>onboardAccessibility</code>                 | <code>1.19.4–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.19.4–26.3</code>    |
+| <code>onlyShowSecureChat</code>                   | <code>1.19–26.3</code>: <code>boolean</code>                                                                                                   | <code>1.19–26.3</code>      |
+| <code>operatorItemsTab</code>                     | <code>1.19.3–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.19.3–26.3</code>    |
+| <code>overrideHeight</code>                       | <code>1.4.6–26.3</code>: <code>integer</code>                                                                                                  | <code>1.4.6–26.3</code>     |
+| <code>overrideWidth</code>                        | <code>1.4.6–26.3</code>: <code>integer</code>                                                                                                  | <code>1.4.6–26.3</code>     |
+| <code>panoramaScrollSpeed</code>                  | <code>1.19.3–26.3</code>: <code>decimal</code>                                                                                                 | <code>1.19.3–26.3</code>    |
+| <code>particles</code>                            | <code>1.0–26.3</code>: <code>enum (0, 1, 2)</code>                                                                                                       | <code>1.0–26.3</code>       |
+| <code>pauseOnLostFocus</code>                     | <code>1.4.2–26.3</code>: <code>boolean</code>                                                                                                  | <code>1.4.2–26.3</code>     |
+| <code>preferredGraphicsBackend</code>             | <code>26.2–26.3</code>: <code>enum (default, opengl, vulkan)</code>                                                                                                      | <code>26.2–26.3</code>      |
+| <code>prioritizeChunkUpdates</code>               | <code>1.18–26.3</code>: <code>enum (0, 1, 2)</code>                                                                                                      | <code>1.18–26.3</code>      |
+| <code>quitShortcuts</code>                        | <code>26.3</code>: <code>boolean</code>                                                                                                        | <code>26.3</code>           |
+| <code>rawMouseInput</code>                        | <code>1.14.4–26.2</code>: <code>boolean</code>                                                                                                 | <code>1.14.4–26.2</code>    |
+| <code>realmsNotifications</code>                  | <code>1.8.9–26.3</code>: <code>boolean</code>                                                                                                  | <code>1.8.9–26.3</code>     |
+| <code>reducedDebugInfo</code>                     | <code>1.8–26.3</code>: <code>boolean</code>                                                                                                    | <code>1.8–26.3</code>       |
+| <code>renderClouds</code>                         | <code>1.8</code>: <code>boolean</code><br><code>1.8.1–26.3</code>: <code>enum (false, fast, true)</code>                                                           | <code>1.8–26.3</code>       |
+| <code>renderDistance</code>                       | <code>1.7.2–26.3</code>: <code>integer</code>                                                                                                  | <code>1.7.2–26.3</code>     |
+| <code>resourcePacks</code>                        | <code>1.7.2–26.3</code>: <code>string_list</code>                                                                                              | <code>1.7.2–26.3</code>     |
+| <code>rotateWithMinecart</code>                   | <code>1.21.2–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.21.2–26.3</code>    |
+| <code>saturation</code>                           | <code>1.7.2–1.13.2</code>: <code>decimal</code>                                                                                                | <code>1.7.2–1.13.2</code>   |
+| <code>saveChatDrafts</code>                       | <code>1.21.9–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.21.9–26.3</code>    |
+| <code>screenEffectScale</code>                    | <code>1.16.2–26.3</code>: <code>decimal</code>                                                                                                 | <code>1.16.2–26.3</code>    |
+| <code>serverTextures</code>                       | <code>1.3.1–1.7.5</code>: <code>boolean</code>                                                                                                 | <code>1.3.1–1.7.5</code>    |
+| <code>sharePresence</code>                        | <code>26.2–26.3</code>: <code>enum (all, limited, none)</code>                                                                                                      | <code>26.2–26.3</code>      |
+| <code>showAutosaveIndicator</code>                | <code>1.18–26.3</code>: <code>boolean</code>                                                                                                   | <code>1.18–26.3</code>      |
+| <code>showCape</code>                             | <code>1.4.2–1.7.10</code>: <code>boolean</code>                                                                                                | <code>1.4.2–1.7.10</code>   |
+| <code>showInventoryAchievementHint</code>         | <code>1.7.2–1.11.2</code>: <code>boolean</code>                                                                                                | <code>1.7.2–1.11.2</code>   |
+| <code>showNowPlayingToast</code>                  | <code>1.21.6–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.21.6–1.21.10</code> |
+| <code>showSubtitles</code>                        | <code>1.9–26.3</code>: <code>boolean</code>                                                                                                    | <code>1.9–26.3</code>       |
+| <code>simulationDistance</code>                   | <code>1.18–26.3</code>: <code>integer</code>                                                                                                   | <code>1.18–26.3</code>      |
+| <code>skin</code>                                 | <code>1.0–1.6.4</code>: <code>string</code>                                                                                                    | <code>1.0–1.6.4</code>      |
+| <code>skipMultiplayerWarning</code>               | <code>1.15.2–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.15.2–26.3</code>    |
+| <code>skipRealms32bitWarning</code>               | <code>1.18.2–1.20.4</code>: <code>boolean</code>                                                                                               | <code>1.18.2–1.20.4</code>  |
+| <code>snooperEnabled</code>                       | <code>1.3.1–1.17.1</code>: <code>boolean</code>                                                                                                | <code>1.3.1–1.17.1</code>   |
+| <code>sound</code>                                | <code>1.0–1.6.4</code>: <code>decimal</code>                                                                                                   | <code>1.0–1.6.4</code>      |
+| <code>soundCategory_ambient</code>                | <code>1.7.2–26.3</code>: <code>decimal</code>                                                                                                  | <code>1.7.2–26.3</code>     |
+| <code>soundCategory_block</code>                  | <code>1.7.2–26.3</code>: <code>decimal</code>                                                                                                  | <code>1.7.2–26.3</code>     |
+| <code>soundCategory_hostile</code>                | <code>1.7.2–26.3</code>: <code>decimal</code>                                                                                                  | <code>1.7.2–26.3</code>     |
+| <code>soundCategory_master</code>                 | <code>1.7.2–26.3</code>: <code>decimal</code>                                                                                                  | <code>1.7.2–26.3</code>     |
+| <code>soundCategory_music</code>                  | <code>1.7.2–26.3</code>: <code>decimal</code>                                                                                                  | <code>1.7.2–26.3</code>     |
+| <code>soundCategory_neutral</code>                | <code>1.7.2–26.3</code>: <code>decimal</code>                                                                                                  | <code>1.7.2–26.3</code>     |
+| <code>soundCategory_player</code>                 | <code>1.7.2–26.3</code>: <code>decimal</code>                                                                                                  | <code>1.7.2–26.3</code>     |
+| <code>soundCategory_record</code>                 | <code>1.7.2–26.3</code>: <code>decimal</code>                                                                                                  | <code>1.7.2–26.3</code>     |
+| <code>soundCategory_ui</code>                     | <code>1.21.6–26.3</code>: <code>decimal</code>                                                                                                 | <code>1.21.6–26.3</code>    |
+| <code>soundCategory_voice</code>                  | <code>1.9–26.3</code>: <code>decimal</code>                                                                                                    | <code>1.9–26.3</code>       |
+| <code>soundCategory_weather</code>                | <code>1.7.2–26.3</code>: <code>decimal</code>                                                                                                  | <code>1.7.2–26.3</code>     |
+| <code>soundDevice</code>                          | <code>1.18–26.3</code>: <code>string</code>                                                                                                    | <code>1.18–26.3</code>      |
+| <code>sprintWindow</code>                         | <code>1.21.9–26.3</code>: <code>integer</code>                                                                                                 | <code>1.21.9–26.3</code>    |
+| <code>startedCleanly</code>                       | <code>1.21.5–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.21.5–26.3</code>    |
+| <code>streamBytesPerPixel</code>                  | <code>1.7.3–1.8.9</code>: <code>decimal</code>                                                                                                 | <code>1.7.3–1.8.9</code>    |
+| <code>streamChatEnabled</code>                    | <code>1.7.3–1.8.9</code>: <code>enum (0, 1, 2)</code>                                                                                                    | <code>1.7.3–1.8.9</code>    |
+| <code>streamChatUserFilter</code>                 | <code>1.7.3–1.8.9</code>: <code>enum (0, 1, 2)</code>                                                                                                    | <code>1.7.3–1.8.9</code>    |
+| <code>streamCompression</code>                    | <code>1.7.3–1.8.9</code>: <code>enum (0, 1, 2)</code>                                                                                                    | <code>1.7.3–1.8.9</code>    |
+| <code>streamFps</code>                            | <code>1.7.3–1.8.9</code>: <code>decimal</code>                                                                                                 | <code>1.7.3–1.8.9</code>    |
+| <code>streamKbps</code>                           | <code>1.7.3–1.8.9</code>: <code>decimal</code>                                                                                                 | <code>1.7.3–1.8.9</code>    |
+| <code>streamMicToggleBehavior</code>              | <code>1.7.3–1.8.9</code>: <code>enum (0, 1)</code>                                                                                                    | <code>1.7.3–1.8.9</code>    |
+| <code>streamMicVolume</code>                      | <code>1.7.3–1.8.9</code>: <code>decimal</code>                                                                                                 | <code>1.7.3–1.8.9</code>    |
+| <code>streamPreferredServer</code>                | <code>1.7.3–1.8.9</code>: <code>string</code>                                                                                                  | <code>1.7.3–1.8.9</code>    |
+| <code>streamSendMetadata</code>                   | <code>1.7.3–1.8.9</code>: <code>boolean</code>                                                                                                 | <code>1.7.3–1.8.9</code>    |
+| <code>streamSystemVolume</code>                   | <code>1.7.3–1.8.9</code>: <code>decimal</code>                                                                                                 | <code>1.7.3–1.8.9</code>    |
+| <code>syncChunkWrites</code>                      | <code>1.16–26.3</code>: <code>boolean</code>                                                                                                   | <code>1.16–26.3</code>      |
+| <code>telemetryOptInExtra</code>                  | <code>1.19.3–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.19.3–26.3</code>    |
+| <code>textBackgroundOpacity</code>                | <code>1.14–26.3</code>: <code>decimal</code>                                                                                                   | <code>1.14–26.3</code>      |
+| <code>textureFiltering</code>                     | <code>1.21.11–26.3</code>: <code>enum (0, 1, 2)</code>                                                                                                   | <code>1.21.11–26.3</code>   |
+| <code>toggleAttack</code>                         | <code>1.21.9–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.21.9–26.3</code>    |
+| <code>toggleCrouch</code>                         | <code>1.15–26.3</code>: <code>boolean</code>                                                                                                   | <code>1.15–26.3</code>      |
+| <code>toggleSprint</code>                         | <code>1.15–26.3</code>: <code>boolean</code>                                                                                                   | <code>1.15–26.3</code>      |
+| <code>toggleUse</code>                            | <code>1.21.9–26.3</code>: <code>boolean</code>                                                                                                 | <code>1.21.9–26.3</code>    |
+| <code>touchscreen</code>                          | <code>1.4.4–26.1.2</code>: <code>boolean</code>                                                                                                | <code>1.4.4–26.1.2</code>   |
+| <code>tutorialStep</code>                         | <code>1.12–26.3</code>: <code>enum (craft_planks, find_tree, movement, none, open_inventory, punch_tree)</code>                                                                                                      | <code>1.12–26.3</code>      |
+| <code>useNativeTransport</code>                   | <code>1.8.1–26.3</code>: <code>boolean</code>                                                                                                  | <code>1.8.1–26.3</code>     |
+| <code>useVbo</code>                               | <code>1.8–26.3</code>: <code>boolean</code>                                                                                                    | <code>1.8–1.13.2</code>     |
+| <code>version</code>                              | <code>1.10–26.3</code>: <code>integer</code>                                                                                                   | <code>1.10–26.3</code>      |
+| <code>viewDistance</code>                         | <code>1.0–1.6.4</code>: <code>enum (0, 1, 2, 3)</code>                                                                                                      | <code>1.0–1.6.4</code>      |
+| <code>vignette</code>                             | <code>1.21.11–26.3</code>: <code>boolean</code>                                                                                                | <code>1.21.11–26.3</code>   |
+| <code>weatherRadius</code>                        | <code>1.21.11–26.3</code>: <code>integer</code>                                                                                                | <code>1.21.11–26.3</code>   |
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/catalog/accessibility.rs b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/accessibility.rs
new file mode 100644
index 0000000000..d6b5a4c8e4
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/accessibility.rs
@@ -0,0 +1,51 @@
+use super::{BOOL, SettingEditor, SupportedSetting, ValueEncoding, setting};
+
+const NARRATOR: &[&str] = &["0", "1", "2", "3"];
+
+pub(super) const SETTINGS: &[SupportedSetting] = &[
+    setting(
+        "narrator",
+        &["narrator"],
+        "accessibility",
+        true,
+        SettingEditor::Enum(NARRATOR),
+        ValueEncoding::Enum(NARRATOR),
+    ),
+    setting(
+        "subtitles",
+        &["showSubtitles"],
+        "accessibility",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "high_contrast",
+        &["highContrast"],
+        "accessibility",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "dark_splash",
+        &["darkMojangStudiosBackground"],
+        "accessibility",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "notification_time",
+        &["notificationDisplayTime"],
+        "accessibility",
+        true,
+        SettingEditor::Decimal {
+            min: 0.5,
+            max: 10.0,
+            step: 0.5,
+            unit: Some("multiplier"),
+        },
+        ValueEncoding::Decimal,
+    ),
+];
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/catalog/chat.rs b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/chat.rs
new file mode 100644
index 0000000000..cb8e91b337
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/chat.rs
@@ -0,0 +1,57 @@
+use super::{
+    BOOL, SettingEditor, SupportedSetting, UNIT_INTERVAL, ValueEncoding,
+    setting,
+};
+
+const VISIBILITY: &[&str] = &["0", "1", "2"];
+
+pub(super) const SETTINGS: &[SupportedSetting] = &[
+    setting(
+        "chat_visibility",
+        &["chatVisibility"],
+        "chat",
+        true,
+        SettingEditor::Enum(VISIBILITY),
+        ValueEncoding::Enum(VISIBILITY),
+    ),
+    setting(
+        "chat_colors",
+        &["chatColors"],
+        "chat",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "chat_links",
+        &["chatLinks"],
+        "chat",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "chat_links_prompt",
+        &["chatLinksPrompt"],
+        "chat",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "chat_opacity",
+        &["chatOpacity"],
+        "chat",
+        true,
+        UNIT_INTERVAL,
+        ValueEncoding::Decimal,
+    ),
+    setting(
+        "chat_scale",
+        &["chatScale"],
+        "chat",
+        true,
+        UNIT_INTERVAL,
+        ValueEncoding::Decimal,
+    ),
+];
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/catalog/controls.rs b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/controls.rs
new file mode 100644
index 0000000000..2d7d3f8289
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/controls.rs
@@ -0,0 +1,221 @@
+use super::{
+    BOOL, SettingEditor, SupportedSetting, ValueEncoding, setting,
+    version_changes, versioned_setting,
+};
+
+pub(super) const SETTINGS: &[SupportedSetting] = &[
+    setting(
+        "sensitivity",
+        &["mouseSensitivity"],
+        "controls",
+        true,
+        SettingEditor::Decimal {
+            min: 0.0,
+            max: 1.0,
+            step: 0.005,
+            unit: Some("percent"),
+        },
+        ValueEncoding::Decimal,
+    ),
+    setting(
+        "invert_mouse",
+        &["invertYMouse"],
+        "controls",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "auto_jump",
+        &["autoJump"],
+        "controls",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "toggle_crouch",
+        &["toggleCrouch"],
+        "controls",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "toggle_sprint",
+        &["toggleSprint"],
+        "controls",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "discrete_mouse_scroll",
+        &["discrete_mouse_scroll"],
+        "controls",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "key.forward",
+        &["key_key.forward"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.left",
+        &["key_key.left"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.back",
+        &["key_key.back"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.right",
+        &["key_key.right"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.jump",
+        &["key_key.jump"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.sneak",
+        &["key_key.sneak"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.sprint",
+        &["key_key.sprint"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.inventory",
+        &["key_key.inventory"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    versioned_setting(
+        "key.swap_offhand",
+        &["key_key.swapOffhand", "key_key.swapHands"],
+        version_changes::SWAP_OFFHAND_KEYS,
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.drop",
+        &["key_key.drop"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.use",
+        &["key_key.use"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.attack",
+        &["key_key.attack"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.pick_item",
+        &["key_key.pickItem"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.chat",
+        &["key_key.chat"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.player_list",
+        &["key_key.playerlist"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.command",
+        &["key_key.command"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.screenshot",
+        &["key_key.screenshot"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.perspective",
+        &["key_key.togglePerspective"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.fullscreen",
+        &["key_key.fullscreen"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+    setting(
+        "key.advancements",
+        &["key_key.advancements"],
+        "controls",
+        true,
+        SettingEditor::KeyBinding,
+        ValueEncoding::KeyBinding,
+    ),
+];
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/catalog/known_vanilla_keys.rs b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/known_vanilla_keys.rs
new file mode 100644
index 0000000000..9511ac1692
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/known_vanilla_keys.rs
@@ -0,0 +1,274 @@
+// Never treat these Minecraft keys as settings added by mods. NEVER_SYNC_KEYS are
+// not safe to share; KNOWN_VANILLA_KEYS are Minecraft settings the editor does not
+// support yet.
+pub(super) const NEVER_SYNC_KEYS: &[&str] = &[
+    "version",
+    "resourcePacks",
+    "incompatibleResourcePacks",
+    "lastServer",
+    "startedCleanly",
+    "tutorialStep",
+    "joinedFirstServer",
+    "onboardAccessibility",
+    "soundDevice",
+    "fullscreenResolution",
+    "overrideWidth",
+    "overrideHeight",
+    "preferredGraphicsBackend",
+    "difficulty",
+    "snooperEnabled",
+    "touchscreen",
+    "heldItemTooltips",
+    "useVbo",
+    "fboEnable",
+    "saturation",
+    "anaglyph3d",
+    "advancedOpengl",
+    "streamBytesPerPixel",
+    "streamMicVolume",
+    "streamGameVolume",
+    "streamKbps",
+    "streamFps",
+    "streamCompression",
+    "streamSendMetadata",
+    "streamPreferredServer",
+    "streamChatEnabled",
+    "streamChatUserFilter",
+    "streamMicToggleBehavior",
+    "fpsLimit",
+    "music",
+    "skin",
+    "sound",
+    "viewDistance",
+    "anisotropicFiltering",
+    "clouds",
+    "showCape",
+    "allowBlockAlternatives",
+    "key_key.streamCommercial",
+    "key_key.streamPauseUnpause",
+    "key_key.streamStartStop",
+    "key_key.streamToggleMic",
+    "streamSystemVolume",
+    "showInventoryAchievementHint",
+    "enableWeakAttacks",
+    "chatPreview",
+    "skipRealms32bitWarning",
+    "showNowPlayingToast",
+    "key_Build",
+    "key_Load location",
+    "key_Save location",
+    "showFrameRate",
+    "limitFramerate",
+    "key_key.fog",
+    "chunksPerFrame",
+    "uploadsPerFrame",
+    "onlyShowSignedChat",
+    "skipFriendsListPromo",
+    "postProcessEnable",
+    "soundCategory_animals",
+    "soundCategory_blocks",
+    "soundCategory_mobs",
+    "soundCategory_players",
+    "soundCategory_records",
+    "shieldAnimation",
+    "serverTextures",
+    "rawMouseInput",
+];
+
+pub(super) const KNOWN_VANILLA_KEYS: &[&str] = &[
+    "version",
+    "ao",
+    "biomeBlendRadius",
+    "chunkSectionFadeInTime",
+    "cutoutLeaves",
+    "enableVsync",
+    "entityDistanceScaling",
+    "entityShadows",
+    "forceUnicodeFont",
+    "japaneseGlyphVariants",
+    "fov",
+    "fovEffectScale",
+    "darknessEffectScale",
+    "glintSpeed",
+    "glintStrength",
+    "preferredGraphicsBackend",
+    "graphicsPreset",
+    "prioritizeChunkUpdates",
+    "fullscreen",
+    "exclusiveFullscreen",
+    "macFullscreenMenuVisibility",
+    "gamma",
+    "guiScale",
+    "debugGuiScale",
+    "maxAnisotropyBit",
+    "textureFiltering",
+    "maxFps",
+    "improvedTransparency",
+    "inactivityFpsLimit",
+    "mipmapLevels",
+    "narrator",
+    "particles",
+    "reducedDebugInfo",
+    "renderClouds",
+    "cloudRange",
+    "renderDistance",
+    "simulationDistance",
+    "screenEffectScale",
+    "soundDevice",
+    "vignette",
+    "weatherRadius",
+    "autoJump",
+    "rotateWithMinecart",
+    "operatorItemsTab",
+    "autoSuggestions",
+    "chatColors",
+    "chatLinks",
+    "chatLinksPrompt",
+    "discrete_mouse_scroll",
+    "invertXMouse",
+    "invertYMouse",
+    "realmsNotifications",
+    "showSubtitles",
+    "directionalAudio",
+    "bobView",
+    "toggleCrouch",
+    "toggleSprint",
+    "toggleAttack",
+    "toggleUse",
+    "sprintWindow",
+    "darkMojangStudiosBackground",
+    "hideLightningFlashes",
+    "hideSplashTexts",
+    "mouseSensitivity",
+    "damageTiltStrength",
+    "highContrast",
+    "highContrastBlockOutline",
+    "narratorHotKey",
+    "resourcePacks",
+    "incompatibleResourcePacks",
+    "lastServer",
+    "lang",
+    "chatVisibility",
+    "chatOpacity",
+    "chatLineSpacing",
+    "textBackgroundOpacity",
+    "backgroundForChatOnly",
+    "hideServerAddress",
+    "advancedItemTooltips",
+    "pauseOnLostFocus",
+    "overrideWidth",
+    "overrideHeight",
+    "chatHeightFocused",
+    "chatDelay",
+    "chatHeightUnfocused",
+    "chatScale",
+    "chatWidth",
+    "notificationDisplayTime",
+    "useNativeTransport",
+    "mainHand",
+    "attackIndicator",
+    "tutorialStep",
+    "mouseWheelSensitivity",
+    "allowCursorChanges",
+    "quitShortcuts",
+    "ctrlClickEmulatesRightClick",
+    "glDebugVerbosity",
+    "skipMultiplayerWarning",
+    "hideMatchedNames",
+    "joinedFirstServer",
+    "syncChunkWrites",
+    "showAutosaveIndicator",
+    "allowServerListing",
+    "inGameNotification",
+    "sharePresence",
+    "onlyShowSecureChat",
+    "saveChatDrafts",
+    "panoramaScrollSpeed",
+    "telemetryOptInExtra",
+    "onboardAccessibility",
+    "menuBackgroundBlurriness",
+    "startedCleanly",
+    "musicToast",
+    "musicFrequency",
+    "key_key.attack",
+    "key_key.use",
+    "key_key.forward",
+    "key_key.left",
+    "key_key.back",
+    "key_key.right",
+    "key_key.jump",
+    "key_key.sneak",
+    "key_key.sprint",
+    "key_key.drop",
+    "key_key.inventory",
+    "key_key.chat",
+    "key_key.playerlist",
+    "key_key.pickItem",
+    "key_key.command",
+    "key_key.friends",
+    "key_key.socialInteractions",
+    "key_key.toggleGui",
+    "key_key.toggleSpectatorShaderEffects",
+    "key_key.screenshot",
+    "key_key.togglePerspective",
+    "key_key.smoothCamera",
+    "key_key.fullscreen",
+    "key_key.spectatorOutlines",
+    "key_key.spectatorHotbar",
+    "key_key.swapOffhand",
+    "key_key.saveToolbarActivator",
+    "key_key.loadToolbarActivator",
+    "key_key.advancements",
+    "key_key.quickActions",
+    "key_key.debug.overlay",
+    "key_key.debug.modifier",
+    "key_key.hotbar.1",
+    "key_key.hotbar.2",
+    "key_key.hotbar.3",
+    "key_key.hotbar.4",
+    "key_key.hotbar.5",
+    "key_key.hotbar.6",
+    "key_key.hotbar.7",
+    "key_key.hotbar.8",
+    "key_key.hotbar.9",
+    "key_key.debug.reloadChunk",
+    "key_key.debug.showHitboxes",
+    "key_key.debug.clearChat",
+    "key_key.debug.crash",
+    "key_key.debug.showChunkBorders",
+    "key_key.debug.showAdvancedTooltips",
+    "key_key.debug.copyRecreateCommand",
+    "key_key.debug.spectate",
+    "key_key.debug.switchGameMode",
+    "key_key.debug.debugOptions",
+    "key_key.debug.focusPause",
+    "key_key.debug.dumpDynamicTextures",
+    "key_key.debug.reloadResourcePacks",
+    "key_key.debug.profiling",
+    "key_key.debug.copyLocation",
+    "key_key.debug.dumpVersion",
+    "key_key.debug.profilingChart",
+    "key_key.debug.fpsCharts",
+    "key_key.debug.networkCharts",
+    "key_key.debug.lightmapTexture",
+    "key_key.debug.improvedTransparency",
+    "soundCategory_master",
+    "soundCategory_music",
+    "soundCategory_record",
+    "soundCategory_weather",
+    "soundCategory_block",
+    "soundCategory_hostile",
+    "soundCategory_neutral",
+    "soundCategory_player",
+    "soundCategory_ambient",
+    "soundCategory_voice",
+    "soundCategory_ui",
+    "modelPart_cape",
+    "modelPart_jacket",
+    "modelPart_left_sleeve",
+    "modelPart_right_sleeve",
+    "modelPart_left_pants_leg",
+    "modelPart_right_pants_leg",
+    "modelPart_hat",
+    "fullscreenResolution",
+];
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/catalog/legacy_key_bindings.rs b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/legacy_key_bindings.rs
new file mode 100644
index 0000000000..f926d9d7a3
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/legacy_key_bindings.rs
@@ -0,0 +1,112 @@
+// Before Minecraft 1.13, options.txt stored key bindings as numbers. This table
+// converts those numbers to the key names used by current versions.
+pub(in crate::api::instance) const LEGACY_KEY_BINDINGS: &[(i32, &str)] = &[
+    (0, "key.keyboard.unknown"),
+    (1, "key.keyboard.escape"),
+    (2, "key.keyboard.1"),
+    (3, "key.keyboard.2"),
+    (4, "key.keyboard.3"),
+    (5, "key.keyboard.4"),
+    (6, "key.keyboard.5"),
+    (7, "key.keyboard.6"),
+    (8, "key.keyboard.7"),
+    (9, "key.keyboard.8"),
+    (10, "key.keyboard.9"),
+    (11, "key.keyboard.0"),
+    (12, "key.keyboard.minus"),
+    (13, "key.keyboard.equal"),
+    (14, "key.keyboard.backspace"),
+    (15, "key.keyboard.tab"),
+    (16, "key.keyboard.q"),
+    (17, "key.keyboard.w"),
+    (18, "key.keyboard.e"),
+    (19, "key.keyboard.r"),
+    (20, "key.keyboard.t"),
+    (21, "key.keyboard.y"),
+    (22, "key.keyboard.u"),
+    (23, "key.keyboard.i"),
+    (24, "key.keyboard.o"),
+    (25, "key.keyboard.p"),
+    (26, "key.keyboard.left.bracket"),
+    (27, "key.keyboard.right.bracket"),
+    (28, "key.keyboard.enter"),
+    (29, "key.keyboard.left.control"),
+    (30, "key.keyboard.a"),
+    (31, "key.keyboard.s"),
+    (32, "key.keyboard.d"),
+    (33, "key.keyboard.f"),
+    (34, "key.keyboard.g"),
+    (35, "key.keyboard.h"),
+    (36, "key.keyboard.j"),
+    (37, "key.keyboard.k"),
+    (38, "key.keyboard.l"),
+    (39, "key.keyboard.semicolon"),
+    (40, "key.keyboard.apostrophe"),
+    (41, "key.keyboard.grave.accent"),
+    (42, "key.keyboard.left.shift"),
+    (43, "key.keyboard.backslash"),
+    (44, "key.keyboard.z"),
+    (45, "key.keyboard.x"),
+    (46, "key.keyboard.c"),
+    (47, "key.keyboard.v"),
+    (48, "key.keyboard.b"),
+    (49, "key.keyboard.n"),
+    (50, "key.keyboard.m"),
+    (51, "key.keyboard.comma"),
+    (52, "key.keyboard.period"),
+    (53, "key.keyboard.slash"),
+    (54, "key.keyboard.right.shift"),
+    (55, "key.keyboard.keypad.multiply"),
+    (56, "key.keyboard.left.alt"),
+    (57, "key.keyboard.space"),
+    (58, "key.keyboard.caps.lock"),
+    (59, "key.keyboard.f1"),
+    (60, "key.keyboard.f2"),
+    (61, "key.keyboard.f3"),
+    (62, "key.keyboard.f4"),
+    (63, "key.keyboard.f5"),
+    (64, "key.keyboard.f6"),
+    (65, "key.keyboard.f7"),
+    (66, "key.keyboard.f8"),
+    (67, "key.keyboard.f9"),
+    (68, "key.keyboard.f10"),
+    (69, "key.keyboard.num.lock"),
+    (70, "key.keyboard.scroll.lock"),
+    (71, "key.keyboard.keypad.7"),
+    (72, "key.keyboard.keypad.8"),
+    (73, "key.keyboard.keypad.9"),
+    (74, "key.keyboard.keypad.subtract"),
+    (75, "key.keyboard.keypad.4"),
+    (76, "key.keyboard.keypad.5"),
+    (77, "key.keyboard.keypad.6"),
+    (78, "key.keyboard.keypad.add"),
+    (79, "key.keyboard.keypad.1"),
+    (80, "key.keyboard.keypad.2"),
+    (81, "key.keyboard.keypad.3"),
+    (82, "key.keyboard.keypad.0"),
+    (83, "key.keyboard.keypad.decimal"),
+    (87, "key.keyboard.f11"),
+    (88, "key.keyboard.f12"),
+    (100, "key.keyboard.f13"),
+    (101, "key.keyboard.f14"),
+    (102, "key.keyboard.f15"),
+    (141, "key.keyboard.keypad.equal"),
+    (156, "key.keyboard.keypad.enter"),
+    (157, "key.keyboard.right.control"),
+    (181, "key.keyboard.keypad.divide"),
+    (183, "key.keyboard.print.screen"),
+    (184, "key.keyboard.right.alt"),
+    (197, "key.keyboard.pause"),
+    (199, "key.keyboard.home"),
+    (200, "key.keyboard.up"),
+    (201, "key.keyboard.page.up"),
+    (203, "key.keyboard.left"),
+    (205, "key.keyboard.right"),
+    (207, "key.keyboard.end"),
+    (208, "key.keyboard.down"),
+    (209, "key.keyboard.page.down"),
+    (210, "key.keyboard.insert"),
+    (211, "key.keyboard.delete"),
+    (219, "key.keyboard.left.win"),
+    (220, "key.keyboard.right.win"),
+];
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/catalog/mod.rs b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/mod.rs
new file mode 100644
index 0000000000..cc2d87e0b7
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/mod.rs
@@ -0,0 +1,264 @@
+//! Defines the Minecraft settings Modrinth knows how to read and write.
+//!
+//! File keys and version conversions live here. The frontend supplies the labels
+//! and translations shown to the user.
+
+mod accessibility;
+mod chat;
+mod controls;
+mod known_vanilla_keys;
+mod legacy_key_bindings;
+mod sound;
+mod version_changes;
+mod video;
+
+use super::api_types::{
+    GameOptionEditorChoice, GameOptionEditorDefinition, GameOptionMappingKind,
+};
+
+use known_vanilla_keys::{KNOWN_VANILLA_KEYS, NEVER_SYNC_KEYS};
+pub(in crate::api::instance) use legacy_key_bindings::LEGACY_KEY_BINDINGS;
+pub(in crate::api::instance) use version_changes::*;
+
+#[derive(Clone, Copy)]
+pub(super) enum SettingEditor {
+    Boolean,
+    Integer {
+        min: i64,
+        max: i64,
+        step: i64,
+    },
+    Decimal {
+        min: f64,
+        max: f64,
+        step: f64,
+        unit: Option<&'static str>,
+    },
+    Enum(&'static [&'static str]),
+    Language,
+    KeyBinding,
+}
+
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub(super) enum ValueEncoding {
+    Bool,
+    Integer,
+    Decimal,
+    Enum(&'static [&'static str]),
+    Text,
+    Graphics,
+    AmbientOcclusion,
+    MusicToast,
+    Fov,
+    KeyBinding,
+}
+
+pub(super) struct SupportedSetting {
+    pub(super) id: &'static str,
+    pub(super) keys: &'static [&'static str],
+    pub(super) versioned_keys: &'static [VersionedKey],
+    pub(super) category: &'static str,
+    pub(super) default_on: bool,
+    pub(super) editor: SettingEditor,
+    pub(super) encoding: ValueEncoding,
+}
+
+#[derive(Clone, Copy)]
+pub(super) struct VersionedKey {
+    pub(super) key: &'static str,
+    pub(super) since: &'static str,
+    pub(super) until: &'static str,
+    pub(super) mapping: GameOptionMappingKind,
+}
+
+pub(super) const BOOL: SettingEditor = SettingEditor::Boolean;
+pub(super) const UNIT_INTERVAL: SettingEditor = SettingEditor::Decimal {
+    min: 0.0,
+    max: 1.0,
+    step: 0.01,
+    unit: Some("percent"),
+};
+
+pub(super) const fn setting(
+    id: &'static str,
+    keys: &'static [&'static str],
+    category: &'static str,
+    default_on: bool,
+    editor: SettingEditor,
+    encoding: ValueEncoding,
+) -> SupportedSetting {
+    SupportedSetting {
+        id,
+        keys,
+        versioned_keys: &[],
+        category,
+        default_on,
+        editor,
+        encoding,
+    }
+}
+
+pub(super) const fn versioned_setting(
+    id: &'static str,
+    keys: &'static [&'static str],
+    versioned_keys: &'static [VersionedKey],
+    category: &'static str,
+    default_on: bool,
+    editor: SettingEditor,
+    encoding: ValueEncoding,
+) -> SupportedSetting {
+    SupportedSetting {
+        id,
+        keys,
+        versioned_keys,
+        category,
+        default_on,
+        editor,
+        encoding,
+    }
+}
+
+const SETTING_GROUPS: &[&[SupportedSetting]] = &[
+    video::SETTINGS,
+    sound::SETTINGS,
+    controls::SETTINGS,
+    chat::SETTINGS,
+    accessibility::SETTINGS,
+    GENERAL_SETTINGS,
+];
+
+const MAIN_HAND: &[&str] = &["left", "right"];
+
+// These settings all use the common value formats above, so they can stay together.
+const GENERAL_SETTINGS: &[SupportedSetting] = &[
+    setting(
+        "main_hand",
+        &["mainHand"],
+        "skin_customization",
+        true,
+        SettingEditor::Enum(MAIN_HAND),
+        ValueEncoding::Enum(MAIN_HAND),
+    ),
+    setting(
+        "cape",
+        &["modelPart_cape"],
+        "skin_customization",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "hat",
+        &["modelPart_hat"],
+        "skin_customization",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "jacket",
+        &["modelPart_jacket"],
+        "skin_customization",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "allow_server_listing",
+        &["allowServerListing"],
+        "online",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "realms_notifications",
+        &["realmsNotifications"],
+        "online",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+];
+
+pub(super) fn all_supported_settings()
+-> impl Iterator<Item = &'static SupportedSetting> {
+    SETTING_GROUPS.iter().flat_map(|group| group.iter())
+}
+
+pub(super) fn setting_by_id(
+    option_id: &str,
+) -> Option<&'static SupportedSetting> {
+    all_supported_settings().find(|setting| setting.id == option_id)
+}
+
+pub(super) fn setting_by_file_key(
+    key: &str,
+) -> Option<&'static SupportedSetting> {
+    all_supported_settings().find(|setting| setting.keys.contains(&key))
+}
+
+pub(super) fn is_never_sync_key(key: &str) -> bool {
+    NEVER_SYNC_KEYS.contains(&key)
+        || KNOWN_VANILLA_KEYS.contains(&key)
+        || key.starts_with("skip")
+        || key.starts_with("hideBundleTutorial")
+        || key.starts_with("key_") && !key.starts_with("key_key.")
+}
+
+pub(super) fn editor_for(
+    setting: &SupportedSetting,
+) -> GameOptionEditorDefinition {
+    let mut editor = GameOptionEditorDefinition {
+        type_: String::new(),
+        min: None,
+        max: None,
+        step: None,
+        unit: None,
+        choices: Vec::new(),
+    };
+    match setting.editor {
+        SettingEditor::Boolean => editor.type_ = "bool".to_string(),
+        SettingEditor::Integer { min, max, step } => {
+            editor.type_ = "integer".to_string();
+            editor.min = Some(min as f64);
+            editor.max = Some(max as f64);
+            editor.step = Some(step as f64);
+        }
+        SettingEditor::Decimal {
+            min,
+            max,
+            step,
+            unit,
+        } => {
+            editor.type_ = "decimal".to_string();
+            editor.min = Some(min);
+            editor.max = Some(max);
+            editor.step = Some(step);
+            editor.unit = unit.map(str::to_string);
+        }
+        SettingEditor::Enum(choices) => {
+            editor.type_ = "enum".to_string();
+            editor.choices = choices
+                .iter()
+                .map(|value| GameOptionEditorChoice {
+                    value: (*value).to_string(),
+                })
+                .collect();
+        }
+        SettingEditor::Language => editor.type_ = "text".to_string(),
+        SettingEditor::KeyBinding => editor.type_ = "key_binding".to_string(),
+    }
+    editor
+}
+
+pub(super) fn custom_setting_editor() -> GameOptionEditorDefinition {
+    GameOptionEditorDefinition {
+        type_: "external_raw".to_string(),
+        min: None,
+        max: None,
+        step: None,
+        unit: None,
+        choices: Vec::new(),
+    }
+}
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/catalog/sound.rs b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/sound.rs
new file mode 100644
index 0000000000..0b4ae4a267
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/sound.rs
@@ -0,0 +1,114 @@
+use super::{
+    SettingEditor, SupportedSetting, UNIT_INTERVAL, ValueEncoding, setting,
+    version_changes, versioned_setting,
+};
+
+const MUSIC_TOAST: &[&str] = &["never", "pause", "pause_and_toast"];
+
+pub(super) const SETTINGS: &[SupportedSetting] = &[
+    setting(
+        "language",
+        &["lang"],
+        "language",
+        true,
+        SettingEditor::Language,
+        ValueEncoding::Text,
+    ),
+    setting(
+        "master_volume",
+        &["soundCategory_master"],
+        "music_and_sound",
+        true,
+        UNIT_INTERVAL,
+        ValueEncoding::Decimal,
+    ),
+    setting(
+        "music_volume",
+        &["soundCategory_music"],
+        "music_and_sound",
+        true,
+        UNIT_INTERVAL,
+        ValueEncoding::Decimal,
+    ),
+    versioned_setting(
+        "music_toast",
+        &["musicToast", "showNowPlayingToast"],
+        version_changes::MUSIC_TOAST_KEYS,
+        "music_and_sound",
+        true,
+        SettingEditor::Enum(MUSIC_TOAST),
+        ValueEncoding::MusicToast,
+    ),
+    setting(
+        "record_volume",
+        &["soundCategory_record"],
+        "music_and_sound",
+        true,
+        UNIT_INTERVAL,
+        ValueEncoding::Decimal,
+    ),
+    setting(
+        "weather_volume",
+        &["soundCategory_weather"],
+        "music_and_sound",
+        true,
+        UNIT_INTERVAL,
+        ValueEncoding::Decimal,
+    ),
+    setting(
+        "blocks_volume",
+        &["soundCategory_block"],
+        "music_and_sound",
+        true,
+        UNIT_INTERVAL,
+        ValueEncoding::Decimal,
+    ),
+    setting(
+        "hostile_volume",
+        &["soundCategory_hostile"],
+        "music_and_sound",
+        true,
+        UNIT_INTERVAL,
+        ValueEncoding::Decimal,
+    ),
+    setting(
+        "neutral_volume",
+        &["soundCategory_neutral"],
+        "music_and_sound",
+        true,
+        UNIT_INTERVAL,
+        ValueEncoding::Decimal,
+    ),
+    setting(
+        "players_volume",
+        &["soundCategory_player"],
+        "music_and_sound",
+        true,
+        UNIT_INTERVAL,
+        ValueEncoding::Decimal,
+    ),
+    setting(
+        "ambient_volume",
+        &["soundCategory_ambient"],
+        "music_and_sound",
+        true,
+        UNIT_INTERVAL,
+        ValueEncoding::Decimal,
+    ),
+    setting(
+        "voice_volume",
+        &["soundCategory_voice"],
+        "music_and_sound",
+        true,
+        UNIT_INTERVAL,
+        ValueEncoding::Decimal,
+    ),
+    setting(
+        "ui_volume",
+        &["soundCategory_ui"],
+        "music_and_sound",
+        true,
+        UNIT_INTERVAL,
+        ValueEncoding::Decimal,
+    ),
+];
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/catalog/version_changes.rs b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/version_changes.rs
new file mode 100644
index 0000000000..a9efcebc02
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/version_changes.rs
@@ -0,0 +1,704 @@
+//! Handles settings Minecraft renamed or stored differently between versions.
+
+use super::super::api_types::canonical_values_equal;
+use super::super::options_file::{
+    GameOptionsDocument, input_error, validate_raw_key_value,
+};
+use super::{
+    GameOptionMappingKind, LEGACY_KEY_BINDINGS, SettingEditor,
+    SupportedSetting, ValueEncoding, VersionedKey,
+};
+use crate::state::{CanonicalValue, StoredOption};
+
+const GRAPHICS_VALUES: &[&str] = &["fast", "fancy", "fabulous", "custom"];
+const MUSIC_TOAST_VALUES: &[&str] = &["never", "pause", "pause_and_toast"];
+
+fn decode_string_token(raw: &str) -> Option<String> {
+    if raw.starts_with('"') {
+        serde_json::from_str(raw).ok()
+    } else {
+        Some(raw.to_string())
+    }
+}
+
+fn encode_string_token(value: &str) -> Option<String> {
+    serde_json::to_string(value).ok()
+}
+
+pub(in crate::api::instance) const GRAPHICS_KEYS: &[VersionedKey] = &[
+    VersionedKey {
+        key: "fancyGraphics",
+        since: "1.0",
+        until: "1.16.1",
+        mapping: GameOptionMappingKind::Legacy,
+    },
+    VersionedKey {
+        key: "graphicsMode",
+        since: "1.16",
+        until: "1.21.10",
+        mapping: GameOptionMappingKind::Migrated,
+    },
+    VersionedKey {
+        key: "graphicsPreset",
+        since: "1.21.11",
+        until: "26.3",
+        mapping: GameOptionMappingKind::Direct,
+    },
+];
+
+pub(in crate::api::instance) const AMBIENT_OCCLUSION_KEYS: &[VersionedKey] = &[
+    VersionedKey {
+        key: "ao",
+        since: "1.0",
+        until: "1.19.3",
+        mapping: GameOptionMappingKind::Legacy,
+    },
+    VersionedKey {
+        key: "ao",
+        since: "1.19.4",
+        until: "26.3",
+        mapping: GameOptionMappingKind::Migrated,
+    },
+];
+
+pub(in crate::api::instance) const MUSIC_TOAST_KEYS: &[VersionedKey] = &[
+    VersionedKey {
+        key: "showNowPlayingToast",
+        since: "1.21.6",
+        until: "1.21.10",
+        mapping: GameOptionMappingKind::Legacy,
+    },
+    VersionedKey {
+        key: "musicToast",
+        since: "1.21.11",
+        until: "26.3",
+        mapping: GameOptionMappingKind::Direct,
+    },
+];
+
+pub(in crate::api::instance) const SWAP_OFFHAND_KEYS: &[VersionedKey] = &[
+    VersionedKey {
+        key: "key_key.swapHands",
+        since: "1.0",
+        until: "1.15.2",
+        mapping: GameOptionMappingKind::Legacy,
+    },
+    VersionedKey {
+        key: "key_key.swapOffhand",
+        since: "1.16",
+        until: "26.3",
+        mapping: GameOptionMappingKind::Direct,
+    },
+];
+
+pub(in crate::api::instance) fn release_version(
+    version: &str,
+) -> Option<(u32, u32, u32)> {
+    let components = version
+        .split('.')
+        .map(|component| component.parse::<u32>())
+        .collect::<Result<Vec<_>, _>>()
+        .ok()?;
+    match components.as_slice() {
+        [major, minor] => Some((*major, *minor, 0)),
+        [major, minor, patch] => Some((*major, *minor, *patch)),
+        _ => None,
+    }
+}
+
+pub(in crate::api::instance) fn physical_variant_for_version<'a>(
+    definition: &'a SupportedSetting,
+    version: &str,
+) -> Option<&'a VersionedKey> {
+    let version = release_version(version)?;
+    definition.versioned_keys.iter().find(|variant| {
+        let Some(since) = release_version(variant.since) else {
+            return false;
+        };
+        let Some(until) = release_version(variant.until) else {
+            return false;
+        };
+        version >= since && version <= until
+    })
+}
+
+pub(in crate::api::instance) fn physical_variant_for_present_key<'a>(
+    definition: &'a SupportedSetting,
+    key: &str,
+    version: &str,
+) -> Option<&'a VersionedKey> {
+    let version = release_version(version)?;
+    definition.versioned_keys.iter().rev().find(|variant| {
+        variant.key == key
+            && release_version(variant.since)
+                .is_some_and(|since| since <= version)
+            && release_version(variant.until)
+                .is_some_and(|until| version <= until)
+    })
+}
+
+pub(in crate::api::instance) fn uses_modern_key_tokens(version: &str) -> bool {
+    release_version(version).is_some_and(|version| version >= (1, 13, 0))
+}
+
+pub(in crate::api::instance) fn split_key_binding(
+    value: &str,
+) -> (&str, Option<&str>) {
+    value
+        .split_once(':')
+        .map_or((value, None), |(key, modifier)| (key, Some(modifier)))
+}
+
+pub(in crate::api::instance) fn append_key_modifier(
+    mut key: String,
+    modifier: Option<&str>,
+) -> String {
+    if let Some(modifier) = modifier {
+        key.push(':');
+        key.push_str(modifier);
+    }
+    key
+}
+
+pub(in crate::api::instance) fn legacy_key_binding_to_token(
+    value: &str,
+) -> Option<String> {
+    let (key, modifier) = split_key_binding(value);
+    let key = key.parse::<i32>().ok()?;
+    let token = match key {
+        -100 => "key.mouse.left".to_string(),
+        -99 => "key.mouse.right".to_string(),
+        -98 => "key.mouse.middle".to_string(),
+        -97..=-85 => format!("key.mouse.{}", key + 101),
+        _ => LEGACY_KEY_BINDINGS
+            .iter()
+            .find(|(legacy, _)| *legacy == key)
+            .map(|(_, token)| (*token).to_string())?,
+    };
+    Some(append_key_modifier(token, modifier))
+}
+
+pub(in crate::api::instance) fn token_key_binding_to_legacy(
+    value: &str,
+) -> Option<String> {
+    let (token, modifier) = split_key_binding(value);
+    let key = match token {
+        "key.mouse.left" => -100,
+        "key.mouse.right" => -99,
+        "key.mouse.middle" => -98,
+        _ => {
+            if let Some(button) = token.strip_prefix("key.mouse.") {
+                let button = button.parse::<i32>().ok()?;
+                if !(4..=16).contains(&button) {
+                    return None;
+                }
+                button - 101
+            } else {
+                LEGACY_KEY_BINDINGS
+                    .iter()
+                    .find(|(_, candidate)| *candidate == token)
+                    .map(|(legacy, _)| *legacy)?
+            }
+        }
+    };
+    Some(append_key_modifier(key.to_string(), modifier))
+}
+
+pub(in crate::api::instance) fn valid_modern_key_binding(value: &str) -> bool {
+    let (key, modifier) = split_key_binding(value);
+    let key_valid = ["key.keyboard.", "key.mouse.", "scancode."]
+        .into_iter()
+        .find_map(|prefix| key.strip_prefix(prefix))
+        .is_some_and(|identifier| {
+            !identifier.is_empty()
+                && identifier.chars().all(|character| {
+                    character.is_ascii_alphanumeric()
+                        || matches!(character, '.' | '_' | '-')
+                })
+        });
+    key_valid
+        && modifier.is_none_or(|modifier| {
+            !modifier.is_empty()
+                && modifier.len() <= 64
+                && modifier.chars().all(|character| {
+                    character.is_ascii_alphanumeric()
+                        || matches!(character, '.' | '_' | '-' | ':' | '+')
+                })
+        })
+}
+
+pub(in crate::api::instance) fn supported_settings_cover_game_version(
+    version: &str,
+) -> bool {
+    if version.contains('w') || version.contains("snapshot") {
+        return false;
+    }
+    let components = version
+        .split('.')
+        .map(|component| component.parse::<u32>())
+        .collect::<Result<Vec<_>, _>>();
+    let Ok(components) = components else {
+        return false;
+    };
+    match components.as_slice() {
+        [1, minor] => *minor <= 21,
+        [1, minor, patch] => *minor < 21 || (*minor == 21 && *patch <= 11),
+        [26, minor] | [26, minor, _] => (1..=3).contains(minor),
+        _ => false,
+    }
+}
+
+pub(in crate::api::instance) fn decode_value(
+    definition: &SupportedSetting,
+    physical_key: &str,
+    raw: &str,
+) -> Option<CanonicalValue> {
+    match definition.encoding {
+        ValueEncoding::Bool => match raw {
+            "true" => Some(CanonicalValue::Bool(true)),
+            "false" => Some(CanonicalValue::Bool(false)),
+            _ => None,
+        },
+        ValueEncoding::Integer => {
+            raw.parse::<i64>().ok().map(CanonicalValue::Integer)
+        }
+        ValueEncoding::Decimal => raw
+            .parse::<f64>()
+            .ok()
+            .filter(|value| value.is_finite())
+            .map(|_| CanonicalValue::Decimal(raw.to_string())),
+        ValueEncoding::Enum(choices) => {
+            let value = decode_string_token(raw)?;
+            choices
+                .contains(&value.as_str())
+                .then(|| CanonicalValue::Enum(value))
+        }
+        ValueEncoding::Text => Some(CanonicalValue::Text(raw.to_string())),
+        ValueEncoding::KeyBinding => {
+            if valid_modern_key_binding(raw) {
+                Some(CanonicalValue::KeyBinding(raw.to_string()))
+            } else {
+                legacy_key_binding_to_token(raw).map(CanonicalValue::KeyBinding)
+            }
+        }
+        ValueEncoding::Fov => raw.parse::<f64>().ok().and_then(|value| {
+            let degrees = value * 40.0 + 70.0;
+            (value.is_finite()
+                && (-1.0..=1.0).contains(&value)
+                && (degrees - degrees.round()).abs() <= 0.000_001)
+                .then(|| CanonicalValue::Integer(degrees.round() as i64))
+        }),
+        ValueEncoding::Graphics => {
+            let raw = decode_string_token(raw)?;
+            let value = match physical_key {
+                "fancyGraphics" => match raw.as_str() {
+                    "false" => "fast",
+                    "true" => "fancy",
+                    _ => return None,
+                },
+                "graphicsMode" => match raw.as_str() {
+                    "0" => "fast",
+                    "1" => "fancy",
+                    "2" => "fabulous",
+                    _ => return None,
+                },
+                "graphicsPreset" if GRAPHICS_VALUES.contains(&raw.as_str()) => {
+                    raw.as_str()
+                }
+                _ => return None,
+            };
+            Some(CanonicalValue::Enum(value.to_string()))
+        }
+        ValueEncoding::AmbientOcclusion => {
+            let value = match raw {
+                "false" | "0" => "off",
+                "true" => "on",
+                "1" => "minimum",
+                "2" => "maximum",
+                _ => return None,
+            };
+            Some(CanonicalValue::Enum(value.to_string()))
+        }
+        ValueEncoding::MusicToast => {
+            let raw = decode_string_token(raw)?;
+            let value = match (physical_key, raw.as_str()) {
+                ("showNowPlayingToast", "false") => "never",
+                ("showNowPlayingToast", "true") => "pause_and_toast",
+                ("musicToast", "never" | "pause" | "pause_and_toast") => {
+                    raw.as_str()
+                }
+                _ => return None,
+            };
+            Some(CanonicalValue::Enum(value.to_string()))
+        }
+    }
+}
+
+pub(in crate::api::instance) fn encode_value(
+    definition: &SupportedSetting,
+    physical_key: &str,
+    value: &CanonicalValue,
+    game_version: &str,
+    current_raw: Option<&str>,
+) -> Option<String> {
+    if let Some(current_raw) = current_raw
+        && physical_representation_supported_for_target(
+            definition,
+            physical_key,
+            current_raw,
+            game_version,
+        )
+        && decode_value(definition, physical_key, current_raw)
+            .as_ref()
+            .is_some_and(|current| canonical_values_equal(current, value))
+    {
+        return Some(current_raw.to_string());
+    }
+    match (definition.encoding, value) {
+        (ValueEncoding::Bool, CanonicalValue::Bool(value)) => {
+            Some(value.to_string())
+        }
+        (ValueEncoding::Integer, CanonicalValue::Integer(value)) => {
+            Some(value.to_string())
+        }
+        (ValueEncoding::Decimal, CanonicalValue::Decimal(value)) => {
+            Some(value.clone())
+        }
+        (ValueEncoding::Decimal, CanonicalValue::Integer(value)) => {
+            Some(value.to_string())
+        }
+        (ValueEncoding::Enum(choices), CanonicalValue::Enum(value))
+            if choices.contains(&value.as_str()) =>
+        {
+            if current_raw.is_some_and(|raw| raw.starts_with('"')) {
+                encode_string_token(value)
+            } else {
+                Some(value.clone())
+            }
+        }
+        (ValueEncoding::Text, CanonicalValue::Text(value)) => {
+            Some(value.clone())
+        }
+        (ValueEncoding::KeyBinding, CanonicalValue::KeyBinding(value))
+            if valid_modern_key_binding(value) =>
+        {
+            if !uses_modern_key_tokens(game_version) {
+                token_key_binding_to_legacy(value)
+            } else {
+                Some(value.clone())
+            }
+        }
+        (ValueEncoding::Fov, CanonicalValue::Integer(value))
+            if (30..=110).contains(value) =>
+        {
+            let normalized = (*value as f64 - 70.0) / 40.0;
+            Some(format_decimal(normalized))
+        }
+        (ValueEncoding::Graphics, CanonicalValue::Enum(value)) => {
+            match physical_key {
+                "fancyGraphics" => match value.as_str() {
+                    "fast" => Some("false".to_string()),
+                    "fancy" => Some("true".to_string()),
+                    _ => None,
+                },
+                "graphicsMode" => match value.as_str() {
+                    "fast" => Some("0".to_string()),
+                    "fancy" => Some("1".to_string()),
+                    "fabulous" => Some("2".to_string()),
+                    _ => None,
+                },
+                "graphicsPreset"
+                    if GRAPHICS_VALUES.contains(&value.as_str()) =>
+                {
+                    encode_string_token(value)
+                }
+                _ => None,
+            }
+        }
+        (ValueEncoding::AmbientOcclusion, CanonicalValue::Enum(value)) => {
+            let target_is_legacy = release_version(game_version)
+                .is_some_and(|version| version <= (1, 19, 3));
+            if target_is_legacy {
+                match value.as_str() {
+                    "off" => Some("0".to_string()),
+                    "minimum" => Some("1".to_string()),
+                    "maximum" => Some("2".to_string()),
+                    _ => None,
+                }
+            } else {
+                match value.as_str() {
+                    "off" => Some("false".to_string()),
+                    "on" => Some("true".to_string()),
+                    _ => None,
+                }
+            }
+        }
+        (ValueEncoding::MusicToast, CanonicalValue::Enum(value)) => {
+            match physical_key {
+                "showNowPlayingToast" => match value.as_str() {
+                    "never" => Some("false".to_string()),
+                    "pause_and_toast" => Some("true".to_string()),
+                    _ => None,
+                },
+                "musicToast"
+                    if MUSIC_TOAST_VALUES.contains(&value.as_str()) =>
+                {
+                    encode_string_token(value)
+                }
+                _ => None,
+            }
+        }
+        _ => None,
+    }
+}
+
+fn validate_value(
+    definition: Option<&SupportedSetting>,
+    value: &CanonicalValue,
+    enforce_editor_increment: bool,
+) -> crate::Result<()> {
+    if let Some(definition) = definition {
+        let type_valid = match definition.encoding {
+            ValueEncoding::Bool => matches!(value, CanonicalValue::Bool(_)),
+            ValueEncoding::Integer => {
+                matches!(value, CanonicalValue::Integer(_))
+            }
+            ValueEncoding::Decimal => matches!(
+                value,
+                CanonicalValue::Decimal(_) | CanonicalValue::Integer(_)
+            ),
+            ValueEncoding::Enum(_)
+            | ValueEncoding::Graphics
+            | ValueEncoding::AmbientOcclusion
+            | ValueEncoding::MusicToast => {
+                matches!(value, CanonicalValue::Enum(_))
+            }
+            ValueEncoding::Text => matches!(value, CanonicalValue::Text(_)),
+            ValueEncoding::Fov => matches!(value, CanonicalValue::Integer(_)),
+            ValueEncoding::KeyBinding => {
+                matches!(value, CanonicalValue::KeyBinding(_))
+            }
+        };
+        if !type_valid {
+            return Err(input_error(format!(
+                "Invalid value type for {}",
+                definition.id
+            )));
+        }
+        match (definition.editor, value) {
+            (
+                SettingEditor::Integer { min, max, step },
+                CanonicalValue::Integer(value),
+            ) if *value < min
+                || *value > max
+                || enforce_editor_increment
+                    && step > 0
+                    && (*value - min) % step != 0 =>
+            {
+                return Err(input_error(format!(
+                    "{} is outside its supported range or increment",
+                    definition.id
+                )));
+            }
+            (
+                SettingEditor::Decimal { min, max, step, .. },
+                CanonicalValue::Decimal(value),
+            ) => {
+                let parsed = value
+                    .parse::<f64>()
+                    .map_err(|_| input_error("Invalid decimal value"))?;
+                let increment = (parsed - min) / step;
+                if !parsed.is_finite()
+                    || parsed < min
+                    || parsed > max
+                    || enforce_editor_increment
+                        && step > 0.0
+                        && (increment - increment.round()).abs() > 0.000_001
+                {
+                    return Err(input_error(format!(
+                        "{} is outside its supported range or increment",
+                        definition.id
+                    )));
+                }
+            }
+            (
+                SettingEditor::Decimal { min, max, step, .. },
+                CanonicalValue::Integer(value),
+            ) => {
+                let parsed = *value as f64;
+                let increment = (parsed - min) / step;
+                if parsed < min
+                    || parsed > max
+                    || enforce_editor_increment
+                        && step > 0.0
+                        && (increment - increment.round()).abs() > 0.000_001
+                {
+                    return Err(input_error(format!(
+                        "{} is outside its supported range or increment",
+                        definition.id
+                    )));
+                }
+            }
+            (SettingEditor::Enum(choices), CanonicalValue::Enum(value))
+                if !choices.iter().any(|choice| *choice == value.as_str()) =>
+            {
+                return Err(input_error(format!(
+                    "Invalid choice for {}",
+                    definition.id
+                )));
+            }
+            (SettingEditor::Language, CanonicalValue::Text(value))
+                if value.is_empty()
+                    || value.len() > 64
+                    || value.chars().any(char::is_control) =>
+            {
+                return Err(input_error("Invalid language value"));
+            }
+            (SettingEditor::KeyBinding, CanonicalValue::KeyBinding(value))
+                if value.len() > 256
+                    || value.contains(['\r', '\n'])
+                    || !valid_modern_key_binding(value) =>
+            {
+                return Err(input_error("Invalid key binding value"));
+            }
+            _ => {}
+        }
+    } else if let CanonicalValue::ExternalRaw(raw) = value {
+        validate_raw_key_value("external", raw)?;
+    } else {
+        return Err(input_error("Custom settings require a raw string value"));
+    }
+    Ok(())
+}
+
+pub(in crate::api::instance) fn validate_canonical_value(
+    definition: Option<&SupportedSetting>,
+    value: &CanonicalValue,
+) -> crate::Result<()> {
+    validate_value(definition, value, true)
+}
+
+pub(in crate::api::instance) fn validate_file_value(
+    definition: Option<&SupportedSetting>,
+    value: &CanonicalValue,
+) -> crate::Result<()> {
+    validate_value(definition, value, false)
+}
+
+pub(in crate::api::instance) fn decode_value_for_version(
+    definition: &SupportedSetting,
+    physical_key: &str,
+    raw: &str,
+    game_version: &str,
+) -> Option<CanonicalValue> {
+    let value = decode_value(definition, physical_key, raw)?;
+    validate_file_value(Some(definition), &value).ok()?;
+    let target_key = if definition.versioned_keys.is_empty() {
+        physical_key
+    } else {
+        physical_variant_for_version(definition, game_version)?.key
+    };
+    encode_value(definition, target_key, &value, game_version, None)?;
+    Some(value)
+}
+
+pub(in crate::api::instance) fn target_physical_key(
+    definition: Option<&SupportedSetting>,
+    stored: &StoredOption,
+    document: &GameOptionsDocument,
+    game_version: &str,
+) -> Option<String> {
+    if let Some(definition) = definition {
+        if !definition.versioned_keys.is_empty() {
+            observed_physical_key(definition, document, game_version)?;
+            return physical_variant_for_version(definition, game_version)
+                .map(|variant| variant.key.to_string());
+        }
+        definition
+            .keys
+            .iter()
+            .find(|key| document.value(key).is_some())
+            .map(|key| (*key).to_string())
+    } else {
+        stored.raw_key.clone()
+    }
+}
+
+pub(in crate::api::instance) fn observed_physical_key(
+    definition: &SupportedSetting,
+    document: &GameOptionsDocument,
+    game_version: &str,
+) -> Option<String> {
+    if let Some(target) = physical_variant_for_version(definition, game_version)
+        && document.value(target.key).is_some()
+    {
+        return Some(target.key.to_string());
+    }
+    definition
+        .keys
+        .iter()
+        .find(|key| document.value(key).is_some())
+        .map(|key| (*key).to_string())
+}
+
+pub(in crate::api::instance) fn alias_migration_needed(
+    definition: &SupportedSetting,
+    document: &GameOptionsDocument,
+    target_key: &str,
+) -> bool {
+    document.value(target_key).is_none()
+        && definition
+            .keys
+            .iter()
+            .any(|key| *key != target_key && document.value(key).is_some())
+}
+
+pub(in crate::api::instance) fn physical_representation_supported_for_target(
+    definition: &SupportedSetting,
+    physical_key: &str,
+    raw: &str,
+    game_version: &str,
+) -> bool {
+    let Some(target_version) = release_version(game_version) else {
+        return false;
+    };
+    if matches!(definition.encoding, ValueEncoding::KeyBinding) {
+        return if target_version >= (1, 13, 0) {
+            valid_modern_key_binding(raw)
+        } else {
+            legacy_key_binding_to_token(raw).is_some()
+        };
+    }
+    if matches!(definition.encoding, ValueEncoding::AmbientOcclusion) {
+        return if target_version >= (1, 19, 4) {
+            matches!(raw, "true" | "false")
+        } else {
+            matches!(raw, "0" | "1" | "2")
+        };
+    }
+
+    let mut variants = definition
+        .versioned_keys
+        .iter()
+        .filter(|variant| variant.key == physical_key)
+        .peekable();
+    if variants.peek().is_none() {
+        return true;
+    }
+    variants.any(|variant| {
+        release_version(variant.since)
+            .is_some_and(|since| since <= target_version)
+            && release_version(variant.until)
+                .is_some_and(|until| target_version <= until)
+    })
+}
+
+pub(in crate::api::instance) fn format_decimal(value: f64) -> String {
+    let value = format!("{value:.8}");
+    let value = value.trim_end_matches('0').trim_end_matches('.');
+    if value == "-0" {
+        "0".to_string()
+    } else {
+        value.to_string()
+    }
+}
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/catalog/video.rs b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/video.rs
new file mode 100644
index 0000000000..467ee62615
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/catalog/video.rs
@@ -0,0 +1,162 @@
+use super::{
+    BOOL, SettingEditor, SupportedSetting, ValueEncoding, setting,
+    version_changes, versioned_setting,
+};
+
+const GRAPHICS: &[&str] = &["fast", "fancy", "fabulous", "custom"];
+const AMBIENT_OCCLUSION: &[&str] = &["off", "on", "minimum", "maximum"];
+const PARTICLES: &[&str] = &["0", "1", "2"];
+const CLOUDS: &[&str] = &["false", "fast", "true"];
+
+pub(super) const SETTINGS: &[SupportedSetting] = &[
+    setting(
+        "fov",
+        &["fov"],
+        "video",
+        true,
+        SettingEditor::Integer {
+            min: 30,
+            max: 110,
+            step: 1,
+        },
+        ValueEncoding::Fov,
+    ),
+    versioned_setting(
+        "graphics",
+        &["graphicsPreset", "graphicsMode", "fancyGraphics"],
+        version_changes::GRAPHICS_KEYS,
+        "video",
+        true,
+        SettingEditor::Enum(GRAPHICS),
+        ValueEncoding::Graphics,
+    ),
+    versioned_setting(
+        "ambient_occlusion",
+        &["ao"],
+        version_changes::AMBIENT_OCCLUSION_KEYS,
+        "video",
+        true,
+        SettingEditor::Enum(AMBIENT_OCCLUSION),
+        ValueEncoding::AmbientOcclusion,
+    ),
+    setting(
+        "render_distance",
+        &["renderDistance"],
+        "video",
+        false,
+        SettingEditor::Integer {
+            min: 2,
+            max: 64,
+            step: 1,
+        },
+        ValueEncoding::Integer,
+    ),
+    setting(
+        "simulation_distance",
+        &["simulationDistance"],
+        "video",
+        false,
+        SettingEditor::Integer {
+            min: 2,
+            max: 64,
+            step: 1,
+        },
+        ValueEncoding::Integer,
+    ),
+    setting(
+        "gui_scale",
+        &["guiScale"],
+        "video",
+        true,
+        SettingEditor::Integer {
+            min: 0,
+            max: 8,
+            step: 1,
+        },
+        ValueEncoding::Integer,
+    ),
+    setting(
+        "particles",
+        &["particles"],
+        "video",
+        true,
+        SettingEditor::Enum(PARTICLES),
+        ValueEncoding::Enum(PARTICLES),
+    ),
+    setting(
+        "clouds",
+        &["renderClouds"],
+        "video",
+        true,
+        SettingEditor::Enum(CLOUDS),
+        ValueEncoding::Enum(CLOUDS),
+    ),
+    setting(
+        "entity_shadows",
+        &["entityShadows"],
+        "video",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "view_bobbing",
+        &["bobView"],
+        "video",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "vsync",
+        &["enableVsync"],
+        "video",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "fullscreen",
+        &["fullscreen"],
+        "video",
+        true,
+        BOOL,
+        ValueEncoding::Bool,
+    ),
+    setting(
+        "max_framerate",
+        &["maxFps"],
+        "video",
+        true,
+        SettingEditor::Integer {
+            min: 10,
+            max: 260,
+            step: 10,
+        },
+        ValueEncoding::Integer,
+    ),
+    setting(
+        "mipmap_levels",
+        &["mipmapLevels"],
+        "video",
+        false,
+        SettingEditor::Integer {
+            min: 0,
+            max: 4,
+            step: 1,
+        },
+        ValueEncoding::Integer,
+    ),
+    setting(
+        "biome_blend_radius",
+        &["biomeBlendRadius"],
+        "video",
+        true,
+        SettingEditor::Integer {
+            min: 0,
+            max: 7,
+            step: 1,
+        },
+        ValueEncoding::Integer,
+    ),
+];
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/fullscreen.rs b/packages/app-lib/src/api/instance/synced_options/game_options/fullscreen.rs
new file mode 100644
index 0000000000..d52df69396
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/fullscreen.rs
@@ -0,0 +1,127 @@
+//! Keeps the app-wide fullscreen setting aligned with the shared Minecraft value.
+
+use super::CATALOG_REVISION;
+use crate::state::{
+    CanonicalValue, State, load_game_option_preferences,
+    load_game_options_sync_state, load_shared_game_options,
+};
+use chrono::Utc;
+use sqlx::{Sqlite, Transaction};
+
+const FULLSCREEN_OPTION_ID: &str = "fullscreen";
+
+pub(crate) async fn shared_fullscreen_value(
+    state: &State,
+) -> crate::Result<Option<bool>> {
+    let preferences = load_game_option_preferences(&state.pool).await?;
+    if !preferences
+        .get(FULLSCREEN_OPTION_ID)
+        .is_some_and(|preference| preference.enabled)
+    {
+        return Ok(None);
+    }
+    let values = load_shared_game_options(&state.pool).await?;
+    Ok(values.get(FULLSCREEN_OPTION_ID).and_then(|stored| {
+        if !stored.seeded {
+            return None;
+        }
+        match stored.value.as_ref() {
+            Some(CanonicalValue::Bool(value)) => Some(*value),
+            _ => None,
+        }
+    }))
+}
+
+pub(crate) async fn update_shared_fullscreen_from_app(
+    state: &State,
+    value: bool,
+) -> crate::Result<bool> {
+    let values = load_shared_game_options(&state.pool).await?;
+    let preferences = load_game_option_preferences(&state.pool).await?;
+    let stored = values.get(FULLSCREEN_OPTION_ID);
+    let preference = preferences.get(FULLSCREEN_OPTION_ID);
+    let value_matches = stored.is_some_and(|stored| {
+        stored.seeded
+            && matches!(
+                stored.value.as_ref(),
+                Some(CanonicalValue::Bool(current)) if *current == value
+            )
+    });
+    let sync_enabled = preference.is_some_and(|preference| preference.enabled);
+    if !sync_enabled || value_matches {
+        return Ok(false);
+    }
+
+    let option_revision = stored
+        .map(|stored| stored.revision)
+        .unwrap_or(0)
+        .max(
+            preference
+                .map(|preference| preference.revision)
+                .unwrap_or(0),
+        )
+        .saturating_add(1) as i64;
+    let (canonical_revision, _) =
+        load_game_options_sync_state(&state.pool, CATALOG_REVISION).await?;
+    let next_canonical_revision = canonical_revision.saturating_add(1) as i64;
+    let canonical = CanonicalValue::Bool(value);
+    let value_json = serde_json::to_string(&canonical)?;
+    let canonical_type = canonical.type_name();
+    let now = Utc::now().timestamp();
+    let catalog_revision = CATALOG_REVISION as i64;
+    let kind = "vanilla";
+    let raw_key: Option<&str> = None;
+    let value_codec = "catalog";
+    let source_game_version: Option<&str> = None;
+    let mut tx = state.pool.begin().await?;
+
+    sqlx::query!(
+        "\n\t\t\t\tINSERT INTO synced_game_option_values\n\t\t\t\t\t(option_id, kind, raw_key, canonical_type,\n\t\t\t\t\t canonical_value_json, value_codec, seeded, revision, origin,\n\t\t\t\t\t source_game_version, source_instance_id, updated_at)\n\t\t\t\tVALUES (?, ?, ?, ?, ?, ?, 1, ?, 'app_editor', ?, NULL, ?)\n\t\t\t\tON CONFLICT(option_id) DO UPDATE SET\n\t\t\t\t\tkind = excluded.kind, raw_key = excluded.raw_key,\n\t\t\t\t\tcanonical_type = excluded.canonical_type,\n\t\t\t\t\tcanonical_value_json = excluded.canonical_value_json,\n\t\t\t\t\tvalue_codec = excluded.value_codec, seeded = 1,\n\t\t\t\t\trevision = excluded.revision, origin = 'app_editor',\n\t\t\t\t\tsource_game_version = NULL, source_instance_id = NULL,\n\t\t\t\t\tupdated_at = excluded.updated_at\n\t\t\t\t",
+        FULLSCREEN_OPTION_ID,
+        kind,
+        raw_key,
+        canonical_type,
+        value_json,
+        value_codec,
+        option_revision,
+        source_game_version,
+        now,
+    )
+    .execute(&mut *tx)
+    .await?;
+    sqlx::query!(
+        "\n\t\t\t\tINSERT INTO synced_game_option_preferences\n\t\t\t\t\t(option_id, enabled, source, revision)\n\t\t\t\tVALUES (?, ?, ?, ?)\n\t\t\t\tON CONFLICT(option_id) DO UPDATE SET\n\t\t\t\t\tenabled = excluded.enabled, source = 'user',\n\t\t\t\t\trevision = excluded.revision\n\t\t\t\t",
+        FULLSCREEN_OPTION_ID,
+        true,
+        "user",
+        option_revision,
+    )
+    .execute(&mut *tx)
+    .await?;
+    sqlx::query!(
+        "\n\t\t\tINSERT INTO synced_game_option_state (singleton, revision, catalog_revision)\n\t\t\tVALUES (1, ?, ?)\n\t\t\tON CONFLICT(singleton) DO UPDATE SET\n\t\t\t\trevision = excluded.revision,\n\t\t\t\tcatalog_revision = excluded.catalog_revision\n\t\t\t",
+        next_canonical_revision,
+        catalog_revision,
+    )
+    .execute(&mut *tx)
+    .await?;
+    tx.commit().await?;
+    Ok(true)
+}
+
+pub(super) async fn update_app_fullscreen_setting(
+    tx: &mut Transaction<'_, Sqlite>,
+    value: &CanonicalValue,
+    sync_enabled: bool,
+) -> crate::Result<()> {
+    if !sync_enabled {
+        return Ok(());
+    }
+    let CanonicalValue::Bool(value) = value else {
+        return Ok(());
+    };
+    let mut settings = crate::state::Settings::get(&mut **tx).await?;
+    settings.force_fullscreen = *value;
+    settings.update(&mut **tx).await?;
+    Ok(())
+}
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/instance_support.rs b/packages/app-lib/src/api/instance/synced_options/game_options/instance_support.rs
new file mode 100644
index 0000000000..be678994f6
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/instance_support.rs
@@ -0,0 +1,510 @@
+//! Works out which instances can receive each shared setting.
+
+use super::super as synced_options;
+use super::CATALOG_REVISION;
+use super::api_types::*;
+use super::catalog::*;
+use super::options_file::{
+    GameOptionsDocument, options_path, read_document, sha1_bytes,
+};
+use crate::state::{
+    CanonicalValue, InstanceMetadata, State, StoredOption,
+    game_options_sync_is_enabled,
+};
+use std::collections::BTreeMap;
+
+/// The instance data needed to decide whether a setting can be synced.
+#[derive(Clone)]
+pub(super) struct ParticipatingInstance {
+    metadata: InstanceMetadata,
+    deferred: bool,
+    fullscreen_controlled: bool,
+    pub(super) document: Option<GameOptionsDocument>,
+    inspection_error: Option<String>,
+}
+
+/// Loads every instance with game-settings sync turned on.
+///
+/// An instance may not have an `options.txt` until its first launch. It still takes
+/// part in sync, but its settings are marked as waiting for the file.
+pub(super) async fn load_participating_instances(
+    state: &State,
+) -> crate::Result<Vec<ParticipatingInstance>> {
+    if !game_options_sync_is_enabled(&state.pool).await? {
+        return Ok(Vec::new());
+    }
+    let instances = crate::state::list_instances(&state.pool).await?;
+    let mut participants = Vec::new();
+    for metadata in instances {
+        if !metadata.synced_options.game_options {
+            continue;
+        }
+        let deferred = synced_options::sync_files_are_protected(&metadata);
+        let path = options_path(&metadata, state);
+        let (document, inspection_error) = if path.exists() {
+            match read_document(&path).await {
+                Ok((document, _)) => (Some(document), None),
+                Err(error) => {
+                    tracing::warn!(
+                        "Could not inspect game options compatibility for {}: {error}",
+                        metadata.instance.id
+                    );
+                    (None, Some(error.to_string()))
+                }
+            }
+        } else {
+            (None, None)
+        };
+        participants.push(ParticipatingInstance {
+            fullscreen_controlled: metadata
+                .launch_overrides
+                .force_fullscreen
+                .is_some(),
+            metadata,
+            deferred,
+            document,
+            inspection_error,
+        });
+    }
+    Ok(participants)
+}
+
+pub(super) fn summary_revision(
+    canonical_revision: u64,
+    participants: &[ParticipatingInstance],
+) -> String {
+    let mut summary = format!("{CATALOG_REVISION}:{canonical_revision}");
+    let mut participants = participants.iter().collect::<Vec<_>>();
+    participants.sort_by(|left, right| {
+        left.metadata.instance.id.cmp(&right.metadata.instance.id)
+    });
+    for participant in participants {
+        summary.push('|');
+        summary.push_str(&participant.metadata.instance.id);
+        summary.push(':');
+        summary
+            .push_str(&participant.metadata.applied_content_set.game_version);
+        summary.push(':');
+        summary.push_str(if participant.deferred {
+            "deferred"
+        } else {
+            "ready"
+        });
+        summary.push(':');
+        summary.push_str(if participant.inspection_error.is_some() {
+            "degraded"
+        } else if participant.document.is_some() {
+            "file"
+        } else {
+            "missing"
+        });
+        summary.push(':');
+        summary.push_str(if participant.fullscreen_controlled {
+            "fullscreen-controlled"
+        } else {
+            "fullscreen-shared"
+        });
+    }
+    sha1_bytes(summary.as_bytes())
+}
+/// Counts which instances can receive a setting now, later, or not at all.
+///
+/// The settings screen uses these results for its preview, and the file writer uses
+/// the same checks when it saves. A setting shown as blocked therefore cannot be
+/// written behind the user's back.
+pub(super) fn describe_instance_support(
+    definition: Option<&SupportedSetting>,
+    stored: &StoredOption,
+    value: Option<&CanonicalValue>,
+    participants: &[ParticipatingInstance],
+) -> GameOptionCompatibility {
+    let total = participants.len() as u32;
+    let mut will_receive = 0;
+    let mut write_now = 0;
+    let mut buckets: BTreeMap<
+        (String, String, String, String),
+        GameOptionCompatibilityBucket,
+    > = BTreeMap::new();
+
+    for participant in participants {
+        let version = participant
+            .metadata
+            .applied_content_set
+            .game_version
+            .clone();
+        // Check launcher-controlled settings first. Finding the key in options.txt
+        // does not make a launcher-owned setting safe to overwrite.
+        let (status, key, mapping, reason) = if stored.option_id == "fullscreen"
+            && participant.fullscreen_controlled
+        {
+            (
+                GameOptionCompatibilityStatus::Controlled,
+                None,
+                None,
+                Some(GameOptionCompatibilityReason::LauncherControlled),
+            )
+        } else if definition.is_some()
+            && !supported_settings_cover_game_version(&version)
+        {
+            (
+                GameOptionCompatibilityStatus::CatalogUncovered,
+                None,
+                None,
+                Some(GameOptionCompatibilityReason::CatalogUncovered),
+            )
+        } else if participant.inspection_error.is_some() {
+            (
+                GameOptionCompatibilityStatus::Degraded,
+                None,
+                None,
+                Some(GameOptionCompatibilityReason::InspectionFailed),
+            )
+        } else {
+            match &participant.document {
+                None => {
+                    // An instance that has not launched yet has no options.txt. If we know
+                    // the key Minecraft will create, wait for the file instead of excluding it.
+                    if definition.is_none()
+                        && stored.raw_key.is_some()
+                        && matches!(value, Some(CanonicalValue::ExternalRaw(_)))
+                    {
+                        (
+						GameOptionCompatibilityStatus::WaitingForFile,
+						stored.raw_key.clone(),
+						Some(GameOptionMappingKind::Direct),
+						Some(GameOptionCompatibilityReason::WaitingForOptionsFile),
+					)
+                    } else if let Some((key, mapping)) =
+                        definition.and_then(|definition| {
+                            physical_variant_for_version(definition, &version)
+                                .map(|variant| (variant.key, variant.mapping))
+                                .or_else(|| {
+                                    definition
+                                        .versioned_keys
+                                        .is_empty()
+                                        .then(|| {
+                                            definition
+										.keys
+										.first()
+										.copied()
+										.map(|key| (key, GameOptionMappingKind::Direct))
+                                        })
+                                        .flatten()
+                                })
+                        })
+                    {
+                        let representable = value.is_none_or(|value| {
+                            definition.is_some_and(|definition| {
+                                encode_value(
+                                    definition, key, value, &version, None,
+                                )
+                                .is_some()
+                            })
+                        });
+                        if representable {
+                            (
+							GameOptionCompatibilityStatus::WaitingForFile,
+							Some(key.to_string()),
+							Some(mapping),
+							Some(GameOptionCompatibilityReason::WaitingForOptionsFile),
+						)
+                        } else {
+                            (
+							GameOptionCompatibilityStatus::UnsupportedValue,
+							Some(key.to_string()),
+							None,
+							Some(GameOptionCompatibilityReason::UnsupportedValue),
+						)
+                        }
+                    } else {
+                        (
+                            GameOptionCompatibilityStatus::NotAvailable,
+                            None,
+                            None,
+                            Some(GameOptionCompatibilityReason::MissingSetting),
+                        )
+                    }
+                }
+                Some(document) => {
+                    // Vanilla keys sometimes change between versions. Replace an old key with
+                    // its newer name only when we know the value can be converted safely.
+                    let key = target_physical_key(
+                        definition, stored, document, &version,
+                    );
+                    if let Some(key) = key {
+                        let needs_alias_migration =
+                            definition.is_some_and(|definition| {
+                                alias_migration_needed(
+                                    definition, document, &key,
+                                )
+                            });
+                        let representable =
+                            value.is_none_or(|value| match definition {
+                                Some(definition) => encode_value(
+                                    definition,
+                                    &key,
+                                    value,
+                                    &version,
+                                    document.value(&key),
+                                )
+                                .is_some(),
+                                None => matches!(
+                                    value,
+                                    CanonicalValue::ExternalRaw(_)
+                                ),
+                            });
+                        if !representable {
+                            (
+							GameOptionCompatibilityStatus::UnsupportedValue,
+							Some(key.to_string()),
+							None,
+							Some(GameOptionCompatibilityReason::UnsupportedValue),
+						)
+                        } else {
+                            let mapped = if needs_alias_migration {
+                                Some(GameOptionMappingKind::Migrated)
+                            } else {
+                                definition.and_then(|definition| {
+                                    physical_variant_for_present_key(
+                                        definition, &key, &version,
+                                    )
+                                    .map(|variant| variant.mapping)
+                                    .or_else(|| {
+                                        (matches!(
+                                            definition.encoding,
+                                            ValueEncoding::KeyBinding
+                                        ) && document.value(&key).is_some_and(
+                                            |raw| {
+                                                split_key_binding(raw)
+                                                    .0
+                                                    .parse::<i32>()
+                                                    .is_ok()
+                                            },
+                                        ))
+                                        .then_some(
+                                            GameOptionMappingKind::Migrated,
+                                        )
+                                    })
+                                })
+                            };
+                            let legacy = definition.is_some_and(|definition| {
+                                definition.keys.first().copied()
+                                    != Some(key.as_str())
+                            });
+                            (
+							if participant.deferred {
+								GameOptionCompatibilityStatus::Deferred
+							} else {
+								GameOptionCompatibilityStatus::Ready
+							},
+							Some(key.to_string()),
+							Some(mapped.unwrap_or(if legacy {
+								GameOptionMappingKind::Legacy
+							} else {
+								GameOptionMappingKind::Direct
+							})),
+							needs_alias_migration
+								.then_some(GameOptionCompatibilityReason::MigratesOnWrite),
+						)
+                        }
+                    } else if let Some(definition) =
+                        definition.filter(|definition| {
+                            (definition.versioned_keys.is_empty()
+                                || physical_variant_for_version(
+                                    definition, &version,
+                                )
+                                .is_some())
+                                && definition
+                                    .keys
+                                    .iter()
+                                    .any(|key| document.value(key).is_some())
+                        })
+                    {
+                        let eventual_key =
+                            physical_variant_for_version(definition, &version)
+                                .map(|variant| variant.key.to_string())
+                                .or_else(|| {
+                                    definition
+                                        .keys
+                                        .iter()
+                                        .find(|key| {
+                                            document.value(key).is_some()
+                                        })
+                                        .map(|key| (*key).to_string())
+                                });
+                        let representable =
+                            eventual_key.as_deref().is_some_and(|key| {
+                                value.is_none_or(|value| {
+                                    encode_value(
+                                        definition, key, value, &version, None,
+                                    )
+                                    .is_some()
+                                })
+                            });
+                        if representable {
+                            (
+							GameOptionCompatibilityStatus::WaitingForBase,
+							eventual_key,
+							Some(GameOptionMappingKind::Migrated),
+							Some(GameOptionCompatibilityReason::WaitingForCompatibleBase),
+						)
+                        } else {
+                            (
+							GameOptionCompatibilityStatus::UnsupportedValue,
+							eventual_key,
+							None,
+							Some(GameOptionCompatibilityReason::UnsupportedValue),
+						)
+                        }
+                    } else {
+                        (
+                            GameOptionCompatibilityStatus::NotAvailable,
+                            None,
+                            None,
+                            Some(GameOptionCompatibilityReason::MissingSetting),
+                        )
+                    }
+                }
+            }
+        };
+
+        let receives = matches!(
+            status,
+            GameOptionCompatibilityStatus::Ready
+                | GameOptionCompatibilityStatus::Deferred
+                | GameOptionCompatibilityStatus::WaitingForFile
+                | GameOptionCompatibilityStatus::WaitingForBase
+        );
+        if receives {
+            will_receive += 1;
+        }
+        if matches!(status, GameOptionCompatibilityStatus::Ready) {
+            write_now += 1;
+        }
+        let status_key = serde_json::to_string(&status).unwrap_or_default();
+        let key_name = key.clone().unwrap_or_default();
+        let mapping_key = mapping
+            .as_ref()
+            .and_then(|mapping| serde_json::to_string(mapping).ok())
+            .unwrap_or_default();
+        let reason_key = reason
+            .as_ref()
+            .and_then(|reason| serde_json::to_string(reason).ok())
+            .unwrap_or_default();
+        // Group instances with the same result to keep the response small. Keep their
+        // Minecraft versions so the UI can explain which versions are affected.
+        let bucket = buckets
+            .entry((status_key, key_name.clone(), mapping_key, reason_key))
+            .or_insert_with(|| GameOptionCompatibilityBucket {
+                instance_count: 0,
+                write_keys: if matches!(
+                    status,
+                    GameOptionCompatibilityStatus::Ready
+                        | GameOptionCompatibilityStatus::Deferred
+                ) {
+                    key.clone().into_iter().collect()
+                } else {
+                    Vec::new()
+                },
+                eventual_keys: if matches!(
+                    status,
+                    GameOptionCompatibilityStatus::WaitingForFile
+                        | GameOptionCompatibilityStatus::WaitingForBase
+                ) {
+                    key.clone().into_iter().collect()
+                } else {
+                    Vec::new()
+                },
+                game_versions: vec![version.clone()],
+                status,
+                mapping,
+                reason,
+            });
+        bucket.instance_count += 1;
+        if !bucket.game_versions.contains(&version) {
+            bucket.game_versions.push(version);
+            bucket.game_versions.sort();
+        }
+    }
+
+    let left_local = total.saturating_sub(will_receive);
+    GameOptionCompatibility {
+        total_participating: total,
+        will_receive,
+        write_now,
+        left_local,
+        buckets: buckets.into_values().collect(),
+    }
+}
+
+/// Uses the local value only when every readable instance currently agrees on it.
+pub(super) fn find_common_local_value(
+    definition: Option<&SupportedSetting>,
+    stored: &StoredOption,
+    participants: &[ParticipatingInstance],
+) -> (Option<CanonicalValue>, GameOptionValueState) {
+    let mut values = Vec::new();
+    let mut invalid = false;
+    for participant in participants {
+        if stored.option_id == "fullscreen" && participant.fullscreen_controlled
+        {
+            continue;
+        }
+        if definition.is_some()
+            && !supported_settings_cover_game_version(
+                &participant.metadata.applied_content_set.game_version,
+            )
+        {
+            continue;
+        }
+        let Some(document) = &participant.document else {
+            continue;
+        };
+        let key = if let Some(definition) = definition {
+            observed_physical_key(
+                definition,
+                document,
+                &participant.metadata.applied_content_set.game_version,
+            )
+        } else {
+            target_physical_key(
+                None,
+                stored,
+                document,
+                &participant.metadata.applied_content_set.game_version,
+            )
+        };
+        let Some(key) = key else {
+            continue;
+        };
+        let Some(raw_value) = document.value(&key) else {
+            continue;
+        };
+        let value = if let Some(definition) = definition {
+            decode_value(definition, &key, raw_value)
+        } else {
+            Some(CanonicalValue::ExternalRaw(raw_value.to_string()))
+        };
+        if let Some(value) = value
+            .filter(|value| validate_file_value(definition, value).is_ok())
+        {
+            values.push(value);
+        } else {
+            invalid = true;
+        }
+    }
+    if invalid && values.is_empty() {
+        return (None, GameOptionValueState::Invalid);
+    }
+    let Some(first) = values.first().cloned() else {
+        return (None, GameOptionValueState::Unset);
+    };
+    if values
+        .iter()
+        .all(|value| canonical_values_equal(value, &first))
+    {
+        (Some(first), GameOptionValueState::UniformLocal)
+    } else {
+        (None, GameOptionValueState::Mixed)
+    }
+}
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/launch_overrides.rs b/packages/app-lib/src/api/instance/synced_options/game_options/launch_overrides.rs
new file mode 100644
index 0000000000..a095bb5398
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/launch_overrides.rs
@@ -0,0 +1,71 @@
+//! Writes synced settings and launcher overrides before Minecraft starts.
+
+use super::options_file::{
+    GameOptionsDocument, input_error, options_path, read_document, sha1_bytes,
+    validate_raw_key_value,
+};
+use super::write_shared_settings::{
+    apply_shared_settings_to_instance, remember_processed_sha,
+    sync_is_active_for_instance,
+};
+use crate::state::{InstanceMetadata, State};
+use crate::util::io;
+use std::collections::HashSet;
+
+pub(super) fn currently_launcher_owned_keys(
+    metadata: &InstanceMetadata,
+) -> HashSet<String> {
+    let mut keys = HashSet::new();
+    if metadata.launch_overrides.force_fullscreen.is_some() {
+        keys.insert("fullscreen".to_string());
+    }
+    keys
+}
+
+/// Writes canonical settings to `options.txt` before launch.
+pub async fn sync_before_launch(instance_id: &str) -> crate::Result<()> {
+    let state = State::get().await?;
+    let _guard = state.lock_synced_options().await;
+    let metadata = crate::state::get_instance(instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| input_error("Unknown instance"))?;
+    if sync_is_active_for_instance(&metadata, &state).await? {
+        let _ =
+            apply_shared_settings_to_instance(&metadata, &state, false).await?;
+    }
+    Ok(())
+}
+
+/// Applies launcher settings, such as forced fullscreen, after shared settings.
+///
+/// Stores the written file's hash so the watcher ignores the app's write.
+pub async fn apply_launcher_overrides(
+    instance_id: &str,
+    overrides: &[(String, String)],
+) -> crate::Result<()> {
+    if overrides.is_empty() {
+        return Ok(());
+    }
+    let state = State::get().await?;
+    let _guard = state.lock_synced_options().await;
+    let metadata = crate::state::get_instance(instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| input_error("Unknown instance"))?;
+    let path = options_path(&metadata, &state);
+    let (mut document, input_bytes) = if path.exists() {
+        read_document(&path).await?
+    } else {
+        (GameOptionsDocument::empty(), Vec::new())
+    };
+    for (key, value) in overrides {
+        validate_raw_key_value(key, value)?;
+        document.set(key, value, true)?;
+    }
+    let output_bytes = document.serialize()?;
+    let output_sha1 = sha1_bytes(&output_bytes);
+    if output_bytes != input_bytes {
+        io::write(&path, output_bytes).await?;
+    }
+    remember_processed_sha(instance_id, &output_sha1, &state).await?;
+    Ok(())
+}
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/local_settings_editor.rs b/packages/app-lib/src/api/instance/synced_options/game_options/local_settings_editor.rs
new file mode 100644
index 0000000000..98bd098252
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/local_settings_editor.rs
@@ -0,0 +1,424 @@
+//! Loads and saves the game settings stored by one unsynced instance.
+
+use super::super as synced_options;
+use super::CATALOG_REVISION;
+use super::api_types::*;
+use super::catalog::*;
+use super::launch_overrides::currently_launcher_owned_keys;
+use super::options_file::{
+    GameOptionsDocument, input_error, options_path, read_document, sha1_bytes,
+    validate_raw_key_value,
+};
+use super::read_instance_changes::custom_setting_id;
+use crate::state::{CanonicalValue, GameOptionKind, InstanceMetadata, State};
+use crate::util::io;
+use std::collections::HashSet;
+
+fn compatibility(controlled: bool) -> GameOptionCompatibility {
+    if controlled {
+        GameOptionCompatibility {
+            total_participating: 1,
+            will_receive: 0,
+            write_now: 0,
+            left_local: 1,
+            buckets: vec![GameOptionCompatibilityBucket {
+                instance_count: 1,
+                write_keys: Vec::new(),
+                eventual_keys: Vec::new(),
+                game_versions: Vec::new(),
+                status: GameOptionCompatibilityStatus::Controlled,
+                mapping: None,
+                reason: Some(
+                    GameOptionCompatibilityReason::LauncherControlled,
+                ),
+            }],
+        }
+    } else {
+        GameOptionCompatibility {
+            total_participating: 1,
+            will_receive: 1,
+            write_now: 1,
+            left_local: 0,
+            buckets: Vec::new(),
+        }
+    }
+}
+
+fn categories(settings: &[EditableGameSetting]) -> Vec<GameSettingCategory> {
+    [
+        "skin_customization",
+        "video",
+        "language",
+        "music_and_sound",
+        "controls",
+        "chat",
+        "accessibility",
+        "online",
+        "custom",
+    ]
+    .into_iter()
+    .filter(|id| settings.iter().any(|setting| setting.category_id == *id))
+    .map(|id| GameSettingCategory {
+        id: id.to_string(),
+        is_custom: id == "custom",
+    })
+    .collect()
+}
+
+fn editor_revision(metadata: &InstanceMetadata, input_bytes: &[u8]) -> String {
+    sha1_bytes(
+        format!(
+            "{CATALOG_REVISION}:{}:{}",
+            metadata.applied_content_set.game_version,
+            sha1_bytes(input_bytes)
+        )
+        .as_bytes(),
+    )
+}
+
+async fn load_instance_document(
+    instance_id: &str,
+    state: &State,
+) -> crate::Result<(
+    InstanceMetadata,
+    GameOptionsDocument,
+    Vec<u8>,
+    HashSet<String>,
+)> {
+    let metadata = crate::state::get_instance(instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| input_error("Unknown instance"))?;
+    if crate::state::game_options_sync_is_enabled(&state.pool).await?
+        && metadata.synced_options.game_options
+    {
+        return Err(input_error(
+            "This instance is using synced game settings.",
+        ));
+    }
+    if synced_options::sync_files_are_protected(&metadata) {
+        return Err(input_error(
+            "Game settings cannot be edited while this instance is installing or updating.",
+        ));
+    }
+    let path = options_path(&metadata, state);
+    if !path.exists() {
+        return Err(input_error(
+            "Launch this instance once so Minecraft can create options.txt.",
+        ));
+    }
+    let (document, input_bytes) = read_document(&path).await?;
+    let mut controlled_keys = currently_launcher_owned_keys(&metadata);
+    if metadata.launch_overrides.force_fullscreen.is_none()
+        && crate::state::Settings::get(&state.pool)
+            .await?
+            .force_fullscreen
+    {
+        controlled_keys.insert("fullscreen".to_string());
+    }
+    Ok((metadata, document, input_bytes, controlled_keys))
+}
+
+fn build_editor_state(
+    metadata: &InstanceMetadata,
+    document: &GameOptionsDocument,
+    input_bytes: &[u8],
+    controlled_keys: &HashSet<String>,
+) -> GameSettingsEditorState {
+    let game_version = metadata.applied_content_set.game_version.as_str();
+    let mut settings = Vec::new();
+
+    if supported_settings_cover_game_version(game_version) {
+        for definition in all_supported_settings() {
+            let Some(physical_key) =
+                observed_physical_key(definition, document, game_version)
+            else {
+                continue;
+            };
+            let Some(value) = document.value(&physical_key).and_then(|raw| {
+                decode_value_for_version(
+                    definition,
+                    &physical_key,
+                    raw,
+                    game_version,
+                )
+            }) else {
+                continue;
+            };
+            let controlled = controlled_keys.contains(definition.id);
+            settings.push(EditableGameSetting {
+                option_id: definition.id.to_string(),
+                category_id: definition.category.to_string(),
+                kind: GameOptionKind::Vanilla,
+                raw_key: None,
+                sync_enabled: true,
+                canonical_value: Some(value),
+                value_state: GameOptionValueState::Canonical,
+                option_revision: 0,
+                editor: editor_for(definition),
+                compatibility: compatibility(controlled),
+                validation_error: None,
+                controlled,
+            });
+        }
+    }
+
+    let mut custom_settings = document
+        .effective_entries()
+        .into_iter()
+        .filter_map(|(key, (index, _))| {
+            if controlled_keys.contains(key)
+                || setting_by_file_key(key).is_some()
+                || is_never_sync_key(key)
+            {
+                return None;
+            }
+            let entry = document.lines[index].entry.as_ref()?;
+            validate_raw_key_value(key, &entry.value).ok()?;
+            Some(EditableGameSetting {
+                option_id: custom_setting_id(key),
+                category_id: "custom".to_string(),
+                kind: GameOptionKind::External,
+                raw_key: Some(key.to_string()),
+                sync_enabled: true,
+                canonical_value: Some(CanonicalValue::ExternalRaw(
+                    entry.value.clone(),
+                )),
+                value_state: GameOptionValueState::Canonical,
+                option_revision: 0,
+                editor: custom_setting_editor(),
+                compatibility: compatibility(false),
+                validation_error: None,
+                controlled: false,
+            })
+        })
+        .collect::<Vec<_>>();
+    custom_settings.sort_by(|left, right| left.raw_key.cmp(&right.raw_key));
+    settings.extend(custom_settings);
+
+    GameSettingsEditorState {
+        summary_revision: editor_revision(metadata, input_bytes),
+        canonical_revision: 0,
+        catalog_revision: CATALOG_REVISION,
+        total_participating: 1,
+        categories: categories(&settings),
+        settings,
+    }
+}
+
+fn encode_setting_value(
+    metadata: &InstanceMetadata,
+    document: &GameOptionsDocument,
+    setting: &EditableGameSetting,
+    value: &CanonicalValue,
+) -> crate::Result<(String, String)> {
+    let game_version = metadata.applied_content_set.game_version.as_str();
+    if let Some(definition) = setting_by_id(&setting.option_id) {
+        validate_canonical_value(Some(definition), value)?;
+        let key = observed_physical_key(definition, document, game_version)
+            .ok_or_else(|| {
+                input_error(format!(
+                    "{} is no longer present in options.txt",
+                    setting.option_id
+                ))
+            })?;
+        let raw = encode_value(
+            definition,
+            &key,
+            value,
+            game_version,
+            document.value(&key),
+        )
+        .ok_or_else(|| {
+            input_error(format!(
+                "{} cannot be represented by this Minecraft version",
+                setting.option_id
+            ))
+        })?;
+        Ok((key, raw))
+    } else {
+        validate_canonical_value(None, value)?;
+        let key = setting
+            .raw_key
+            .clone()
+            .ok_or_else(|| input_error("Custom setting is missing its file key"))?;
+        let CanonicalValue::ExternalRaw(raw) = value else {
+            return Err(input_error(
+                "Custom settings require a raw string value",
+            ));
+        };
+        validate_raw_key_value(&key, raw)?;
+        Ok((key, raw.clone()))
+    }
+}
+
+async fn load_editor(
+    instance_id: &str,
+    state: &State,
+) -> crate::Result<GameSettingsEditorState> {
+    let (metadata, document, input_bytes, controlled_keys) =
+        load_instance_document(instance_id, state).await?;
+    Ok(build_editor_state(
+        &metadata,
+        &document,
+        &input_bytes,
+        &controlled_keys,
+    ))
+}
+
+pub async fn get_config(
+    instance_id: &str,
+) -> crate::Result<GameSettingsEditorState> {
+    let state = State::get().await?;
+    let _guard = state.lock_synced_options().await;
+    load_editor(instance_id, &state).await
+}
+
+pub async fn preview_changes(
+    instance_id: &str,
+    request: UpdateGameSettingsRequest,
+) -> crate::Result<GameSettingsEditorState> {
+    let state = State::get().await?;
+    let _guard = state.lock_synced_options().await;
+    let (metadata, document, input_bytes, controlled_keys) =
+        load_instance_document(instance_id, &state).await?;
+    let mut editor = build_editor_state(
+        &metadata,
+        &document,
+        &input_bytes,
+        &controlled_keys,
+    );
+    let stale = request.expected_catalog_revision != CATALOG_REVISION
+        || request.expected_summary_revision != editor.summary_revision
+        || request.expected_canonical_revision != editor.canonical_revision;
+
+    for change in request.changes {
+        let Some(setting) = editor
+            .settings
+            .iter_mut()
+            .find(|setting| setting.option_id == change.option_id)
+        else {
+            continue;
+        };
+        if stale || change.base_option_revision != setting.option_revision {
+            setting.validation_error =
+                Some(GameOptionValidationIssue::ChangedSinceOpened);
+            continue;
+        }
+        if change.sync_enabled.is_some() {
+            setting.validation_error =
+                Some(GameOptionValidationIssue::InvalidValue);
+            continue;
+        }
+        if let Some(value) = change.canonical_value {
+            match value {
+                Some(value)
+                    if encode_setting_value(
+                        &metadata,
+                        &document,
+                        setting,
+                        &value,
+                    )
+                    .is_ok() =>
+                {
+                    setting.canonical_value = Some(value);
+                    setting.value_state = GameOptionValueState::Canonical;
+                    setting.validation_error = None;
+                }
+                _ => {
+                    setting.canonical_value = None;
+                    setting.value_state = GameOptionValueState::Invalid;
+                    setting.validation_error =
+                        Some(GameOptionValidationIssue::InvalidValue);
+                }
+            }
+        }
+    }
+    Ok(editor)
+}
+
+pub async fn save_changes(
+    instance_id: &str,
+    request: UpdateGameSettingsRequest,
+) -> crate::Result<SaveGameSettingsResult> {
+    let state = State::get().await?;
+    let _guard = state.lock_synced_options().await;
+    let (metadata, mut document, input_bytes, controlled_keys) =
+        load_instance_document(instance_id, &state).await?;
+    let current_editor = build_editor_state(
+        &metadata,
+        &document,
+        &input_bytes,
+        &controlled_keys,
+    );
+    let UpdateGameSettingsRequest {
+        expected_summary_revision,
+        expected_canonical_revision,
+        expected_catalog_revision,
+        changes,
+    } = request;
+    if expected_catalog_revision != CATALOG_REVISION
+        || expected_summary_revision != current_editor.summary_revision
+        || expected_canonical_revision != current_editor.canonical_revision
+    {
+        return Ok(SaveGameSettingsResult {
+            state: Some(current_editor),
+            conflicts: changes
+                .into_iter()
+                .map(|change| change.option_id)
+                .collect(),
+            ..SaveGameSettingsResult::default()
+        });
+    }
+
+    let mut changed = false;
+    for change in changes {
+        let setting = current_editor
+            .settings
+            .iter()
+            .find(|setting| setting.option_id == change.option_id)
+            .ok_or_else(|| {
+                input_error(format!(
+                    "Unknown game setting {}",
+                    change.option_id
+                ))
+            })?;
+        if setting.controlled {
+            return Err(input_error(format!(
+                "{} is controlled by the instance's launcher settings",
+                setting.option_id
+            )));
+        }
+        if change.base_option_revision != setting.option_revision {
+            return Ok(SaveGameSettingsResult {
+                state: Some(current_editor),
+                conflicts: vec![change.option_id],
+                ..SaveGameSettingsResult::default()
+            });
+        }
+        if change.sync_enabled.is_some() {
+            return Err(input_error(
+                "Sync selection cannot be changed in the instance editor",
+            ));
+        }
+        let Some(Some(value)) = change.canonical_value else {
+            return Err(input_error(format!(
+                "Choose a value for {}",
+                setting.option_id
+            )));
+        };
+        let (key, raw) =
+            encode_setting_value(&metadata, &document, setting, &value)?;
+        changed |= document.set(&key, &raw, false)?;
+    }
+
+    if changed {
+        io::write(options_path(&metadata, &state), document.serialize()?)
+            .await?;
+    }
+    let refreshed = load_editor(instance_id, &state).await?;
+    Ok(SaveGameSettingsResult {
+        state: Some(refreshed),
+        applied: u32::from(changed),
+        ..SaveGameSettingsResult::default()
+    })
+}
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/mod.rs b/packages/app-lib/src/api/instance/synced_options/game_options/mod.rs
new file mode 100644
index 0000000000..862eb02606
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/mod.rs
@@ -0,0 +1,80 @@
+//! Syncs selected values from Minecraft's `options.txt` between instances.
+//!
+//! When sync is first enabled, the user chooses an instance to supply the initial
+//! values. Each instance keeps its own `options.txt`; we update only the selected
+//! settings and leave modpack defaults, comments, and disabled settings alone.
+//!
+//! The watcher imports enabled values whenever `options.txt` changes. After the
+//! app writes the file, it stores the file hash and ignores the matching watcher
+//! event. On conflict, the latest save is persisted.
+//!
+//! Minecraft has renamed and reformatted settings over time. `catalog`
+//! contains the file keys and conversions for the versions we support. Any other
+//! key is treated as a custom setting and copied as-is to every synced instance.
+//! Custom settings can be turned off individually in the settings screen.
+//!
+//! `catalog` will need to be checked every time a Minecraft update comes out. For maintenance reasons we will just
+//! do this for major releases, no snapshots/pre-releases.
+//!
+//! Launcher-enforced settings, such as fullscreen, are applied last and excluded
+//! when importing `options.txt`.
+
+mod api_types;
+mod catalog;
+mod fullscreen;
+mod instance_support;
+mod launch_overrides;
+mod local_settings_editor;
+mod options_file;
+mod pack_updates;
+mod read_instance_changes;
+mod settings_editor;
+mod source_selection;
+mod write_shared_settings;
+
+pub use crate::state::{CanonicalValue, GameOptionKind};
+pub use api_types::{
+    EditableGameSetting, GameOptionCompatibility,
+    GameOptionCompatibilityBucket, GameOptionCompatibilityReason,
+    GameOptionCompatibilityStatus, GameOptionEditorChoice,
+    GameOptionEditorDefinition, GameOptionMappingKind,
+    GameOptionValidationIssue, GameOptionValueState,
+    GameOptionsSourceCandidate, GameOptionsSourceIssue, GameSettingCategory,
+    GameSettingChange, GameSettingsEditorState, SaveGameSettingsResult,
+    UpdateGameSettingsRequest,
+};
+pub use launch_overrides::{apply_launcher_overrides, sync_before_launch};
+pub use local_settings_editor::{
+    get_config as get_local_config,
+    preview_changes as preview_local_changes,
+    save_changes as save_local_changes,
+};
+pub use pack_updates::{GameOptionsPackSource, capture_pack_base};
+pub use settings_editor::{get_config, preview_changes, save_changes};
+pub use source_selection::list_sync_sources;
+
+pub(crate) use fullscreen::{
+    shared_fullscreen_value, update_shared_fullscreen_from_app,
+};
+pub(crate) use write_shared_settings::sync_all_participating_instances;
+
+pub(in crate::api::instance) use pack_updates::{
+    detach_instance, prepare_instance_update_with_state,
+};
+pub(in crate::api::instance) use source_selection::initialize_from_source_instance;
+pub(in crate::api::instance) use write_shared_settings::{
+    apply_instance_with_state, capture_instance_file_change,
+};
+
+pub(in crate::api::instance) async fn canonical_exists(
+    state: &crate::state::State,
+) -> crate::Result<bool> {
+    crate::state::shared_game_options_exist(&state.pool).await
+}
+
+const OPTIONS_FILE: &str = "options.txt";
+const CATALOG_REVISION: u32 = 5;
+const MAX_OPTIONS_BYTES: usize = 2 * 1024 * 1024;
+const MAX_OPTIONS_LINES: usize = 16_384;
+const MAX_KEY_BYTES: usize = 1_024;
+const MAX_VALUE_BYTES: usize = 32 * 1024;
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/options_file.rs b/packages/app-lib/src/api/instance/synced_options/game_options/options_file.rs
new file mode 100644
index 0000000000..429f94cbe5
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/options_file.rs
@@ -0,0 +1,317 @@
+//! Reads and edits `options.txt` without changing unrelated lines or file formatting.
+
+use super::super as synced_options;
+use super::{
+    MAX_KEY_BYTES, MAX_OPTIONS_BYTES, MAX_OPTIONS_LINES, MAX_VALUE_BYTES,
+    OPTIONS_FILE,
+};
+use crate::ErrorKind;
+use crate::state::{InstanceMetadata, State};
+use crate::util::io;
+use encoding_rs::{Encoding, UTF_8, UTF_16BE, UTF_16LE};
+use sha1_smol::Sha1;
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+
+#[derive(Clone)]
+pub(super) struct GameOptionsDocument {
+    pub(super) encoding: &'static Encoding,
+    pub(super) bom: Bom,
+    pub(super) default_line_ending: String,
+    pub(super) lines: Vec<GameOptionsLine>,
+}
+
+#[derive(Clone, Copy)]
+pub(super) enum Bom {
+    None,
+    Utf8,
+    Utf16Le,
+    Utf16Be,
+}
+
+#[derive(Clone)]
+pub(super) struct GameOptionsLine {
+    pub(super) raw: String,
+    pub(super) ending: String,
+    pub(super) entry: Option<GameOptionsEntry>,
+}
+
+#[derive(Clone)]
+pub(super) struct GameOptionsEntry {
+    pub(super) key: String,
+    pub(super) value: String,
+    pub(super) changed: bool,
+}
+
+impl GameOptionsDocument {
+    pub(super) fn empty() -> Self {
+        Self {
+            encoding: UTF_8,
+            bom: Bom::None,
+            default_line_ending: "\n".to_string(),
+            lines: Vec::new(),
+        }
+    }
+
+    pub(super) fn parse(bytes: &[u8]) -> crate::Result<Self> {
+        if bytes.len() > MAX_OPTIONS_BYTES {
+            return Err(input_error("options.txt is too large to sync safely"));
+        }
+
+        let (bom, encoding, contents) =
+            if bytes.starts_with(&[0xEF, 0xBB, 0xBF]) {
+                (Bom::Utf8, UTF_8, &bytes[3..])
+            } else if bytes.starts_with(&[0xFF, 0xFE]) {
+                (Bom::Utf16Le, UTF_16LE, &bytes[2..])
+            } else if bytes.starts_with(&[0xFE, 0xFF]) {
+                (Bom::Utf16Be, UTF_16BE, &bytes[2..])
+            } else {
+                let mut detector = chardetng::EncodingDetector::new();
+                detector.feed(bytes, true);
+                (Bom::None, detector.guess(None, true), bytes)
+            };
+        let (decoded, decode_errors) =
+            encoding.decode_without_bom_handling(contents);
+        if decode_errors {
+            return Err(input_error(
+                "options.txt contains bytes that cannot be decoded losslessly",
+            ));
+        }
+        let roundtrip = encode_without_bom(encoding, &decoded)?;
+        if roundtrip.as_slice() != contents {
+            return Err(input_error(
+                "options.txt encoding cannot be round-tripped safely",
+            ));
+        }
+
+        let mut lines = Vec::new();
+        let mut start = 0;
+        let source: &str = decoded.as_ref();
+        for (index, byte) in source.as_bytes().iter().enumerate() {
+            if *byte != b'\n' {
+                continue;
+            }
+            let raw_end =
+                if index > start && source.as_bytes()[index - 1] == b'\r' {
+                    index - 1
+                } else {
+                    index
+                };
+            let ending = if raw_end == index { "\n" } else { "\r\n" };
+            lines.push(Self::parse_line(&source[start..raw_end], ending));
+            start = index + 1;
+        }
+        if start < source.len() {
+            lines.push(Self::parse_line(&source[start..], ""));
+        }
+        if lines.len() > MAX_OPTIONS_LINES {
+            return Err(input_error(
+                "options.txt has too many lines to sync safely",
+            ));
+        }
+        let default_line_ending = lines
+            .iter()
+            .find(|line| !line.ending.is_empty())
+            .map(|line| line.ending.clone())
+            .unwrap_or_else(|| "\n".to_string());
+        Ok(Self {
+            encoding,
+            bom,
+            default_line_ending,
+            lines,
+        })
+    }
+
+    pub(super) fn parse_line(raw: &str, ending: &str) -> GameOptionsLine {
+        let entry = raw.split_once(':').and_then(|(key, value)| {
+            if key.is_empty()
+                || key.len() > MAX_KEY_BYTES
+                || value.len() > MAX_VALUE_BYTES
+            {
+                None
+            } else {
+                Some(GameOptionsEntry {
+                    key: key.to_string(),
+                    value: value.to_string(),
+                    changed: false,
+                })
+            }
+        });
+        GameOptionsLine {
+            raw: raw.to_string(),
+            ending: ending.to_string(),
+            entry,
+        }
+    }
+
+    pub(super) fn effective_entries(&self) -> HashMap<&str, (usize, usize)> {
+        let mut entries = HashMap::new();
+        for (index, line) in self.lines.iter().enumerate() {
+            if let Some(entry) = &line.entry {
+                entries
+                    .entry(entry.key.as_str())
+                    .and_modify(|value: &mut (usize, usize)| {
+                        value.0 = index;
+                        value.1 += 1;
+                    })
+                    .or_insert((index, 1));
+            }
+        }
+        entries
+    }
+
+    pub(super) fn value(&self, key: &str) -> Option<&str> {
+        let (index, _) = self.effective_entries().get(key).copied()?;
+        self.lines[index]
+            .entry
+            .as_ref()
+            .map(|entry| entry.value.as_str())
+    }
+
+    pub(super) fn set(
+        &mut self,
+        key: &str,
+        value: &str,
+        insert: bool,
+    ) -> crate::Result<bool> {
+        validate_raw_key_value(key, value)?;
+        if let Some((index, _)) = self.effective_entries().get(key).copied() {
+            let entry = self.lines[index].entry.as_mut().expect("entry index");
+            if entry.value == value {
+                return Ok(false);
+            }
+            entry.value = value.to_string();
+            entry.changed = true;
+            return Ok(true);
+        }
+        if !insert {
+            return Ok(false);
+        }
+
+        let ending = if let Some(last) = self.lines.last_mut() {
+            if last.ending.is_empty() {
+                last.ending = self.default_line_ending.clone();
+                String::new()
+            } else {
+                self.default_line_ending.clone()
+            }
+        } else {
+            self.default_line_ending.clone()
+        };
+        self.lines.push(GameOptionsLine {
+            raw: String::new(),
+            ending,
+            entry: Some(GameOptionsEntry {
+                key: key.to_string(),
+                value: value.to_string(),
+                changed: true,
+            }),
+        });
+        Ok(true)
+    }
+
+    pub(super) fn serialize(&self) -> crate::Result<Vec<u8>> {
+        let mut text = String::new();
+        for line in &self.lines {
+            match &line.entry {
+                Some(entry) if entry.changed => {
+                    text.push_str(&entry.key);
+                    text.push(':');
+                    text.push_str(&entry.value);
+                }
+                _ => text.push_str(&line.raw),
+            }
+            text.push_str(&line.ending);
+        }
+        let encoded = encode_without_bom(self.encoding, &text)?;
+        let bom: &[u8] = match self.bom {
+            Bom::None => &[],
+            Bom::Utf8 => &[0xEF, 0xBB, 0xBF],
+            Bom::Utf16Le => &[0xFF, 0xFE],
+            Bom::Utf16Be => &[0xFE, 0xFF],
+        };
+        let mut result = Vec::with_capacity(bom.len() + encoded.len());
+        result.extend_from_slice(bom);
+        result.extend_from_slice(&encoded);
+        Ok(result)
+    }
+}
+
+pub(super) fn encode_without_bom(
+    encoding: &'static Encoding,
+    text: &str,
+) -> crate::Result<Vec<u8>> {
+    if encoding == UTF_16LE || encoding == UTF_16BE {
+        let mut encoded = Vec::with_capacity(text.len().saturating_mul(2));
+        for unit in text.encode_utf16() {
+            let bytes = if encoding == UTF_16LE {
+                unit.to_le_bytes()
+            } else {
+                unit.to_be_bytes()
+            };
+            encoded.extend_from_slice(&bytes);
+        }
+        return Ok(encoded);
+    }
+
+    let (encoded, _, had_errors) = encoding.encode(text);
+    if had_errors {
+        return Err(input_error(
+            "A synced option value cannot be represented in this file's encoding",
+        ));
+    }
+    Ok(encoded.into_owned())
+}
+
+pub(super) fn input_error(message: impl Into<String>) -> crate::Error {
+    ErrorKind::InputError(message.into()).into()
+}
+
+pub(super) fn validate_raw_key_value(
+    key: &str,
+    value: &str,
+) -> crate::Result<()> {
+    if key.is_empty()
+        || key.len() > MAX_KEY_BYTES
+        || key.contains(':')
+        || key.chars().any(char::is_control)
+    {
+        return Err(input_error("Invalid options.txt setting key"));
+    }
+    if value.len() > MAX_VALUE_BYTES
+        || value
+            .chars()
+            .any(|character| character.is_control() && character != '\t')
+    {
+        return Err(input_error("Invalid options.txt setting value"));
+    }
+    Ok(())
+}
+
+pub(super) fn options_path(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> PathBuf {
+    synced_options::instance_dir(metadata, state).join(OPTIONS_FILE)
+}
+
+pub(super) fn sha1_bytes(bytes: &[u8]) -> String {
+    Sha1::from(bytes).digest().to_string()
+}
+
+/// Reads an `options.txt` only when it is safe to rewrite.
+///
+/// The parser keeps its text encoding, line endings, comments, and duplicate keys.
+pub(super) async fn read_document(
+    path: &Path,
+) -> crate::Result<(GameOptionsDocument, Vec<u8>)> {
+    let metadata = tokio::fs::symlink_metadata(path)
+        .await
+        .map_err(|error| io::IOError::with_path(error, path))?;
+    if metadata.file_type().is_symlink() {
+        return Err(input_error("Refusing to sync a symlinked options.txt"));
+    }
+    let bytes = io::read(path).await?;
+    let document = GameOptionsDocument::parse(&bytes)?;
+    Ok((document, bytes))
+}
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/pack_updates.rs b/packages/app-lib/src/api/instance/synced_options/game_options/pack_updates.rs
new file mode 100644
index 0000000000..a0d4c0b74c
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/pack_updates.rs
@@ -0,0 +1,304 @@
+//! Keeps game settings intact when a modpack is installed or updated.
+
+use super::MAX_OPTIONS_BYTES;
+use super::options_file::{input_error, options_path, sha1_bytes};
+use super::write_shared_settings::{
+    apply_shared_settings_to_instance, capture_instance_options,
+    sync_is_active_for_instance,
+};
+use crate::state::{InstanceLink, InstanceMetadata, State, SyncedOption};
+use crate::util::io;
+use encoding_rs::{UTF_8, UTF_16BE, UTF_16LE};
+use std::io::ErrorKind;
+use std::path::Path;
+
+const YOSBR_OPTIONS_PATH: &str = "config/yosbr/options.txt";
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum GameOptionsPackSource {
+    ClientOverrides,
+    Overrides,
+    ClientOverridesYosbr,
+    OverridesYosbr,
+}
+
+impl GameOptionsPackSource {
+    fn as_str(self) -> &'static str {
+        match self {
+            Self::ClientOverrides | Self::ClientOverridesYosbr => {
+                "client_overrides"
+            }
+            Self::Overrides | Self::OverridesYosbr => "overrides",
+        }
+    }
+
+    fn is_yosbr(self) -> bool {
+        matches!(self, Self::ClientOverridesYosbr | Self::OverridesYosbr)
+    }
+}
+
+fn detected_encoding_name(bytes: &[u8]) -> String {
+    if bytes.starts_with(&[0xFF, 0xFE]) {
+        return UTF_16LE.name().to_string();
+    }
+    if bytes.starts_with(&[0xFE, 0xFF]) {
+        return UTF_16BE.name().to_string();
+    }
+    if bytes.starts_with(&[0xEF, 0xBB, 0xBF]) {
+        return UTF_8.name().to_string();
+    }
+    let mut detector = chardetng::EncodingDetector::new();
+    detector.feed(bytes, true);
+    detector.guess(None, true).name().to_string()
+}
+
+fn pack_version_id(metadata: &InstanceMetadata) -> Option<&str> {
+    match &metadata.link {
+        InstanceLink::ModrinthModpack { version_id, .. } => Some(version_id),
+        InstanceLink::ServerProjectModpack {
+            content_version_id, ..
+        } => Some(content_version_id),
+        InstanceLink::ImportedModpack { version_id, .. } => {
+            version_id.as_deref()
+        }
+        InstanceLink::SharedInstance {
+            modpack_version_id, ..
+        } => modpack_version_id.as_deref(),
+        _ => None,
+    }
+}
+
+async fn read_pack_options(
+    path: &Path,
+    name: &str,
+) -> crate::Result<Option<(Vec<u8>, String, String)>> {
+    let metadata = match tokio::fs::symlink_metadata(path).await {
+        Ok(metadata) => metadata,
+        Err(error) if error.kind() == ErrorKind::NotFound => return Ok(None),
+        Err(error) => return Err(io::IOError::with_path(error, path).into()),
+    };
+    if metadata.file_type().is_symlink() {
+        return Err(input_error(format!(
+            "Refusing to capture a symlinked {name}"
+        )));
+    }
+    if metadata.len() > MAX_OPTIONS_BYTES as u64 {
+        return Err(input_error(format!(
+            "The modpack {name} is too large to capture for syncing"
+        )));
+    }
+    let bytes = io::read(path).await?;
+    let sha1 = sha1_bytes(&bytes);
+    let encoding = detected_encoding_name(&bytes);
+    Ok(Some((bytes, sha1, encoding)))
+}
+
+async fn options_target_exists(path: &Path) -> crate::Result<bool> {
+    match tokio::fs::symlink_metadata(path).await {
+        Ok(metadata) if metadata.file_type().is_symlink() => {
+            Err(input_error("Refusing to replace a symlinked options.txt"))
+        }
+        Ok(_) => Ok(true),
+        Err(error) if error.kind() == ErrorKind::NotFound => Ok(false),
+        Err(error) => Err(io::IOError::with_path(error, path).into()),
+    }
+}
+
+pub(super) async fn materialize_yosbr_options_if_missing(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<()> {
+    let path = options_path(metadata, state);
+    if options_target_exists(&path).await? {
+        return Ok(());
+    }
+    let template_path =
+        super::super::instance_dir(metadata, state).join(YOSBR_OPTIONS_PATH);
+    let Some((bytes, _, _)) =
+        read_pack_options(&template_path, "YOSBR options.txt").await?
+    else {
+        return Ok(());
+    };
+    io::write(&path, bytes).await?;
+    Ok(())
+}
+
+pub(in crate::api::instance) async fn detach_instance(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<()> {
+    let feature = SyncedOption::GameOptions.as_str();
+    sqlx::query!(
+        "
+		DELETE FROM instance_sync_checkpoints
+		WHERE instance_id = ? AND feature = ?
+		",
+        metadata.instance.id,
+        feature,
+    )
+    .execute(&state.pool)
+    .await?;
+    Ok(())
+}
+
+/// Before replacing modpack files, saves `options.txt` and shares any settings the
+/// player changed in Minecraft.
+pub(in crate::api::instance) async fn prepare_instance_update_with_state(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<()> {
+    sqlx::query!(
+        "DELETE FROM instance_game_option_update_state WHERE instance_id = ?",
+        metadata.instance.id,
+    )
+    .execute(&state.pool)
+    .await?;
+    if sync_is_active_for_instance(metadata, state).await? {
+        let _ = capture_instance_options(metadata, state, true).await?;
+    }
+    let path = options_path(metadata, state);
+    let (had_file, bytes, sha1) = if path.exists() {
+        let file_metadata = tokio::fs::symlink_metadata(&path)
+            .await
+            .map_err(|error| io::IOError::with_path(error, &path))?;
+        if file_metadata.file_type().is_symlink() {
+            return Err(input_error(
+                "Refusing to prepare a symlinked options.txt for a modpack update",
+            ));
+        }
+        if file_metadata.len() > MAX_OPTIONS_BYTES as u64 {
+            return Err(input_error(
+                "options.txt is too large to preserve for a modpack update",
+            ));
+        }
+        let bytes = io::read(&path).await?;
+        (true, Some(bytes.clone()), Some(sha1_bytes(&bytes)))
+    } else {
+        (false, None, None)
+    };
+    sqlx::query!(
+        "
+		INSERT INTO instance_game_option_update_state
+			(instance_id, had_file, sha1, document)
+		VALUES (?, ?, ?, ?)
+		ON CONFLICT(instance_id) DO UPDATE SET
+			had_file = excluded.had_file, sha1 = excluded.sha1,
+			document = excluded.document
+		",
+        metadata.instance.id,
+        had_file,
+        sha1,
+        bytes,
+    )
+    .execute(&state.pool)
+    .await?;
+    Ok(())
+}
+
+/// Keeps the new modpack's `options.txt` as its default, then reapplies the user's
+/// shared settings.
+pub async fn capture_pack_base(
+    instance_id: &str,
+    source: Option<GameOptionsPackSource>,
+) -> crate::Result<()> {
+    let state = State::get().await?;
+    let _guard = state.lock_synced_options().await;
+    let metadata = crate::state::get_instance(instance_id, &state.pool)
+        .await?
+        .ok_or_else(|| input_error("Unknown instance"))?;
+    let path = options_path(&metadata, &state);
+    let feature = SyncedOption::GameOptions.as_str();
+    sqlx::query!(
+        "
+		DELETE FROM instance_sync_checkpoints
+		WHERE instance_id = ? AND feature = ?
+		",
+        instance_id,
+        feature,
+    )
+    .execute(&state.pool)
+    .await?;
+
+    if source.is_none() {
+        let pending = sqlx::query!(
+            r#"
+			SELECT had_file AS "had_file!: bool", document
+			FROM instance_game_option_update_state
+			WHERE instance_id = ?
+			"#,
+            instance_id,
+        )
+        .fetch_optional(&state.pool)
+        .await?;
+        if let Some(pending) = pending {
+            if pending.had_file {
+                if let Some(document) = pending.document {
+                    io::write(&path, document).await?;
+                }
+            } else if path.exists() {
+                io::remove_file(&path).await?;
+            }
+        }
+    }
+
+    let captured = if source.is_some_and(GameOptionsPackSource::is_yosbr) {
+        let template_path = super::super::instance_dir(&metadata, &state)
+            .join(YOSBR_OPTIONS_PATH);
+        let template = read_pack_options(&template_path, "YOSBR options.txt")
+            .await?
+            .ok_or_else(|| {
+                input_error("The modpack YOSBR options.txt is missing")
+            })?;
+        if !options_target_exists(&path).await? {
+            io::write(&path, template.0.clone()).await?;
+        }
+        Some(template)
+    } else {
+        read_pack_options(&path, "options.txt").await?
+    };
+    let (document_bytes, sha1, encoding) = captured
+        .map(|(document, sha1, encoding)| {
+            (Some(document), Some(sha1), Some(encoding))
+        })
+        .unwrap_or((None, None, None));
+    let source_name =
+        source.map(GameOptionsPackSource::as_str).unwrap_or("none");
+    let version_id = pack_version_id(&metadata);
+    sqlx::query!(
+        "
+		INSERT INTO instance_game_option_pack_bases
+			(instance_id, pack_version_id, source, sha1, encoding, document)
+		VALUES (?, ?, ?, ?, ?, ?)
+		ON CONFLICT(instance_id) DO UPDATE SET
+			pack_version_id = excluded.pack_version_id,
+			source = excluded.source, sha1 = excluded.sha1,
+			encoding = excluded.encoding, document = excluded.document
+		",
+        instance_id,
+        version_id,
+        source_name,
+        sha1,
+        encoding,
+        document_bytes,
+    )
+    .execute(&state.pool)
+    .await?;
+    sqlx::query!(
+        "DELETE FROM instance_game_option_update_state WHERE instance_id = ?",
+        instance_id,
+    )
+    .execute(&state.pool)
+    .await?;
+
+    if sync_is_active_for_instance(&metadata, &state).await? {
+        if let Err(error) =
+            apply_shared_settings_to_instance(&metadata, &state, true).await
+        {
+            tracing::warn!(
+                "Captured the modpack options.txt for {}, but shared settings could not be overlaid yet: {error}",
+                metadata.instance.id
+            );
+        }
+    }
+    Ok(())
+}
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/read_instance_changes.rs b/packages/app-lib/src/api/instance/synced_options/game_options/read_instance_changes.rs
new file mode 100644
index 0000000000..b4022f44b2
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/read_instance_changes.rs
@@ -0,0 +1,363 @@
+//! Imports saved `options.txt` settings into the canonical values.
+
+use super::CATALOG_REVISION;
+use super::api_types::canonical_values_equal;
+use super::catalog::*;
+use super::fullscreen::update_app_fullscreen_setting;
+use super::launch_overrides::currently_launcher_owned_keys;
+use super::options_file::{GameOptionsDocument, validate_raw_key_value};
+use crate::state::{
+    CanonicalValue, GameOptionKind, InstanceMetadata, State,
+    load_game_option_preferences, load_game_options_sync_state,
+    load_shared_game_options,
+};
+use chrono::Utc;
+use std::collections::HashSet;
+
+pub(super) fn custom_setting_id(key: &str) -> String {
+    format!("external:{key}")
+}
+
+/// Imports every enabled setting present in `options.txt`. The caller skips file
+/// hashes produced by app writes.
+pub(super) async fn read_instance_changes_into_shared_settings(
+    metadata: &InstanceMetadata,
+    document: &GameOptionsDocument,
+    state: &State,
+) -> crate::Result<bool> {
+    let values = load_shared_game_options(&state.pool).await?;
+    let preferences = load_game_option_preferences(&state.pool).await?;
+    let launcher_keys = currently_launcher_owned_keys(metadata);
+    let now = Utc::now().timestamp();
+    let mut updates = Vec::new();
+    for (option_id, stored) in &values {
+        if !preferences
+            .get(option_id)
+            .is_some_and(|preference| preference.enabled)
+        {
+            continue;
+        }
+        if matches!(stored.kind, GameOptionKind::External)
+            && stored.raw_key.is_none()
+        {
+            continue;
+        }
+        if stored
+            .raw_key
+            .as_deref()
+            .is_some_and(|key| setting_by_file_key(key).is_some())
+        {
+            continue;
+        }
+        let definition = setting_by_id(option_id);
+        if definition.is_some()
+            && !supported_settings_cover_game_version(
+                &metadata.applied_content_set.game_version,
+            )
+        {
+            continue;
+        }
+        let current_key = if let Some(definition) = definition {
+            observed_physical_key(
+                definition,
+                document,
+                &metadata.applied_content_set.game_version,
+            )
+        } else {
+            stored.raw_key.clone()
+        };
+        let Some(current_key) = current_key else {
+            continue;
+        };
+        if launcher_keys.contains(&current_key) {
+            continue;
+        }
+        let Some(current_raw) = document.value(&current_key) else {
+            continue;
+        };
+        let candidate = if let Some(definition) = definition {
+            decode_value_for_version(
+                definition,
+                &current_key,
+                current_raw,
+                &metadata.applied_content_set.game_version,
+            )
+        } else if matches!(stored.kind, GameOptionKind::External) {
+            if validate_raw_key_value(&current_key, current_raw).is_err() {
+                continue;
+            }
+            Some(CanonicalValue::ExternalRaw(current_raw.to_string()))
+        } else {
+            None
+        };
+        let Some(candidate) = candidate else {
+            continue;
+        };
+        if stored
+            .value
+            .as_ref()
+            .is_some_and(|current| canonical_values_equal(current, &candidate))
+        {
+            continue;
+        }
+        updates.push((option_id.to_string(), candidate, stored.revision));
+    }
+
+    let mut changed = false;
+    let mut fullscreen_value = None;
+    if !updates.is_empty() {
+        let (canonical_revision, _) =
+            load_game_options_sync_state(&state.pool, CATALOG_REVISION).await?;
+        let mut tx = state.pool.begin().await?;
+        for (option_id, candidate, revision) in updates {
+            let next_revision = revision.saturating_add(1) as i64;
+            let current_revision = revision as i64;
+            let value_json = serde_json::to_string(&candidate)?;
+            let canonical_type = candidate.type_name();
+            let result = sqlx::query!(
+                "
+				UPDATE synced_game_option_values
+				SET canonical_type = ?, canonical_value_json = ?, seeded = 1,
+					revision = ?, origin = 'instance', source_game_version = ?,
+					source_instance_id = ?, updated_at = ?
+				WHERE option_id = ? AND revision = ?
+				",
+                canonical_type,
+                value_json,
+                next_revision,
+                metadata.applied_content_set.game_version,
+                metadata.instance.id,
+                now,
+                option_id,
+                current_revision,
+            )
+            .execute(&mut *tx)
+            .await?;
+            if result.rows_affected() == 0 {
+                continue;
+            }
+            if option_id == "fullscreen" {
+                fullscreen_value = Some(candidate.clone());
+            }
+            changed = true;
+        }
+        if changed {
+            let next_revision = canonical_revision.saturating_add(1) as i64;
+            sqlx::query!(
+                "
+				UPDATE synced_game_option_state
+				SET revision = ?, catalog_revision = ?
+				WHERE singleton = 1
+				",
+                next_revision,
+                CATALOG_REVISION as i64,
+            )
+            .execute(&mut *tx)
+            .await?;
+        }
+        if let Some(value) = fullscreen_value.as_ref() {
+            update_app_fullscreen_setting(&mut tx, value, true).await?;
+        }
+        tx.commit().await?;
+    }
+    let discovered =
+        discover_custom_settings(metadata, document, &launcher_keys, state)
+            .await?;
+    Ok(discovered || changed)
+}
+
+/// Finds settings added by mods and adds them to the shared settings list.
+pub(super) async fn discover_custom_settings(
+    metadata: &InstanceMetadata,
+    document: &GameOptionsDocument,
+    excluded_keys: &HashSet<String>,
+    state: &State,
+) -> crate::Result<bool> {
+    let existing = load_shared_game_options(&state.pool).await?;
+    let preferences = load_game_option_preferences(&state.pool).await?;
+    let (canonical_revision, _) =
+        load_game_options_sync_state(&state.pool, CATALOG_REVISION).await?;
+    let entries = document.effective_entries();
+    let now = Utc::now().timestamp();
+    let mut discovered = false;
+    let mut tx = state.pool.begin().await?;
+    let game_version = metadata.applied_content_set.game_version.as_str();
+
+    for definition in all_supported_settings() {
+        for key in definition.keys {
+            let custom_id = custom_setting_id(key);
+            let Some(custom) = existing.get(&custom_id) else {
+                continue;
+            };
+            if !custom.seeded {
+                continue;
+            }
+            let revision = custom.revision.saturating_add(1) as i64;
+            sqlx::query!(
+                "
+				UPDATE synced_game_option_values
+				SET seeded = 0, revision = ?, updated_at = ?
+				WHERE option_id = ?
+				",
+                revision,
+                now,
+                custom_id,
+            )
+            .execute(&mut *tx)
+            .await?;
+            sqlx::query!(
+                "
+				UPDATE synced_game_option_preferences
+				SET enabled = 0, source = 'catalog_default', revision = ?
+				WHERE option_id = ?
+				",
+                revision,
+                custom_id,
+            )
+            .execute(&mut *tx)
+            .await?;
+            discovered = true;
+        }
+    }
+
+    if supported_settings_cover_game_version(game_version) {
+        for definition in all_supported_settings() {
+            if existing.contains_key(definition.id) {
+                continue;
+            }
+            let discovered_value = definition.keys.iter().find_map(|key| {
+                if excluded_keys.contains(*key) {
+                    return None;
+                }
+                let raw = document.value(key)?;
+                decode_value_for_version(definition, key, raw, game_version)
+            });
+            let Some(value) = discovered_value else {
+                continue;
+            };
+            let value_json = serde_json::to_string(&value)?;
+            let canonical_type = value.type_name();
+            sqlx::query!(
+                "
+				INSERT INTO synced_game_option_values
+					(option_id, kind, raw_key, canonical_type,
+					 canonical_value_json, value_codec, seeded, revision, origin,
+					 source_game_version, source_instance_id, updated_at)
+				VALUES (?, 'vanilla', NULL, ?, ?, 'catalog', 1, 1,
+					'instance', ?, ?, ?)
+				",
+                definition.id,
+                canonical_type,
+                value_json,
+                game_version,
+                metadata.instance.id,
+                now,
+            )
+            .execute(&mut *tx)
+            .await?;
+            sqlx::query!(
+                "
+				INSERT INTO synced_game_option_preferences
+					(option_id, enabled, source, revision)
+				VALUES (?, ?, 'catalog_default', 1)
+				",
+                definition.id,
+                definition.default_on,
+            )
+            .execute(&mut *tx)
+            .await?;
+            discovered = true;
+        }
+    }
+
+    for (key, (index, _)) in entries {
+        if excluded_keys.contains(key)
+            || setting_by_file_key(key).is_some()
+            || is_never_sync_key(key)
+        {
+            continue;
+        }
+        let Some(entry) = &document.lines[index].entry else {
+            continue;
+        };
+        if validate_raw_key_value(key, &entry.value).is_err() {
+            continue;
+        }
+        let option_id = custom_setting_id(key);
+        let should_seed =
+            existing.get(&option_id).is_none_or(|stored| !stored.seeded);
+        if !should_seed {
+            continue;
+        }
+        let revision = existing
+            .get(&option_id)
+            .map(|stored| stored.revision)
+            .unwrap_or(0)
+            .max(
+                preferences
+                    .get(&option_id)
+                    .map(|preference| preference.revision)
+                    .unwrap_or(0),
+            )
+            .saturating_add(1) as i64;
+        let value = CanonicalValue::ExternalRaw(entry.value.clone());
+        let value_json = serde_json::to_string(&value)?;
+        sqlx::query!(
+            "
+			INSERT INTO synced_game_option_values
+				(option_id, kind, raw_key, canonical_type,
+				 canonical_value_json, value_codec, seeded, revision, origin,
+				 source_game_version, source_instance_id, updated_at)
+			VALUES (?, 'external', ?, 'external_raw', ?, 'exact_raw',
+				1, ?, 'instance', ?, ?, ?)
+			ON CONFLICT(option_id) DO UPDATE SET
+				raw_key = excluded.raw_key,
+				canonical_value_json = excluded.canonical_value_json,
+				seeded = 1, revision = excluded.revision,
+				origin = 'instance',
+				source_game_version = excluded.source_game_version,
+				source_instance_id = excluded.source_instance_id,
+				updated_at = excluded.updated_at
+			",
+            option_id,
+            key,
+            value_json,
+            revision,
+            game_version,
+            metadata.instance.id,
+            now,
+        )
+        .execute(&mut *tx)
+        .await?;
+        sqlx::query!(
+            "
+			INSERT INTO synced_game_option_preferences
+				(option_id, enabled, source, revision)
+			VALUES (?, 1, 'discovery_default', ?)
+			ON CONFLICT(option_id) DO NOTHING
+			",
+            option_id,
+            revision,
+        )
+        .execute(&mut *tx)
+        .await?;
+        discovered = true;
+    }
+
+    if discovered {
+        let next_revision = canonical_revision.saturating_add(1) as i64;
+        sqlx::query!(
+            "
+			UPDATE synced_game_option_state
+			SET revision = ?, catalog_revision = ?
+			WHERE singleton = 1
+			",
+            next_revision,
+            CATALOG_REVISION as i64,
+        )
+        .execute(&mut *tx)
+        .await?;
+    }
+    tx.commit().await?;
+    Ok(discovered)
+}
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/settings_editor.rs b/packages/app-lib/src/api/instance/synced_options/game_options/settings_editor.rs
new file mode 100644
index 0000000000..4162c29a75
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/settings_editor.rs
@@ -0,0 +1,535 @@
+//! Loads, previews, and saves the game settings shown in the app.
+
+use super::CATALOG_REVISION;
+use super::api_types::*;
+use super::catalog::*;
+use super::fullscreen::update_app_fullscreen_setting;
+use super::instance_support::{
+    describe_instance_support, find_common_local_value,
+    load_participating_instances, summary_revision,
+};
+use super::options_file::input_error;
+use super::write_shared_settings::sync_all_participating_instances;
+use crate::state::{
+    CanonicalValue, GameOptionKind, State, StoredOption,
+    game_options_sync_is_enabled, load_game_option_preferences,
+    load_game_options_sync_state, load_shared_game_options,
+};
+use chrono::Utc;
+
+fn validation_issue(
+    sync_enabled: bool,
+    value_state: GameOptionValueState,
+    value: Option<&CanonicalValue>,
+    compatibility: &GameOptionCompatibility,
+) -> Option<GameOptionValidationIssue> {
+    if !sync_enabled {
+        return None;
+    }
+    if value_state == GameOptionValueState::UniformLocal {
+        return Some(GameOptionValidationIssue::LocalValueNeedsSaving);
+    }
+    if value.is_none() {
+        return Some(GameOptionValidationIssue::MissingValue);
+    }
+    if compatibility.total_participating > 0 && compatibility.will_receive == 0
+    {
+        return Some(GameOptionValidationIssue::NoCompatibleInstances);
+    }
+    None
+}
+
+/// Loads everything shown in the game-settings modal.
+///
+/// It returns message IDs and setting details; the frontend provides the translated
+/// labels and explanations.
+pub(super) async fn load_settings_editor(
+    state: &State,
+) -> crate::Result<GameSettingsEditorState> {
+    let (canonical_revision, catalog_revision) =
+        load_game_options_sync_state(&state.pool, CATALOG_REVISION).await?;
+    let values = load_shared_game_options(&state.pool).await?;
+    let preferences = load_game_option_preferences(&state.pool).await?;
+    let participants = load_participating_instances(state).await?;
+    let mut settings = Vec::new();
+
+    for definition in all_supported_settings() {
+        let retained = values.contains_key(definition.id)
+            || preferences.contains_key(definition.id);
+        let observed = participants.iter().any(|participant| {
+            participant.document.as_ref().is_some_and(|document| {
+                definition
+                    .keys
+                    .iter()
+                    .any(|key| document.value(key).is_some())
+            })
+        });
+        if !retained && !observed {
+            continue;
+        }
+        let stored = values.get(definition.id).cloned().unwrap_or_else(|| {
+            StoredOption {
+                option_id: definition.id.to_string(),
+                kind: GameOptionKind::Vanilla,
+                raw_key: None,
+                value: None,
+                seeded: false,
+                revision: 0,
+            }
+        });
+        let preference = preferences.get(definition.id);
+        let (canonical_value, value_state) = if stored.seeded {
+            (stored.value.clone(), GameOptionValueState::Canonical)
+        } else {
+            find_common_local_value(Some(definition), &stored, &participants)
+        };
+        let compatibility = describe_instance_support(
+            Some(definition),
+            &stored,
+            canonical_value.as_ref(),
+            &participants,
+        );
+        let sync_enabled =
+            preference.map(|value| value.enabled).unwrap_or(false);
+        let validation_error = validation_issue(
+            sync_enabled,
+            value_state,
+            canonical_value.as_ref(),
+            &compatibility,
+        );
+        settings.push(EditableGameSetting {
+            option_id: definition.id.to_string(),
+            category_id: definition.category.to_string(),
+            kind: GameOptionKind::Vanilla,
+            raw_key: None,
+            sync_enabled,
+            canonical_value,
+            value_state,
+            option_revision: stored
+                .revision
+                .max(preference.map(|value| value.revision).unwrap_or(0)),
+            editor: editor_for(definition),
+            compatibility,
+            validation_error,
+            controlled: false,
+        });
+    }
+
+    let mut custom_values = values
+        .values()
+        .filter(|value| {
+            matches!(value.kind, GameOptionKind::External)
+                && value
+                    .raw_key
+                    .as_deref()
+                    .is_none_or(|key| setting_by_file_key(key).is_none())
+        })
+        .cloned()
+        .collect::<Vec<_>>();
+    custom_values.sort_by(|left, right| left.raw_key.cmp(&right.raw_key));
+    for stored in custom_values {
+        let preference = preferences.get(&stored.option_id);
+        let (canonical_value, value_state) = if stored.seeded {
+            (stored.value.clone(), GameOptionValueState::Canonical)
+        } else {
+            find_common_local_value(None, &stored, &participants)
+        };
+        let compatibility = describe_instance_support(
+            None,
+            &stored,
+            canonical_value.as_ref(),
+            &participants,
+        );
+        let sync_enabled = preference.is_some_and(|value| value.enabled);
+        let validation_error = validation_issue(
+            sync_enabled,
+            value_state,
+            canonical_value.as_ref(),
+            &compatibility,
+        );
+        settings.push(EditableGameSetting {
+            option_id: stored.option_id.clone(),
+            category_id: "custom".to_string(),
+            kind: GameOptionKind::External,
+            raw_key: stored.raw_key.clone(),
+            sync_enabled,
+            canonical_value,
+            value_state,
+            option_revision: stored
+                .revision
+                .max(preference.map(|value| value.revision).unwrap_or(0)),
+            editor: custom_setting_editor(),
+            compatibility,
+            validation_error,
+            controlled: false,
+        });
+    }
+
+    let category_definitions = [
+        "skin_customization",
+        "video",
+        "language",
+        "music_and_sound",
+        "controls",
+        "chat",
+        "accessibility",
+        "online",
+        "custom",
+    ];
+    let categories = category_definitions
+        .into_iter()
+        .filter(|id| {
+            *id == "custom"
+                || settings.iter().any(|setting| setting.category_id == *id)
+        })
+        .map(|id| GameSettingCategory {
+            id: id.to_string(),
+            is_custom: id == "custom",
+        })
+        .collect();
+
+    Ok(GameSettingsEditorState {
+        summary_revision: summary_revision(canonical_revision, &participants),
+        canonical_revision,
+        catalog_revision,
+        total_participating: participants.len() as u32,
+        categories,
+        settings,
+    })
+}
+
+pub async fn get_config() -> crate::Result<GameSettingsEditorState> {
+    let state = State::get().await?;
+    let _guard = state.lock_synced_options().await;
+    load_settings_editor(&state).await
+}
+
+/// Previews how the user's unsaved changes would apply to their instances.
+pub async fn preview_changes(
+    request: UpdateGameSettingsRequest,
+) -> crate::Result<GameSettingsEditorState> {
+    let state = State::get().await?;
+    let _guard = state.lock_synced_options().await;
+    if request.expected_catalog_revision != CATALOG_REVISION {
+        return Ok(load_settings_editor(&state).await?);
+    }
+    let mut editor_state = load_settings_editor(&state).await?;
+    let participants = load_participating_instances(&state).await?;
+    for change in request.changes {
+        let Some(setting) = editor_state
+            .settings
+            .iter_mut()
+            .find(|setting| setting.option_id == change.option_id)
+        else {
+            continue;
+        };
+        if setting.option_revision != change.base_option_revision {
+            setting.validation_error =
+                Some(GameOptionValidationIssue::ChangedSinceOpened);
+            continue;
+        }
+        if let Some(value) = change.canonical_value {
+            let definition = setting_by_id(&setting.option_id);
+            if let Some(value) = value {
+                if validate_canonical_value(definition, &value).is_err() {
+                    setting.validation_error =
+                        Some(GameOptionValidationIssue::InvalidValue);
+                } else {
+                    setting.canonical_value = Some(value);
+                    setting.value_state = GameOptionValueState::Canonical;
+                    setting.validation_error = None;
+                }
+            } else {
+                setting.canonical_value = None;
+                setting.value_state = GameOptionValueState::Unset;
+                setting.validation_error = None;
+            }
+        }
+        if let Some(enabled) = change.sync_enabled {
+            setting.sync_enabled = enabled;
+        }
+        let stored = StoredOption {
+            option_id: setting.option_id.clone(),
+            kind: setting.kind,
+            raw_key: setting.raw_key.clone(),
+            value: setting.canonical_value.clone(),
+            seeded: setting.canonical_value.is_some(),
+            revision: setting.option_revision,
+        };
+        setting.compatibility = describe_instance_support(
+            setting_by_id(&setting.option_id),
+            &stored,
+            setting.canonical_value.as_ref(),
+            &participants,
+        );
+        if setting.sync_enabled && setting.canonical_value.is_none() {
+            setting.validation_error =
+                Some(GameOptionValidationIssue::MissingValue);
+        } else if setting.sync_enabled
+            && setting.compatibility.total_participating > 0
+            && setting.compatibility.will_receive == 0
+        {
+            setting.validation_error =
+                Some(GameOptionValidationIssue::NoCompatibleInstances);
+        }
+    }
+    Ok(editor_state)
+}
+
+/// Saves changes if nothing has changed since the modal opened, then updates each
+/// instance that can receive them.
+pub async fn save_changes(
+    request: UpdateGameSettingsRequest,
+) -> crate::Result<SaveGameSettingsResult> {
+    let state = State::get().await?;
+    let _guard = state.lock_synced_options().await;
+    if !game_options_sync_is_enabled(&state.pool).await? {
+        return Err(input_error(
+            "Turn on game-settings sync before editing shared values.",
+        ));
+    }
+    let current_editor = load_settings_editor(&state).await?;
+    let UpdateGameSettingsRequest {
+        expected_summary_revision,
+        expected_canonical_revision,
+        expected_catalog_revision,
+        changes,
+    } = request;
+    if expected_catalog_revision != CATALOG_REVISION
+        || expected_summary_revision != current_editor.summary_revision
+        || expected_canonical_revision != current_editor.canonical_revision
+    {
+        return Ok(SaveGameSettingsResult {
+            state: Some(current_editor),
+            conflicts: changes
+                .into_iter()
+                .map(|change| change.option_id)
+                .collect(),
+            ..SaveGameSettingsResult::default()
+        });
+    }
+    let stored_values = load_shared_game_options(&state.pool).await?;
+    let participants = load_participating_instances(&state).await?;
+    let mut conflicts = Vec::new();
+    let mut accepted = Vec::new();
+
+    for mut change in changes {
+        let Some(setting) = current_editor
+            .settings
+            .iter()
+            .find(|setting| setting.option_id == change.option_id)
+        else {
+            return Err(input_error(format!(
+                "Unknown game setting {}",
+                change.option_id
+            )));
+        };
+        if setting.option_revision != change.base_option_revision {
+            conflicts.push(change.option_id);
+            continue;
+        }
+        if let Some(Some(value)) = &change.canonical_value {
+            validate_canonical_value(setting_by_id(&setting.option_id), value)?;
+        }
+        let resulting_enabled =
+            change.sync_enabled.unwrap_or(setting.sync_enabled);
+        let stored_seeded = stored_values
+            .get(&setting.option_id)
+            .is_some_and(|stored| stored.seeded);
+        if resulting_enabled
+            && !stored_seeded
+            && change.canonical_value.is_none()
+            && setting.canonical_value.is_some()
+        {
+            change.canonical_value = Some(setting.canonical_value.clone());
+        }
+        let resulting_value = match &change.canonical_value {
+            Some(value) => value.as_ref(),
+            None => setting.canonical_value.as_ref(),
+        };
+        if resulting_enabled {
+            if resulting_value.is_none() {
+                return Err(input_error(format!(
+                    "Choose a value before enabling {}",
+                    setting.option_id
+                )));
+            }
+            let projected = StoredOption {
+                option_id: setting.option_id.clone(),
+                kind: setting.kind,
+                raw_key: setting.raw_key.clone(),
+                value: resulting_value.cloned(),
+                seeded: resulting_value.is_some(),
+                revision: setting.option_revision,
+            };
+            let compatibility = describe_instance_support(
+                setting_by_id(&setting.option_id),
+                &projected,
+                resulting_value,
+                &participants,
+            );
+            if compatibility.total_participating > 0
+                && compatibility.will_receive == 0
+            {
+                return Err(input_error(format!(
+                    "{} is not compatible with any participating instance",
+                    setting.option_id
+                )));
+            }
+        }
+        accepted.push((setting.clone(), change));
+    }
+
+    let mut changed = false;
+    let mut fullscreen_value = None;
+    let mut tx = state.pool.begin().await?;
+    for (setting, change) in accepted {
+        let resulting_enabled =
+            change.sync_enabled.unwrap_or(setting.sync_enabled);
+        let value_changed =
+            change.canonical_value.as_ref().is_some_and(|value| {
+                setting.value_state != GameOptionValueState::Canonical
+                    || value.as_ref() != setting.canonical_value.as_ref()
+            });
+        let selection_changed = change
+            .sync_enabled
+            .is_some_and(|enabled| enabled != setting.sync_enabled);
+        if !value_changed && !selection_changed {
+            continue;
+        }
+        if resulting_enabled
+            && setting.option_id == "fullscreen"
+            && let Some(value) = change
+                .canonical_value
+                .as_ref()
+                .and_then(|value| value.as_ref())
+                .or(setting.canonical_value.as_ref())
+        {
+            fullscreen_value = Some(value.clone());
+        }
+        changed = true;
+        let revision = setting.option_revision.saturating_add(1) as i64;
+        if let Some(value) = change.canonical_value {
+            let now = Utc::now().timestamp();
+            if let Some(value) = value {
+                let value_json = serde_json::to_string(&value)?;
+                let canonical_type = value.type_name();
+                let kind = if matches!(setting.kind, GameOptionKind::External) {
+                    "external"
+                } else {
+                    "vanilla"
+                };
+                let raw_key = setting.raw_key.as_deref();
+                let value_codec = if setting_by_id(&setting.option_id).is_some()
+                {
+                    "catalog"
+                } else {
+                    "exact_raw"
+                };
+                let source_game_version: Option<&str> = None;
+                sqlx::query!(
+                    "
+				INSERT INTO synced_game_option_values
+					(option_id, kind, raw_key, canonical_type,
+					 canonical_value_json, value_codec, seeded, revision, origin,
+					 source_game_version, source_instance_id, updated_at)
+				VALUES (?, ?, ?, ?, ?, ?, 1, ?, 'app_editor', ?, NULL, ?)
+				ON CONFLICT(option_id) DO UPDATE SET
+					kind = excluded.kind, raw_key = excluded.raw_key,
+					canonical_type = excluded.canonical_type,
+					canonical_value_json = excluded.canonical_value_json,
+					value_codec = excluded.value_codec, seeded = 1,
+					revision = excluded.revision, origin = 'app_editor',
+					source_game_version = NULL, source_instance_id = NULL,
+					updated_at = excluded.updated_at
+				",
+                    setting.option_id,
+                    kind,
+                    raw_key,
+                    canonical_type,
+                    value_json,
+                    value_codec,
+                    revision,
+                    source_game_version,
+                    now,
+                )
+                .execute(&mut *tx)
+                .await?;
+            } else {
+                sqlx::query!(
+                    "
+					UPDATE synced_game_option_values
+					SET canonical_value_json = NULL, seeded = 0, revision = ?,
+						origin = 'app_editor', source_game_version = NULL,
+						source_instance_id = NULL, updated_at = ?
+					WHERE option_id = ?
+					",
+                    revision,
+                    now,
+                    setting.option_id,
+                )
+                .execute(&mut *tx)
+                .await?;
+            }
+        }
+        if let Some(enabled) = change.sync_enabled {
+            sqlx::query!(
+                "
+				INSERT INTO synced_game_option_preferences
+					(option_id, enabled, source, revision)
+				VALUES (?, ?, ?, ?)
+				ON CONFLICT(option_id) DO UPDATE SET
+					enabled = excluded.enabled, source = 'user',
+					revision = excluded.revision
+				",
+                setting.option_id,
+                enabled,
+                "user",
+                revision,
+            )
+            .execute(&mut *tx)
+            .await?;
+        }
+    }
+    if changed {
+        let next_revision =
+            current_editor.canonical_revision.saturating_add(1) as i64;
+        let catalog_revision = CATALOG_REVISION as i64;
+        sqlx::query!(
+            "
+			INSERT INTO synced_game_option_state (singleton, revision, catalog_revision)
+			VALUES (1, ?, ?)
+			ON CONFLICT(singleton) DO UPDATE SET
+				revision = excluded.revision,
+				catalog_revision = excluded.catalog_revision
+			",
+            next_revision,
+            catalog_revision,
+        )
+        .execute(&mut *tx)
+        .await?;
+    }
+    if let Some(value) = fullscreen_value.as_ref() {
+        update_app_fullscreen_setting(&mut tx, value, true).await?;
+    }
+    tx.commit().await?;
+
+    let write_result = if changed {
+        sync_all_participating_instances(&state).await
+    } else {
+        SaveGameSettingsResult {
+            state: None,
+            applied: 0,
+            migrated: 0,
+            deferred: 0,
+            unsupported: 0,
+            failed: 0,
+            conflicts: Vec::new(),
+        }
+    };
+    Ok(SaveGameSettingsResult {
+        state: Some(load_settings_editor(&state).await?),
+        conflicts,
+        ..write_result
+    })
+}
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/source_selection.rs b/packages/app-lib/src/api/instance/synced_options/game_options/source_selection.rs
new file mode 100644
index 0000000000..f3272ba33b
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/source_selection.rs
@@ -0,0 +1,416 @@
+//! Finds eligible source instances and copies the first shared settings from one.
+
+use super::super as synced_options;
+use super::CATALOG_REVISION;
+use super::api_types::{GameOptionsSourceCandidate, GameOptionsSourceIssue};
+use super::catalog::*;
+use super::fullscreen::update_app_fullscreen_setting;
+use super::launch_overrides::currently_launcher_owned_keys;
+use super::options_file::{
+    input_error, options_path, read_document, validate_raw_key_value,
+};
+use super::read_instance_changes::custom_setting_id;
+use crate::state::{
+    CanonicalValue, InstanceMetadata, State, load_game_option_preferences,
+    load_game_options_sync_state, load_shared_game_options,
+};
+use chrono::Utc;
+
+/// Uses the selected instance's `options.txt` as the initial shared settings.
+pub(in crate::api::instance) async fn initialize_from_source_instance(
+    metadata: &InstanceMetadata,
+    state: &State,
+) -> crate::Result<()> {
+    let path = options_path(metadata, state);
+    if !path.exists() {
+        return Err(input_error(
+            "Launch the source instance once so Minecraft can create options.txt.",
+        ));
+    }
+    let (document, _) = read_document(&path).await?;
+    let launcher_keys = currently_launcher_owned_keys(metadata);
+    let entries = document.effective_entries();
+    let current_values = load_shared_game_options(&state.pool).await?;
+    let current_preferences = load_game_option_preferences(&state.pool).await?;
+    let (current_revision, _) =
+        load_game_options_sync_state(&state.pool, CATALOG_REVISION).await?;
+    let now = Utc::now().timestamp();
+    let source_version = metadata.applied_content_set.game_version.as_str();
+    let source_id = metadata.instance.id.as_str();
+    let mut tx = state.pool.begin().await?;
+    let catalog_revision = CATALOG_REVISION as i64;
+
+    sqlx::query!(
+        "
+		INSERT INTO sync_feature_settings
+			(feature, globally_enabled, new_instance_default)
+		VALUES ('game_options', 1, 1)
+		ON CONFLICT(feature) DO UPDATE SET globally_enabled = 1
+		",
+    )
+    .execute(&mut *tx)
+    .await?;
+    sqlx::query!(
+        "
+		INSERT INTO instance_sync_preferences (instance_id, feature, enabled)
+		VALUES (?, 'game_options', 1)
+		ON CONFLICT(instance_id, feature) DO UPDATE SET enabled = 1
+		",
+        source_id,
+    )
+    .execute(&mut *tx)
+    .await?;
+    sqlx::query!(
+        "
+		INSERT INTO synced_game_option_state (singleton, revision, catalog_revision)
+		VALUES (1, 0, ?)
+		ON CONFLICT(singleton) DO UPDATE SET
+			catalog_revision = excluded.catalog_revision
+		",
+        catalog_revision,
+    )
+    .execute(&mut *tx)
+    .await?;
+    sqlx::query!(
+        "UPDATE synced_game_option_values
+		 SET seeded = 0, revision = revision + 1, updated_at = ?",
+        now,
+    )
+    .execute(&mut *tx)
+    .await?;
+    for definition in all_supported_settings() {
+        for key in definition.keys {
+            let custom_id = custom_setting_id(key);
+            let Some(custom) = current_values.get(&custom_id) else {
+                continue;
+            };
+            let revision = custom
+                .revision
+                .max(
+                    current_preferences
+                        .get(&custom_id)
+                        .map(|preference| preference.revision)
+                        .unwrap_or(0),
+                )
+                .saturating_add(1) as i64;
+            sqlx::query!(
+                "
+				UPDATE synced_game_option_values
+				SET seeded = 0, revision = ?, updated_at = ?
+				WHERE option_id = ?
+				",
+                revision,
+                now,
+                custom_id,
+            )
+            .execute(&mut *tx)
+            .await?;
+            sqlx::query!(
+                "
+				UPDATE synced_game_option_preferences
+				SET enabled = 0, source = 'catalog_default', revision = ?
+				WHERE option_id = ?
+				",
+                revision,
+                custom_id,
+            )
+            .execute(&mut *tx)
+            .await?;
+        }
+    }
+    let mut seeded_any = false;
+    let mut fullscreen_value = None;
+    let mut fullscreen_sync_enabled = false;
+
+    for definition in all_supported_settings() {
+        if !supported_settings_cover_game_version(source_version) {
+            break;
+        }
+        let found = definition.keys.iter().find_map(|key| {
+            if launcher_keys.contains(*key) {
+                return None;
+            }
+            let (index, _) = entries.get(*key).copied()?;
+            let entry = document.lines[index].entry.as_ref()?;
+            decode_value_for_version(
+                definition,
+                key,
+                &entry.value,
+                source_version,
+            )
+            .map(|value| ((*key).to_string(), value))
+        });
+        let Some((_physical_key, value)) = found else {
+            continue;
+        };
+        if definition.id == "fullscreen" {
+            fullscreen_value = Some(value.clone());
+            fullscreen_sync_enabled = current_preferences
+                .get(definition.id)
+                .map(|preference| preference.enabled)
+                .unwrap_or(definition.default_on);
+        }
+        seeded_any = true;
+        let option_revision = current_values
+            .get(definition.id)
+            .map(|value| value.revision)
+            .unwrap_or(0)
+            .max(
+                current_preferences
+                    .get(definition.id)
+                    .map(|value| value.revision)
+                    .unwrap_or(0),
+            )
+            .saturating_add(1) as i64;
+        let value_json = serde_json::to_string(&value)?;
+        let canonical_type = value.type_name();
+        sqlx::query!(
+            "
+			INSERT INTO synced_game_option_values
+				(option_id, kind, raw_key, canonical_type,
+				 canonical_value_json, value_codec, seeded, revision, origin,
+				 source_game_version, source_instance_id, updated_at)
+			VALUES (?, 'vanilla', NULL, ?, ?, 'catalog', 1, ?,
+				'source_seed', ?, ?, ?)
+			ON CONFLICT(option_id) DO UPDATE SET
+				kind = 'vanilla', raw_key = NULL,
+				canonical_type = excluded.canonical_type,
+				canonical_value_json = excluded.canonical_value_json,
+				value_codec = excluded.value_codec, seeded = 1,
+				revision = excluded.revision, origin = 'source_seed',
+				source_game_version = excluded.source_game_version,
+				source_instance_id = excluded.source_instance_id,
+				updated_at = excluded.updated_at
+			",
+            definition.id,
+            canonical_type,
+            value_json,
+            option_revision,
+            source_version,
+            source_id,
+            now,
+        )
+        .execute(&mut *tx)
+        .await?;
+        let default_enabled = definition.default_on;
+        sqlx::query!(
+            "
+			INSERT INTO synced_game_option_preferences
+				(option_id, enabled, source, revision)
+			VALUES (?, ?, 'catalog_default', ?)
+			ON CONFLICT(option_id) DO NOTHING
+			",
+            definition.id,
+            default_enabled,
+            option_revision,
+        )
+        .execute(&mut *tx)
+        .await?;
+    }
+
+    for (key, (index, _)) in entries {
+        if launcher_keys.contains(key)
+            || setting_by_file_key(key).is_some()
+            || is_never_sync_key(key)
+        {
+            continue;
+        }
+        let Some(entry) = &document.lines[index].entry else {
+            continue;
+        };
+        if validate_raw_key_value(key, &entry.value).is_err() {
+            continue;
+        }
+        let option_id = custom_setting_id(key);
+        let value = CanonicalValue::ExternalRaw(entry.value.clone());
+        seeded_any = true;
+        let option_revision = current_values
+            .get(&option_id)
+            .map(|value| value.revision)
+            .unwrap_or(0)
+            .max(
+                current_preferences
+                    .get(&option_id)
+                    .map(|value| value.revision)
+                    .unwrap_or(0),
+            )
+            .saturating_add(1) as i64;
+        let value_json = serde_json::to_string(&value)?;
+        sqlx::query!(
+            "
+			INSERT INTO synced_game_option_values
+				(option_id, kind, raw_key, canonical_type,
+				 canonical_value_json, value_codec, seeded, revision, origin,
+				 source_game_version, source_instance_id, updated_at)
+			VALUES (?, 'external', ?, 'external_raw', ?, 'exact_raw',
+				1, ?, 'source_seed', ?, ?, ?)
+			ON CONFLICT(option_id) DO UPDATE SET
+				raw_key = excluded.raw_key,
+				canonical_value_json = excluded.canonical_value_json,
+				seeded = 1, revision = excluded.revision,
+				origin = 'source_seed',
+				source_game_version = excluded.source_game_version,
+				source_instance_id = excluded.source_instance_id,
+				updated_at = excluded.updated_at
+			",
+            option_id,
+            key,
+            value_json,
+            option_revision,
+            source_version,
+            source_id,
+            now,
+        )
+        .execute(&mut *tx)
+        .await?;
+        sqlx::query!(
+            "
+			INSERT INTO synced_game_option_preferences
+				(option_id, enabled, source, revision)
+			VALUES (?, 1, 'discovery_default', ?)
+			ON CONFLICT(option_id) DO NOTHING
+			",
+            option_id,
+            option_revision,
+        )
+        .execute(&mut *tx)
+        .await?;
+    }
+    if !seeded_any {
+        return Err(input_error(
+            "The selected options.txt has no settings that can be safely used as a sync baseline.",
+        ));
+    }
+
+    let next_revision = current_revision.saturating_add(1) as i64;
+    sqlx::query!(
+        "
+		UPDATE synced_game_option_state
+		SET revision = ?, catalog_revision = ?
+		WHERE singleton = 1
+		",
+        next_revision,
+        catalog_revision,
+    )
+    .execute(&mut *tx)
+    .await?;
+    if let Some(value) = fullscreen_value.as_ref() {
+        update_app_fullscreen_setting(&mut tx, value, fullscreen_sync_enabled)
+            .await?;
+    }
+    tx.commit().await?;
+    Ok(())
+}
+
+pub async fn list_sync_sources()
+-> crate::Result<Vec<GameOptionsSourceCandidate>> {
+    let state = State::get().await?;
+    let _guard = state.lock_synced_options().await;
+    let instances = crate::state::list_instances(&state.pool).await?;
+    let mut sources = Vec::with_capacity(instances.len());
+    for metadata in instances {
+        let path = options_path(&metadata, &state);
+        let version_supported = supported_settings_cover_game_version(
+            &metadata.applied_content_set.game_version,
+        );
+        let mut eligible = true;
+        let mut disabled_reason = None;
+        let mut recognized_setting_count = 0;
+        let mut custom_setting_count = 0;
+        if synced_options::sync_files_are_protected(&metadata) {
+            eligible = false;
+            disabled_reason =
+                Some(GameOptionsSourceIssue::InstallingOrUpdating);
+        } else if !path.exists() {
+            eligible = false;
+            disabled_reason = Some(GameOptionsSourceIssue::MissingOptionsFile);
+        } else {
+            match read_document(&path).await {
+                Ok((document, _)) => {
+                    let launcher_keys =
+                        currently_launcher_owned_keys(&metadata);
+                    let entries = document.effective_entries();
+                    let source_version =
+                        metadata.applied_content_set.game_version.as_str();
+                    let recognized = if version_supported {
+                        all_supported_settings()
+                            .filter(|setting| {
+                                setting.keys.iter().any(|key| {
+                                    if launcher_keys.contains(*key) {
+                                        return false;
+                                    }
+                                    document.value(key).is_some_and(|raw| {
+                                        decode_value_for_version(
+                                            setting,
+                                            key,
+                                            raw,
+                                            source_version,
+                                        )
+                                        .is_some()
+                                    })
+                                })
+                            })
+                            .count()
+                    } else {
+                        0
+                    };
+                    let custom = entries
+                        .into_iter()
+                        .filter(|(key, (index, _))| {
+                            !launcher_keys.contains(*key)
+                                && setting_by_file_key(key).is_none()
+                                && !is_never_sync_key(key)
+                                && document.lines[*index]
+                                    .entry
+                                    .as_ref()
+                                    .is_some_and(|entry| {
+                                        validate_raw_key_value(
+                                            key,
+                                            &entry.value,
+                                        )
+                                        .is_ok()
+                                    })
+                        })
+                        .count();
+                    if recognized + custom == 0 {
+                        eligible = false;
+                        disabled_reason = Some(if version_supported {
+                            GameOptionsSourceIssue::NoSyncableSettings
+                        } else {
+                            GameOptionsSourceIssue::UnsupportedVersion
+                        });
+                    } else {
+                        recognized_setting_count = recognized as u32;
+                        custom_setting_count = custom as u32;
+                    }
+                }
+                Err(error) => {
+                    tracing::warn!(
+                        "Could not inspect {} as a game-settings source: {error}",
+                        metadata.instance.id
+                    );
+                    eligible = false;
+                    disabled_reason =
+                        Some(GameOptionsSourceIssue::UnreadableOptionsFile);
+                }
+            }
+        }
+        sources.push(GameOptionsSourceCandidate {
+            source_id: metadata.instance.id.clone(),
+            instance_id: metadata.instance.id,
+            name: metadata.instance.name,
+            icon_path: metadata.instance.icon_path,
+            game_version: Some(metadata.applied_content_set.game_version),
+            eligible,
+            disabled_reason,
+            recognized_setting_count,
+            custom_setting_count,
+        });
+    }
+    sources.sort_by(|left, right| {
+        left.name
+            .cmp(&right.name)
+            .then(left.instance_id.cmp(&right.instance_id))
+    });
+    Ok(sources)
+}
diff --git a/packages/app-lib/src/api/instance/synced_options/game_options/write_shared_settings.rs b/packages/app-lib/src/api/instance/synced_options/game_options/write_shared_settings.rs
new file mode 100644
index 0000000000..06bff8c3da
--- /dev/null
+++ b/packages/app-lib/src/api/instance/synced_options/game_options/write_shared_settings.rs
@@ -0,0 +1,358 @@
+//! Imports `options.txt` saves and copies canonical values to synced instances.
+
+use super::super as synced_options;
+use super::CATALOG_REVISION;
+use super::api_types::{
+	GameOptionMappingKind, SaveGameSettingsResult, SyncOutcome,
+};
+use super::catalog::*;
+use super::options_file::{
+	GameOptionsDocument, options_path, read_document, sha1_bytes,
+};
+use super::pack_updates::materialize_yosbr_options_if_missing;
+use super::read_instance_changes::read_instance_changes_into_shared_settings;
+use super::source_selection::initialize_from_source_instance;
+use crate::state::{
+	CanonicalValue, InstanceMetadata, State, SyncedOption,
+	game_options_sync_is_enabled, load_game_option_preferences,
+	load_game_options_sync_state, load_shared_game_options,
+};
+use crate::util::io;
+
+struct AppliedSettings {
+	count: usize,
+	used_migration: bool,
+}
+
+pub(super) async fn sync_is_active_for_instance(
+	metadata: &InstanceMetadata,
+	state: &State,
+) -> crate::Result<bool> {
+	Ok(metadata.synced_options.game_options
+		&& game_options_sync_is_enabled(&state.pool).await?)
+}
+
+pub(super) async fn remember_processed_sha(
+	instance_id: &str,
+	sha1: &str,
+	state: &State,
+) -> crate::Result<()> {
+	let (canonical_revision, _) =
+		load_game_options_sync_state(&state.pool, CATALOG_REVISION).await?;
+	synced_options::begin_checkpoint(
+		instance_id,
+		SyncedOption::GameOptions,
+		"default",
+		sha1,
+		None,
+		canonical_revision as i64,
+		state,
+	)
+	.await?;
+	synced_options::finish_plain_checkpoint(
+		instance_id,
+		SyncedOption::GameOptions,
+		"default",
+		state,
+	)
+	.await
+}
+
+async fn apply_shared_settings_to_document(
+	metadata: &InstanceMetadata,
+	document: &mut GameOptionsDocument,
+	state: &State,
+) -> crate::Result<AppliedSettings> {
+	let values = load_shared_game_options(&state.pool).await?;
+	let preferences = load_game_option_preferences(&state.pool).await?;
+	let mut count = 0;
+	let mut used_migration = false;
+
+	for (option_id, preference) in preferences {
+		if !preference.enabled {
+			continue;
+		}
+		if option_id == "fullscreen"
+			&& metadata.launch_overrides.force_fullscreen.is_some()
+		{
+			continue;
+		}
+		let Some(stored) = values.get(&option_id) else {
+			continue;
+		};
+		let Some(value) = stored.value.as_ref().filter(|_| stored.seeded)
+		else {
+			continue;
+		};
+		let definition = setting_by_id(&option_id);
+		if definition.is_some()
+			&& !supported_settings_cover_game_version(
+				&metadata.applied_content_set.game_version,
+			)
+		{
+			continue;
+		}
+		if definition.is_none()
+			&& stored
+				.raw_key
+				.as_deref()
+				.is_some_and(|key| setting_by_file_key(key).is_some())
+		{
+			continue;
+		}
+
+		let target_version = &metadata.applied_content_set.game_version;
+		let key = target_physical_key(
+			definition,
+			stored,
+			document,
+			target_version,
+		)
+		.or_else(|| {
+			definition.and_then(|definition| {
+				if definition.versioned_keys.is_empty() {
+					definition.keys.first().map(|key| (*key).to_string())
+				} else {
+					physical_variant_for_version(definition, target_version)
+						.map(|variant| variant.key.to_string())
+				}
+			})
+		})
+		.or_else(|| stored.raw_key.clone());
+		let Some(key) = key else {
+			continue;
+		};
+
+		let migrated = definition.is_some_and(|definition| {
+			alias_migration_needed(definition, document, &key)
+				|| document.value(&key).is_some_and(|raw| {
+					!physical_representation_supported_for_target(
+						definition,
+						&key,
+						raw,
+						target_version,
+					)
+				})
+		});
+		let raw_value = if let Some(definition) = definition {
+			let Some(raw_value) = encode_value(
+				definition,
+				&key,
+				value,
+				target_version,
+				document.value(&key),
+			) else {
+				continue;
+			};
+			raw_value
+		} else if let CanonicalValue::ExternalRaw(raw_value) = value {
+			raw_value.clone()
+		} else {
+			continue;
+		};
+
+		document.set(&key, &raw_value, definition.is_none() || migrated)?;
+		count += 1;
+		used_migration |= migrated
+			|| definition.is_some_and(|definition| {
+				(matches!(definition.encoding, ValueEncoding::KeyBinding)
+					&& split_key_binding(&raw_value).0.parse::<i32>().is_ok())
+					|| physical_variant_for_present_key(
+						definition,
+						&key,
+						target_version,
+					)
+					.map(|variant| {
+						variant.mapping != GameOptionMappingKind::Direct
+					})
+					.unwrap_or_else(|| {
+						definition.keys.first().copied() != Some(key.as_str())
+					})
+			});
+	}
+
+	Ok(AppliedSettings {
+		count,
+		used_migration,
+	})
+}
+
+pub(super) async fn apply_shared_settings_to_instance(
+	metadata: &InstanceMetadata,
+	state: &State,
+	allow_protected: bool,
+) -> crate::Result<SyncOutcome> {
+	if !allow_protected && synced_options::sync_files_are_protected(metadata) {
+		return Ok(SyncOutcome::Deferred);
+	}
+	if !sync_is_active_for_instance(metadata, state).await? {
+		return Ok(SyncOutcome::Unchanged);
+	}
+
+	let path = options_path(metadata, state);
+	if !path.exists() {
+		materialize_yosbr_options_if_missing(metadata, state).await?;
+	}
+	let file_was_missing = !path.exists();
+	let (mut document, input_bytes) = if path.exists() {
+		read_document(&path).await?
+	} else {
+		(GameOptionsDocument::empty(), Vec::new())
+	};
+	let applied =
+		apply_shared_settings_to_document(metadata, &mut document, state).await?;
+	if file_was_missing && applied.count == 0 {
+		return Ok(SyncOutcome::WaitingForFile);
+	}
+
+	let output_bytes = document.serialize()?;
+	let output_sha1 = sha1_bytes(&output_bytes);
+	let changed = file_was_missing || output_bytes != input_bytes;
+	if changed {
+		io::write(&path, output_bytes).await?;
+	}
+	remember_processed_sha(&metadata.instance.id, &output_sha1, state).await?;
+
+	Ok(if changed && applied.used_migration {
+		SyncOutcome::Migrated
+	} else if changed {
+		SyncOutcome::Applied
+	} else {
+		SyncOutcome::Unchanged
+	})
+}
+
+pub(super) async fn capture_instance_options(
+	metadata: &InstanceMetadata,
+	state: &State,
+	allow_protected: bool,
+) -> crate::Result<SyncOutcome> {
+	if !allow_protected && synced_options::sync_files_are_protected(metadata) {
+		return Ok(SyncOutcome::Deferred);
+	}
+	if !sync_is_active_for_instance(metadata, state).await? {
+		return Ok(SyncOutcome::Unchanged);
+	}
+
+	let path = options_path(metadata, state);
+	if !path.exists() {
+		return Ok(SyncOutcome::WaitingForFile);
+	}
+	let (document, input_bytes) = read_document(&path).await?;
+	let input_sha1 = sha1_bytes(&input_bytes);
+	let checkpoint = synced_options::checkpoint(
+		&metadata.instance.id,
+		SyncedOption::GameOptions,
+		"default",
+		state,
+	)
+	.await?;
+	if checkpoint
+		.as_ref()
+		.is_some_and(|checkpoint| checkpoint.expected_sha1 == input_sha1)
+	{
+		return Ok(SyncOutcome::Unchanged);
+	}
+
+	let canonical_changed = if crate::state::shared_game_options_exist(
+		&state.pool,
+	)
+	.await?
+	{
+		read_instance_changes_into_shared_settings(metadata, &document, state)
+			.await?
+	} else {
+		initialize_from_source_instance(metadata, state).await?;
+		true
+	};
+	remember_processed_sha(&metadata.instance.id, &input_sha1, state).await?;
+
+	if canonical_changed {
+		let _ =
+			sync_other_participating_instances(state, Some(&metadata.instance.id))
+				.await;
+	}
+	Ok(SyncOutcome::Unchanged)
+}
+
+pub(in crate::api::instance) async fn capture_instance_file_change(
+	metadata: &InstanceMetadata,
+	state: &State,
+) -> crate::Result<()> {
+	capture_instance_options(metadata, state, false).await?;
+	Ok(())
+}
+
+pub(in crate::api::instance) async fn apply_instance_with_state(
+	metadata: &InstanceMetadata,
+	state: &State,
+) -> crate::Result<()> {
+	apply_shared_settings_to_instance(metadata, state, false).await?;
+	Ok(())
+}
+
+pub(super) async fn sync_other_participating_instances(
+	state: &State,
+	excluded_instance_id: Option<&str>,
+) -> SaveGameSettingsResult {
+	let mut result = SaveGameSettingsResult {
+		state: None,
+		applied: 0,
+		migrated: 0,
+		deferred: 0,
+		unsupported: 0,
+		failed: 0,
+		conflicts: Vec::new(),
+	};
+	match game_options_sync_is_enabled(&state.pool).await {
+		Ok(true) => {}
+		Ok(false) => return result,
+		Err(error) => {
+			tracing::warn!(
+				"Failed to inspect global game-options state before fan-out: {error}"
+			);
+			result.failed += 1;
+			return result;
+		}
+	}
+	let instances = match crate::state::list_instances(&state.pool).await {
+		Ok(instances) => instances,
+		Err(error) => {
+			tracing::warn!(
+				"Failed to list instances for game-options fan-out: {error}"
+			);
+			result.failed += 1;
+			return result;
+		}
+	};
+	for metadata in instances {
+		if excluded_instance_id == Some(metadata.instance.id.as_str())
+			|| !metadata.synced_options.game_options
+		{
+			continue;
+		}
+		match apply_shared_settings_to_instance(&metadata, state, false).await {
+			Ok(SyncOutcome::Applied | SyncOutcome::Unchanged) => {
+				result.applied += 1
+			}
+			Ok(SyncOutcome::Migrated) => result.migrated += 1,
+			Ok(SyncOutcome::Deferred | SyncOutcome::WaitingForFile) => {
+				result.deferred += 1
+			}
+			Err(error) => {
+				tracing::warn!(
+					"Failed to write synced game options into {}: {error}",
+					metadata.instance.id
+				);
+				result.failed += 1;
+			}
+		}
+	}
+	result
+}
+
+pub(crate) async fn sync_all_participating_instances(
+	state: &State,
+) -> SaveGameSettingsResult {
+	sync_other_participating_instances(state, None).await
+}
diff --git a/packages/app-lib/src/api/instance/synced_options/mod.rs b/packages/app-lib/src/api/instance/synced_options/mod.rs
index c5862f0b55..75518875db 100644
--- a/packages/app-lib/src/api/instance/synced_options/mod.rs
+++ b/packages/app-lib/src/api/instance/synced_options/mod.rs
@@ -1,5 +1,6 @@
 mod command_history;
 mod files;
+pub(super) mod game_options;
 mod hotbars;
 mod orchestration;
 
@@ -8,9 +9,10 @@ const HOTBAR_FILE: &str = "hotbar.nbt";
 
 pub use self::command_history::{get_command_history, set_command_history};
 pub(super) use self::files::{
-    CheckpointStatus, checkpoint, detach_link, ensure_link, finish_checkpoint,
-    instance_dir, instance_is_running, instance_option_enabled, nbt_from_bytes,
-    nbt_to_bytes, read_nbt_file, safe_instance_id, sha1_bytes, sha1_file,
+    CheckpointStatus, begin_checkpoint, checkpoint, detach_link, ensure_link,
+    finish_checkpoint, finish_plain_checkpoint, instance_dir,
+    instance_is_running, instance_option_enabled, nbt_from_bytes, nbt_to_bytes,
+    read_nbt_file, safe_instance_id, sha1_bytes, sha1_file,
     sync_files_are_protected,
 };
 pub(super) use self::orchestration::instance_option_supported;
@@ -24,5 +26,5 @@ pub use self::orchestration::{
 };
 pub(crate) use self::orchestration::{
     monitor_persisted_processes, prepare_instance_update,
-    remove_generated_instance_files,
+    reconcile_instance_after_pack_update, remove_generated_instance_files,
 };
diff --git a/packages/app-lib/src/api/instance/synced_options/orchestration.rs b/packages/app-lib/src/api/instance/synced_options/orchestration.rs
index 32888467e4..abdd54cb9d 100644
--- a/packages/app-lib/src/api/instance/synced_options/orchestration.rs
+++ b/packages/app-lib/src/api/instance/synced_options/orchestration.rs
@@ -50,6 +50,7 @@ pub enum SyncedOptionJoinResolution {
 
 #[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]
 pub struct GlobalSyncedOptions {
+    pub game_options: bool,
     pub command_history: bool,
     pub multiplayer_servers: bool,
     pub creative_hotbars: bool,
@@ -59,6 +60,7 @@ pub struct GlobalSyncedOptions {
 impl GlobalSyncedOptions {
     pub fn get(self, option: SyncedOption) -> bool {
         match option {
+            SyncedOption::GameOptions => self.game_options,
             SyncedOption::CommandHistory => self.command_history,
             SyncedOption::MultiplayerServers => self.multiplayer_servers,
             SyncedOption::CreativeHotbars => self.creative_hotbars,
@@ -68,6 +70,7 @@ impl GlobalSyncedOptions {
 
     fn set(&mut self, option: SyncedOption, enabled: bool) {
         match option {
+            SyncedOption::GameOptions => self.game_options = enabled,
             SyncedOption::CommandHistory => self.command_history = enabled,
             SyncedOption::MultiplayerServers => {
                 self.multiplayer_servers = enabled
@@ -223,7 +226,10 @@ async fn version_capability(
     option: SyncedOption,
     state: &State,
 ) -> CapabilityStatus {
-    if option == SyncedOption::Screenshots {
+    if matches!(
+        option,
+        SyncedOption::GameOptions | SyncedOption::Screenshots
+    ) {
         return CapabilityStatus::Supported;
     }
 
@@ -237,6 +243,7 @@ async fn version_capability(
 		);
     };
     let cutoff_id = match option {
+        SyncedOption::GameOptions => unreachable!(),
         // 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.
@@ -270,6 +277,7 @@ async fn version_capability(
 
     CapabilityStatus::Unsupported(
 		match option {
+			SyncedOption::GameOptions => unreachable!(),
 			SyncedOption::MultiplayerServers => {
 				"Multiplayer server syncing requires Minecraft Beta 1.8 Pre-release or newer."
 			}
@@ -292,42 +300,93 @@ pub async fn set_global_option(
 ) -> crate::Result<GlobalSyncedOptions> {
     let state = State::get().await?;
     let _guard = state.lock_synced_options().await;
-
-    if enabled && option != SyncedOption::Screenshots {
-        let base_instance_id = base_instance_id.ok_or_else(|| {
-            ErrorKind::InputError(
-                "Choose an instance to use as the sync source.".to_string(),
+    let was_enabled = get_global_options_with_state(&state).await?.get(option);
+
+    let initializing_game_options_from_base = enabled
+        && !was_enabled
+        && option == SyncedOption::GameOptions
+        && base_instance_id.is_some();
+    if enabled
+        && !was_enabled
+        && option != SyncedOption::Screenshots
+        && let Some(base_instance_id) = base_instance_id
+    {
+        if option == SyncedOption::GameOptions {
+            let source =
+                crate::state::get_instance(base_instance_id, &state.pool)
+                    .await?
+                    .ok_or_else(|| {
+                        ErrorKind::InputError(
+                            "Unknown sync source instance.".to_string(),
+                        )
+                    })?;
+            if sync_files_are_protected(&source) {
+                return Err(ErrorKind::InputError(
+                    "Wait for the source instance to finish installing or updating."
+                        .to_string(),
+                )
+                .into());
+            }
+            match capability_status(&source, option, true, &state).await {
+                CapabilityStatus::Supported => {}
+                CapabilityStatus::Unsupported(reason)
+                | CapabilityStatus::Indeterminate(reason) => {
+                    return Err(ErrorKind::InputError(reason).into());
+                }
+            }
+            seed_from_instance(&source, option, &state).await?;
+        } else {
+            return enable_global_option_from_base(
+                option,
+                base_instance_id,
+                &state,
             )
-        })?;
-        return enable_global_option_from_base(
-            option,
-            base_instance_id,
-            &state,
-        )
-        .await;
+            .await;
+        }
     }
 
-    set_global_option_enabled(option, enabled, &state).await?;
+    if !initializing_game_options_from_base {
+        set_global_option_enabled(option, enabled, &state).await?;
+    }
 
-    let instances = crate::state::list_instances(&state.pool).await?;
-    for metadata in instances {
-        if sync_files_are_protected(&metadata)
-            || instance_is_running(&metadata, &state).await?
-        {
-            continue;
+    let instances = match crate::state::list_instances(&state.pool).await {
+        Ok(instances) => instances,
+        Err(error) if option == SyncedOption::GameOptions => {
+            tracing::warn!(
+                "Game-settings sync changed, but participating instances could not be listed yet: {error}"
+            );
+            return get_global_options_with_state(&state).await;
         }
-        if !instance_option_enabled(&metadata, option) {
-            detach_option(&metadata, option, &state).await?;
+        Err(error) => return Err(error),
+    };
+    for metadata in instances {
+        let running = option != SyncedOption::GameOptions
+            && instance_is_running(&metadata, &state).await?;
+        if sync_files_are_protected(&metadata) || running {
             continue;
         }
-        match capability_status(&metadata, option, enabled, &state).await {
-            CapabilityStatus::Supported => {
-                reconcile_option(&metadata, option, &state).await?
+        let result = if !instance_option_enabled(&metadata, option) {
+            detach_option(&metadata, option, &state).await
+        } else {
+            match capability_status(&metadata, option, enabled, &state).await {
+                CapabilityStatus::Supported => {
+                    reconcile_option(&metadata, option, &state).await
+                }
+                CapabilityStatus::Unsupported(_) => {
+                    detach_option(&metadata, option, &state).await
+                }
+                CapabilityStatus::Indeterminate(_) => Ok(()),
             }
-            CapabilityStatus::Unsupported(_) => {
-                detach_option(&metadata, option, &state).await?
+        };
+        if let Err(error) = result {
+            if option == SyncedOption::GameOptions {
+                tracing::warn!(
+                    "Game-settings sync changed, but {} could not be reconciled yet: {error}",
+                    metadata.instance.id
+                );
+                continue;
             }
-            CapabilityStatus::Indeterminate(_) => {}
+            return Err(error);
         }
     }
 
@@ -451,12 +510,14 @@ pub async fn set_instance_option(
     let metadata = crate::state::get_instance(instance_id, &state.pool)
         .await?
         .ok_or_else(|| ErrorKind::InputError("Unknown instance".to_string()))?;
-    if instance_option_enabled(&metadata, option) == enabled {
+    let previous_enabled = instance_option_enabled(&metadata, option);
+    if previous_enabled == enabled {
         return Ok(metadata);
     }
     let global = get_global_options_with_state(&state).await?;
     let can_reconcile = !sync_files_are_protected(&metadata)
-        && !instance_is_running(&metadata, &state).await?;
+        && (option == SyncedOption::GameOptions
+            || !instance_is_running(&metadata, &state).await?);
     if enabled {
         let eligibility =
             capability(&metadata, option, global.get(option), &state).await;
@@ -466,7 +527,11 @@ pub async fn set_instance_option(
             )
             .into());
         }
-        if option != SyncedOption::Screenshots && !can_reconcile {
+        if !matches!(
+            option,
+            SyncedOption::GameOptions | SyncedOption::Screenshots
+        ) && !can_reconcile
+        {
             return Err(ErrorKind::InputError(
                 "Close the instance before including it in file syncing."
                     .to_string(),
@@ -504,7 +569,9 @@ pub async fn set_instance_option(
                     )
                     .await?;
                 }
-                SyncedOption::CreativeHotbars | SyncedOption::Screenshots => {
+                SyncedOption::GameOptions
+                | SyncedOption::CreativeHotbars
+                | SyncedOption::Screenshots => {
                     unreachable!()
                 }
             },
@@ -527,10 +594,28 @@ pub async fn set_instance_option(
     )
     .await?;
     if can_reconcile {
-        if enabled {
-            ensure_option(&metadata, option, &state).await?;
+        let result = if enabled {
+            ensure_option(&metadata, option, &state).await
         } else {
-            detach_option(&metadata, option, &state).await?;
+            detach_option(&metadata, option, &state).await
+        };
+        if let Err(error) = result {
+            if option == SyncedOption::GameOptions {
+                if let Err(rollback_error) =
+                    instance_rows::set_instance_sync_preference(
+                        instance_id,
+                        option,
+                        previous_enabled,
+                        &state.pool,
+                    )
+                    .await
+                {
+                    tracing::error!(
+                        "Failed to roll back the game-settings sync preference for {instance_id}: {rollback_error}"
+                    );
+                }
+            }
+            return Err(error);
         }
     }
 
@@ -559,7 +644,10 @@ pub async fn get_instance_option_join_preview(
         )
         .into());
     }
-    if option != SyncedOption::Screenshots
+    if !matches!(
+        option,
+        SyncedOption::GameOptions | SyncedOption::Screenshots
+    )
         && (sync_files_are_protected(&metadata)
             || instance_is_running(&metadata, &state).await?)
     {
@@ -584,6 +672,7 @@ async fn instance_option_join_action(
         return Ok(SyncedOptionJoinAction::SeedShared);
     }
     Ok(match option {
+        SyncedOption::GameOptions => SyncedOptionJoinAction::Attach,
         SyncedOption::CommandHistory | SyncedOption::MultiplayerServers => {
             SyncedOptionJoinAction::Merge
         }
@@ -605,7 +694,7 @@ pub async fn reconcile_all() -> crate::Result<()> {
     let instances = crate::state::list_instances(&state.pool).await?;
     for metadata in instances {
         if let Err(error) =
-            reconcile_instance_with_state(&metadata, &state).await
+            reconcile_instance_with_state(&metadata, &state, false).await
         {
             tracing::warn!(
                 "Failed to reconcile synced options for {}: {error}",
@@ -639,13 +728,6 @@ pub(crate) async fn monitor_persisted_processes() -> crate::Result<()> {
                             .await;
                     }
                     Ok(false) => {
-                        if let Err(error) =
-                            reconcile_instance(&instance_id).await
-                        {
-                            tracing::warn!(
-                                "Failed to reconcile synced options after a persisted process exited for {instance_id}: {error}"
-                            );
-                        }
                         break;
                     }
                     Err(error) => {
@@ -668,7 +750,18 @@ pub async fn reconcile_instance(instance_id: &str) -> crate::Result<()> {
     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
+    reconcile_instance_with_state(&metadata, &state, false).await
+}
+
+pub(crate) async fn reconcile_instance_after_pack_update(
+    instance_id: &str,
+) -> crate::Result<()> {
+    let state = State::get().await?;
+    let _guard = state.lock_synced_options().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, true).await
 }
 
 pub(crate) async fn prepare_instance_update(
@@ -680,10 +773,24 @@ pub(crate) async fn prepare_instance_update(
         .await?
         .ok_or_else(|| ErrorKind::InputError("Unknown instance".to_string()))?;
     for option in [
+        SyncedOption::GameOptions,
         SyncedOption::CommandHistory,
         SyncedOption::CreativeHotbars,
         SyncedOption::MultiplayerServers,
     ] {
+        if option == SyncedOption::GameOptions {
+            if let Err(error) =
+                super::game_options::prepare_instance_update_with_state(
+                    &metadata, &state,
+                )
+                .await
+            {
+                tracing::warn!(
+                    "The modpack update will continue, but options.txt could not be prepared for game-settings sync: {error}"
+                );
+            }
+            continue;
+        }
         if instance_option_enabled(&metadata, option) {
             detach_option(&metadata, option, &state).await?;
         }
@@ -694,8 +801,9 @@ pub(crate) async fn prepare_instance_update(
 async fn reconcile_instance_with_state(
     metadata: &InstanceMetadata,
     state: &State,
+    allow_protected: bool,
 ) -> crate::Result<()> {
-    if sync_files_are_protected(metadata)
+    if (!allow_protected && sync_files_are_protected(metadata))
         || instance_is_running(metadata, state).await?
     {
         return Ok(());
@@ -710,7 +818,20 @@ async fn reconcile_instance_with_state(
             .await
         {
             CapabilityStatus::Supported => {
-                reconcile_option(metadata, option, state).await?
+                if option == SyncedOption::GameOptions {
+                    continue;
+                }
+                let result = reconcile_option(metadata, option, state).await;
+                if let Err(error) = result {
+                    if option == SyncedOption::GameOptions {
+                        tracing::warn!(
+                            "Game settings could not be reconciled for {}, continuing with the remaining synced options: {error}",
+                            metadata.instance.id
+                        );
+                    } else {
+                        return Err(error);
+                    }
+                }
             }
             CapabilityStatus::Unsupported(_) => {
                 detach_option(metadata, option, state).await?
@@ -727,6 +848,10 @@ async fn reconcile_option(
     state: &State,
 ) -> crate::Result<()> {
     match option {
+        SyncedOption::GameOptions => {
+            super::game_options::apply_instance_with_state(metadata, state)
+                .await
+        }
         SyncedOption::CommandHistory => {
             reconcile_command_history(metadata, state).await
         }
@@ -753,6 +878,21 @@ pub async fn reconcile_changed_file(
         return Ok(());
     }
     match file_name {
+        "options.txt" => {
+            let participates = option_participates(
+                &metadata,
+                SyncedOption::GameOptions,
+                &state,
+            )
+            .await?;
+            if participates {
+                super::game_options::capture_instance_file_change(
+                    &metadata, &state,
+                )
+                .await?;
+            }
+            Ok(())
+        }
         COMMAND_HISTORY_FILE => {
             reconcile_command_history(&metadata, &state).await
         }
@@ -812,6 +952,7 @@ async fn backup_instance_option_file(
 ) -> crate::Result<()> {
     let directory = instance_dir(metadata, state);
     let path = match option {
+        SyncedOption::GameOptions => directory.join("options.txt"),
         SyncedOption::CommandHistory => directory.join(COMMAND_HISTORY_FILE),
         SyncedOption::CreativeHotbars => directory.join(HOTBAR_FILE),
         SyncedOption::MultiplayerServers => directory.join("servers.dat"),
@@ -860,6 +1001,12 @@ pub(super) async fn seed_from_instance(
     create_synced_directories(state).await?;
     let instance_dir = instance_dir(metadata, state);
     match option {
+        SyncedOption::GameOptions => {
+            super::game_options::initialize_from_source_instance(
+                metadata, state,
+            )
+            .await?;
+        }
         SyncedOption::CommandHistory => {
             let path = instance_dir.join(COMMAND_HISTORY_FILE);
             let contents = if path.exists() {
@@ -913,6 +1060,10 @@ async fn ensure_option(
     state: &State,
 ) -> crate::Result<()> {
     match option {
+        SyncedOption::GameOptions => {
+            super::game_options::apply_instance_with_state(metadata, state)
+                .await
+        }
         SyncedOption::CommandHistory => {
             ensure_command_history(metadata, state).await
         }
@@ -931,6 +1082,9 @@ async fn detach_option(
 ) -> crate::Result<()> {
     let instance_dir = instance_dir(metadata, state);
     match option {
+        SyncedOption::GameOptions => {
+            super::game_options::detach_instance(metadata, state).await
+        }
         SyncedOption::CommandHistory => {
             detach_link(
                 &command_history_path(state),
@@ -960,6 +1114,9 @@ async fn canonical_exists(
     state: &State,
 ) -> crate::Result<bool> {
     Ok(match option {
+        SyncedOption::GameOptions => {
+            super::game_options::canonical_exists(state).await?
+        }
         SyncedOption::CommandHistory => command_history_path(state).exists(),
         SyncedOption::CreativeHotbars => hotbar_state_exists(state).await?,
         SyncedOption::MultiplayerServers => {
@@ -979,6 +1136,14 @@ pub(super) async fn option_effective(
     {
         return Ok(false);
     }
+    option_participates(metadata, option, state).await
+}
+
+async fn option_participates(
+    metadata: &InstanceMetadata,
+    option: SyncedOption,
+    state: &State,
+) -> crate::Result<bool> {
     let global = get_global_options_with_state(state).await?;
     Ok(instance_option_enabled(metadata, option)
         && capability(metadata, option, global.get(option), state)
@@ -997,6 +1162,7 @@ fn is_linked_server_project(link: &InstanceLink) -> bool {
 
 fn option_from_str(value: &str) -> Option<SyncedOption> {
     match value {
+        "game_options" => Some(SyncedOption::GameOptions),
         "command_history" => Some(SyncedOption::CommandHistory),
         "multiplayer_servers" => Some(SyncedOption::MultiplayerServers),
         "creative_hotbars" => Some(SyncedOption::CreativeHotbars),
diff --git a/packages/app-lib/src/api/pack/install_mrpack.rs b/packages/app-lib/src/api/pack/install_mrpack.rs
index c70b472113..b3f981496e 100644
--- a/packages/app-lib/src/api/pack/install_mrpack.rs
+++ b/packages/app-lib/src/api/pack/install_mrpack.rs
@@ -1,5 +1,6 @@
 use crate::State;
 use crate::api::instance::CONFIG_FILE_EXTENSIONS;
+use crate::api::instance::GameOptionsPackSource;
 use crate::event::emit::loading_try_for_each_concurrent;
 use crate::install::{
     InstallErrorContext, InstallJobEventKind, InstallPhaseDetails,
@@ -630,8 +631,6 @@ 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,
@@ -957,6 +956,19 @@ pub(crate) async fn install_zipped_mrpack_files_with_reporter(
     )
     .await?;
 
+    let has_override =
+        |path: &str| {
+            zip_reader.file().entries().iter().any(|file| {
+                file.filename().as_str().unwrap_or_default() == path
+            })
+        };
+    let has_client_options_override =
+        has_override("client-overrides/options.txt");
+    let has_options_override = has_override("overrides/options.txt");
+    let has_client_yosbr_options_override =
+        has_override("client-overrides/config/yosbr/options.txt");
+    let has_yosbr_options_override =
+        has_override("overrides/config/yosbr/options.txt");
     let override_file_entries = zip_reader
         .file()
         .entries()
@@ -964,10 +976,15 @@ pub(crate) async fn install_zipped_mrpack_files_with_reporter(
         .enumerate()
         .filter_map(|(index, file)| {
             let filename = file.filename().as_str().unwrap_or_default();
-            ((filename.starts_with("overrides/")
+            let is_override = (filename.starts_with("overrides/")
                 || filename.starts_with("client-overrides/"))
-                && !filename.ends_with('/'))
-            .then(|| (index, file.clone()))
+                && !filename.ends_with('/');
+            let shadowed_game_options = has_client_options_override
+                && filename == "overrides/options.txt";
+            let shadowed_yosbr_options = has_client_yosbr_options_override
+                && filename == "overrides/config/yosbr/options.txt";
+            (is_override && !shadowed_game_options && !shadowed_yosbr_options)
+                .then(|| (index, file.clone()))
         })
         .collect::<Vec<_>>();
     let override_total_bytes = override_file_entries
@@ -979,6 +996,17 @@ pub(crate) async fn install_zipped_mrpack_files_with_reporter(
         filename == "overrides/servers.dat"
             || filename == "client-overrides/servers.dat"
     });
+    let game_options_override_source = if has_client_options_override {
+        Some(GameOptionsPackSource::ClientOverrides)
+    } else if has_options_override {
+        Some(GameOptionsPackSource::Overrides)
+    } else if has_client_yosbr_options_override {
+        Some(GameOptionsPackSource::ClientOverridesYosbr)
+    } else if has_yosbr_options_override {
+        Some(GameOptionsPackSource::OverridesYosbr)
+    } else {
+        None
+    };
     let progress = (override_total_bytes > 0).then_some(InstallProgress {
         current: 0,
         total: override_total_bytes,
@@ -1034,8 +1062,8 @@ pub(crate) async fn install_zipped_mrpack_files_with_reporter(
                 file.filename().as_str().unwrap().to_string(),
             )?;
         let relative_override_file_path = relative_override_file_path
-            .strip_prefix("overrides")
-            .or_else(|_| relative_override_file_path.strip_prefix("client-overrides"))
+			.strip_prefix("overrides")
+			.or_else(|_| relative_override_file_path.strip_prefix("client-overrides"))
             .map_err(|_| {
                 crate::Error::from(crate::ErrorKind::OtherError(
                     format!("Failed to strip override prefix from override file path: {relative_override_file_path}")
@@ -1141,7 +1169,17 @@ pub(crate) async fn install_zipped_mrpack_files_with_reporter(
         )
         .await?;
     }
-    crate::api::instance::reconcile_instance_synced_options(&instance_id)
+    if let Err(error) = crate::api::instance::capture_game_options_pack_base(
+        &instance_id,
+        game_options_override_source,
+    )
+    .await
+    {
+        tracing::warn!(
+            "The modpack was installed, but its options.txt could not be captured for game-settings sync: {error}"
+        );
+    }
+    crate::api::instance::reconcile_instance_after_pack_update(&instance_id)
         .await?;
 
     // If the icon doesn't exist, we expect icon.png to be a potential icon.
@@ -1299,8 +1337,11 @@ pub async fn remove_all_related_files(
             .map_err(|_| {
                 crate::Error::from(crate::ErrorKind::OtherError(
                     format!("Failed to strip override prefix from override file path: {relative_override_file_path}")
-                ))
-            })?;
+				))
+			})?;
+        if relative_override_file_path.as_str() == "options.txt" {
+            continue;
+        }
 
         // Remove this file if a corresponding one exists in the filesystem
         match io::remove_file(
diff --git a/packages/app-lib/src/api/settings.rs b/packages/app-lib/src/api/settings.rs
index a0c1294e50..264dcbd954 100644
--- a/packages/app-lib/src/api/settings.rs
+++ b/packages/app-lib/src/api/settings.rs
@@ -9,7 +9,17 @@ pub use crate::{
 #[tracing::instrument]
 pub async fn get() -> crate::Result<Settings> {
     let state = State::get().await?;
-    let settings = Settings::get(&state.pool).await?;
+    let _guard = state.lock_synced_options().await;
+    let mut settings = Settings::get(&state.pool).await?;
+    if crate::state::game_options_sync_is_enabled(&state.pool).await?
+        && let Some(fullscreen) =
+            crate::api::instance::shared_fullscreen_value(&state).await?
+    {
+        if settings.force_fullscreen != fullscreen {
+            settings.force_fullscreen = fullscreen;
+            settings.update(&state.pool).await?;
+        }
+    }
     Ok(settings)
 }
 
@@ -17,8 +27,42 @@ pub async fn get() -> crate::Result<Settings> {
 #[tracing::instrument]
 pub async fn set(settings: Settings) -> crate::Result<()> {
     let state = State::get().await?;
+    let _guard = state.lock_synced_options().await;
+    let current_settings = Settings::get(&state.pool).await?;
+    let game_options_sync_enabled =
+        crate::state::game_options_sync_is_enabled(&state.pool).await?;
+    let current_fullscreen = if game_options_sync_enabled {
+        crate::api::instance::shared_fullscreen_value(&state)
+            .await?
+            .unwrap_or(current_settings.force_fullscreen)
+    } else {
+        current_settings.force_fullscreen
+    };
+    let fullscreen_changed = current_fullscreen != settings.force_fullscreen;
+    let shared_fullscreen_changed =
+        if game_options_sync_enabled && fullscreen_changed {
+            crate::api::instance::update_shared_fullscreen_from_app(
+                &state,
+                settings.force_fullscreen,
+            )
+            .await?
+        } else {
+            false
+        };
     settings.update(&state.pool).await?;
 
+    if shared_fullscreen_changed {
+        let result =
+            crate::api::instance::sync_all_participating_instances(&state)
+                .await;
+        if result.failed > 0 {
+            tracing::warn!(
+                "Fullscreen was saved, but {} synced instance(s) could not be updated",
+                result.failed
+            );
+        }
+    }
+
     Ok(())
 }
 
diff --git a/packages/app-lib/src/install/runner.rs b/packages/app-lib/src/install/runner.rs
index 6eed6d2e71..2add5d541a 100644
--- a/packages/app-lib/src/install/runner.rs
+++ b/packages/app-lib/src/install/runner.rs
@@ -693,6 +693,16 @@ async fn run_job(job_id: Uuid) -> crate::Result<()> {
             if let Some(record) =
                 store::complete_success(job_id, &job_state, &state).await?
             {
+                if let Err(error) =
+                    crate::api::instance::reconcile_instance_synced_options(
+                        &instance_id,
+                    )
+                    .await
+                {
+                    tracing::warn!(
+                        "Failed to reconcile synced options after installing {instance_id}: {error}"
+                    );
+                }
                 recovery::clear_staging_dir(&job_state).await;
                 if let Err(error) =
                     emit_instance(&instance_id, InstancePayloadType::Edited)
@@ -1021,6 +1031,7 @@ async fn run_request(
         } => {
             prepare_existing_rollback(job_state, state, &instance_id).await?;
             lock_existing_instance(&instance_id, state).await?;
+            crate::api::instance::prepare_instance_update(&instance_id).await?;
             let disabled_project_ids = remove_existing_pack_content(
                 job_id,
                 job_state,
diff --git a/packages/app-lib/src/install/shared_instance.rs b/packages/app-lib/src/install/shared_instance.rs
index 36cbbc1577..cb347d6494 100644
--- a/packages/app-lib/src/install/shared_instance.rs
+++ b/packages/app-lib/src/install/shared_instance.rs
@@ -225,6 +225,7 @@ pub(super) async fn apply_shared_instance_update(
     let plan = SharedInstanceApplyPlan::build(&metadata, data, state).await?;
 
     if plan.configuration_changed {
+        crate::api::instance::prepare_instance_update(instance_id).await?;
         remove_existing_shared_instance_content(instance_id, state).await?;
         Box::pin(apply_shared_instance_content(
             job_id,
@@ -234,6 +235,23 @@ pub(super) async fn apply_shared_instance_update(
             data,
         ))
         .await?;
+        if data.modpack.is_none() {
+            if let Err(error) =
+                crate::api::instance::capture_game_options_pack_base(
+                    instance_id,
+                    None,
+                )
+                .await
+            {
+                tracing::warn!(
+                    "The shared instance was updated, but its local options.txt could not be restored after removing the previous pack: {error}"
+                );
+            }
+            crate::api::instance::reconcile_instance_after_pack_update(
+                instance_id,
+            )
+            .await?;
+        }
         return Ok(());
     }
 
@@ -579,6 +597,14 @@ pub(super) async fn apply_shared_instance_content(
     .await?;
 
     if let Some(modpack) = data.modpack.clone() {
+        crate::api::instance::edit(
+            instance_id,
+            crate::state::EditInstance {
+                link: Some(shared_instance_link(Some(&modpack))),
+                ..Default::default()
+            },
+        )
+        .await?;
         let location = shared_instance_pack_location(modpack);
         update_progress(
             job_id,
diff --git a/packages/app-lib/src/launcher/mod.rs b/packages/app-lib/src/launcher/mod.rs
index 009edc06c3..060cfefec8 100644
--- a/packages/app-lib/src/launcher/mod.rs
+++ b/packages/app-lib/src/launcher/mod.rs
@@ -25,9 +25,7 @@ use chrono::Utc;
 use daedalus as d;
 use daedalus::minecraft::{LoggingSide, RuleAction, VersionInfo};
 use daedalus::modded::{LoaderVersion, Manifest};
-use regex::Regex;
 use serde::Deserialize;
-use std::fmt::Write;
 use std::path::PathBuf;
 use tokio::process::Command;
 
@@ -673,6 +671,17 @@ pub async fn install_minecraft_with_reporter(
 			&state.pool,
 		)
 		.await?;
+		if let Err(error) =
+			crate::api::instance::reconcile_instance_synced_options(
+				&instance.id,
+			)
+			.await
+		{
+			tracing::warn!(
+				"Failed to reconcile synced options after installing {}: {error}",
+				instance.id
+			);
+		}
 		emit_instance(&instance.id, InstancePayloadType::Edited).await?;
 	}
     if let Some(loading_bar) = &loading_bar {
@@ -1067,49 +1076,22 @@ pub async fn launch_minecraft(
 
     command.envs(env_args.iter().cloned());
 
-    // Overwrites the minecraft options.txt file with the settings from the profile
-    // Uses 'a:b' syntax which is not quite yaml
-    if !mc_set_options.is_empty() {
-        let options_path = instance_path.join("options.txt");
-
-        let (mut options_string, input_encoding) = if options_path.exists() {
-            io::read_any_encoding_to_string(&options_path).await?
-        } else {
-            (String::new(), encoding_rs::UTF_8)
-        };
-
-        // UTF-16 encodings may be successfully detected and read, but we cannot encode
-        // them back, and it's technically possible that the game client strongly expects
-        // such encoding
-        if input_encoding != input_encoding.output_encoding() {
-            return Err(crate::ErrorKind::LauncherError(format!(
-                "The instance options.txt file uses an unsupported encoding: {}. \
-                Please either turn off instance options that need to modify this file, \
-                or convert the file to an encoding that both the game and this app support, \
-                such as UTF-8.",
-                input_encoding.name()
-            ))
-            .into());
-        }
-
-        for (key, value) in mc_set_options {
-            let re = Regex::new(&format!(r"(?m)^{}:.*$", regex::escape(key)))?;
-            // check if the regex exists in the file
-            if !re.is_match(&options_string) {
-                // The key was not found in the file, so append it
-                write!(&mut options_string, "\n{key}:{value}").unwrap();
-            } else {
-                let replaced_string = re
-                    .replace_all(&options_string, &format!("{key}:{value}"))
-                    .to_string();
-                options_string = replaced_string;
-            }
-        }
-
-        io::write(&options_path, input_encoding.encode(&options_string).0)
-            .await?;
+    if let Err(error) =
+        crate::api::instance::sync_game_options_before_launch(&instance.id)
+            .await
+    {
+        tracing::warn!(
+            "Failed to reconcile game options before launching {}: {error}",
+            instance.id
+        );
     }
 
+    crate::api::instance::apply_game_options_launcher_overrides(
+        &instance.id,
+        mc_set_options,
+    )
+    .await?;
+
     crate::state::instances::commands::set_instance_last_played(
         &instance.id,
         Utc::now(),
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 2cc2c3007e..a311c83034 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
@@ -528,6 +528,7 @@ pub(crate) async fn get_instance_sync_preferences(
     .collect::<HashSet<_>>();
 
     Ok(InstanceSyncedOptions {
+        game_options: enabled_features.contains("game_options"),
         command_history: enabled_features.contains("command_history"),
         multiplayer_servers: enabled_features.contains("multiplayer_servers"),
         creative_hotbars: enabled_features.contains("creative_hotbars"),
@@ -555,6 +556,7 @@ async fn attach_sync_preferences(
             .filter(|row| row.instance_id == record.instance.id)
         {
             match row.feature.as_str() {
+                "game_options" => record.synced_options.game_options = true,
                 "command_history" => {
                     record.synced_options.command_history = true
                 }
diff --git a/packages/app-lib/src/state/instances/commands/game_options.rs b/packages/app-lib/src/state/instances/commands/game_options.rs
new file mode 100644
index 0000000000..c75692f416
--- /dev/null
+++ b/packages/app-lib/src/state/instances/commands/game_options.rs
@@ -0,0 +1,136 @@
+use crate::state::{GameOptionKind, StoredOption, StoredPreference};
+use sqlx::SqlitePool;
+use std::collections::HashMap;
+
+/// Returns whether an instance has supplied the first set of shared values.
+///
+/// The values are kept when sync is turned off, so this is separate from checking
+/// whether sync is currently enabled.
+pub(crate) async fn shared_game_options_exist(
+    pool: &SqlitePool,
+) -> crate::Result<bool> {
+    let exists = sqlx::query_scalar!(
+        r#"
+		SELECT EXISTS(
+			SELECT 1 FROM synced_game_option_state WHERE singleton = 1
+		) AS "exists!: bool"
+		"#,
+    )
+    .fetch_one(pool)
+    .await?;
+    Ok(exists)
+}
+
+/// Returns whether game-settings sync is enabled for the app.
+pub(crate) async fn game_options_sync_is_enabled(
+    pool: &SqlitePool,
+) -> crate::Result<bool> {
+    let enabled = sqlx::query_scalar!(
+        r#"
+		SELECT globally_enabled AS "globally_enabled!: bool"
+		FROM sync_feature_settings
+		WHERE feature = 'game_options'
+		"#,
+    )
+    .fetch_optional(pool)
+    .await?
+    .unwrap_or(false);
+    Ok(enabled)
+}
+
+/// Loads two version numbers: one for the shared values and one for the list of
+/// Minecraft settings Modrinth knows how to sync.
+///
+/// If the code contains a newer list than the database remembers, use the newer
+/// version without writing to the database just to update this number.
+pub(crate) async fn load_game_options_sync_state(
+    pool: &SqlitePool,
+    current_catalog_revision: u32,
+) -> crate::Result<(u64, u32)> {
+    let row = sqlx::query!(
+        r#"
+		SELECT revision AS "revision!: i64",
+			catalog_revision AS "catalog_revision!: i64"
+		FROM synced_game_option_state
+		WHERE singleton = 1
+		"#,
+    )
+    .fetch_optional(pool)
+    .await?;
+    Ok(row
+        .map(|row| {
+            (
+                row.revision.max(0) as u64,
+                (row.catalog_revision.max(1) as u32)
+                    .max(current_catalog_revision),
+            )
+        })
+        .unwrap_or((0, current_catalog_revision)))
+}
+
+/// Loads every shared setting, including ones that are currently turned off or
+/// belong to mods that are not installed in any synced instance right now.
+pub(crate) async fn load_shared_game_options(
+    pool: &SqlitePool,
+) -> crate::Result<HashMap<String, StoredOption>> {
+    let rows = sqlx::query!(
+        r#"
+		SELECT option_id, kind, raw_key, canonical_value_json,
+			seeded AS "seeded!: bool", revision AS "revision!: i64"
+		FROM synced_game_option_values
+		"#,
+    )
+    .fetch_all(pool)
+    .await?;
+    let mut values = HashMap::with_capacity(rows.len());
+    for row in rows {
+        let value = row
+            .canonical_value_json
+            .as_deref()
+            .map(serde_json::from_str)
+            .transpose()?;
+        values.insert(
+            row.option_id.clone(),
+            StoredOption {
+                option_id: row.option_id,
+                kind: if row.kind == "external" {
+                    GameOptionKind::External
+                } else {
+                    GameOptionKind::Vanilla
+                },
+                raw_key: row.raw_key,
+                value,
+                seeded: row.seeded,
+                revision: row.revision.max(0) as u64,
+            },
+        );
+    }
+    Ok(values)
+}
+
+/// Loads whether sync is turned on for each setting.
+pub(crate) async fn load_game_option_preferences(
+    pool: &SqlitePool,
+) -> crate::Result<HashMap<String, StoredPreference>> {
+    let rows = sqlx::query!(
+        r#"
+		SELECT option_id, enabled AS "enabled!: bool",
+			revision AS "revision!: i64"
+		FROM synced_game_option_preferences
+		"#,
+    )
+    .fetch_all(pool)
+    .await?;
+    Ok(rows
+        .into_iter()
+        .map(|row| {
+            (
+                row.option_id,
+                StoredPreference {
+                    enabled: row.enabled,
+                    revision: row.revision.max(0) as u64,
+                },
+            )
+        })
+        .collect())
+}
diff --git a/packages/app-lib/src/state/instances/commands/mod.rs b/packages/app-lib/src/state/instances/commands/mod.rs
index c6a01bf927..6b1c893ff3 100644
--- a/packages/app-lib/src/state/instances/commands/mod.rs
+++ b/packages/app-lib/src/state/instances/commands/mod.rs
@@ -14,6 +14,9 @@ pub(crate) use self::get_instance::{
     get_instance, get_instance_metadata, get_instances_metadata, list_instances,
 };
 
+mod game_options;
+pub(crate) use self::game_options::*;
+
 mod list_content;
 pub(crate) use self::list_content::{
     dependencies_to_content_items, get_content_projects,
diff --git a/packages/app-lib/src/state/instances/mod.rs b/packages/app-lib/src/state/instances/mod.rs
index 3be87083a7..11a229d77e 100644
--- a/packages/app-lib/src/state/instances/mod.rs
+++ b/packages/app-lib/src/state/instances/mod.rs
@@ -3,6 +3,9 @@ pub use self::content::*;
 
 mod model;
 pub use self::model::*;
+pub(crate) use self::model::{
+    StoredOption, StoredPreference,
+};
 
 pub(crate) mod adapters;
 pub(crate) mod commands;
@@ -24,4 +27,9 @@ pub(crate) use self::commands::{
     get_linked_modpack_info, list_content, list_content_sets,
     list_linked_modpack_content, refresh_content_updates, sync_content_files,
 };
+pub(crate) use self::commands::{
+    game_options_sync_is_enabled, load_game_option_preferences,
+    load_game_options_sync_state, load_shared_game_options,
+    shared_game_options_exist,
+};
 pub(crate) mod watcher;
diff --git a/packages/app-lib/src/state/instances/model/game_options.rs b/packages/app-lib/src/state/instances/model/game_options.rs
new file mode 100644
index 0000000000..24e2f3a90f
--- /dev/null
+++ b/packages/app-lib/src/state/instances/model/game_options.rs
@@ -0,0 +1,61 @@
+use serde::{Deserialize, Serialize};
+
+/// The value shared between instances for one Minecraft setting.
+///
+/// Minecraft versions sometimes store the same setting in different ways. We
+/// convert those formats into one of these values before syncing them.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "type", content = "value", rename_all = "snake_case")]
+pub enum CanonicalValue {
+    Bool(bool),
+    Integer(i64),
+    Decimal(String),
+    Enum(String),
+    Text(String),
+    StringList(Vec<String>),
+    KeyBinding(String),
+    ExternalRaw(String),
+}
+
+impl CanonicalValue {
+    pub(crate) fn type_name(&self) -> &'static str {
+        match self {
+            Self::Bool(_) => "bool",
+            Self::Integer(_) => "integer",
+            Self::Decimal(_) => "decimal",
+            Self::Enum(_) => "enum",
+            Self::Text(_) => "text",
+            Self::StringList(_) => "string_list",
+            Self::KeyBinding(_) => "key_binding",
+            Self::ExternalRaw(_) => "external_raw",
+        }
+    }
+}
+
+/// Whether a setting comes from Minecraft itself or was added by a mod.
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum GameOptionKind {
+    Vanilla,
+    External,
+}
+
+/// A shared game setting loaded from the database.
+#[derive(Clone)]
+pub(crate) struct StoredOption {
+    pub(crate) option_id: String,
+    pub(crate) kind: GameOptionKind,
+    pub(crate) raw_key: Option<String>,
+    pub(crate) value: Option<CanonicalValue>,
+    pub(crate) seeded: bool,
+    pub(crate) revision: u64,
+}
+
+/// Whether the user chose to sync this setting.
+///
+/// This is stored separately so turning sync off does not forget its value.
+#[derive(Clone)]
+pub(crate) struct StoredPreference {
+    pub(crate) enabled: bool,
+    pub(crate) revision: u64,
+}
diff --git a/packages/app-lib/src/state/instances/model/instance.rs b/packages/app-lib/src/state/instances/model/instance.rs
index 8c2f157e6c..81e836a942 100644
--- a/packages/app-lib/src/state/instances/model/instance.rs
+++ b/packages/app-lib/src/state/instances/model/instance.rs
@@ -27,6 +27,8 @@ pub struct InstanceIconConfig {
     Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, Deserialize,
 )]
 pub struct InstanceSyncedOptions {
+    #[serde(default)]
+    pub game_options: bool,
     pub command_history: bool,
     pub multiplayer_servers: bool,
     pub creative_hotbars: bool,
@@ -36,6 +38,7 @@ pub struct InstanceSyncedOptions {
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum SyncedOption {
+    GameOptions,
     CommandHistory,
     MultiplayerServers,
     CreativeHotbars,
@@ -45,6 +48,7 @@ pub enum SyncedOption {
 impl SyncedOption {
     pub fn as_str(self) -> &'static str {
         match self {
+            Self::GameOptions => "game_options",
             Self::CommandHistory => "command_history",
             Self::MultiplayerServers => "multiplayer_servers",
             Self::CreativeHotbars => "creative_hotbars",
@@ -52,7 +56,8 @@ impl SyncedOption {
         }
     }
 
-    pub const ALL: [Self; 4] = [
+    pub const ALL: [Self; 5] = [
+        Self::GameOptions,
         Self::CommandHistory,
         Self::MultiplayerServers,
         Self::CreativeHotbars,
diff --git a/packages/app-lib/src/state/instances/model/mod.rs b/packages/app-lib/src/state/instances/model/mod.rs
index c505c5e6ca..0624286cb4 100644
--- a/packages/app-lib/src/state/instances/model/mod.rs
+++ b/packages/app-lib/src/state/instances/model/mod.rs
@@ -15,6 +15,12 @@ pub use self::content_set_sync_state::*;
 mod file;
 pub use self::file::*;
 
+mod game_options;
+pub use self::game_options::{CanonicalValue, GameOptionKind};
+pub(crate) use self::game_options::{
+    StoredOption, StoredPreference,
+};
+
 mod instance;
 pub use self::instance::*;
 
diff --git a/packages/app-lib/src/state/instances/watcher.rs b/packages/app-lib/src/state/instances/watcher.rs
index 02112f1ac0..0315895759 100644
--- a/packages/app-lib/src/state/instances/watcher.rs
+++ b/packages/app-lib/src/state/instances/watcher.rs
@@ -8,7 +8,11 @@ use crate::state::{
 use crate::worlds::WorldType;
 use notify::{RecommendedWatcher, RecursiveMode};
 use notify_debouncer_mini::{DebounceEventResult, Debouncer, new_debouncer};
-use std::{collections::HashMap, sync::Arc, time::Duration};
+use std::{
+    collections::{HashMap, HashSet},
+    sync::Arc,
+    time::Duration,
+};
 use tokio::sync::{RwLock, mpsc::channel};
 
 use super::adapters::sqlite::instance_rows;
@@ -20,7 +24,7 @@ pub struct FileWatcher {
 
 pub async fn init_watcher() -> crate::Result<FileWatcher> {
     let (tx, mut rx) = channel(1);
-    let instance_ids = Arc::new(RwLock::new(HashMap::new()));
+    let instance_ids = Arc::new(RwLock::new(HashMap::<String, String>::new()));
     let event_instance_ids = instance_ids.clone();
 
     let file_watcher = new_debouncer(
@@ -41,6 +45,8 @@ pub async fn init_watcher() -> crate::Result<FileWatcher> {
                     let instance_ids = event_instance_ids.read().await;
                     let mut visited_instances = Vec::new();
                     let mut visited_screenshot_instances = Vec::new();
+                    let mut synced_option_files =
+                        HashMap::<String, HashSet<String>>::new();
 
                     for e in &events {
                         let mut instance_path = None;
@@ -62,8 +68,9 @@ pub async fn init_watcher() -> crate::Result<FileWatcher> {
                         if let Some(instance_path) = instance_path {
                             let instance_path_str =
                                 instance_path.to_string_lossy().to_string();
-                            let Some(instance_id) =
-                                instance_ids.get(&instance_path_str).cloned()
+                            let Some(instance_id) = instance_ids
+                                .get(&instance_path_str)
+                                .cloned()
                             else {
                                 continue;
                             };
@@ -76,6 +83,24 @@ pub async fn init_watcher() -> crate::Result<FileWatcher> {
                             let is_screenshot_event = first_file_name
                                 .as_ref()
                                 .is_some_and(|name| *name == "screenshots");
+                            if let Some(file_name) = first_file_name
+                                .as_ref()
+                                .and_then(|name| name.to_str())
+                                .filter(|name| {
+                                    matches!(
+                                        *name,
+                                        "command_history.txt"
+                                            | "hotbar.nbt"
+                                            | "options.txt"
+                                            | "servers.dat"
+                                    )
+                                })
+                            {
+                                synced_option_files
+                                    .entry(instance_id.clone())
+                                    .or_default()
+                                    .insert(file_name.to_owned());
+                            }
                             if first_file_name
                                 .as_ref()
                                 .is_some_and(|x| *x == "crash-reports")
@@ -169,18 +194,6 @@ 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) =
@@ -196,18 +209,6 @@ pub async fn init_watcher() -> crate::Result<FileWatcher> {
                                                 "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(
@@ -235,6 +236,24 @@ pub async fn init_watcher() -> crate::Result<FileWatcher> {
                             }
                         }
                     }
+
+                    for (instance_id, file_names) in synced_option_files {
+                        tokio::spawn(async move {
+                            for file_name in file_names {
+                                if let Err(error) =
+                                    crate::api::instance::reconcile_synced_option_file(
+                                        &instance_id,
+                                        &file_name,
+                                    )
+                                    .await
+                                {
+                                    tracing::error!(
+                                        "Failed to reconcile {file_name} after filesystem change: {error}"
+                                    );
+                                }
+                            }
+                        });
+                    }
                 }
                 Err(error) => tracing::warn!("Unable to watch file: {error}"),
             }
diff --git a/packages/app-lib/src/state/mod.rs b/packages/app-lib/src/state/mod.rs
index f0a186a2ca..e7b5473c40 100644
--- a/packages/app-lib/src/state/mod.rs
+++ b/packages/app-lib/src/state/mod.rs
@@ -17,6 +17,14 @@ pub use self::instance_types::*;
 
 pub(crate) mod instances;
 pub use self::instances::*;
+pub(crate) use self::instances::{
+    StoredOption, StoredPreference,
+};
+pub(crate) use self::instances::{
+    game_options_sync_is_enabled, load_game_option_preferences,
+    load_game_options_sync_state, load_shared_game_options,
+    shared_game_options_exist,
+};
 
 mod settings;
 pub use self::settings::*;
diff --git a/packages/app-lib/src/state/process.rs b/packages/app-lib/src/state/process.rs
index 3b80a78bda..b9d7465b89 100644
--- a/packages/app-lib/src/state/process.rs
+++ b/packages/app-lib/src/state/process.rs
@@ -940,20 +940,6 @@ 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/components/base/Slider.vue b/packages/ui/src/components/base/Slider.vue
index fe3c3e451a..f2d590f8b3 100644
--- a/packages/ui/src/components/base/Slider.vue
+++ b/packages/ui/src/components/base/Slider.vue
@@ -31,7 +31,7 @@
 				:min="min"
 				:max="max"
 				:step="step"
-				class="slider absolute top-0 h-10 min-h-0 appearance-none border-0 bg-transparent p-0 shadow-none outline-none"
+				class="slider absolute top-0 h-10 min-h-0 appearance-none overflow-visible border-0 bg-transparent p-0 shadow-none outline-none"
 				:class="disabled ? 'cursor-not-allowed' : 'cursor-pointer'"
 				:disabled="disabled"
 				@input="onInputWithSnap(($event.target as HTMLInputElement).value)"
@@ -92,7 +92,7 @@ const props = withDefaults(defineProps<Props>(), {
 const currentValue = ref(clampValue(props.modelValue))
 const currentPercentage = computed(() => getPercentage(currentValue.value))
 const valueInputWidth = computed(
-	() => `calc(${Math.max(String(currentValue.value).length, 1)}ch + 2.125rem)`,
+	() => `calc(${Math.max(String(props.min).length, String(props.max).length, 1)}ch + 2.125rem)`,
 )
 const visibleSnapPoints = computed(() =>
 	props.snapPoints.filter((snapPoint) => snapPoint >= props.min && snapPoint <= props.max),
diff --git a/packages/ui/src/components/modal/NewModal.vue b/packages/ui/src/components/modal/NewModal.vue
index 80be8dfcfa..d6722abb38 100644
--- a/packages/ui/src/components/modal/NewModal.vue
+++ b/packages/ui/src/components/modal/NewModal.vue
@@ -1,8 +1,15 @@
 <template>
 	<Teleport to="body">
-		<div v-if="open" class="modal-root" data-modal-root :data-modal-id="modalId">
+		<div
+			v-if="open"
+			class="modal-root"
+			data-modal-root
+			:data-modal-id="modalId"
+			:data-modal-depth="stackDepth"
+		>
 			<div
 				:class="{ shown: visible }"
+				:style="{ zIndex: stackTauriZ }"
 				class="tauri-overlay"
 				data-tauri-drag-region
 				@pointerdown="onTauriOverlayPointerDown"
@@ -17,9 +24,10 @@
 					},
 					computedFade,
 				]"
+				:style="{ zIndex: stackOverlayZ }"
 				@click="() => (closeOnClickOutside && closable ? hide() : {})"
 			/>
-			<div class="modal-container" :class="{ shown: visible }">
+			<div class="modal-container" :class="{ shown: visible }" :style="{ zIndex: stackContainerZ }">
 				<div
 					ref="modalBodyRef"
 					role="dialog"
@@ -267,10 +275,13 @@ function getFocusableElements(): HTMLElement[] {
 	return Array.from(modalBodyRef.value.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR))
 }
 
-function renderedModalDepth(): number {
-	return Array.from(document.querySelectorAll<HTMLElement>('[data-modal-root]')).filter(
-		(root) => root.dataset.modalId !== modalId,
-	).length
+function nextRenderedModalDepth(): number {
+	return Array.from(document.querySelectorAll<HTMLElement>('[data-modal-root]'))
+		.filter((root) => root.dataset.modalId !== modalId)
+		.reduce((nextDepth, root) => {
+			const depth = Number(root.dataset.modalDepth)
+			return Number.isFinite(depth) ? Math.max(nextDepth, depth + 1) : nextDepth + 1
+		}, 0)
 }
 
 function show(event?: MouseEvent) {
@@ -280,7 +291,7 @@ function show(event?: MouseEvent) {
 	}
 	props.onShow?.()
 	const wasEmpty = modalStackSize() === 0
-	stackDepth.value = Math.max(modalStackSize(), renderedModalDepth())
+	stackDepth.value = Math.max(modalStackSize(), nextRenderedModalDepth())
 	open.value = true
 	previousFocusEl = document.activeElement
 	pushModal()
@@ -436,7 +447,6 @@ defineOptions({
 	left: 0;
 	width: 100%;
 	height: 100px;
-	z-index: v-bind(stackTauriZ);
 
 	&.shown {
 		opacity: 1;
@@ -447,7 +457,6 @@ defineOptions({
 .modal-overlay {
 	position: fixed;
 	inset: -5rem;
-	z-index: v-bind(stackOverlayZ);
 	opacity: 0;
 	visibility: hidden;
 	pointer-events: none;
@@ -505,7 +514,6 @@ defineOptions({
 	display: flex;
 	justify-content: center;
 	align-items: center;
-	z-index: v-bind(stackContainerZ);
 	visibility: hidden;
 	pointer-events: none;
 	transform: translate(v-bind(mouseXOffset), v-bind(mouseYOffset));
diff --git a/packages/ui/src/components/modal/TabbedModal.vue b/packages/ui/src/components/modal/TabbedModal.vue
index accfe2abe4..99a607949b 100644
--- a/packages/ui/src/components/modal/TabbedModal.vue
+++ b/packages/ui/src/components/modal/TabbedModal.vue
@@ -18,6 +18,14 @@ export interface Tab {
 	shown?: boolean
 }
 
+defineSlots<{
+	title?(): unknown
+	'sidebar-header'?(): unknown
+	footer?(): unknown
+	content?(props: { tab: Tab | undefined; index: number }): unknown
+	'floating-action-bar'?(): unknown
+}>()
+
 const { formatMessage } = useVIntl()
 
 const props = withDefaults(
@@ -28,10 +36,12 @@ const props = withDefaults(
 		width?: string
 		closable?: boolean
 		onHide?: () => void
+		onAfterHide?: () => void
 		onShow?: () => void
 		beforeHide?: () => boolean
 		beforeTabChange?: (fromIndex: number, toIndex: number) => boolean
 		floatingActionBarShown?: boolean
+		disableClose?: boolean
 	}>(),
 	{
 		header: undefined,
@@ -39,10 +49,12 @@ const props = withDefaults(
 		width: undefined,
 		closable: true,
 		onHide: undefined,
+		onAfterHide: undefined,
 		onShow: undefined,
 		beforeHide: undefined,
 		beforeTabChange: undefined,
 		floatingActionBarShown: false,
+		disableClose: false,
 	},
 )
 
@@ -102,8 +114,10 @@ defineExpose({ show, hide, selectedTab, setTab })
 		:width="width"
 		:closable="closable"
 		:on-hide="onHide"
+		:on-after-hide="onAfterHide"
 		:on-show="onShow"
 		:before-hide="beforeHide"
+		:disable-close="disableClose"
 		no-padding
 	>
 		<template v-if="$slots.title" #title>
@@ -113,6 +127,8 @@ defineExpose({ show, hide, selectedTab, setTab })
 			<div
 				class="flex min-w-0 max-h-[min(65vh,600px)] flex-col border-0 border-r-[1px] border-solid border-divider pr-4"
 			>
+				<slot name="sidebar-header" />
+
 				<div class="relative min-h-0 flex-1">
 					<Transition
 						enter-active-class="transition-all duration-200 ease-out"
@@ -205,12 +221,14 @@ defineExpose({ show, hide, selectedTab, setTab })
 					:class="floatingActionBarShown ? 'pb-24' : 'pb-6'"
 					@scroll="checkScrollState"
 				>
-					<Suspense>
-						<component
-							:is="visibleTabs[selectedTab]?.content"
-							v-if="visibleTabs[selectedTab]?.content"
-						/>
-					</Suspense>
+					<slot name="content" :tab="visibleTabs[selectedTab]" :index="selectedTab">
+						<Suspense>
+							<component
+								:is="visibleTabs[selectedTab]?.content"
+								v-if="visibleTabs[selectedTab]?.content"
+							/>
+						</Suspense>
+					</slot>
 				</div>
 
 				<Transition
diff --git a/packages/ui/src/stories/modal/NewModal.stories.ts b/packages/ui/src/stories/modal/NewModal.stories.ts
index f2931cceae..11d9f3ac3b 100644
--- a/packages/ui/src/stories/modal/NewModal.stories.ts
+++ b/packages/ui/src/stories/modal/NewModal.stories.ts
@@ -73,9 +73,9 @@ export const Stacked: Story = {
 				<NewModal ref="parentModalRef" header="Parent Modal">
 					<p>The child modal should appear above this surface and backdrop.</p>
 					<Button type="colored" color="brand" @click="openChildModal">Open Child Modal</Button>
-				</NewModal>
-				<NewModal ref="childModalRef" header="Child Modal" max-width="500px">
-					<p>This modal is the topmost layer.</p>
+					<NewModal ref="childModalRef" header="Child Modal" max-width="500px">
+						<p>This modal is the topmost layer.</p>
+					</NewModal>
 				</NewModal>
 			</div>
 		`,
diff --git a/packages/ui/src/stories/modal/TabbedModal.stories.ts b/packages/ui/src/stories/modal/TabbedModal.stories.ts
index 5d85e192ef..483dc98376 100644
--- a/packages/ui/src/stories/modal/TabbedModal.stories.ts
+++ b/packages/ui/src/stories/modal/TabbedModal.stories.ts
@@ -107,6 +107,39 @@ export const WithTitleSlot: StoryObj = {
 	}),
 }
 
+export const WithContentSlot: StoryObj = {
+	render: () => ({
+		components: { TabbedModal, Button },
+		setup() {
+			const modalRef = ref<InstanceType<typeof TabbedModal> | null>(null)
+			const tabs = [
+				{
+					name: { id: 'general', defaultMessage: 'General' },
+					icon: InfoIcon,
+				},
+				{
+					name: { id: 'appearance', defaultMessage: 'Appearance' },
+					icon: PaintbrushIcon,
+				},
+			]
+			return { modalRef, tabs }
+		},
+		template: /* html */ `
+			<div>
+				<Button type="colored" color="brand" @click="modalRef?.show()">Open with Content Slot</Button>
+				<TabbedModal ref="modalRef" header="Settings" :tabs="tabs">
+					<template #content="{ tab, index }">
+						<div class="space-y-4 py-2">
+							<h2 class="m-0 text-xl font-bold text-contrast">{{ tab?.name.defaultMessage }}</h2>
+							<p class="m-0 text-secondary">Content supplied by the parent for tab {{ index + 1 }}.</p>
+						</div>
+					</template>
+				</TabbedModal>
+			</div>
+		`,
+	}),
+}
+
 export const WithFooter: StoryObj = {
 	render: () => ({
 		components: { TabbedModal, Button },