diff --git a/Cargo.lock b/Cargo.lock
index 51cc896cb80..edc3baa6f69 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12433,6 +12433,7 @@ version = "1.0.0-local"
 dependencies = [
  "anyhow",
  "ariadne",
+ "async-compression",
  "async-minecraft-ping",
  "async-recursion",
  "async-trait",
@@ -12467,6 +12468,7 @@ dependencies = [
  "httpdate",
  "image",
  "indicatif",
+ "infer 0.22.0",
  "itertools 0.14.0",
  "json5",
  "modrinth-content-management",
diff --git a/Cargo.toml b/Cargo.toml
index 74cf970c30c..96d3a08e9bc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -38,6 +38,7 @@ anyhow = "1.0.100"
 arc-swap = "1.7.1"
 argon2 = { version = "0.5.3", features = ["std"] }
 ariadne = { path = "packages/ariadne" }
+async-compression = "0.4.32"
 async-minecraft-ping = { path = "packages/async-minecraft-ping" }
 async-recursion = "1.1.1"
 async-stripe = { version = "0.41.0", default-features = false, features = [
@@ -113,6 +114,7 @@ iana-time-zone = "0.1.64"
 image = { version = "0.25.8", default-features = false, features = ["rayon"] }
 indexmap = "2.11.4"
 indicatif = "0.18.0"
+infer = "0.22.0"
 itertools = "0.14.0"
 jemalloc_pprof = "0.8.1"
 json-patch = { version = "4.1.0", default-features = false }
diff --git a/apps/app-frontend/src/components/ui/download-manager/download-manager-job.vue b/apps/app-frontend/src/components/ui/download-manager/download-manager-job.vue
index 963670ceeef..ddc8d7c07b8 100644
--- a/apps/app-frontend/src/components/ui/download-manager/download-manager-job.vue
+++ b/apps/app-frontend/src/components/ui/download-manager/download-manager-job.vue
@@ -8,6 +8,7 @@ import {
 	PlayIcon,
 	TrashIcon,
 	UpdatedIcon,
+	UploadIcon,
 	XIcon,
 } from '@modrinth/assets'
 import {
@@ -106,7 +107,11 @@ const instanceLink = computed(() =>
 				>
 					<component
 						:is="
-							job.kind === 'external-file' || job.kind === 'debug-export' ? DownloadIcon : BoxIcon
+							job.kind === 'shared-instance-publish'
+								? UploadIcon
+								: job.kind === 'external-file' || job.kind === 'debug-export'
+									? DownloadIcon
+									: BoxIcon
 						"
 						class="size-6 text-primary"
 						aria-hidden="true"
diff --git a/apps/app-frontend/src/components/ui/download-manager/shared-instance-publishes.ts b/apps/app-frontend/src/components/ui/download-manager/shared-instance-publishes.ts
new file mode 100644
index 00000000000..8722087c980
--- /dev/null
+++ b/apps/app-frontend/src/components/ui/download-manager/shared-instance-publishes.ts
@@ -0,0 +1,81 @@
+import { reactive, ref } from 'vue'
+
+const RATE_WINDOW_MS = 5000
+
+export interface SharedInstancePublishTask {
+	id: string
+	instanceId: string
+	instanceName: string
+	iconPath: string | null
+	status: 'running' | 'succeeded' | 'failed'
+	uploadedBytes: number
+	totalBytes: number
+	rate: number
+	createdAt: string
+	finishedAt?: string
+	error?: string
+	details?: string
+}
+
+export const sharedInstancePublishes = ref(new Map<string, SharedInstancePublishTask>())
+
+export function findRunningSharedInstancePublish(instanceId: string) {
+	for (const task of sharedInstancePublishes.value.values()) {
+		if (task.instanceId === instanceId && task.status === 'running') return task
+	}
+	return null
+}
+
+export function trackSharedInstancePublish(instance: {
+	id: string
+	name: string
+	icon_path?: string | null
+}) {
+	const task = reactive<SharedInstancePublishTask>({
+		id: `shared-instance-publish-${crypto.randomUUID()}`,
+		instanceId: instance.id,
+		instanceName: instance.name,
+		iconPath: instance.icon_path ?? null,
+		status: 'running',
+		uploadedBytes: 0,
+		totalBytes: 0,
+		rate: 0,
+		createdAt: new Date().toISOString(),
+	})
+	sharedInstancePublishes.value.set(task.id, task)
+	const samples: { time: number; bytes: number }[] = []
+
+	function finish(status: SharedInstancePublishTask['status']) {
+		task.status = status
+		task.finishedAt = new Date().toISOString()
+		task.rate = 0
+	}
+
+	return {
+		update(uploadedBytes: number, totalBytes: number) {
+			if (task.status !== 'running') return
+			const now = performance.now()
+			samples.push({ time: now, bytes: uploadedBytes })
+			while (samples.length > 2 && now - samples[1].time >= RATE_WINDOW_MS) samples.shift()
+			const oldest = samples[0]
+			const elapsed = now - oldest.time
+			task.rate = elapsed >= 1000 ? ((uploadedBytes - oldest.bytes) * 1000) / elapsed : 0
+			task.uploadedBytes = uploadedBytes
+			task.totalBytes = totalBytes
+		},
+		succeed() {
+			finish('succeeded')
+		},
+		fail(error: string) {
+			task.error = error
+			finish('failed')
+		},
+		setDetails(details: string) {
+			task.details = details
+		},
+	}
+}
+
+export function getSharedInstancePublishRate(task: SharedInstancePublishTask) {
+	return task.status === 'running' ? task.rate : 0
+}
diff --git a/apps/app-frontend/src/components/ui/download-manager/use-download-manager.ts b/apps/app-frontend/src/components/ui/download-manager/use-download-manager.ts
index 0a7b9500607..47d5c38b724 100644
--- a/apps/app-frontend/src/components/ui/download-manager/use-download-manager.ts
+++ b/apps/app-frontend/src/components/ui/download-manager/use-download-manager.ts
@@ -32,12 +32,17 @@ import {
 	getExternalFileDownloadRate,
 } from './external-file-downloads'
 import { createInstallJobProgressTracker } from './install-job-progress'
+import {
+	getSharedInstancePublishRate,
+	sharedInstancePublishes,
+	type SharedInstancePublishTask,
+} from './shared-instance-publishes'
 import { storeVerificationTask } from './store-verification'
 import { useInstallJobDisplay } from './use-install-job-display'
 
 export interface DownloadManagerJob {
 	id: string
-	kind?: 'external-file' | 'debug-export'
+	kind?: 'external-file' | 'debug-export' | 'shared-instance-publish'
 	serverId?: string
 	createdAt?: string
 	instanceId: string | null
@@ -94,6 +99,21 @@ const debugExportMessages = defineMessages({
 	canceling: { id: 'app.debug-export.canceling', defaultMessage: 'Canceling export…' },
 })
 
+const publishMessages = defineMessages({
+	preparing: {
+		id: 'app.shared-instance-publish.preparing',
+		defaultMessage: 'Preparing update…',
+	},
+	uploading: {
+		id: 'app.shared-instance-publish.uploading',
+		defaultMessage: 'Pushing update…',
+	},
+	pushed: {
+		id: 'app.shared-instance-publish.pushed',
+		defaultMessage: 'Update pushed',
+	},
+})
+
 function getIconUrl(icon: string | null | undefined): string | null {
 	if (!icon) return null
 	return /^(https?:|data:|blob:|asset:|tauri:)/.test(icon) ? icon : convertFileSrc(icon)
@@ -184,11 +204,15 @@ export function useDownloadManager() {
 	const debugExportRows = computed(() =>
 		[...debugInfoExports.value.values()].map(buildDebugExportRow),
 	)
+	const publishRows = computed(() =>
+		[...sharedInstancePublishes.value.values()].map(buildPublishRow),
+	)
 	const allRows = computed(() => [
 		...rows.value,
 		...verificationRows.value,
 		...fileRows.value,
 		...debugExportRows.value,
+		...publishRows.value,
 	])
 
 	const activeJobs = computed(() =>
@@ -214,7 +238,12 @@ export function useDownloadManager() {
 		display.formatRate(
 			activeJobs.value.reduce((total, job) => {
 				const file = externalFileDownloads.value.get(job.id)
-				const fileRate = file ? getExternalFileDownloadRate(file, now.value) : null
+				const publish = sharedInstancePublishes.value.get(job.id)
+				const fileRate = file
+					? getExternalFileDownloadRate(file, now.value)
+					: publish
+						? getSharedInstancePublishRate(publish)
+						: null
 				return total + (fileRate ?? transfer.get(job.id, now.value).rate ?? 0)
 			}, 0),
 		),
@@ -262,6 +291,53 @@ export function useDownloadManager() {
 		}
 	}
 
+	function buildPublishRow(task: SharedInstancePublishTask): DownloadManagerJob {
+		const rate = getSharedInstancePublishRate(task)
+		const uploading = task.totalBytes > 0
+		const progress = uploading ? Math.min(0.99, task.uploadedBytes / task.totalBytes) : 0
+		return {
+			id: task.id,
+			kind: 'shared-instance-publish',
+			createdAt: task.createdAt,
+			instanceId: task.instanceId,
+			status: task.status,
+			paused: false,
+			canceling: false,
+			canPause: false,
+			canCancel: false,
+			title: task.instanceName,
+			iconUrl: getIconUrl(task.iconPath),
+			text:
+				task.error ??
+				formatMessage(
+					task.status === 'succeeded'
+						? publishMessages.pushed
+						: uploading
+							? publishMessages.uploading
+							: publishMessages.preparing,
+				),
+			finishedAt: task.finishedAt,
+			progress,
+			overallProgress: task.status === 'succeeded' ? 1 : progress,
+			progressLabel:
+				task.status === 'running' && uploading
+					? [
+							`${formatBytes(task.uploadedBytes)} / ${formatBytes(task.totalBytes)}`,
+							display.formatRate(rate),
+						]
+							.filter(Boolean)
+							.join(' · ')
+					: '',
+			waiting: !uploading,
+			eta:
+				rate && uploading ? display.formatEta((task.totalBytes - task.uploadedBytes) / rate) : '',
+			canRetry: false,
+			canCopyDetails: !!task.error || (appSettings.alwaysShowCopyDetails && !!task.details),
+			copied: copiedJobs.value.has(task.id),
+			busy: busyJobs.value.has(task.id),
+		}
+	}
+
 	function buildFileRow(task: ExternalFileDownloadTask): DownloadManagerJob {
 		const rate = getExternalFileDownloadRate(task, now.value)
 		const progress = task.totalBytes ? Math.min(0.99, task.downloadedBytes / task.totalBytes) : 0
@@ -491,6 +567,11 @@ export function useDownloadManager() {
 			if (file.status !== 'running') externalFileDownloads.value.delete(id)
 			return
 		}
+		const publish = sharedInstancePublishes.value.get(id)
+		if (publish) {
+			if (publish.status !== 'running') sharedInstancePublishes.value.delete(id)
+			return
+		}
 		if (storeVerificationTask.value?.id === id) {
 			if (storeVerificationTask.value.status !== 'running') storeVerificationTask.value = null
 			return
@@ -512,8 +593,13 @@ export function useDownloadManager() {
 
 	async function copyDetails(id: string) {
 		await runAction(id, async () => {
+			const publish = sharedInstancePublishes.value.get(id)
 			const file = externalFileDownloads.value.get(id) ?? debugInfoExports.value.get(id)
-			const details = file ? (file.error ?? '') : await install_job_support_details(id)
+			const details = publish
+				? (publish.details ?? publish.error ?? '')
+				: file
+					? (file.error ?? '')
+					: await install_job_support_details(id)
 			if (disposed) return
 			await navigator.clipboard.writeText(details)
 			if (disposed) return
diff --git a/apps/app-frontend/src/components/ui/shared-instances/SharedInstancePublishModal.vue b/apps/app-frontend/src/components/ui/shared-instances/SharedInstancePublishModal.vue
index 2ef93151c92..4319853c03d 100644
--- a/apps/app-frontend/src/components/ui/shared-instances/SharedInstancePublishModal.vue
+++ b/apps/app-frontend/src/components/ui/shared-instances/SharedInstancePublishModal.vue
@@ -1,70 +1,152 @@
 <template>
-	<ContentDiffModal
-		ref="publishReviewModal"
+	<NewModal
+		ref="modal"
 		:header="formatMessage(messages.header)"
-		:admonition-header="formatMessage(messages.admonitionHeader)"
-		:description="formatMessage(messages.description)"
-		:diffs="publishDiffs"
-		:confirm-label="formatMessage(messages.publishButton)"
-		:confirm-icon="UploadIcon"
-		:confirm-disabled="publishDiffs.length === 0 && selectedConfigPaths.length === 0"
-		:added-label="formatMessage(messages.addedLabel)"
-		:removed-label="formatMessage(messages.removedLabel)"
-		@confirm="publishChanges"
-		@cancel="finishReview"
+		:on-hide="finishReview"
+		max-width="544px"
+		width="544px"
+		no-padding
+		scrollable
 	>
-		<template #additional-content>
-			<Accordion
-				class="min-w-0"
-				overflow-visible
-				button-class="w-full bg-transparent m-0 p-0 border-none"
+		<div class="flex flex-col gap-4 px-6 py-4">
+			<Tabs v-model:value="activeTab" :tabs="tabs" size="large" />
+			<p class="m-0 text-base text-primary">
+				{{
+					formatMessage(
+						activeTab === 'changes' ? messages.changesDescription : messages.filesDescription,
+					)
+				}}
+			</p>
+		</div>
+
+		<ContentDiffList
+			v-show="activeTab === 'changes'"
+			:diffs="publishDiffs"
+			:added-label="formatMessage(messages.addedLabel)"
+			:removed-label="formatMessage(messages.removedLabel)"
+		/>
+		<div v-show="activeTab === 'files'">
+			<div
+				ref="fileTreeContainer"
+				class="max-h-[336px] overflow-y-auto border-0 border-y border-solid border-surface-5"
+			>
+				<FileTreeSelect
+					v-model="includedFilePaths"
+					v-model:excluded-paths="excludedFilePaths"
+					:items="fileItems"
+					:show-modified="false"
+					flush
+					@navigate="scrollFileTreeToTop"
+				/>
+			</div>
+			<div
+				class="flex flex-col gap-2 border-0 border-b border-solid border-surface-5 px-6 pb-4 pt-6"
 			>
-				<template #title>
-					<FileCogIcon class="size-4 shrink-0 text-primary" />
-					<span class="text-lg font-semibold text-contrast">
-						{{ formatMessage(messages.configTitle) }}
+				<div class="flex flex-wrap items-baseline justify-between gap-x-4 gap-y-1">
+					<span class="font-semibold text-contrast">
+						{{ formatMessage(messages.storageTitle) }}
 					</span>
-				</template>
-				<div class="flex min-w-0 flex-col gap-3 pt-4">
-					<div ref="configFileTreeContainer" class="max-h-[292px] overflow-y-auto rounded-[20px]">
-						<FileTreeSelect
-							v-model="includedConfigPaths"
-							v-model:excluded-paths="excludedConfigPaths"
-							:items="configFileItems"
-							:show-size="false"
-							:show-modified="false"
-							@navigate="scrollConfigFileTreeToTop"
-						/>
-					</div>
+					<span
+						class="font-semibold tabular-nums"
+						:class="overStorageLimit ? 'text-red' : 'text-contrast'"
+						aria-live="polite"
+					>
+						{{
+							formatMessage(messages.storageUsage, {
+								used: formatBytes(selectedSize, 1),
+								limit: formatBytes(STORAGE_LIMIT_BYTES, 0),
+							})
+						}}
+					</span>
+				</div>
+				<div
+					role="meter"
+					:aria-label="formatMessage(messages.storageTitle)"
+					:aria-valuenow="selectedSize"
+					:aria-valuemin="0"
+					:aria-valuemax="STORAGE_LIMIT_BYTES"
+					class="relative h-3.5 overflow-hidden rounded-full bg-surface-4"
+				>
+					<div
+						class="absolute inset-y-0 left-0 bg-gradient-to-b from-white/10 to-black/10 motion-safe:transition-[width,background-color] motion-safe:duration-300"
+						:style="{ width: `${withinLimitPercent}%`, backgroundColor: storageBarColor }"
+					/>
+					<div
+						v-if="overStorageLimit"
+						class="absolute inset-y-0 right-0 bg-red bg-gradient-to-b from-white/10 to-black/10 motion-safe:transition-[left] motion-safe:duration-300"
+						:style="{ left: `calc(${limitMarkerPercent}% + 2px)` }"
+					/>
+					<div
+						v-if="overStorageLimit"
+						class="absolute inset-y-0 w-0 border-0 border-l-2 border-dotted border-contrast"
+						:style="{ left: `${limitMarkerPercent}%` }"
+						aria-hidden="true"
+					/>
 				</div>
-			</Accordion>
+				<p v-if="overStorageLimit" class="m-0 text-sm text-red">
+					{{
+						formatMessage(messages.storageOverLimit, {
+							size: formatBytes(selectedSize - STORAGE_LIMIT_BYTES, 1),
+						})
+					}}
+				</p>
+			</div>
+		</div>
+
+		<template #actions>
+			<div class="flex justify-end gap-2 p-2">
+				<Button type="outlined" class="!border" @click="modal?.hide()">
+					<XIcon />
+					{{ formatMessage(commonMessages.cancelButton) }}
+				</Button>
+				<Button type="colored" color="brand" :disabled="confirmDisabled" @click="confirmPublish">
+					<UploadIcon />
+					{{ formatMessage(messages.publishButton) }}
+				</Button>
+			</div>
 		</template>
-	</ContentDiffModal>
+	</NewModal>
 </template>
 
 <script setup lang="ts">
-import { FileCogIcon, UploadIcon } from '@modrinth/assets'
+import { UploadIcon, XIcon } from '@modrinth/assets'
 import {
-	Accordion,
+	Button,
+	commonMessages,
 	type ContentDiffItem,
-	ContentDiffModal,
+	ContentDiffList,
 	defineMessages,
 	FileTreeSelect,
 	type FileTreeSelectItem,
+	NewModal,
+	Tabs,
+	type TabsTab,
+	type TabsValue,
+	useFormatBytes,
 	useVIntl,
 } from '@modrinth/ui'
 import { computed, ref } from 'vue'
 
+import { trackSharedInstancePublish } from '@/components/ui/download-manager/shared-instance-publishes'
 import {
+	getErrorMessage,
 	getSharedInstanceUnavailableReason,
 	isSharedInstanceUnavailableError,
 } from '@/helpers/install'
-import { get_shared_instance_publish_preview, publish_shared_instance } from '@/helpers/instance'
+import {
+	get_shared_instance_publish_preview,
+	get_shared_instance_publish_support_details,
+	publish_shared_instance,
+	type SharedInstancePublishFile,
+} from '@/helpers/instance'
 import { useSharedInstanceErrors } from '@/helpers/shared-instance-errors'
 import type { GameInstance } from '@/helpers/types'
 
 type SharedInstancePublishState = 'idle' | 'reviewing' | 'publishing'
 
+const STORAGE_LIMIT_BYTES = 2 * 1024 ** 3
+const STORAGE_WARNING_RATIO = 0.75
+
 const props = defineProps<{
 	instance: GameInstance
 }>()
@@ -75,25 +157,61 @@ const emit = defineEmits<{
 }>()
 
 const { formatMessage } = useVIntl()
+const formatBytes = useFormatBytes()
 const { notifySharedInstanceError, notifySharedInstanceUnavailable } = useSharedInstanceErrors()
-const publishReviewModal = ref<InstanceType<typeof ContentDiffModal>>()
-const configFileTreeContainer = ref<HTMLElement>()
+const modal = ref<InstanceType<typeof NewModal>>()
+const fileTreeContainer = ref<HTMLElement>()
 const publishDiffs = ref<ContentDiffItem[]>([])
-const configFilePaths = ref<string[]>([])
-const includedConfigPaths = ref<string[]>([])
-const excludedConfigPaths = ref<string[]>([])
+const files = ref<SharedInstancePublishFile[]>([])
+const includedFilePaths = ref<string[]>([])
+const excludedFilePaths = ref<string[]>([])
+const activeTab = ref<TabsValue>('changes')
 const state = ref<SharedInstancePublishState>('idle')
-const configFileItems = computed<FileTreeSelectItem[]>(() =>
-	configFilePaths.value.map((path) => ({ path, type: 'file' })),
+const tabs = computed<TabsTab[]>(() => [
+	{ value: 'changes', label: formatMessage(messages.changesTab) },
+	{ value: 'files', label: formatMessage(messages.filesTab) },
+])
+const fileItems = computed<FileTreeSelectItem[]>(() =>
+	files.value.map(({ path, size, blocked }) => ({
+		path,
+		size,
+		type: 'file',
+		disabled: blocked,
+		disabledTooltip: blocked ? formatMessage(messages.fileTypeNotAllowed) : undefined,
+	})),
 )
-const selectedConfigPaths = computed(() => {
-	const includedPaths = new Set(includedConfigPaths.value)
-	const excludedPaths = new Set(excludedConfigPaths.value)
+const selectedFiles = computed(() => {
+	const includedPaths = new Set(includedFilePaths.value)
+	const excludedPaths = new Set(excludedFilePaths.value)
 
-	return configFilePaths.value.filter((path) =>
-		isConfigPathSelected(path, includedPaths, excludedPaths),
+	return files.value.filter(
+		(file) => !file.blocked && isPathSelected(file.path, includedPaths, excludedPaths),
 	)
 })
+const selectedFilePaths = computed(() => selectedFiles.value.map((file) => file.path))
+const selectedSize = computed(() =>
+	selectedFiles.value.reduce((total, file) => total + file.size, 0),
+)
+const overStorageLimit = computed(() => selectedSize.value > STORAGE_LIMIT_BYTES)
+const confirmDisabled = computed(
+	() =>
+		overStorageLimit.value ||
+		(publishDiffs.value.length === 0 && selectedFilePaths.value.length === 0),
+)
+const storageBarScale = computed(() => Math.max(selectedSize.value, STORAGE_LIMIT_BYTES))
+const withinLimitPercent = computed(
+	() => (Math.min(selectedSize.value, STORAGE_LIMIT_BYTES) / storageBarScale.value) * 100,
+)
+const limitMarkerPercent = computed(() => (STORAGE_LIMIT_BYTES / storageBarScale.value) * 100)
+const storageBarColor = computed(() => {
+	const ratio = Math.min(selectedSize.value / STORAGE_LIMIT_BYTES, 1)
+	if (ratio <= STORAGE_WARNING_RATIO) {
+		const orangeWeight = (ratio / STORAGE_WARNING_RATIO) * 100
+		return `color-mix(in oklch, var(--color-green), var(--color-orange) ${orangeWeight}%)`
+	}
+	const redWeight = ((ratio - STORAGE_WARNING_RATIO) / (1 - STORAGE_WARNING_RATIO)) * 100
+	return `color-mix(in oklch, var(--color-orange), var(--color-red) ${redWeight}%)`
+})
 
 async function show(e?: MouseEvent) {
 	if (state.value !== 'idle') return
@@ -117,12 +235,13 @@ async function show(e?: MouseEvent) {
 			fileCount: diff.configFileCount ?? undefined,
 			disabled: diff.disabled,
 		}))
-		configFilePaths.value = preview.configFiles
-		includedConfigPaths.value = []
-		excludedConfigPaths.value = []
-		if (!publishReviewModal.value) return
+		files.value = preview.files
+		includedFilePaths.value = []
+		excludedFilePaths.value = []
+		activeTab.value = 'changes'
+		if (!modal.value) return
 
-		publishReviewModal.value.show(e)
+		modal.value.show(e)
 		reviewOpened = true
 	} catch (error) {
 		handlePublishError(error)
@@ -131,25 +250,42 @@ async function show(e?: MouseEvent) {
 	}
 }
 
+function confirmPublish() {
+	if (confirmDisabled.value) return
+
+	void publishChanges()
+	modal.value?.hide()
+}
+
 async function publishChanges() {
-	if (state.value !== 'reviewing') return
+	if (state.value !== 'reviewing' || overStorageLimit.value) return
 
 	setState('publishing')
+	const task = trackSharedInstancePublish(props.instance)
 	try {
-		await publish_shared_instance(props.instance.id, selectedConfigPaths.value)
+		await publish_shared_instance(props.instance.id, selectedFilePaths.value, task.update)
+		await loadSupportDetails(task)
+		task.succeed()
 		emit('published')
 	} catch (error) {
+		await loadSupportDetails(task)
+		task.fail(getErrorMessage(error))
 		handlePublishError(error)
 	} finally {
 		setState('idle')
 	}
 }
 
-function isConfigPathSelected(
-	path: string,
-	includedPaths: Set<string>,
-	excludedPaths: Set<string>,
-) {
+async function loadSupportDetails(task: ReturnType<typeof trackSharedInstancePublish>) {
+	try {
+		const details = await get_shared_instance_publish_support_details(props.instance.id)
+		if (details) task.setDetails(details)
+	} catch {
+		return
+	}
+}
+
+function isPathSelected(path: string, includedPaths: Set<string>, excludedPaths: Set<string>) {
 	let selected = false
 	let prefix = ''
 
@@ -162,9 +298,9 @@ function isConfigPathSelected(
 	return selected
 }
 
-function scrollConfigFileTreeToTop() {
-	if (configFileTreeContainer.value) {
-		configFileTreeContainer.value.scrollTop = 0
+function scrollFileTreeToTop() {
+	if (fileTreeContainer.value) {
+		fileTreeContainer.value.scrollTop = 0
 	}
 }
 
@@ -192,16 +328,25 @@ function setState(nextState: SharedInstancePublishState) {
 const messages = defineMessages({
 	header: {
 		id: 'instance.shared-instance.publish-review.header',
-		defaultMessage: 'Review changes',
+		defaultMessage: 'Push update',
 	},
-	admonitionHeader: {
-		id: 'instance.shared-instance.publish-review.admonition-header',
-		defaultMessage: 'Push update to players',
+	changesTab: {
+		id: 'instance.shared-instance.publish-review.changes-tab',
+		defaultMessage: 'Changes',
 	},
-	description: {
-		id: 'instance.shared-instance.publish-review.description',
+	filesTab: {
+		id: 'instance.shared-instance.publish-review.files-tab',
+		defaultMessage: 'Files',
+	},
+	changesDescription: {
+		id: 'instance.shared-instance.publish-review.changes-description',
+		defaultMessage:
+			"Review the changes we've detected since your last update. These will automatically be included when you push.",
+	},
+	filesDescription: {
+		id: 'instance.shared-instance.publish-review.files-description',
 		defaultMessage:
-			'Review the content changes and choose any config files to include in this update.',
+			"You can also include individual files alongside the detected changes. Select any additional files you'd like to publish.",
 	},
 	publishButton: {
 		id: 'instance.shared-instance.publish-review.publish-button',
@@ -215,9 +360,21 @@ const messages = defineMessages({
 		id: 'instance.shared-instance.publish-review.removed-label',
 		defaultMessage: 'Removed',
 	},
-	configTitle: {
-		id: 'instance.shared-instance.publish-review.config-title-v2',
-		defaultMessage: 'Select config files',
+	storageTitle: {
+		id: 'instance.shared-instance.publish-review.storage-title',
+		defaultMessage: 'Storage allowance',
+	},
+	storageUsage: {
+		id: 'instance.shared-instance.publish-review.storage-usage',
+		defaultMessage: '{used} of {limit}',
+	},
+	storageOverLimit: {
+		id: 'instance.shared-instance.publish-review.storage-over-limit',
+		defaultMessage: '{size} over the limit. Deselect some files to push this update.',
+	},
+	fileTypeNotAllowed: {
+		id: 'instance.shared-instance.publish-review.file-type-not-allowed',
+		defaultMessage: "You're not allowed to push this file type.",
 	},
 })
 
diff --git a/apps/app-frontend/src/helpers/install.ts b/apps/app-frontend/src/helpers/install.ts
index 6f6477ea279..3ddcf13d1dc 100644
--- a/apps/app-frontend/src/helpers/install.ts
+++ b/apps/app-frontend/src/helpers/install.ts
@@ -128,6 +128,7 @@ const SHARED_INSTANCE_UNAVAILABLE_ERROR_CODES: Record<string, SharedInstanceUnav
 	shared_instance_quarantined: 'quarantined',
 }
 export const SHARED_INSTANCES_API_ERROR_CODE = 'shared_instances_api_error'
+export const SHARED_INSTANCE_FILE_NOT_ALLOWED_ERROR_CODE = 'shared_instance_file_not_allowed'
 
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === 'object' && value !== null
@@ -141,6 +142,10 @@ export function isSharedInstancesApiError(error: unknown) {
 	return isRecord(error) && error.code === SHARED_INSTANCES_API_ERROR_CODE
 }
 
+export function isSharedInstanceFileNotAllowedError(error: unknown) {
+	return isRecord(error) && error.code === SHARED_INSTANCE_FILE_NOT_ALLOWED_ERROR_CODE
+}
+
 export function getSharedInstanceUnavailableReason(
 	error: unknown,
 ): SharedInstanceUnavailableReason | null {
diff --git a/apps/app-frontend/src/helpers/instance.ts b/apps/app-frontend/src/helpers/instance.ts
index 46de853e802..a37a962dae1 100644
--- a/apps/app-frontend/src/helpers/instance.ts
+++ b/apps/app-frontend/src/helpers/instance.ts
@@ -5,7 +5,7 @@
  */
 import type { Labrinth } from '@modrinth/api-client'
 import type { ContentItem, ContentOwner } from '@modrinth/ui'
-import { convertFileSrc, invoke } from '@tauri-apps/api/core'
+import { Channel, convertFileSrc, invoke } from '@tauri-apps/api/core'
 
 import type { InstallJobSnapshot, SharedInstanceUpdateDiff } from './install'
 import type {
@@ -683,7 +683,13 @@ export interface SharedInstancePublishPreview {
 	sharedInstanceId: string
 	latestVersion: number
 	diffs: SharedInstanceUpdateDiff[]
-	configFiles: string[]
+	files: SharedInstancePublishFile[]
+}
+
+export interface SharedInstancePublishFile {
+	path: string
+	size: number
+	blocked: boolean
 }
 
 export interface SharedInstanceInviteLink {
@@ -761,9 +767,20 @@ export async function get_shared_instance_publish_preview(
 
 export async function publish_shared_instance(
 	instanceId: string,
-	configPaths: string[],
+	filePaths: string[],
+	onProgress: (uploadedBytes: number, totalBytes: number) => void,
 ): Promise<SharedInstanceAttachment> {
-	return await invoke('plugin:instance|instance_share_publish', { instanceId, configPaths })
+	return await invoke('plugin:instance|instance_share_publish', {
+		instanceId,
+		filePaths,
+		onProgress: new Channel<[number, number]>(([uploaded, total]) => onProgress(uploaded, total)),
+	})
+}
+
+export async function get_shared_instance_publish_support_details(
+	instanceId: string,
+): Promise<string | null> {
+	return await invoke('plugin:instance|instance_share_publish_support_details', { instanceId })
 }
 
 export async function unlink_shared_instance(instanceId: string): Promise<void> {
diff --git a/apps/app-frontend/src/helpers/shared-instance-errors.ts b/apps/app-frontend/src/helpers/shared-instance-errors.ts
index b0ce5d0f74d..88865750f0a 100644
--- a/apps/app-frontend/src/helpers/shared-instance-errors.ts
+++ b/apps/app-frontend/src/helpers/shared-instance-errors.ts
@@ -2,6 +2,7 @@ import { defineMessages, injectNotificationManager, useVIntl } from '@modrinth/u
 
 import {
 	getErrorMessage,
+	isSharedInstanceFileNotAllowedError,
 	isSharedInstancesApiError,
 	type SharedInstanceUnavailableReason,
 } from '@/helpers/install'
@@ -51,6 +52,10 @@ export const sharedInstanceErrorMessages = defineMessages({
 		id: 'instance.shared-instance.network-error.text',
 		defaultMessage: 'Unable to connect to shared instances API',
 	},
+	fileNotAllowedTitle: {
+		id: 'instance.shared-instance.file-not-allowed.title',
+		defaultMessage: 'File type not allowed',
+	},
 })
 
 export function sharedInstanceUnavailableTextMessage(
@@ -110,7 +115,11 @@ export function useSharedInstanceErrors() {
 
 		addNotification({
 			type: 'error',
-			title: formatMessage(sharedInstanceErrorMessages.errorTitle),
+			title: formatMessage(
+				isSharedInstanceFileNotAllowedError(error)
+					? sharedInstanceErrorMessages.fileNotAllowedTitle
+					: sharedInstanceErrorMessages.errorTitle,
+			),
 			text: getErrorMessage(error),
 		})
 	}
diff --git a/apps/app-frontend/src/locales/ar-SA/index.json b/apps/app-frontend/src/locales/ar-SA/index.json
index 5948dd4859b..816aac6dcb6 100644
--- a/apps/app-frontend/src/locales/ar-SA/index.json
+++ b/apps/app-frontend/src/locales/ar-SA/index.json
@@ -2852,15 +2852,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "مضاف"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "رفع التحديث للاعبين"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "اختر مِلَف الإعداد"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "راجع تغييرات المحتوى واختر أي ملفات تكوين (config) لضرورة تضمينها في هذا التحديث."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "مراجعة التغييرات"
   },
diff --git a/apps/app-frontend/src/locales/da-DK/index.json b/apps/app-frontend/src/locales/da-DK/index.json
index f3c45b93629..d7719e7cb35 100644
--- a/apps/app-frontend/src/locales/da-DK/index.json
+++ b/apps/app-frontend/src/locales/da-DK/index.json
@@ -1022,12 +1022,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Tilføjede"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Skub opdatering til spillere"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Vælg konfigurations filer"
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "Gennemså ændringer"
   },
diff --git a/apps/app-frontend/src/locales/de-CH/index.json b/apps/app-frontend/src/locales/de-CH/index.json
index 42b3fd4a704..2e92c3ba3af 100644
--- a/apps/app-frontend/src/locales/de-CH/index.json
+++ b/apps/app-frontend/src/locales/de-CH/index.json
@@ -4301,15 +4301,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Hinzugefügt"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Update an Spieler senden"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Konfigurationsdateien auswählen"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "Überprüfe die Inhaltsänderungen und wähle Konfigurationsdateien aus, die in diesem Update enthalten sein sollen."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "Änderungen überprüfen"
   },
diff --git a/apps/app-frontend/src/locales/de-DE/index.json b/apps/app-frontend/src/locales/de-DE/index.json
index b9397171092..ad9d66fe323 100644
--- a/apps/app-frontend/src/locales/de-DE/index.json
+++ b/apps/app-frontend/src/locales/de-DE/index.json
@@ -4301,15 +4301,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Hinzugefügt"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Update an Spieler senden"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Konfigurationsdateien auswählen"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "Überprüfe die Inhaltsänderungen und wähle Konfigurationsdateien aus, die in diesem Update enthalten sein sollen."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "Änderungen überprüfen"
   },
diff --git a/apps/app-frontend/src/locales/en-US/index.json b/apps/app-frontend/src/locales/en-US/index.json
index b2f15f6e2e9..3055ce1c772 100644
--- a/apps/app-frontend/src/locales/en-US/index.json
+++ b/apps/app-frontend/src/locales/en-US/index.json
@@ -3182,6 +3182,15 @@
   "app.settings.troubleshooting.report-ad.title": {
     "message": "Report an ad"
   },
+  "app.shared-instance-publish.preparing": {
+    "message": "Preparing update…"
+  },
+  "app.shared-instance-publish.pushed": {
+    "message": "Update pushed"
+  },
+  "app.shared-instance-publish.uploading": {
+    "message": "Pushing update…"
+  },
   "app.sidebar.playing-as": {
     "message": "Playing as"
   },
@@ -4382,6 +4391,9 @@
   "instance.shared-instance.error.title": {
     "message": "Something has gone wrong"
   },
+  "instance.shared-instance.file-not-allowed.title": {
+    "message": "File type not allowed"
+  },
   "instance.shared-instance.network-error.text": {
     "message": "Unable to connect to shared instances API"
   },
@@ -4394,17 +4406,23 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Added"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Push update to players"
+  "instance.shared-instance.publish-review.changes-description": {
+    "message": "Review the changes we've detected since your last update. These will automatically be included when you push."
+  },
+  "instance.shared-instance.publish-review.changes-tab": {
+    "message": "Changes"
+  },
+  "instance.shared-instance.publish-review.file-type-not-allowed": {
+    "message": "You're not allowed to push this file type."
   },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Select config files"
+  "instance.shared-instance.publish-review.files-description": {
+    "message": "You can also include individual files alongside the detected changes. Select any additional files you'd like to publish."
   },
-  "instance.shared-instance.publish-review.description": {
-    "message": "Review the content changes and choose any config files to include in this update."
+  "instance.shared-instance.publish-review.files-tab": {
+    "message": "Files"
   },
   "instance.shared-instance.publish-review.header": {
-    "message": "Review changes"
+    "message": "Push update"
   },
   "instance.shared-instance.publish-review.publish-button": {
     "message": "Push update"
@@ -4412,6 +4430,15 @@
   "instance.shared-instance.publish-review.removed-label": {
     "message": "Removed"
   },
+  "instance.shared-instance.publish-review.storage-over-limit": {
+    "message": "{size} over the limit. Deselect some files to push this update."
+  },
+  "instance.shared-instance.publish-review.storage-title": {
+    "message": "Storage allowance"
+  },
+  "instance.shared-instance.publish-review.storage-usage": {
+    "message": "{used} of {limit}"
+  },
   "instance.shared-instance.tooltip": {
     "message": "This instance's content is being managed by someone else."
   },
diff --git a/apps/app-frontend/src/locales/es-419/index.json b/apps/app-frontend/src/locales/es-419/index.json
index e9ca0902173..ddf3b4c7ade 100644
--- a/apps/app-frontend/src/locales/es-419/index.json
+++ b/apps/app-frontend/src/locales/es-419/index.json
@@ -4301,15 +4301,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Se añadió"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Enviar actualización a los jugadores"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Seleccionar archivos de configuración"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "Revisa los cambios de contenido y escoge cualquier archivo de configuración que quieras incluir en esta actualización."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "Revisar cambios"
   },
diff --git a/apps/app-frontend/src/locales/es-ES/index.json b/apps/app-frontend/src/locales/es-ES/index.json
index dc862a5d1af..d10a0f7b596 100644
--- a/apps/app-frontend/src/locales/es-ES/index.json
+++ b/apps/app-frontend/src/locales/es-ES/index.json
@@ -4271,15 +4271,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Añadido"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Lanzar actualización a jugadores"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Seleccionar archivos de configuración"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "Revisa los cambios de contenido y elige cualquier archivo de configuración para incluir en esta actualización."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "Revisar cambios"
   },
diff --git a/apps/app-frontend/src/locales/fr-FR/index.json b/apps/app-frontend/src/locales/fr-FR/index.json
index b903764760b..c6ab4d2f03e 100644
--- a/apps/app-frontend/src/locales/fr-FR/index.json
+++ b/apps/app-frontend/src/locales/fr-FR/index.json
@@ -4238,15 +4238,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Ajouté"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Déployer la mise à jour aux joueurs"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Sélectionner les fichiers de configuration"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "Examiner les changements de contenu et choisir n'importe quel fichier de configuration à inclure dans cette mise à jour."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "Examiner les changements"
   },
diff --git a/apps/app-frontend/src/locales/hu-HU/index.json b/apps/app-frontend/src/locales/hu-HU/index.json
index ec464c1f7ed..11a7754974a 100644
--- a/apps/app-frontend/src/locales/hu-HU/index.json
+++ b/apps/app-frontend/src/locales/hu-HU/index.json
@@ -4280,15 +4280,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Hozzáadva:"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Frissítés közzététele a játékosoknak"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Konfigurációs fájlok kiválasztása"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "Ellenőrizd a tartalmi módosításokat, és válaszd ki azokat a konfigurációs fájlokat, amelyeket be szeretnél vonni ebbe a frissítésbe."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "Változtatások áttekintése"
   },
diff --git a/apps/app-frontend/src/locales/it-IT/index.json b/apps/app-frontend/src/locales/it-IT/index.json
index d46609e21e8..63dba95ea8b 100644
--- a/apps/app-frontend/src/locales/it-IT/index.json
+++ b/apps/app-frontend/src/locales/it-IT/index.json
@@ -4301,15 +4301,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Aggiunto"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Invia l'aggiornamento ai giocatori"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Seleziona i file di configurazione"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "Rivedi i contenuti modificati e scegli i file di configurazione da includere nell'aggiornamento."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "Revisione modifiche"
   },
diff --git a/apps/app-frontend/src/locales/ja-JP/index.json b/apps/app-frontend/src/locales/ja-JP/index.json
index 7b83c823030..a231d8ee0ab 100644
--- a/apps/app-frontend/src/locales/ja-JP/index.json
+++ b/apps/app-frontend/src/locales/ja-JP/index.json
@@ -3395,15 +3395,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "追加しました"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "アップデートを配信する"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "設定ファイルを選択"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "変更内容を確認し、この更新に含める設定ファイルを選択してください。"
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "変更内容を確認"
   },
diff --git a/apps/app-frontend/src/locales/ko-KR/index.json b/apps/app-frontend/src/locales/ko-KR/index.json
index 9f6220e24f1..f70fae4f6fc 100644
--- a/apps/app-frontend/src/locales/ko-KR/index.json
+++ b/apps/app-frontend/src/locales/ko-KR/index.json
@@ -4280,15 +4280,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "추가됨"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "플레이어에게 업데이트 업로드"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "설정 파일 선택"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "콘텐츠 변경 사항을 검토하고 이번 업데이트에 포함할 설정 파일을 선택하세요."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "변경 사항 검토"
   },
diff --git a/apps/app-frontend/src/locales/nl-NL/index.json b/apps/app-frontend/src/locales/nl-NL/index.json
index f4dfc335a25..639638e379e 100644
--- a/apps/app-frontend/src/locales/nl-NL/index.json
+++ b/apps/app-frontend/src/locales/nl-NL/index.json
@@ -3887,15 +3887,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Toegevoegd"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Update naar spelers verzenden"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Configuratiebestanden selecteren"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "Bekijk de inhoudelijke wijzigingen en selecteer de configuratiebestanden die je in deze update wilt opnemen."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "Wijzigingen bekijken"
   },
diff --git a/apps/app-frontend/src/locales/pl-PL/index.json b/apps/app-frontend/src/locales/pl-PL/index.json
index c5bff2eff29..420972bfd07 100644
--- a/apps/app-frontend/src/locales/pl-PL/index.json
+++ b/apps/app-frontend/src/locales/pl-PL/index.json
@@ -4289,15 +4289,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Dodano"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Opublikuj aktualizację graczom"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Wybierz pliki konfiguracji"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "Sprawdź zmiany zawartości i wybierz pliki konfiguracji, które mają być zawarte w tej aktualizacji."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "Sprawdź zmiany"
   },
diff --git a/apps/app-frontend/src/locales/pt-BR/index.json b/apps/app-frontend/src/locales/pt-BR/index.json
index 5e9eaa224ba..ed15efa4260 100644
--- a/apps/app-frontend/src/locales/pt-BR/index.json
+++ b/apps/app-frontend/src/locales/pt-BR/index.json
@@ -4301,15 +4301,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Adicionado"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Enviar atualização aos jogadores"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Selecione os arquivos de configuração"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "Revise as alterações de conteúdo e selecione os arquivos de configuração que deseja incluir nesta atualização."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "Revisar alterações"
   },
diff --git a/apps/app-frontend/src/locales/ru-RU/index.json b/apps/app-frontend/src/locales/ru-RU/index.json
index 365189392b6..8cd00cf1d1b 100644
--- a/apps/app-frontend/src/locales/ru-RU/index.json
+++ b/apps/app-frontend/src/locales/ru-RU/index.json
@@ -4277,15 +4277,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Добавлен"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Отправка изменений игрокам"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Выберите файлы настройки"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "Ознакомьтесь с изменениями в содержимом и выберите файлы конфигурации, которые следует включить в это обновление."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "Обзор изменений"
   },
diff --git a/apps/app-frontend/src/locales/sv-SE/index.json b/apps/app-frontend/src/locales/sv-SE/index.json
index 14f33c5a572..452f1c60f59 100644
--- a/apps/app-frontend/src/locales/sv-SE/index.json
+++ b/apps/app-frontend/src/locales/sv-SE/index.json
@@ -3758,15 +3758,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Lade till"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Skicka uppdatering till spelare"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Välj konfigurationsfiler"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "Granska innehållsändringar och välj vilka konfigurationsfiler att inkludera i den här uppdateringen."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "Granska ändringar"
   },
diff --git a/apps/app-frontend/src/locales/tr-TR/index.json b/apps/app-frontend/src/locales/tr-TR/index.json
index c7192221d25..bdde7e2159f 100644
--- a/apps/app-frontend/src/locales/tr-TR/index.json
+++ b/apps/app-frontend/src/locales/tr-TR/index.json
@@ -3584,15 +3584,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Eklendi"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Oyunculara güncellemeyi gönder"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Yapılandırma dosyalarını seç"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "İçerik değişikliklerini gözden geçirin ve bu güncellemeye dahil edilecek yapılandırma dosyalarını seçin."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "Değişiklikleri incele"
   },
diff --git a/apps/app-frontend/src/locales/uk-UA/index.json b/apps/app-frontend/src/locales/uk-UA/index.json
index 296070c5dd3..77e994a4fba 100644
--- a/apps/app-frontend/src/locales/uk-UA/index.json
+++ b/apps/app-frontend/src/locales/uk-UA/index.json
@@ -4292,15 +4292,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Додано"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Публікація оновлення"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Оберіть файли конфігурації"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "Перегляньте зміни вмісту та оберіть файли конфігурації, які варто включити в цьому оновленні."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "Огляд змін"
   },
diff --git a/apps/app-frontend/src/locales/vi-VN/index.json b/apps/app-frontend/src/locales/vi-VN/index.json
index 5e382158db2..c83de69ab01 100644
--- a/apps/app-frontend/src/locales/vi-VN/index.json
+++ b/apps/app-frontend/src/locales/vi-VN/index.json
@@ -4301,15 +4301,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "Đã thêm"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "Gửi bản cập nhật tới người chơi"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "Chọn tệp cấu hình"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "Xem lại các thay đổi nội dung và chọn các tệp cấu hình cần đưa vào bản cập nhật này."
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "Xem lại thay đổi"
   },
diff --git a/apps/app-frontend/src/locales/zh-CN/index.json b/apps/app-frontend/src/locales/zh-CN/index.json
index 523bdaae502..186e184314c 100644
--- a/apps/app-frontend/src/locales/zh-CN/index.json
+++ b/apps/app-frontend/src/locales/zh-CN/index.json
@@ -4301,15 +4301,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "新增"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "向玩家推送更新"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "预览内容变更，并选择要在本次更新中包含的配置文件"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "审核哪些内容做了更改，并选择你想要包含在这次更新的的配置文件。"
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "审核更改内容"
   },
diff --git a/apps/app-frontend/src/locales/zh-TW/index.json b/apps/app-frontend/src/locales/zh-TW/index.json
index 33f30eee9a7..59a55c1f9f8 100644
--- a/apps/app-frontend/src/locales/zh-TW/index.json
+++ b/apps/app-frontend/src/locales/zh-TW/index.json
@@ -4301,15 +4301,6 @@
   "instance.shared-instance.publish-review.added-label": {
     "message": "已新增"
   },
-  "instance.shared-instance.publish-review.admonition-header": {
-    "message": "向玩家推送更新"
-  },
-  "instance.shared-instance.publish-review.config-title-v2": {
-    "message": "選擇設定檔"
-  },
-  "instance.shared-instance.publish-review.description": {
-    "message": "檢視內容變更，並選擇要包含在本次更新的設定檔。"
-  },
   "instance.shared-instance.publish-review.header": {
     "message": "檢視變更"
   },
diff --git a/apps/app-frontend/src/pages/instance/components/admonitions/shared-instance-stale.vue b/apps/app-frontend/src/pages/instance/components/admonitions/shared-instance-stale.vue
index 63d053a91e9..a47b21b5d8b 100644
--- a/apps/app-frontend/src/pages/instance/components/admonitions/shared-instance-stale.vue
+++ b/apps/app-frontend/src/pages/instance/components/admonitions/shared-instance-stale.vue
@@ -3,6 +3,8 @@
 		type="info"
 		inline-actions
 		:header="formatMessage(messages.sharedInstanceChangesHeader)"
+		:progress="isPublishing ? publishProgress : undefined"
+		:waiting="isPublishing && !publishTask?.totalBytes"
 	>
 		{{ formatMessage(messages.sharedInstanceChangesBody) }}
 		<template #actions>
@@ -43,12 +45,13 @@ import { SpinnerIcon, UploadIcon } from '@modrinth/assets'
 import { Admonition, Button, useVIntl } from '@modrinth/ui'
 import { computed, ref } from 'vue'
 
+import { findRunningSharedInstancePublish } from '@/components/ui/download-manager/shared-instance-publishes'
 import SharedInstancePublishModal from '@/components/ui/shared-instances/SharedInstancePublishModal.vue'
 import type { GameInstance } from '@/helpers/types'
 
 import { instanceAdmonitionsMessages as messages } from './messages'
 
-defineProps<{
+const props = defineProps<{
 	instance: GameInstance
 }>()
 
@@ -59,7 +62,13 @@ const emit = defineEmits<{
 const { formatMessage } = useVIntl()
 const publishModal = ref<InstanceType<typeof SharedInstancePublishModal>>()
 const publishState = ref<'idle' | 'reviewing' | 'publishing'>('idle')
-const isPublishing = computed(() => publishState.value === 'publishing')
+const publishTask = computed(() => findRunningSharedInstancePublish(props.instance.id))
+const isPublishing = computed(() => publishState.value === 'publishing' || !!publishTask.value)
+const publishProgress = computed(() =>
+	publishTask.value?.totalBytes
+		? publishTask.value.uploadedBytes / publishTask.value.totalBytes
+		: 0,
+)
 const isReviewingPublish = computed(() => publishState.value === 'reviewing')
 
 const isPublishButtonDisabled = computed(() => isPublishing.value || isReviewingPublish.value)
diff --git a/apps/app-frontend/src/pages/instance/share/index.vue b/apps/app-frontend/src/pages/instance/share/index.vue
index d88eed0d3ce..ec1399140de 100644
--- a/apps/app-frontend/src/pages/instance/share/index.vue
+++ b/apps/app-frontend/src/pages/instance/share/index.vue
@@ -57,17 +57,6 @@
 
 		<SharedInstanceMembersTable v-else-if="showMembersTable" />
 
-		<SharedInstanceShareEmptyState
-			v-else-if="sharedInstanceUnavailable"
-			:heading="formatMessage(sharedInstanceErrorMessages.unavailableTitle)"
-			:description="
-				formatSharedInstanceUnavailable(
-					sharedInstanceUnavailableReason,
-					sharedInstanceUnavailableManager,
-				)
-			"
-		/>
-
 		<SharedInstanceShareEmptyState
 			v-else-if="sharedInstanceActionsLocked"
 			:heading="formatMessage(lockedEmptyHeading)"
@@ -153,10 +142,7 @@ import {
 } from '@/helpers/install'
 import { edit } from '@/helpers/instance'
 import type { ModrinthAuthFlow } from '@/helpers/mr_auth.ts'
-import {
-	sharedInstanceErrorMessages,
-	useSharedInstanceErrors,
-} from '@/helpers/shared-instance-errors'
+import { useSharedInstanceErrors } from '@/helpers/shared-instance-errors'
 
 import { injectInstancePage } from '../instance-context'
 import { injectSharedInstance } from '../shared-instance-context'
@@ -173,15 +159,11 @@ const instancePage = injectInstancePage()
 const auth = injectAuth()
 const queryClient = useQueryClient()
 const { formatMessage } = useVIntl()
-const {
-	formatSharedInstanceUnavailable,
-	notifySharedInstanceError,
-	notifySharedInstanceUnavailable,
-} = useSharedInstanceErrors()
+const { notifySharedInstanceError, notifySharedInstanceUnavailable } = useSharedInstanceErrors()
 const sharedInstanceState = injectSharedInstance()
 const instance = computed(() => instancePage.instance.value!)
 const offline = instancePage.offline
-const actionsLocked = sharedInstanceState.shareActionsLocked
+const actionsLocked = sharedInstanceState.actionsLocked
 const sharedInstanceActionsLocked = actionsLocked
 const currentUserId = computed(() => auth.user.value?.id ?? null)
 const isSignedIn = computed(() => !!auth.session_token.value)
@@ -248,9 +230,7 @@ const lockedEmptyHeading = computed(() =>
 const lockedActionButton = computed(() =>
 	isSignedIn.value ? messages.switchAccountButton : messages.signInButton,
 )
-const sharedInstanceUnavailableReason = sharedInstanceState.unavailableReason
-const sharedInstanceUnavailable = computed(() => !!sharedInstanceUnavailableReason.value)
-const sharedInstanceUnavailableManager = sharedInstanceState.unavailableManager
+const sharedInstanceUnavailable = computed(() => !!sharedInstanceState.unavailableReason.value)
 const unableToConnect = computed(
 	() =>
 		sharedInstancesApiUnavailable.value ||
diff --git a/apps/app-frontend/src/pages/instance/shared-instance-context.ts b/apps/app-frontend/src/pages/instance/shared-instance-context.ts
index 57c424d5caa..163810122d2 100644
--- a/apps/app-frontend/src/pages/instance/shared-instance-context.ts
+++ b/apps/app-frontend/src/pages/instance/shared-instance-context.ts
@@ -125,7 +125,6 @@ export function createSharedInstanceContext(
 	})
 
 	const unavailableReason = computed(() => forcedUnavailableReason.value)
-	const shareActionsLocked = computed(() => actionsLocked.value || unavailableReason.value !== null)
 	const updatePreview = computed(() =>
 		unavailableReason.value ? null : (updatePreviewQuery.data.value ?? null),
 	)
@@ -159,7 +158,6 @@ export function createSharedInstanceContext(
 
 	return {
 		actionsLocked,
-		shareActionsLocked,
 		unavailableReason,
 		unavailableManager,
 		manager,
diff --git a/apps/app/build.rs b/apps/app/build.rs
index 77e64bdd4e7..7ae9fd15281 100644
--- a/apps/app/build.rs
+++ b/apps/app/build.rs
@@ -300,6 +300,7 @@ fn main() {
                         "instance_share_remove_users",
                         "instance_share_get_publish_preview",
                         "instance_share_publish",
+                        "instance_share_publish_support_details",
                         "instance_share_unlink",
                         "instance_share_unpublish",
                         "instance_export_mrpack",
diff --git a/apps/app/src/api/instance.rs b/apps/app/src/api/instance.rs
index add73cee103..c7b641942d9 100644
--- a/apps/app/src/api/instance.rs
+++ b/apps/app/src/api/instance.rs
@@ -119,6 +119,7 @@ pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
             instance_share_remove_users,
             instance_share_get_publish_preview,
             instance_share_publish,
+            instance_share_publish_support_details,
             instance_share_unlink,
             instance_share_unpublish,
             instance_export_mrpack,
@@ -1479,12 +1480,29 @@ pub async fn instance_share_get_publish_preview(
 #[tauri::command]
 pub async fn instance_share_publish(
     instance_id: &str,
-    config_paths: Vec<String>,
+    file_paths: Vec<String>,
+    on_progress: tauri::ipc::Channel<(u64, u64)>,
 ) -> Result<SharedInstanceAttachment> {
+    Ok(theseus::instance::publish_shared_instance(
+        instance_id,
+        file_paths,
+        &|uploaded, total| {
+            let _ = on_progress.send((uploaded, total));
+        },
+    )
+    .await?
+    .into())
+}
+
+#[tauri::command]
+pub async fn instance_share_publish_support_details(
+    instance_id: &str,
+) -> Result<Option<String>> {
     Ok(
-        theseus::instance::publish_shared_instance(instance_id, config_paths)
-            .await?
-            .into(),
+        theseus::instance::get_shared_instance_publish_support_details(
+            instance_id,
+        )
+        .await?,
     )
 }
 
diff --git a/packages/app-lib/Cargo.toml b/packages/app-lib/Cargo.toml
index fcf1edca17b..8d75047259d 100644
--- a/packages/app-lib/Cargo.toml
+++ b/packages/app-lib/Cargo.toml
@@ -11,6 +11,7 @@ required-features = ["export-ts"]
 [dependencies]
 anyhow = { workspace = true }
 ariadne = { workspace = true }
+async-compression = { workspace = true, features = ["tokio", "zstd"] }
 async-minecraft-ping = { workspace = true, features = ["srv"] }
 async-recursion = { workspace = true }
 async-trait = { workspace = true }
@@ -50,6 +51,7 @@ hickory-resolver = { workspace = true }
 httpdate = { workspace = true }
 image = { workspace = true, features = ["gif", "jpeg", "png", "webp"] }
 indicatif = { workspace = true, optional = true }
+infer = { workspace = true }
 itertools = { workspace = true }
 json5 = { workspace = true }
 modrinth-content-management = { workspace = true }
diff --git a/packages/app-lib/src/api/instance.rs b/packages/app-lib/src/api/instance.rs
index 9f7b21562b6..c6378fb7519 100644
--- a/packages/app-lib/src/api/instance.rs
+++ b/packages/app-lib/src/api/instance.rs
@@ -3,6 +3,7 @@
 mod content;
 mod export_mrpack;
 mod files;
+pub(crate) use files::InstanceFileWriter;
 pub use files::{
     InstanceFileItem, create_instance_directory, delete_instance_file,
     list_instance_files, read_instance_file, rename_instance_file,
@@ -75,26 +76,29 @@ pub use self::screenshots::{
 };
 pub(crate) use self::shared::{
     CONFIG_BUNDLE_FILE_TYPE, CONFIG_DIRECTORY, CONFIG_FILE_EXTENSIONS,
-    CONFIG_SYNC_ENABLED, MAX_CONFIG_BUNDLE_ENTRIES,
-    read_bounded_config_bundle_entry,
+    CONFIG_FILE_TYPE, CONFIG_SYNC_ENABLED, MAX_CONFIG_BUNDLE_ENTRIES,
+    MAX_SHARED_FILES_TOTAL_SIZE, is_shareable_file_path,
+    is_supported_config_file, read_bounded_config_bundle_entry,
 };
 pub use self::shared::{
     SharedInstanceExternalFilePreview, SharedInstanceInstallPreview,
     SharedInstanceInvite, SharedInstanceInviteInstallPreview,
     SharedInstanceInviteLink, SharedInstanceJoinType,
-    SharedInstancePublishPreview, SharedInstanceUpdateDiff,
-    SharedInstanceUpdateDiffType, SharedInstanceUpdatePreview,
-    SharedInstanceUser, SharedInstanceUsers,
+    SharedInstancePublishFile, SharedInstancePublishPreview,
+    SharedInstanceUpdateDiff, SharedInstanceUpdateDiffType,
+    SharedInstanceUpdatePreview, SharedInstanceUser, SharedInstanceUsers,
     accept_pending_shared_instance_invite,
     accept_shared_instance_invite_for_install,
     can_active_user_use_shared_instances, create_shared_instance_invite_link,
     decline_pending_shared_instance_invite,
     get_shared_instance_install_preview, get_shared_instance_invites,
-    get_shared_instance_publish_preview, get_shared_instance_update_preview,
-    get_shared_instance_users, install_shared_instance,
-    invite_shared_instance_users, publish_shared_instance,
-    remove_shared_instance_users, revoke_shared_instance_invite,
-    unlink_shared_instance, unpublish_shared_instance, update_shared_instance,
+    get_shared_instance_publish_preview,
+    get_shared_instance_publish_support_details,
+    get_shared_instance_update_preview, get_shared_instance_users,
+    install_shared_instance, invite_shared_instance_users,
+    publish_shared_instance, 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,
diff --git a/packages/app-lib/src/api/instance/export_mrpack.rs b/packages/app-lib/src/api/instance/export_mrpack.rs
index dcded30fc4b..6f9c11458a0 100644
--- a/packages/app-lib/src/api/instance/export_mrpack.rs
+++ b/packages/app-lib/src/api/instance/export_mrpack.rs
@@ -355,8 +355,12 @@ where
 }
 
 fn is_path_exportable(relative_path: &SafeRelativeUtf8UnixPathBuf) -> bool {
-    let path = relative_path.as_str();
+    is_exportable_path(relative_path.as_str())
+}
 
+/// Whether an instance-relative path may leave the instance, such as in an
+/// exported pack or a shared instance version.
+pub(crate) fn is_exportable_path(path: &str) -> bool {
     !NEVER_EXPORTABLE_PATH_PREFIXES.iter().any(|prefix| {
         path == *prefix
             || path
diff --git a/packages/app-lib/src/api/instance/files.rs b/packages/app-lib/src/api/instance/files.rs
index 4a186974da6..362b02c3332 100644
--- a/packages/app-lib/src/api/instance/files.rs
+++ b/packages/app-lib/src/api/instance/files.rs
@@ -6,6 +6,7 @@ use crate::state::instances::adapters::sqlite::{content_rows, instance_rows};
 use crate::{ErrorKind, State};
 use anyhow::bail;
 use serde::Serialize;
+use std::collections::HashSet;
 use std::path::{Path, PathBuf};
 use std::time::UNIX_EPOCH;
 use tokio::fs;
@@ -59,6 +60,74 @@ async fn resolve(
     }
     validate_relative(path)?;
     if writing {
+        ManagedPaths::load(state, instance_id)
+            .await?
+            .ensure_writable(path)?;
+    }
+    Ok(ReadableContent::Local(
+        local_destination(state, &instance.path, path).await?,
+    ))
+}
+
+async fn local_destination(
+    state: &State,
+    instance_path: &str,
+    path: &str,
+) -> crate::Result<PathBuf> {
+    let destination = state
+        .content_store
+        .instance_path(instance_path, path)
+        .await?;
+    if let Ok(metadata) = fs::symlink_metadata(&destination).await
+        && metadata.file_type().is_symlink()
+    {
+        bail!(ErrorKind::InputError(
+            "Files cannot access a symbolic link or its target".to_string()
+        ));
+    }
+    Ok(destination)
+}
+
+/// Lowercased paths of an instance's managed content, and every directory
+/// containing it, which the Files tab must not write.
+struct ManagedPaths {
+    files: HashSet<String>,
+    directories: HashSet<String>,
+}
+
+impl ManagedPaths {
+    async fn load(state: &State, instance_id: &str) -> crate::Result<Self> {
+        let bindings =
+            content_store::instance_storage(&state.pool, instance_id).await?;
+        let bound = bindings
+            .iter()
+            .map(|binding| binding.file_id.as_str())
+            .collect::<HashSet<_>>();
+        let mut managed = Self {
+            files: HashSet::new(),
+            directories: HashSet::new(),
+        };
+        for file in
+            content_rows::get_instance_files(instance_id, &state.pool).await?
+        {
+            if !bound.contains(file.id.as_str()) {
+                continue;
+            }
+            let relative_path = file.relative_path.to_lowercase();
+            for (index, _) in relative_path.match_indices('/') {
+                managed
+                    .directories
+                    .insert(relative_path[..index].to_string());
+            }
+            managed
+                .files
+                .insert(content_file_path(&file).to_lowercase());
+            managed.files.insert(relative_path);
+        }
+        Ok(managed)
+    }
+
+    fn ensure_writable(&self, path: &str) -> crate::Result<()> {
         if path
             .split('/')
             .next()
@@ -69,35 +138,104 @@ async fn resolve(
                     .to_string(),
             ));
         }
-        let prefix = format!("{}/", path.to_lowercase());
-        let bindings =
-            content_store::instance_storage(&state.pool, instance_id).await?;
-        let files =
-            content_rows::get_instance_files(instance_id, &state.pool).await?;
-        if files.iter().any(|file| {
-            bindings.iter().any(|binding| binding.file_id == file.id)
-                && (file.relative_path.eq_ignore_ascii_case(path)
-                    || content_file_path(file).eq_ignore_ascii_case(path)
-                    || file.relative_path.to_lowercase().starts_with(&prefix))
-        }) {
+        let path = path.to_lowercase();
+        if self.files.contains(&path) || self.directories.contains(&path) {
             bail!(ErrorKind::InputError(
                 "managed content is read-only in Files; use the Content tab"
                     .to_string(),
             ));
         }
+        Ok(())
     }
-    let destination = state
-        .content_store
-        .instance_path(&instance.path, path)
+}
+
+/// Writes many files into one instance, checking each against managed content
+/// loaded once rather than per file.
+pub(crate) struct InstanceFileWriter {
+    instance_id: String,
+    instance_path: String,
+    managed: ManagedPaths,
+}
+
+impl InstanceFileWriter {
+    pub(crate) async fn new(
+        state: &State,
+        instance_id: &str,
+    ) -> crate::Result<Self> {
+        let instance =
+            instance_rows::get_instance_by_id(instance_id, &state.pool)
+                .await?
+                .ok_or(ErrorKind::InputError("unknown instance".to_string()))?;
+        Ok(Self {
+            instance_id: instance_id.to_string(),
+            instance_path: instance.path,
+            managed: ManagedPaths::load(state, instance_id).await?,
+        })
+    }
+
+    pub(crate) async fn destination(
+        &self,
+        state: &State,
+        path: &str,
+    ) -> crate::Result<PathBuf> {
+        let path = normalized(path);
+        if path.is_empty() {
+            bail!(ErrorKind::InputError(
+                "the instance directory cannot be changed in the Files tab"
+                    .to_string(),
+            ));
+        }
+        validate_relative(path)?;
+        self.managed.ensure_writable(path)?;
+        local_destination(state, &self.instance_path, path).await
+    }
+
+    /// Streams `reader` into an instance file, replacing any file already
+    /// there. The contents are only kept when exactly `expected_size` bytes
+    /// are read, and the instance is only locked to move the finished file
+    /// into place.
+    pub(crate) async fn write_from_reader(
+        &self,
+        state: &State,
+        path: &str,
+        reader: impl tokio::io::AsyncRead + Unpin,
+        expected_size: u64,
+    ) -> crate::Result<()> {
+        use tokio::io::AsyncReadExt;
+
+        let destination = self.destination(state, path).await?;
+        let parent = destination.parent().ok_or(ErrorKind::InputError(
+            "invalid file destination".to_string(),
+        ))?;
+        fs::create_dir_all(parent).await?;
+        let parent = parent.to_path_buf();
+        let temporary = tokio::task::spawn_blocking(move || {
+            tempfile::NamedTempFile::new_in(parent)
+                .map(|file| file.into_temp_path())
+        })
+        .await??;
+        let mut file = fs::File::options().write(true).open(&temporary).await?;
+        let written = tokio::io::copy(
+            &mut reader.take(expected_size.saturating_add(1)),
+            &mut file,
+        )
         .await?;
-    if let Ok(metadata) = fs::symlink_metadata(&destination).await
-        && metadata.file_type().is_symlink()
-    {
-        bail!(ErrorKind::InputError(
-            "Files cannot access a symbolic link or its target".to_string()
-        ));
+        if written != expected_size {
+            bail!("{path} has an unexpected size");
+        }
+        file.sync_all().await?;
+        drop(file);
+
+        let _instance =
+            state.instance_locks.lock_content(&self.instance_id).await;
+        let _files = state.content_store.files_lock.lock().await;
+        self.destination(state, path).await?;
+        tokio::task::spawn_blocking(move || {
+            temporary.persist(destination).map_err(|error| error.error)
+        })
+        .await??;
+        Ok(())
     }
-    Ok(ReadableContent::Local(destination))
 }
 
 pub async fn list_instance_files(
@@ -179,7 +317,15 @@ pub async fn validate_instance_file_write(
     path: &str,
 ) -> crate::Result<PathBuf> {
     let state = State::get().await?;
-    Ok(resolve(&state, instance_id, path, true)
+    instance_file_write_path(&state, instance_id, path).await
+}
+
+async fn instance_file_write_path(
+    state: &State,
+    instance_id: &str,
+    path: &str,
+) -> crate::Result<PathBuf> {
+    Ok(resolve(state, instance_id, path, true)
         .await?
         .path()
         .to_path_buf())
diff --git a/packages/app-lib/src/api/instance/shared/client.rs b/packages/app-lib/src/api/instance/shared/client.rs
index 710e13d35f1..e851f94fc9a 100644
--- a/packages/app-lib/src/api/instance/shared/client.rs
+++ b/packages/app-lib/src/api/instance/shared/client.rs
@@ -50,12 +50,7 @@ pub(super) struct ExternalFileCandidate {
 #[derive(Clone, Debug)]
 pub(super) enum ExternalFileSource {
     InstanceFile(String),
-    ConfigBundle(std::sync::Arc<tempfile::TempPath>),
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub(super) struct ConfigFile {
-    pub(super) path: String,
+    SharedFile(std::path::PathBuf),
 }
 
 #[derive(Clone, Debug, Serialize)]
@@ -127,6 +122,8 @@ pub(super) struct ExternalFileResponse {
     pub(super) url: String,
     #[serde(default)]
     pub(super) file_size: Option<i64>,
+    #[serde(default)]
+    pub(super) sha1: Option<String>,
 }
 
 #[derive(Clone, Debug, Deserialize)]
@@ -394,6 +391,32 @@ pub(super) async fn get_latest_remote_version_optional_unavailable_with_auth(
     .await
 }
 
+/// Returns `None` for versions that never became ready.
+pub(super) async fn get_remote_version(
+    shared_instance_id: &str,
+    version: i32,
+    state: &State,
+) -> crate::Result<Option<InstanceVersionResponse>> {
+    match request_json_optional_unavailable(
+        "get_instance_version",
+        Method::GET,
+        &format!("/instances/{shared_instance_id}/versions/{version}"),
+        None,
+        state,
+        SharedInstancesRequestAuth::ModrinthSession,
+    )
+    .await?
+    {
+        SharedInstanceRemoteResponse::Available(version) => Ok(Some(version)),
+        SharedInstanceRemoteResponse::Unavailable(
+            SharedInstanceUnavailableReason::Deleted,
+        ) => Ok(None),
+        SharedInstanceRemoteResponse::Unavailable(reason) => {
+            Err(shared_instance_unavailable_error(reason))
+        }
+    }
+}
+
 pub(super) async fn add_remote_users(
     shared_instance_id: &str,
     user_ids: Vec<String>,
@@ -836,12 +859,26 @@ pub(super) async fn send_bytes_request_to_url(
         url,
         body.into(),
         Some(size),
-        file_sha512,
+        file_sha512_headers(file_sha512)?,
         state,
     )
     .await
 }
 
+pub(super) fn file_sha512_headers(
+    file_sha512: Option<&str>,
+) -> crate::Result<reqwest::header::HeaderMap> {
+    let mut headers = reqwest::header::HeaderMap::new();
+    if let Some(file_sha512) = file_sha512 {
+        headers.insert(
+            "x-file-sha512",
+            reqwest::header::HeaderValue::from_str(file_sha512)
+                .context("invalid file SHA-512")?,
+        );
+    }
+    Ok(headers)
+}
+
 pub(super) async fn send_body_request_to_url(
     operation: &'static str,
     method: Method,
@@ -849,7 +886,7 @@ pub(super) async fn send_body_request_to_url(
     url: &str,
     body: reqwest::Body,
     content_length: Option<u64>,
-    file_sha512: Option<&str>,
+    headers: reqwest::header::HeaderMap,
     state: &State,
 ) -> crate::Result<reqwest::Response> {
     let service_origin = url::Url::parse(service_base_url())
@@ -883,14 +920,12 @@ pub(super) async fn send_body_request_to_url(
         .request(method.clone(), url)
         .bearer_auth(credentials.session)
         .header(reqwest::header::CONTENT_TYPE, "application/octet-stream")
+        .headers(headers)
         .body(body);
     if let Some(content_length) = content_length {
         request =
             request.header(reqwest::header::CONTENT_LENGTH, content_length);
     }
-    if let Some(file_sha512) = file_sha512 {
-        request = request.header("x-file-sha512", file_sha512);
-    }
 
     let response = request
         .send()
diff --git a/packages/app-lib/src/api/instance/shared/content.rs b/packages/app-lib/src/api/instance/shared/content.rs
new file mode 100644
index 00000000000..1907cc3246b
--- /dev/null
+++ b/packages/app-lib/src/api/instance/shared/content.rs
@@ -0,0 +1,195 @@
+use super::client::{
+    ExternalFileResponse, InstanceVersionResponse, get_remote_version,
+};
+use super::*;
+use std::collections::BTreeMap;
+
+const CONFIG_VERSION_FETCH_CONCURRENCY: usize = 4;
+
+/// Config files are published as deltas, so a member needs every config
+/// uploaded after `applied_version`, keeping the newest upload of each path.
+pub(super) async fn remote_shared_config_files(
+    shared_instance_id: &str,
+    applied_version: Option<i32>,
+    latest: &InstanceVersionResponse,
+    state: &State,
+) -> crate::Result<Vec<ExternalFileResponse>> {
+    use futures::{StreamExt, TryStreamExt};
+
+    let first = applied_version.map_or(1, |version| version.saturating_add(1));
+    let intermediate = futures::stream::iter(first..latest.version)
+        .map(|version| get_remote_version(shared_instance_id, version, state))
+        .buffered(CONFIG_VERSION_FETCH_CONCURRENCY)
+        .try_collect::<Vec<_>>()
+        .await?;
+
+    newest_config_files(
+        intermediate
+            .iter()
+            .flatten()
+            .chain((first <= latest.version).then_some(latest))
+            .map(|version| version.external_files.as_slice()),
+    )
+}
+
+/// Takes each version's external files in ascending version order. A legacy
+/// config bundle is a full snapshot, so it replaces every older config. The
+/// bundle comes first so newer individual files are written over it.
+///
+/// Limits apply per version, matching what a single publish may upload.
+fn newest_config_files<'a>(
+    versions: impl IntoIterator<Item = &'a [ExternalFileResponse]>,
+) -> crate::Result<Vec<ExternalFileResponse>> {
+    let mut bundle = None;
+    let mut files = BTreeMap::new();
+    for external_files in versions {
+        ensure_config_limits(external_files)?;
+        if let Some(newer) = external_files
+            .iter()
+            .find(|file| file.file_type == CONFIG_BUNDLE_FILE_TYPE)
+        {
+            bundle = Some(newer.clone());
+            files.clear();
+        }
+        for file in external_files
+            .iter()
+            .filter(|file| file.file_type == CONFIG_FILE_TYPE)
+        {
+            files.insert(file.file_name.clone(), file.clone());
+        }
+    }
+
+    Ok(bundle.into_iter().chain(files.into_values()).collect())
+}
+
+fn ensure_config_limits(
+    external_files: &[ExternalFileResponse],
+) -> crate::Result<()> {
+    let mut count = 0;
+    let mut size = 0_u64;
+    for file in external_files
+        .iter()
+        .filter(|file| file.file_type == CONFIG_FILE_TYPE)
+    {
+        count += 1;
+        size = size.saturating_add(
+            file.file_size
+                .and_then(|size| u64::try_from(size).ok())
+                .unwrap_or(u64::MAX),
+        );
+    }
+    if count > MAX_SHARED_FILES || size > MAX_SHARED_FILES_TOTAL_SIZE {
+        bail!(crate::ErrorKind::InputError(
+            "shared instance files exceed the size or file count limit"
+                .to_string(),
+        ));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn file(
+        file_type: &str,
+        file_name: &str,
+        url: &str,
+    ) -> ExternalFileResponse {
+        ExternalFileResponse {
+            file_name: file_name.to_string(),
+            file_type: file_type.to_string(),
+            url: url.to_string(),
+            file_size: Some(1),
+            sha1: None,
+        }
+    }
+
+    fn names(files: &[ExternalFileResponse]) -> Vec<(&str, &str, &str)> {
+        files
+            .iter()
+            .map(|file| {
+                (
+                    file.file_type.as_str(),
+                    file.file_name.as_str(),
+                    file.url.as_str(),
+                )
+            })
+            .collect()
+    }
+
+    #[test]
+    fn newest_upload_of_each_path_wins() {
+        let v1 = [
+            file(CONFIG_FILE_TYPE, "config/a.toml", "v1"),
+            file(CONFIG_FILE_TYPE, "config/b.toml", "v1"),
+        ];
+        let v2 = [file("mod", "extra.jar", "v2")];
+        let v3 = [file(CONFIG_FILE_TYPE, "config/a.toml", "v3")];
+
+        let files = newest_config_files([&v1[..], &v2[..], &v3[..]]).unwrap();
+
+        assert_eq!(
+            names(&files),
+            [
+                (CONFIG_FILE_TYPE, "config/a.toml", "v3"),
+                (CONFIG_FILE_TYPE, "config/b.toml", "v1"),
+            ]
+        );
+    }
+
+    #[test]
+    fn bundle_replaces_older_configs_and_is_written_first() {
+        let v1 = [file(CONFIG_FILE_TYPE, "config/old.toml", "v1")];
+        let v2 = [
+            file(CONFIG_FILE_TYPE, "config/same.toml", "v2"),
+            file(CONFIG_BUNDLE_FILE_TYPE, "configs.zip", "v2"),
+        ];
+        let v3 = [file(CONFIG_FILE_TYPE, "config/new.toml", "v3")];
+
+        let files = newest_config_files([&v1[..], &v2[..], &v3[..]]).unwrap();
+
+        assert_eq!(
+            names(&files),
+            [
+                (CONFIG_BUNDLE_FILE_TYPE, "configs.zip", "v2"),
+                (CONFIG_FILE_TYPE, "config/new.toml", "v3"),
+                (CONFIG_FILE_TYPE, "config/same.toml", "v2"),
+            ]
+        );
+    }
+
+    #[test]
+    fn limits_apply_per_version() {
+        let mut half = file(CONFIG_FILE_TYPE, "config/a.toml", "v1");
+        half.file_size = Some((MAX_SHARED_FILES_TOTAL_SIZE / 2 + 1) as i64);
+        let mut other_half = half.clone();
+        other_half.file_name = "config/b.toml".to_string();
+        let mut too_large = half.clone();
+        too_large.file_name = "config/c.toml".to_string();
+
+        assert!(
+            newest_config_files([
+                &[half.clone()][..],
+                &[other_half.clone()][..]
+            ])
+            .is_ok()
+        );
+        assert!(
+            newest_config_files([&[half, other_half, too_large][..]]).is_err()
+        );
+    }
+
+    #[test]
+    fn newest_bundle_wins() {
+        let v1 = [file(CONFIG_BUNDLE_FILE_TYPE, "configs.zip", "v1")];
+        let v2 = [file(CONFIG_BUNDLE_FILE_TYPE, "configs.zip", "v2")];
+
+        let files = newest_config_files([&v1[..], &v2[..]]).unwrap();
+
+        assert_eq!(
+            names(&files),
+            [(CONFIG_BUNDLE_FILE_TYPE, "configs.zip", "v2")]
+        );
+    }
+}
diff --git a/packages/app-lib/src/api/instance/shared/diff.rs b/packages/app-lib/src/api/instance/shared/diff.rs
index 84483bce32a..d01f0c07084 100644
--- a/packages/app-lib/src/api/instance/shared/diff.rs
+++ b/packages/app-lib/src/api/instance/shared/diff.rs
@@ -13,6 +13,7 @@ struct SharedContentSnapshot {
 pub(super) async fn shared_instance_update_diffs(
     metadata: &crate::state::InstanceMetadata,
     version: &InstanceVersionResponse,
+    config_files: &[ExternalFileResponse],
     state: &State,
 ) -> crate::Result<Vec<SharedInstanceUpdateDiff>> {
     let before_configuration = local_configuration(metadata);
@@ -33,7 +34,7 @@ pub(super) async fn shared_instance_update_diffs(
         configuration: after_configuration,
     };
 
-    shared_content_diffs(
+    let mut diffs = shared_content_diffs(
         &before,
         &after,
         &HashSet::new(),
@@ -42,7 +43,24 @@ pub(super) async fn shared_instance_update_diffs(
         CommonExternalFilePolicy::AssumeUpdated,
         state,
     )
-    .await
+    .await?;
+    let config_file_count = config_files
+        .iter()
+        .filter(|file| file.file_type == CONFIG_FILE_TYPE)
+        .count();
+    if config_file_count > 0 {
+        diffs.push(SharedInstanceUpdateDiff {
+            type_: SharedInstanceUpdateDiffType::ConfigFilesUpdated,
+            project_id: None,
+            project_name: None,
+            file_name: None,
+            current_version_name: None,
+            new_version_name: None,
+            config_file_count: Some(config_file_count),
+            disabled: false,
+        });
+    }
+    Ok(diffs)
 }
 
 pub(super) async fn shared_instance_publish_diffs(
@@ -484,7 +502,12 @@ fn remote_shared_content(
     let external_files = version
         .external_files
         .iter()
-        .filter(|file| file.file_type != CONFIG_BUNDLE_FILE_TYPE)
+        .filter(|file| {
+            !matches!(
+                file.file_type.as_str(),
+                CONFIG_BUNDLE_FILE_TYPE | CONFIG_FILE_TYPE
+            )
+        })
         .map(|file| shared_external_file_key(&file.file_type, &file.file_name))
         .collect::<crate::Result<_>>()?;
     Ok((version_ids, external_files))
diff --git a/packages/app-lib/src/api/instance/shared/install.rs b/packages/app-lib/src/api/instance/shared/install.rs
index 0e6b9123f02..2c45dcd4c14 100644
--- a/packages/app-lib/src/api/instance/shared/install.rs
+++ b/packages/app-lib/src/api/instance/shared/install.rs
@@ -1,4 +1,5 @@
 use super::client::*;
+use super::content::remote_shared_config_files;
 use super::diff::*;
 use super::publish::*;
 use super::types::*;
@@ -23,6 +24,7 @@ pub async fn install_shared_instance(
         instance_icon_url,
         name,
         version,
+        None,
         &state,
     )
     .await?;
@@ -142,7 +144,12 @@ pub(super) async fn shared_instance_install_preview_from_version(
     let external_files = version
         .external_files
         .iter()
-        .filter(|file| file.file_type != CONFIG_BUNDLE_FILE_TYPE)
+        .filter(|file| {
+            !matches!(
+                file.file_type.as_str(),
+                CONFIG_BUNDLE_FILE_TYPE | CONFIG_FILE_TYPE
+            )
+        })
         .map(|file| SharedInstanceExternalFilePreview {
             file_name: file.file_name.clone(),
             file_type: file.file_type.clone(),
@@ -212,7 +219,15 @@ pub async fn get_shared_instance_update_preview(
         .applied_version
         .is_none_or(|current| current < version.version);
     let diffs = if update_available {
-        shared_instance_update_diffs(&metadata, &version, &state).await?
+        let config_files = remote_shared_config_files(
+            &attachment.id,
+            attachment.applied_version,
+            &version,
+            &state,
+        )
+        .await?;
+        shared_instance_update_diffs(&metadata, &version, &config_files, &state)
+            .await?
     } else {
         Vec::new()
     };
@@ -296,6 +311,7 @@ pub async fn update_shared_instance(
         None,
         metadata.instance.name,
         version,
+        attachment.applied_version,
         &state,
     )
     .await?;
@@ -319,7 +335,8 @@ pub(super) async fn ensure_ready_remote_version_for_invite(
                 shared_instance_id = %attachment.id,
                 "Shared instance has no ready version before invite; publishing current content"
             );
-            publish_shared_instance_inner(instance_id, &[], state).await
+            publish_shared_instance_inner(instance_id, &[], &|_, _| {}, state)
+                .await
         }
         SharedInstanceRemoteResponse::Unavailable(reason) => {
             handle_unavailable_shared_instance_if_current_user(
@@ -493,6 +510,7 @@ fn shared_instance_external_file_data(
         file_type: file.file_type,
         url: file.url,
         file_size,
+        sha1: file.sha1,
     })
 }
 
@@ -504,6 +522,7 @@ pub(super) async fn shared_instance_install_data(
     instance_icon_url: Option<String>,
     name: String,
     version: InstanceVersionResponse,
+    applied_version: Option<i32>,
     state: &State,
 ) -> crate::Result<SharedInstanceInstallData> {
     if !version.ready {
@@ -511,6 +530,13 @@ pub(super) async fn shared_instance_install_data(
             "shared instance version is not ready to install".to_string(),
         ));
     }
+    let config_files = remote_shared_config_files(
+        shared_instance_id,
+        applied_version,
+        &version,
+        state,
+    )
+    .await?;
 
     let name = shared_instance_name(name);
     let linked_user_id = linked_modrinth_user_id(state).await?;
@@ -536,6 +562,13 @@ pub(super) async fn shared_instance_install_data(
         external_files: version
             .external_files
             .into_iter()
+            .filter(|file| {
+                !matches!(
+                    file.file_type.as_str(),
+                    CONFIG_BUNDLE_FILE_TYPE | CONFIG_FILE_TYPE
+                )
+            })
+            .chain(config_files)
             .map(shared_instance_external_file_data)
             .collect::<crate::Result<Vec<_>>>()?,
         modpack,
diff --git a/packages/app-lib/src/api/instance/shared/mod.rs b/packages/app-lib/src/api/instance/shared/mod.rs
index 60334f73f24..8e088825a0a 100644
--- a/packages/app-lib/src/api/instance/shared/mod.rs
+++ b/packages/app-lib/src/api/instance/shared/mod.rs
@@ -31,13 +31,17 @@ use std::collections::BTreeSet;
 use std::collections::{HashMap, HashSet};
 use std::io::Read;
 
-pub(crate) const CONFIG_BUNDLE_FILE_NAME: &str = "configs.zip";
 pub(crate) const CONFIG_BUNDLE_FILE_TYPE: &str = "configs";
+/// Wire type for an instance file the owner selected to share. The file name
+/// is its instance-relative path.
+pub(crate) const CONFIG_FILE_TYPE: &str = "config";
 pub(crate) const CONFIG_SYNC_ENABLED: bool = true;
 pub(crate) const CONFIG_DIRECTORY: &str = "config";
+pub(crate) const MAX_SHARED_FILES: usize = 4096;
+pub(crate) const MAX_SHARED_FILES_TOTAL_SIZE: u64 = 500 * 1024 * 1024;
 pub(crate) const MAX_CONFIG_BUNDLE_ENTRIES: usize = 4096;
-pub(crate) const MAX_CONFIG_BUNDLE_FILE_SIZE: u64 = 16 * 1024 * 1024;
-pub(crate) const MAX_CONFIG_BUNDLE_TOTAL_SIZE: u64 = 128 * 1024 * 1024;
+pub(crate) const MAX_CONFIG_BUNDLE_FILE_SIZE: u64 = 512 * 1024 * 1024;
+pub(crate) const MAX_CONFIG_BUNDLE_TOTAL_SIZE: u64 = 512 * 1024 * 1024;
 pub(crate) const CONFIG_FILE_EXTENSIONS: [&str; 14] = [
     "json",
     "json5",
@@ -55,6 +59,81 @@ pub(crate) const CONFIG_FILE_EXTENSIONS: [&str; 14] = [
     "nbt",
 ];
 
+/// Extensions of executables, scripts and installers. These are hidden from
+/// the publish file selection and never installed; the shared instances
+/// backend also rejects them by content.
+const EXECUTABLE_FILE_EXTENSIONS: &[&str] = &[
+    "exe", "dll", "msi", "msix", "com", "scr", "cpl", "sys", "bat", "cmd",
+    "ps1", "psm1", "vbs", "vbe", "jse", "wsf", "wsh", "hta", "lnk", "reg",
+    "sh", "bash", "zsh", "command", "app", "dylib", "so", "appimage", "apk",
+    "deb", "rpm", "dmg", "pkg", "class",
+];
+
+pub(crate) fn is_supported_config_file(path: &std::path::Path) -> bool {
+    path.extension()
+        .and_then(|extension| extension.to_str())
+        .is_some_and(|extension| {
+            CONFIG_FILE_EXTENSIONS
+                .iter()
+                .any(|candidate| extension.eq_ignore_ascii_case(candidate))
+        })
+}
+
+/// Whether members can install a shared file at this instance-relative path.
+/// Content folders are shared through the content set instead.
+pub(crate) fn is_shareable_file_path(path: &str) -> bool {
+    crate::state::content_store::validate_relative(path).is_ok()
+        && is_shareable_path(path)
+        && !is_executable_file(path)
+        && path
+            .split_once('/')
+            .is_none_or(|(root, _)| !is_content_folder(root))
+}
+
+fn is_executable_file(path: &str) -> bool {
+    std::path::Path::new(path)
+        .extension()
+        .and_then(|extension| extension.to_str())
+        .is_some_and(|extension| {
+            EXECUTABLE_FILE_EXTENSIONS
+                .iter()
+                .any(|candidate| extension.eq_ignore_ascii_case(candidate))
+        })
+}
+
+/// Leading bytes of each file passed to [`is_executable_content`].
+pub(super) const FILE_SCAN_HEAD_SIZE: usize = 8192;
+
+/// Mirrors the upload scan of the shared instances backend, so files it would
+/// reject fail before a version is created.
+pub(super) fn is_executable_content(head: &[u8]) -> bool {
+    infer::get(head).is_some_and(|kind| match kind.matcher_type() {
+        infer::MatcherType::App => {
+            !matches!(kind.extension(), "der" | "pem" | "obj" | "bc")
+        }
+        _ => matches!(
+            kind.extension(),
+            "sh" | "msi" | "cab" | "deb" | "rpm" | "crx"
+        ),
+    })
+}
+
+/// Whether a directory can hold shareable files, so the rest can be skipped
+/// while walking the instance.
+pub(super) fn is_shareable_directory(path: &str) -> bool {
+    is_shareable_path(path) && !is_content_folder(path)
+}
+
+fn is_shareable_path(path: &str) -> bool {
+    !path.split('/').any(|part| part.starts_with('.'))
+        && super::export_mrpack::is_exportable_path(path)
+}
+
+fn is_content_folder(path: &str) -> bool {
+    ProjectType::iterator()
+        .any(|project_type| project_type.get_folder() == path)
+}
+
 pub(crate) fn read_bounded_config_bundle_entry(
     reader: impl Read,
     declared_size: u64,
@@ -96,10 +175,12 @@ pub(crate) fn read_bounded_config_bundle_entry(
 }
 
 mod client;
+mod content;
 mod diff;
 mod install;
 mod invites;
 mod publish;
+mod report;
 mod types;
 
 pub(crate) use self::install::check_shared_instance_availability_before_launch;
@@ -120,13 +201,14 @@ pub use self::publish::{
     get_shared_instance_publish_preview, publish_shared_instance,
     unlink_shared_instance, unpublish_shared_instance,
 };
+pub use self::report::get_shared_instance_publish_support_details;
 pub use self::types::{
     SharedInstanceExternalFilePreview, SharedInstanceInstallPreview,
     SharedInstanceInvite, SharedInstanceInviteInstallPreview,
     SharedInstanceInviteLink, SharedInstanceJoinType,
-    SharedInstancePublishPreview, SharedInstanceUpdateDiff,
-    SharedInstanceUpdateDiffType, SharedInstanceUpdatePreview,
-    SharedInstanceUser, SharedInstanceUsers,
+    SharedInstancePublishFile, SharedInstancePublishPreview,
+    SharedInstanceUpdateDiff, SharedInstanceUpdateDiffType,
+    SharedInstanceUpdatePreview, SharedInstanceUser, SharedInstanceUsers,
 };
 
 pub async fn can_active_user_use_shared_instances() -> crate::Result<bool> {
diff --git a/packages/app-lib/src/api/instance/shared/publish.rs b/packages/app-lib/src/api/instance/shared/publish.rs
index c06690b16fe..fd48f6cffd6 100644
--- a/packages/app-lib/src/api/instance/shared/publish.rs
+++ b/packages/app-lib/src/api/instance/shared/publish.rs
@@ -1,14 +1,25 @@
 use super::client::*;
 use super::diff::*;
 use super::install::*;
+use super::report::{PublishReport, PublishReportFile};
 use super::types::*;
 use super::*;
-use async_walkdir::WalkDir;
-use futures::StreamExt;
+use async_walkdir::{Filtering, WalkDir};
+use futures::{FutureExt, StreamExt, TryStreamExt};
 use sha2::Digest;
-use std::collections::BTreeMap;
-use std::path::{Path, PathBuf};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::Duration;
+
+/// Set by the shared instances backend when it rejects an upload by file type.
+const FILE_NOT_ALLOWED_HEADER: &str = "x-file-not-allowed";
+const UPLOAD_PROGRESS_INTERVAL: Duration = Duration::from_millis(200);
+const UPLOAD_CONCURRENCY: usize = 4;
+const UPLOAD_BATCH_MAX_FILES: usize = 256;
+const UPLOAD_BATCH_MIN_BYTES: u64 = 16 * 1024 * 1024;
+/// Total file size the shared instances backend accepts in one batch.
+const UPLOAD_BATCH_MAX_BYTES: u64 = 450 * 1024 * 1024;
+const UPLOAD_BATCH_ATTEMPTS: usize = 2;
 
 #[tracing::instrument]
 pub async fn unpublish_shared_instance(instance_id: &str) -> crate::Result<()> {
@@ -88,13 +99,22 @@ pub(super) async fn detach_local_shared_instance(
     Ok(())
 }
 
-#[tracing::instrument]
+/// `on_progress` receives the uploaded and total bytes of the files the
+/// shared instances service asks for.
+#[tracing::instrument(skip(on_progress))]
 pub async fn publish_shared_instance(
     instance_id: &str,
-    config_paths: Vec<String>,
+    file_paths: Vec<String>,
+    on_progress: &(dyn Fn(u64, u64) + Send + Sync),
 ) -> crate::Result<SharedInstanceAttachment> {
     let state = State::get().await?;
-    publish_shared_instance_inner(instance_id, &config_paths, &state).await?;
+    publish_shared_instance_inner(
+        instance_id,
+        &file_paths,
+        on_progress,
+        &state,
+    )
+    .await?;
     emit_instance(instance_id, InstancePayloadType::Edited).await?;
 
     shared_attachment(instance_id, &state).await?.ok_or(
@@ -152,11 +172,7 @@ pub async fn get_shared_instance_publish_preview(
         shared_instance_id: attachment.id,
         latest_version: version.version,
         diffs,
-        config_files: snapshot
-            .config_files
-            .into_iter()
-            .map(|file| file.path)
-            .collect(),
+        files: snapshot.shared_files,
     }))
 }
 
@@ -187,7 +203,12 @@ pub(super) async fn remote_publish_content(
         version
             .external_files
             .iter()
-            .filter(|file| file.file_type != CONFIG_BUNDLE_FILE_TYPE)
+            .filter(|file| {
+                !matches!(
+                    file.file_type.as_str(),
+                    CONFIG_BUNDLE_FILE_TYPE | CONFIG_FILE_TYPE
+                )
+            })
             .map(|file| {
                 shared_external_file_key(&file.file_type, &file.file_name)
             })
@@ -356,7 +377,7 @@ pub(super) struct CurrentPublishSnapshot {
     pub(super) disabled_project_ids: HashSet<String>,
     pub(super) disabled_version_ids: Vec<String>,
     pub(super) disabled_external_files: BTreeSet<ExternalFileKey>,
-    pub(super) config_files: Vec<ConfigFile>,
+    pub(super) shared_files: Vec<SharedInstancePublishFile>,
 }
 
 /// Cached metadata can outlive a deleted or hidden version. Only publish version
@@ -369,7 +390,7 @@ pub(super) async fn collect_publish_snapshot(
         .directories
         .instances_dir()
         .join(&metadata.instance.path);
-    let (items, config_files) = if CONFIG_SYNC_ENABLED {
+    let (items, shared_files) = if CONFIG_SYNC_ENABLED {
         tokio::try_join!(
             crate::state::list_content(
                 &metadata.instance.id,
@@ -377,7 +398,7 @@ pub(super) async fn collect_publish_snapshot(
                 None,
                 state,
             ),
-            collect_config_files(&instance_path),
+            collect_shareable_files(&instance_path),
         )?
     } else {
         (
@@ -481,7 +502,7 @@ pub(super) async fn collect_publish_snapshot(
         disabled_project_ids,
         disabled_version_ids,
         disabled_external_files,
-        config_files,
+        shared_files,
     })
 }
 
@@ -583,7 +604,28 @@ pub(super) async fn set_shared_instance_publish_status(
 
 pub(super) async fn publish_shared_instance_inner(
     instance_id: &str,
-    config_paths: &[String],
+    file_paths: &[String],
+    on_progress: &(dyn Fn(u64, u64) + Send + Sync),
+    state: &State,
+) -> crate::Result<()> {
+    let mut report = PublishReport::new(instance_id, file_paths);
+    let result = publish_shared_instance_reported(
+        instance_id,
+        file_paths,
+        on_progress,
+        &mut report,
+        state,
+    )
+    .await;
+    report.finish(&result);
+    result
+}
+
+async fn publish_shared_instance_reported(
+    instance_id: &str,
+    file_paths: &[String],
+    on_progress: &(dyn Fn(u64, u64) + Send + Sync),
+    report: &mut PublishReport,
     state: &State,
 ) -> crate::Result<()> {
     let attachment = shared_attachment(instance_id, state).await?.ok_or(
@@ -591,6 +633,9 @@ pub(super) async fn publish_shared_instance_inner(
             "instance is not attached to a shared instance".to_string(),
         ),
     )?;
+    report.shared_instance_id = Some(attachment.id.clone());
+    report.applied_version = attachment.applied_version;
+    report.latest_version = attachment.latest_version;
     ensure_owner(&attachment)?;
     tracing::info!(
         instance_id,
@@ -612,7 +657,9 @@ pub(super) async fn publish_shared_instance_inner(
     let result = publish_current_content(
         instance_id,
         &attachment.id,
-        config_paths,
+        file_paths,
+        on_progress,
+        report,
         state,
     )
     .await;
@@ -658,13 +705,21 @@ pub(super) async fn publish_shared_instance_inner(
 pub(super) async fn publish_current_content(
     instance_id: &str,
     shared_instance_id: &str,
-    config_paths: &[String],
+    file_paths: &[String],
+    on_progress: &(dyn Fn(u64, u64) + Send + Sync),
+    report: &mut PublishReport,
     state: &State,
 ) -> crate::Result<i32> {
     let _store_lease = state.content_store.lease().await;
     let metadata = crate::state::get_instance(instance_id, &state.pool)
         .await?
         .ok_or(crate::ErrorKind::InputError("unknown instance".to_string()))?;
+    report.instance_name = Some(metadata.instance.name.clone());
+    report.game_version =
+        Some(metadata.applied_content_set.game_version.clone());
+    report.loader =
+        Some(metadata.applied_content_set.loader.as_str().to_string());
+    report.loader_version = metadata.applied_content_set.loader_version.clone();
     ensure_shareable_link(&metadata.link)?;
     update_remote_instance(
         shared_instance_id,
@@ -672,44 +727,25 @@ pub(super) async fn publish_current_content(
         state,
     )
     .await?;
+    report.step("Updated shared instance details");
     let modpack_id = shared_modpack_id(&metadata.link);
+    report.modpack_id = modpack_id.clone();
     let snapshot = collect_publish_snapshot(&metadata, state).await?;
-    let previous_version = if CONFIG_SYNC_ENABLED
-        && metadata
-            .shared_instance
-            .as_ref()
-            .and_then(|attachment| attachment.applied_version)
-            .is_some()
-    {
-        match get_latest_remote_version_optional_unavailable(
-            shared_instance_id,
-            state,
-        )
-        .await?
-        {
-            SharedInstanceRemoteResponse::Available(version) => Some(version),
-            SharedInstanceRemoteResponse::Unavailable(_) => None,
-        }
-    } else {
-        None
-    };
-    let config_bundle = if CONFIG_SYNC_ENABLED {
-        build_config_bundle_candidate(
+    report.step("Collected instance content");
+    let shared_files = if CONFIG_SYNC_ENABLED {
+        shared_file_candidates(
             &metadata.instance.path,
-            &snapshot.config_files,
-            config_paths,
-            previous_version.as_ref(),
+            &snapshot.shared_files,
+            file_paths,
             state,
         )
         .await?
     } else {
-        None
+        Vec::new()
     };
     let modrinth_ids = snapshot.version_ids;
     let mut external_files = snapshot.external_files;
-    if let Some(config_bundle) = config_bundle {
-        external_files.push(config_bundle);
-    }
+    external_files.extend(shared_files);
     tracing::debug!(
         instance_id,
         shared_instance_id,
@@ -718,7 +754,36 @@ pub(super) async fn publish_current_content(
         external_file_count = external_files.len(),
         "Creating shared instance version"
     );
-    let external_file_data = external_files
+    report.modrinth_ids = modrinth_ids.clone();
+    let hashed_files =
+        hash_external_files(&metadata.instance.path, &external_files, state)
+            .await?;
+    report.files = hashed_files
+        .iter()
+        .map(|file| PublishReportFile {
+            file_name: file.file_name.clone(),
+            file_type: file.file_type.clone(),
+            size: file.size,
+            sha512: file.sha512.clone(),
+            executable: file.executable,
+        })
+        .collect();
+    report.step(format!("Hashed {} files", hashed_files.len()));
+    if let Some(file) = hashed_files.iter().find(|file| file.executable) {
+        bail!(crate::ErrorKind::SharedInstanceFileNotAllowed(
+            file.file_name.clone()
+        ));
+    }
+    let total_size = hashed_files
+        .iter()
+        .fold(0_u64, |total, file| total.saturating_add(file.size));
+    if total_size > MAX_SHARED_FILES_TOTAL_SIZE {
+        bail!(crate::ErrorKind::InputError(format!(
+            "files exceed the {} limit for a shared instance version",
+            crate::util::io::format_bytes(MAX_SHARED_FILES_TOTAL_SIZE)
+        )));
+    }
+    let external_file_data = hashed_files
         .iter()
         .map(|file| ExternalFileData {
             file_name: file.file_name.clone(),
@@ -761,15 +826,31 @@ pub(super) async fn publish_current_content(
             return Err(shared_instance_unavailable_error(reason));
         }
     };
+    report.created_version = Some(response.version);
+    report.requested_files = Some(
+        response
+            .external_files
+            .iter()
+            .map(|file| file.file_name.clone())
+            .collect(),
+    );
+    report.step(format!(
+        "Created version {} ({} files requested for upload)",
+        response.version,
+        response.external_files.len()
+    ));
 
     if !response.external_files.is_empty() {
         upload_external_files(
-            &metadata.instance.path,
-            &external_files,
+            shared_instance_id,
+            response.version,
+            &hashed_files,
             &response.external_files,
+            on_progress,
             state,
         )
         .await?;
+        report.step("Uploaded requested files");
     } else if !response.ready {
         tracing::debug!(
             "Shared instance version {} was not ready but had no external files",
@@ -780,250 +861,151 @@ pub(super) async fn publish_current_content(
     Ok(response.version)
 }
 
-pub(super) async fn collect_config_files(
+pub(super) async fn collect_shareable_files(
     instance_path: &std::path::Path,
-) -> crate::Result<Vec<ConfigFile>> {
-    let config_path = instance_path.join(CONFIG_DIRECTORY);
-    crate::util::io::create_dir_all(&config_path).await?;
+) -> crate::Result<Vec<SharedInstancePublishFile>> {
     let mut files = Vec::new();
-    let mut walker = WalkDir::new(&config_path);
+    let root = instance_path.to_path_buf();
+    let mut walker = WalkDir::new(instance_path).filter(move |entry| {
+        let root = root.clone();
+        async move {
+            let is_dir = entry
+                .file_type()
+                .await
+                .is_ok_and(|file_type| file_type.is_dir());
+            let entry_path = entry.path();
+            let skip_dir = is_dir
+                && entry_path.strip_prefix(&root).is_ok_and(|relative| {
+                    !is_shareable_directory(
+                        &relative.to_string_lossy().replace('\\', "/"),
+                    )
+                });
+            if skip_dir {
+                Filtering::IgnoreDir
+            } else {
+                Filtering::Continue
+            }
+        }
+    });
 
     while let Some(entry) = walker.next().await {
-        let entry = entry.context("failed to read config directory")?;
-        if !entry.file_type().await?.is_file()
-            || !is_supported_config_file(&entry.path())
-        {
+        let entry = entry.context("failed to read instance directory")?;
+        if !entry.file_type().await?.is_file() {
             continue;
         }
 
         let entry_path = entry.path();
-        let relative_path = entry_path.strip_prefix(&config_path)?;
+        let relative_path = entry_path.strip_prefix(instance_path)?;
         let path = relative_path.to_string_lossy().replace('\\', "/");
-        files.push(ConfigFile { path });
+        if !is_shareable_file_path(&path) {
+            continue;
+        }
+        let size = entry.metadata().await?.len();
+        let blocked =
+            is_executable_content(&read_file_head(&entry_path).await?);
+        files.push(SharedInstancePublishFile {
+            path,
+            size,
+            blocked,
+        });
     }
 
     files.sort_by(|left, right| left.path.cmp(&right.path));
     Ok(files)
 }
 
-fn is_supported_config_file(path: &std::path::Path) -> bool {
-    path.extension()
-        .and_then(|extension| extension.to_str())
-        .is_some_and(|extension| {
-            CONFIG_FILE_EXTENSIONS
-                .iter()
-                .any(|candidate| extension.eq_ignore_ascii_case(candidate))
-        })
+async fn read_file_head(path: &std::path::Path) -> crate::Result<Vec<u8>> {
+    use tokio::io::AsyncReadExt;
+
+    let mut head = Vec::with_capacity(FILE_SCAN_HEAD_SIZE);
+    tokio::fs::File::open(path)
+        .await?
+        .take(FILE_SCAN_HEAD_SIZE as u64)
+        .read_to_end(&mut head)
+        .await?;
+    Ok(head)
 }
 
-async fn build_config_bundle_candidate(
+/// Each selected file is uploaded on its own under its instance-relative
+/// path, matching how linked servers publish files.
+async fn shared_file_candidates(
     instance_path: &str,
-    local_files: &[ConfigFile],
+    local_files: &[SharedInstancePublishFile],
     selected_paths: &[String],
-    previous_version: Option<&InstanceVersionResponse>,
     state: &State,
-) -> crate::Result<Option<ExternalFileCandidate>> {
-    let selected_paths = selected_paths
-        .iter()
-        .map(String::as_str)
-        .collect::<HashSet<_>>();
-    let local_files_by_path = local_files
+) -> crate::Result<Vec<ExternalFileCandidate>> {
+    let local_files = local_files
         .iter()
         .map(|file| (file.path.as_str(), file))
         .collect::<HashMap<_, _>>();
-    for selected_path in &selected_paths {
-        if !local_files_by_path.contains_key(selected_path) {
+    let selected_paths = selected_paths
+        .iter()
+        .map(String::as_str)
+        .collect::<BTreeSet<_>>();
+    for path in &selected_paths {
+        match local_files.get(path) {
+            None => bail!(crate::ErrorKind::InputError(format!(
+                "file {path} is unavailable for sharing"
+            ))),
+            Some(file) if file.blocked => {
+                bail!(crate::ErrorKind::SharedInstanceFileNotAllowed(
+                    path.to_string()
+                ))
+            }
+            Some(_) => {}
+        }
+    }
+    ensure_shared_file_count(&selected_paths)?;
+
+    let instance_path = state.directories.instances_dir().join(instance_path);
+    let mut total_size = 0_u64;
+    let mut candidates = Vec::with_capacity(selected_paths.len());
+    for path in selected_paths {
+        let source = instance_path.join(path);
+        let size = crate::util::io::metadata(&source).await?.len();
+        total_size = total_size.saturating_add(size);
+        if total_size > MAX_SHARED_FILES_TOTAL_SIZE {
             bail!(crate::ErrorKind::InputError(format!(
-                "config file {selected_path} is unavailable for sharing"
+                "selected files exceed the {} limit for a shared instance version",
+                crate::util::io::format_bytes(MAX_SHARED_FILES_TOTAL_SIZE)
             )));
         }
+        candidates.push(ExternalFileCandidate {
+            file_name: path.to_string(),
+            file_type: CONFIG_FILE_TYPE.to_string(),
+            source: ExternalFileSource::SharedFile(source),
+        });
     }
 
-    let previous_bundle = previous_version.and_then(|version| {
-        version
-            .external_files
-            .iter()
-            .find(|file| file.file_type == CONFIG_BUNDLE_FILE_TYPE)
-    });
-    if previous_bundle.is_none() && selected_paths.is_empty() {
-        return Ok(None);
-    }
-
-    let previous_bundle = if let Some(previous_bundle) = previous_bundle {
-        Some(
-            crate::util::fetch::fetch_file_mirrors_in(
-                &[&previous_bundle.url],
-                None,
-                None,
-                None,
-                &state.fetch_semaphore,
-                &state.pool,
-                None,
-                Some(&state.directories.store_staging_dir()),
-            )
-            .await?,
-        )
-    } else {
-        None
-    };
-    let config_path = state
-        .directories
-        .instances_dir()
-        .join(instance_path)
-        .join(CONFIG_DIRECTORY);
-    let selected_files = selected_paths
-        .into_iter()
-        .map(|path| (path.to_string(), config_path.join(path)))
-        .collect::<BTreeMap<_, _>>();
-    let bundle = tokio::task::spawn_blocking(move || {
-        let directory = tempfile::tempdir()?;
-        let mut entries = match &previous_bundle {
-            Some(bundle) => {
-                read_config_bundle(bundle.path(), directory.path())?
-            }
-            None => BTreeMap::new(),
-        };
-        entries.extend(selected_files);
-        config_bundle_file(&entries)
-    })
-    .await??;
-
-    Ok(Some(ExternalFileCandidate {
-        file_name: CONFIG_BUNDLE_FILE_NAME.to_string(),
-        file_type: CONFIG_BUNDLE_FILE_TYPE.to_string(),
-        source: ExternalFileSource::ConfigBundle(Arc::new(bundle)),
-    }))
+    Ok(candidates)
 }
 
-fn config_bundle_file(
-    entries: &BTreeMap<String, PathBuf>,
-) -> crate::Result<tempfile::TempPath> {
-    if entries.len() > MAX_CONFIG_BUNDLE_ENTRIES {
-        let mut folder_entry_counts = HashMap::new();
-        for path in entries.keys() {
-            if let Some((folder, _)) = path.split_once('/') {
-                *folder_entry_counts.entry(folder).or_insert(0_usize) += 1;
-            }
-        }
+fn ensure_shared_file_count(paths: &BTreeSet<&str>) -> crate::Result<()> {
+    if paths.len() <= MAX_SHARED_FILES {
+        return Ok(());
+    }
 
-        if let Some((folder, count)) = folder_entry_counts
-            .into_iter()
-            .filter(|(_, count)| *count > MAX_CONFIG_BUNDLE_ENTRIES)
-            .max_by_key(|(_, count)| *count)
-        {
-            bail!(crate::ErrorKind::InputError(format!(
-                "the \"{folder}\" config folder has too many files to share ({count}; maximum {MAX_CONFIG_BUNDLE_ENTRIES}); select fewer files from this folder"
-            )));
+    let mut folder_entry_counts = HashMap::new();
+    for path in paths {
+        if let Some((folder, _)) = path.split_once('/') {
+            *folder_entry_counts.entry(folder).or_insert(0_usize) += 1;
         }
+    }
 
+    if let Some((folder, count)) = folder_entry_counts
+        .into_iter()
+        .filter(|(_, count)| *count > MAX_SHARED_FILES)
+        .max_by_key(|(_, count)| *count)
+    {
         bail!(crate::ErrorKind::InputError(format!(
-            "too many config files were selected to share ({}; maximum {MAX_CONFIG_BUNDLE_ENTRIES}); select fewer files",
-            entries.len()
+            "the \"{folder}\" folder has too many files to share ({count}; maximum {MAX_SHARED_FILES}); select fewer files from this folder"
         )));
     }
-    let temporary = tempfile::NamedTempFile::new()?;
-    let mut writer = zip::ZipWriter::new(temporary);
-    let options = zip::write::SimpleFileOptions::default()
-        .compression_method(zip::CompressionMethod::Deflated);
-    let mut total_size = 0;
-    for (path, source) in entries {
-        let file = std::fs::File::open(source)?;
-        let declared_size = file.metadata()?.len();
-        writer
-            .start_file(path, options)
-            .map_err(std::io::Error::from)?;
-        copy_config_bundle_entry(
-            file,
-            declared_size,
-            &mut total_size,
-            &mut writer,
-        )?;
-    }
-    Ok(writer
-        .finish()
-        .map_err(std::io::Error::from)?
-        .into_temp_path())
-}
 
-fn copy_config_bundle_entry(
-    reader: impl std::io::Read,
-    declared_size: u64,
-    total_size: &mut u64,
-    writer: &mut impl std::io::Write,
-) -> crate::Result<()> {
-    let limit = MAX_CONFIG_BUNDLE_FILE_SIZE
-        .min(MAX_CONFIG_BUNDLE_TOTAL_SIZE.saturating_sub(*total_size));
-    if declared_size > limit {
-        bail!(crate::ErrorKind::InputError(
-            "shared instance config bundle exceeds the uncompressed size limit"
-                .to_string(),
-        ));
-    }
-    let size = std::io::copy(&mut reader.take(limit + 1), writer)?;
-    if size > limit {
-        bail!(crate::ErrorKind::InputError(
-            "shared instance config bundle exceeds the uncompressed size limit"
-                .to_string(),
-        ));
-    }
-    *total_size += size;
-    Ok(())
-}
-
-fn read_config_bundle(
-    path: &Path,
-    directory: &Path,
-) -> crate::Result<BTreeMap<String, PathBuf>> {
-    let mut archive = zip::ZipArchive::new(std::fs::File::open(path)?)
-        .context(crate::ErrorKind::InputError(
-            "invalid shared instance config bundle".to_string(),
-        ))?;
-    if archive.len() > MAX_CONFIG_BUNDLE_ENTRIES {
-        bail!(crate::ErrorKind::InputError(
-            "shared instance config bundle contains too many entries"
-                .to_string(),
-        ));
-    }
-    let mut entries = BTreeMap::new();
-    let mut total_size = 0;
-
-    for index in 0..archive.len() {
-        let file =
-            archive
-                .by_index(index)
-                .context(crate::ErrorKind::InputError(
-                    "invalid shared instance config bundle entry".to_string(),
-                ))?;
-        if file.is_dir() {
-            continue;
-        }
-        let path = file.enclosed_name().ok_or(crate::ErrorKind::InputError(
-            "shared instance config bundle contains an unsafe path".to_string(),
-        ))?;
-        if !is_supported_config_file(&path) {
-            bail!(crate::ErrorKind::InputError(format!(
-                "shared instance config bundle contains unsupported file {}",
-                path.display()
-            )));
-        }
-        let path = path.to_string_lossy().replace('\\', "/");
-        let declared_size = file.size();
-        let destination = directory.join(index.to_string());
-        let mut output = std::fs::File::create(&destination)?;
-        copy_config_bundle_entry(
-            file,
-            declared_size,
-            &mut total_size,
-            &mut output,
-        )?;
-        if entries.insert(path.clone(), destination).is_some() {
-            bail!(crate::ErrorKind::InputError(format!(
-                "shared instance config bundle contains duplicate file {path}"
-            )));
-        }
-    }
-
-    Ok(entries)
+    bail!(crate::ErrorKind::InputError(format!(
+        "too many files were selected to share ({}; maximum {MAX_SHARED_FILES}); select fewer files",
+        paths.len()
+    )))
 }
 
 pub(super) fn shared_modpack_id(link: &InstanceLink) -> Option<String> {
@@ -1052,86 +1034,403 @@ pub(super) fn ensure_shareable_link(link: &InstanceLink) -> crate::Result<()> {
     Ok(())
 }
 
-pub(super) async fn upload_external_files(
+/// A publish candidate with its content, size and SHA-512.
+pub(super) struct HashedExternalFile {
+    file_name: String,
+    file_type: String,
+    content: crate::state::content_store::ReadableContent,
+    size: u64,
+    sha512: String,
+    executable: bool,
+}
+
+async fn hash_external_files(
     instance_path: &str,
     candidates: &[ExternalFileCandidate],
+    state: &State,
+) -> crate::Result<Vec<HashedExternalFile>> {
+    let hashes = candidates
+        .iter()
+        .map(|candidate| hash_external_file(instance_path, candidate, state))
+        .collect::<Vec<_>>();
+    futures::stream::iter(hashes)
+        .buffered(UPLOAD_CONCURRENCY)
+        .try_collect()
+        .await
+}
+
+async fn hash_external_file(
+    instance_path: &str,
+    candidate: &ExternalFileCandidate,
+    state: &State,
+) -> crate::Result<HashedExternalFile> {
+    use tokio::io::AsyncReadExt;
+
+    let content = external_file_source(instance_path, candidate, state).await?;
+    let mut file = tokio::fs::File::open(content.path()).await?;
+    let mut hasher = sha2::Sha512::new();
+    let mut buffer = vec![0_u8; 64 * 1024];
+    let mut head = Vec::with_capacity(FILE_SCAN_HEAD_SIZE);
+    let mut size = 0_u64;
+    loop {
+        let read = file.read(&mut buffer).await?;
+        if read == 0 {
+            break;
+        }
+        hasher.update(&buffer[..read]);
+        let remaining = FILE_SCAN_HEAD_SIZE - head.len();
+        head.extend_from_slice(&buffer[..read.min(remaining)]);
+        size += read as u64;
+    }
+
+    Ok(HashedExternalFile {
+        file_name: candidate.file_name.clone(),
+        file_type: candidate.file_type.clone(),
+        content,
+        size,
+        sha512: format!("{:x}", hasher.finalize()),
+        executable: is_executable_content(&head),
+    })
+}
+
+pub(super) async fn upload_external_files(
+    shared_instance_id: &str,
+    version: i32,
+    files: &[HashedExternalFile],
     uploads: &[ExternalFileResponse],
+    on_progress: &(dyn Fn(u64, u64) + Send + Sync),
     state: &State,
 ) -> crate::Result<()> {
+    let mut sources = Vec::with_capacity(uploads.len());
     for upload in uploads {
-        let candidate = candidates
+        let file = files
             .iter()
-            .find(|candidate| {
-                candidate.file_name == upload.file_name
-                    && candidate.file_type == upload.file_type
+            .find(|file| {
+                file.file_name == upload.file_name
+                    && file.file_type == upload.file_type
             })
             .ok_or(crate::ErrorKind::InputError(format!(
                 "shared instance service requested unknown external file {}",
                 upload.file_name
             )))?;
-        let path = match &candidate.source {
-            ExternalFileSource::InstanceFile(file_path) => {
-                let instance = crate::state::instances::adapters::sqlite::instance_rows::get_instance_by_path(instance_path, &state.pool).await?
-					.ok_or(crate::ErrorKind::InputError("unknown instance".to_string()))?;
-                let file = crate::state::instances::adapters::sqlite::content_rows::get_instance_file_by_relative_path(&instance.id, file_path, &state.pool).await?
-					.ok_or(crate::ErrorKind::InputError("shared content file is not registered".to_string()))?;
-                state.content_store.read_path(&file, instance_path).await?
+        sources.push((upload, file));
+    }
+    sources.sort_by_key(|(_, file)| file.size);
+    let total = sources
+        .iter()
+        .fold(0_u64, |total, (_, file)| total.saturating_add(file.size));
+
+    let (single, batched): (Vec<_>, Vec<_>) = sources
+        .into_iter()
+        .partition(|(_, file)| file.size > UPLOAD_BATCH_MAX_BYTES);
+    let batch_bytes = (total / UPLOAD_CONCURRENCY as u64)
+        .clamp(UPLOAD_BATCH_MIN_BYTES, UPLOAD_BATCH_MAX_BYTES);
+    let mut batches = Vec::<Vec<&HashedExternalFile>>::new();
+    let mut current_bytes = 0_u64;
+    for (_, file) in batched {
+        match batches.last_mut() {
+            Some(batch)
+                if batch.len() < UPLOAD_BATCH_MAX_FILES
+                    && current_bytes + file.size <= batch_bytes =>
+            {
+                current_bytes += file.size;
+                batch.push(file);
             }
-            ExternalFileSource::ConfigBundle(path) => {
-                crate::state::content_store::ReadableContent::Local(
-                    path.as_ref().to_path_buf(),
-                )
+            _ => {
+                current_bytes = file.size;
+                batches.push(vec![file]);
             }
+        }
+    }
+
+    let batch_path =
+        format!("/instances/{shared_instance_id}/versions/{version}/files");
+    let uploaded = Arc::new(AtomicU64::new(0));
+    on_progress(0, total);
+    let uploads = batches
+        .into_iter()
+        .map(|batch| {
+            upload_external_file_batch(
+                &batch_path,
+                batch,
+                uploaded.clone(),
+                state,
+            )
+            .boxed()
+        })
+        .chain(single.into_iter().map(|(upload, file)| {
+            upload_external_file(upload, file, uploaded.clone(), state).boxed()
+        }))
+        .collect::<Vec<_>>();
+    let uploads = futures::stream::iter(uploads)
+        .buffer_unordered(UPLOAD_CONCURRENCY)
+        .try_collect::<()>();
+    tokio::pin!(uploads);
+    let mut ticker = tokio::time::interval(UPLOAD_PROGRESS_INTERVAL);
+    loop {
+        tokio::select! {
+            result = &mut uploads => break result?,
+            _ = ticker.tick() => on_progress(
+                uploaded.load(Ordering::Relaxed).min(total),
+                total,
+            ),
+        }
+    }
+    on_progress(total, total);
+
+    Ok(())
+}
+
+async fn upload_external_file_batch(
+    path: &str,
+    files: Vec<&HashedExternalFile>,
+    uploaded: Arc<AtomicU64>,
+    state: &State,
+) -> crate::Result<()> {
+    let url = service_url(service_base_url(), path);
+    let mut attempt = 1;
+    loop {
+        let sent = Arc::new(AtomicU64::new(0));
+        let result = send_external_file_batch(
+            path,
+            &url,
+            &files,
+            uploaded.clone(),
+            sent.clone(),
+            state,
+        )
+        .await;
+        let retry = match &result {
+            Ok(response) => response.status().is_server_error(),
+            Err(_) => true,
         };
-        let upload_url = url::Url::parse(&upload.url)
-            .context("invalid shared instance external file upload URL")?;
-        let mut file = tokio::fs::File::open(path.path()).await?;
-        let mut hasher = sha2::Sha512::new();
-        let mut buffer = vec![0_u8; 64 * 1024];
-        let mut size = 0_u64;
-        loop {
-            use tokio::io::AsyncReadExt;
-            let read = file.read(&mut buffer).await?;
-            if read == 0 {
-                break;
-            }
-            hasher.update(&buffer[..read]);
-            size += read as u64;
+        if !retry || attempt == UPLOAD_BATCH_ATTEMPTS {
+            let response = result?;
+            return handle_external_file_batch_response(path, &files, response)
+                .await;
         }
-        let file_sha512 = format!("{:x}", hasher.finalize());
-        use tokio::io::AsyncSeekExt;
-        file.rewind().await?;
-        let body =
-            reqwest::Body::wrap_stream(tokio_util::io::ReaderStream::new(file));
-        let response = send_body_request_to_url(
+        uploaded.fetch_sub(sent.load(Ordering::Relaxed), Ordering::Relaxed);
+        tracing::warn!(
+            path,
+            attempt,
+            file_count = files.len(),
+            "Retrying shared instance external file batch upload"
+        );
+        attempt += 1;
+    }
+}
+
+async fn send_external_file_batch(
+    path: &str,
+    url: &str,
+    files: &[&HashedExternalFile],
+    uploaded: Arc<AtomicU64>,
+    sent: Arc<AtomicU64>,
+    state: &State,
+) -> crate::Result<reqwest::Response> {
+    use futures::stream::BoxStream;
+    use reqwest::header::{CONTENT_ENCODING, CONTENT_TYPE, HeaderValue};
+
+    let boundary = format!("modrinth-{}", uuid::Uuid::new_v4().simple());
+    let manifest = serde_json::to_vec(&json!({
+        "files": files
+            .iter()
+            .map(|file| json!({
+                "file_name": file.file_name,
+                "file_type": file.file_type,
+                "file_size": file.size,
+                "sha512": file.sha512,
+            }))
+            .collect::<Vec<_>>(),
+    }))?;
+
+    let chunk =
+        |data: Vec<u8>| -> BoxStream<'static, std::io::Result<bytes::Bytes>> {
+            futures::stream::once(futures::future::ready(Ok(data.into())))
+                .boxed()
+        };
+    let part_header = |name: &str, content_type: &str| {
+        chunk(
+            format!(
+                "--{boundary}\r\nContent-Disposition: form-data; name=\"{name}\"\r\nContent-Type: {content_type}\r\n\r\n"
+            )
+            .into_bytes(),
+        )
+    };
+
+    let mut parts = vec![
+        part_header("manifest", "application/json"),
+        chunk(manifest),
+        chunk(b"\r\n".to_vec()),
+    ];
+    for file in files {
+        let file_path = file.content.path().to_path_buf();
+        let uploaded = uploaded.clone();
+        let sent = sent.clone();
+        parts.push(part_header("file", "application/octet-stream"));
+        parts.push(
+            futures::stream::once(tokio::fs::File::open(file_path))
+                .map_ok(|reader| {
+                    tokio_util::io::ReaderStream::with_capacity(
+                        reader,
+                        64 * 1024,
+                    )
+                })
+                .try_flatten()
+                .inspect_ok(move |read| {
+                    let len = read.len() as u64;
+                    uploaded.fetch_add(len, Ordering::Relaxed);
+                    sent.fetch_add(len, Ordering::Relaxed);
+                })
+                .boxed(),
+        );
+        parts.push(chunk(b"\r\n".to_vec()));
+    }
+    parts.push(chunk(format!("--{boundary}--\r\n").into_bytes()));
+
+    let encoder = async_compression::tokio::bufread::ZstdEncoder::new(
+        tokio_util::io::StreamReader::new(
+            futures::stream::iter(parts).flatten(),
+        ),
+    );
+    let body = reqwest::Body::wrap_stream(
+        tokio_util::io::ReaderStream::with_capacity(encoder, 64 * 1024),
+    );
+
+    let mut headers = reqwest::header::HeaderMap::new();
+    headers.insert(
+        CONTENT_TYPE,
+        HeaderValue::from_str(&format!(
+            "multipart/form-data; boundary={boundary}"
+        ))
+        .context("invalid multipart boundary")?,
+    );
+    headers.insert(CONTENT_ENCODING, HeaderValue::from_static("zstd"));
+
+    let size = files.iter().map(|file| file.size).sum::<u64>();
+    send_body_request_to_url(
+        "upload_external_files",
+        Method::POST,
+        path,
+        url,
+        body,
+        None,
+        headers,
+        state,
+    )
+    .await
+    .context(format!(
+        "uploading {} external files ({size} bytes)",
+        files.len()
+    ))
+}
+
+async fn handle_external_file_batch_response(
+    path: &str,
+    files: &[&HashedExternalFile],
+    response: reqwest::Response,
+) -> crate::Result<()> {
+    if response.status() == reqwest::StatusCode::BAD_REQUEST
+        && response.headers().contains_key(FILE_NOT_ALLOWED_HEADER)
+    {
+        let message = response.text().await.unwrap_or_default();
+        let file_name = files
+            .iter()
+            .map(|file| file.file_name.as_str())
+            .filter(|file_name| message.ends_with(file_name))
+            .max_by_key(|file_name| file_name.len())
+            .map(str::to_string)
+            .unwrap_or(message);
+        bail!(crate::ErrorKind::SharedInstanceFileNotAllowed(file_name));
+    }
+    if !response.status().is_success() {
+        return shared_instances_request_error(
+            "upload_external_files",
+            Method::POST,
+            path,
+            response,
+        )
+        .await;
+    }
+
+    Ok(())
+}
+
+async fn upload_external_file(
+    upload: &ExternalFileResponse,
+    file: &HashedExternalFile,
+    uploaded: Arc<AtomicU64>,
+    state: &State,
+) -> crate::Result<()> {
+    let HashedExternalFile {
+        content,
+        size,
+        sha512: file_sha512,
+        ..
+    } = file;
+    let upload_url = url::Url::parse(&upload.url)
+        .context("invalid shared instance external file upload URL")?;
+    let reader = tokio::fs::File::open(content.path()).await?;
+    let body = reqwest::Body::wrap_stream(
+        tokio_util::io::ReaderStream::with_capacity(reader, 64 * 1024)
+            .inspect_ok(move |chunk| {
+                uploaded.fetch_add(chunk.len() as u64, Ordering::Relaxed);
+            }),
+    );
+    let response = send_body_request_to_url(
+        "upload_external_file",
+        Method::PUT,
+        upload_url.path(),
+        &upload.url,
+        body,
+        Some(*size),
+        file_sha512_headers(Some(file_sha512))?,
+        state,
+    )
+    .await
+    .context(format!(
+        "uploading external file {} ({size} bytes, sha512 {file_sha512})",
+        upload.file_name
+    ))?;
+    if response.status() == reqwest::StatusCode::BAD_REQUEST
+        && response.headers().contains_key(FILE_NOT_ALLOWED_HEADER)
+    {
+        bail!(crate::ErrorKind::SharedInstanceFileNotAllowed(
+            upload.file_name.clone(),
+        ));
+    }
+    if !response.status().is_success() {
+        return shared_instances_request_error(
             "upload_external_file",
             Method::PUT,
             upload_url.path(),
-            &upload.url,
-            body,
-            Some(size),
-            Some(&file_sha512),
-            state,
+            response,
         )
-        .await
-        .context(format!(
-            "uploading external file {} ({size} bytes, sha512 {file_sha512})",
-            upload.file_name
-        ))?;
-        if !response.status().is_success() {
-            return shared_instances_request_error(
-                "upload_external_file",
-                Method::PUT,
-                upload_url.path(),
-                response,
-            )
-            .await;
-        }
+        .await;
     }
 
     Ok(())
 }
 
+async fn external_file_source(
+    instance_path: &str,
+    candidate: &ExternalFileCandidate,
+    state: &State,
+) -> crate::Result<crate::state::content_store::ReadableContent> {
+    Ok(match &candidate.source {
+        ExternalFileSource::InstanceFile(file_path) => {
+            let instance = crate::state::instances::adapters::sqlite::instance_rows::get_instance_by_path(instance_path, &state.pool).await?
+				.ok_or(crate::ErrorKind::InputError("unknown instance".to_string()))?;
+            let file = crate::state::instances::adapters::sqlite::content_rows::get_instance_file_by_relative_path(&instance.id, file_path, &state.pool).await?
+				.ok_or(crate::ErrorKind::InputError("shared content file is not registered".to_string()))?;
+            state.content_store.read_path(&file, instance_path).await?
+        }
+        ExternalFileSource::SharedFile(path) => {
+            crate::state::content_store::ReadableContent::Local(path.clone())
+        }
+    })
+}
+
 pub(super) async fn shared_attachment(
     instance_id: &str,
     state: &State,
@@ -1214,7 +1513,8 @@ pub(super) async fn shared_instance_for_invites(
                 shared_instance_id = %remote.id,
                 "Attached local instance as shared instance owner"
             );
-            publish_shared_instance_inner(instance_id, &[], state).await?;
+            publish_shared_instance_inner(instance_id, &[], &|_, _| {}, state)
+                .await?;
             shared_attachment(instance_id, state).await?.ok_or(
                 crate::ErrorKind::InputError(
                     "shared instance attachment was not persisted".to_string(),
diff --git a/packages/app-lib/src/api/instance/shared/report.rs b/packages/app-lib/src/api/instance/shared/report.rs
new file mode 100644
index 00000000000..0a4a7549806
--- /dev/null
+++ b/packages/app-lib/src/api/instance/shared/report.rs
@@ -0,0 +1,243 @@
+use crate::install::diagnostics::{
+    censor_support_text, write_environment_details, write_latest_log,
+};
+use crate::util::io::format_bytes;
+use chrono::{DateTime, Utc};
+use std::collections::{HashMap, HashSet};
+use std::fmt::Write as _;
+use std::sync::{LazyLock, Mutex};
+
+static PUBLISH_REPORTS: LazyLock<Mutex<HashMap<String, PublishReport>>> =
+    LazyLock::new(Default::default);
+
+pub(super) struct PublishReportFile {
+    pub(super) file_name: String,
+    pub(super) file_type: String,
+    pub(super) size: u64,
+    pub(super) sha512: String,
+    pub(super) executable: bool,
+}
+
+pub(super) struct PublishReport {
+    instance_id: String,
+    started_at: DateTime<Utc>,
+    pub(super) instance_name: Option<String>,
+    pub(super) shared_instance_id: Option<String>,
+    pub(super) applied_version: Option<i32>,
+    pub(super) latest_version: Option<i32>,
+    pub(super) created_version: Option<i32>,
+    pub(super) game_version: Option<String>,
+    pub(super) loader: Option<String>,
+    pub(super) loader_version: Option<String>,
+    pub(super) modpack_id: Option<String>,
+    pub(super) selected_paths: Vec<String>,
+    pub(super) modrinth_ids: Vec<String>,
+    pub(super) files: Vec<PublishReportFile>,
+    pub(super) requested_files: Option<HashSet<String>>,
+    timeline: Vec<(DateTime<Utc>, String)>,
+    error: Option<(&'static str, String)>,
+}
+
+impl PublishReport {
+    pub(super) fn new(instance_id: &str, selected_paths: &[String]) -> Self {
+        let mut report = Self {
+            instance_id: instance_id.to_string(),
+            started_at: Utc::now(),
+            instance_name: None,
+            shared_instance_id: None,
+            applied_version: None,
+            latest_version: None,
+            created_version: None,
+            game_version: None,
+            loader: None,
+            loader_version: None,
+            modpack_id: None,
+            selected_paths: selected_paths.to_vec(),
+            modrinth_ids: Vec::new(),
+            files: Vec::new(),
+            requested_files: None,
+            timeline: Vec::new(),
+            error: None,
+        };
+        report.step("Started push");
+        report
+    }
+
+    pub(super) fn step(&mut self, description: impl Into<String>) {
+        self.timeline.push((Utc::now(), description.into()));
+    }
+
+    pub(super) fn finish(mut self, result: &crate::Result<()>) {
+        match result {
+            Ok(()) => self.step("Push succeeded"),
+            Err(error) => {
+                self.step("Push failed");
+                self.error = Some((
+                    crate::error::error_code(error),
+                    format!("{error:#}"),
+                ));
+            }
+        }
+        if let Ok(mut reports) = PUBLISH_REPORTS.lock() {
+            reports.insert(self.instance_id.clone(), self);
+        }
+    }
+
+    fn render(&self) -> String {
+        let mut details = String::new();
+        let name = self.instance_name.as_deref().unwrap_or("Unknown");
+        let _ = writeln!(details, "Shared instance push report: {name}");
+        let _ = writeln!(
+            details,
+            "Result: {}",
+            match &self.error {
+                Some((code, _)) => format!("failed ({code})"),
+                None => "succeeded".to_string(),
+            }
+        );
+        let _ = writeln!(details, "Started: {}", self.started_at.to_rfc3339());
+        let _ = writeln!(details, "Instance ID: {}", self.instance_id);
+        let _ = writeln!(
+            details,
+            "Shared instance ID: {}",
+            self.shared_instance_id.as_deref().unwrap_or("unknown")
+        );
+        let _ = writeln!(
+            details,
+            "Applied version before push: {}",
+            optional_version(self.applied_version)
+        );
+        let _ = writeln!(
+            details,
+            "Latest version before push: {}",
+            optional_version(self.latest_version)
+        );
+        let _ = writeln!(
+            details,
+            "Version being pushed: {}",
+            optional_version(self.created_version)
+        );
+        let _ = writeln!(
+            details,
+            "Minecraft version: {}",
+            self.game_version.as_deref().unwrap_or("unknown")
+        );
+        let _ = writeln!(
+            details,
+            "Loader: {} {}",
+            self.loader.as_deref().unwrap_or("unknown"),
+            self.loader_version.as_deref().unwrap_or("")
+        );
+        let _ = writeln!(
+            details,
+            "Modpack version ID: {}",
+            self.modpack_id.as_deref().unwrap_or("none")
+        );
+
+        write_environment_details(&mut details);
+
+        let _ = writeln!(details);
+        let _ = writeln!(details, "Timeline");
+        for (index, (at, description)) in self.timeline.iter().enumerate() {
+            let _ = writeln!(
+                details,
+                "{}. {} {description}",
+                index + 1,
+                at.to_rfc3339()
+            );
+        }
+
+        if let Some((code, message)) = &self.error {
+            let _ = writeln!(details);
+            let _ = writeln!(details, "Failure");
+            let _ = writeln!(details, "Code: {code}");
+            let _ = writeln!(details, "Message: {message}");
+        }
+
+        let _ = writeln!(details);
+        let _ = writeln!(
+            details,
+            "Modrinth versions ({})",
+            self.modrinth_ids.len()
+        );
+        for version_id in &self.modrinth_ids {
+            let _ = writeln!(details, "- {version_id}");
+        }
+
+        let _ = writeln!(details);
+        let _ =
+            writeln!(details, "Selected files ({})", self.selected_paths.len());
+        for path in &self.selected_paths {
+            let _ = writeln!(details, "- {path}");
+        }
+
+        let total_size = self
+            .files
+            .iter()
+            .fold(0_u64, |total, file| total.saturating_add(file.size));
+        let _ = writeln!(details);
+        let _ = writeln!(
+            details,
+            "Files ({}, {})",
+            self.files.len(),
+            format_bytes(total_size)
+        );
+        if let Some(requested) = &self.requested_files {
+            let requested_size = self
+                .files
+                .iter()
+                .filter(|file| requested.contains(&file.file_name))
+                .fold(0_u64, |total, file| total.saturating_add(file.size));
+            let _ = writeln!(
+                details,
+                "Requested for upload: {} ({})",
+                requested.len(),
+                format_bytes(requested_size)
+            );
+        }
+        for file in &self.files {
+            let upload = match &self.requested_files {
+                Some(requested) if requested.contains(&file.file_name) => {
+                    ", upload"
+                }
+                Some(_) => ", already stored",
+                None => "",
+            };
+            let blocked = if file.executable {
+                ", blocked as executable"
+            } else {
+                ""
+            };
+            let _ = writeln!(
+                details,
+                "- {} [{}{upload}{blocked}] {} sha512={}",
+                file.file_name,
+                file.file_type,
+                format_bytes(file.size),
+                file.sha512
+            );
+        }
+
+        details
+    }
+}
+
+fn optional_version(version: Option<i32>) -> String {
+    version.map_or_else(|| "none".to_string(), |version| version.to_string())
+}
+
+#[tracing::instrument]
+pub async fn get_shared_instance_publish_support_details(
+    instance_id: &str,
+) -> crate::Result<Option<String>> {
+    let state = crate::State::get().await?;
+    let details = PUBLISH_REPORTS.lock().ok().and_then(|reports| {
+        reports.get(instance_id).map(PublishReport::render)
+    });
+    let Some(mut details) = details else {
+        return Ok(None);
+    };
+    write_latest_log(&mut details, &state.directories).await;
+
+    Ok(Some(censor_support_text(details, &state.pool).await?))
+}
diff --git a/packages/app-lib/src/api/instance/shared/types.rs b/packages/app-lib/src/api/instance/shared/types.rs
index a6def37decf..da602d8f7b2 100644
--- a/packages/app-lib/src/api/instance/shared/types.rs
+++ b/packages/app-lib/src/api/instance/shared/types.rs
@@ -105,7 +105,15 @@ pub struct SharedInstancePublishPreview {
     pub shared_instance_id: String,
     pub latest_version: i32,
     pub diffs: Vec<SharedInstanceUpdateDiff>,
-    pub config_files: Vec<String>,
+    pub files: Vec<SharedInstancePublishFile>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SharedInstancePublishFile {
+    pub path: String,
+    pub size: u64,
+    pub blocked: bool,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
diff --git a/packages/app-lib/src/error.rs b/packages/app-lib/src/error.rs
index 7fe1d4866e5..2c1b3c4370c 100644
--- a/packages/app-lib/src/error.rs
+++ b/packages/app-lib/src/error.rs
@@ -124,6 +124,9 @@ pub enum ErrorKind {
     #[error("shared instances api request failed")]
     SharedInstancesApiError,
 
+    #[error("you are not allowed to share {0}")]
+    SharedInstanceFileNotAllowed(String),
+
     #[error("join handle error: {0}")]
     JoinError(#[from] tokio::task::JoinError),
 
@@ -293,6 +296,9 @@ impl ErrorKind {
                 }
             },
             Self::SharedInstancesApiError => "shared_instances_api_error",
+            Self::SharedInstanceFileNotAllowed(_) => {
+                "shared_instance_file_not_allowed"
+            }
             Self::HashError(_, _) => "hash_error",
             Self::LoginCanceled => "login_canceled",
             Self::NotLoggedIn => "not_logged_in",
diff --git a/packages/app-lib/src/install/diagnostics.rs b/packages/app-lib/src/install/diagnostics.rs
index 642a6840b82..bc3816c24f1 100644
--- a/packages/app-lib/src/install/diagnostics.rs
+++ b/packages/app-lib/src/install/diagnostics.rs
@@ -5,6 +5,7 @@ use super::model::{
 };
 use super::store;
 use crate::state::{DirectoryInfo, ModrinthCredentials, State};
+use crate::util::io::format_bytes;
 use regex::{Captures, Regex};
 use sqlx::{Row, SqlitePool};
 use std::fmt::Write as _;
@@ -95,7 +96,7 @@ fn result_summary(
     }
 }
 
-fn write_environment_details(details: &mut String) {
+pub(crate) fn write_environment_details(details: &mut String) {
     let _ = writeln!(details);
     let _ = writeln!(details, "Environment");
     let _ = writeln!(details, "App version: {}", env!("CARGO_PKG_VERSION"));
@@ -411,7 +412,10 @@ fn write_raw_snapshot(details: &mut String, snapshot: &InstallJobSnapshot) {
     }
 }
 
-async fn write_latest_log(details: &mut String, directories: &DirectoryInfo) {
+pub(crate) async fn write_latest_log(
+    details: &mut String,
+    directories: &DirectoryInfo,
+) {
     let _ = writeln!(details);
     let _ = writeln!(details, "Latest launcher log excerpt");
     match latest_launcher_log_tail(directories).await {
@@ -514,25 +518,6 @@ fn progress_summary(progress: &InstallProgress) -> String {
     value
 }
 
-fn format_bytes(bytes: u64) -> String {
-    const UNITS: [&str; 5] = ["B", "KiB", "MiB", "GiB", "TiB"];
-    let mut value = bytes as f64;
-    let mut unit = UNITS[0];
-    for next_unit in UNITS.iter().skip(1) {
-        if value < 1024.0 {
-            break;
-        }
-        value /= 1024.0;
-        unit = next_unit;
-    }
-
-    if unit == "B" {
-        format!("{bytes} B")
-    } else {
-        format!("{value:.1} {unit}")
-    }
-}
-
 fn json_string<T: serde::Serialize>(value: &T) -> String {
     serde_json::to_string(value)
         .map(|value| value.trim_matches('"').to_string())
@@ -598,7 +583,7 @@ fn read_file_tail(path: &Path, max_bytes: u64) -> crate::Result<String> {
     Ok(output)
 }
 
-async fn censor_support_text(
+pub(crate) async fn censor_support_text(
     mut text: String,
     pool: &SqlitePool,
 ) -> crate::Result<String> {
diff --git a/packages/app-lib/src/install/mod.rs b/packages/app-lib/src/install/mod.rs
index 3786acca15a..172b44cdfdc 100644
--- a/packages/app-lib/src/install/mod.rs
+++ b/packages/app-lib/src/install/mod.rs
@@ -4,7 +4,7 @@
 #![deny(clippy::large_futures)]
 
 pub(crate) mod control;
-mod diagnostics;
+pub(crate) mod diagnostics;
 pub mod events;
 pub mod model;
 pub mod recovery;
diff --git a/packages/app-lib/src/install/model.rs b/packages/app-lib/src/install/model.rs
index 104bd06c3f6..413d044fd4b 100644
--- a/packages/app-lib/src/install/model.rs
+++ b/packages/app-lib/src/install/model.rs
@@ -252,6 +252,8 @@ pub struct SharedInstanceExternalFileData {
     pub file_type: String,
     pub url: String,
     pub file_size: u64,
+    #[serde(default)]
+    pub sha1: Option<String>,
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
diff --git a/packages/app-lib/src/install/runner.rs b/packages/app-lib/src/install/runner.rs
index 271ad9d212a..68ef9eae75d 100644
--- a/packages/app-lib/src/install/runner.rs
+++ b/packages/app-lib/src/install/runner.rs
@@ -3,8 +3,8 @@ use super::model::{
     InstallCleanup, InstallErrorContext, InstallErrorView, InstallJobDisplay,
     InstallJobEventKind, InstallJobSnapshot, InstallJobState, InstallJobStatus,
     InstallPhaseDetails, InstallPhaseId, InstallPostInstallEdit,
-    InstallProgress, InstallRequest, InstallRollbackState, InstallTarget,
-    SharedInstanceInstallData,
+    InstallProgress, InstallProgressSecondary, InstallRequest,
+    InstallRollbackState, InstallTarget, SharedInstanceInstallData,
 };
 use super::shared_instance::{
     apply_shared_instance_content, apply_shared_instance_update,
@@ -1742,6 +1742,17 @@ async fn update_backup_scope(
         }
         InstallRequest::UpdateSharedInstance { instance_id, data } => {
             paths.push(crate::api::instance::CONFIG_DIRECTORY.to_string());
+            paths.extend(
+                data.external_files
+                    .iter()
+                    .filter(|file| {
+                        file.file_type == crate::api::instance::CONFIG_FILE_TYPE
+                    })
+                    .filter_map(|file| file.file_name.split('/').next())
+                    .map(str::to_string),
+            );
+            paths.sort_unstable();
+            paths.dedup();
             let metadata = instance_metadata(instance_id, state).await?;
             if !shared_instance_update_requires_full_apply(&metadata, data) {
                 return Ok(Some(paths));
@@ -1887,13 +1898,27 @@ pub(super) async fn update_content_progress(
     pool: &SqlitePool,
     current: u64,
     total: u64,
+) -> crate::Result<()> {
+    update_content_progress_with_bytes(
+        job_id, job_state, pool, current, total, None,
+    )
+    .await
+}
+
+pub(super) async fn update_content_progress_with_bytes(
+    job_id: Uuid,
+    job_state: &mut InstallJobState,
+    pool: &SqlitePool,
+    current: u64,
+    total: u64,
+    bytes: Option<InstallProgressSecondary>,
 ) -> crate::Result<()> {
     super::control::checkpoint(job_id).await?;
     job_state.progress.phase = InstallPhaseId::DownloadingContent;
     job_state.progress.progress = Some(InstallProgress {
         current,
         total,
-        secondary: None,
+        secondary: bytes,
     });
     job_state.progress.details = InstallPhaseDetails::Empty;
     let record = store::update_state(job_id, job_state, pool).await?;
diff --git a/packages/app-lib/src/install/shared_instance.rs b/packages/app-lib/src/install/shared_instance.rs
index 1362b637cca..8472c4d63fc 100644
--- a/packages/app-lib/src/install/shared_instance.rs
+++ b/packages/app-lib/src/install/shared_instance.rs
@@ -1,17 +1,19 @@
 use super::events::InstallProgressReporter;
 use super::model::{
     InstallJobState, InstallPhaseDetails, InstallPhaseId,
-    SharedInstanceExternalFileData, SharedInstanceInstallData,
-    SharedInstanceInstallModpack,
+    InstallProgressSecondary, SharedInstanceExternalFileData,
+    SharedInstanceInstallData, SharedInstanceInstallModpack,
 };
 use super::runner::{
-    install_pack, modpack_details, update_content_progress, update_progress,
+    install_pack, modpack_details, update_content_progress,
+    update_content_progress_with_bytes, update_progress,
 };
 use crate::ErrorKind;
 use crate::api::instance::{
-    CONFIG_BUNDLE_FILE_TYPE, CONFIG_DIRECTORY, CONFIG_FILE_EXTENSIONS,
+    CONFIG_BUNDLE_FILE_TYPE, CONFIG_DIRECTORY, CONFIG_FILE_TYPE,
     CONFIG_SYNC_ENABLED, MAX_CONFIG_BUNDLE_ENTRIES,
-    read_bounded_config_bundle_entry,
+    MAX_SHARED_FILES_TOTAL_SIZE, is_shareable_file_path,
+    is_supported_config_file, read_bounded_config_bundle_entry,
 };
 use crate::api::pack::install_from::CreatePackLocation;
 use crate::state::instances::adapters::sqlite::content_rows;
@@ -24,13 +26,19 @@ use anyhow::{Context, bail};
 use futures::StreamExt;
 use path_util::SafeRelativeUtf8UnixPathBuf;
 use sqlx::SqlitePool;
+use std::cmp::Reverse;
 use std::collections::{HashMap, HashSet};
 use std::future::Future;
 use std::path::PathBuf;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::Duration;
 use uuid::Uuid;
 
 const MAX_SHARED_INSTANCE_EXTERNAL_FILE_SIZE: u64 = 500 * 1024 * 1024;
 const MAX_SHARED_INSTANCE_INITIAL_BUFFER_SIZE: u64 = 8 * 1024 * 1024;
+const SHARED_INSTANCE_CONTENT_DOWNLOAD_CONCURRENCY: usize = 4;
+const SHARED_INSTANCE_FILE_DOWNLOAD_CONCURRENCY: usize = 64;
+const SHARED_INSTANCE_PROGRESS_INTERVAL: Duration = Duration::from_millis(500);
 
 pub(super) async fn attach_pending_shared_instance(
     instance_id: &str,
@@ -88,6 +96,18 @@ struct CurrentSharedInstanceProject {
 #[derive(Clone, Debug)]
 struct CurrentSharedInstanceExternalFile {
     relative_path: String,
+    sha1: String,
+    missing: bool,
+}
+
+impl CurrentSharedInstanceExternalFile {
+    fn matches(&self, desired: &SharedInstanceExternalFileData) -> bool {
+        !self.missing
+            && desired
+                .sha1
+                .as_deref()
+                .is_some_and(|sha1| self.sha1.eq_ignore_ascii_case(sha1))
+    }
 }
 
 type SharedInstanceExternalFileKey = (ProjectType, String);
@@ -121,6 +141,7 @@ struct DesiredSharedInstanceContent {
         DesiredSharedInstanceExternalFile,
     >,
     config_bundle: Option<SharedInstanceExternalFileData>,
+    config_files: Vec<SharedInstanceExternalFileData>,
 }
 
 struct SharedInstanceProjectUpdate {
@@ -138,6 +159,7 @@ struct SharedInstanceApplyPlan {
     external_updates: Vec<DesiredSharedInstanceExternalFile>,
     external_additions: Vec<DesiredSharedInstanceExternalFile>,
     config_bundle: Option<SharedInstanceExternalFileData>,
+    config_files: Vec<SharedInstanceExternalFileData>,
 }
 
 impl SharedInstanceApplyPlan {
@@ -173,6 +195,7 @@ impl SharedInstanceApplyPlan {
             project_removals,
             external_removals,
             config_bundle: desired.config_bundle,
+            config_files: desired.config_files,
             ..Default::default()
         };
 
@@ -211,10 +234,9 @@ impl SharedInstanceApplyPlan {
         for desired in desired.external_files.into_values() {
             let key = (desired.file_type, desired.file.file_name.clone());
             match current.external_files.get(&key) {
-                Some(_) => {
-                    plan.external_updates.push(desired);
-                }
-                _ => plan.external_additions.push(desired),
+                Some(current) if current.matches(&desired.file) => {}
+                Some(_) => plan.external_updates.push(desired),
+                None => plan.external_additions.push(desired),
             }
         }
 
@@ -226,7 +248,8 @@ impl SharedInstanceApplyPlan {
             + self.project_additions.len()
             + self.external_updates.len()
             + self.external_additions.len()
-            + usize::from(self.config_bundle.is_some())) as u64
+            + usize::from(self.config_bundle.is_some())
+            + self.config_files.len()) as u64
     }
 }
 
@@ -335,94 +358,36 @@ async fn apply_shared_instance_update_inner(
         .await?;
     }
 
-    let mut completed_content_changes = 0;
-    for update in plan.project_updates {
-        let new_path =
-            crate::state::instances::commands::add_project_from_version(
-                instance_id,
-                &update.desired.version_id,
-                DownloadReason::Update,
-                Some(update.current.version_id),
-                ContentSourceKind::SharedInstance,
-                state,
-            )
-            .await?;
-
-        if update.current.relative_path != new_path {
-            crate::state::instances::commands::remove_project(
-                instance_id,
-                &update.current.relative_path,
-                state,
-            )
-            .await?;
-        }
-        completed_content_changes += 1;
-        update_content_progress(
-            job_id,
-            job_state,
-            &state.pool,
-            completed_content_changes,
-            content_change_count,
-        )
-        .await?;
-    }
-
-    for project in plan.project_additions {
-        crate::state::instances::commands::add_project_from_version(
-            instance_id,
-            &project.version_id,
-            DownloadReason::Standalone,
-            None,
-            ContentSourceKind::SharedInstance,
-            state,
-        )
-        .await?;
-        completed_content_changes += 1;
-        update_content_progress(
-            job_id,
-            job_state,
-            &state.pool,
-            completed_content_changes,
-            content_change_count,
-        )
-        .await?;
-    }
-
-    for file in plan
-        .external_updates
-        .into_iter()
-        .chain(plan.external_additions)
-    {
-        install_shared_instance_external_file(instance_id, &file.file, state)
-            .await?;
-        completed_content_changes += 1;
-        update_content_progress(
-            job_id,
-            job_state,
-            &state.pool,
-            completed_content_changes,
-            content_change_count,
-        )
-        .await?;
-    }
-
-    if let Some(config_bundle) = plan.config_bundle {
-        install_shared_instance_external_file(
-            instance_id,
-            &config_bundle,
-            state,
-        )
-        .await?;
-        completed_content_changes += 1;
-        update_content_progress(
-            job_id,
-            job_state,
-            &state.pool,
-            completed_content_changes,
-            content_change_count,
-        )
-        .await?;
-    }
+    install_shared_instance_downloads(
+        job_id,
+        job_state,
+        state,
+        instance_id,
+        plan.project_updates
+            .iter()
+            .map(|update| SharedInstanceModInstall {
+                version_id: &update.desired.version_id,
+                reason: DownloadReason::Update,
+                replaces: Some(&update.current),
+            })
+            .chain(plan.project_additions.iter().map(|project| {
+                SharedInstanceModInstall {
+                    version_id: &project.version_id,
+                    reason: DownloadReason::Standalone,
+                    replaces: None,
+                }
+            }))
+            .collect(),
+        plan.external_updates
+            .iter()
+            .chain(&plan.external_additions)
+            .map(|file| &file.file)
+            .chain(&plan.config_bundle)
+            .chain(&plan.config_files)
+            .collect(),
+        content_change_count,
+    )
+    .await?;
 
     crate::api::instance::edit(
         instance_id,
@@ -525,6 +490,8 @@ async fn current_shared_instance_content(
                 (entry.project_type, file.file_name.clone()),
                 CurrentSharedInstanceExternalFile {
                     relative_path: file.relative_path.clone(),
+                    sha1: file.sha1.clone(),
+                    missing: file.missing,
                 },
             );
         }
@@ -556,6 +523,12 @@ async fn desired_shared_instance_content(
     }
 
     for file in &data.external_files {
+        if file.file_type == CONFIG_FILE_TYPE {
+            if CONFIG_SYNC_ENABLED {
+                content.config_files.push(file.clone());
+            }
+            continue;
+        }
         if file.file_type == CONFIG_BUNDLE_FILE_TYPE {
             if CONFIG_SYNC_ENABLED {
                 content.config_bundle = Some(file.clone());
@@ -724,49 +697,23 @@ async fn apply_shared_instance_content_inner(
     if !data.modrinth_ids.is_empty() || !data.external_files.is_empty() {
         let content_change_count =
             data.modrinth_ids.len() as u64 + data.external_files.len() as u64;
-        update_content_progress(
+        install_shared_instance_downloads(
             job_id,
             job_state,
-            &state.pool,
-            0,
+            state,
+            instance_id,
+            data.modrinth_ids
+                .iter()
+                .map(|version_id| SharedInstanceModInstall {
+                    version_id,
+                    reason: DownloadReason::Standalone,
+                    replaces: None,
+                })
+                .collect(),
+            data.external_files.iter().collect(),
             content_change_count,
         )
         .await?;
-        let mut completed_content_changes = 0;
-        for version_id in &data.modrinth_ids {
-            crate::state::instances::commands::add_project_from_version(
-                instance_id,
-                version_id,
-                DownloadReason::Standalone,
-                None,
-                ContentSourceKind::SharedInstance,
-                state,
-            )
-            .await?;
-            completed_content_changes += 1;
-            update_content_progress(
-                job_id,
-                job_state,
-                &state.pool,
-                completed_content_changes,
-                content_change_count,
-            )
-            .await?;
-        }
-
-        for file in &data.external_files {
-            install_shared_instance_external_file(instance_id, file, state)
-                .await?;
-            completed_content_changes += 1;
-            update_content_progress(
-                job_id,
-                job_state,
-                &state.pool,
-                completed_content_changes,
-                content_change_count,
-            )
-            .await?;
-        }
     }
 
     crate::api::instance::edit(
@@ -837,12 +784,260 @@ pub(super) fn shared_instance_link(
     }
 }
 
+/// Bytes downloaded across every external file of an install, reported as the
+/// secondary progress so the download manager can show size, speed and ETA.
+struct DownloadedBytes {
+    current: AtomicU64,
+    total: u64,
+}
+
+impl DownloadedBytes {
+    fn add(&self, bytes: u64) {
+        self.current.fetch_add(bytes, Ordering::Relaxed);
+    }
+
+    fn progress(&self) -> InstallProgressSecondary {
+        InstallProgressSecondary {
+            current: self.current.load(Ordering::Relaxed).min(self.total),
+            total: self.total,
+        }
+    }
+}
+
+struct SharedInstanceModInstall<'a> {
+    version_id: &'a str,
+    reason: DownloadReason,
+    replaces: Option<&'a CurrentSharedInstanceProject>,
+}
+
+/// Mods and content files are installed before individual shared files, so
+/// those files are checked against the content just installed and override
+/// any config bundle entries at the same path. Larger downloads start first so
+/// a big download is not left running alone at the end.
+async fn install_shared_instance_downloads(
+    job_id: Uuid,
+    job_state: &mut InstallJobState,
+    state: &State,
+    instance_id: &str,
+    mods: Vec<SharedInstanceModInstall<'_>>,
+    files: Vec<&SharedInstanceExternalFileData>,
+    total: u64,
+) -> crate::Result<()> {
+    let version_ids = mods
+        .iter()
+        .map(|install| install.version_id.to_string())
+        .collect::<Vec<_>>();
+    let versions = shared_instance_versions_by_id(&version_ids, state).await?;
+    let mut mods = mods
+        .into_iter()
+        .map(|install| {
+            let size = versions
+                .get(install.version_id)
+                .and_then(|version| {
+                    version
+                        .files
+                        .iter()
+                        .find(|file| file.primary)
+                        .or_else(|| version.files.first())
+                })
+                .map_or(0, |file| u64::from(file.size));
+            (install, size)
+        })
+        .collect::<Vec<_>>();
+    mods.sort_by_key(|(_, size)| Reverse(*size));
+    let (mut shared_files, mut content_files): (Vec<_>, Vec<_>) = files
+        .into_iter()
+        .partition(|file| file.file_type == CONFIG_FILE_TYPE);
+    content_files.sort_by_key(|file| Reverse(file.file_size));
+    shared_files.sort_by_key(|file| Reverse(file.file_size));
+    let bytes = DownloadedBytes {
+        current: AtomicU64::new(0),
+        total: mods.iter().map(|(_, size)| size).sum::<u64>()
+            + content_files
+                .iter()
+                .chain(&shared_files)
+                .map(|file| file.file_size)
+                .sum::<u64>(),
+    };
+    let mut completed = 0;
+
+    report_shared_instance_installs(
+        futures::stream::iter(
+            mods.into_iter()
+                .map(|(install, size)| {
+                    install_shared_instance_mod(
+                        instance_id,
+                        install,
+                        size,
+                        state,
+                        &bytes,
+                    )
+                })
+                .collect::<Vec<_>>(),
+        )
+        .buffer_unordered(SHARED_INSTANCE_CONTENT_DOWNLOAD_CONCURRENCY),
+        job_id,
+        job_state,
+        &state.pool,
+        &mut completed,
+        total,
+        &bytes,
+    )
+    .await?;
+
+    report_shared_instance_installs(
+        futures::stream::iter(
+            content_files
+                .into_iter()
+                .map(|file| {
+                    install_shared_instance_external_file(
+                        instance_id,
+                        file,
+                        state,
+                        &bytes,
+                    )
+                })
+                .collect::<Vec<_>>(),
+        )
+        .buffer_unordered(SHARED_INSTANCE_CONTENT_DOWNLOAD_CONCURRENCY),
+        job_id,
+        job_state,
+        &state.pool,
+        &mut completed,
+        total,
+        &bytes,
+    )
+    .await?;
+
+    if shared_files.is_empty() {
+        return Ok(());
+    }
+    let writer =
+        crate::api::instance::InstanceFileWriter::new(state, instance_id)
+            .await?;
+    report_shared_instance_installs(
+        futures::stream::iter(
+            shared_files
+                .into_iter()
+                .map(|file| {
+                    install_shared_instance_file(&writer, file, state, &bytes)
+                })
+                .collect::<Vec<_>>(),
+        )
+        .buffer_unordered(SHARED_INSTANCE_FILE_DOWNLOAD_CONCURRENCY),
+        job_id,
+        job_state,
+        &state.pool,
+        &mut completed,
+        total,
+        &bytes,
+    )
+    .await
+}
+
+async fn install_shared_instance_mod(
+    instance_id: &str,
+    install: SharedInstanceModInstall<'_>,
+    size: u64,
+    state: &State,
+    downloaded: &DownloadedBytes,
+) -> crate::Result<()> {
+    let counted = AtomicU64::new(0);
+    let mut on_progress = |current: u64,
+                           _total: u64|
+     -> std::pin::Pin<
+        Box<dyn Future<Output = crate::Result<()>> + Send>,
+    > {
+        let previous = counted.fetch_max(current, Ordering::Relaxed);
+        downloaded.add(current.saturating_sub(previous));
+        Box::pin(std::future::ready(Ok(())))
+    };
+    let project =
+        crate::state::instances::commands::download_project_version_with_progress(
+            instance_id,
+            install.version_id,
+            install.reason,
+            install.replaces.map(|current| current.version_id.clone()),
+            state,
+            Some(&mut on_progress),
+        )
+        .await?;
+    downloaded.add(size.saturating_sub(counted.load(Ordering::Relaxed)));
+
+    let new_path =
+        crate::state::instances::commands::add_downloaded_project_version(
+            instance_id,
+            project,
+            ContentSourceKind::SharedInstance,
+            state,
+        )
+        .await?;
+    if let Some(current) = install.replaces
+        && current.relative_path != new_path
+    {
+        crate::state::instances::commands::remove_project(
+            instance_id,
+            &current.relative_path,
+            state,
+        )
+        .await?;
+    }
+    Ok(())
+}
+
+async fn report_shared_instance_installs(
+    installs: impl futures::Stream<Item = crate::Result<()>>,
+    job_id: Uuid,
+    job_state: &mut InstallJobState,
+    pool: &SqlitePool,
+    completed: &mut u64,
+    total: u64,
+    bytes: &DownloadedBytes,
+) -> crate::Result<()> {
+    let mut installs = std::pin::pin!(installs);
+    let mut ticker = tokio::time::interval(SHARED_INSTANCE_PROGRESS_INTERVAL);
+    ticker.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
+    loop {
+        tokio::select! {
+            result = installs.next() => match result {
+                Some(result) => {
+                    result?;
+                    *completed += 1;
+                }
+                None => break,
+            },
+            _ = ticker.tick() => {
+                update_content_progress_with_bytes(
+                    job_id,
+                    job_state,
+                    pool,
+                    *completed,
+                    total,
+                    Some(bytes.progress()),
+                )
+                .await?;
+            }
+        }
+    }
+    update_content_progress_with_bytes(
+        job_id,
+        job_state,
+        pool,
+        *completed,
+        total,
+        Some(bytes.progress()),
+    )
+    .await
+}
+
 async fn install_shared_instance_external_file(
     instance_id: &str,
     file: &SharedInstanceExternalFileData,
     state: &State,
+    downloaded: &DownloadedBytes,
 ) -> crate::Result<()> {
     if file.file_type == CONFIG_BUNDLE_FILE_TYPE && !CONFIG_SYNC_ENABLED {
+        downloaded.add(file.file_size);
         return Ok(());
     }
 
@@ -897,6 +1092,7 @@ async fn install_shared_instance_external_file(
                 file.file_name
             );
         }
+        downloaded.add(chunk.len() as u64);
         bytes.extend_from_slice(&chunk);
     }
 
@@ -940,6 +1136,86 @@ async fn install_shared_instance_external_file(
     Ok(())
 }
 
+/// Shared files can be up to the version's size limit, so they are streamed to
+/// disk rather than held in memory.
+async fn install_shared_instance_file(
+    writer: &crate::api::instance::InstanceFileWriter,
+    file: &SharedInstanceExternalFileData,
+    state: &State,
+    downloaded: &DownloadedBytes,
+) -> crate::Result<()> {
+    if !CONFIG_SYNC_ENABLED {
+        downloaded.add(file.file_size);
+        return Ok(());
+    }
+    if !is_shareable_file_path(&file.file_name)
+        || file.file_size > MAX_SHARED_FILES_TOTAL_SIZE
+    {
+        bail!(ErrorKind::InputError(format!(
+            "shared instance file {} is unsupported or too large",
+            file.file_name
+        )));
+    }
+    if shared_instance_file_is_current(writer, file, state).await? {
+        downloaded.add(file.file_size);
+        return Ok(());
+    }
+
+    let response = REQWEST_CLIENT.get(&file.url).send().await?;
+    if !response.status().is_success() {
+        bail!(
+            "shared instance file download failed with status {}",
+            response.status()
+        );
+    }
+    if response
+        .content_length()
+        .is_some_and(|content_length| content_length != file.file_size)
+    {
+        bail!(
+            "shared instance file {} has an unexpected size",
+            file.file_name
+        );
+    }
+
+    let reader = tokio_util::io::StreamReader::new(
+        response.bytes_stream().map(|chunk| {
+            let chunk = chunk
+                .map_err(|error| std::io::Error::other(error.to_string()))?;
+            downloaded.add(chunk.len() as u64);
+            Ok::<_, std::io::Error>(chunk)
+        }),
+    );
+    writer
+        .write_from_reader(state, &file.file_name, reader, file.file_size)
+        .await
+}
+
+/// Whether the instance already has this exact shared file, so the download
+/// can be skipped. Without a hash from the server it is treated as changed.
+async fn shared_instance_file_is_current(
+    writer: &crate::api::instance::InstanceFileWriter,
+    file: &SharedInstanceExternalFileData,
+    state: &State,
+) -> crate::Result<bool> {
+    let Some(expected_sha1) = file.sha1.as_deref() else {
+        return Ok(false);
+    };
+    let path = writer.destination(state, &file.file_name).await?;
+    let is_same_size =
+        tokio::fs::symlink_metadata(&path)
+            .await
+            .is_ok_and(|metadata| {
+                metadata.is_file() && metadata.len() == file.file_size
+            });
+    if !is_same_size {
+        return Ok(false);
+    }
+
+    let (_, sha1) = crate::util::fetch::sha1_file_async(&path).await?;
+    Ok(sha1.eq_ignore_ascii_case(expected_sha1))
+}
+
 fn validate_shared_instance_external_file_name(
     file_name: &str,
 ) -> crate::Result<()> {
@@ -1033,13 +1309,3 @@ fn read_config_bundle(bytes: &[u8]) -> crate::Result<Vec<(PathBuf, Vec<u8>)>> {
 
     Ok(files)
 }
-
-fn is_supported_config_file(path: &std::path::Path) -> bool {
-    path.extension()
-        .and_then(|extension| extension.to_str())
-        .is_some_and(|extension| {
-            CONFIG_FILE_EXTENSIONS
-                .iter()
-                .any(|candidate| extension.eq_ignore_ascii_case(candidate))
-        })
-}
diff --git a/packages/app-lib/src/util/io.rs b/packages/app-lib/src/util/io.rs
index 052ea8c86fe..91a9e89ab08 100644
--- a/packages/app-lib/src/util/io.rs
+++ b/packages/app-lib/src/util/io.rs
@@ -376,3 +376,22 @@ macro_rules! get_resource_file {
         get_resource_file!(directory: env!($dir_env_name), file: $file_name)
     };
 }
+
+pub fn format_bytes(bytes: u64) -> String {
+    const UNITS: [&str; 5] = ["B", "KiB", "MiB", "GiB", "TiB"];
+    let mut value = bytes as f64;
+    let mut unit = UNITS[0];
+    for next_unit in UNITS.iter().skip(1) {
+        if value < 1024.0 {
+            break;
+        }
+        value /= 1024.0;
+        unit = next_unit;
+    }
+
+    if unit == "B" {
+        format!("{bytes} B")
+    } else {
+        format!("{value:.1} {unit}")
+    }
+}
diff --git a/packages/ui/src/components/base/FileTreeSelect.vue b/packages/ui/src/components/base/FileTreeSelect.vue
index 2fe2f6ab31d..04b1dd6584e 100644
--- a/packages/ui/src/components/base/FileTreeSelect.vue
+++ b/packages/ui/src/components/base/FileTreeSelect.vue
@@ -1,12 +1,13 @@
 <template>
 	<div class="flex w-full min-w-0 flex-col gap-2">
 		<div
-			class="flex w-full min-w-0 flex-col rounded-[20px] border border-solid border-surface-4 shadow-sm overflow-clip"
+			class="flex w-full min-w-0 flex-col overflow-clip"
+			:class="{ 'rounded-[20px] border border-solid border-surface-4 shadow-sm': !flush }"
 		>
 			<div
-				class="flex h-10 w-full min-w-0 select-none flex-row items-center justify-between bg-surface-3 px-3 text-sm font-medium"
+				class="flex w-full min-w-0 select-none flex-row items-center justify-between bg-surface-3 p-3 font-medium"
 			>
-				<div class="flex min-w-0 flex-1 items-center gap-2">
+				<div class="flex min-w-0 flex-1 items-center gap-2.5">
 					<Checkbox
 						:model-value="allVisibleSelected"
 						:indeterminate="someVisibleSelected && !allVisibleSelected"
@@ -15,19 +16,19 @@
 					/>
 					<button
 						type="button"
-						class="flex min-w-0 appearance-none items-center gap-1.5 border-0 bg-transparent p-0 font-semibold hover:text-primary"
-						:class="sortField === 'name' ? 'text-contrast' : 'text-secondary'"
+						class="flex min-w-0 appearance-none items-center gap-1.5 border-0 bg-transparent p-0 font-medium hover:text-contrast"
+						:class="sortField === 'name' ? 'text-contrast' : 'text-primary'"
 						@click="handleSort('name')"
 					>
 						<span class="min-w-0 truncate">{{ formatMessage(messages.name) }}</span>
 						<ChevronUpIcon
 							v-if="sortField === 'name' && !sortDesc"
-							class="size-4 shrink-0"
+							class="size-5 shrink-0"
 							aria-hidden="true"
 						/>
 						<ChevronDownIcon
 							v-if="sortField === 'name' && sortDesc"
-							class="size-4 shrink-0"
+							class="size-5 shrink-0"
 							aria-hidden="true"
 						/>
 					</button>
@@ -36,83 +37,81 @@
 					<button
 						v-if="showSize"
 						type="button"
-						class="hidden w-[92px] appearance-none items-center gap-1 border-0 bg-transparent p-0 text-left font-semibold hover:text-primary sm:flex"
-						:class="sortField === 'size' ? 'text-contrast' : 'text-secondary'"
+						class="hidden w-[92px] appearance-none items-center gap-1 border-0 bg-transparent p-0 text-left font-medium hover:text-contrast sm:flex"
+						:class="sortField === 'size' ? 'text-contrast' : 'text-primary'"
 						@click="handleSort('size')"
 					>
 						<span>{{ formatMessage(messages.size) }}</span>
 						<ChevronUpIcon
 							v-if="sortField === 'size' && !sortDesc"
-							class="size-4 shrink-0"
+							class="size-5 shrink-0"
 							aria-hidden="true"
 						/>
 						<ChevronDownIcon
 							v-if="sortField === 'size' && sortDesc"
-							class="size-4 shrink-0"
+							class="size-5 shrink-0"
 							aria-hidden="true"
 						/>
 					</button>
 					<button
 						v-if="showModified"
 						type="button"
-						class="hidden w-[132px] appearance-none items-center gap-1 border-0 bg-transparent p-0 text-left font-semibold hover:text-primary sm:flex"
-						:class="sortField === 'modified' ? 'text-contrast' : 'text-secondary'"
+						class="hidden w-[132px] appearance-none items-center gap-1 border-0 bg-transparent p-0 text-left font-medium hover:text-contrast sm:flex"
+						:class="sortField === 'modified' ? 'text-contrast' : 'text-primary'"
 						@click="handleSort('modified')"
 					>
 						<span>{{ formatMessage(messages.modified) }}</span>
 						<ChevronUpIcon
 							v-if="sortField === 'modified' && !sortDesc"
-							class="size-4 shrink-0"
+							class="size-5 shrink-0"
 							aria-hidden="true"
 						/>
 						<ChevronDownIcon
 							v-if="sortField === 'modified' && sortDesc"
-							class="size-4 shrink-0"
+							class="size-5 shrink-0"
 							aria-hidden="true"
 						/>
 					</button>
-					<span class="size-4 shrink-0" aria-hidden="true" />
+					<span class="size-5 shrink-0" aria-hidden="true" />
 				</div>
 			</div>
 			<div
 				v-if="!isHomePath"
 				role="button"
 				tabindex="0"
-				class="group flex w-full min-w-0 cursor-pointer select-none items-center gap-2 border-0 border-t border-solid border-surface-4 bg-surface-2 px-3 py-2 text-left hover:bg-surface-2.5 focus:!outline-none"
+				class="group flex w-full min-w-0 cursor-pointer select-none items-center gap-2.5 border-0 border-t border-solid border-surface-4 bg-surface-2 p-3 text-left hover:bg-surface-2.5 focus:!outline-none"
 				@click="navigateTo(parentPath)"
 				@keydown="(event) => event.key === 'Enter' && navigateTo(parentPath)"
 			>
 				<span class="size-5 shrink-0" aria-hidden="true" />
-				<div class="flex size-4 shrink-0 items-center justify-center text-secondary">
-					<UndoIcon class="size-4 group-hover:text-contrast group-focus:text-contrast" />
+				<div class="flex size-5 shrink-0 items-center justify-center text-secondary">
+					<UndoIcon class="size-5 group-hover:text-contrast group-focus-visible:text-contrast" />
 				</div>
 				<span
-					class="min-w-0 flex-1 truncate text-sm font-medium text-primary group-hover:text-contrast group-focus:text-contrast"
+					class="min-w-0 flex-1 truncate text-primary group-hover:text-contrast group-focus-visible:text-contrast"
 				>
 					{{ formatMessage(messages.parentFolder) }}
 				</span>
 				<div class="ml-2 flex shrink-0 items-center gap-4">
-					<span v-if="showSize" class="hidden w-[92px] text-left text-sm text-secondary sm:block" />
-					<span
-						v-if="showModified"
-						class="hidden w-[132px] text-left text-sm text-secondary sm:block"
-					/>
-					<span class="size-4 shrink-0" aria-hidden="true" />
+					<span v-if="showSize" class="hidden w-[92px] sm:block" />
+					<span v-if="showModified" class="hidden w-[132px] sm:block" />
+					<span class="size-5 shrink-0" aria-hidden="true" />
 				</div>
 			</div>
 			<div
 				v-if="entries.length === 0"
-				class="flex items-center gap-2 bg-surface-2 px-3 py-2 text-sm text-secondary"
+				class="flex items-center gap-2.5 bg-surface-2 p-3 text-primary"
 			>
-				<FileIcon class="size-4 shrink-0" />
+				<FileIcon class="size-5 shrink-0" />
 				<span>{{ formatMessage(messages.emptyFolderTitle) }}</span>
 			</div>
 			<div
 				v-for="(entry, i) in entries"
 				:key="`${entry.type}:${entry.path}`"
+				v-tooltip="entry.disabled ? entry.disabledTooltip : undefined"
 				role="button"
 				tabindex="0"
-				class="group flex w-full min-w-0 select-none items-center gap-2 border-0 border-t border-solid border-surface-4 px-3 py-2 text-left first:border-t-0 focus:!outline-none"
+				class="group flex w-full min-w-0 select-none items-center gap-2.5 border-0 border-t border-solid border-surface-4 p-3 text-left first:border-t-0 focus:!outline-none"
 				:class="[
 					getRowBackgroundClass(i + (isHomePath ? 0 : 1)),
 					entry.disabled && entry.type === 'file'
@@ -131,34 +130,35 @@
 					@click.stop
 					@update:model-value="toggleEntry(entry, $event)"
 				/>
-				<div class="flex size-4 shrink-0 items-center justify-center text-secondary">
+				<div class="flex size-5 shrink-0 items-center justify-center text-secondary">
 					<component
 						:is="entry.icon"
-						class="size-4 group-hover:text-contrast group-focus:text-contrast"
+						class="size-5 group-hover:text-contrast group-focus-visible:text-contrast"
 					/>
 				</div>
 				<span
 					:ref="(element) => setEntryNameRef(entry.path, element)"
-					v-tooltip="truncatedTooltip(entryNameRefs[entry.path], entry.name)"
-					class="min-w-0 flex-1 truncate text-sm font-medium text-primary group-hover:text-contrast group-focus:text-contrast"
+					v-tooltip="
+						entry.disabled && entry.disabledTooltip
+							? undefined
+							: truncatedTooltip(entryNameRefs[entry.path], entry.name)
+					"
+					class="min-w-0 flex-1 truncate text-primary group-hover:text-contrast group-focus-visible:text-contrast"
 				>
 					{{ entry.name }}
 				</span>
 				<div class="ml-2 flex shrink-0 items-center gap-4">
-					<span
-						v-if="showSize"
-						class="hidden w-[92px] truncate text-left text-sm text-secondary sm:block"
-					>
+					<span v-if="showSize" class="hidden w-[92px] truncate text-left text-primary sm:block">
 						{{ formatSize(entry) }}
 					</span>
 					<span
 						v-if="showModified"
-						class="hidden w-[132px] truncate text-left text-sm text-secondary sm:block"
+						class="hidden w-[132px] truncate text-left text-primary sm:block"
 					>
 						{{ formatModified(entry) }}
 					</span>
 					<ChevronRightIcon
-						class="size-4 shrink-0 text-secondary group-hover:text-contrast group-focus:text-contrast"
+						class="size-5 shrink-0 text-secondary group-hover:text-contrast group-focus-visible:text-contrast"
 						:class="{ invisible: entry.type !== 'directory' }"
 						aria-hidden="true"
 					/>
@@ -167,17 +167,17 @@
 			<div
 				v-for="row in fillerRowCount"
 				:key="`filler:${row}`"
-				class="flex w-full min-w-0 select-none items-center gap-2 border-0 border-t border-solid border-surface-4 px-3 py-2 text-left"
+				class="flex w-full min-w-0 select-none items-center gap-2.5 border-0 border-t border-solid border-surface-4 p-3 text-left"
 				:class="getRowBackgroundClass(visibleRowCount + row - 1)"
 				aria-hidden="true"
 			>
 				<span class="size-5 shrink-0" />
-				<span class="size-4 shrink-0" />
-				<span class="min-w-0 flex-1 truncate text-sm font-medium opacity-0">.</span>
+				<span class="size-5 shrink-0" />
+				<span class="min-w-0 flex-1 truncate opacity-0">.</span>
 				<div class="ml-2 flex shrink-0 items-center gap-4">
-					<span v-if="showSize" class="hidden w-[92px] text-left text-sm sm:block" />
-					<span v-if="showModified" class="hidden w-[132px] text-left text-sm sm:block" />
-					<span class="size-4 shrink-0" />
+					<span v-if="showSize" class="hidden w-[92px] sm:block" />
+					<span v-if="showModified" class="hidden w-[132px] sm:block" />
+					<span class="size-5 shrink-0" />
 				</div>
 			</div>
 		</div>
@@ -234,6 +234,7 @@ export type FileTreeSelectItem = {
 	path: string
 	type?: 'directory' | 'file'
 	disabled?: boolean
+	disabledTooltip?: string
 	size?: number
 	modified?: number
 	count?: number
@@ -252,6 +253,7 @@ type FileTreeSelectEntry = {
 	checked: boolean
 	indeterminate: boolean
 	disabled: boolean
+	disabledTooltip?: string
 	size?: number
 	modified?: number
 	count?: number
@@ -282,6 +284,7 @@ const props = withDefaults(
 		lazy?: boolean
 		showSize?: boolean
 		showModified?: boolean
+		flush?: boolean
 	}>(),
 	{
 		items: () => [],
@@ -289,6 +292,7 @@ const props = withDefaults(
 		lazy: false,
 		showSize: true,
 		showModified: true,
+		flush: false,
 	},
 )
 
@@ -574,15 +578,17 @@ function buildDirectoryEntry(
 	const selectableDescendants = descendants.filter((item) => !item.disabled)
 	const selected = isPathSelected(path)
 	const indeterminate = hasDescendantSelectionRule(path)
+	const disabled = item ? (item.disabled ?? false) : selectableDescendants.length === 0
 
 	return {
 		path,
 		name,
 		type: 'directory',
 		icon: getDirectoryIcon(name),
-		checked: selected && !indeterminate,
+		checked: selected && !indeterminate && !disabled,
 		indeterminate,
-		disabled: item ? (item.disabled ?? false) : selectableDescendants.length === 0,
+		disabled,
+		disabledTooltip: item?.disabledTooltip,
 		modified: item?.modified ?? getLatestModified(descendants),
 		count: item?.count ?? (item ? undefined : getFolderChildCount(path)),
 		item,
@@ -595,9 +601,10 @@ function buildFileEntry(item: NormalizedFileTreeSelectItem): FileTreeSelectEntry
 		name: item.name,
 		type: 'file',
 		icon: getFileIcon(item.name),
-		checked: isPathSelected(item.normalizedPath),
+		checked: !item.disabled && isPathSelected(item.normalizedPath),
 		indeterminate: false,
 		disabled: item.disabled ?? false,
+		disabledTooltip: item.disabledTooltip,
 		size: item.size,
 		modified: item.modified,
 		item,
diff --git a/packages/ui/src/components/base/Tabs.vue b/packages/ui/src/components/base/Tabs.vue
index 6a20988537c..97d78b3245d 100644
--- a/packages/ui/src/components/base/Tabs.vue
+++ b/packages/ui/src/components/base/Tabs.vue
@@ -1,8 +1,12 @@
 <template>
 	<div
 		v-if="tabs.length > 0"
-		class="inline-flex w-fit items-center gap-1 rounded-xl border border-solid border-surface-5 p-0.5 shadow-sm"
-		:class="wrap ? 'h-auto max-w-full flex-wrap' : 'h-[38px] overflow-x-auto'"
+		class="inline-flex w-fit items-center gap-1 border border-solid border-surface-5 shadow-sm"
+		:class="[
+			wrap ? 'h-auto max-w-full flex-wrap' : 'overflow-x-auto',
+			size === 'large' ? 'rounded-[14px] p-[3px]' : 'rounded-xl p-0.5',
+			!wrap && (size === 'large' ? 'h-[42px]' : 'h-[38px]'),
+		]"
 		role="tablist"
 	>
 		<button
@@ -10,14 +14,20 @@
 			:key="tab.value"
 			ref="tabButtons"
 			type="button"
-			class="flex min-h-6 shrink-0 cursor-pointer items-center justify-center gap-2 rounded-[10px] border border-solid px-2.5 text-sm font-medium outline-none transition-all active:scale-[0.97] focus-visible:ring-4 focus-visible:ring-brand-shadow disabled:cursor-not-allowed disabled:opacity-50"
+			class="flex min-h-6 shrink-0 cursor-pointer items-center justify-center gap-2 border border-solid outline-none transition-all active:scale-[0.97] focus-visible:ring-4 focus-visible:ring-brand-shadow disabled:cursor-not-allowed disabled:opacity-50"
 			:class="[
 				wrap ? 'h-8' : 'h-full',
+				size === 'large'
+					? 'rounded-xl px-3 text-base font-semibold'
+					: 'rounded-[10px] px-2.5 text-sm font-medium',
 				tab.value === value
 					? color === 'gray'
 						? 'border-surface-5 bg-surface-4 text-contrast'
 						: 'border-green bg-highlight-green text-green'
-					: 'border-transparent bg-transparent text-primary hover:bg-surface-4',
+					: [
+							'border-transparent bg-transparent hover:bg-surface-4',
+							size === 'large' ? 'text-contrast' : 'text-primary',
+						],
 			]"
 			role="tab"
 			:disabled="disabled"
@@ -61,6 +71,7 @@ const props = defineProps<{
 	tabs: TabsTab[]
 	wrap?: boolean
 	color?: 'green' | 'gray'
+	size?: 'default' | 'large'
 	disabled?: boolean
 }>()
 
diff --git a/packages/ui/src/components/sharing/invite-players-modal/index.vue b/packages/ui/src/components/sharing/invite-players-modal/index.vue
index cdc159f4917..0b8570cd116 100644
--- a/packages/ui/src/components/sharing/invite-players-modal/index.vue
+++ b/packages/ui/src/components/sharing/invite-players-modal/index.vue
@@ -7,7 +7,7 @@
 		no-padding
 		noblur
 	>
-		<div class="flex max-h-[calc(100vh-8rem)] min-h-0 flex-col">
+		<div class="flex max-h-[calc(100vh-12rem)] min-h-0 flex-col">
 			<div class="shrink-0 border-0 border-b border-solid border-surface-5 p-6">
 				<div class="flex items-start gap-2">
 					<Combobox
diff --git a/packages/ui/src/layouts/shared/installation-settings/components/ContentDiffList.vue b/packages/ui/src/layouts/shared/installation-settings/components/ContentDiffList.vue
new file mode 100644
index 00000000000..fe8cef16ba0
--- /dev/null
+++ b/packages/ui/src/layouts/shared/installation-settings/components/ContentDiffList.vue
@@ -0,0 +1,220 @@
+<template>
+	<div
+		class="flex max-h-[272px] flex-col overflow-y-auto border-0 border-y border-solid border-surface-5 bg-surface-2 px-3 py-2"
+	>
+		<div v-if="!diffs.length" class="flex h-10 min-h-10 items-center gap-2 px-2">
+			<div class="flex w-4 shrink-0 items-center justify-center">
+				<MinusIcon class="size-4" />
+			</div>
+			<span class="text-sm font-medium text-contrast">
+				{{ formatMessage(messages.noContentChanges) }}
+			</span>
+		</div>
+		<div
+			v-for="(diff, index) in sortedDiffs"
+			:key="diff.projectName || diff.fileName || (isConfigurationDiff(diff) ? diff.type : index)"
+			class="flex h-10 min-h-10 items-center gap-2"
+			:class="showExternalWarning(diff) ? '-mx-3 px-5' : 'px-2'"
+			:style="
+				showExternalWarning(diff)
+					? {
+							backgroundColor: 'color-mix(in srgb, var(--color-orange) 10%, transparent)',
+						}
+					: undefined
+			"
+		>
+			<div class="relative flex w-4 shrink-0 self-stretch items-center justify-center">
+				<div
+					v-if="index > 0"
+					class="absolute left-1/2 top-0 h-3 w-px -translate-x-1/2 bg-surface-5"
+				/>
+				<PlusIcon
+					v-if="diff.type === 'added' || diff.type === 'modpack_linked'"
+					class="relative z-[1] size-4"
+				/>
+				<MinusIcon
+					v-else-if="diff.type === 'removed' || diff.type === 'modpack_unlinked'"
+					class="relative z-[1] size-4 text-red"
+				/>
+				<RefreshCwIcon v-else class="relative z-[1] size-4" />
+				<div
+					v-if="index < sortedDiffs.length - 1"
+					class="absolute bottom-0 left-1/2 top-7 w-px -translate-x-1/2 bg-surface-5"
+				/>
+			</div>
+
+			<div class="flex min-w-0 flex-1 items-center gap-1 text-sm">
+				<span class="shrink-0 whitespace-nowrap text-primary">{{ getDiffTypeLabel(diff) }}</span>
+				<template v-if="showExternalWarning(diff)">
+					<CircleAlertIcon class="size-4 shrink-0 text-orange" />
+					<span class="truncate font-medium text-orange">
+						{{ formatMessage(messages.unknownProject) }}
+					</span>
+				</template>
+				<span
+					v-else-if="!isConfigurationDiff(diff) || diff.type === 'modpack_updated'"
+					class="truncate font-medium text-contrast"
+				>
+					{{ diff.projectName || (diff.fileName ? decodeURIComponent(diff.fileName) : '') }}
+				</span>
+			</div>
+			<span
+				v-if="getVersionLabel(diff)"
+				class="ml-2 max-w-[60%] min-w-0 shrink truncate text-right text-xs"
+				:class="showExternalWarning(diff) ? 'text-orange' : 'text-primary'"
+				:title="getVersionLabel(diff)"
+			>
+				{{ getVersionLabel(diff) }}
+			</span>
+		</div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { CircleAlertIcon, MinusIcon, PlusIcon, RefreshCwIcon } from '@modrinth/assets'
+import { computed } from 'vue'
+
+import { defineMessages, useVIntl } from '#ui/composables/i18n'
+
+import type { ContentDiffItem } from '../types'
+import { isConfigurationDiff, isDependencyDiff, showsExternalWarning } from '../utils'
+
+const props = defineProps<{
+	diffs: ContentDiffItem[]
+	addedLabel?: string
+	removedLabel?: string
+	showExternalWarnings?: boolean
+}>()
+
+const { formatMessage } = useVIntl()
+
+function showExternalWarning(diff: ContentDiffItem) {
+	return showsExternalWarning(diff, props.showExternalWarnings)
+}
+
+const sortedDiffs = computed(() =>
+	[...props.diffs].sort((a, b) => {
+		const aExternal = showExternalWarning(a)
+		const bExternal = showExternalWarning(b)
+		if (aExternal !== bExternal) return aExternal ? -1 : 1
+
+		const typeOrder: Record<ContentDiffItem['type'], number> = {
+			modpack_linked: 0,
+			modpack_updated: 0,
+			modpack_unlinked: 0,
+			game_version_updated: 1,
+			loader_updated: 2,
+			config_files_updated: 3,
+			added: 4,
+			updated: 5,
+			removed: 6,
+		}
+		return typeOrder[a.type] - typeOrder[b.type]
+	}),
+)
+
+function getDiffTypeLabel(diff: ContentDiffItem) {
+	if (showExternalWarning(diff) && isDependencyDiff(diff)) {
+		return formatMessage(externalDiffTypeMessages[diff.type])
+	}
+	if (diff.type === 'modpack_updated') return formatMessage(diffTypeMessages.updated)
+	if (isConfigurationDiff(diff)) return formatMessage(configurationDiffMessages[diff.type])
+	if (diff.type === 'removed' && diff.disabled) {
+		return formatMessage(diffTypeMessages.removedDisabled)
+	}
+	if (diff.type === 'added' && props.addedLabel) return props.addedLabel
+	if (diff.type === 'removed' && props.removedLabel) return props.removedLabel
+	return formatMessage(diffTypeMessages[diff.type])
+}
+
+function getVersionLabel(diff: ContentDiffItem) {
+	if (showExternalWarning(diff) && diff.fileName) return decodeURIComponent(diff.fileName)
+	if (diff.type === 'config_files_updated' && diff.fileCount !== undefined) {
+		return formatMessage(messages.fileCount, { count: diff.fileCount })
+	}
+	if (diff.type === 'modpack_updated') return diff.newVersionName
+	if (isConfigurationDiff(diff)) {
+		if (diff.currentVersionName && diff.newVersionName) {
+			return `${diff.currentVersionName} → ${diff.newVersionName}`
+		}
+		return diff.newVersionName ?? diff.currentVersionName
+	}
+	return diff.type === 'removed' ? diff.currentVersionName : diff.newVersionName
+}
+
+const messages = defineMessages({
+	noContentChanges: {
+		id: 'content.diff-modal.no-content-changes',
+		defaultMessage: 'No content changes',
+	},
+	fileCount: {
+		id: 'content.diff-modal.file-count',
+		defaultMessage: '{count, plural, one {# file} other {# files}}',
+	},
+	unknownProject: {
+		id: 'content.diff-modal.unknown-project',
+		defaultMessage: 'Unknown',
+	},
+})
+
+const configurationDiffMessages = defineMessages({
+	modpack_linked: {
+		id: 'content.diff-modal.modpack-linked',
+		defaultMessage: 'Linked modpack',
+	},
+	modpack_updated: {
+		id: 'content.diff-modal.modpack-updated',
+		defaultMessage: 'Updated modpack',
+	},
+	modpack_unlinked: {
+		id: 'content.diff-modal.modpack-unlinked',
+		defaultMessage: 'Unlinked modpack',
+	},
+	game_version_updated: {
+		id: 'content.diff-modal.game-version-updated',
+		defaultMessage: 'Game version',
+	},
+	loader_updated: {
+		id: 'content.diff-modal.loader-updated',
+		defaultMessage: 'Loader',
+	},
+	config_files_updated: {
+		id: 'content.diff-modal.config-files-updated',
+		defaultMessage: 'Changed files',
+	},
+})
+
+const diffTypeMessages = defineMessages({
+	added: {
+		id: 'content.diff-modal.diff-type.added',
+		defaultMessage: 'Added (dependency)',
+	},
+	removed: {
+		id: 'content.diff-modal.diff-type.removed',
+		defaultMessage: 'Disabled',
+	},
+	removedDisabled: {
+		id: 'content.diff-modal.diff-type.removed-disabled',
+		defaultMessage: 'Removed (disabled)',
+	},
+	updated: {
+		id: 'content.diff-modal.diff-type.updated',
+		defaultMessage: 'Updated',
+	},
+})
+
+const externalDiffTypeMessages = defineMessages({
+	added: {
+		id: 'content.diff-modal.external-diff-type.added',
+		defaultMessage: 'Added',
+	},
+	removed: {
+		id: 'content.diff-modal.external-diff-type.removed',
+		defaultMessage: 'Removed',
+	},
+	updated: {
+		id: 'content.diff-modal.external-diff-type.updated',
+		defaultMessage: 'Updated',
+	},
+})
+</script>
diff --git a/packages/ui/src/layouts/shared/installation-settings/components/ContentDiffModal.vue b/packages/ui/src/layouts/shared/installation-settings/components/ContentDiffModal.vue
index 18782e88633..946db33c741 100644
--- a/packages/ui/src/layouts/shared/installation-settings/components/ContentDiffModal.vue
+++ b/packages/ui/src/layouts/shared/installation-settings/components/ContentDiffModal.vue
@@ -47,79 +47,12 @@
 			</div>
 		</div>
 
-		<div
-			class="flex max-h-[272px] flex-col overflow-y-auto border-0 border-y border-solid border-surface-5 bg-surface-2 px-3 py-2"
-		>
-			<div v-if="!diffs.length" class="flex h-10 min-h-10 items-center gap-2 px-2">
-				<div class="flex w-4 shrink-0 items-center justify-center">
-					<MinusIcon class="size-4" />
-				</div>
-				<span class="text-sm font-medium text-contrast">
-					{{ formatMessage(messages.noContentChanges) }}
-				</span>
-			</div>
-			<div
-				v-for="(diff, index) in sortedDiffs"
-				:key="diff.projectName || diff.fileName || (isConfigurationDiff(diff) ? diff.type : index)"
-				class="flex h-10 min-h-10 items-center gap-2"
-				:class="showExternalWarning(diff) ? '-mx-3 px-5' : 'px-2'"
-				:style="
-					showExternalWarning(diff)
-						? {
-								backgroundColor: 'color-mix(in srgb, var(--color-orange) 10%, transparent)',
-							}
-						: undefined
-				"
-			>
-				<div class="relative flex w-4 shrink-0 self-stretch items-center justify-center">
-					<div
-						v-if="index > 0"
-						class="absolute left-1/2 top-0 h-3 w-px -translate-x-1/2 bg-surface-5"
-					/>
-					<PlusIcon
-						v-if="diff.type === 'added' || diff.type === 'modpack_linked'"
-						class="relative z-[1] size-4"
-					/>
-					<MinusIcon
-						v-else-if="diff.type === 'removed' || diff.type === 'modpack_unlinked'"
-						class="relative z-[1] size-4 text-red"
-					/>
-					<RefreshCwIcon v-else class="relative z-[1] size-4" />
-					<div
-						v-if="index < sortedDiffs.length - 1"
-						class="absolute bottom-0 left-1/2 top-7 w-px -translate-x-1/2 bg-surface-5"
-					/>
-				</div>
-
-				<div class="flex min-w-0 flex-1 items-center gap-1 text-sm">
-					<span class="shrink-0 whitespace-nowrap text-primary">{{ getDiffTypeLabel(diff) }}</span>
-					<template v-if="showExternalWarning(diff)">
-						<CircleAlertIcon class="size-4 shrink-0 text-orange" />
-						<span class="truncate font-medium text-orange">
-							{{ formatMessage(messages.unknownProject) }}
-						</span>
-					</template>
-					<span
-						v-else-if="!isConfigurationDiff(diff) || diff.type === 'modpack_updated'"
-						class="truncate font-medium text-contrast"
-					>
-						{{ diff.projectName || (diff.fileName ? decodeURIComponent(diff.fileName) : '') }}
-					</span>
-				</div>
-				<span
-					v-if="getVersionLabel(diff)"
-					class="ml-2 max-w-[60%] min-w-0 shrink truncate text-right text-xs"
-					:class="showExternalWarning(diff) ? 'text-orange' : 'text-primary'"
-					:title="getVersionLabel(diff)"
-				>
-					{{ getVersionLabel(diff) }}
-				</span>
-			</div>
-		</div>
-
-		<div v-if="$slots['additional-content']" class="px-4 pt-4">
-			<slot name="additional-content" />
-		</div>
+		<ContentDiffList
+			:diffs="diffs"
+			:added-label="addedLabel"
+			:removed-label="removedLabel"
+			:show-external-warnings="showExternalWarnings"
+		/>
 
 		<div
 			v-if="showBackupCreator"
@@ -164,11 +97,7 @@
 					</div>
 				</div>
 			</div>
-			<div
-				v-else
-				class="flex justify-between gap-2"
-				:class="{ 'pt-4': !$slots['additional-content'] }"
-			>
+			<div v-else class="flex justify-between gap-2 pt-4">
 				<div>
 					<Button v-if="showReportButton" type="quiet" color="red" @click="emit('report', $event)">
 						<ReportIcon />
@@ -196,15 +125,7 @@
 </template>
 
 <script setup lang="ts">
-import {
-	BanIcon,
-	CircleAlertIcon,
-	MinusIcon,
-	PlusIcon,
-	RefreshCwIcon,
-	ReportIcon,
-	XIcon,
-} from '@modrinth/assets'
+import { BanIcon, MinusIcon, PlusIcon, RefreshCwIcon, ReportIcon, XIcon } from '@modrinth/assets'
 import { type Component, computed, ref } from 'vue'
 
 import Admonition from '#ui/components/base/Admonition.vue'
@@ -215,6 +136,8 @@ import { commonMessages } from '#ui/utils/common-messages'
 
 import InlineBackupCreator from '../../content-tab/components/modals/InlineBackupCreator.vue'
 import type { ContentDiffItem } from '../types'
+import { showsExternalWarning } from '../utils'
+import ContentDiffList from './ContentDiffList.vue'
 
 const props = defineProps<{
 	header: string
@@ -260,91 +183,10 @@ const updatedCount = computed(
 		props.diffs.filter((diff) => diff.type === 'updated' || diff.type === 'config_files_updated')
 			.length,
 )
-const hasExternalDiffs = computed(() => props.diffs.some(showExternalWarning))
-
-type DependencyDiffType = Extract<ContentDiffItem['type'], 'added' | 'removed' | 'updated'>
-type ConfigurationDiffType = Exclude<ContentDiffItem['type'], DependencyDiffType>
-
-const configurationDiffTypes = new Set<ConfigurationDiffType>([
-	'modpack_linked',
-	'modpack_updated',
-	'modpack_unlinked',
-	'game_version_updated',
-	'loader_updated',
-	'config_files_updated',
-])
-
-function isDependencyDiff(
-	diff: ContentDiffItem,
-): diff is ContentDiffItem & { type: DependencyDiffType } {
-	return diff.type === 'added' || diff.type === 'removed' || diff.type === 'updated'
-}
-
-function isConfigurationDiff(
-	diff: ContentDiffItem,
-): diff is ContentDiffItem & { type: ConfigurationDiffType } {
-	return configurationDiffTypes.has(diff.type as ConfigurationDiffType)
-}
-
-function showExternalWarning(diff: ContentDiffItem) {
-	return Boolean(
-		props.showExternalWarnings &&
-		diff.external &&
-		isDependencyDiff(diff) &&
-		diff.type !== 'removed',
-	)
-}
-
-const sortedDiffs = computed(() =>
-	[...props.diffs].sort((a, b) => {
-		const aExternal = showExternalWarning(a)
-		const bExternal = showExternalWarning(b)
-		if (aExternal !== bExternal) return aExternal ? -1 : 1
-
-		const typeOrder: Record<ContentDiffItem['type'], number> = {
-			modpack_linked: 0,
-			modpack_updated: 0,
-			modpack_unlinked: 0,
-			game_version_updated: 1,
-			loader_updated: 2,
-			config_files_updated: 3,
-			added: 4,
-			updated: 5,
-			removed: 6,
-		}
-		return typeOrder[a.type] - typeOrder[b.type]
-	}),
+const hasExternalDiffs = computed(() =>
+	props.diffs.some((diff) => showsExternalWarning(diff, props.showExternalWarnings)),
 )
 
-function getDiffTypeLabel(diff: ContentDiffItem) {
-	if (showExternalWarning(diff) && isDependencyDiff(diff)) {
-		return formatMessage(externalDiffTypeMessages[diff.type])
-	}
-	if (diff.type === 'modpack_updated') return formatMessage(diffTypeMessages.updated)
-	if (isConfigurationDiff(diff)) return formatMessage(configurationDiffMessages[diff.type])
-	if (diff.type === 'removed' && diff.disabled) {
-		return formatMessage(diffTypeMessages.removedDisabled)
-	}
-	if (diff.type === 'added' && props.addedLabel) return props.addedLabel
-	if (diff.type === 'removed' && props.removedLabel) return props.removedLabel
-	return formatMessage(diffTypeMessages[diff.type])
-}
-
-function getVersionLabel(diff: ContentDiffItem) {
-	if (showExternalWarning(diff) && diff.fileName) return decodeURIComponent(diff.fileName)
-	if (diff.type === 'config_files_updated' && diff.fileCount !== undefined) {
-		return formatMessage(messages.fileCount, { count: diff.fileCount })
-	}
-	if (diff.type === 'modpack_updated') return diff.newVersionName
-	if (isConfigurationDiff(diff)) {
-		if (diff.currentVersionName && diff.newVersionName) {
-			return `${diff.currentVersionName} → ${diff.newVersionName}`
-		}
-		return diff.newVersionName ?? diff.currentVersionName
-	}
-	return diff.type === 'removed' ? diff.currentVersionName : diff.newVersionName
-}
-
 function show(e?: MouseEvent) {
 	modal.value?.show(e)
 }
@@ -392,14 +234,6 @@ const messages = defineMessages({
 		id: 'content.diff-modal.updated-count',
 		defaultMessage: '{count} updated',
 	},
-	noContentChanges: {
-		id: 'content.diff-modal.no-content-changes',
-		defaultMessage: 'No content changes',
-	},
-	fileCount: {
-		id: 'content.diff-modal.file-count',
-		defaultMessage: '{count, plural, one {# file} other {# files}}',
-	},
 	unknownContentBody: {
 		id: 'content.diff-modal.unknown-content-body',
 		defaultMessage:
@@ -414,10 +248,6 @@ const messages = defineMessages({
 		defaultMessage:
 			'This update contains files that aren’t published on Modrinth. We strongly recommend only installing files from sources you trust.',
 	},
-	unknownProject: {
-		id: 'content.diff-modal.unknown-project',
-		defaultMessage: 'Unknown',
-	},
 	reviewedFiles: {
 		id: 'content.diff-modal.reviewed-files',
 		defaultMessage: "Files that aren't published to Modrinth aren't reviewed.",
@@ -432,66 +262,5 @@ const messages = defineMessages({
 	},
 })
 
-const configurationDiffMessages = defineMessages({
-	modpack_linked: {
-		id: 'content.diff-modal.modpack-linked',
-		defaultMessage: 'Linked modpack',
-	},
-	modpack_updated: {
-		id: 'content.diff-modal.modpack-updated',
-		defaultMessage: 'Updated modpack',
-	},
-	modpack_unlinked: {
-		id: 'content.diff-modal.modpack-unlinked',
-		defaultMessage: 'Unlinked modpack',
-	},
-	game_version_updated: {
-		id: 'content.diff-modal.game-version-updated',
-		defaultMessage: 'Game version',
-	},
-	loader_updated: {
-		id: 'content.diff-modal.loader-updated',
-		defaultMessage: 'Loader',
-	},
-	config_files_updated: {
-		id: 'content.diff-modal.config-files-updated',
-		defaultMessage: 'Changed config files',
-	},
-})
-
-const diffTypeMessages = defineMessages({
-	added: {
-		id: 'content.diff-modal.diff-type.added',
-		defaultMessage: 'Added (dependency)',
-	},
-	removed: {
-		id: 'content.diff-modal.diff-type.removed',
-		defaultMessage: 'Disabled',
-	},
-	removedDisabled: {
-		id: 'content.diff-modal.diff-type.removed-disabled',
-		defaultMessage: 'Removed (disabled)',
-	},
-	updated: {
-		id: 'content.diff-modal.diff-type.updated',
-		defaultMessage: 'Updated',
-	},
-})
-
-const externalDiffTypeMessages = defineMessages({
-	added: {
-		id: 'content.diff-modal.external-diff-type.added',
-		defaultMessage: 'Added',
-	},
-	removed: {
-		id: 'content.diff-modal.external-diff-type.removed',
-		defaultMessage: 'Removed',
-	},
-	updated: {
-		id: 'content.diff-modal.external-diff-type.updated',
-		defaultMessage: 'Updated',
-	},
-})
-
 defineExpose({ show, hide })
 </script>
diff --git a/packages/ui/src/layouts/shared/installation-settings/index.ts b/packages/ui/src/layouts/shared/installation-settings/index.ts
index 8c63bff1cd6..77f2773b584 100644
--- a/packages/ui/src/layouts/shared/installation-settings/index.ts
+++ b/packages/ui/src/layouts/shared/installation-settings/index.ts
@@ -1,3 +1,4 @@
+export { default as ContentDiffList } from './components/ContentDiffList.vue'
 export { default as ContentDiffModal } from './components/ContentDiffModal.vue'
 export { useInstallationForm } from './composables'
 export { default as InstallationSettingsLayout } from './layout.vue'
diff --git a/packages/ui/src/layouts/shared/installation-settings/utils.ts b/packages/ui/src/layouts/shared/installation-settings/utils.ts
new file mode 100644
index 00000000000..364c253116e
--- /dev/null
+++ b/packages/ui/src/layouts/shared/installation-settings/utils.ts
@@ -0,0 +1,31 @@
+import type { ContentDiffItem } from './types'
+
+type DependencyDiffType = Extract<ContentDiffItem['type'], 'added' | 'removed' | 'updated'>
+type ConfigurationDiffType = Exclude<ContentDiffItem['type'], DependencyDiffType>
+
+const configurationDiffTypes = new Set<ConfigurationDiffType>([
+	'modpack_linked',
+	'modpack_updated',
+	'modpack_unlinked',
+	'game_version_updated',
+	'loader_updated',
+	'config_files_updated',
+])
+
+export function isDependencyDiff(
+	diff: ContentDiffItem,
+): diff is ContentDiffItem & { type: DependencyDiffType } {
+	return diff.type === 'added' || diff.type === 'removed' || diff.type === 'updated'
+}
+
+export function isConfigurationDiff(
+	diff: ContentDiffItem,
+): diff is ContentDiffItem & { type: ConfigurationDiffType } {
+	return configurationDiffTypes.has(diff.type as ConfigurationDiffType)
+}
+
+export function showsExternalWarning(diff: ContentDiffItem, showExternalWarnings?: boolean) {
+	return Boolean(
+		showExternalWarnings && diff.external && isDependencyDiff(diff) && diff.type !== 'removed',
+	)
+}
diff --git a/packages/ui/src/locales/en-US/index.json b/packages/ui/src/locales/en-US/index.json
index 8f551577726..7d568aa0289 100644
--- a/packages/ui/src/locales/en-US/index.json
+++ b/packages/ui/src/locales/en-US/index.json
@@ -498,7 +498,7 @@
     "defaultMessage": "{count} added"
   },
   "content.diff-modal.config-files-updated": {
-    "defaultMessage": "Changed config files"
+    "defaultMessage": "Changed files"
   },
   "content.diff-modal.diff-type.added": {
     "defaultMessage": "Added (dependency)"