graphics: fix Jusant regression from d8c4a9af3

graphics: add opt-in ZMask support and launcher rendering options
graphics: preserve HTILE metadata across native image replacement
2026-10-21 11:26:56 +02:00 · 2026-10-18 01:03:37 +02:00 · 2026-10-17 17:50:02 +02:00 · 2026-10-17 17:31:25 +02:00 · 2026-10-17 14:47:51 +02:00 · 2026-10-17 13:15:22 +02:00
223 changed files with 27110 additions and 4046 deletions
@@ -113,7 +113,7 @@ jobs:
        shell: cmd
        run: |
          cmake --build _Build/windows --target launcher ^
-            audio_out2_port_tests pad_haptics_tests controller_settings_tests ime_dialog_tests lru_cache_tests virtual_memory_allocation_tests ^
+            audio_out2_port_tests pad_haptics_tests controller_settings_tests host_input_tests ime_dialog_tests lru_cache_tests virtual_memory_allocation_tests ^
            shader_recompiler_compute_tests ^
            resource_tracking_tests scalar_provenance_tests ^
            resource_materialization_tests shader_vertex_metadata_tests archive_file_tests avplayer_file_tests --parallel
@@ -121,7 +121,7 @@ jobs:
      - name: Test
        shell: cmd
        run: |
-          ctest --test-dir _Build/windows --output-on-failure -R "^(audio_out2_port|pad_haptics|controller_settings|ime_dialog|lru_cache|resource_tracking|scalar_provenance|resource_materialization|shader_vertex_metadata|archive_file|avplayer_file|virtual_memory_allocation)$"
+          ctest --test-dir _Build/windows --output-on-failure -R "^(audio_out2_port|pad_haptics|controller_settings|host_input|ime_dialog|lru_cache|resource_tracking|scalar_provenance|resource_materialization|shader_vertex_metadata|archive_file|avplayer_file|virtual_memory_allocation)$"

      - name: Install
        shell: cmd
@@ -202,7 +202,7 @@ jobs:
        shell: bash
        run: |
          cmake --build _Build/macos \
-            --target launcher audio_out2_port_tests pad_haptics_tests controller_settings_tests ime_dialog_tests lru_cache_tests virtual_memory_allocation_tests \
+            --target launcher audio_out2_port_tests pad_haptics_tests controller_settings_tests host_input_tests ime_dialog_tests lru_cache_tests virtual_memory_allocation_tests \
              memory_tracker_tests page_manager_tests shader_recompiler_compute_tests \
              resource_tracking_tests scalar_provenance_tests \
              resource_materialization_tests shader_vertex_metadata_tests archive_file_tests avplayer_file_tests \
@@ -212,7 +212,7 @@ jobs:
        shell: bash
        run: |
          ctest --test-dir _Build/macos --output-on-failure \
-            -R '^(audio_out2_port|pad_haptics|controller_settings|ime_dialog|lru_cache|memory_tracker|page_manager|resource_tracking|scalar_provenance|resource_materialization|shader_vertex_metadata|archive_file|avplayer_file|virtual_memory_allocation)$'
+            -R '^(audio_out2_port|pad_haptics|controller_settings|host_input|ime_dialog|lru_cache|memory_tracker|page_manager|resource_tracking|scalar_provenance|resource_materialization|shader_vertex_metadata|archive_file|avplayer_file|virtual_memory_allocation)$'

      - name: Install
        shell: bash
@@ -388,7 +388,7 @@ jobs:
        run: |
          cmake --build _Build/linux \
            --target launcher page_manager_tests memory_tracker_tests \
-              audio_out2_port_tests pad_haptics_tests controller_settings_tests ime_dialog_tests lru_cache_tests virtual_memory_allocation_tests \
+              audio_out2_port_tests pad_haptics_tests controller_settings_tests host_input_tests ime_dialog_tests lru_cache_tests virtual_memory_allocation_tests \
              resource_tracking_tests scalar_provenance_tests \
              resource_materialization_tests shader_vertex_metadata_tests archive_file_tests avplayer_file_tests \
            --parallel
@@ -397,7 +397,7 @@ jobs:
        shell: bash
        run: |
          ctest --test-dir _Build/linux --output-on-failure \
-            -R '^(audio_out2_port|pad_haptics|controller_settings|ime_dialog|lru_cache|memory_tracker|page_manager|resource_tracking|scalar_provenance|resource_materialization|shader_vertex_metadata|archive_file|avplayer_file|virtual_memory_allocation)$'
+            -R '^(audio_out2_port|pad_haptics|controller_settings|host_input|ime_dialog|lru_cache|memory_tracker|page_manager|resource_tracking|scalar_provenance|resource_materialization|shader_vertex_metadata|archive_file|avplayer_file|virtual_memory_allocation)$'

      - name: Install
        shell: bash
@@ -407,12 +407,12 @@ jobs:
      - name: Verify artifacts
        shell: bash
        run: |
-          file _Build/linux/install/launcher
+          file _Build/linux/install/kyty_launcher
          file _Build/linux/install/kyty_emulator
          test -x _Build/linux/install/kyty_updater
          file _Build/linux/install/kyty_emulator | grep -q "ELF 64-bit LSB .*x86-64"
          ldd _Build/linux/install/kyty_emulator > /dev/null
-          readelf -d _Build/linux/install/launcher | grep -q 'RPATH.*\$ORIGIN/lib'
+          readelf -d _Build/linux/install/kyty_launcher | grep -q 'RPATH.*\$ORIGIN/lib'
          while IFS= read -r -d '' binary; do
            while read -r dependency; do
              test -e "_Build/linux/install/lib/$dependency"
@@ -421,8 +421,8 @@ jobs:
                sed -n 's/.*Shared library: \[\(libQt6[^]]*\|libicu[^]]*\)\].*/\1/p'
            )
          done < <(
-            find _Build/linux/install/launcher _Build/linux/install/plugins \
-              -type f \( -name launcher -o -name '*.so' \) -print0
+            find _Build/linux/install/kyty_launcher _Build/linux/install/plugins \
+              -type f \( -name kyty_launcher -o -name '*.so' \) -print0
          )
          _Build/linux/install/kyty_emulator --help > /dev/null

@@ -497,7 +497,7 @@ jobs:
          linux_dir="artifacts/KytyPS5-Linux-x86_64"
          test -d "$linux_dir"
          chmod a+x \
-            "$linux_dir/launcher" \
+            "$linux_dir/kyty_launcher" \
            "$linux_dir/kyty_emulator" \
            "$linux_dir/kyty_updater"
          tar -C "$linux_dir" -czf \
@@ -5,7 +5,7 @@
            "name": "Debug launcher UI",
            "type": "cppvsdbg",
            "request": "launch",
-            "program": "${workspaceFolder}\\_Build\\vscode-clang\\launcher\\launcher.exe",
+            "program": "${workspaceFolder}\\_Build\\vscode-clang\\launcher\\kyty_launcher.exe",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}\\_Build\\vscode-clang\\launcher",
@@ -13,7 +13,7 @@
            "externalConsole": false,
            "linux": {
                "type": "cppdbg",
-                "program": "${workspaceFolder}/_Build/vscode-clang/launcher/launcher",
+                "program": "${workspaceFolder}/_Build/vscode-clang/launcher/kyty_launcher",
                "cwd": "${workspaceFolder}/_Build/vscode-clang/launcher",
                "MIMode": "gdb",
                "miDebuggerPath": "/usr/bin/gdb"
@@ -350,7 +350,7 @@ set(inc_headers
 	${KYTY_THIRD_PARTY_DIR}/SPIRV-Tools/include
 	${KYTY_THIRD_PARTY_DIR}/SPIRV-Headers/include
 	${KYTY_THIRD_PARTY_DIR}/fmt/include
-	${KYTY_THIRD_PARTY_DIR}/xxhash
+	${KYTY_THIRD_PARTY_DIR}/xxHash
 	${KYTY_THIRD_PARTY_DIR}/cpuinfo/include
 	${KYTY_THIRD_PARTY_DIR}/renderdoc
 	${KYTY_THIRD_PARTY_DIR}/stb
@@ -432,6 +432,14 @@ add_executable(avplayer_file_tests EXCLUDE_FROM_ALL
 target_link_libraries(avplayer_file_tests common FFmpeg::ffmpeg ZArchive::zarchive)
 target_include_directories(avplayer_file_tests PRIVATE ${inc_headers})

+add_executable(vdecsw_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/VdecswTests.cpp"
+	"${KYTY_SOURCE_DIR}/libs/videoDec2Decoder.cpp"
+	"${KYTY_SOURCE_DIR}/loader/timer.cpp"
+)
+target_link_libraries(vdecsw_tests common FFmpeg::ffmpeg)
+target_include_directories(vdecsw_tests PRIVATE ${inc_headers})
+
 add_executable(bit_array_tests EXCLUDE_FROM_ALL
 	"${KYTY_TESTS_DIR}/BitArrayTests.cpp"
 )
@@ -518,6 +526,10 @@ add_executable(controller_settings_tests EXCLUDE_FROM_ALL
 target_link_libraries(controller_settings_tests common fmt::fmt SDL3::SDL3-static)
 target_include_directories(controller_settings_tests PRIVATE ${inc_headers})

+add_executable(host_input_tests EXCLUDE_FROM_ALL "${KYTY_TESTS_DIR}/HostInputTests.cpp")
+target_link_libraries(host_input_tests common fmt::fmt SDL3::SDL3-static)
+target_include_directories(host_input_tests PRIVATE ${inc_headers})
+
 add_executable(save_data_memory_tests EXCLUDE_FROM_ALL
 	"${KYTY_TESTS_DIR}/SaveDataMemoryTests.cpp"
 )
@@ -622,6 +634,7 @@ if(BUILD_TESTING)
 	add_test(NAME archive_file COMMAND $<TARGET_FILE:archive_file_tests>)
 	add_test(NAME trophy_system COMMAND $<TARGET_FILE:trophy_system_tests>)
 	add_test(NAME avplayer_file COMMAND $<TARGET_FILE:avplayer_file_tests>)
+	add_test(NAME vdecsw COMMAND $<TARGET_FILE:vdecsw_tests>)
 	add_test(NAME bit_array COMMAND $<TARGET_FILE:bit_array_tests>)
 	add_test(NAME lru_cache COMMAND $<TARGET_FILE:lru_cache_tests>)
 	add_test(NAME shader_vertex_metadata COMMAND $<TARGET_FILE:shader_vertex_metadata_tests>)
@@ -635,6 +648,7 @@ if(BUILD_TESTING)
 	add_test(NAME ngs2_sampler COMMAND $<TARGET_FILE:ngs2_sampler_tests>)
 	add_test(NAME pad_haptics COMMAND $<TARGET_FILE:pad_haptics_tests>)
 	add_test(NAME controller_settings COMMAND $<TARGET_FILE:controller_settings_tests>)
+	add_test(NAME host_input COMMAND $<TARGET_FILE:host_input_tests>)
 	add_test(NAME save_data_memory COMMAND $<TARGET_FILE:save_data_memory_tests>)
 	add_test(NAME png_enc COMMAND $<TARGET_FILE:png_enc_tests>)
 	add_test(NAME ces COMMAND $<TARGET_FILE:ces_tests>)
@@ -698,6 +712,7 @@ if(BUILD_TESTING)
 		archive_file_tests
 		trophy_system_tests
 		avplayer_file_tests
+		vdecsw_tests
 		bit_array_tests
 		lru_cache_tests
 		shader_vertex_metadata_tests
@@ -713,6 +728,7 @@ if(BUILD_TESTING)
 		ngs2_sampler_tests
 		pad_haptics_tests
 		controller_settings_tests
+		host_input_tests
 		save_data_memory_tests
 		png_enc_tests
 		ces_tests
@@ -750,6 +766,14 @@ add_custom_target(kyty_trophy_sound
 add_dependencies(kyty_emulator kyty_trophy_sound)
 install(FILES "${KYTY_TROPHY_UNLOCK_SOUND}" DESTINATION assets/sounds)

+add_custom_target(kyty_touch_cursors
+	COMMAND ${CMAKE_COMMAND} -E copy_directory
+		"${CMAKE_CURRENT_SOURCE_DIR}/assets/cursors"
+		"$<TARGET_FILE_DIR:kyty_emulator>/assets/cursors"
+	VERBATIM)
+add_dependencies(kyty_emulator kyty_touch_cursors)
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/assets/cursors" DESTINATION assets)
+
 target_link_libraries(kyty_emulator ${kyty_emulator_link_libraries})
 if (WIN32)
 	target_link_libraries(kyty_emulator opengl32)
@@ -275,11 +275,11 @@ From the repository root, follow the launcher configure, build and install steps
 [Building on Linux](#building-on-linux), omitting `-DCMAKE_PREFIX_PATH="$Qt6_DIR"`; CMake finds
 Fedora's packaged Qt 6 automatically.

-Run `./_Build/linux/install/launcher` on regular Fedora or inside the container. To launch a
+Run `./_Build/linux/install/kyty_launcher` on regular Fedora or inside the container. To launch a
 container build from the host, leave the container with `exit`, then run from the repository root:

 ```bash
-distrobox enter kyty-build -- ./_Build/linux/install/launcher
+distrobox enter kyty-build -- ./_Build/linux/install/kyty_launcher
 ```

 Qt libraries and plugins are bundled. You can also launch directly on a Fedora Atomic host
@@ -345,7 +345,7 @@ Use `_Build/linux` instead of `_Build/windows` for a Linux build.

 A ready-made Visual Studio Code setup is included in [`.vscode`](.vscode). It configures CMake
 Tools to build the project with Ninja and `clang-cl` and provides launch profiles for both
-`launcher.exe` and `kyty_emulator.exe`. It is Windows-only: VS Code settings cannot select a
+`kyty_launcher.exe` and `kyty_emulator.exe`. It is Windows-only: VS Code settings cannot select a
 compiler per platform, so on Linux configure from the command line as shown above.

 Before using it:
@@ -365,11 +365,11 @@ Update your graphics driver before reporting rendering problems.
 To use the graphical launcher:

 ```powershell
-.\_Build\windows\install\launcher.exe
+.\_Build\windows\install\kyty_launcher.exe
 ```

 ```bash
-./_Build/linux/install/launcher
+./_Build/linux/install/kyty_launcher
 ```

 ```bash
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "تم كسب الكأس!",
+  "user.guest": "ضيف"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Trofej získána!",
+  "user.guest": "Host"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Trofæ optjent!",
+  "user.guest": "Gæst"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Trophäe erhalten!",
+  "user.guest": "Gast"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Κερδίσατε ένα τρόπαιο!",
+  "user.guest": "Επισκ."
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Trophy earned!",
+  "user.guest": "Guest"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Trophy earned!",
+  "user.guest": "Guest"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "¡Ganaste un trofeo!",
+  "user.guest": "Invitado"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "¡Ganaste un trofeo!",
+  "user.guest": "Invitado"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Pokaali ansaittu!",
+  "user.guest": "Vieras"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Trophée obtenu !",
+  "user.guest": "Invité"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Trophée obtenu !",
+  "user.guest": "Invité"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Trófea megszerezve!",
+  "user.guest": "Vendég"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Trofi diperoleh!",
+  "user.guest": "Tamu"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Trofeo ottenuto!",
+  "user.guest": "Ospite"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "トロフィーを獲得しました！",
+  "user.guest": "ゲスト"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "트로피를 획득했습니다!",
+  "user.guest": "게스트"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Trofee behaald!",
+  "user.guest": "Gast"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Trofé opptjent!",
+  "user.guest": "Gjest"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Zdobyto trofeum!",
+  "user.guest": "Gość"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Troféu conquistado!",
+  "user.guest": "Convidado"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Troféu conquistado!",
+  "user.guest": "Convidado"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Trofeu câștigat!",
+  "user.guest": "Invitat"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Трофей получен!",
+  "user.guest": "Гость"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Trofé intjänad!",
+  "user.guest": "Gäst"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "ได้รับถ้วยรางวัลแล้ว!",
+  "user.guest": "แขก"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Kupa kazanıldı!",
+  "user.guest": "Misafir"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "Đã nhận cúp!",
+  "user.guest": "Khách"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "已获得奖杯！",
+  "user.guest": "访客"
+}
@@ -0,0 +1,4 @@
+{
+  "trophy.toast.earned": "已獲得獎盃！",
+  "user.guest": "訪客"
+}
@@ -0,0 +1,20 @@
+# Notification localization
+
+Trophy notification subtitles use the configured console language. Trophy names still come
+from the game's metadata. The launcher trophy dialogs are unchanged.
+
+Edit `assets/localization/<locale>.json`, using flat UTF-8 string values:
+
+```json
+{
+  "trophy.toast.earned": "Trophy earned!"
+}
+```
+
+CMake converts the catalogs into C++ byte arrays in the build directory. The emulator parses
+the embedded catalogs once and falls back to `en-US.json` for missing translations. No language
+files or translation service are needed at runtime. Rebuild after editing a catalog.
+
+For local testing, rebuild `kyty_emulator`, choose a game's Console Language in the launcher,
+and unlock a trophy with notifications enabled. Installed system fonts provide non-Latin
+glyphs; the selected language needs an appropriate font on the host.
@@ -12,9 +12,23 @@ endif()

 add_library(common STATIC ${common_src} ${common_headers})

+set(localization_dir "${PROJECT_SOURCE_DIR}/assets/localization")
+file(GLOB localization_catalogs CONFIGURE_DEPENDS "${localization_dir}/*.json")
+set(localization_data "${CMAKE_CURRENT_BINARY_DIR}/localizationData.h")
+add_custom_command(
+	OUTPUT "${localization_data}"
+	COMMAND ${CMAKE_COMMAND} "-DINPUTS=${localization_catalogs}" "-DOUTPUT=${localization_data}"
+		-P "${KYTY_SOURCE_DIR}/embed_localization.cmake"
+	DEPENDS ${localization_catalogs} "${KYTY_SOURCE_DIR}/embed_localization.cmake"
+	COMMENT "Embed notification localization catalogs"
+	VERBATIM
+)
+target_sources(common PRIVATE "${localization_data}")
+
 target_include_directories(common
 	PUBLIC ${KYTY_SOURCE_DIR}
 	PRIVATE
+		${CMAKE_CURRENT_BINARY_DIR}
 		${KYTY_THIRD_PARTY_DIR}/cpuinfo/include
 )

@@ -29,6 +43,10 @@ target_link_libraries(common
 		ZArchive::zarchive
 		nlohmann_json::nlohmann_json
 )
+if(APPLE)
+	# hostStats.cpp reads GPU utilization from the IOAccelerator registry entries.
+	target_link_libraries(common PRIVATE "-framework CoreFoundation" "-framework IOKit")
+endif()

 get_property(inc_headers TARGET common PROPERTY INCLUDE_DIRECTORIES)
 set(check_headers ${CMAKE_CURRENT_SOURCE_DIR})
@@ -0,0 +1,112 @@
+#include "common/additionalContent.h"
+
+#include "common/stringUtils.h"
+
+#include <algorithm>
+#include <fstream>
+#include <map>
+#include <nlohmann/json.hpp>
+#include <regex>
+#include <system_error>
+
+namespace Common {
+
+namespace {
+
+std::string GetString(const nlohmann::json& object, const std::string& key) {
+	const auto it = object.find(key);
+	return it != object.end() && it->is_string() ? it->get<std::string>() : std::string {};
+}
+
+std::string GetTitle(const nlohmann::json& param) {
+	const auto localized = param.find("localizedParameters");
+	if (localized != param.end() && localized->is_object()) {
+		const auto preferred = localized->find(GetString(*localized, "defaultLanguage"));
+		if (preferred != localized->end()) {
+			if (auto title = GetString(*preferred, "titleName"); !title.empty()) {
+				return title;
+			}
+		}
+		for (const auto& language: *localized) {
+			if (auto title = GetString(language, "titleName"); !title.empty()) {
+				return title;
+			}
+		}
+	}
+	return GetString(param, "titleName");
+}
+
+} // namespace
+
+std::vector<AddContentEntry> FindAddContent(const std::filesystem::path& dir,
+                                            const std::string&           title_id) {
+	if (dir.empty() || title_id.empty()) {
+		return {};
+	}
+
+	std::error_code ec;
+	const auto      root = std::filesystem::absolute(dir, ec);
+	if (ec) {
+		return {};
+	}
+
+	// Scan directories separately so an unreadable child does not discard its siblings.
+	std::vector<std::filesystem::path> pending {root};
+	std::vector<std::filesystem::path> params;
+	while (!pending.empty()) {
+		const auto current = std::move(pending.back());
+		pending.pop_back();
+		std::filesystem::directory_iterator it(
+		    current, std::filesystem::directory_options::skip_permission_denied, ec);
+		const std::filesystem::directory_iterator end;
+		for (; !ec && it != end; it.increment(ec)) {
+			std::error_code entry_ec;
+			if (it->is_directory(entry_ec) && !it->is_symlink(entry_ec) && !entry_ec) {
+				pending.push_back(it->path());
+			} else if (it->is_regular_file(entry_ec) && !entry_ec &&
+			           EqualNoCase(PathToString(it->path().filename()), "param.json") &&
+			           EqualNoCase(PathToString(it->path().parent_path().filename()), "sce_sys")) {
+				params.push_back(it->path());
+			}
+		}
+	}
+	std::sort(params.begin(), params.end());
+
+	static const std::regex content_id_pattern(
+	    "^[A-Z]{2}[0-9]{4}-[A-Z]{4}[0-9]{5}_[0-9]{2}-[A-Z0-9]{16}$");
+	std::map<std::string, AddContentEntry> by_label;
+	for (const auto& file: params) {
+		const auto size = std::filesystem::file_size(file, ec);
+		if (ec || size > 1024 * 1024) {
+			continue;
+		}
+		std::ifstream stream(file, std::ios::binary);
+		if (!stream) {
+			continue;
+		}
+		const auto param = nlohmann::json::parse(stream, nullptr, false);
+		// applicationCategoryType is required for applications, not additional content.
+		if (!param.is_object() || param.contains("applicationCategoryType")) {
+			continue;
+		}
+		const auto content_id = GetString(param, "contentId");
+		if (!std::regex_match(content_id, content_id_pattern) ||
+		    content_id.compare(7, 9, title_id) != 0) {
+			continue;
+		}
+
+		const auto mount_dir = file.parent_path().parent_path();
+		const auto label     = content_id.substr(20);
+		by_label.try_emplace(label,
+		                     AddContentEntry {content_id, label, mount_dir, GetTitle(param)});
+	}
+
+	std::vector<AddContentEntry> entries;
+	entries.reserve(by_label.size());
+	for (auto& [label, entry]: by_label) {
+		entries.push_back(std::move(entry));
+	}
+	return entries;
+}
+
+} // namespace Common
@@ -0,0 +1,23 @@
+#ifndef KYTY_COMMON_ADDITIONAL_CONTENT_H_
+#define KYTY_COMMON_ADDITIONAL_CONTENT_H_
+
+#include <filesystem>
+#include <string>
+#include <vector>
+
+namespace Common {
+
+struct AddContentEntry {
+	std::string           content_id;
+	std::string           entitlement_label;
+	std::filesystem::path mount_dir;
+	std::string           title;
+};
+
+// Finds packages for this title, deduplicated by entitlement label.
+std::vector<AddContentEntry> FindAddContent(const std::filesystem::path& dir,
+                                            const std::string&           title_id);
+
+} // namespace Common
+
+#endif /* KYTY_COMMON_ADDITIONAL_CONTENT_H_ */
@@ -0,0 +1,117 @@
+#ifndef KYTY_COMMON_DEBUG_COUNTERS_H_
+#define KYTY_COMMON_DEBUG_COUNTERS_H_
+
+#include <atomic>
+#include <chrono>
+#include <cstdint>
+
+namespace Common::DebugCounters {
+
+static_assert(std::atomic<uint64_t>::is_always_lock_free && std::atomic<bool>::is_always_lock_free);
+
+// Collect events only while the panel is visible. Relaxed, lock-free atomics keep updates
+// cheap and safe in signal handlers. Rates come from comparing two snapshots.
+enum class Counter {
+	// GPU work.
+	Draws,
+	DrawInstances,
+	IndirectDraws,
+	Dispatches,
+	QueueSubmits,
+	GpuWaits, // CPU blocked on a GPU timeline semaphore.
+	GpuWaitNs,
+	GpuFaults, // Guest writes to GPU-tracked memory.
+	ShadersCompiled,
+	ShaderCompileNs,
+	PipelinesCreated,
+	PipelineCreateNs,
+	// Caches.
+	TextureUploadBytes,
+	TextureDownloadBytes,
+	TextureEvictions,
+	BufferUploadBytes,
+	BufferDownloadBytes,
+	BufferEvictions,
+	// Presentation.
+	FlipsRequested,
+	FlipsRejected, // Guest flip queue was full.
+	LateVblanks,   // The present thread fell behind the vblank rate.
+	SwapchainRecreations,
+	DroppedPresents,
+	// Emulator.
+	EmulatedInstructions, // Host CPU lacked an instruction the guest used.
+	UnresolvedImportCalls,
+	GuestFileReadBytes,
+	GuestFileWriteBytes,
+	AudioUnderruns,
+	Count
+};
+
+enum class Peak { ShaderCompileNs, PipelineCreateNs, Count };
+
+namespace Detail {
+inline std::atomic<bool>     g_enabled {false};
+inline std::atomic<uint64_t> g_counters[static_cast<int>(Counter::Count)] {};
+inline std::atomic<uint64_t> g_peaks[static_cast<int>(Peak::Count)] {};
+} // namespace Detail
+
+[[nodiscard]] inline bool Enabled() noexcept {
+	return Detail::g_enabled.load(std::memory_order_relaxed);
+}
+
+inline void SetEnabled(bool enabled) noexcept {
+	Detail::g_enabled.store(enabled, std::memory_order_relaxed);
+}
+
+inline void Add(Counter counter, uint64_t value = 1) noexcept {
+	if (!Enabled()) {
+		return;
+	}
+	Detail::g_counters[static_cast<int>(counter)].fetch_add(value, std::memory_order_relaxed);
+}
+
+class ScopedTimer final {
+public:
+	ScopedTimer(Counter count, Counter duration, Peak peak = Peak::Count)
+	    : m_count(count), m_duration(duration), m_peak(peak),
+	      m_start(Enabled() ? std::chrono::steady_clock::now()
+	                        : std::chrono::steady_clock::time_point {}) {}
+	~ScopedTimer() {
+		if (m_start == std::chrono::steady_clock::time_point {} || !Enabled()) {
+			return;
+		}
+		const auto elapsed =
+		    static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(
+		                              std::chrono::steady_clock::now() - m_start)
+		                              .count());
+		Add(m_count);
+		Add(m_duration, elapsed);
+		if (m_peak != Peak::Count) {
+			auto& peak     = Detail::g_peaks[static_cast<int>(m_peak)];
+			auto  previous = peak.load(std::memory_order_relaxed);
+			while (previous < elapsed &&
+			       !peak.compare_exchange_weak(previous, elapsed, std::memory_order_relaxed)) {
+			}
+		}
+	}
+	ScopedTimer(const ScopedTimer&)            = delete;
+	ScopedTimer& operator=(const ScopedTimer&) = delete;
+
+private:
+	Counter                               m_count;
+	Counter                               m_duration;
+	Peak                                  m_peak;
+	std::chrono::steady_clock::time_point m_start;
+};
+
+[[nodiscard]] inline uint64_t Get(Counter counter) noexcept {
+	return Detail::g_counters[static_cast<int>(counter)].load(std::memory_order_relaxed);
+}
+
+[[nodiscard]] inline uint64_t Get(Peak peak) noexcept {
+	return Detail::g_peaks[static_cast<int>(peak)].load(std::memory_order_relaxed);
+}
+
+} // namespace Common::DebugCounters
+
+#endif /* KYTY_COMMON_DEBUG_COUNTERS_H_ */
@@ -1,6 +1,7 @@
 #include "common/emulatorConfig.h"

 #include "common/assert.h"
+#include "common/debugCounters.h"

 #include <algorithm>
 #include <memory>
@@ -16,6 +17,7 @@ void Initialize() {
 }

 void Shutdown() {
+	Common::DebugCounters::SetEnabled(false);
 	g_config.reset();
 }

@@ -24,8 +26,10 @@ void Load(const ConfigOptions& cfg) {
 	EXIT_IF(cfg.user_name.empty() || cfg.user_name.size() > MAX_USER_NAME_LENGTH);
 	EXIT_IF(!IsConfiguredUserIdValid(cfg.user_id));
 	EXIT_IF(cfg.controller_speaker_volume > 100 || cfg.controller_vibration_intensity > 100);
+	EXIT_IF(cfg.keyboard_player > static_cast<uint32_t>(MAX_PLAYERS));

 	*g_config = cfg;
+	Common::DebugCounters::SetEnabled(cfg.perf_overlay_enabled);
 }

 uint32_t GetScreenWidth() {
@@ -60,6 +64,27 @@ uint32_t GetControllerVibrationIntensity() {
 	return g_config->controller_vibration_intensity;
 }

+uint32_t GetKeyboardPlayer() {
+	return g_config->keyboard_player;
+}
+
+int32_t GetPlayerUserId(int player) {
+	return g_config->user_id + player * PLAYER_USER_ID_STEP;
+}
+
+int GetPlayerFromUserId(int32_t user_id) {
+	for (int player = 0; player < MAX_PLAYERS; player++) {
+		if (user_id == GetPlayerUserId(player)) {
+			return player;
+		}
+	}
+	return -1;
+}
+
+bool IsGuestUserId(int32_t user_id) {
+	return GetPlayerFromUserId(user_id) > 0;
+}
+
 PresentMode GetPresentMode() {
 	return g_config->present_mode;
 }
@@ -164,6 +189,10 @@ bool SyncRawImageBuffersEnabled() {
 	return g_config->sync_raw_image_buffers;
 }

+bool SupportZmaskEnabled() {
+	return g_config->support_zmask;
+}
+
 bool TessellationEnabled() {
 	return g_config->tessellation_enabled;
 }
@@ -172,6 +201,10 @@ bool TrophyEnabled() {
 	return g_config->trophy_enabled;
 }

+uint32_t GetTrophyDurationSeconds() {
+	return std::clamp(g_config->trophy_duration_seconds, 5u, 10u);
+}
+
 bool PlayGoHackEnabled() {
 	return g_config->playgo_hack_enabled;
 }
@@ -6,6 +6,7 @@
 #include <cstddef>
 #include <array>
 #include <filesystem>
+#include <limits>
 #include <optional>
 #include <string>
 #include <vector>
@@ -35,10 +36,16 @@ constexpr uint32_t MAX_CONSOLE_LANGUAGE     = 29;
 constexpr std::size_t MAX_USER_NAME_LENGTH = 16;
 constexpr int32_t DEFAULT_USER_ID           = 1000;

+constexpr int     MAX_PLAYERS         = 4;
+constexpr int32_t PLAYER_USER_ID_STEP = 0x100;
+constexpr int32_t MAX_USER_ID =
+    std::numeric_limits<int32_t>::max() - (MAX_PLAYERS - 1) * PLAYER_USER_ID_STEP;
+
 constexpr bool IsConfiguredUserIdValid(int32_t user_id) {
 	constexpr int32_t USER_ID_EVERYONE = 0xfe;
 	constexpr int32_t USER_ID_SYSTEM   = 0xff;
-	return user_id >= 0 && user_id != USER_ID_EVERYONE && user_id != USER_ID_SYSTEM;
+	return user_id >= 0 && user_id <= MAX_USER_ID && user_id != USER_ID_EVERYONE &&
+	       user_id != USER_ID_SYSTEM;
 }

 struct ConfigOptions {
@@ -50,6 +57,8 @@ struct ConfigOptions {
 	std::optional<ControllerColor> controller_color;
 	uint32_t               controller_speaker_volume      = 50;
 	uint32_t               controller_vibration_intensity = 100;
+	// 0 shares player 1 with the first gamepad; 1..MAX_PLAYERS dedicates that player to the keyboard.
+	uint32_t               keyboard_player                = 0;
 	PresentMode            present_mode                = PresentMode::Mailbox;
 	int32_t                gpu_index                   = -1;
 	bool                   fullscreen_enabled          = false;
@@ -77,8 +86,11 @@ struct ConfigOptions {
 	bool                   renderdoc_enabled           = false;
 	bool                   readback_linear_images      = false;
 	bool                   sync_raw_image_buffers      = false;
+	bool                   support_zmask               = false;
 	bool                   tessellation_enabled        = false;
 	bool                   trophy_enabled              = true;
+	uint32_t               trophy_duration_seconds     = 6;
+	bool                   perf_overlay_enabled            = false;
 	bool                   playgo_hack_enabled         = false;
 	bool                   skip_notice_screen          = false;
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
@@ -99,6 +111,13 @@ const std::string& GetAudioInputDevice();
 const std::optional<ControllerColor>& GetControllerColor();
 uint32_t GetControllerSpeakerVolume();
 uint32_t GetControllerVibrationIntensity();
+uint32_t GetKeyboardPlayer();
+// Player 0 is the configured user; later players derive their IDs from it.
+int32_t  GetPlayerUserId(int player);
+// Returns -1 when the user ID does not belong to any player.
+int      GetPlayerFromUserId(int32_t user_id);
+// Players after the first are guests: they have no profile, trophies or NP account.
+bool     IsGuestUserId(int32_t user_id);
 PresentMode GetPresentMode();
 int32_t GetGpuIndex();
 bool     FullscreenEnabled();
@@ -133,8 +152,10 @@ bool GpuAssistedValidationEnabled();
 bool RenderDocEnabled();
 bool ReadbackLinearImagesEnabled();
 bool SyncRawImageBuffersEnabled();
+bool SupportZmaskEnabled();
 bool TessellationEnabled();
 bool TrophyEnabled();
+uint32_t GetTrophyDurationSeconds();
 bool PlayGoHackEnabled();
 bool SkipNoticeScreen();
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
@@ -0,0 +1,580 @@
+#include "common/hostStats.h"
+
+#include "common/config.h"
+
+#include <algorithm>
+#include <chrono>
+#include <thread>
+#include <unordered_map>
+
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h> // IWYU pragma: keep
+// clang-format off
+#include <psapi.h>
+// clang-format on
+#elif defined(__APPLE__)
+#include <CoreFoundation/CoreFoundation.h>
+#include <IOKit/IOKitLib.h>
+#include <cstring>
+#include <libproc.h>
+#include <mach/mach.h>
+#include <notify.h>
+#include <sys/resource.h>
+#include <sys/sysctl.h>
+#include <unistd.h>
+#else
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <sys/resource.h>
+#include <unistd.h>
+#endif
+
+namespace Common {
+
+namespace {
+
+// Cumulative counters; rates come from the difference between two samples.
+struct Counters {
+	struct Thread {
+		uint64_t    cpu_ns;
+		std::string name;
+	};
+	std::optional<uint64_t>              process_cpu_ns;
+	std::optional<uint64_t>              system_busy;
+	std::optional<uint64_t>              system_total;
+	std::optional<uint64_t>              context_switches;
+	std::optional<uint64_t>              page_faults;
+	std::optional<uint64_t>              page_ins;
+	std::optional<uint64_t>              disk_read;
+	std::optional<uint64_t>              disk_write;
+	std::unordered_map<uint64_t, Thread> threads;
+	uint64_t                             wall_ns = 0;
+};
+
+uint64_t WallNanoseconds() {
+	return static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(
+	                                 std::chrono::steady_clock::now().time_since_epoch())
+	                                 .count());
+}
+
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+
+uint64_t FileTimeTo100Ns(const FILETIME& time) {
+	return (static_cast<uint64_t>(time.dwHighDateTime) << 32u) | time.dwLowDateTime;
+}
+
+struct PlatformState {};
+
+void SamplePlatform(PlatformState& /*state*/, HostStats& stats, Counters& now) {
+	const auto process = GetCurrentProcess();
+	FILETIME   creation {};
+	FILETIME   exit {};
+	FILETIME   kernel {};
+	FILETIME   user {};
+	if (GetProcessTimes(process, &creation, &exit, &kernel, &user) != 0) {
+		now.process_cpu_ns = (FileTimeTo100Ns(kernel) + FileTimeTo100Ns(user)) * 100u;
+	}
+	FILETIME idle {};
+	if (GetSystemTimes(&idle, &kernel, &user) != 0) {
+		// Kernel time includes idle time.
+		now.system_total = FileTimeTo100Ns(kernel) + FileTimeTo100Ns(user);
+		now.system_busy  = *now.system_total - FileTimeTo100Ns(idle);
+	}
+
+	PROCESS_MEMORY_COUNTERS memory {};
+	if (K32GetProcessMemoryInfo(process, &memory, sizeof(memory)) != 0) {
+		stats.process_memory   = memory.WorkingSetSize;
+		stats.process_resident = memory.WorkingSetSize;
+		now.page_faults        = memory.PageFaultCount;
+	}
+	IO_COUNTERS io {};
+	if (GetProcessIoCounters(process, &io) != 0) {
+		now.disk_read  = io.ReadTransferCount;
+		now.disk_write = io.WriteTransferCount;
+	}
+
+	MEMORYSTATUSEX system {};
+	system.dwLength = sizeof(system);
+	if (GlobalMemoryStatusEx(&system) != 0) {
+		stats.system_memory_total = system.ullTotalPhys;
+		stats.system_memory_used  = system.ullTotalPhys - system.ullAvailPhys;
+		stats.system_free         = system.ullAvailPhys;
+		stats.memory_pressure     = system.dwMemoryLoad >= 90   ? MemoryPressure::Critical
+		                            : system.dwMemoryLoad >= 80 ? MemoryPressure::Warning
+		                                                        : MemoryPressure::Normal;
+	}
+}
+
+#else
+
+void SampleRusage(Counters& now) {
+	rusage usage {};
+	if (getrusage(RUSAGE_SELF, &usage) != 0) {
+		return;
+	}
+	const auto to_ns = [](const timeval& time) {
+		return static_cast<uint64_t>(time.tv_sec) * 1000000000u +
+		       static_cast<uint64_t>(time.tv_usec) * 1000u;
+	};
+	now.process_cpu_ns   = to_ns(usage.ru_utime) + to_ns(usage.ru_stime);
+	now.context_switches = static_cast<uint64_t>(usage.ru_nvcsw + usage.ru_nivcsw);
+	now.page_faults      = static_cast<uint64_t>(usage.ru_minflt + usage.ru_majflt);
+	now.page_ins         = static_cast<uint64_t>(usage.ru_majflt);
+}
+
+#if defined(__APPLE__)
+
+template <typename T>
+std::optional<T> SysctlValue(const char* name) {
+	T      value {};
+	size_t size = sizeof(value);
+	if (sysctlbyname(name, &value, &size, nullptr, 0) != 0 || size != sizeof(value)) {
+		return std::nullopt;
+	}
+	return value;
+}
+
+struct PlatformState {
+	mach_port_t             host          = mach_host_self();
+	int                     thermal_token = -1;
+	bool                    thermal_ready = false;
+	std::string             gpu_model;
+	std::optional<uint32_t> gpu_cores;
+
+	~PlatformState() {
+		if (thermal_ready) {
+			notify_cancel(thermal_token);
+		}
+		mach_port_deallocate(mach_task_self(), host);
+	}
+};
+
+std::optional<int64_t> DictionaryNumber(CFDictionaryRef dictionary, CFStringRef key) {
+	const auto* value  = CFDictionaryGetValue(dictionary, key);
+	int64_t     number = 0;
+	if (value == nullptr || CFGetTypeID(value) != CFNumberGetTypeID() ||
+	    !CFNumberGetValue(static_cast<CFNumberRef>(value), kCFNumberSInt64Type, &number) ||
+	    number < 0) {
+		return std::nullopt;
+	}
+	return number;
+}
+
+std::string RegistryString(io_object_t service, CFStringRef key) {
+	std::string result;
+	auto*       value = IORegistryEntryCreateCFProperty(service, key, kCFAllocatorDefault, 0);
+	if (value == nullptr) {
+		return result;
+	}
+	if (CFGetTypeID(value) == CFStringGetTypeID()) {
+		char buffer[128] {};
+		if (CFStringGetCString(static_cast<CFStringRef>(value), buffer, sizeof(buffer),
+		                       kCFStringEncodingUTF8)) {
+			result = buffer;
+		}
+	} else if (CFGetTypeID(value) == CFDataGetTypeID()) {
+		// Intel Macs store the model as NUL-terminated data.
+		const auto* data   = static_cast<CFDataRef>(value);
+		const auto* bytes  = reinterpret_cast<const char*>(CFDataGetBytePtr(data));
+		const auto  length = static_cast<size_t>(CFDataGetLength(data));
+		result.assign(bytes, strnlen(bytes, length));
+	}
+	CFRelease(value);
+	return result;
+}
+
+// IOAccelerator exposes whole-device statistics; there is no per-process figure.
+void SampleGpu(PlatformState& state, HostStats& stats) {
+	io_iterator_t iterator = 0;
+	if (IOServiceGetMatchingServices(MACH_PORT_NULL, IOServiceMatching("IOAccelerator"),
+	                                 &iterator) != KERN_SUCCESS) {
+		return;
+	}
+	const auto take_max = [](std::optional<double>& target, std::optional<int64_t> value) {
+		if (value) {
+			target = std::max(target.value_or(0.0), std::min(100.0, static_cast<double>(*value)));
+		}
+	};
+	const auto add = [](std::optional<uint64_t>& target, std::optional<int64_t> value) {
+		if (value) {
+			target = target.value_or(0) + static_cast<uint64_t>(*value);
+		}
+	};
+	for (io_object_t service = IOIteratorNext(iterator); service != 0;
+	     service             = IOIteratorNext(iterator)) {
+		if (state.gpu_model.empty()) {
+			state.gpu_model = RegistryString(service, CFSTR("model"));
+			auto*   cores   = IORegistryEntryCreateCFProperty(service, CFSTR("gpu-core-count"),
+			                                                  kCFAllocatorDefault, 0);
+			int64_t count   = 0;
+			if (cores != nullptr) {
+				if (CFGetTypeID(cores) == CFNumberGetTypeID() &&
+				    CFNumberGetValue(static_cast<CFNumberRef>(cores), kCFNumberSInt64Type,
+				                     &count) &&
+				    count > 0) {
+					state.gpu_cores = static_cast<uint32_t>(count);
+				}
+				CFRelease(cores);
+			}
+		}
+		auto* statistics = IORegistryEntryCreateCFProperty(service, CFSTR("PerformanceStatistics"),
+		                                                   kCFAllocatorDefault, 0);
+		if (statistics != nullptr) {
+			if (CFGetTypeID(statistics) == CFDictionaryGetTypeID()) {
+				const auto* values = static_cast<CFDictionaryRef>(statistics);
+				take_max(stats.gpu_percent,
+				         DictionaryNumber(values, CFSTR("Device Utilization %")));
+				take_max(stats.gpu_renderer_percent,
+				         DictionaryNumber(values, CFSTR("Renderer Utilization %")));
+				take_max(stats.gpu_tiler_percent,
+				         DictionaryNumber(values, CFSTR("Tiler Utilization %")));
+				add(stats.gpu_memory_in_use,
+				    DictionaryNumber(values, CFSTR("In use system memory")));
+				add(stats.gpu_memory_allocated,
+				    DictionaryNumber(values, CFSTR("Alloc system memory")));
+				add(stats.gpu_recoveries, DictionaryNumber(values, CFSTR("recoveryCount")));
+			}
+			CFRelease(statistics);
+		}
+		IOObjectRelease(service);
+	}
+	IOObjectRelease(iterator);
+	stats.gpu_model = state.gpu_model;
+	stats.gpu_cores = state.gpu_cores;
+}
+
+void SampleThreads(HostStats& stats, Counters& now) {
+	thread_act_array_t     threads = nullptr;
+	mach_msg_type_number_t count   = 0;
+	const auto             task    = mach_task_self();
+	if (task_threads(task, &threads, &count) != KERN_SUCCESS) {
+		return;
+	}
+	stats.thread_count = count;
+	for (mach_msg_type_number_t i = 0; i < count; i++) {
+		thread_identifier_info_data_t identifier {};
+		mach_msg_type_number_t        size = THREAD_IDENTIFIER_INFO_COUNT;
+		thread_basic_info_data_t      basic {};
+		mach_msg_type_number_t        basic_size = THREAD_BASIC_INFO_COUNT;
+		if (thread_info(threads[i], THREAD_IDENTIFIER_INFO,
+		                reinterpret_cast<thread_info_t>(&identifier), &size) == KERN_SUCCESS &&
+		    thread_info(threads[i], THREAD_BASIC_INFO, reinterpret_cast<thread_info_t>(&basic),
+		                &basic_size) == KERN_SUCCESS) {
+			const auto to_ns = [](const time_value_t& time) {
+				return static_cast<uint64_t>(time.seconds) * 1000000000u +
+				       static_cast<uint64_t>(time.microseconds) * 1000u;
+			};
+			auto& thread  = now.threads[identifier.thread_id];
+			thread.cpu_ns = to_ns(basic.user_time) + to_ns(basic.system_time);
+			thread_extended_info_data_t extended {};
+			mach_msg_type_number_t      extended_size = THREAD_EXTENDED_INFO_COUNT;
+			if (thread_info(threads[i], THREAD_EXTENDED_INFO,
+			                reinterpret_cast<thread_info_t>(&extended),
+			                &extended_size) == KERN_SUCCESS) {
+				thread.name = std::string(extended.pth_name,
+				                          strnlen(extended.pth_name, sizeof(extended.pth_name)));
+			}
+		}
+		mach_port_deallocate(task, threads[i]);
+	}
+	vm_deallocate(task, reinterpret_cast<vm_address_t>(threads), count * sizeof(thread_act_t));
+}
+
+void SamplePlatform(PlatformState& state, HostStats& stats, Counters& now) {
+	SampleRusage(now);
+
+	host_cpu_load_info_data_t load {};
+	mach_msg_type_number_t    load_count = HOST_CPU_LOAD_INFO_COUNT;
+	if (host_statistics(state.host, HOST_CPU_LOAD_INFO, reinterpret_cast<host_info_t>(&load),
+	                    &load_count) == KERN_SUCCESS) {
+		const uint64_t busy = static_cast<uint64_t>(load.cpu_ticks[CPU_STATE_USER]) +
+		                      load.cpu_ticks[CPU_STATE_SYSTEM] + load.cpu_ticks[CPU_STATE_NICE];
+		now.system_busy     = busy;
+		now.system_total    = busy + load.cpu_ticks[CPU_STATE_IDLE];
+	}
+
+	// Physical footprint is what Activity Monitor shows in its Memory column.
+	task_vm_info_data_t    vm_info {};
+	mach_msg_type_number_t vm_info_count = TASK_VM_INFO_COUNT;
+	if (task_info(mach_task_self(), TASK_VM_INFO, reinterpret_cast<task_info_t>(&vm_info),
+	              &vm_info_count) == KERN_SUCCESS) {
+		stats.process_memory      = vm_info.phys_footprint;
+		stats.process_resident    = vm_info.resident_size;
+		stats.process_compressed  = vm_info.compressed;
+		stats.process_file_backed = vm_info.external;
+		stats.process_virtual     = vm_info.virtual_size;
+	}
+	rusage_info_v2 usage {};
+	if (proc_pid_rusage(getpid(), RUSAGE_INFO_V2, reinterpret_cast<rusage_info_t*>(&usage)) == 0) {
+		now.disk_read  = usage.ri_diskio_bytesread;
+		now.disk_write = usage.ri_diskio_byteswritten;
+	}
+
+	stats.system_memory_total   = SysctlValue<uint64_t>("hw.memsize");
+	vm_size_t              page = 0;
+	vm_statistics64_data_t vm {};
+	mach_msg_type_number_t count = HOST_VM_INFO64_COUNT;
+	if (host_page_size(state.host, &page) == KERN_SUCCESS &&
+	    host_statistics64(state.host, HOST_VM_INFO64, reinterpret_cast<host_info64_t>(&vm),
+	                      &count) == KERN_SUCCESS) {
+		// Activity Monitor's "Memory Used": app memory + wired + compressed.
+		const uint64_t app       = vm.internal_page_count > vm.purgeable_count
+		                               ? vm.internal_page_count - vm.purgeable_count
+		                               : 0;
+		stats.system_memory_used = (app + vm.wire_count + vm.compressor_page_count) * page;
+		stats.system_wired       = static_cast<uint64_t>(vm.wire_count) * page;
+		stats.system_compressed  = static_cast<uint64_t>(vm.compressor_page_count) * page;
+		stats.system_cached =
+		    (static_cast<uint64_t>(vm.external_page_count) + vm.purgeable_count) * page;
+		stats.system_free = static_cast<uint64_t>(vm.free_count) * page;
+	}
+
+	if (const auto swap = SysctlValue<xsw_usage>("vm.swapusage")) {
+		stats.swap_used  = swap->xsu_used;
+		stats.swap_total = swap->xsu_total;
+	}
+
+	// 1 = normal, 2 = warning, 4 = critical, as reported to dispatch memory-pressure sources.
+	if (const auto level = SysctlValue<int>("kern.memorystatus_vm_pressure_level")) {
+		stats.memory_pressure = *level >= 4   ? MemoryPressure::Critical
+		                        : *level >= 2 ? MemoryPressure::Warning
+		                                      : MemoryPressure::Normal;
+	}
+
+	// 0 nominal, 1 moderate, 2 heavy, 3 trapping, 4 sleeping.
+	if (!state.thermal_ready) {
+		state.thermal_ready = notify_register_check("com.apple.system.thermalpressurelevel",
+		                                            &state.thermal_token) == NOTIFY_STATUS_OK;
+	}
+	uint64_t thermal = 0;
+	if (state.thermal_ready &&
+	    notify_get_state(state.thermal_token, &thermal) == NOTIFY_STATUS_OK) {
+		stats.thermal_pressure = thermal >= 3   ? ThermalPressure::Critical
+		                         : thermal == 2 ? ThermalPressure::Heavy
+		                         : thermal == 1 ? ThermalPressure::Moderate
+		                                        : ThermalPressure::Nominal;
+	}
+
+	SampleThreads(stats, now);
+	SampleGpu(state, stats);
+}
+
+#else
+
+using ProcValues = std::unordered_map<std::string, uint64_t>;
+
+// Reads "<key>: <number> [kB]" lines; kB values are returned in bytes.
+ProcValues ReadProcValues(const char* path) {
+	ProcValues    values;
+	std::ifstream file(path);
+	std::string   line;
+	while (std::getline(file, line)) {
+		const auto colon = line.find(':');
+		if (colon == std::string::npos) {
+			continue;
+		}
+		std::istringstream stream(line.substr(colon + 1));
+		uint64_t           number = 0;
+		std::string        unit;
+		if (stream >> number) {
+			stream >> unit;
+			values[line.substr(0, colon)] = unit == "kB" ? number * 1024u : number;
+		}
+	}
+	return values;
+}
+
+std::optional<uint64_t> Find(const ProcValues& values, const char* key) {
+	const auto it = values.find(key);
+	return it != values.end() ? std::optional(it->second) : std::nullopt;
+}
+
+struct PlatformState {};
+
+void SampleThreads(HostStats& stats, Counters& now) {
+	static const double ns_per_tick = 1e9 / static_cast<double>(std::max(sysconf(_SC_CLK_TCK), 1L));
+	std::error_code     error;
+	uint32_t            count = 0;
+	for (std::filesystem::directory_iterator it("/proc/self/task", error), end; !error && it != end;
+	     it.increment(error)) {
+		count++;
+		std::ifstream stat_file(it->path() / "stat");
+		std::string   stat;
+		uint64_t      id = 0;
+		if (!(stat_file >> id)) {
+			continue; // The thread may have exited during enumeration.
+		}
+		std::getline(stat_file, stat);
+		const auto close = stat.rfind(')');
+		if (close == std::string::npos) {
+			continue;
+		}
+		// Fields after the command name start at field 3 (state); utime and stime are 14 and 15.
+		std::istringstream fields(stat.substr(close + 2));
+		std::string        field;
+		for (int index = 3; index < 14 && fields >> field; index++) {
+		}
+		uint64_t user   = 0;
+		uint64_t system = 0;
+		if (!(fields >> user >> system)) {
+			continue;
+		}
+		auto& thread  = now.threads[id];
+		thread.cpu_ns = static_cast<uint64_t>(static_cast<double>(user + system) * ns_per_tick);
+		std::ifstream name_file(it->path() / "comm");
+		std::getline(name_file, thread.name);
+	}
+	if (!error) {
+		stats.thread_count = count;
+	}
+}
+
+void SamplePlatform(PlatformState& /*state*/, HostStats& stats, Counters& now) {
+	SampleRusage(now);
+
+	std::ifstream cpu_file("/proc/stat");
+	std::string   label;
+	if (cpu_file >> label && label == "cpu") {
+		uint64_t total = 0;
+		uint64_t idle  = 0;
+		uint64_t value = 0;
+		for (int index = 0; index < 8 && cpu_file >> value; index++) {
+			total += value;
+			if (index == 3 || index == 4) { // idle, iowait
+				idle += value;
+			}
+		}
+		now.system_total = total;
+		now.system_busy  = total - idle;
+	}
+
+	const auto status         = ReadProcValues("/proc/self/status");
+	stats.process_memory      = Find(status, "VmRSS");
+	stats.process_resident    = Find(status, "VmRSS");
+	stats.process_file_backed = Find(status, "RssFile");
+	stats.process_compressed  = Find(status, "VmSwap");
+	stats.process_virtual     = Find(status, "VmSize");
+
+	const auto io  = ReadProcValues("/proc/self/io");
+	now.disk_read  = Find(io, "read_bytes");
+	now.disk_write = Find(io, "write_bytes");
+
+	const auto memory    = ReadProcValues("/proc/meminfo");
+	const auto total     = Find(memory, "MemTotal");
+	const auto available = Find(memory, "MemAvailable");
+	if (total && available && *available <= *total) {
+		stats.system_memory_total = total;
+		stats.system_memory_used  = *total - *available;
+	}
+	stats.system_free = Find(memory, "MemFree");
+	if (const auto cached = Find(memory, "Cached")) {
+		stats.system_cached = *cached + Find(memory, "Buffers").value_or(0);
+	}
+	const auto swap_total = Find(memory, "SwapTotal");
+	const auto swap_free  = Find(memory, "SwapFree");
+	if (swap_total && swap_free && *swap_free <= *swap_total) {
+		stats.swap_total = swap_total;
+		stats.swap_used  = *swap_total - *swap_free;
+	}
+
+	// Pressure stall information: share of the last 10 s some task waited on memory.
+	std::ifstream pressure("/proc/pressure/memory");
+	std::string   kind;
+	std::string   average;
+	double        stalled = 0.0;
+	if (pressure >> kind >> average && kind == "some" && average.rfind("avg10=", 0) == 0 &&
+	    std::istringstream(average.substr(6)) >> stalled) {
+		stats.memory_pressure = stalled >= 20.0  ? MemoryPressure::Critical
+		                        : stalled >= 5.0 ? MemoryPressure::Warning
+		                                         : MemoryPressure::Normal;
+	} else if (total && available && *total != 0) {
+		const double free_share = static_cast<double>(*available) / static_cast<double>(*total);
+		stats.memory_pressure   = free_share < 0.10   ? MemoryPressure::Critical
+		                          : free_share < 0.25 ? MemoryPressure::Warning
+		                                              : MemoryPressure::Normal;
+	}
+
+	SampleThreads(stats, now);
+}
+
+#endif
+#endif
+
+constexpr size_t BUSIEST_THREADS = 6;
+
+} // namespace
+
+struct HostStatsSampler::Impl {
+	PlatformState state;
+	Counters      last;
+	uint32_t      logical_cores = std::max(std::thread::hardware_concurrency(), 1u);
+	bool          has_last      = false;
+};
+
+HostStatsSampler::HostStatsSampler(): m_impl(std::make_unique<Impl>()) {}
+
+HostStatsSampler::~HostStatsSampler() = default;
+
+HostStats HostStatsSampler::Sample() {
+	HostStats stats;
+	stats.logical_cores = m_impl->logical_cores;
+
+	Counters now;
+	now.wall_ns = WallNanoseconds();
+	SamplePlatform(m_impl->state, stats, now);
+
+	const auto& last    = m_impl->last;
+	const auto  elapsed = static_cast<double>(now.wall_ns - last.wall_ns) / 1e9;
+	if (m_impl->has_last && elapsed > 0.0) {
+		const auto rate = [&](std::optional<uint64_t> current,
+		                      std::optional<uint64_t> previous) -> std::optional<double> {
+			if (!current || !previous || *current < *previous) {
+				return std::nullopt;
+			}
+			return static_cast<double>(*current - *previous) / elapsed;
+		};
+		if (const auto cpu = rate(now.process_cpu_ns, last.process_cpu_ns)) {
+			stats.process_cpu_percent =
+			    std::clamp(*cpu / 1e9 * 100.0 / stats.logical_cores, 0.0, 100.0);
+		}
+		if (now.system_total && last.system_total && now.system_busy && last.system_busy &&
+		    *now.system_total > *last.system_total && *now.system_busy >= *last.system_busy) {
+			stats.system_cpu_percent =
+			    std::clamp(static_cast<double>(*now.system_busy - *last.system_busy) /
+			                   static_cast<double>(*now.system_total - *last.system_total) * 100.0,
+			               0.0, 100.0);
+		}
+		stats.context_switches_per_s = rate(now.context_switches, last.context_switches);
+		stats.page_faults_per_s      = rate(now.page_faults, last.page_faults);
+		stats.page_ins_per_s         = rate(now.page_ins, last.page_ins);
+		stats.disk_read_per_s        = rate(now.disk_read, last.disk_read);
+		stats.disk_write_per_s       = rate(now.disk_write, last.disk_write);
+
+		for (const auto& [id, thread]: now.threads) {
+			// A thread missing from the last sample started during this interval.
+			const auto     previous = last.threads.find(id);
+			const uint64_t before   = previous != last.threads.end() ? previous->second.cpu_ns : 0;
+			if (thread.cpu_ns < before) {
+				continue;
+			}
+			const double percent =
+			    static_cast<double>(thread.cpu_ns - before) / 1e9 / elapsed * 100.0;
+			stats.busiest_threads.push_back(
+			    {thread.name.empty() ? "thread " + std::to_string(id) : thread.name, percent});
+		}
+		std::sort(stats.busiest_threads.begin(), stats.busiest_threads.end(),
+		          [](const auto& a, const auto& b) { return a.cpu_percent > b.cpu_percent; });
+		if (stats.busiest_threads.size() > BUSIEST_THREADS) {
+			stats.busiest_threads.resize(BUSIEST_THREADS);
+		}
+	}
+	m_impl->last     = std::move(now);
+	m_impl->has_last = true;
+	return stats;
+}
+
+} // namespace Common
@@ -0,0 +1,86 @@
+#ifndef KYTY_COMMON_HOST_STATS_H_
+#define KYTY_COMMON_HOST_STATS_H_
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace Common {
+
+enum class MemoryPressure { Unknown, Normal, Warning, Critical };
+enum class ThermalPressure { Unknown, Nominal, Moderate, Heavy, Critical };
+
+struct ThreadUsage {
+	std::string name;
+	double      cpu_percent = 0.0; // Of one core.
+};
+
+// Host-wide and process-wide resource usage. Missing values are std::nullopt; rates are per
+// second since the previous sample.
+struct HostStats {
+	uint32_t logical_cores = 0;
+
+	// Processing.
+	std::optional<double>    process_cpu_percent; // Share of all logical cores, 0-100.
+	std::optional<double>    system_cpu_percent;  // Whole machine, 0-100.
+	std::optional<uint32_t>  thread_count;
+	std::vector<ThreadUsage> busiest_threads; // Busiest first.
+	std::optional<double>    context_switches_per_s;
+	std::optional<double>    page_faults_per_s;
+	std::optional<double>    page_ins_per_s; // Faults that read from disk.
+	ThermalPressure          thermal_pressure = ThermalPressure::Unknown;
+
+	// Emulator process memory.
+	std::optional<uint64_t> process_memory; // Physical footprint / resident set.
+	std::optional<uint64_t> process_resident;
+	std::optional<uint64_t> process_compressed; // Compressed or swapped out.
+	std::optional<uint64_t> process_file_backed;
+	std::optional<uint64_t> process_virtual; // Reserved address space.
+
+	// System memory.
+	std::optional<uint64_t> system_memory_used;
+	std::optional<uint64_t> system_memory_total;
+	std::optional<uint64_t> system_wired;
+	std::optional<uint64_t> system_compressed;
+	std::optional<uint64_t> system_cached; // File cache, reclaimable.
+	std::optional<uint64_t> system_free;
+	std::optional<uint64_t> swap_used;
+	std::optional<uint64_t> swap_total;
+	MemoryPressure          memory_pressure = MemoryPressure::Unknown;
+
+	// Disk I/O of the emulator process.
+	std::optional<double> disk_read_per_s;
+	std::optional<double> disk_write_per_s;
+
+	// GPU, whole device (macOS IOAccelerator).
+	std::string             gpu_model;
+	std::optional<uint32_t> gpu_cores;
+	std::optional<double>   gpu_percent;
+	std::optional<double>   gpu_renderer_percent;
+	std::optional<double>   gpu_tiler_percent;
+	std::optional<uint64_t> gpu_memory_in_use; // System memory the GPU driver has in use.
+	std::optional<uint64_t> gpu_memory_allocated;
+	std::optional<uint64_t> gpu_recoveries; // GPU resets since boot.
+};
+
+// May block for a few milliseconds (thread enumeration, OS registry reads), so call it off the
+// render thread. The first sample has no rates.
+class HostStatsSampler final {
+public:
+	HostStatsSampler();
+	~HostStatsSampler();
+	HostStatsSampler(const HostStatsSampler&)            = delete;
+	HostStatsSampler& operator=(const HostStatsSampler&) = delete;
+
+	[[nodiscard]] HostStats Sample();
+
+private:
+	struct Impl;
+	std::unique_ptr<Impl> m_impl;
+};
+
+} // namespace Common
+
+#endif /* KYTY_COMMON_HOST_STATS_H_ */
@@ -0,0 +1,53 @@
+#include "common/localization.h"
+
+#include <array>
+#include <cstddef>
+#include <nlohmann/json.hpp>
+#include <string>
+
+#include "localizationData.h"
+
+namespace Common::Localization {
+namespace {
+
+constexpr std::array<std::string_view, 30> Locales = {
+    "ja-JP", "en-US", "fr-FR",   "es-ES",   "de-DE", "it-IT", "nl-NL", "pt-PT",
+    "ru-RU", "ko-KR", "zh-Hant", "zh-Hans", "fi-FI", "sv-SE", "da-DK", "no-NO",
+    "pl-PL", "pt-BR", "en-GB",   "tr-TR",   "es-419", "ar-AE", "fr-CA", "cs-CZ",
+    "hu-HU", "el-GR", "ro-RO",   "th-TH",   "vi-VN", "id-ID"};
+
+size_t LanguageIndex(int console_language) {
+	return console_language >= 0 && console_language < static_cast<int>(Locales.size())
+	           ? static_cast<size_t>(console_language)
+	           : 1;
+}
+
+} // namespace
+
+std::string_view LocaleName(int console_language) {
+	return Locales[LanguageIndex(console_language)];
+}
+
+std::string_view Get(int console_language, std::string_view key) {
+	static const auto catalogs = [] {
+		std::array<nlohmann::json, Locales.size()> result;
+		for (size_t i = 0; i < Locales.size(); ++i) {
+			const auto bytes = EmbeddedCatalog(Locales[i]);
+			result[i] = nlohmann::json::parse(bytes.begin(), bytes.end(), nullptr, false);
+		}
+		return result;
+	}();
+	for (const auto index: std::array {LanguageIndex(console_language), size_t {1}}) {
+		const auto& catalog = catalogs[index];
+		const auto  found   = catalog.find(key);
+		if (found != catalog.end() && found->is_string()) {
+			const auto& text = found->get_ref<const std::string&>();
+			if (!text.empty()) {
+				return text;
+			}
+		}
+	}
+	return key;
+}
+
+} // namespace Common::Localization
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <string_view>
+
+namespace Common::Localization {
+
+// Console language indices follow the system configuration; invalid indices use English.
+[[nodiscard]] std::string_view LocaleName(int console_language);
+
+// Translations have static lifetime. Missing translations use English, then the supplied key.
+[[nodiscard]] std::string_view Get(int console_language, std::string_view key);
+
+} // namespace Common::Localization
@@ -5,6 +5,7 @@
 #include "common/emulatorConfig.h"

 #include <cstdio>
+#include <cstdlib>
 #include <filesystem>
 #include <fmt/format.h>
 #include <memory>
@@ -45,8 +46,8 @@ std::shared_ptr<spdlog::logger> MakeFileLogger(std::string                  name
 		std::filesystem::create_directories(parent);
 	}

-	auto sink =
-	    std::make_shared<spdlog::sinks::basic_file_sink_mt>(path.native(), true);
+	const bool truncate = std::getenv(Log::RelaunchedVariable) == nullptr;
+	auto       sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(path.native(), truncate);
 	return MakeLogger(std::move(name), std::move(sink));
 }

@@ -21,6 +21,10 @@ struct Lifecycle {

 enum class Direction { Silent, Console, File };

+// Set by LoadExec for the program it starts, which continues the log file of the one it replaces
+// instead of starting it over.
+inline constexpr const char* RelaunchedVariable = "KYTY_RELAUNCHED";
+
 Direction GetDirection();
 bool      IsSilent();
 void      Write(std::string_view text);
@@ -152,42 +152,29 @@ void SysFileWrite(const void* data, uint32_t size, sys_file_t& f, uint32_t* byte
 	}
 }

-sys_file_t* SysFileCreate(const std::filesystem::path& file_name) {
+static sys_file_t* OpenHostFile(const std::filesystem::path& file_name, const char* mode,
+                               sys_file_cache_type_t cache_type) {
 	auto* ret = new sys_file_t;
-
-	auto real_name     = get_internal_name(file_name);
-	auto real_name_str = real_name.string();
-
-	ret->f = fopen(real_name_str.c_str(), "w+");
-
-	if (ret->f == nullptr) {
-		printf("can't create file: %s\n", real_name_str.c_str());
+	ret->f = fopen(get_internal_name(file_name).c_str(), mode);
+	ret->type = ret->f == nullptr ? SYS_FILE_ERROR : SYS_FILE_FILE;
+	if (ret->f != nullptr) {
+		// Independent handles must observe writes and truncation immediately.
+		setvbuf(ret->f, nullptr, _IONBF, 0);
+		apply_cache_hint(ret->f, cache_type);
 	}
+	return ret;
+}

-	ret->type = SYS_FILE_FILE;
-
+sys_file_t* SysFileCreate(const std::filesystem::path& file_name) {
+	auto* ret = OpenHostFile(file_name, "w+", SYS_FILE_CACHE_AUTO);
+	if (ret->f == nullptr) {
+		printf("can't create file: %s\n", file_name.c_str());
+	}
 	return ret;
 }

 sys_file_t* SysFileOpenR(const std::filesystem::path& file_name, sys_file_cache_type_t cache_type) {
-	auto* ret = new sys_file_t;
-
-	ret->type = SYS_FILE_FILE;
-
-	auto internal_name     = get_internal_name(file_name);
-	auto internal_name_str = internal_name.string();
-
-	FILE* f = fopen(internal_name_str.c_str(), "r");
-
-	if (f == nullptr) {
-		ret->type = SYS_FILE_ERROR;
-	}
-
-	apply_cache_hint(f, cache_type);
-
-	ret->f = f;
-
-	return ret;
+	return OpenHostFile(file_name, "r", cache_type);
 }

 sys_file_t* SysFileOpen(uint8_t* buf, uint32_t buf_size) {
@@ -215,46 +202,12 @@ sys_file_t* SysFileCreate() {
 }

 sys_file_t* SysFileOpenW(const std::filesystem::path& file_name, sys_file_cache_type_t cache_type) {
-	auto* ret = new sys_file_t;
-
-	auto real_name     = get_internal_name(file_name);
-	auto real_name_str = real_name.string();
-
-	FILE* f = fopen(real_name_str.c_str(), "r+");
-
-	if (f == nullptr) {
-		ret->type = SYS_FILE_ERROR;
-	} else {
-		ret->type = SYS_FILE_FILE;
-	}
-
-	apply_cache_hint(f, cache_type);
-
-	ret->f = f;
-
-	return ret;
+	return OpenHostFile(file_name, "r+", cache_type);
 }

 sys_file_t* SysFileOpenRw(const std::filesystem::path& file_name,
                          sys_file_cache_type_t        cache_type) {
-	auto* ret = new sys_file_t;
-
-	auto real_name     = get_internal_name(file_name);
-	auto real_name_str = real_name.string();
-
-	FILE* f = fopen(real_name_str.c_str(), "r+");
-
-	if (f == nullptr) {
-		ret->type = SYS_FILE_ERROR;
-	} else {
-		ret->type = SYS_FILE_FILE;
-	}
-
-	apply_cache_hint(f, cache_type);
-
-	ret->f = f;
-
-	return ret;
+	return OpenHostFile(file_name, "r+", cache_type);
 }

 void SysFileClose(sys_file_t* f) {
@@ -8,10 +8,6 @@
 #include <condition_variable> // IWYU pragma: keep
 #include <mutex>

-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS && KYTY_COMPILER == KYTY_COMPILER_CLANG
-#define KYTY_WIN_CS
-#endif
-
 // macOS has no clock_nanosleep.
 #if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS && !defined(__APPLE__)
 #define KYTY_POSIX_HIGH_RES_SLEEP
@@ -22,7 +18,7 @@
 #include <string>
 #include <thread>

-#ifdef KYTY_WIN_CS
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 #include <windows.h> // IWYU pragma: keep
 // IWYU pragma: no_include <winbase.h>
 constexpr DWORD KYTY_CS_SPIN_COUNT = 4000;
@@ -133,7 +129,7 @@ namespace Common {
 using thread_id_t = std::thread::id;

 struct MutexPrivate {
-#ifdef KYTY_WIN_CS
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	MutexPrivate() { InitializeCriticalSectionAndSpinCount(&m_cs, KYTY_CS_SPIN_COUNT); }
 	~MutexPrivate() { DeleteCriticalSection(&m_cs); }
 	KYTY_CLASS_NO_COPY(MutexPrivate);
@@ -144,7 +140,7 @@ struct MutexPrivate {
 };

 struct CondVarPrivate {
-#ifdef KYTY_WIN_CS
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	CondVarPrivate() {
 		static auto func = ResolveInitializeConditionVariable();
 		EXIT_NOT_IMPLEMENTED(func == nullptr);
@@ -216,7 +212,7 @@ void Thread::Detach() {
 }

 void Thread::SleepMicro(uint32_t micros) {
-#ifdef KYTY_WIN_CS
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	SleepHighResolution100ns(static_cast<uint64_t>(micros) * 10);
 #elif defined(KYTY_POSIX_HIGH_RES_SLEEP)
 	SleepHighResolutionNanos(static_cast<uint64_t>(micros) * 1000);
@@ -226,7 +222,7 @@ void Thread::SleepMicro(uint32_t micros) {
 }

 void Thread::SleepNano(uint64_t nanos) {
-#ifdef KYTY_WIN_CS
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	SleepHighResolution100ns((nanos + 99) / 100);
 #elif defined(KYTY_POSIX_HIGH_RES_SLEEP)
 	SleepHighResolutionNanos(nanos);
@@ -262,7 +258,7 @@ Mutex::~Mutex() {
 }

 void Mutex::Lock() {
-#ifdef KYTY_WIN_CS
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	EnterCriticalSection(&m_mutex->m_cs);
 #else
 	m_mutex->m_mutex.lock();
@@ -270,7 +266,7 @@ void Mutex::Lock() {
 }

 void Mutex::Unlock() {
-#ifdef KYTY_WIN_CS
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	LeaveCriticalSection(&m_mutex->m_cs);
 #else
 	m_mutex->m_mutex.unlock();
@@ -278,7 +274,7 @@ void Mutex::Unlock() {
 }

 bool Mutex::TryLock() {
-#ifdef KYTY_WIN_CS
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	return (TryEnterCriticalSection(&m_mutex->m_cs) != 0);
 #else
 	return m_mutex->m_mutex.try_lock();
@@ -292,7 +288,7 @@ CondVar::~CondVar() {
 }

 void CondVar::Wait(Mutex* mutex) {
-#ifndef KYTY_WIN_CS
+#if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS
 	std::unique_lock<std::recursive_mutex> cpp_lock(mutex->m_mutex->m_mutex, std::adopt_lock_t());
 #endif
 	auto poll_callback = [&] {
@@ -300,7 +296,7 @@ void CondVar::Wait(Mutex* mutex) {
 		if (callback == nullptr) {
 			return;
 		}
-#if defined(KYTY_WIN_CS)
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 		LeaveCriticalSection(&mutex->m_mutex->m_cs);
 		callback();
 		EnterCriticalSection(&mutex->m_mutex->m_cs);
@@ -310,7 +306,7 @@ void CondVar::Wait(Mutex* mutex) {
 		cpp_lock.lock();
 #endif
 	};
-#ifdef KYTY_WIN_CS
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	static auto func = ResolveSleepConditionVariableCS();
 	EXIT_NOT_IMPLEMENTED(func == nullptr);
 	if (g_cond_wait_poll_callback == nullptr) {
@@ -340,10 +336,10 @@ void CondVar::SetWaitPollCallback(wait_poll_func_t callback) {

 bool CondVar::WaitFor(Mutex* mutex, uint32_t micros) {
 	bool ok = false;
-#ifndef KYTY_WIN_CS
+#if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS
 	std::unique_lock<std::recursive_mutex> cpp_lock(mutex->m_mutex->m_mutex, std::adopt_lock_t());
 #endif
-#ifdef KYTY_WIN_CS
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	static auto func = ResolveSleepConditionVariableCS();
 	EXIT_NOT_IMPLEMENTED(func == nullptr);
 	ok = !(func(&m_cond_var->m_cv, &mutex->m_mutex->m_cs, (micros < 1000 ? 1 : micros / 1000)) ==
@@ -358,7 +354,7 @@ bool CondVar::WaitFor(Mutex* mutex, uint32_t micros) {
 }

 void CondVar::Signal() {
-#ifdef KYTY_WIN_CS
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	static auto func = ResolveWakeConditionVariable();
 	EXIT_NOT_IMPLEMENTED(func == nullptr);
 	func(&m_cond_var->m_cv);
@@ -368,7 +364,7 @@ void CondVar::Signal() {
 }

 void CondVar::SignalAll() {
-#ifdef KYTY_WIN_CS
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	static auto func = ResolveWakeAllConditionVariable();
 	EXIT_NOT_IMPLEMENTED(func == nullptr);
 	func(&m_cond_var->m_cv);
@@ -1,9 +1,9 @@
 #include "common/trophies.h"

 #include "common/file.h"
+#include "common/localization.h"

 #include <algorithm>
-#include <array>
 #include <charconv>
 #include <fmt/format.h>
 #include <nlohmann/json.hpp>
@@ -105,13 +105,7 @@ Package ParsePackage(std::span<const std::byte> data, int console_language) {
 	    !conf["defaultLanguage"].is_string()) {
 		return {};
 	}
-	static constexpr std::array<std::string_view, 30> locales = {
-	    "ja-JP", "en-US", "fr-FR",   "es-ES",   "de-DE",  "it-IT", "nl-NL", "pt-PT",
-	    "ru-RU", "ko-KR", "zh-Hant", "zh-Hans", "fi-FI",  "sv-SE", "da-DK", "no-NO",
-	    "pl-PL", "pt-BR", "en-GB",   "tr-TR",   "es-419", "ar-AE", "fr-CA", "cs-CZ",
-	    "hu-HU", "el-GR", "ro-RO",   "th-TH",   "vi-VN",  "id-ID"};
-	const auto locale =
-	    locales[console_language >= 0 && console_language < locales.size() ? console_language : 1];
+	const auto locale = Localization::LocaleName(console_language);
 	auto meta = ReadJson(files, fmt::format("tropmeta_{}.json", locale));
 	if (meta.is_null()) {
 		meta = ReadJson(files, fmt::format("tropmeta_{}.json",
@@ -0,0 +1,62 @@
+if(NOT DEFINED INPUTS OR NOT DEFINED OUTPUT)
+	message(FATAL_ERROR "embed_localization.cmake requires INPUTS and OUTPUT")
+endif()
+
+set(contents "// Generated from assets/localization; do not edit.\n#pragma once\n#include <span>\n#include <string_view>\n\nnamespace {\n")
+set(lookup "std::span<const unsigned char> EmbeddedCatalog(std::string_view locale) {\n")
+set(continuation "[89ab][0-9a-f]")
+string(CONCAT utf8_character
+	"[0-7][0-9a-f]|(c[2-9a-f]|d[0-9a-f])${continuation}"
+	"|e0[ab][0-9a-f]${continuation}|e[1-9abcef]${continuation}${continuation}"
+	"|ed[89][0-9a-f]${continuation}|f0[9ab][0-9a-f]${continuation}${continuation}"
+	"|f[123]${continuation}${continuation}${continuation}|f48[0-9a-f]${continuation}${continuation}")
+foreach(catalog IN LISTS INPUTS)
+	file(READ "${catalog}" bytes HEX)
+	# Validate UTF-8, excluding overlong sequences, surrogates, and values above U+10FFFF.
+	if(NOT bytes MATCHES "^(${utf8_character})*$")
+		message(FATAL_ERROR "Localization must be UTF-8: ${catalog}")
+	endif()
+	file(READ "${catalog}" json)
+	string(JSON type ERROR_VARIABLE error TYPE "${json}")
+	if(error OR NOT type STREQUAL "OBJECT")
+		message(FATAL_ERROR "Invalid localization object in ${catalog}: ${error}")
+	endif()
+	string(JSON count LENGTH "${json}")
+	if(count GREATER 0)
+		math(EXPR last "${count} - 1")
+		foreach(index RANGE ${last})
+			string(JSON key MEMBER "${json}" ${index})
+			string(JSON type TYPE "${json}" "${key}")
+			if(NOT type STREQUAL "STRING")
+				message(FATAL_ERROR "Localization value '${key}' must be a string: ${catalog}")
+			endif()
+			string(JSON text GET "${json}" "${key}")
+			if(key STREQUAL "" OR text STREQUAL "")
+				message(FATAL_ERROR "Localization keys and values must not be empty: ${catalog}")
+			endif()
+		endforeach()
+	endif()
+	get_filename_component(locale "${catalog}" NAME_WE)
+	if(locale STREQUAL "en-US")
+		string(JSON earned ERROR_VARIABLE error GET "${json}" "trophy.toast.earned")
+		if(error OR earned STREQUAL "")
+			message(FATAL_ERROR "English localization requires trophy.toast.earned: ${catalog}")
+		endif()
+		set(english_found TRUE)
+	endif()
+	string(MAKE_C_IDENTIFIER "${locale}" symbol)
+	string(REGEX REPLACE "(..)" "0x\\1," bytes "${bytes}")
+	string(APPEND contents "constexpr unsigned char catalog_${symbol}[] = {${bytes}};\n")
+	string(APPEND lookup "\tif (locale == \"${locale}\") return catalog_${symbol};\n")
+endforeach()
+if(NOT english_found)
+	message(FATAL_ERROR "Localization requires an en-US.json fallback")
+endif()
+string(APPEND contents "\n${lookup}\treturn {};\n}\n} // namespace\n")
+
+get_filename_component(output_dir "${OUTPUT}" DIRECTORY)
+file(MAKE_DIRECTORY "${output_dir}")
+file(WRITE "${OUTPUT}.tmp" "${contents}")
+execute_process(COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${OUTPUT}.tmp" "${OUTPUT}"
+	COMMAND_ERROR_IS_FATAL ANY)
+file(REMOVE "${OUTPUT}.tmp")
@@ -22,6 +22,7 @@
 #include "libs/controller.h"
 #include "libs/libs.h"
 #include "libs/network.h"
+#include "loader/additionalContent.h"
 #include "loader/runtimeLinker.h"
 #include "loader/systemContent.h"
 #include "loader/timer.h"
@@ -201,7 +202,15 @@ void Run(const RunOptions& options) {

 	PrintSystemInfo();
 	std::string title_id;
-	if (Loader::SystemContentParamSfoGetString("TITLE_ID", &title_id) && !title_id.empty()) {
+	Loader::SystemContentParamSfoGetString("TITLE_ID", &title_id);
+	if (title_id.empty()) {
+		std::string content_id;
+		if (Loader::SystemContentParamSfoGetString("CONTENT_ID", &content_id) &&
+		    content_id.size() == 36 && content_id[6] == '-' && content_id[16] == '_') {
+			title_id = content_id.substr(7, 9);
+		}
+	}
+	if (!title_id.empty()) {
 		Log::WriteToConsoleAndLog(fmt::format("Title ID: {}\n", title_id));
 	}

@@ -217,6 +226,7 @@ void Run(const RunOptions& options) {

 	MountSandboxDirs();

+	Loader::AddContentLoad(options.addcont_dir, title_id);
 	auto* rt = Common::Singleton<Loader::RuntimeLinker>::Instance();
 	Libs::InitAll(rt->Symbols());

@@ -13,6 +13,7 @@ struct RunOptions {
 	std::filesystem::path app0_dir;
 	std::filesystem::path elf;
 	std::filesystem::path game_patch;
+	std::filesystem::path addcont_dir;
 };

 void Run(const RunOptions& options);
@@ -231,7 +231,6 @@ constexpr auto MakeCustomOpcodeDispatchTable() {
 	g_cp_op_custom_func[Pm4::R_WAIT_FLIP_DONE] = CpOpWaitFlipDone;
 	g_cp_op_custom_func[Pm4::R_PUSH_MARKER]    = CpOpPushMarker;
 	g_cp_op_custom_func[Pm4::R_POP_MARKER]     = CpOpPopMarker;
-	g_cp_op_custom_func[Pm4::R_ACQUIRE_MEM]    = CpOpAcquireMem;
 	g_cp_op_custom_func[Pm4::R_FLIP]           = CpOpFlip;
 	g_cp_op_custom_func[Pm4::R_RELEASE_MEM]    = CpOpReleaseMem;
 	g_cp_op_custom_func[Pm4::R_CONTEXT_STATE]  = CpOpContextState;
@@ -295,10 +295,6 @@ static void HwCtxIgnoreDisabledUserClipPlane(CommandProcessor& cp, uint32_t valu
 	EXIT_NOT_IMPLEMENTED(value != 0 || cp.GetCtx().GetClipControl().user_clip_planes != 0);
 }

-static void HwCtxIgnoreDrawPayloadControl([[maybe_unused]] uint32_t value) {}
-
-static void HwCtxIgnoreObjprimIdControl([[maybe_unused]] uint32_t value) {}
-
 static void HwCtxIgnorePrimitiveIdReset([[maybe_unused]] uint32_t value) {}

 static void HwCtxIgnoreVtxControl([[maybe_unused]] uint32_t value) {}
@@ -454,23 +450,13 @@ KYTY_HW_CTX_PARSER(HwCtxSetAlphaToMask) {
 }

 KYTY_HW_CTX_PARSER(HwCtxSetDrawPayloadControl) {
-	auto num_values = KYTY_PM4_LEN(cmd_id) - 2u;
-
-	for (uint32_t i = 0; i < num_values; i++) {
-		HwCtxIgnoreDrawPayloadControl(buffer[i]);
-	}
-
-	return num_values;
+	cp.GetCtx().SetDrawPayloadControl(buffer[0]);
+	return KYTY_PM4_LEN(cmd_id) - 2u;
 }

 KYTY_HW_CTX_PARSER(HwCtxSetObjprimIdControl) {
-	auto num_values = KYTY_PM4_LEN(cmd_id) - 2u;
-
-	for (uint32_t i = 0; i < num_values; i++) {
-		HwCtxIgnoreObjprimIdControl(buffer[i]);
-	}
-
-	return num_values;
+	cp.GetCtx().SetObjprimIdControl(buffer[0]);
+	return KYTY_PM4_LEN(cmd_id) - 2u;
 }

 KYTY_HW_CTX_PARSER(HwCtxSetPrimitiveIdReset) {
@@ -1304,8 +1290,8 @@ KYTY_HW_UC_PARSER(HwUcSetGdsOaRegisters) {
 KYTY_CP_OP_PARSER(CpOpAcquireMem) {
 	KYTY_PROFILER_FUNCTION();

-	EXIT_NOT_IMPLEMENTED(cmd_id != 0xC0055800 && cmd_id != 0xc0061050);
-	return (cmd_id == 0xc0061050 ? 7 : 6);
+	EXIT_NOT_IMPLEMENTED(cmd_id != 0xc0055800 && cmd_id != 0xc0065800);
+	return KYTY_PM4_LEN(cmd_id) - 1;
 }

 KYTY_CP_OP_PARSER(CpOpDispatchDirect) {
@@ -2142,27 +2128,23 @@ KYTY_CP_OP_PARSER(CpOpIndirectUcRegs) {
 KYTY_CP_OP_PARSER(CpOpMarker) {
 	KYTY_PROFILER_FUNCTION();

-	// EXIT_NOT_IMPLEMENTED(cmd_id != 0xC0001000);
-
-	uint32_t id     = buffer[0] & 0xfffu;
 	uint32_t len_dw = ((cmd_id >> 16u) & 0x3fffu);

-	switch (id) {
-		case 0x0: break;
-		case 0x4: cp.SetUserDataMarker(HW::UserSgprType::Vsharp); break;
-		case 0xd: cp.SetUserDataMarker(HW::UserSgprType::Region); break;
-		case 0x777: {
+	switch (buffer[0]) {
+		case 0x68750004: cp.SetUserDataMarker(HW::UserSgprType::Vsharp); break;
+		case 0x6875000d: cp.SetUserDataMarker(HW::UserSgprType::Region); break;
+		case 0x68750777: {
 			cp.Flip();
 			break;
 		}
-		case 0x778: {
+		case 0x68750778: {
 			auto* addr =
 			    reinterpret_cast<void*>(buffer[1] | (static_cast<uint64_t>(buffer[2]) << 32u));
 			uint32_t value = buffer[3];
 			cp.Flip(addr, value);
 			break;
 		}
-		case 0x781: {
+		case 0x68750781: {
 			auto* addr =
 			    reinterpret_cast<void*>(buffer[1] | (static_cast<uint64_t>(buffer[2]) << 32u));
 			uint32_t value          = buffer[3];
@@ -2171,7 +2153,8 @@ KYTY_CP_OP_PARSER(CpOpMarker) {
 			cp.FlipWithInterrupt(eop_event_type, cache_action, addr, value);
 			break;
 		}
-		default: EXIT("unknown marker at %05" PRIx32 ": 0x%" PRIx32 "\n", num_dw - dw, id);
+		// NOP payloads are caller-owned data; only complete known marker tags execute.
+		default: break;
 	}

 	return len_dw + 1;
@@ -3109,7 +3092,7 @@ void GraphicsInitJmpTablesCxIndirect() {
 		cp.GetCtx().SetTfParam(value);
 	};
 	g_hw_ctx_indirect_func[Pm4::VGT_DRAW_PAYLOAD_CNTL] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
-		HwCtxIgnoreDrawPayloadControl(value);
+		cp.GetCtx().SetDrawPayloadControl(value);
 	};
 	g_hw_ctx_indirect_func[Pm4::VGT_PRIMITIVEID_RESET] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
 		HwCtxIgnorePrimitiveIdReset(value);
@@ -3118,7 +3101,7 @@ void GraphicsInitJmpTablesCxIndirect() {
 		cp.GetCtx().SetShaderZFormat(value);
 	};
 	g_hw_ctx_indirect_func[Pm4::PA_CL_OBJPRIM_ID_CNTL] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
-		HwCtxIgnoreObjprimIdControl(value);
+		cp.GetCtx().SetObjprimIdControl(value);
 	};

 	for (auto cmd_offset = Pm4::PA_SC_CLIPRECT_RULE; cmd_offset < Pm4::PA_SC_CLIPRECT_0_TL + 8u;
@@ -23,6 +23,7 @@ constexpr FormatInfo kFormatInfo[] = {
 	{BufferFormat::k8UScaled, 1, 0, 0, true, false},
 	{BufferFormat::k8SNorm, 1, 0, 1, true, false},
 	{BufferFormat::k8UInt, 1, 0, 1, true, true},
+	{BufferFormat::k8SInt, 1, 0, 1, true, false, true},
 	{BufferFormat::k16UNorm, 2, 0, 2, true, false},
 	{BufferFormat::k16SNorm, 2, 0, 2, true, false},
 	{BufferFormat::k16UInt, 2, 0, 2, true, true},
@@ -41,6 +42,7 @@ constexpr FormatInfo kFormatInfo[] = {
 	{BufferFormat::k16_16UInt, 4, 0, 4, true, true},
 	{BufferFormat::k16_16SInt, 4, 0, 4, true, false, true},
 	{BufferFormat::k16_16Float, 4, 0, 4, true, false},
+	{BufferFormat::k11_11_10UNorm, 4, 0, 4, true, false},
 	{BufferFormat::k11_11_10UInt, 4, 0, 4, true, true},
 	{BufferFormat::k11_11_10Float, 4, 0, 4, true, false},
 	{BufferFormat::k10_11_11Float, 4, 0, 4, true, false},
@@ -237,6 +239,7 @@ BufferFormat RemapTextureFormat(BufferFormat format) {
 	switch (format) {
 		case BufferFormat::k8UScaled: return BufferFormat::k8UNorm;
 		case BufferFormat::k8_8UScaled: return BufferFormat::k8_8UNorm;
+		case BufferFormat::k11_11_10UNorm:
 		case BufferFormat::k11_11_10UInt: return BufferFormat::k32UInt;
 		default: return format;
 	}
@@ -1,6 +1,7 @@
 #include "graphics/guest_gpu/graphicsRun.h"

 #include "common/assert.h"
+#include "common/debugCounters.h"
 #include "common/emulatorConfig.h"
 #include "common/logging/log.h"
 #include "common/profiler.h"
@@ -576,12 +577,7 @@ bool GuestGpu::Process(Submission& submission) {
 				}
 			}
 			if (progressed) {
-				if (complete) {
-					m_renderer.RunGarbageCollector();
-				}
 				cp.BufferFlush();
-			} else if (complete) {
-				m_renderer.RunGarbageCollector();
 			}
 			break;
 		}
@@ -602,20 +598,16 @@ bool GuestGpu::Process(Submission& submission) {
 			complete = cp.Process(submission.command_execution, submission.commands) ==
 			           Pm4ProcessResult::Complete;
 			if (submission.command_execution.MadeProgress()) {
-				if (complete) {
-					m_renderer.RunGarbageCollector();
-				}
 				cp.BufferFlush();
-			} else if (complete) {
-				m_renderer.RunGarbageCollector();
 			}
 			break;
 		}
 		case SubmissionType::FlipPreparation:
-			m_renderer.RunGarbageCollector();
 			cp.PrepareCpuFlip(submission.flip_request_id);
 			break;
 		case SubmissionType::SuspendPoint:
+			// Age caches at the frame boundary, not once per command list.
+			m_renderer.RunGarbageCollector();
 			cp.EmitGlobalBarrier();
 			m_renderer.GetCommandScheduler().DeferPriorityOperation(
 			    [ready = m_suspend_point_ready] { ready->release(); });
@@ -915,6 +907,7 @@ void CommandProcessor::DrawIndirectMulti(uint32_t data_offset, uint32_t max_coun
 	if (draw_count == 0) {
 		return;
 	}
+	Common::DebugCounters::Add(Common::DebugCounters::Counter::IndirectDraws, draw_count);

 	const auto args_size = indexed ? sizeof(DrawIndexedIndirectArgs) : sizeof(DrawIndirectArgs);
 	EXIT_NOT_IMPLEMENTED(stride_in_bytes < args_size);
@@ -556,6 +556,8 @@ struct ShaderRegisters {
 	uint32_t m_vgtGsMaxVertOut        = 0;
 	uint32_t m_vgtGsOutPrimType       = 0;
 	uint32_t m_vgtPrimitiveIdEn       = 0;
+	uint32_t m_vgtDrawPayloadCntl     = 0;
+	uint32_t m_paClObjprimIdCntl      = 0;
 	uint32_t m_vgtReuseOff            = 0;
 	uint32_t m_vgtTessDistribution    = 0;
 	uint32_t m_vgtLsHsConfig          = 0;
@@ -679,6 +681,10 @@ public:

 	void                   SetRenderTargetMask(uint32_t mask) { m_render_target_mask = mask; }
 	[[nodiscard]] uint32_t GetRenderTargetMask() const { return m_render_target_mask; }
+	[[nodiscard]] bool HasObjectPrimitiveIdOutput() const {
+		return (m_sh_regs.m_vgtDrawPayloadCntl & 1u) != 0 &&
+		       (m_render_target_mask & 0xf0000000u) != 0;
+	}

 	void                   SetShaderStages(uint32_t flags) { m_shader_stages = flags; }
 	[[nodiscard]] uint32_t GetShaderStages() const { return m_shader_stages; }
@@ -877,6 +883,8 @@ public:
 	void SetGsMaxVertOut(uint32_t value) { m_sh_regs.m_vgtGsMaxVertOut = value; }
 	void SetGsOutPrimType(uint32_t value) { m_sh_regs.m_vgtGsOutPrimType = value; }
 	void SetPrimitiveIdEn(uint32_t value) { m_sh_regs.m_vgtPrimitiveIdEn = value; }
+	void SetDrawPayloadControl(uint32_t value) { m_sh_regs.m_vgtDrawPayloadCntl = value; }
+	void SetObjprimIdControl(uint32_t value) { m_sh_regs.m_paClObjprimIdCntl = value; }
 	void SetReuseOff(uint32_t value) { m_sh_regs.m_vgtReuseOff = value; }
 	void SetTessDistribution(uint32_t value) { m_sh_regs.m_vgtTessDistribution = value; }
 	void SetLsHsConfig(uint32_t value) { m_sh_regs.m_vgtLsHsConfig = value; }
@@ -23,7 +23,6 @@ constexpr auto MakeRegisterNames() {
 	names[R_DISPATCH_RESET] = "R_DISPATCH_RESET";
 	names[R_PUSH_MARKER]    = "R_PUSH_MARKER";
 	names[R_POP_MARKER]     = "R_POP_MARKER";
-	names[R_ACQUIRE_MEM]    = "R_ACQUIRE_MEM";
 	names[R_WRITE_DATA]     = "R_WRITE_DATA";
 	names[R_FLIP]           = "R_FLIP";
 	names[R_RELEASE_MEM]    = "R_RELEASE_MEM";
@@ -86,7 +86,6 @@ constexpr uint32_t R_WAIT_FLIP_DONE = 0x06;
 constexpr uint32_t R_DISPATCH_RESET = 0x09;
 constexpr uint32_t R_PUSH_MARKER    = 0x0B;
 constexpr uint32_t R_POP_MARKER     = 0x0C;
-constexpr uint32_t R_ACQUIRE_MEM    = 0x14;
 constexpr uint32_t R_WRITE_DATA     = 0x15;
 constexpr uint32_t R_FLIP           = 0x17;
 constexpr uint32_t R_RELEASE_MEM    = 0x18;
@@ -8,6 +8,7 @@

 #include <map>
 #include <mutex>
+#include <span>
 #include <tuple>
 #include <vector>
 #include <vk_mem_alloc.h>
@@ -33,7 +34,7 @@ struct GraphicContext {
 	// bool fp64_denorm_preserve = false; // Temporarily disabled.
 	bool                               attachment_feedback_loop_enabled      = false;
 	bool                               provoking_vertex_last_enabled         = false;
-	bool                               depth_color_copy_enabled               = false;
+	bool                               maintenance8_enabled                  = false;
 	bool                               supports_block_texel_view              = false;
 	bool                                      mesh_shader_enabled                   = false;
 	vk::PhysicalDeviceMeshShaderPropertiesEXT mesh_shader_properties                = {};
@@ -99,6 +100,14 @@ struct GraphicContext {
 	[[nodiscard]] bool CanReportMemoryUsage() const noexcept { return memory_budget_ext_enabled; }
 	[[nodiscard]] uint64_t GetDeviceMemoryUsage() const;
 	[[nodiscard]] uint64_t GetTotalMemoryBudget() const;
+
+	struct HeapUsage {
+		uint64_t usage        = 0; // Whole process, as reported by VK_EXT_memory_budget.
+		uint64_t budget       = 0;
+		uint32_t allocations  = 0;
+		bool     device_local = false;
+	};
+	[[nodiscard]] uint32_t GetHeapUsage(std::span<HeapUsage, VK_MAX_MEMORY_HEAPS> heaps) const;
 	[[nodiscard]] bool     CreateImage(const vk::ImageCreateInfo& info, VulkanImage& image);
 	void                   DeleteImage(VulkanImage& image);

@@ -66,6 +66,18 @@ RegionManager* MemoryTracker::GetOrCreateRegion(uint64_t index) {
 	return ptr;
 }

+void MemoryTracker::QueueBdaSync(uint64_t vaddr, uint64_t size) {
+	const auto begin = Common::AlignDown(vaddr, TRACKER_PAGE_SIZE);
+	const auto end   = Common::AlignUp(vaddr + size, TRACKER_PAGE_SIZE);
+	std::lock_guard lock(m_bda_sync_mutex);
+	m_bda_sync.Add(begin, end - begin);
+}
+
+RangeSet MemoryTracker::TakeBdaSync() {
+	std::lock_guard lock(m_bda_sync_mutex);
+	return std::exchange(m_bda_sync, RangeSet {});
+}
+
 bool MemoryTracker::IsRegionCpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
 	return Iterate<true>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
@@ -88,6 +100,7 @@ void MemoryTracker::MarkRegionAsCpuModified(uint64_t vaddr, uint64_t size) {
 		std::scoped_lock lock(manager->lock);
 		manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
 	});
+	QueueBdaSync(vaddr, size);
 }

 void MemoryTracker::MarkRegionAsGpuModified(uint64_t vaddr, uint64_t size) {
@@ -128,6 +141,8 @@ void MemoryTracker::UntrackMemory(uint64_t vaddr, uint64_t size) {
 	Iterate<false>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
 	});
+	locks.clear();
+	QueueBdaSync(vaddr, size);
 }

 } // namespace Libs::Graphics
@@ -29,6 +29,10 @@ public:
 	void               MarkRegionAsGpuModified(uint64_t vaddr, uint64_t size);
 	void               UnmarkRegionAsGpuModified(uint64_t vaddr, uint64_t size);
 	void               UntrackMemory(uint64_t vaddr, uint64_t size);
+	// Queue after changing ownership; a concurrent drain must not consume an event
+	// before the dirty pages it describes become visible.
+	void                   QueueBdaSync(uint64_t vaddr, uint64_t size);
+	[[nodiscard]] RangeSet TakeBdaSync();
 	// Removes protection from a range and flushes GPU-owned data when required.
 	template <typename Flush>
 	void InvalidateRegion(uint64_t vaddr, uint64_t size, Flush&& on_flush) noexcept {
@@ -51,6 +55,7 @@ public:
 				on_flush();
 			}
 		});
+		QueueBdaSync(vaddr, size);
 	}
 #if KYTY_BUILD == KYTY_BUILD_DEBUG
 	void ValidateGpuDirtyPages(const RangeSet& dirty, uint64_t vaddr, uint64_t size,
@@ -149,6 +154,8 @@ private:
 	std::unique_ptr<std::atomic<RegionManager*>[]> m_regions;
 	std::vector<std::unique_ptr<RegionManager>>    m_region_storage;
 	std::mutex                                     m_region_mutex;
+	std::mutex                                     m_bda_sync_mutex;
+	RangeSet                                       m_bda_sync;
 	PageManager&                                   m_page_manager;
 };

@@ -2,6 +2,7 @@

 #include "common/alignment.h"
 #include "common/assert.h"
+#include "common/debugCounters.h"
 #include "common/logging/log.h"
 #include "common/profiler.h"
 #include "graphics/guest_gpu/graphicsRun.h"
@@ -27,6 +28,26 @@ namespace {
 constexpr uint64_t MiB           = 1024 * 1024;
 constexpr uint64_t GdsBufferSize = 64 * 1024;

+std::pair<Buffer*, uint64_t> UploadMemory(GraphicContext& graphics, CommandScheduler& scheduler,
+                                        StreamBuffer& staging, uint64_t size, uint64_t alignment,
+                                        vk::BufferUsageFlags usage, const auto& write) {
+	const auto [mapped, offset] = staging.Map(size, alignment);
+	if (mapped != nullptr) {
+		write(mapped, offset);
+		staging.Commit();
+		return {&staging, offset};
+	}
+
+	// Large transfers use the same one-time host allocation as ordinary buffer uploads.
+	auto temporary = std::make_unique<Buffer>(graphics, scheduler, MemoryUsage::Upload, 0,
+	                                         usage, size);
+	write(temporary->Mapped().data(), 0);
+	temporary->Flush(0, size);
+	auto* buffer = temporary.get();
+	scheduler.DeferOperation([owner = std::move(temporary)]() mutable { owner.reset(); });
+	return {buffer, 0};
+}
+
 } // namespace

 void BufferCache::WriteDataBuffer(Buffer& buffer, uint64_t address, const void* source,
@@ -106,6 +127,7 @@ void BufferCache::ChangeRegister(BufferId id) {
 		}
 		WriteDataBuffer(m_bda_pagetable_buffer, table_offset,
 		                addresses.data(), addresses.size() * sizeof(vk::DeviceAddress));
+		m_memory_tracker.QueueBdaSync(buffer.CpuAddress(), buffer.Size());
 	} else {
 		const auto found = m_buffers.find(buffer.CpuAddress());
 		EXIT_IF(found == m_buffers.end() || found->second != id);
@@ -156,6 +178,7 @@ bool BufferCache::DownloadBufferMemory(Buffer& buffer, uint64_t vaddr, uint64_t
 	if (copies.empty()) {
 		return false;
 	}
+	Common::DebugCounters::Add(Common::DebugCounters::Counter::BufferDownloadBytes, total_size);

 	auto [mapped, offset] = m_download_buffer.Map(total_size, 64);
 	std::unique_ptr<Buffer> temporary;
@@ -446,29 +469,19 @@ vk::Buffer BufferCache::UploadCopies(Buffer& buffer, std::span<vk::BufferCopy> c
 	if (copies.empty()) {
 		return nullptr;
 	}
+	Common::DebugCounters::Add(Common::DebugCounters::Counter::BufferUploadBytes, total_size);

-	auto [mapped, base_offset] = m_staging_buffer.Map(total_size, 4);
-	if (mapped != nullptr) {
+	const auto source = UploadMemory(m_graphics, m_scheduler, m_staging_buffer, total_size, 4,
+	    vk::BufferUsageFlagBits::eTransferSrc, [&](uint8_t* mapped, uint64_t base_offset) {
 		for (auto& copy: copies) {
 			const auto address = buffer.CpuAddress() + copy.dstOffset;
-			std::memcpy(mapped + copy.srcOffset, reinterpret_cast<const void*>(address), copy.size);
+			if (!LibKernel::Memory::CopySparseMemory(address, mapped + copy.srcOffset, copy.size)) {
+				EXIT("BufferCache: failed to read sparse guest buffer memory\n");
+			}
 			copy.srcOffset += base_offset;
 		}
-		m_staging_buffer.Commit();
-		return m_staging_buffer.Handle();
-	}
-
-	auto temporary = std::make_unique<Buffer>(m_graphics, m_scheduler, MemoryUsage::Upload, 0,
-	                                         vk::BufferUsageFlagBits::eTransferSrc, total_size);
-	for (const auto& copy: copies) {
-		const auto address = buffer.CpuAddress() + copy.dstOffset;
-		std::memcpy(temporary->Mapped().data() + copy.srcOffset,
-		            reinterpret_cast<const void*>(address), copy.size);
-	}
-	temporary->Flush(0, total_size);
-	const auto handle = temporary->Handle();
-	m_scheduler.DeferOperation([owner = std::move(temporary)]() mutable { owner.reset(); });
-	return handle;
+	});
+	return source.first->Handle();
 }

 std::pair<Buffer*, uint64_t> BufferCache::ObtainBuffer(uint64_t vaddr, uint64_t size,
@@ -486,7 +499,9 @@ std::pair<Buffer*, uint64_t> BufferCache::ObtainBuffer(uint64_t vaddr, uint64_t
 		    m_graphics.physical_device_properties.limits.minUniformBufferOffsetAlignment, 1);
 		auto [mapped, offset] = m_stream_buffer.Map(size, alignment, false);
 		if (mapped != nullptr) {
-			std::memcpy(mapped, reinterpret_cast<const void*>(vaddr), size);
+			if (!LibKernel::Memory::CopySparseMemory(vaddr, mapped, size)) {
+				EXIT("BufferCache: failed to read sparse guest buffer memory\n");
+			}
 			m_stream_buffer.Commit();
 			return {&m_stream_buffer, offset};
 		}
@@ -521,12 +536,13 @@ std::pair<Buffer*, uint64_t> BufferCache::ObtainBufferForImage(uint64_t vaddr, u
 		return ObtainBuffer(vaddr, size, false, false);
 	}

-	auto [staging, stage_offset] = m_staging_buffer.Map(size, 16);
-	if (staging == nullptr || !Libs::LibKernel::Memory::TryReadSparseBacking(vaddr, staging, size)) {
-		EXIT("BufferCache: failed to read mapped guest image backing\n");
-	}
-	m_staging_buffer.Commit();
-	return {&m_staging_buffer, stage_offset};
+	return UploadMemory(m_graphics, m_scheduler, m_staging_buffer, size, 16,
+	    vk::BufferUsageFlagBits::eTransferSrc | vk::BufferUsageFlagBits::eStorageBuffer,
+	    [&](uint8_t* mapped, uint64_t) {
+		if (!Libs::LibKernel::Memory::TryReadSparseBacking(vaddr, mapped, size)) {
+			EXIT("BufferCache: failed to read mapped guest image backing\n");
+		}
+	});
 }

 void BufferCache::FillBuffer(uint64_t vaddr, uint64_t size, uint32_t value, bool is_gds) {
@@ -645,6 +661,7 @@ void BufferCache::RunGarbageCollector() {
 		} else {
 			m_memory_tracker.UntrackMemory(buffer.CpuAddress(), buffer.Size());
 			DeleteBuffer(id);
+			Common::DebugCounters::Add(Common::DebugCounters::Counter::BufferEvictions);
 		}
 		return ++retire_count == limit;
 	});
@@ -673,6 +690,16 @@ void BufferCache::ProcessFaultBuffer() {
 	m_fault_manager.ProcessFaultBuffer();
 }

+void BufferCache::SynchronizeBda(const RangeSet& mapped) {
+	// Take before walking: writes queued during synchronization remain pending.
+	const auto pending = m_memory_tracker.TakeBdaSync();
+	pending.ForEach([&](uint64_t begin, uint64_t end) {
+		mapped.ForEachInRange(begin, end - begin, [this](uint64_t start, uint64_t finish) {
+			SynchronizeBuffersInRange(start, finish - start);
+		});
+	});
+}
+
 void BufferCache::SynchronizeBuffersInRange(uint64_t vaddr, uint64_t size) {
 	const auto end = vaddr + size;
 	auto       it  = m_buffers.upper_bound(vaddr);
@@ -80,7 +80,10 @@ public:
 	[[nodiscard]] bool IsRegionCpuModified(uint64_t vaddr, uint64_t size);
 	[[nodiscard]] bool IsRegionGpuModified(uint64_t vaddr, uint64_t size);
 	void               ProcessFaultBuffer();
-	void               SynchronizeBuffersInRange(uint64_t vaddr, uint64_t size);
+	void               SynchronizeBda(const RangeSet& mapped);
+	void               QueueBdaSync(uint64_t vaddr, uint64_t size) {
+		m_memory_tracker.QueueBdaSync(vaddr, size);
+	}
 	void               RunGarbageCollector();

 private:
@@ -114,6 +117,7 @@ private:
 	void DeleteBuffer(BufferId id);
 	[[nodiscard]] bool SynchronizeBuffer(Buffer& buffer, uint64_t vaddr, uint64_t size,
 	                                     bool is_written, bool is_texel_buffer);
+	void SynchronizeBuffersInRange(uint64_t vaddr, uint64_t size);
 	[[nodiscard]] vk::Buffer UploadCopies(Buffer& buffer, std::span<vk::BufferCopy> copies,
 	                                      uint64_t total_size);
 	[[nodiscard]] bool SynchronizeBufferFromImage(Buffer& buffer, uint64_t vaddr, uint64_t size);
@@ -67,11 +67,9 @@ Buffer::Buffer(GraphicContext& graphics, CommandScheduler& scheduler, MemoryUsag
 	buffer_info.usage       = flags;

 	const bool with_bda = bool(flags & vk::BufferUsageFlagBits::eShaderDeviceAddress);
-	const VmaAllocationCreateFlags bda_flag =
-	    with_bda ? VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT : 0;
 	VmaAllocationCreateInfo allocation_info {};
 	allocation_info.flags =
-	    VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | bda_flag | AllocationFlags(usage);
+	    VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | AllocationFlags(usage);
 	allocation_info.usage = AllocationUsage(usage);
 	allocation_info.preferredFlags = usage == MemoryUsage::DeviceLocal
 	                                     ? VkMemoryPropertyFlags {}
@@ -2,6 +2,7 @@

 #include "common/alignment.h"
 #include "common/assert.h"
+#include "common/debugCounters.h"
 #include "common/emulatorConfig.h"
 #include "common/logging/log.h"
 #include "common/profiler.h"
@@ -25,6 +26,7 @@
 #include <mutex>
 #include <span>
 #include <tuple>
+#include <utility>
 #include <vulkan/vulkan_format_traits.hpp>

 namespace Libs::Graphics {
@@ -198,9 +200,7 @@ TextureCache::BindingType TextureCache::UploadBinding(const Image& image) {

 ImageId TextureCache::InsertImage(const ImageInfo& info) {
 	const auto id = m_slot_images.insert(m_graphics, m_scheduler, info);
-	if (!info.data.Empty()) {
-		RegisterImage(id);
-	}
+	RegisterImage(id);
 	return id;
 }

@@ -251,14 +251,11 @@ void TextureCache::DeleteImage(ImageId id) {
 	if (image == nullptr || !image->registered) {
 		return;
 	}
-	if (!image->depth_id) {
-		std::vector<ImageId> associations;
-		m_slot_images.ForEach([&](ImageId candidate, const Image& associated) {
-			if (associated.depth_id == id) {
-				associations.push_back(candidate);
-			}
-		});
-		for (const auto association: associations) {
+	if (image->depth_id) {
+		std::erase(m_slot_images[image->depth_id].stencil_ids, id);
+	} else {
+		// Detach first: deleting each association also unlinks it from its depth owner.
+		for (const auto association: std::exchange(image->stencil_ids, {})) {
 			FreeImage(association);
 		}
 	}
@@ -266,15 +263,6 @@ void TextureCache::DeleteImage(ImageId id) {
 		EXIT("TextureCache: deleting a GPU-modified image without resolving its contents\n");
 	}
 	m_download_images.erase(id);
-	if (image->info.HasMetadata()) {
-		const auto metadata = m_surface_metas.find(image->info.metadata.range.address);
-		if (metadata != m_surface_metas.end() &&
-		    image->info.metadata.kind == ImageMetadataKind::Htile &&
-		    metadata->second.type == MetaDataInfo::Type::HTile) {
-			// A later binding may have reused this address for another metadata type.
-			m_surface_metas.erase(metadata);
-		}
-	}
 	UnregisterImage(id);
 	if (m_scheduler.Active()) {
 		m_scheduler.DeferOperation([this, id] { m_slot_images.erase(id); });
@@ -299,9 +287,6 @@ void TextureCache::TouchImage(Image& image) {

 void TextureCache::MarkAsMaybeDirty(ImageId id, Image& image) {
 	image.MarkMaybeCpuDirty();
-	if (image.NeedsMaybeCpuHash()) {
-		image.SetMaybeCpuHash(image.HashGuestEdges());
-	}
 	UntrackImage(id);
 }

@@ -413,7 +398,7 @@ void TextureCache::UntrackImageTail(ImageId id) {
 }

 void TextureCache::TrackImageDownload(ImageId id, Image& image) {
-	if (m_readback_linear_images && !image.info.IsTiled() && !image.info.data.Empty()) {
+	if (m_readback_linear_images && !image.info.IsTiled()) {
 		if (!image.IsGpuModified()) {
 			EXIT("TextureCache: cannot enroll a non-GPU-owned image for download\n");
 		}
@@ -457,27 +442,6 @@ TextureCache::ImageIds TextureCache::FindImagesInRegion(uint64_t address, uint64
 	return result;
 }

-ImageId TextureCache::GetNullImage(const ImageDesc& desc) {
-	const auto format = desc.info.pixel_format;
-	if (const auto found = m_null_images.find(format); found != m_null_images.end()) {
-		return found->second;
-	}
-	ImageInfo info {};
-	info.pixel_format    = desc.info.pixel_format;
-	info.guest_format    = desc.info.guest_format;
-	info.type            = Prospero::ImageType::kColor2D;
-	info.extent          = {1, 1, 1};
-	info.resources       = {1, 1};
-	info.pitch           = 1;
-	info.bytes_per_block = std::max(desc.info.bytes_per_block, 1u);
-	info.samples         = 1;
-	info.tile_mode       = Prospero::TileMode::kLinear;
-	info.mip_layout[0]   = {0, info.bytes_per_block, 1, 1};
-	const auto id        = InsertImage(info);
-	m_null_images.emplace(format, id);
-	return id;
-}
-
 void TextureCache::ValidateImageDesc(const ImageDesc& desc) const {
 	ImageOps::Validate(desc.info);
 	if (desc.view_info.format == vk::Format::eUndefined || desc.view_info.level_count == 0 ||
@@ -633,6 +597,9 @@ void TextureCache::CopyImage(ImageId destination_id, ImageId source_id) {
 void TextureCache::CopyImageMip(ImageId destination_id, ImageId source_id, uint32_t mip,
                                uint32_t layer) {
 	RefreshCopySource(source_id);
+	if (m_slot_images[destination_id].IsBufferModified()) {
+		RefreshImage(destination_id);
+	}
 	auto& destination = m_slot_images[destination_id];
 	auto& source      = m_slot_images[source_id];
 	TrackImage(destination_id);
@@ -717,7 +684,7 @@ ImageId TextureCache::ResolveDepthOverlap(const ImageInfo& requested, BindingTyp
 		info.linear_slice_stride = cached.info.linear_slice_stride;
 		info.first_tail_level    = cached.info.first_tail_level;
 	}
-	info.htile_clear_mask     = 0;
+	info.htile_initial_clear  = false;
 	const auto replacement_id = InsertImage(info);
 	auto&      replacement    = m_slot_images[replacement_id];
 	replacement.usage         = cached.usage;
@@ -749,15 +716,74 @@ ImageId TextureCache::ResolveDepthOverlap(const ImageInfo& requested, BindingTyp
 		           "TextureCache: unsupported unequal-sample depth overlap copy (%u -> %u)\n",
 		           cached.backing.samples, replacement.backing.samples);
 	}
+	if (info.IsDepth() && info.metadata.kind == ImageMetadataKind::Htile) {
+		// Copied depth supersedes pending clears from the previous native image.
+		const auto metadata = m_surface_metas.find(info.metadata.range.address);
+		if (metadata != m_surface_metas.end()) {
+			metadata->second.clear_mask.reset();
+		}
+	}
 	FreeImage(cached_id);
 	return replacement_id;
 }

+namespace BcAlias {
+
+bool Matches(const ImageInfo& requested, const ImageInfo& cached) {
+	return requested.guest_format != cached.guest_format &&
+	       requested.IsBlock() != cached.IsBlock() &&
+	       requested.tile_mode == cached.tile_mode &&
+	       requested.bytes_per_block == cached.bytes_per_block &&
+	       requested.samples == 1 && cached.samples == 1 &&
+	       (requested.data != cached.data || requested.resources != cached.resources ||
+	        requested.BlockExtent() != cached.BlockExtent()) &&
+	       !TextureCache::SameBacking(cached, requested, false);
+}
+
+bool Publish(TextureCache& cache, Image& image) {
+	if (!cache.CanDownload(image)) {
+		return false;
+	}
+	// ObtainBuffer preserves padding and records ownership before the GPU-only transfer.
+	auto [buffer, offset] =
+	    cache.m_buffer_cache.ObtainBuffer(image.info.data.address, image.info.data.size, true);
+	cache.DownloadImage(image, *buffer, offset, image.info.data.size, image.info.resources.levels);
+	image.ClearGpuModified();
+	image.MarkBufferModified();
+	return true;
+}
+
+void Resolve(TextureCache& cache, ImageId cached_id, ImageId merged_id) {
+	auto& cached = cache.m_slot_images[cached_id];
+	auto* merged = merged_id ? &cache.m_slot_images[merged_id] : nullptr;
+	// PS5 raw block images can span several packed BC mips. Transfer their complete
+	// guest bytes, including tail padding, before retiring the incompatible backing.
+	if (cached.SafeToDownload()) {
+		if (merged && merged->SafeToDownload() && !Publish(cache, *merged)) {
+			return;
+		}
+		if (!Publish(cache, cached)) {
+			return;
+		}
+		if (merged) {
+			merged->MarkBufferModified();
+		}
+	}
+	cached.binding.needs_rebind |= cached.binding.is_bound || cached.binding.is_target;
+	cache.FreeImage(cached_id);
+}
+
+} // namespace BcAlias
+
 TextureCache::OverlapResult TextureCache::ResolveOverlap(const ImageInfo& requested,
                                                         BindingType binding, ImageId cached_id,
                                                         ImageId merged_id) {
 	auto owner = m_slot_images.try_get(cached_id);
-	if (owner == nullptr) {
+	if (owner == nullptr || !owner->registered) {
+		return {merged_id};
+	}
+	if (BcAlias::Matches(requested, owner->info) && !owner->IsCpuDirty()) {
+		BcAlias::Resolve(*this, cached_id, merged_id);
 		return {merged_id};
 	}
 	auto&      cached       = *owner;
@@ -927,6 +953,7 @@ void TextureCache::UploadImage(Image& image, Buffer& source, uint64_t source_off
 		const auto linear = m_tiler.Detile(source.Handle(), source_offset, info);
 		const auto copies = info.BufferCopies(linear.offset);
 		destination.Upload(copies, linear.buffer, linear.offset, linear.size);
+		Common::DebugCounters::Add(Common::DebugCounters::Counter::TextureUploadBytes, linear.size);
 		return;
 	}

@@ -972,13 +999,11 @@ void TextureCache::UploadImage(Image& image, Buffer& source, uint64_t source_off
 		copies[0].imageExtent       = info.extent;
 	}
 	destination.Upload(copies, linear.buffer, linear.offset, linear.size);
+	Common::DebugCounters::Add(Common::DebugCounters::Counter::TextureUploadBytes, linear.size);
 }

 void TextureCache::InitializeImage(ImageId id) {
 	auto& image = m_slot_images[id];
-	if (image.info.data.Empty()) {
-		return;
-	}
 	TrackImage(id);
 	if (image.info.metadata.compression != VideoOutCompression::Uncompressed) {
 		if (image.IsCpuDirty()) {
@@ -1091,12 +1116,7 @@ void TextureCache::RefreshImage(ImageId id) {
 	}
 	TrackImage(id);
 	if (image.IsMaybeCpuDirty()) {
-		const auto hash = image.HashGuestEdges();
-		if (image.NeedsMaybeCpuHash()) {
-			image.SetMaybeCpuHash(hash);
-			return;
-		}
-		(void)image.ResolveMaybeCpuHash(hash);
+		(void)image.ResolveMaybeCpuHash(image.HashGuestEdges());
 	}
 	bool cpu_dirty = image.IsBufferModified() || image.IsDefinitelyCpuDirty();
 	if (image.info.metadata.compression != VideoOutCompression::Uncompressed) {
@@ -1150,6 +1170,12 @@ ImageId TextureCache::AssociateStencil(ImageId depth_id, GuestRange stencil) {
 		    plane.IsTiled() ? TileGetDepthPitch(plane.extent.width, 1, 0) : depth.info.pitch;
 		plane.bytes_per_block = 1;
 		plane.UpdateSize();
+		if (record.depth_id != depth_id) {
+			if (record.depth_id) {
+				std::erase(m_slot_images[record.depth_id].stencil_ids, association);
+			}
+			depth.stencil_ids.push_back(association);
+		}
 		record.info                 = plane;
 		record.depth_id             = depth_id;
 		record.stencil_subresources = depth.stencil_subresources;
@@ -1164,10 +1190,7 @@ ImageId TextureCache::FindImage(ImageDesc& desc, bool exact_format) {
 		EXIT("TextureCache: image lookup requires a valid command buffer\n");
 	}
 	ValidateImageDesc(desc);
-	if (desc.info.data.Empty()) {
-		std::scoped_lock lock {m_lock};
-		return GetNullImage(desc);
-	}
+	EXIT_IF(desc.info.data.Empty());
 	const auto metadata_base_layer = desc.view_info.base_layer;

 	ImageId result {};
@@ -1175,6 +1198,7 @@ ImageId TextureCache::FindImage(ImageDesc& desc, bool exact_format) {
 		std::scoped_lock lock {m_lock};
 		const auto       candidates =
 		    FindImagesInRegion(desc.info.data.address, desc.info.data.size, false);
+		bool block_alias = false;

 		for (const auto id: candidates) {
 			const auto& image = m_slot_images[id];
@@ -1193,6 +1217,9 @@ ImageId TextureCache::FindImage(ImageDesc& desc, bool exact_format) {
 			}
 			if (SameBacking(image.info, desc.info, exact_format)) {
 				result = id;
+			} else if (image.SafeToDownload() &&
+			           BcAlias::Matches(desc.info, image.info)) {
+				block_alias = true;
 			}
 		}

@@ -1210,6 +1237,15 @@ ImageId TextureCache::FindImage(ImageDesc& desc, bool exact_format) {
 					view_layer = overlap.layer;
 				}
 			}
+		} else if (block_alias) {
+			for (const auto candidate: candidates) {
+				const auto* owner = m_slot_images.try_get(candidate);
+				if (candidate != result && owner != nullptr && owner->registered &&
+				    !owner->IsCpuDirty() &&
+				    BcAlias::Matches(m_slot_images[result].info, owner->info)) {
+					BcAlias::Resolve(*this, candidate, result);
+				}
+			}
 		}

 		if (result && !m_slot_images[result].depth_id) {
@@ -1306,36 +1342,30 @@ vk::ImageView TextureCache::FindTexture(ImageId id, const ImageDesc& desc) {
 	std::scoped_lock lock {m_lock};
 	auto&            image = m_slot_images[id];
 	TouchImage(image);
-	if (!image.info.data.Empty()) {
-		if (!image.registered || image.depth_id || image.binding.needs_rebind) {
-			EXIT("TextureCache: texture requires rediscovery before final acquisition\n");
-		}
+	if (!image.registered || image.depth_id || image.binding.needs_rebind) {
+		EXIT("TextureCache: texture requires rediscovery before final acquisition\n");
 	}
 	if (desc.type == BindingType::Storage) {
 		image.MarkGpuModified();
 	}
-	if (!image.info.data.Empty()) {
-		RefreshImage(id);
-		if (image.info.HasStencil() &&
-		    desc.info.data.address >= image.info.stencil.address &&
-		    desc.info.data.End() <= image.info.stencil.End()) {
-			for (const auto stencil_id:
-			     FindImagesInRegion(image.info.stencil.address, image.info.stencil.size, false)) {
-				const auto* stencil = m_slot_images.try_get(stencil_id);
-				if (stencil != nullptr && stencil->depth_id == id &&
-				    stencil->info.data == image.info.stencil) {
-					RefreshImage(stencil_id);
-					break;
-				}
+	RefreshImage(id);
+	if (image.info.HasStencil() &&
+	    desc.info.data.address >= image.info.stencil.address &&
+	    desc.info.data.End() <= image.info.stencil.End()) {
+		for (const auto stencil_id:
+		     FindImagesInRegion(image.info.stencil.address, image.info.stencil.size, false)) {
+			const auto* stencil = m_slot_images.try_get(stencil_id);
+			if (stencil != nullptr && stencil->depth_id == id &&
+			    stencil->info.data == image.info.stencil) {
+				RefreshImage(stencil_id);
+				break;
 			}
 		}
 	}
 	switch (desc.type) {
 		case BindingType::Texture: break;
 		case BindingType::Storage:
-			if (!image.info.data.Empty()) {
-				CommitGpuWrite(image);
-			}
+			CommitGpuWrite(image);
 			TrackImageDownload(id, image);
 			break;
 		default: EXIT("TextureCache: invalid texture binding\n");
@@ -1372,7 +1402,6 @@ vk::ImageView TextureCache::FindDepthTarget(ImageId id, const ImageDesc& desc) {
 	}
 	TouchImage(image);
 	image.MarkGpuModified();
-	image.usage.depth_target = true;
 	if (desc.info.HasStencil()) {
 		const auto layers = image.info.resources.layers;
 		EXIT_IF(layers == 0 || image.info.data.size % layers != 0 ||
@@ -1388,9 +1417,13 @@ vk::ImageView TextureCache::FindDepthTarget(ImageId id, const ImageDesc& desc) {
 	image.info.stencil = desc.info.stencil;
 	image.info.metadata = desc.info.metadata;
 	if (desc.info.HasMetadata()) {
-		m_surface_metas.emplace(desc.info.metadata.range.address,
-		                        MetaDataInfo {.type       = MetaDataInfo::Type::HTile,
-		                                      .clear_mask = image.info.htile_clear_mask});
+		const auto [metadata, inserted] = m_surface_metas.try_emplace(desc.info.metadata.range.address);
+		if (inserted) {
+			metadata->second.type = MetaDataInfo::Type::HTile;
+			if (image.info.htile_initial_clear) {
+				metadata->second.clear_mask.set();
+			}
+		}
 	}
 	RefreshImage(id);
 	CommitGpuWrite(image);
@@ -1742,6 +1775,7 @@ bool TextureCache::DownloadImageMemory(ImageId id) {
 	download.Flush(offset, range.size);

 	DownloadImage(image, download, offset, range.size, image.info.resources.levels);
+	Common::DebugCounters::Add(Common::DebugCounters::Counter::TextureDownloadBytes, range.size);
 	vk::BufferMemoryBarrier barrier {};
 	barrier.srcAccessMask = vk::AccessFlagBits::eMemoryWrite | vk::AccessFlagBits::eTransferWrite |
 	                        vk::AccessFlagBits::eShaderWrite;
@@ -1788,7 +1822,7 @@ void TextureCache::InvalidateCpuAliases(uint64_t address, uint64_t size) {
 			continue;
 		}
 		if (owner->Overlaps(address, size)) {
-			owner->InvalidateCpuWrite(address, size);
+			owner->MarkCpuDirty();
 			UntrackImage(id);
 			continue;
 		}
@@ -1813,10 +1847,10 @@ bool TextureCache::IsMeta(uint64_t address) {
 bool TextureCache::IsMetaCleared(uint64_t address, uint32_t slice) {
 	std::scoped_lock lock {m_lock};
 	const auto       found = m_surface_metas.find(address);
-	if (found == m_surface_metas.end() || slice >= 32) {
+	if (found == m_surface_metas.end() || slice >= found->second.clear_mask.size()) {
 		return false;
 	}
-	return (found->second.clear_mask & (1u << slice)) != 0;
+	return found->second.clear_mask.test(slice);
 }

 bool TextureCache::ClearMeta(uint64_t address) {
@@ -1825,21 +1859,17 @@ bool TextureCache::ClearMeta(uint64_t address) {
 	if (found == m_surface_metas.end()) {
 		return false;
 	}
-	found->second.clear_mask = UINT32_MAX;
+	found->second.clear_mask.set();
 	return true;
 }

 bool TextureCache::TouchMeta(uint64_t address, uint32_t slice, bool is_clear) {
 	std::scoped_lock lock {m_lock};
 	const auto       found = m_surface_metas.find(address);
-	if (found == m_surface_metas.end() || slice >= 32) {
+	if (found == m_surface_metas.end() || slice >= found->second.clear_mask.size()) {
 		return false;
 	}
-	if (is_clear) {
-		found->second.clear_mask |= 1u << slice;
-	} else {
-		found->second.clear_mask &= ~(1u << slice);
-	}
+	found->second.clear_mask.set(slice, is_clear);
 	return true;
 }

@@ -1853,6 +1883,7 @@ void TextureCache::UnmapMemory(uint64_t address, uint64_t size) {
 		EXIT("TextureCache: invalid unmap range\n");
 	}
 	std::scoped_lock lock {m_lock};
+	// HTILE belongs to guest memory, independently of native image replacements.
 	for (auto metadata = m_surface_metas.begin(); metadata != m_surface_metas.end();) {
 		const auto base = metadata->first;
 		if (base >= address && base < address + size) {
@@ -1915,6 +1946,7 @@ void TextureCache::RunGarbageCollector() {
 				}
 			}
 			FreeImage(id);
+			Common::DebugCounters::Add(Common::DebugCounters::Counter::TextureEvictions);
 			if (m_total_used_memory < m_critical_gc_memory && aggressive) {
 				deletions >>= 2;
 				aggressive = false;
@@ -12,9 +12,9 @@
 #include "graphics/host_gpu/renderer/image/image.h"
 #include "graphics/host_gpu/renderer/image/tiler.h"

+#include <bitset>
 #include <map>
 #include <type_traits>
-#include <unordered_map>
 #include <unordered_set>
 #include <vector>

@@ -26,8 +26,15 @@ class BufferCache;
 class CommandBuffer;
 class CommandScheduler;
 class RenderExecutor;
+class TextureCache;
 struct TextureCacheTestAccess;

+namespace BcAlias {
+[[nodiscard]] bool Matches(const ImageInfo& requested, const ImageInfo& cached);
+[[nodiscard]] bool Publish(TextureCache& cache, Image& image);
+void Resolve(TextureCache& cache, ImageId cached, ImageId merged);
+} // namespace BcAlias
+
 class TextureCache {
 public:
 	enum class BindingType : uint8_t { Texture, Storage, RenderTarget, DepthTarget, VideoOut };
@@ -76,8 +83,9 @@ private:
 	struct MetaDataInfo {
 		enum class Type : uint8_t { CMask, FMask, HTile };

-		Type     type;
-		uint32_t clear_mask = UINT32_MAX;
+		Type type;
+		// PS5 DB_DEPTH_VIEW encodes 13-bit base and last array-slice indices.
+		std::bitset<8192> clear_mask;
 	};

 	struct OverlapResult {
@@ -107,7 +115,6 @@ private:
 	}

 	[[nodiscard]] ImageId     InsertImage(const ImageInfo& info);
-	[[nodiscard]] ImageId     GetNullImage(const ImageDesc& desc);
 	void                      RegisterImage(ImageId id);
 	void                      UnregisterImage(ImageId id);
 	void                      DeleteImage(ImageId id);
@@ -166,7 +173,6 @@ private:
 	BufferCache&                                      m_buffer_cache;
 	Common::SlotVector<Image>                         m_slot_images;
 	ImagePageTable                                    m_image_page_table;
-	std::unordered_map<vk::Format, ImageId>           m_null_images;
 	Common::LeastRecentlyUsedCache<ImageId, uint64_t> m_lru_cache;
 	std::unordered_set<ImageId>                       m_download_images;
 	std::map<uint64_t, MetaDataInfo>                  m_surface_metas;
@@ -181,6 +187,9 @@ private:
 	friend struct TextureCacheTestAccess;
 	friend class BufferCache;
 	friend class RenderExecutor;
+	friend bool BcAlias::Matches(const ImageInfo&, const ImageInfo&);
+	friend bool BcAlias::Publish(TextureCache&, Image&);
+	friend void BcAlias::Resolve(TextureCache&, ImageId, ImageId);
 };

 } // namespace Libs::Graphics
@@ -236,7 +236,8 @@ void RenderExecutor::ResolveRenderColorTarget(CommandBuffer& buffer, RenderColor
 		// DCC owns the clear when both planes are enabled; single-sample CMASK stays expanded.
 		desc.info.metadata.kind = has_dcc ? ImageMetadataKind::Dcc : ImageMetadataKind::Cmask;
 		desc.info.metadata.range = {has_dcc ? rt.dcc_addr.addr : rt.cmask.addr, metadata_size.size};
-		desc.info.metadata.clear_word           = rt.clear_word0.word0;
+		desc.info.metadata.clear_word =
+		    rt.clear_word0.word0 | (uint64_t {rt.clear_word1.word1} << 32u);
 		desc.info.metadata.clear_register_valid = true;
 	}
 	desc.view_info.format = target_format.format;
@@ -1,6 +1,7 @@
 #include "graphics/host_gpu/renderer/commandScheduler.h"

 #include "common/assert.h"
+#include "common/debugCounters.h"
 #include "common/logging/log.h"
 #include "graphics/host_gpu/graphicContext.h"

@@ -373,6 +374,7 @@ uint64_t CommandScheduler::Submit(SubmitInfo submit) {

 		result = graphics.queue.submit(1, &submit_info, nullptr);
 	}
+	Common::DebugCounters::Add(Common::DebugCounters::Counter::QueueSubmits);

 	if (result != vk::Result::eSuccess) {
 		ReportVulkanFatal("vkQueueSubmit", result, tick, m_command.m_debug_op,
@@ -874,14 +874,33 @@ void hw_check(const CommandBuffer& buffer) {
 	log_phase("done");

 	if (graphics_debug_dump_enabled() && RenderTargetMaskHasBoundMrt(buffer)) {
-		LOGF("MRT render target mask: 0x%08" PRIx32 "\n", hw.GetRenderTargetMask());
+		const auto& sh = hw.GetShaderRegisters();
+		LOGF("MRT render target mask: 0x%08" PRIx32
+		     " export_modes={%u,%u,%u,%u,%u,%u,%u,%u}\n",
+		     hw.GetRenderTargetMask(), sh.target_output_mode[0], sh.target_output_mode[1],
+		     sh.target_output_mode[2], sh.target_output_mode[3], sh.target_output_mode[4],
+		     sh.target_output_mode[5], sh.target_output_mode[6], sh.target_output_mode[7]);
 		for (uint32_t i = 0; i < 8; i++) {
 			const auto& mrt = hw.GetRenderTarget(i);
+			const auto& bc  = hw.GetBlendControl(i);
 			LOGF("\t RT%u addr=0x%010" PRIx64 " mask=0x%x fmt=0x%08" PRIx32
-			     " width=%u height=%u tile=%u\n",
+			     " type=%u order=%u shader_mask=0x%x"
+			     " width=%u height=%u tile=%u blend=%u bypass=%u clamp=%u round_mode=%u"
+			     " samples=%u fragments=%u dcc=%u dcc_addr=0x%010" PRIx64
+			     " cmask_clear=%u cmask_addr=0x%010" PRIx64
+			     " dcc_clear_key=%u clear={%08" PRIx32 ",%08" PRIx32 "}\n",
 			     i, mrt.base.addr, (hw.GetRenderTargetMask() >> (i * 4u)) & 0x0fu,
-			     static_cast<uint32_t>(mrt.info.format), mrt.attrib2.width + 1,
-			     mrt.attrib2.height + 1, static_cast<uint32_t>(mrt.attrib3.tile_mode));
+			     static_cast<uint32_t>(mrt.info.format), static_cast<uint32_t>(mrt.info.channel_type),
+			     static_cast<uint32_t>(mrt.info.channel_order), (sh.m_cbShaderMask >> (i * 4u)) & 0x0fu,
+			     mrt.attrib2.width + 1, mrt.attrib2.height + 1,
+			     static_cast<uint32_t>(mrt.attrib3.tile_mode), static_cast<uint32_t>(bc.enable),
+			     static_cast<uint32_t>(mrt.info.blend_bypass), static_cast<uint32_t>(mrt.info.blend_clamp),
+			     static_cast<uint32_t>(mrt.info.round_mode), mrt.attrib.num_samples,
+			     mrt.attrib.num_fragments,
+			     static_cast<uint32_t>(mrt.info.dcc_compression_enable), mrt.dcc_addr.addr,
+			     static_cast<uint32_t>(mrt.info.cmask_fast_clear_enable), mrt.cmask.addr,
+			     static_cast<uint32_t>(mrt.dcc.dcc_clear_key_enable), mrt.clear_word0.word0,
+			     mrt.clear_word1.word1);
 		}
 	}
 	if (rc.depth_clear_enable && hw.GetDepthClearValue() != 0.0f &&
@@ -177,9 +177,6 @@ static TextureCache::ImageDesc MakeDepthTargetDesc(const CommandBuffer& buffer,
 		if (z.htile_data_base_addr == 0 || (z.htile_data_base_addr & 0x7fffu) != 0) {
 			DepthFatal("invalid HTile metadata address");
 		}
-		if (z.depth_view.slice_max >= 32) {
-			DepthFatal("HTile clear tracking supports at most 32 slices");
-		}
 	}
 	if (!z.size.valid) {
 		DepthFatal("missing depth extent");
@@ -314,7 +311,6 @@ void RenderExecutor::ResolveRenderDepthTarget(CommandBuffer& buffer, RenderDepth
 	}
 	r.desc = MakeDepthTargetDesc(buffer, z);
 	r.depth_clear_enable      = rc.depth_clear_enable;
-	r.depth_load_clear_enable = r.depth_clear_enable;
 	r.depth_clear_value       = hw.GetDepthClearValue();
 	r.depth_test_enable       = dc.z_enable;
 	r.depth_write_enable      = r.depth_test_enable && dc.z_write_enable &&
@@ -424,9 +420,9 @@ vk::ImageAspectFlags RenderDepthInfo::AttachmentWriteAspects() const {
 	}

 	const auto           available = ImageViewOps::DepthAspectMask(format);
-	vk::ImageAspectFlags writes {};
+	vk::ImageAspectFlags writes = load_clear_aspects & available;
 	if ((available & vk::ImageAspectFlagBits::eDepth) &&
-	    (depth_load_clear_enable || depth_write_enable)) {
+	    depth_write_enable) {
 		writes |= vk::ImageAspectFlagBits::eDepth;
 	}
 	if (!(available & vk::ImageAspectFlagBits::eStencil)) {
@@ -464,8 +460,7 @@ vk::ImageAspectFlags RenderDepthInfo::AttachmentWriteAspects() const {
 		       (can_pass && depth_pass && state.passOp != vk::StencilOp::eKeep) ||
 		       (can_pass && depth_fail && state.depthFailOp != vk::StencilOp::eKeep);
 	};
-	if (stencil_clear_enable ||
-	    (stencil_test_enable && (face_writes(stencil_front) || face_writes(stencil_back)))) {
+	if (stencil_test_enable && (face_writes(stencil_front) || face_writes(stencil_back))) {
 		writes |= vk::ImageAspectFlagBits::eStencil;
 	}
 	return writes;
@@ -22,7 +22,7 @@ struct RenderDepthInfo {
 	// Discovery keeps guest image information but can remap the view into a larger cache image.
 	TextureCache::ImageDesc     desc;
 	bool                        depth_clear_enable       = false;
-	bool                        depth_load_clear_enable  = false;
+	vk::ImageAspectFlags        load_clear_aspects;
 	float                       depth_clear_value        = 0.0f;
 	bool                        depth_test_enable        = false;
 	// Effective draw writes; discovery applies test, target-write and clear controls.
@@ -29,10 +29,8 @@ struct CachedImageView {
 };

 struct ImageUsage {
-	bool texture       = false;
 	bool storage       = false;
 	bool render_target = false;
-	bool depth_target  = false;
 	bool video_out     = false;
 };

@@ -70,40 +68,25 @@ public:
 	void CopyImageWithBuffer(Image& source, Buffer& buffer, TileManager& tiler);
 	void CopyMip(Image& source, uint32_t mip, uint32_t layer);

-	void InvalidateCpuWrite(uint64_t vaddr, uint64_t size) {
-		if (ImageRangeOverlaps(info.data.address, info.data.size, vaddr, size)) {
-			m_cpu_dirty        = true;
-			m_maybe_cpu_dirty  = false;
-			m_maybe_hash_valid = false;
-		} else if (ImagePageRangesOverlap(info.data.address, info.data.size, vaddr, size)) {
-			m_maybe_cpu_dirty = true;
-		}
+	void MarkCpuDirty() {
+		m_cpu_dirty       = true;
+		m_maybe_cpu_dirty = false;
 	}

 	[[nodiscard]] bool IsCpuDirty() const { return m_cpu_dirty || m_maybe_cpu_dirty; }
 	[[nodiscard]] bool IsDefinitelyCpuDirty() const { return m_cpu_dirty; }
 	[[nodiscard]] bool IsMaybeCpuDirty() const { return m_maybe_cpu_dirty; }
 	void               MarkMaybeCpuDirty() {
-		if (!m_cpu_dirty) {
+		if (!IsCpuDirty()) {
+			m_maybe_cpu_hash  = HashGuestEdges();
 			m_maybe_cpu_dirty = true;
 		}
 	}
-	[[nodiscard]] bool NeedsMaybeCpuHash() const {
-		return m_maybe_cpu_dirty && !m_maybe_hash_valid;
-	}
-	void SetMaybeCpuHash(uint64_t hash) {
-		if (!NeedsMaybeCpuHash()) {
-			EXIT("image cannot initialize maybe-dirty hash\n");
-		}
-		m_maybe_cpu_hash   = hash;
-		m_maybe_hash_valid = true;
-	}
 	[[nodiscard]] bool ResolveMaybeCpuHash(uint64_t hash) {
-		if (!m_maybe_cpu_dirty || !m_maybe_hash_valid || m_cpu_dirty) {
+		if (!m_maybe_cpu_dirty || m_cpu_dirty) {
 			EXIT("image cannot resolve maybe-dirty hash\n");
 		}
-		m_maybe_cpu_dirty  = false;
-		m_maybe_hash_valid = false;
+		m_maybe_cpu_dirty = false;
 		m_cpu_dirty |= hash != m_maybe_cpu_hash;
 		return m_cpu_dirty;
 	}
@@ -112,9 +95,8 @@ public:
 		if (!IsCpuDirty()) {
 			EXIT("clean image cannot complete a refresh\n");
 		}
-		m_cpu_dirty        = false;
-		m_maybe_cpu_dirty  = false;
-		m_maybe_hash_valid = false;
+		m_cpu_dirty       = false;
+		m_maybe_cpu_dirty = false;
 	}

 	[[nodiscard]] bool IsGpuModified() const noexcept { return m_gpu_modified; }
@@ -149,6 +131,8 @@ public:
 	uint64_t         track_addr     = 0;
 	uint64_t         track_addr_end = 0;
 	ImageId          depth_id {};
+	// Stencil associations that refer to this depth image.
+	std::vector<ImageId> stencil_ids;
 	// The current stencil plane's mapping into the depth image, also retained by its association.
 	ImageSubresourceRange stencil_subresources;
 	uint64_t         tick_accessed_last = 0;
@@ -165,12 +149,11 @@ private:

 	GraphicContext&   m_graphics;
 	CommandScheduler& m_scheduler;
-	uint64_t          m_maybe_cpu_hash   = 0;
-	bool              m_cpu_dirty        = false;
-	bool              m_maybe_cpu_dirty  = false;
-	bool              m_maybe_hash_valid = false;
-	bool              m_gpu_modified     = false;
-	bool              m_buffer_modified  = false;
+	uint64_t          m_maybe_cpu_hash  = 0;
+	bool              m_cpu_dirty       = false;
+	bool              m_maybe_cpu_dirty = false;
+	bool              m_gpu_modified    = false;
+	bool              m_buffer_modified = false;
 };

 namespace ImageOps {
@@ -21,6 +21,53 @@ bool IsDepthPlane(const ImageInfo& info) {
 	        info.tile_mode == Prospero::TileMode::kLinear);
 }

+GuestRange TiledMipRange(const ImageInfo& info, uint32_t level) {
+	const auto& block = info.tiling.block;
+	if (info.tile_mode != Prospero::TileMode::kStandard4KB ||
+	    block.family != TileBlockFamily::Standard4KB || info.IsVolume() || info.samples != 1 ||
+	    info.HasMetadata() || level >= info.resources.levels || level >= info.mip_layout.size() ||
+	    info.tiling.texel_width == 0 || info.tiling.texel_height == 0) {
+		return {};
+	}
+	const auto extent = info.MipExtent(level);
+	const auto width  = (extent.width + info.tiling.texel_width - 1u) / info.tiling.texel_width;
+	const auto height = (extent.height + info.tiling.texel_height - 1u) / info.tiling.texel_height;
+	const auto& mip   = info.mip_layout[level];
+	uint32_t last = 0, origin = 0;
+	if (!std::has_single_bit(width) || !std::has_single_bit(height) ||
+	    width > block.block_width || height > block.block_height ||
+	    mip.tail_x > block.block_width - width || mip.tail_y > block.block_height - height ||
+	    mip.tail_x % width != 0 || mip.tail_y % height != 0 ||
+	    !TileGetBlockOffset(block, width - 1u, height - 1u, 0, last) ||
+	    !TileGetBlockOffset(block, mip.tail_x, mip.tail_y, 0, origin)) {
+		return {};
+	}
+	// Standard4KB interleaves monotonically ordered X/Y bits, so the last
+	// corner bounds every active texel. Tiling preserves any holes in this span.
+	const uint64_t size = uint64_t {last} + block.bytes_per_element;
+	if ((origin & (std::bit_ceil(size) - 1u)) != 0 || size > block.block_size - origin ||
+	    mip.offset > UINT64_MAX - origin) {
+		return {};
+	}
+	return {mip.offset + origin, size};
+}
+
+uint32_t CompactMipSize(const ImageInfo& info) {
+	if (info.resources.levels != 1 || info.resources.layers != 1) {
+		return 0;
+	}
+	const auto range = TiledMipRange(info, 0);
+	if (range.size == 0 || range.size % 4 != 0 || range.address != 0) {
+		return 0;
+	}
+	const auto alignment = std::max<uint64_t>(256, std::bit_ceil(range.size));
+	const auto in_block  = info.data.address & (info.tiling.block.block_size - 1u);
+	return (info.data.address & (alignment - 1u)) == 0 &&
+	               range.size <= info.tiling.block.block_size - in_block
+	           ? static_cast<uint32_t>(range.size)
+	           : 0;
+}
+
 } // namespace

 vk::Extent3D ImageInfo::MipExtent(uint32_t level) const {
@@ -34,6 +81,7 @@ void ImageInfo::UpdateSize() {
 	        extent.height == 0 || extent.depth == 0 || resources.levels == 0 ||
 	        resources.levels > mip_layout.size() || resources.layers == 0 || samples == 0 ||
 	        !std::has_single_bit(samples));
+	const bool auto_size = data.size == 0;
 	TileTextureElementLayout element {};
 	EXIT_NOT_IMPLEMENTED(!TileGetTextureElementLayout(guest_format, element));
 	if (bytes_per_block == 0) {
@@ -164,9 +212,86 @@ void ImageInfo::UpdateSize() {
 			linear_offset     = Add(mip.linear_offset, Multiply(mip.linear_size, active.depth));
 			mip_pitch         = std::max(mip_pitch >> 1u, 1u);
 		}
+		const auto compact_size = CompactMipSize(*this);
+		if (compact_size != 0 && (auto_size || data.size == compact_size)) {
+			data.size = mip_layout[0].size = compact_size;
+		}
 	}
 }

+uint32_t ImageInfo::DataAlignment() const {
+	if (!IsTiled()) {
+		return 256;
+	}
+	const auto compact_size = CompactMipSize(*this);
+	if (compact_size != 0 && data.size == compact_size && mip_layout[0].size == compact_size) {
+		return std::max(256u, std::bit_ceil(compact_size));
+	}
+	return tiling.block.block_size;
+}
+
+int32_t ImageInfo::SliceOf(const ImageInfo& container, int32_t mip) const noexcept {
+	if (!IsCompatible(container) || tile_mode != container.tile_mode || type != container.type ||
+	    IsVolume() || resources.levels != 1 || resources.layers == 0 ||
+	    container.resources.layers == 0 || mip < 0 ||
+	    static_cast<uint32_t>(mip) >= container.resources.levels ||
+	    container.resources.levels > container.mip_layout.size() ||
+	    !data.Valid() || !container.data.Valid() || data.address < container.data.address ||
+	    data.End() > container.data.End()) {
+		return -1;
+	}
+	if (HasStencil() != container.HasStencil() ||
+	    (HasStencil() && (stencil.address < container.stencil.address ||
+	                      stencil.End() > container.stencil.End()))) {
+		return -1;
+	}
+
+	const auto  level  = static_cast<uint32_t>(mip);
+	const auto& layout = container.mip_layout[level];
+	if (extent.width != std::max(container.extent.width >> level, 1u) ||
+	    extent.height != std::max(container.extent.height >> level, 1u) ||
+	    extent.depth != container.extent.depth || mip_layout[0].pitch != layout.pitch ||
+	    mip_layout[0].height != layout.height || layout.size == 0 ||
+	    layout.size % container.resources.layers != 0 ||
+	    container.data.size % container.resources.layers != 0 ||
+	    data.size % resources.layers != 0) {
+		return -1;
+	}
+
+	// PS5 block slices contain the entire reversed mip chain. A rebased tail
+	// descriptor covers its addressed span within the shared tail block.
+	const auto slice_stride = container.data.size / container.resources.layers;
+	const auto child_stride = data.size / resources.layers;
+	auto mip_offset = layout.offset;
+	auto mip_size   = layout.size / container.resources.layers;
+	const auto compact_size = CompactMipSize(*this);
+	if (compact_size != 0 && child_stride == compact_size && mip_layout[0].size == compact_size) {
+		const auto range = TiledMipRange(container, level);
+		if (range.size != compact_size) {
+			return -1;
+		}
+		mip_offset = range.address;
+		mip_size   = range.size;
+	} else if (mip_layout[0].tail_x != layout.tail_x || mip_layout[0].tail_y != layout.tail_y) {
+		return -1;
+	}
+	if (child_stride != mip_size || mip_offset >= slice_stride ||
+	    child_stride > slice_stride - mip_offset ||
+	    (resources.layers > 1 && child_stride != slice_stride)) {
+		return -1;
+	}
+	const auto address_delta = data.address - container.data.address;
+	if (address_delta < mip_offset || (address_delta - mip_offset) % slice_stride != 0) {
+		return -1;
+	}
+	const auto layer = (address_delta - mip_offset) / slice_stride;
+	if (layer > INT32_MAX || layer >= container.resources.layers ||
+	    resources.layers > container.resources.layers - layer) {
+		return -1;
+	}
+	return static_cast<int32_t>(layer);
+}
+
 uint64_t ImageInfo::LinearSize(uint32_t levels) const {
 	levels = levels == 0 ? resources.levels : levels;
 	EXIT_IF(levels == 0 || levels > resources.levels || levels > mip_layout.size());
@@ -27,7 +27,7 @@ struct ImageMetadataInfo {
 	GuestRange          range;
 	ImageMetadataKind   kind                 = ImageMetadataKind::None;
 	uint32_t            control              = 0;
-	uint32_t            clear_word           = 0;
+	uint64_t            clear_word           = 0;
 	VideoOutCompression compression          = VideoOutCompression::Uncompressed;
 	bool                stencil_compressed   = false;
 	bool                clear_register_valid = false;
@@ -69,7 +69,7 @@ struct ImageInfo {
 	GuestRange                   data;
 	GuestRange                   stencil;
 	ImageMetadataInfo            metadata;
-	uint32_t                     htile_clear_mask = UINT32_MAX;
+	bool                         htile_initial_clear = true;
 	vk::Format                   pixel_format     = vk::Format::eUndefined;
 	Prospero::BufferFormat       guest_format     = Prospero::BufferFormat::kInvalid;
 	Prospero::ImageType          type             = Prospero::ImageType::kColor2D;
@@ -88,6 +88,7 @@ struct ImageInfo {
 	uint32_t first_tail_level    = 16;

 	void                                           UpdateSize();
+	[[nodiscard]] uint32_t                         DataAlignment() const;
 	[[nodiscard]] uint64_t                         LinearSize(uint32_t levels = 0) const;
 	[[nodiscard]] vk::Extent3D                     MipExtent(uint32_t level) const;
 	[[nodiscard]] std::vector<vk::BufferImageCopy> BufferCopies(uint64_t buffer_offset = 0,
@@ -136,53 +137,7 @@ struct ImageInfo {
 		}
 		return -1;
 	}
-	[[nodiscard]] int32_t SliceOf(const ImageInfo& container, int32_t mip) const noexcept {
-		if (!IsCompatible(container) || tile_mode != container.tile_mode || type != container.type ||
-		    IsVolume() || resources.levels != 1 || resources.layers == 0 ||
-		    container.resources.layers == 0 || mip < 0 ||
-		    static_cast<uint32_t>(mip) >= container.resources.levels ||
-		    container.resources.levels > container.mip_layout.size() ||
-		    !data.Valid() || !container.data.Valid() || data.address < container.data.address ||
-		    data.End() > container.data.End()) {
-			return -1;
-		}
-		if (HasStencil() != container.HasStencil() ||
-		    (HasStencil() && (stencil.address < container.stencil.address ||
-		                      stencil.End() > container.stencil.End()))) {
-			return -1;
-		}
-
-		const auto  level  = static_cast<uint32_t>(mip);
-		const auto& layout = container.mip_layout[level];
-		if (extent.width != std::max(container.extent.width >> level, 1u) ||
-		    extent.height != std::max(container.extent.height >> level, 1u) ||
-		    extent.depth != container.extent.depth || mip_layout[0].pitch != layout.pitch ||
-		    mip_layout[0].height != layout.height || layout.size == 0 ||
-		    layout.size % container.resources.layers != 0 ||
-		    container.data.size % container.resources.layers != 0 ||
-		    data.size % resources.layers != 0) {
-			return -1;
-		}
-
-		// PS5 block slices contain the entire reversed mip chain.
-		const auto slice_stride = container.data.size / container.resources.layers;
-		const auto child_stride = data.size / resources.layers;
-		if (child_stride != layout.size / container.resources.layers ||
-		    layout.offset >= slice_stride || child_stride > slice_stride - layout.offset ||
-		    (resources.layers > 1 && child_stride != slice_stride)) {
-			return -1;
-		}
-		const auto address_delta = data.address - container.data.address;
-		if (address_delta < layout.offset || (address_delta - layout.offset) % slice_stride != 0) {
-			return -1;
-		}
-		const auto layer = (address_delta - layout.offset) / slice_stride;
-		if (layer > INT32_MAX || layer >= container.resources.layers ||
-		    resources.layers > container.resources.layers - layer) {
-			return -1;
-		}
-		return static_cast<int32_t>(layer);
-	}
+	[[nodiscard]] int32_t SliceOf(const ImageInfo& container, int32_t mip) const noexcept;
 };

 struct ImageViewInfo {
@@ -414,9 +369,10 @@ inline constexpr std::array<VideoOutFormatPolicy, 8> VIDEO_OUT_FORMAT_POLICIES {
 	return false;
 }

-[[nodiscard]] inline bool DecodePackedColorClear(vk::Format format, uint32_t packed,
+[[nodiscard]] inline bool DecodePackedColorClear(vk::Format format, uint64_t clear_words,
                                                 vk::ClearColorValue& clear) {
 	vk::ClearColorValue next {};
+	const auto packed = static_cast<uint32_t>(clear_words);
 	const auto unorm8 = [](uint32_t value) { return static_cast<float>(value & 0xffu) / 255.0f; };
 	const auto srgb8  = [](uint32_t value) {
 		const auto encoded = static_cast<float>(value & 0xffu) / 255.0f;
@@ -434,6 +390,15 @@ inline constexpr std::array<VideoOutFormatPolicy, 8> VIDEO_OUT_FORMAT_POLICIES {
 		                            (mantissa << 13u));
 	};
 	switch (format) {
+		case vk::Format::eB10G11R11UfloatPack32:
+			next.float32[0] = float16((packed & 0x7ffu) << 4u);
+			next.float32[1] = float16(((packed >> 11u) & 0x7ffu) << 4u);
+			next.float32[2] = float16((packed >> 22u) << 5u);
+			break;
+		case vk::Format::eR16G16B16A16Sfloat:
+			next.float32[2] = float16(static_cast<uint32_t>(clear_words >> 32u));
+			next.float32[3] = float16(static_cast<uint32_t>(clear_words >> 48u));
+			[[fallthrough]];
 		case vk::Format::eR16G16Sfloat:
 			next.float32[1] = float16(packed >> 16u);
 			[[fallthrough]];
@@ -444,9 +409,10 @@ inline constexpr std::array<VideoOutFormatPolicy, 8> VIDEO_OUT_FORMAT_POLICIES {
 		case vk::Format::eR16Unorm:
 			next.float32[0] = static_cast<float>(packed & 0xffffu) / 65535.0f;
 			break;
-		// A single-plane float target carries its clear as raw float bits, the same encoding the
-		// depth decoder below uses. Without this the clear is discarded and the target keeps stale
-		// contents.
+		// Each clear register stores one raw 32-bit float channel.
+		case vk::Format::eR32G32Sfloat:
+			next.float32[1] = std::bit_cast<float>(static_cast<uint32_t>(clear_words >> 32u));
+			[[fallthrough]];
 		case vk::Format::eR32Sfloat: next.float32[0] = std::bit_cast<float>(packed); break;
 		case vk::Format::eR32Uint: next.uint32[0] = packed; break;
 		case vk::Format::eR32Sint: next.int32[0] = static_cast<int32_t>(packed); break;
@@ -507,7 +473,7 @@ inline constexpr std::array<VideoOutFormatPolicy, 8> VIDEO_OUT_FORMAT_POLICIES {
 		clear = vk::ClearColorValue {};
 		return true;
 	}
-	return DecodePackedColorClear(format, packed, clear);
+	return DecodePackedColorClear(format, uint64_t {packed} | (uint64_t {packed} << 32u), clear);
 }

 [[nodiscard]] inline bool DecodePackedStencilClear(uint32_t packed, uint8_t& clear) {
@@ -31,18 +31,6 @@ namespace ImageViewOps {
 	       ImageViewOps::IsFormatDepthCompatible(view_format);
 }

-[[nodiscard]] inline bool IsValidImageSwizzle(uint32_t swizzle,
-                                             uint32_t component_count = 4) noexcept {
-	if ((swizzle & ~0xfffu) != 0) {
-		return false;
-	}
-	for (uint32_t channel = 0; channel < 4; channel++) {
-		const auto selector = GetDstSel(swizzle, channel);
-		if (selector > 1 && (selector < 4 || selector >= 4 + component_count)) return false;
-	}
-	return true;
-}
-
 [[noreturn]] inline void UnsupportedColorView(const char* usage, vk::Format image_format,
                                              vk::Format view_format, uint32_t swizzle) noexcept {
 	EXIT("unsupported %s color image view: image_format=%d view_format=%d swizzle=0x%03x\n", usage,
@@ -64,7 +64,10 @@ RenderTargetFormatInfo TextureGetRenderTargetFormat(Prospero::ChannelLayout layo
                                                    Prospero::ChannelOrder  order) {
 	const auto encoding = Prospero::ResolveRenderTargetFormat(layout, type);
 	if (encoding.IsValid() && encoding.SupportsOrder(order)) {
-		const auto host_format = ResolveHostFormat(encoding.buffer_format, order);
+		const auto backing_format = encoding.buffer_format == Prospero::BufferFormat::k11_11_10UNorm
+		                                ? Prospero::RemapTextureFormat(encoding.buffer_format)
+		                                : encoding.buffer_format;
+		const auto host_format = ResolveHostFormat(backing_format, order);
 		const auto bytes       = Prospero::RenderTargetBytesPerElement(encoding.buffer_format);
 		if (host_format.format != vk::Format::eUndefined && bytes != 0) {
 			const auto order_mapping =
@@ -1,6 +1,7 @@
 #include "graphics/host_gpu/renderer/masterSemaphore.h"

 #include "common/assert.h"
+#include "common/debugCounters.h"
 #include "graphics/host_gpu/graphicContext.h"

 namespace Libs::Graphics {
@@ -49,6 +50,8 @@ void MasterSemaphore::Wait(uint64_t tick) {
 	wait_info.pSemaphores    = &m_semaphore;
 	wait_info.pValues        = &tick;

+	Common::DebugCounters::ScopedTimer timer(Common::DebugCounters::Counter::GpuWaits,
+	                                         Common::DebugCounters::Counter::GpuWaitNs);
 	const auto result = m_graphics.device.waitSemaphores(&wait_info, UINT64_MAX);
 	EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess);
 	Refresh();
@@ -76,6 +76,10 @@ vk::DescriptorType NativeDescriptorType(BindingKind kind) {
 }

 vk::DescriptorImageInfo MakeImageInfo(const TextureBinding& texture, uint32_t element) {
+	if (!texture.image_id) {
+		EXIT_IF(texture.image_view != nullptr || !texture.mip_views.empty());
+		return {nullptr, nullptr, vk::ImageLayout::eGeneral};
+	}
 	vk::ImageView view = nullptr;
 	if (texture.mip_views.empty()) {
 		if (element == 0u) {
@@ -84,7 +88,7 @@ vk::DescriptorImageInfo MakeImageInfo(const TextureBinding& texture, uint32_t el
 	} else if (element < texture.mip_views.size()) {
 		view = texture.mip_views[element];
 	}
-	EXIT_IF(!texture.image_id || view == nullptr || texture.layout == vk::ImageLayout::eUndefined);
+	EXIT_IF(view == nullptr || texture.layout == vk::ImageLayout::eUndefined);
 	return {nullptr, view, texture.layout};
 }

@@ -122,9 +126,13 @@ NativeStorageBuffer(RenderContext& context, const PreparedBindings::BufferSource
 	if (size > graphics.GetPhysicalDeviceProperties().limits.maxStorageBufferRange) {
 		EXIT("storage buffer range is unsupported\n");
 	}
-	auto [buffer, offset] = context.GetBufferCache().ObtainBuffer(
-	    address, size, resource.written,
+	const bool metadata_read = resource.read && Config::SupportZmaskEnabled() &&
+	                           (address & 0x7fffu) == 0 &&
+	                           context.GetTextureCache().IsMeta(address);
+	auto [buffer, offset]    = context.GetBufferCache().ObtainBuffer(
+	    address, size, resource.written || metadata_read,
 	    resource.formatted || (resource.read && Config::SyncRawImageBuffersEnabled()), id);
+	if (metadata_read) buffer->Fill(offset, size, 0xf); // HTILE ZMask::kUncompressed.
 	const auto aligned_offset = Common::AlignDown(offset, alignment);
 	const auto adjustment     = offset - aligned_offset;
 	const auto max_range      = graphics.GetPhysicalDeviceProperties().limits.maxStorageBufferRange;
@@ -308,9 +316,10 @@ void ValidateStorageTexture(const ShaderRecompiler::IR::ImageResource& resource,
 	const bool descriptor_ok = IsSupportedStorageTextureDescriptor(resource, descriptor);
 	const bool encoding_ok   = IsSupportedStorageTextureEncoding(resource, descriptor);
 	const bool uint_resource    = resource.numeric_class == Prospero::TextureNumericClass::Uint;
-	const bool raw_sint_storage = format == Prospero::BufferFormat::k32SInt && uint_resource &&
-	                              resource.written && !resource.read && !resource.atomic;
-	const auto numeric_class = Prospero::SampledTextureNumericClass(format);
+	const bool raw_sint_storage = uint_resource &&
+	    ShaderRecompiler::IR::RawSignedStorageFormat(resource, format) != Prospero::BufferFormat::kInvalid;
+	const auto numeric_class =
+	    Prospero::SampledTextureNumericClass(Prospero::RemapTextureFormat(format));
 	const bool raw_float_atomic = format == Prospero::BufferFormat::k32Float && uint_resource &&
 	                              resource.atomic && !resource.atomic64;
 	const bool format_ok =
@@ -347,39 +356,6 @@ void ValidateStorageTexture(const ShaderRecompiler::IR::ImageResource& resource,
 	     descriptor.fields[5], descriptor.fields[6], descriptor.fields[7]);
 }

-static TextureCache::ImageDesc NullTextureDesc(const ShaderRecompiler::IR::ImageResource& resource,
-                                               TextureCache::BindingType                  binding) {
-	TextureCache::ImageDesc desc {};
-	switch (resource.numeric_class) {
-		case Prospero::TextureNumericClass::Float:
-			desc.info.guest_format = Prospero::BufferFormat::k32Float;
-			break;
-		case Prospero::TextureNumericClass::Uint:
-			desc.info.guest_format = resource.atomic64 ? Prospero::BufferFormat::k32_32UInt
-			                                         : Prospero::BufferFormat::k32UInt;
-			break;
-		case Prospero::TextureNumericClass::Sint:
-			desc.info.guest_format = Prospero::BufferFormat::k32SInt;
-			break;
-		default: EXIT("null image has unsupported numeric class\n");
-	}
-	desc.info.pixel_format    = VulkanFormat(desc.info.guest_format);
-	desc.info.type            = Prospero::ImageType::kColor2D;
-	desc.info.extent          = {1, 1, 1};
-	desc.info.resources       = {1, 1};
-	desc.info.bytes_per_block = Prospero::NumBytesPerElement(desc.info.guest_format);
-	desc.info.samples         = 1;
-	desc.info.mip_layout[0]   = {0, 0, 1, 1};
-	desc.view_info.format     = resource.atomic64 ? vk::Format::eR64Uint : desc.info.pixel_format;
-	desc.view_info.type       = vk::ImageViewType::e2D;
-	desc.view_info.aspect     = vk::ImageAspectFlagBits::eColor;
-	desc.view_info.usage      = binding == TextureCache::BindingType::Storage
-	                                ? vk::ImageUsageFlagBits::eStorage
-	                                : vk::ImageUsageFlagBits::eSampled;
-	desc.type                 = binding;
-	return desc;
-}
-
 static ImageViewInfo TextureViewInfo(const ShaderRecompiler::IR::ImageResource& resource,
                                     const ShaderTextureResource& descriptor, vk::Format format,
                                     const SurfaceFormatInfo& surface_format, bool storage,
@@ -515,10 +491,7 @@ TextureBinding RenderExecutor::ResolveTexture(const ShaderRecompiler::IR::ImageR

 	auto& texture_cache = m_context.GetTextureCache();
 	if (descriptor.IsNull()) {
-		auto       desc = NullTextureDesc(resource, storage ? TextureCache::BindingType::Storage
-		                                                    : TextureCache::BindingType::Texture);
-		const auto id   = texture_cache.FindImage(desc);
-		return {id, nullptr, std::move(desc)};
+		return {.layout = vk::ImageLayout::eGeneral};
 	}

 	const auto address         = descriptor.Base40();
@@ -566,7 +539,8 @@ TextureBinding RenderExecutor::ResolveTexture(const ShaderRecompiler::IR::ImageR
 	const bool shader_conversion =
 	    surface_format.conversion_format != Prospero::BufferFormat::kInvalid;
 	const bool sampled_numeric_class =
-	    storage || resource.numeric_class == Prospero::SampledTextureNumericClass(format);
+	    storage || resource.numeric_class ==
+	                   Prospero::SampledTextureNumericClass(Prospero::RemapTextureFormat(format));
 	if (!storage && resource.resource_class == ShaderRecompiler::IR::ImageResourceClass::Sampled &&
 	    !sampled_numeric_class) {
 		EXIT("sampled image numeric class mismatch: numeric=%u format=%u addr=0x%016" PRIx64 "\n",
@@ -585,10 +559,11 @@ TextureBinding RenderExecutor::ResolveTexture(const ShaderRecompiler::IR::ImageR
 			pixel_format = depth_format->depth_attachment_format;
 		}
 	}
+	const auto raw_sint_format = ShaderRecompiler::IR::RawSignedStorageFormat(resource, format);
 	const auto storage_view_format = resource.atomic64 ? vk::Format::eR64Uint
-	                                 : storage && (resource.atomic ||
-	                                               format == Prospero::BufferFormat::k32SInt)
-	                                     ? vk::Format::eR32Uint
+	                                 : storage && resource.atomic ? vk::Format::eR32Uint
+	                                 : raw_sint_format != Prospero::BufferFormat::kInvalid
+	                                     ? VulkanFormat(raw_sint_format)
 	                                     : SrgbStorageViewFormat(pixel_format);
 	const auto view_format         = storage && storage_view_format != vk::Format::eUndefined
 	                                     ? storage_view_format
@@ -605,6 +580,9 @@ TextureBinding RenderExecutor::ResolveTexture(const ShaderRecompiler::IR::ImageR
 	    block_bytes != 0 ? block_bytes : Prospero::NumBytesPerElement(format);
 	desc.info.samples   = samples;
 	desc.info.tile_mode = tile;
+	if (!resource.r128 && descriptor.MetaCompress() && tile != Prospero::TileMode::kDepth) {
+		desc.info.metadata.kind = ImageMetadataKind::Dcc;
+	}
 	if (levels > physical_levels) {
 		if (!ResolveTextureMipView(desc.info, physical_levels,
 		                           !resource.r128 && descriptor.MetaCompress(), view_levels,
@@ -617,8 +595,7 @@ TextureBinding RenderExecutor::ResolveTexture(const ShaderRecompiler::IR::ImageR
 	} else {
 		desc.info.UpdateSize();
 	}
-	const auto alignment =
-	    tile == Prospero::TileMode::kLinear ? 256u : desc.info.tiling.block.block_size;
+	const auto alignment = desc.info.DataAlignment();
 	EXIT_NOT_IMPLEMENTED(desc.info.data.size == 0 || alignment == 0 ||
 	                     (address & (static_cast<uint64_t>(alignment) - 1u)) != 0);
 	if (storage) {
@@ -629,7 +606,6 @@ TextureBinding RenderExecutor::ResolveTexture(const ShaderRecompiler::IR::ImageR
 		(void)TileGetDccSize(width, height, volume ? depth : image_layers,
 		                     desc.info.bytes_per_block, physical_levels, tile, metadata_size,
 		                     std::countr_zero(samples));
-		desc.info.metadata.kind          = ImageMetadataKind::Dcc;
 		desc.info.metadata.range         = {descriptor.MetaAddr() << 8u, metadata_size.size};
 		desc.info.metadata.dcc_alpha_msb = descriptor.DccAlphaPos();
 	}
@@ -685,10 +661,10 @@ static vk::DescriptorBufferInfo NativeUpload(RenderContext&            context,
 }

 void RenderExecutor::BindImage(ImageId id, bool storage) {
-	auto& image = m_context.GetTextureCache().GetImage(id);
-	if (image.info.data.Empty()) {
+	if (!id) {
 		return;
 	}
+	auto& image = m_context.GetTextureCache().GetImage(id);
 	if (image.binding.is_bound) {
 		image.binding.force_general |= image.binding.shader_write != storage;
 	}
@@ -841,8 +817,9 @@ void RenderExecutor::RebindImages(PreparedBindings& prepared) {
 	auto& texture_cache = m_context.GetTextureCache();
 	// Acquire each view before a later overlapping descriptor can replace its image.
 	for (uint32_t i = 0; i < program.info.images.size(); i++) {
+		if (!images[i].image_id) continue;
 		const auto old_image = texture_cache.m_slot_images.try_get(images[i].image_id);
-		if (old_image == nullptr || (!old_image->registered && !old_image->info.data.Empty()) ||
+		if (old_image == nullptr || !old_image->registered ||
 		    old_image->binding.needs_rebind) {
 			if (old_image != nullptr) {
 				old_image->binding = {};
@@ -873,7 +850,6 @@ void RenderExecutor::RebindImages(PreparedBindings& prepared) {
 		auto&      image   = texture_cache.GetImage(binding.image_id);
 		const bool storage = binding.desc.type == TextureCache::BindingType::Storage;
 		image.usage.storage |= storage;
-		image.usage.texture |= !storage;
 	}
 }

@@ -894,7 +870,7 @@ void RenderExecutor::PrepareGraphicsBindings(std::span<PreparedBindings* const>
 	for (auto& target: colors) {
 		EXIT_IF(!target.image_id);
 		const auto old_image = cache.m_slot_images.try_get(target.image_id);
-		if (old_image == nullptr || (!old_image->registered && !old_image->info.data.Empty()) ||
+		if (old_image == nullptr || !old_image->registered ||
 		    old_image->binding.needs_rebind) {
 			if (old_image != nullptr) {
 				old_image->binding = {};
@@ -1004,19 +980,14 @@ void RenderExecutor::CommitBindings(CommandBuffer&                     buffer,
 		}

 		for (uint32_t i = 0; i < program.info.images.size(); i++) {
-			auto& image   = m_context.GetTextureCache().GetImage(descriptors.images[i].image_id);
 			auto& binding = descriptors.images[i];
+			if (!binding.image_id) continue;
+			auto& image = m_context.GetTextureCache().GetImage(binding.image_id);
 			const auto&                 view = binding.desc.view_info;
 			const ImageSubresourceRange range {view.base_level, view.level_count, view.base_layer,
 			                                   view.layer_count};
 			const bool storage = binding.desc.type == TextureCache::BindingType::Storage;
-			if (image.info.data.Empty()) {
-				image.Transit(vk::ImageLayout::eGeneral,
-				              storage ? vk::AccessFlagBits2::eShaderRead |
-				                            vk::AccessFlagBits2::eShaderWrite
-				                      : vk::AccessFlagBits2::eShaderRead,
-				              range, vk_buffer);
-			} else if (image.binding.is_target) {
+			if (image.binding.is_target) {
 				const auto layout = image.binding.attachment_layout;
 				EXIT_IF(layout == vk::ImageLayout::eUndefined);
 				if (image.info.IsDepth()) {
@@ -1117,7 +1088,8 @@ void RenderExecutor::CommitBindings(CommandBuffer&                     buffer,
 		for (uint32_t i = 0; i < program.info.images.size(); ++i) {
 			const auto& resource = program.info.images[i];
 			const auto& texture = descriptors.images[i];
-			EXIT_IF(resource.mip_count != (texture.mip_views.empty() ? 1u : texture.mip_views.size()));
+			EXIT_IF(texture.image_id &&
+			        resource.mip_count != (texture.mip_views.empty() ? 1u : texture.mip_views.size()));
 			const auto kind = *ShaderRecompiler::IR::DescriptorBindingForImage(resource);
 			const auto start = image_starts[ShaderRecompiler::IR::ImageBindingIndex(kind)] +
 			                   resource.descriptor_index;
@@ -1,11 +1,13 @@
 #include "graphics/host_gpu/renderer/pipeline/pipelineCache.h"

 #include "common/assert.h"
+#include "common/debugCounters.h"
 #include "common/emulatorConfig.h"
 #include "common/file.h"
 #include "common/logging/log.h"
 #include "common/profiler.h"
 #include "common/threads.h"
+#include "graphics/guest_gpu/gpu_format.h"
 #include "graphics/guest_gpu/hardwareContext.h"
 #include "graphics/host_gpu/renderer/colorRenderTarget.h"
 #include "graphics/host_gpu/renderer/debug.h"
@@ -17,13 +19,13 @@
 #include "graphics/shader/recompiler/ShaderRecompiler.h"
 #include "graphics/shader/shaderCompiler.h"
 #include "kernel/memory.h"
-#include "kytyGitVersion.h"
 #include "loader/systemContent.h"

 #include <algorithm>
 #include <array>
 #include <atomic>
 #include <cctype>
+#include <chrono>
 #include <cstdio>
 #include <cstring>
 #include <fmt/format.h>
@@ -39,6 +41,8 @@ namespace Libs::Graphics {

 namespace {

+constexpr auto DriverCacheSaveInterval = std::chrono::minutes {5};
+
 uint8_t RemapSourceAlphaFactor(uint8_t factor) {
 	switch (static_cast<Prospero::BlendFactor>(factor)) {
 		case Prospero::BlendFactor::kSrcAlpha:
@@ -78,7 +82,8 @@ std::string DriverCacheSignature(const vk::PhysicalDeviceProperties& properties)
 		uuid[i * 2]     = hex[properties.pipelineCacheUUID[i] >> 4u];
 		uuid[i * 2 + 1] = hex[properties.pipelineCacheUUID[i] & 0xfu];
 	}
-	return fmt::format("KytyPC1:{}:{:08x}:{:08x}:{:08x}:{}\n", KYTY_GIT_REVISION,
+	// Driver cache entries already distinguish shader code and pipeline state across builds.
+	return fmt::format("KytyPC2:{:08x}:{:08x}:{:08x}:{}\n",
 	                   properties.vendorID, properties.deviceID, properties.driverVersion, uuid);
 }

@@ -148,7 +153,7 @@ void DumpShaderOriginal(const char* stage_name, uint64_t shader_hash,
 }

 bool ValidateShaderSpirv(const char* label, uint64_t shader_hash,
-                         const std::vector<uint32_t>& spirv) {
+                         const std::vector<uint32_t>& spirv, bool maintenance8_enabled) {
 	if (!Config::ShaderValidationEnabled()) {
 		return true;
 	}
@@ -160,7 +165,9 @@ bool ValidateShaderSpirv(const char* label, uint64_t shader_hash,
 		                        static_cast<int>(position.column), static_cast<int>(position.index),
 		                        message);
 	});
-	if (tools.Validate(spirv)) {
+	spvtools::ValidatorOptions validator_options;
+	validator_options.SetAllowOffsetTextureOperand(maintenance8_enabled);
+	if (tools.Validate(spirv.data(), spirv.size(), validator_options)) {
 		return true;
 	}
 	spvtools::SpirvTools disassembler(SPV_ENV_VULKAN_1_2);
@@ -294,16 +301,20 @@ struct PipelineCache::ProgramCache {
 	                               ShaderRecompiler::IR::ResourceSpecialization specialization,
 	                               uint32_t push_data_start_dword,
 	                               std::span<const uint32_t> function_code) {
+		Common::DebugCounters::ScopedTimer timer(Common::DebugCounters::Counter::ShadersCompiled,
+		                                         Common::DebugCounters::Counter::ShaderCompileNs,
+		                                         Common::DebugCounters::Peak::ShaderCompileNs);
 		auto result = ShaderRecompiler::CompileProgram(std::move(translated), options,
 		                                               specialization, push_data_start_dword);
-		if (!ValidateShaderSpirv(options.dump_label, options.shader_hash, result.spirv)) {
+		if (!ValidateShaderSpirv(options.dump_label, options.shader_hash, result.spirv,
+		                         options.maintenance8_enabled)) {
 			DumpShaderSpirv(stage_name, options.shader_hash, result.spirv);
 			EXIT("%s failed hash=0x%016" PRIx64 ": SPIR-V validation failed\n", options.dump_label,
 			     options.shader_hash);
 		}
 		DumpShaderSpirv(stage_name, options.shader_hash, result.spirv);

-		const auto module = CompileSPV(result.spirv, device);
+		const auto module = CompileSPV(result.spirv, graphics.device);
 		EXIT_IF(module == nullptr);
 		if (options.dump_ir) {
 			LOGF("%s SPIR-V words=%" PRIu64 " wave_size=%u\n", options.dump_label,
@@ -344,6 +355,7 @@ struct PipelineCache::ProgramCache {
 		};
 		if constexpr (std::is_same_v<InputInfo, ShaderComputeInputInfo>) {
 			runtime.workgroup_counts = input_info.workgroup_counts;
+			runtime.indirect_args_address = input_info.indirect_args_address;
 		}
 		bool source_changed = false;
 		if (entry != programs.end()) {
@@ -384,11 +396,13 @@ struct PipelineCache::ProgramCache {
 		}
 		ShaderRecompiler::CompileOptions options;
 		options.stage       = stage;
+		options.maintenance8_enabled = graphics.maintenance8_enabled;
 		options.shader_hash = params.hash;
 		options.user_data   = user_data;
 		options.back_code      = params.back_code;
 		options.dump_ir     = Config::GetShaderLogDirection() != Config::LogDirection::Silent;
 		options.early_dump  = options.dump_ir;
+		options.emit_debug_info = Config::GraphicsDebugDumpEnabled();
 		options.dump_label  = label;
 		options.input_info  = stage_input;

@@ -456,26 +470,27 @@ struct PipelineCache::ProgramCache {
 		return permutation.handle;
 	}

-	explicit ProgramCache(vk::Device device): device(device) {
+	explicit ProgramCache(GraphicContext& graphics): graphics(graphics) {
 		lookup_key.static_state.reserve(MaxStaticKeyWords);
 	}
 	~ProgramCache() {
 		for (const auto& [key, entry]: programs) {
 			(void)key;
 			for (const auto& permutation: entry.permutations) {
-				device.destroyShaderModule(permutation.handle.module, nullptr);
+				graphics.device.destroyShaderModule(permutation.handle.module, nullptr);
 			}
 		}
 	}

 	std::unordered_map<ProgramKey, SourceEntry, ProgramKeyHash> programs;
 	ProgramKey                                                  lookup_key;
-	vk::Device                                                  device;
+	GraphicContext&                                             graphics;
 	uint64_t                                                    next_shader_id = 0;
 };

 PipelineCache::PipelineCache(GraphicContext& graphics)
-    : m_graphics(graphics), m_program_cache(std::make_unique<ProgramCache>(graphics.device)) {
+    : m_graphics(graphics), m_program_cache(std::make_unique<ProgramCache>(graphics)),
+      m_next_driver_cache_save(std::chrono::steady_clock::now() + DriverCacheSaveInterval) {
 	EXIT_NOT_IMPLEMENTED(!Common::Thread::IsMainThread());
 	InitializeDriverCache();
 }
@@ -506,17 +521,6 @@ void PipelineCache::InitializeDriverCache() {
 		PipelineCacheLog("Vulkan pipeline cache: disabled (non-Release build)");
 		return;
 	}
-	const std::string_view git_hash     = KYTY_GIT_HASH;
-	const std::string_view git_revision = KYTY_GIT_REVISION;
-	if (git_hash == "unknown" || git_revision == "unknown") {
-		PipelineCacheLog("Vulkan pipeline cache: disabled (unknown git revision)");
-		return;
-	}
-	if (git_hash.ends_with("-dirty")) {
-		PipelineCacheLog("Vulkan pipeline cache: disabled (dirty build)");
-		return;
-	}
-
 	m_driver_cache_path     = std::filesystem::path("_PipelineCache") / (title_id + ".bin");
 	const auto path         = Common::PathToString(m_driver_cache_path);
 	const bool cache_exists = Common::File::IsFileExisting(m_driver_cache_path);
@@ -549,7 +553,7 @@ void PipelineCache::InitializeDriverCache() {
 			    XXH3_64bits(initial_data.data(), initial_data.size()) != payload_hash) {
 				initial_data.clear();
 				PipelineCacheLog(
-				    "Vulkan pipeline cache: invalidating {} (driver, emulator, or data mismatch)",
+				    "Vulkan pipeline cache: invalidating {} (driver or data mismatch)",
 				    path);
 			}
 		} else {
@@ -583,10 +587,21 @@ void PipelineCache::InitializeDriverCache() {
 	}
 }

-void PipelineCache::Save() {
+void PipelineCache::CheckpointDriverCache() {
 	if (m_driver_cache == nullptr) {
 		return;
 	}
+	m_driver_cache_dirty = true;
+	if (std::chrono::steady_clock::now() >= m_next_driver_cache_save) {
+		Save();
+	}
+}
+
+void PipelineCache::Save() {
+	if (m_driver_cache == nullptr || !m_driver_cache_dirty) {
+		return;
+	}
+	m_next_driver_cache_save = std::chrono::steady_clock::now() + DriverCacheSaveInterval;

 	size_t               size = 0;
 	vk::Result           result;
@@ -629,16 +644,19 @@ void PipelineCache::Save() {
 	}
 	const bool flushed = !file.IsInvalid() && file.Flush();
 	file.Close();
-	if (prefix_written != prefix.size() || payload_written != payload.size() || !flushed ||
-	    !Common::File::RenameFile(temp_path, m_driver_cache_path)) {
+	const bool written = prefix_written == prefix.size() && payload_written == payload.size() && flushed;
+	std::error_code error;
+	if (written) {
+		std::filesystem::rename(temp_path, m_driver_cache_path, error);
+	}
+	if (!written || error) {
 		PipelineCacheLog("Vulkan pipeline cache: failed to write {}",
 		                 Common::PathToString(m_driver_cache_path));
 		return;
 	}
 	PipelineCacheLog("Vulkan pipeline cache: saved {} bytes to {}", payload.size(),
 	                 Common::PathToString(m_driver_cache_path));
-	m_graphics.device.destroyPipelineCache(m_driver_cache, nullptr);
-	m_driver_cache = nullptr;
+	m_driver_cache_dirty = false;
 }

 PipelineCache::GraphicsPrograms PipelineCache::GetGraphicsPrograms(
@@ -654,6 +672,17 @@ PipelineCache::GraphicsPrograms PipelineCache::GetGraphicsPrograms(
 		vertex_params[0] = PrepareProgram(vertex_regs, context, user_config, vertex_info[0]);
 	}
 	const bool mesh_active = vertex_info[0].logical_stage == ShaderType::Mesh;
+	const bool object_primitive_id = context.HasObjectPrimitiveIdOutput();
+	if (object_primitive_id) {
+		// CxObjectIdMode: register source plus a 32-bit pipelined primitive-ID addition.
+		EXIT_NOT_IMPLEMENTED(sh.m_paClObjprimIdCntl != 2u || mesh_active || tess_active ||
+		                     !pixel_active || (sh.m_vgtDrawPayloadCntl & 8u) == 0 ||
+		                     user_config.GetPrimType() != Prospero::PrimitiveType::kTriList);
+		const auto& target = context.GetRenderTarget(7);
+		EXIT_NOT_IMPLEMENTED(Prospero::ResolveRenderTargetFormat(target.info.format,
+		                                                       target.info.channel_type)
+		                         .buffer_format != Prospero::BufferFormat::k32UInt);
+	}
 	if (mesh_active) {
 		EXIT_NOT_IMPLEMENTED(!m_graphics.mesh_shader_enabled);
 		auto& mesh              = vertex_info[0].mesh;
@@ -675,6 +704,29 @@ PipelineCache::GraphicsPrograms PipelineCache::GetGraphicsPrograms(
 	ShaderParams pixel_params;
 	if (pixel_active) {
 		pixel_params      = PrepareProgram(pixel_regs, sh, target_export_mapping, pixel_info);
+		pixel_info.object_primitive_id = object_primitive_id;
+		for (uint32_t export_index = 0; export_index < 8u; export_index++) {
+			const auto slot = ShaderPixelExportTarget(pixel_info.target_shader_mask, export_index);
+			if (slot >= 8u || pixel_info.target_output_mode[export_index] == 0u) continue;
+			const auto& rt = context.GetRenderTarget(slot);
+			const auto target_mask = render_target_mask_slot(context.GetRenderTargetMask(), slot);
+			if (rt.base.addr == 0 || target_mask == 0u) continue;
+			const auto format = Prospero::ResolveRenderTargetFormat(rt.info.format, rt.info.channel_type);
+			if (format.buffer_format != Prospero::BufferFormat::k11_11_10UNorm) continue;
+			const auto mapping = pixel_info.target_export_mapping[export_index];
+			const auto shader_mask = render_target_mask_slot(pixel_info.target_shader_mask, slot);
+			const bool blend = context.GetBlendControl(slot).enable && !rt.info.blend_bypass;
+			if (blend || (mapping.ApplyMask(target_mask) & 7u) != 7u ||
+			    (mapping.ApplyMask(shader_mask) & 7u) != 7u ||
+			    pixel_info.target_output_mode[export_index] != 9u) {
+				EXIT("unsupported packed UNorm render-target export: slot=%u export=%u mode=%u "
+				     "target_mask=0x%x shader_mask=0x%x mapping=0x%02x blend=%u\n",
+				     slot, export_index, pixel_info.target_output_mode[export_index], target_mask,
+				     shader_mask, mapping.packed, static_cast<uint32_t>(blend));
+			}
+			pixel_info.target_packed_unorm_mask |= 1u << export_index;
+			pixel_info.target_round_mode |= static_cast<uint8_t>(rt.info.round_mode) << export_index;
+		}
 		if (!mesh_active && !tess_active && Prospero::IsRectList(user_config.GetPrimType())) {
 			pixel_info.parameter_mode = ShaderPixelParameterMode::Rectangle;
 		} else if (context.GetModeControl().provoking_vtx_last) {
@@ -731,8 +783,8 @@ PipelineCache::GraphicsPrograms PipelineCache::GetGraphicsPrograms(
 		    static_cast<float>(std::min(limits.maxViewportDimensions[1], 16384u)) * 0.5f;
 		clip.enabled = true;
 	}
-	uint32_t          push_data_cursor =
-	    mesh_active ? ShaderRecompiler::IR::PushData::MeshDrawDwordCount : 0;
+	uint32_t push_data_cursor = ShaderRecompiler::IR::PushData::GraphicsDrawDwords(
+	    mesh_active, object_primitive_id);
 	GraphicsPrograms  result;
 	if (pixel_active) {
 		result.pixel = m_program_cache->Get(pixel_params, pixel_info, push_data_cursor);
@@ -797,6 +849,9 @@ PipelineCache::Pipeline& PipelineCache::GetGraphicsPipeline(
 		EXIT_IF(!colors[i].image_id || colors[i].desc.view_info.format == vk::Format::eUndefined);
 		static_params.color_mask[slot] = colors[i].export_mapping.ApplyMask(
 		    render_target_mask_slot(ctx.GetRenderTargetMask(), colors[i].target_slot));
+		if (colors[i].desc.info.guest_format == Prospero::BufferFormat::k11_11_10UNorm) {
+			static_params.color_mask[slot] = 1u;
+		}
 		rendering.color_formats[slot] = colors[i].desc.view_info.format;
 		if (attachment_samples == 0) {
 			attachment_samples = colors[i].desc.info.samples;
@@ -943,8 +998,13 @@ PipelineCache::Pipeline& PipelineCache::GetGraphicsPipeline(

 	auto cached = std::make_unique<Pipeline>();
 	LogPipelineTrace("CreatePipelineInternal begin", vs_id, ps_id);
-	CreatePipelineInternal(m_graphics, *cached, rendering, key.vertex_input, vertex_info,
-	                       ps_input_info, programs, static_params, m_driver_cache);
+	{
+		Common::DebugCounters::ScopedTimer timer(Common::DebugCounters::Counter::PipelinesCreated,
+		                                         Common::DebugCounters::Counter::PipelineCreateNs,
+		                                         Common::DebugCounters::Peak::PipelineCreateNs);
+		CreatePipelineInternal(m_graphics, *cached, rendering, key.vertex_input, vertex_info,
+		                       ps_input_info, programs, static_params, m_driver_cache);
+	}
 	LogPipelineTrace("CreatePipelineInternal done", vs_id, ps_id);

 	EXIT_NOT_IMPLEMENTED(cached->pipeline == nullptr);
@@ -952,6 +1012,7 @@ PipelineCache::Pipeline& PipelineCache::GetGraphicsPipeline(

 	auto [iter, inserted] = m_graphics_pipelines.emplace(std::move(key), std::move(cached));
 	EXIT_IF(!inserted);
+	CheckpointDriverCache();

 	return *iter->second;
 }
@@ -973,13 +1034,20 @@ PipelineCache::GetComputePipeline(const ShaderComputeInputInfo& input_info,
 	}

 	auto cached = std::make_unique<Pipeline>();
-	CreatePipelineInternal(m_graphics, *cached, input_info, compute_program.module, m_driver_cache);
+	{
+		Common::DebugCounters::ScopedTimer timer(Common::DebugCounters::Counter::PipelinesCreated,
+		                                         Common::DebugCounters::Counter::PipelineCreateNs,
+		                                         Common::DebugCounters::Peak::PipelineCreateNs);
+		CreatePipelineInternal(m_graphics, *cached, input_info, compute_program.module,
+		                       m_driver_cache);
+	}

 	EXIT_NOT_IMPLEMENTED(cached->pipeline == nullptr);
 	EXIT_NOT_IMPLEMENTED(cached->pipeline_layout == nullptr);

 	auto [iter, inserted] = m_compute_pipelines.emplace(compute_program.id, std::move(cached));
 	EXIT_IF(!inserted);
+	CheckpointDriverCache();

 	return *iter->second;
 }
@@ -8,6 +8,7 @@
 #include "graphics/host_gpu/vulkanCommon.h"
 #include "graphics/shader/shader.h"

+#include <chrono>
 #include <cstddef>
 #include <filesystem>
 #include <memory>
@@ -173,11 +174,14 @@ private:
 	std::unique_ptr<ProgramCache> m_program_cache;
 	vk::PipelineCache             m_driver_cache = nullptr;
 	std::filesystem::path         m_driver_cache_path;
+	std::chrono::steady_clock::time_point m_next_driver_cache_save;
+	bool                          m_driver_cache_dirty = false;
 	std::unordered_map<GraphicsPipelineKey, std::unique_ptr<Pipeline>, GraphicsPipelineKeyHash>
 	                                                        m_graphics_pipelines;
 	std::unordered_map<uint64_t, std::unique_ptr<Pipeline>> m_compute_pipelines;

 	void InitializeDriverCache();
+	void CheckpointDriverCache();
 };

 void LogPipelineTrace(const char* phase, uint64_t vertex_program_id, uint64_t pixel_program_id);
@@ -19,6 +19,7 @@
 #include "graphics/shader/shader.h"

 #include <algorithm>
+#include <array>
 #include <bit>
 #include <limits>
 #include <span>
@@ -192,9 +193,30 @@ static void AddLayoutBindings(std::vector<vk::DescriptorSetLayoutBinding>& descr

 static void CreateDescriptorLayout(GraphicContext& graphics, PipelineCache::Pipeline& pipeline,
                                   std::span<const vk::DescriptorSetLayoutBinding> bindings) {
-	uint32_t descriptor_count = 0;
+	const auto& limits = graphics.GetPhysicalDeviceProperties().limits;
+	uint64_t descriptor_count = 0;
+	uint64_t storage_buffers = 0;
+	std::array<uint64_t, 32> stage_buffers {}, stage_resources {};
 	for (const auto& binding: bindings) {
 		descriptor_count += binding.descriptorCount;
+		const bool storage = binding.descriptorType == vk::DescriptorType::eStorageBuffer;
+		if (storage) storage_buffers += binding.descriptorCount;
+		for (auto stages = static_cast<uint32_t>(binding.stageFlags); stages != 0; stages &= stages - 1u) {
+			const auto stage = std::countr_zero(stages);
+			if (storage) stage_buffers[stage] += binding.descriptorCount;
+			if (binding.descriptorType != vk::DescriptorType::eSampler)
+				stage_resources[stage] += binding.descriptorCount;
+			if (stage_buffers[stage] > limits.maxPerStageDescriptorStorageBuffers ||
+			    stage_resources[stage] > limits.maxPerStageResources) {
+				EXIT("native descriptor stage %u exceeds device limits: buffers=%" PRIu64
+				     "/%u resources=%" PRIu64 "/%u\n", stage, stage_buffers[stage],
+				     limits.maxPerStageDescriptorStorageBuffers, stage_resources[stage], limits.maxPerStageResources);
+			}
+		}
+	}
+	if (storage_buffers > limits.maxDescriptorSetStorageBuffers) {
+		EXIT("native storage-buffer descriptors exceed device limit: %" PRIu64 "/%u\n",
+		     storage_buffers, limits.maxDescriptorSetStorageBuffers);
 	}
 	pipeline.uses_push_descriptors = descriptor_count <= graphics.max_push_descriptors;

@@ -196,11 +196,13 @@ private:
 	                                               std::span<PreparedBindings* const> stages = {});
 	[[nodiscard]] bool        ResolveColorTargets(CommandBuffer& buffer,
 	                                              uint32_t render_target_slice_offset);
+	[[nodiscard]] bool        ConsumeMetadataColorOperation(CommandBuffer& buffer,
+	                                                       uint32_t render_target_slice_offset);
 	void                      BindImage(ImageId id, bool storage);
 	void                      BindRenderTarget(ImageId id);
 	void                      ResetBindings();
-	[[nodiscard]] bool        TryConsumeComputeMetaClear(const ShaderComputeInputInfo& input,
-	                                                     const CommandBuffer&          buffer);
+	void                     UpdateComputeMetaClears(const ShaderComputeInputInfo& input,
+	                                                 const CommandBuffer&          buffer);
 	[[nodiscard]] bool TryConsumeComputeImageClear(const ShaderComputeInputInfo& input,
 	                                              CommandBuffer& command, uint32_t group_x,
 	                                              uint32_t group_y, uint32_t group_z, uint32_t mode);
@@ -1,5 +1,6 @@
 #include "common/assert.h"
 #include "common/common.h"
+#include "common/debugCounters.h"
 #include "common/emulatorConfig.h"
 #include "common/file.h"
 #include "common/logging/log.h"
@@ -22,6 +23,7 @@
 #include "graphics/shader/recompiler/ir/passes/ResourceMaterialization.h"
 #include "graphics/shader/shader.h"
 #include "kernel/eventQueue.h"
+#include "kernel/memory.h"
 #include "kernel/pthread.h"
 #include "libs/errno.h"

@@ -49,8 +51,8 @@ static bool FillSourcesDisjoint(std::span<const ShaderRecompiler::IR::Descriptor
 	return true;
 }

-bool RenderExecutor::TryConsumeComputeMetaClear(const ShaderComputeInputInfo& input,
-                                                const CommandBuffer&          buffer) {
+void RenderExecutor::UpdateComputeMetaClears(const ShaderComputeInputInfo& input,
+                                            const CommandBuffer&          buffer) {
 	const auto& program   = *input.stage.program;
 	const auto& resources = *input.stage.resources;
 	if (resources.buffers.size() != program.info.buffers.size()) {
@@ -60,10 +62,9 @@ bool RenderExecutor::TryConsumeComputeMetaClear(const ShaderComputeInputInfo& in
 	for (uint32_t i = 0; i < program.info.buffers.size(); i++) {
 		const auto& resource   = program.info.buffers[i];
 		const auto  descriptor = DecodeNativeDescriptor<ShaderBufferResource>(resources.buffers[i]);
-		// A metadata resource that is also read is not proven to be a full overwrite. Execute it
-		// conservatively instead of replacing the dispatch with a coarse full-surface clear.
+		// Reads and transforms of metadata do not establish a clear state.
 		if ((!resource.written || resource.read) && cache.IsMeta(descriptor.Base48())) {
-			return false;
+			return;
 		}
 	}

@@ -73,13 +74,10 @@ bool RenderExecutor::TryConsumeComputeMetaClear(const ShaderComputeInputInfo& in
 			if (resource.written) {
 				const auto descriptor =
 				    DecodeNativeDescriptor<ShaderBufferResource>(resources.buffers[i]);
-				if (cache.ClearMeta(descriptor.Base48())) {
-					return true;
-				}
+				(void)cache.ClearMeta(descriptor.Base48());
 			}
 		}
 	}
-	return false;
 }

 bool ResolveComputeBufferFill(const ShaderComputeInputInfo& input, uint32_t group_x,
@@ -97,9 +95,10 @@ bool ResolveComputeBufferFill(const ShaderComputeInputInfo& input, uint32_t grou
 	constexpr std::array formats {
 	    Prospero::BufferFormat::k32UInt, Prospero::BufferFormat::k32_32UInt,
 	    Prospero::BufferFormat::k32_32_32UInt, Prospero::BufferFormat::k32_32_32_32UInt};
+	// Offset-or-swizzle bounds do not describe the element range proved by the shader.
 	if (descriptor.Stride() != element_size || descriptor.Format() != formats[fill.words - 1] ||
 	    descriptor.SwizzleEnabled() || descriptor.IndexStride() != 0 || descriptor.AddTid() ||
-	    descriptor.Base48() == 0) {
+	    descriptor.OutOfBounds() == 3 || descriptor.Base48() == 0) {
 		return false;
 	}
 	if (input.threads_num[0] == 0 || input.threads_num[0] != fill.group_stride[0] ||
@@ -111,7 +110,11 @@ bool ResolveComputeBufferFill(const ShaderComputeInputInfo& input, uint32_t grou
 	                                 ? group_x
 	                                 : static_cast<uint64_t>(group_x) * input.threads_num[0];
 	const auto     size        = descriptor.GetSize();
-	if (invocations != descriptor.NumRecords() || size == 0 || size > UINT32_MAX ||
+	const auto elements = descriptor.NumRecords();
+	const bool covered = fill.bounded_elements != 0
+	                         ? fill.bounded_elements == elements && invocations >= elements
+	                         : invocations == elements;
+	if (!covered || invocations > uint64_t {UINT32_MAX} + 1 || size == 0 || size > UINT32_MAX ||
 	    (input.dispatch_thread_dimensions &&
 	     (group_x % input.threads_num[0] != 0 || input.dispatch_threads_num[0] != group_x ||
 	      input.dispatch_threads_num[1] != 1 || input.dispatch_threads_num[2] != 1))) {
@@ -255,10 +258,6 @@ void RenderExecutor::DispatchDirect(uint64_t submit_id, CommandBuffer& buffer,
 		return;
 	}

-	if (sh_ctx.GetCs().cs_regs.data_addr == 0) {
-		return;
-	}
-
 	constexpr uint32_t DISPATCH_INITIATOR_USE_THREAD_DIMENSIONS = 1u << 5u;
 	constexpr uint32_t DISPATCH_INITIATOR_BASE_BITS             = 0x41u;
 	constexpr uint32_t DISPATCH_INITIATOR_MODIFIER_BITS         = 0xa038u;
@@ -306,12 +305,14 @@ void RenderExecutor::DispatchDirect(uint64_t submit_id, CommandBuffer& buffer,

 	const auto& program   = *input_info.stage.program;
 	const auto& resources = *input_info.stage.resources;
-	if (resources.specialization_reads.empty() &&
-	    (TryConsumeComputeMetaClear(input_info, buffer) ||
-	     TryConsumeComputeImageClear(input_info, buffer, thread_group_x, thread_group_y,
-	                                 thread_group_z, mode))) {
-		ResetBindings();
-		return;
+	if (resources.specialization_reads.empty()) {
+		// Cached metadata addresses can be reused as ordinary buffers; preserve their guest writes.
+		UpdateComputeMetaClears(input_info, buffer);
+		if (TryConsumeComputeImageClear(input_info, buffer, thread_group_x, thread_group_y,
+		                               thread_group_z, mode)) {
+			ResetBindings();
+			return;
+		}
 	}

 	if (use_thread_dimensions) {
@@ -376,11 +377,12 @@ void RenderExecutor::DispatchDirect(uint64_t submit_id, CommandBuffer& buffer,
 		    });
 		const uint32_t frame_num = static_cast<uint32_t>(m_context.GetGpu().GetFrameNum());
 		LOGF("GraphicsRenderDispatchDirect: frame=%u shader=0x%016" PRIx64
-		     " hash=0x%016" PRIx64 " tick=%" PRIu64
+		     " hash=0x%016" PRIx64 " tick=%" PRIu64 " completed_tick=%" PRIu64
 		     " groups=%ux%ux%u mode=0x%08" PRIx32 " local=%ux%ux%u "
 		     "buffers=%zu textures=%zu sampled=%zu storage=%zu samplers=%zu push=%u\n",
 		     frame_num, sh_ctx.GetCs().cs_regs.data_addr, program.shader_hash,
 		     m_context.GetCommandScheduler().CurrentTick(),
+		     m_context.GetCommandScheduler().GetMasterSemaphore().KnownGpuTick(),
 		     thread_group_x, thread_group_y, thread_group_z, mode,
 		     input_info.threads_num[0], input_info.threads_num[1],
 		     input_info.threads_num[2], program.info.buffers.size(), program.info.images.size(),
@@ -431,6 +433,7 @@ void RenderExecutor::DispatchDirect(uint64_t submit_id, CommandBuffer& buffer,

 	vk_buffer.bindPipeline(vk::PipelineBindPoint::eCompute, pipeline.pipeline);
 	vk_buffer.dispatch(thread_group_x, thread_group_y, thread_group_z);
+	Common::DebugCounters::Add(Common::DebugCounters::Counter::Dispatches);

 	// The removed host fence also ordered read-only dispatches before later writers.
 	ShaderAccessBarrier(vk_buffer, vk::PipelineStageFlagBits::eComputeShader);
@@ -446,12 +449,19 @@ void RenderExecutor::DispatchIndirect(uint64_t submit_id, CommandBuffer& buffer,
 	                    static_cast<uint32_t>(args_addr), static_cast<uint32_t>(args_addr >> 32u),
 	                    0, mode, buffer.GetShaders().GetCs().cs_regs.data_addr);
 	Common::LockGuard lock(m_context.GetMutex());
+	vk::DispatchIndirectCommand args {};
+	if (!m_context.GetBufferCache().HasGpuDirtyBytes(args_addr, sizeof(args)) &&
+	    LibKernel::Memory::TryReadBacking(args_addr, &args, sizeof(args)) &&
+	    (args.x == 0 || args.y == 0 || args.z == 0)) {
+		return;
+	}
 	const auto& cs_regs = buffer.GetShaders().GetCs();
 	if (cs_regs.cs_regs.data_addr == 0) {
 		return;
 	}
 	ShaderComputeInputInfo input_info {};
 	input_info.async_compute = async_compute;
+	input_info.indirect_args_address = args_addr;
 	const auto compute_program = m_context.GetPipelineCache().GetComputeProgram(
 	    cs_regs, buffer.GetRegisters().GetShaderRegisters(), input_info);
 	buffer.EndRendering();
@@ -493,6 +503,7 @@ void RenderExecutor::DispatchIndirect(uint64_t submit_id, CommandBuffer& buffer,
 	                          1, &barrier, 0, nullptr, 0, nullptr);
 	vk_buffer.bindPipeline(vk::PipelineBindPoint::eCompute, pipeline.pipeline);
 	vk_buffer.dispatchIndirect(args_buffer->Handle(), args_offset);
+	Common::DebugCounters::Add(Common::DebugCounters::Counter::Dispatches);
 	ShaderAccessBarrier(vk_buffer, vk::PipelineStageFlagBits::eComputeShader);
 	ResetBindings();
 }
@@ -90,6 +90,7 @@ bool RenderContext::IsMapped(uint64_t vaddr, uint64_t size) const noexcept {
 void RenderContext::MapMemory(uint64_t vaddr, uint64_t size) {
 	std::lock_guard lock(m_mapped_ranges_mutex);
 	m_mapped_ranges.Add(vaddr, size);
+	m_buffer_cache.QueueBdaSync(vaddr, size);
 }

 void RenderContext::UnmapMemory(uint64_t vaddr, uint64_t size) {
@@ -129,9 +130,7 @@ void RenderContext::PrepareBda() {
 		m_bda_logged = true;
 	}
 	std::shared_lock lock(m_mapped_ranges_mutex);
-	m_mapped_ranges.ForEach([this](uint64_t start, uint64_t end) {
-		m_buffer_cache.SynchronizeBuffersInRange(start, end - start);
-	});
+	m_buffer_cache.SynchronizeBda(m_mapped_ranges);
 	m_fault_process_pending = true;
 }

@@ -2,6 +2,7 @@

 #include "common/assert.h"
 #include "common/common.h"
+#include "common/debugCounters.h"
 #include "common/emulatorConfig.h"
 #include "common/file.h"
 #include "common/logging/log.h"
@@ -507,14 +508,15 @@ RenderState RenderExecutor::AcquireRenderTargets(CommandBuffer& buffer, RenderCo
 		}
 		const auto  image_view = cache.FindDepthTarget(depth.image_id, depth.desc);
 		const auto& metadata   = depth.desc.info.metadata;
-		if (metadata.kind == ImageMetadataKind::Htile && depth.depth_clear_enable &&
-		    !cache.ClearMeta(metadata.range.address)) {
-			EXIT("failed to acquire HTile metadata for a depth clear\n");
-		}
 		const bool meta_clear =
 		    metadata.kind == ImageMetadataKind::Htile &&
 		    cache.IsMetaCleared(metadata.range.address, depth.desc.view_info.base_layer);
-		depth.depth_load_clear_enable = depth.depth_clear_enable || meta_clear;
+		depth.load_clear_aspects = {};
+		if (depth.depth_clear_enable || meta_clear)
+			depth.load_clear_aspects |= vk::ImageAspectFlagBits::eDepth;
+		// Apply pending clears to compressed stencil as well as depth.
+		if (depth.stencil_clear_enable || (meta_clear && metadata.stencil_compressed))
+			depth.load_clear_aspects |= vk::ImageAspectFlagBits::eStencil;
 		if (meta_clear &&
 		    !cache.TouchMeta(metadata.range.address, depth.desc.view_info.base_layer, false)) {
 			EXIT("failed to consume HTile clear state\n");
@@ -536,7 +538,10 @@ RenderState RenderExecutor::AcquireRenderTargets(CommandBuffer& buffer, RenderCo
 			}
 		}
 		if (feedback_aspects && !m_context.GetGraphics().attachment_feedback_loop_enabled) {
-			EXIT("depth attachment feedback loop is not supported by the host\n");
+			static std::atomic_bool logged = false;
+			if (!logged.exchange(true, std::memory_order_relaxed)) {
+				std::printf("depth attachment feedback loop is not supported by the host\n");
+			}
 		}
 		auto layout = depth_attachment_layout(depth);
 		if (sampled_aspects & ~DepthReadableAspects(layout)) {
@@ -564,9 +569,11 @@ RenderState RenderExecutor::AcquireRenderTargets(CommandBuffer& buffer, RenderCo
 		attachment.clear_value[0] = std::bit_cast<uint32_t>(depth.depth_clear_value);
 		attachment.clear_value[1] = depth.stencil_clear_value;
 		attachment.has_depth      = static_cast<bool>(aspects & vk::ImageAspectFlagBits::eDepth);
-		attachment.depth_clear    = depth.depth_load_clear_enable;
+		attachment.depth_clear =
+		    static_cast<bool>(depth.load_clear_aspects & vk::ImageAspectFlagBits::eDepth);
 		attachment.has_stencil    = static_cast<bool>(aspects & vk::ImageAspectFlagBits::eStencil);
-		attachment.stencil_clear  = depth.stencil_clear_enable;
+		attachment.stencil_clear =
+		    static_cast<bool>(depth.load_clear_aspects & vk::ImageAspectFlagBits::eStencil);
 	}
 	if (color_count == 0 && !depth.image_id) {
 		const auto& limits = buffer.GetGraphics().GetPhysicalDeviceProperties().limits;
@@ -585,7 +592,7 @@ RenderState RenderExecutor::AcquireRenderTargets(CommandBuffer& buffer, RenderCo
 static uint32_t DrawColorOutputMask(const HW::Context& ctx) {
 	const auto& sh_regs     = ctx.GetShaderRegisters();
 	const auto  write_mask  = ctx.GetRenderTargetMask() & sh_regs.m_cbShaderMask;
-	uint32_t    output_mask = 0;
+	uint32_t    output_mask = ctx.HasObjectPrimitiveIdOutput() ? 1u << 7u : 0;
 	for (uint32_t index = 0; index < RENDER_COLOR_ATTACHMENTS_MAX; index++) {
 		const auto slot = ShaderPixelExportTarget(sh_regs.m_cbShaderMask, index);
 		if (slot >= RENDER_COLOR_ATTACHMENTS_MAX) {
@@ -608,16 +615,19 @@ enum class CbColorMode : uint8_t {
 	DccDecompress      = 6,
 };

-static bool ConsumeMetadataColorOperation(const CommandBuffer& buffer) {
+bool RenderExecutor::ConsumeMetadataColorOperation(CommandBuffer& buffer,
+                                                   uint32_t render_target_slice_offset) {
 	const auto& ctx  = buffer.GetRegisters();
 	const auto  mode = ctx.GetColorControl().mode;
-	// These special modes run color-buffer metadata or decompression operations. The shader is a
-	// vehicle for that operation, and its exported color must not be applied as a normal draw.
-	// Kyty stores expanded Vulkan images rather than compressed guest surfaces, so no equivalent
-	// hardware pass is emitted. Tracked DCC clear state is materialized on attachment bind;
-	// future CMask/FMask support can consume its state through the same TextureCache path.
-	return mode == static_cast<uint8_t>(CbColorMode::EliminateFastClear) ||
-	       mode == static_cast<uint8_t>(CbColorMode::FmaskDecompress) ||
+	if (mode == static_cast<uint8_t>(CbColorMode::EliminateFastClear)) {
+		// FCE can precede any ordinary draw. Discover the target to materialize its native
+		// clear metadata before the expanded image is sampled.
+		RenderColorInfo target {};
+		ResolveRenderColorTarget(buffer, target, render_target_slice_offset, 0, true);
+		return true;
+	}
+	// Metadata/decompression shaders must not export colors into the expanded image.
+	return mode == static_cast<uint8_t>(CbColorMode::FmaskDecompress) ||
 	       mode == static_cast<uint8_t>(CbColorMode::DccDecompress);
 }

@@ -902,7 +912,8 @@ bool RenderExecutor::PrepareDrawRenderState(CommandBuffer& buffer, const DrawCal
 	uint32_t mrt_mask = 0;
 	if (state.ps_active) {
 		for (const auto& output: state.ps_input_info.stage.program->info.outputs) {
-			if (output.kind == ShaderRecompiler::IR::StageOutputKind::Mrt) {
+			if (output.kind == ShaderRecompiler::IR::StageOutputKind::Mrt ||
+			    output.kind == ShaderRecompiler::IR::StageOutputKind::ObjectPrimitiveId) {
 				mrt_mask |= 1u << output.location;
 			}
 		}
@@ -1038,7 +1049,7 @@ bool RenderExecutor::CopyDepthToColor(CommandBuffer& buffer, const DrawCallInfo&
 	const auto& hw = buffer.GetRegisters();
 	auto& depth = state.depth_info;
 	auto& color = state.color_info[0];
-	EXIT_NOT_IMPLEMENTED(!m_context.GetGraphics().depth_color_copy_enabled ||
+	EXIT_NOT_IMPLEMENTED(!m_context.GetGraphics().maintenance8_enabled ||
 	                     !Prospero::IsRectList(ucfg.GetPrimType()) ||
 	                     draw.IsIndexed() || draw.index_count != 3 || draw.instance_count != 1 ||
 	                     emit.first_vertex != 0 || emit.first_instance != 0 ||
@@ -1053,7 +1064,7 @@ bool RenderExecutor::CopyDepthToColor(CommandBuffer& buffer, const DrawCallInfo&
 	                     state.ps_input_info.ps_sample_mask_export_enable);
 	vk::ImageAspectFlags feedback;
 	const auto rendering = AcquireRenderTargets(buffer, &color, 1, depth, feedback);
-	if (depth.depth_load_clear_enable) {
+	if (depth.load_clear_aspects) {
 		m_context.GetCommandScheduler().BeginRendering(rendering);
 	}
 	auto& cache = m_context.GetTextureCache();
@@ -1179,21 +1190,29 @@ void RenderExecutor::ExecutePreparedDraw(uint64_t submit_id, CommandBuffer& buff
 		SetDrawDebugPhase(buffer, submit_id, draw, 0x300u);
 	}
 	CommitBindings(buffer, vk::PipelineBindPoint::eGraphics, pipeline, stages);
-	if (mesh_active) {
-		const uint32_t draw_data[] {
-		    draw.index_count,
-		    draw.IsIndexed() ? static_cast<uint32_t>(emit.vertex_offset) : emit.first_vertex,
-		    emit.first_instance, index_source.guest_element_size,
-		    static_cast<uint32_t>(index_source.address),
-		    static_cast<uint32_t>(index_source.address >> 32u)};
-		static_assert(std::size(draw_data) == ShaderRecompiler::IR::PushData::MeshDrawDwordCount);
-		vk_buffer.pushConstants(pipeline.pipeline_layout,
-		                        vk::ShaderStageFlagBits::eMeshEXT |
-		                            vk::ShaderStageFlagBits::eFragment,
-		                        0, sizeof(draw_data), draw_data);
-	} else {
+	if (!mesh_active) {
 		CommitIndexBuffer(vk_buffer, index_binding);
 	}
+	const auto draw_dwords = ShaderRecompiler::IR::PushData::GraphicsDrawDwords(
+	    mesh_active, state.ps_input_info.object_primitive_id);
+	if (draw_dwords != 0) {
+		std::array<uint32_t, ShaderRecompiler::IR::PushData::MeshDrawDwordCount> draw_data {};
+		const auto draw_stages = vk::ShaderStageFlagBits::eFragment |
+		                         (mesh_active ? vk::ShaderStageFlagBits::eMeshEXT
+		                                      : vk::ShaderStageFlagBits::eVertex);
+		if (mesh_active) {
+			draw_data = {
+			    draw.index_count,
+			    draw.IsIndexed() ? static_cast<uint32_t>(emit.vertex_offset) : emit.first_vertex,
+			    emit.first_instance, index_source.guest_element_size,
+			    static_cast<uint32_t>(index_source.address),
+			    static_cast<uint32_t>(index_source.address >> 32u)};
+		} else {
+			draw_data[0] = buffer.GetUserConfig().GetObjectId();
+		}
+		vk_buffer.pushConstants(pipeline.pipeline_layout, draw_stages, 0,
+		                        draw_dwords * sizeof(uint32_t), draw_data.data());
+	}

 	auto& dynamic_state = m_context.GetCommandScheduler().GetDynamicState();
 	UpdateGraphicsDynamicState(buffer, dynamic_state, vertex_stages.back(), state.depth_info,
@@ -1215,6 +1234,8 @@ void RenderExecutor::ExecutePreparedDraw(uint64_t submit_id, CommandBuffer& buff
 	} else {
 		EmitDrawPrimitives(ucfg, vk_buffer, draw, emit);
 	}
+	Common::DebugCounters::Add(Common::DebugCounters::Counter::Draws);
+	Common::DebugCounters::Add(Common::DebugCounters::Counter::DrawInstances, draw.instance_count);

 	if (!draw.IsIndexed()) {
 		SetDrawDebugPhase(buffer, submit_id, draw, 0x600u);
@@ -1257,7 +1278,8 @@ void RenderExecutor::DrawIndex(uint64_t submit_id, CommandBuffer& buffer,
 		return;
 	}

-	if (ConsumeMetadataColorOperation(buffer) || DepthStencilCopy(buffer) ||
+	if (ConsumeMetadataColorOperation(buffer, args.render_target_slice_offset) ||
+	    DepthStencilCopy(buffer) ||
 	    ResolveColorTargets(buffer, args.render_target_slice_offset)) {
 		ResetBindings();
 		return;
@@ -1370,7 +1392,8 @@ void RenderExecutor::DrawAuto(uint64_t submit_id, CommandBuffer& buffer, const D
 		return;
 	}

-	if (ConsumeMetadataColorOperation(buffer) || DepthStencilCopy(buffer) ||
+	if (ConsumeMetadataColorOperation(buffer, args.render_target_slice_offset) ||
+	    DepthStencilCopy(buffer) ||
 	    ResolveColorTargets(buffer, args.render_target_slice_offset)) {
 		ResetBindings();
 		return;
@@ -97,6 +97,24 @@ uint64_t GraphicContext::GetDeviceMemoryUsage() const {
 	return usage;
 }

+uint32_t GraphicContext::GetHeapUsage(std::span<HeapUsage, VK_MAX_MEMORY_HEAPS> heaps) const {
+	if (allocator == nullptr) {
+		return 0;
+	}
+	VmaBudget budgets[VK_MAX_MEMORY_HEAPS] {};
+	vmaGetHeapBudgets(allocator, budgets);
+	const auto count = physical_device_memory_properties.memoryHeapCount;
+	for (uint32_t heap = 0; heap < count; heap++) {
+		const auto& properties = physical_device_memory_properties.memoryHeaps[heap];
+		heaps[heap] = {.usage        = budgets[heap].usage,
+		               .budget       = budgets[heap].budget,
+		               .allocations  = budgets[heap].statistics.allocationCount,
+		               .device_local = static_cast<bool>(properties.flags &
+		                                                 vk::MemoryHeapFlagBits::eDeviceLocal)};
+	}
+	return count;
+}
+
 uint64_t GraphicContext::GetTotalMemoryBudget() const {
 	if (allocator == nullptr) {
 		return 0;
@@ -0,0 +1,747 @@
+#include "graphics/presentation/performanceOverlay.h"
+
+#include "common/debugCounters.h"
+#include "common/emulatorConfig.h"
+#include "common/hostStats.h"
+#include "graphics/host_gpu/graphicContext.h"
+#include "imgui.h"
+#include "kernel/memory.h"
+
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <cstdarg>
+#include <cstdio>
+#include <mutex>
+#include <optional>
+#include <stop_token>
+#include <thread>
+
+namespace Libs::Graphics {
+
+namespace {
+
+using Clock   = std::chrono::steady_clock;
+using Counter = Common::DebugCounters::Counter;
+using Peak    = Common::DebugCounters::Peak;
+
+constexpr auto   REFRESH_INTERVAL  = std::chrono::seconds(1);
+constexpr size_t FRAME_HISTORY     = 120;
+constexpr float  FRAME_GRAPH_MS    = 50.0f;
+constexpr float  FRAME_TIME_GOOD   = 17.5f;
+constexpr float  FRAME_TIME_MEDIUM = 34.0f;
+constexpr size_t COUNTER_COUNT     = static_cast<size_t>(Counter::Count);
+
+// Tables as wide as their columns; the default fills the window, which an auto-resizing
+// window then never shrinks.
+constexpr ImGuiTableFlags TABLE_FLAGS =
+    ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_NoHostExtendX;
+
+constexpr ImU32 GOOD    = IM_COL32(96, 220, 120, 255);
+constexpr ImU32 MEDIUM  = IM_COL32(230, 195, 60, 255);
+constexpr ImU32 BAD     = IM_COL32(235, 80, 70, 255);
+constexpr ImU32 NEUTRAL = IM_COL32(160, 160, 160, 255);
+
+struct FrameWindow {
+	std::array<float, FRAME_HISTORY> intervals_ms {};
+	size_t                           next         = 0;
+	size_t                           count        = 0;
+	uint32_t                         flips        = 0;
+	float                            max_ms       = 0.0f;
+	uint32_t                         guest_width  = 0;
+	uint32_t                         guest_height = 0;
+	Clock::time_point                last_flip    = {};
+	Clock::time_point                window_start = {};
+};
+
+// Shown values, recomputed once per refresh interval.
+struct Snapshot {
+	double                              fps          = 0.0;
+	double                              frame_ms     = 0.0;
+	double                              max_frame_ms = 0.0;
+	double                              low_fps      = 0.0; // From the 99th percentile.
+	double                              stalled_s    = 0.0;
+	uint32_t                            guest_width  = 0;
+	uint32_t                            guest_height = 0;
+	std::array<double, COUNTER_COUNT>   rates {};
+	std::array<uint64_t, COUNTER_COUNT> totals {};
+	uint64_t                            shader_compile_peak_ns  = 0;
+	uint64_t                            pipeline_create_peak_ns = 0;
+	Common::HostStats                   host;
+	std::optional<uint64_t>             device_memory;
+	uint64_t                            device_budget = 0;
+	std::array<GraphicContext::HeapUsage, VK_MAX_MEMORY_HEAPS> heaps {};
+	uint32_t                                                   heap_count = 0;
+	std::array<float, FRAME_HISTORY>                           history {};
+	size_t                                                     history_count = 0;
+	Clock::time_point                                          sample_time {};
+	LibKernel::Memory::DebugStats                              guest_memory;
+};
+
+std::mutex            g_frame_mutex;
+FrameWindow           g_frames;
+std::atomic<uint64_t> g_generation {0};
+std::atomic<bool>     g_details {false};
+std::atomic<uint64_t> g_revision {0};
+
+std::mutex                  g_host_mutex;
+Common::HostStats           g_host_stats;
+uint64_t                    g_host_generation = 0;
+std::condition_variable_any g_sampler_wait;
+std::jthread                g_sampler;
+
+void SetOverlayEnabled(bool enabled) {
+	{
+		std::scoped_lock lock(g_host_mutex);
+		if (enabled) {
+			std::scoped_lock frame_lock(g_frame_mutex);
+			g_frames = {};
+			g_generation.fetch_add(1, std::memory_order_release);
+		}
+		Common::DebugCounters::SetEnabled(enabled);
+	}
+	g_sampler_wait.notify_all();
+}
+
+bool GuestStalled(Clock::time_point now) {
+	std::scoped_lock lock(g_frame_mutex);
+	return now - g_frames.last_flip >= REFRESH_INTERVAL;
+}
+
+// Host statistics can block for milliseconds (IOKit, thread enumeration), so sample them off
+// the present path. While the guest stops flipping (loading screens), ask for one repaint per
+// interval.
+void SamplerThread(const std::stop_token& stop) {
+	std::optional<Common::HostStatsSampler> sampler;
+	uint64_t                                sampled_generation = 0;
+	std::unique_lock                        lock(g_host_mutex);
+	while (!stop.stop_requested()) {
+		g_sampler_wait.wait(lock, stop, [] { return Common::DebugCounters::Enabled(); });
+		if (stop.stop_requested()) {
+			break;
+		}
+		const auto generation = g_generation.load(std::memory_order_acquire);
+		lock.unlock();
+		if (!sampler || generation != sampled_generation) {
+			sampler.emplace();
+			sampled_generation = generation;
+		}
+		auto stats = sampler->Sample();
+		lock.lock();
+		g_host_stats      = std::move(stats);
+		g_host_generation = generation;
+		if (Common::DebugCounters::Enabled() && GuestStalled(Clock::now())) {
+			g_revision.fetch_add(1, std::memory_order_acq_rel);
+		}
+		g_sampler_wait.wait_for(lock, stop, REFRESH_INTERVAL, [generation] {
+			return !Common::DebugCounters::Enabled() ||
+			       generation != g_generation.load(std::memory_order_acquire);
+		});
+	}
+}
+
+void EnsureSampler() {
+	static std::once_flag once;
+	std::call_once(once, [] { g_sampler = std::jthread(SamplerThread); });
+}
+
+ImU32 FrameTimeColor(double ms) {
+	return ms <= FRAME_TIME_GOOD ? GOOD : ms <= FRAME_TIME_MEDIUM ? MEDIUM : BAD;
+}
+
+// Green below `warn`, yellow below `bad`, red above.
+ImU32 LevelColor(double value, double warn, double bad) {
+	return value < warn ? GOOD : value < bad ? MEDIUM : BAD;
+}
+
+ImVec4 Color(ImU32 color) {
+	return ImGui::ColorConvertU32ToFloat4(color);
+}
+
+std::string Bytes(uint64_t bytes) {
+	constexpr double GIB = 1024.0 * 1024.0 * 1024.0;
+	constexpr double MIB = 1024.0 * 1024.0;
+	char             buffer[32];
+	if (static_cast<double>(bytes) >= GIB) {
+		std::snprintf(buffer, sizeof(buffer), "%.2f GB", static_cast<double>(bytes) / GIB);
+	} else {
+		std::snprintf(buffer, sizeof(buffer), "%.0f MB", static_cast<double>(bytes) / MIB);
+	}
+	return buffer;
+}
+
+std::string Bytes(std::optional<uint64_t> bytes) {
+	return bytes ? Bytes(*bytes) : "n/a";
+}
+
+std::string Throughput(double bytes_per_second) {
+	char buffer[32];
+	std::snprintf(buffer, sizeof(buffer), "%.1f MB/s", bytes_per_second / (1024.0 * 1024.0));
+	return buffer;
+}
+
+std::string Percent(std::optional<double> value) {
+	if (!value) {
+		return "n/a";
+	}
+	char buffer[16];
+	std::snprintf(buffer, sizeof(buffer), "%.0f%%", *value);
+	return buffer;
+}
+
+void Row(const char* label, const std::string& value, std::optional<ImU32> color = std::nullopt) {
+	ImGui::TableNextRow();
+	ImGui::TableNextColumn();
+	ImGui::TextDisabled("%s", label);
+	ImGui::TableNextColumn();
+	if (color) {
+		ImGui::TextColored(Color(*color), "%s", value.c_str());
+	} else {
+		ImGui::TextUnformatted(value.c_str());
+	}
+}
+
+[[gnu::format(printf, 1, 2)]] std::string Fmt(const char* format, ...) {
+	char    buffer[128];
+	va_list args;
+	va_start(args, format);
+	std::vsnprintf(buffer, sizeof(buffer), format, args);
+	va_end(args);
+	return buffer;
+}
+
+bool BeginSection(const char* title) {
+	ImGui::SeparatorText(title);
+	return ImGui::BeginTable(title, 2, TABLE_FLAGS);
+}
+
+void DrawFrameGraph(const std::array<float, FRAME_HISTORY>& history, size_t count, float width,
+                    float height) {
+	const ImVec2 origin = ImGui::GetCursorScreenPos();
+	auto*        draw   = ImGui::GetWindowDrawList();
+	draw->AddRectFilled(origin, {origin.x + width, origin.y + height}, IM_COL32(0, 0, 0, 90));
+	const auto y_of = [&](float ms) {
+		return origin.y + height - std::min(ms, FRAME_GRAPH_MS) / FRAME_GRAPH_MS * height;
+	};
+	for (const float reference: {1000.0f / 60.0f, 1000.0f / 30.0f}) {
+		draw->AddLine({origin.x, y_of(reference)}, {origin.x + width, y_of(reference)},
+		              IM_COL32(255, 255, 255, 45));
+	}
+	const float bar = width / static_cast<float>(FRAME_HISTORY);
+	for (size_t i = 0; i < count; i++) {
+		const float ms = history[i];
+		const float x  = origin.x + width - static_cast<float>(count - i) * bar;
+		draw->AddRectFilled({x, y_of(ms)}, {x + std::max(bar - 1.0f, 1.0f), origin.y + height},
+		                    FrameTimeColor(ms));
+	}
+	ImGui::Dummy({width, height});
+}
+
+const char* PressureName(Common::MemoryPressure pressure) {
+	switch (pressure) {
+		case Common::MemoryPressure::Normal: return "Normal";
+		case Common::MemoryPressure::Warning: return "Warning";
+		case Common::MemoryPressure::Critical: return "Critical";
+		case Common::MemoryPressure::Unknown: break;
+	}
+	return "n/a";
+}
+
+ImU32 PressureColor(Common::MemoryPressure pressure) {
+	switch (pressure) {
+		case Common::MemoryPressure::Normal: return GOOD;
+		case Common::MemoryPressure::Warning: return MEDIUM;
+		case Common::MemoryPressure::Critical: return BAD;
+		case Common::MemoryPressure::Unknown: break;
+	}
+	return NEUTRAL;
+}
+
+const char* ThermalName(Common::ThermalPressure thermal) {
+	switch (thermal) {
+		case Common::ThermalPressure::Nominal: return "Nominal";
+		case Common::ThermalPressure::Moderate: return "Moderate";
+		case Common::ThermalPressure::Heavy: return "Heavy (throttling)";
+		case Common::ThermalPressure::Critical: return "Critical (throttling)";
+		case Common::ThermalPressure::Unknown: break;
+	}
+	return "n/a";
+}
+
+ImU32 ThermalColor(Common::ThermalPressure thermal) {
+	switch (thermal) {
+		case Common::ThermalPressure::Nominal: return GOOD;
+		case Common::ThermalPressure::Moderate: return MEDIUM;
+		case Common::ThermalPressure::Heavy:
+		case Common::ThermalPressure::Critical: return BAD;
+		case Common::ThermalPressure::Unknown: break;
+	}
+	return NEUTRAL;
+}
+
+const char* PresentModeName(Config::PresentMode mode) {
+	switch (mode) {
+		case Config::PresentMode::Fifo: return "FIFO";
+		case Config::PresentMode::Mailbox: return "Mailbox";
+		case Config::PresentMode::Immediate: return "Immediate";
+	}
+	return "?";
+}
+
+double Rate(const Snapshot& shown, Counter counter) {
+	return shown.rates[static_cast<size_t>(counter)];
+}
+
+uint64_t Total(const Snapshot& shown, Counter counter) {
+	return shown.totals[static_cast<size_t>(counter)];
+}
+
+void TransferRow(const Snapshot& shown, const char* label, Counter upload, Counter download) {
+	Row(label,
+	    Throughput(Rate(shown, upload)) + " up / " + Throughput(Rate(shown, download)) + " down");
+}
+
+void GpuActivityRows(const Snapshot& shown) {
+	const auto draws = Rate(shown, Counter::Draws);
+	Row("Draw calls", Fmt("%.0f/frame  %.0f/s", draws / std::max(shown.fps, 1.0), draws));
+	// Includes present pacing waits, so a high value alone is not a stall.
+	Row("CPU waiting on GPU",
+	    Fmt("%.0f ms/s  (%.0f waits/s)", Rate(shown, Counter::GpuWaitNs) / 1e6,
+	        Rate(shown, Counter::GpuWaits)));
+}
+
+void CompilationRows(const Snapshot& shown) {
+	const auto row = [&](const char* label, Counter count_counter, Counter duration_counter,
+	                     uint64_t peak_ns) {
+		const auto count = Total(shown, count_counter);
+		Row(label,
+		    Fmt("%llu  (avg %.1f ms, peak %.1f ms)", static_cast<unsigned long long>(count),
+		        count != 0 ? static_cast<double>(Total(shown, duration_counter)) / 1e6 /
+		                         static_cast<double>(count)
+		                   : 0.0,
+		        static_cast<double>(peak_ns) / 1e6),
+		    Rate(shown, count_counter) > 0.0 ? MEDIUM : GOOD);
+	};
+	row("Shader recompiler", Counter::ShadersCompiled, Counter::ShaderCompileNs,
+	    shown.shader_compile_peak_ns);
+	row("Pipeline compile", Counter::PipelinesCreated, Counter::PipelineCreateNs,
+	    shown.pipeline_create_peak_ns);
+}
+
+void Refresh(Snapshot& shown, const GraphicContext& graphics, Clock::time_point now,
+             uint64_t generation) {
+	const double seconds = shown.sample_time == Clock::time_point {}
+	                           ? 0.0
+	                           : std::chrono::duration<double>(now - shown.sample_time).count();
+	for (size_t i = 0; i < COUNTER_COUNT; i++) {
+		const auto value = Common::DebugCounters::Get(static_cast<Counter>(i));
+		shown.rates[i] =
+		    seconds > 0.0 ? static_cast<double>(value - shown.totals[i]) / seconds : 0.0;
+		shown.totals[i] = value;
+	}
+	shown.shader_compile_peak_ns  = Common::DebugCounters::Get(Peak::ShaderCompileNs);
+	shown.pipeline_create_peak_ns = Common::DebugCounters::Get(Peak::PipelineCreateNs);
+	shown.sample_time             = now;
+	{
+		std::scoped_lock lock(g_host_mutex);
+		if (g_host_generation == generation) {
+			shown.host = g_host_stats;
+		}
+	}
+	shown.heap_count = graphics.GetHeapUsage(shown.heaps);
+	shown.device_memory =
+	    graphics.CanReportMemoryUsage() ? std::optional<uint64_t>(0) : std::nullopt;
+	shown.device_budget = 0;
+	const bool discrete =
+	    graphics.GetPhysicalDeviceProperties().deviceType == vk::PhysicalDeviceType::eDiscreteGpu;
+	for (uint32_t i = 0; i < shown.heap_count; i++) {
+		const auto& heap = shown.heaps[i];
+		if (shown.device_memory && (!discrete || heap.device_local)) {
+			*shown.device_memory += heap.usage;
+			shown.device_budget += heap.budget;
+		}
+	}
+	if (g_details.load(std::memory_order_acquire)) {
+		shown.guest_memory = LibKernel::Memory::GetDebugStats();
+	}
+}
+
+void DrawCompact(const Snapshot& shown) {
+	if (!ImGui::BeginTable("##performance", 2, TABLE_FLAGS)) {
+		return;
+	}
+	const auto& host = shown.host;
+	if (shown.max_frame_ms > 0.0) {
+		Row("Worst frame", Fmt("%.1f ms", shown.max_frame_ms), FrameTimeColor(shown.max_frame_ms));
+	}
+	Row("CPU", host.process_cpu_percent
+	               ? Fmt("%.0f%%  of %u threads", *host.process_cpu_percent, host.logical_cores)
+	               : std::string("n/a"));
+	Row("GPU", Percent(host.gpu_percent));
+	GpuActivityRows(shown);
+	CompilationRows(shown);
+	if (shown.device_memory) {
+		Row("GPU memory", Bytes(*shown.device_memory) + " / " + Bytes(shown.device_budget));
+	}
+	TransferRow(shown, "Texture transfers", Counter::TextureUploadBytes,
+	            Counter::TextureDownloadBytes);
+	TransferRow(shown, "Buffer transfers", Counter::BufferUploadBytes,
+	            Counter::BufferDownloadBytes);
+	Row("Emulator RAM", Bytes(host.process_memory));
+	if (host.system_memory_used && host.system_memory_total) {
+		Row("System RAM",
+		    Bytes(*host.system_memory_used) + " / " + Bytes(*host.system_memory_total));
+	}
+	ImGui::EndTable();
+}
+
+void DrawFramesAndCpu(const Snapshot& shown, vk::Extent2D extent) {
+	const auto& host = shown.host;
+	if (BeginSection("Frames")) {
+		if (shown.low_fps > 0.0) {
+			Row("1% low", Fmt("%.1f FPS", shown.low_fps), FrameTimeColor(1000.0 / shown.low_fps));
+		}
+		Row("Worst frame", Fmt("%.1f ms", shown.max_frame_ms), FrameTimeColor(shown.max_frame_ms));
+		Row("Guest output", shown.guest_width != 0
+		                        ? Fmt("%ux%u", shown.guest_width, shown.guest_height)
+		                        : std::string("n/a"));
+		Row("Window", Fmt("%ux%u  %s  %u Hz", extent.width, extent.height,
+		                  PresentModeName(Config::GetPresentMode()), Config::GetVblankFrequency()));
+		Row("Flips", Fmt("%.0f/s requested", Rate(shown, Counter::FlipsRequested)));
+		const auto rejected = Rate(shown, Counter::FlipsRejected);
+		Row("Flip queue full", Fmt("%.0f/s", rejected), rejected > 0.0 ? BAD : GOOD);
+		const auto late = Rate(shown, Counter::LateVblanks);
+		Row("Late vblanks", Fmt("%.0f/s", late), LevelColor(late, 1.0, 10.0));
+		Row("Swapchain rebuilds",
+		    Fmt("%llu  (dropped %llu)",
+		        static_cast<unsigned long long>(Total(shown, Counter::SwapchainRecreations)),
+		        static_cast<unsigned long long>(Total(shown, Counter::DroppedPresents))));
+		ImGui::EndTable();
+	}
+	if (BeginSection("CPU")) {
+		Row("Emulator",
+		    host.process_cpu_percent
+		        ? Fmt("%.0f%% of %u threads  (%.1f cores)", *host.process_cpu_percent,
+		              host.logical_cores, *host.process_cpu_percent * host.logical_cores / 100.0)
+		        : std::string("n/a"));
+		Row("Machine", Percent(host.system_cpu_percent),
+		    host.system_cpu_percent ? std::optional(LevelColor(*host.system_cpu_percent, 70, 90))
+		                            : std::nullopt);
+		if (host.thread_count) {
+			Row("Host threads", Fmt("%u", *host.thread_count));
+		}
+		for (const auto& thread: host.busiest_threads) {
+			Row(Fmt("  %.24s", thread.name.c_str()).c_str(), Fmt("%.0f%%", thread.cpu_percent),
+			    LevelColor(thread.cpu_percent, 70, 95));
+		}
+		if (host.context_switches_per_s) {
+			Row("Context switches", Fmt("%.0f/s", *host.context_switches_per_s));
+		}
+		if (host.page_faults_per_s) {
+			Row("Page faults", Fmt("%.0f/s  (%.0f from disk)", *host.page_faults_per_s,
+			                       host.page_ins_per_s.value_or(0.0)));
+		}
+		Row("Thermal", ThermalName(host.thermal_pressure), ThermalColor(host.thermal_pressure));
+		const auto emulated = Rate(shown, Counter::EmulatedInstructions);
+		Row("Emulated instrs", Fmt("%.0f/s", emulated), LevelColor(emulated, 1000, 100000));
+		const auto unresolved = Rate(shown, Counter::UnresolvedImportCalls);
+		Row("Missing HLE calls",
+		    Fmt("%.0f/s  (%llu total)", unresolved,
+		        static_cast<unsigned long long>(Total(shown, Counter::UnresolvedImportCalls))),
+		    unresolved > 0.0 ? MEDIUM : GOOD);
+		ImGui::EndTable();
+	}
+}
+
+void DrawGpu(const Snapshot& shown, const GraphicContext& graphics) {
+	const auto& host = shown.host;
+	if (BeginSection("GPU")) {
+		Row("Device", host.gpu_model.empty()
+		                  ? std::string(graphics.GetPhysicalDeviceProperties().deviceName.data())
+		              : host.gpu_cores
+		                  ? Fmt("%s (%u cores)", host.gpu_model.c_str(), *host.gpu_cores)
+		                  : host.gpu_model);
+		Row("Utilization", Percent(host.gpu_percent),
+		    host.gpu_percent ? std::optional(LevelColor(*host.gpu_percent, 80, 95)) : std::nullopt);
+		if (host.gpu_renderer_percent || host.gpu_tiler_percent) {
+			Row("Renderer / tiler",
+			    Percent(host.gpu_renderer_percent) + " / " + Percent(host.gpu_tiler_percent));
+		}
+		if (host.gpu_memory_in_use) {
+			Row("Driver memory", Bytes(*host.gpu_memory_in_use) + " in use / " +
+			                         Bytes(host.gpu_memory_allocated) + " allocated");
+		}
+		if (host.gpu_recoveries) {
+			Row("GPU resets", Fmt("%llu", static_cast<unsigned long long>(*host.gpu_recoveries)),
+			    *host.gpu_recoveries > 0 ? BAD : GOOD);
+		}
+		const double fps = std::max(shown.fps, 1.0);
+		GpuActivityRows(shown);
+		Row("Instances", Fmt("%.0f/frame", Rate(shown, Counter::DrawInstances) / fps));
+		Row("Indirect draws", Fmt("%.0f/s", Rate(shown, Counter::IndirectDraws)));
+		Row("Dispatches", Fmt("%.0f/frame  %.0f/s", Rate(shown, Counter::Dispatches) / fps,
+		                      Rate(shown, Counter::Dispatches)));
+		Row("Queue submits", Fmt("%.0f/s", Rate(shown, Counter::QueueSubmits)));
+		const auto faults = Rate(shown, Counter::GpuFaults);
+		Row("Write-tracking faults", Fmt("%.0f/s", faults), LevelColor(faults, 20000, 100000));
+		CompilationRows(shown);
+		ImGui::EndTable();
+	}
+	if (BeginSection("GPU memory")) {
+		if (shown.device_memory) {
+			const double share = shown.device_budget != 0
+			                         ? static_cast<double>(*shown.device_memory) /
+			                               static_cast<double>(shown.device_budget) * 100.0
+			                         : 0.0;
+			Row("Vulkan budget", Bytes(*shown.device_memory) + " / " + Bytes(shown.device_budget),
+			    LevelColor(share, 80, 95));
+		}
+		for (size_t heap = 0; heap < shown.heap_count; heap++) {
+			const auto& usage = shown.heaps[heap];
+			Row(Fmt("  Heap %zu%s", heap, usage.device_local ? " (device)" : "").c_str(),
+			    Bytes(usage.usage) + " / " + Bytes(usage.budget) +
+			        Fmt("  %u allocs", usage.allocations));
+		}
+		TransferRow(shown, "Texture transfers", Counter::TextureUploadBytes,
+		            Counter::TextureDownloadBytes);
+		Row("Texture evictions", Fmt("%.0f/s", Rate(shown, Counter::TextureEvictions)));
+		TransferRow(shown, "Buffer transfers", Counter::BufferUploadBytes,
+		            Counter::BufferDownloadBytes);
+		Row("Buffer evictions", Fmt("%.0f/s", Rate(shown, Counter::BufferEvictions)));
+		ImGui::EndTable();
+	}
+}
+
+void DrawMemoryAndIo(const Snapshot& shown) {
+	const auto& host  = shown.host;
+	const auto& guest = shown.guest_memory;
+	if (BeginSection("PS5 memory")) {
+		const auto direct_used = guest.direct_allocated + guest.pooled_allocated;
+		Row("Direct", Bytes(direct_used) + " / " + Bytes(guest.direct_total),
+		    LevelColor(guest.direct_total != 0 ? static_cast<double>(direct_used) /
+		                                             static_cast<double>(guest.direct_total) * 100.0
+		                                       : 0.0,
+		               85, 97));
+		Row("  Mapped", Bytes(guest.direct_mapped));
+		Row("  Pool",
+		    Bytes(guest.pooled_allocated) + " (" + Bytes(guest.pool_committed) + " committed)");
+		Row("Flexible", Bytes(guest.flexible_used) + " / " + Bytes(guest.flexible_total));
+		Row("Extended", Bytes(guest.automatic_allocated));
+		// Past the pool size the guest sees no page-table entries available.
+		const auto entries = std::max(guest.cpu_page_entries, guest.gpu_page_entries);
+		Row("Page table (2 MB)",
+		    Fmt("CPU %llu  GPU %llu  / %llu",
+		        static_cast<unsigned long long>(guest.cpu_page_entries),
+		        static_cast<unsigned long long>(guest.gpu_page_entries),
+		        static_cast<unsigned long long>(guest.page_entries_total)),
+		    entries > guest.page_entries_total            ? BAD
+		    : entries * 10 > guest.page_entries_total * 9 ? MEDIUM
+		                                                  : GOOD);
+		ImGui::EndTable();
+	}
+	if (BeginSection("Emulator process")) {
+		Row("Footprint", Bytes(host.process_memory));
+		Row("Resident", Bytes(host.process_resident));
+		if (host.process_compressed) {
+			Row("Compressed / swapped", Bytes(*host.process_compressed),
+			    *host.process_compressed > (1ull << 30u) ? MEDIUM : GOOD);
+		}
+		Row("File-backed", Bytes(host.process_file_backed));
+		Row("Address space", Bytes(host.process_virtual));
+		ImGui::EndTable();
+	}
+	if (BeginSection("System memory")) {
+		if (host.system_memory_used && host.system_memory_total) {
+			Row("Used", Bytes(*host.system_memory_used) + " / " + Bytes(*host.system_memory_total));
+		}
+		if (host.system_wired) {
+			Row("Wired", Bytes(*host.system_wired));
+		}
+		if (host.system_compressed) {
+			Row("Compressed", Bytes(*host.system_compressed));
+		}
+		Row("Cached files", Bytes(host.system_cached));
+		Row("Free", Bytes(host.system_free));
+		if (host.swap_used) {
+			Row("Swap", Bytes(*host.swap_used) + " / " + Bytes(host.swap_total),
+			    *host.swap_used > (4ull << 30u) ? MEDIUM : GOOD);
+		}
+		Row("Pressure", PressureName(host.memory_pressure), PressureColor(host.memory_pressure));
+		ImGui::EndTable();
+	}
+	if (BeginSection("I/O & audio")) {
+		Row("Disk read / write", Throughput(host.disk_read_per_s.value_or(0.0)) + " / " +
+		                             Throughput(host.disk_write_per_s.value_or(0.0)));
+		Row("Guest file read / write", Throughput(Rate(shown, Counter::GuestFileReadBytes)) +
+		                                   " / " +
+		                                   Throughput(Rate(shown, Counter::GuestFileWriteBytes)));
+		const auto underruns = Rate(shown, Counter::AudioUnderruns);
+		Row("Audio underruns",
+		    Fmt("%.0f/s  (%llu total)", underruns,
+		        static_cast<unsigned long long>(Total(shown, Counter::AudioUnderruns))),
+		    underruns > 0.0 ? BAD : GOOD);
+		ImGui::EndTable();
+	}
+}
+
+} // namespace
+
+void PerformanceOverlayRecordFlip(uint32_t guest_width, uint32_t guest_height) noexcept {
+	if (!Common::DebugCounters::Enabled()) {
+		return;
+	}
+	std::scoped_lock lock(g_frame_mutex);
+	const auto       now = Clock::now();
+	if (g_frames.window_start == Clock::time_point {}) {
+		g_frames.window_start = now;
+	}
+	auto& frames = g_frames;
+	if (frames.last_flip != Clock::time_point {}) {
+		const float ms = std::chrono::duration<float, std::milli>(now - frames.last_flip).count();
+		frames.intervals_ms[frames.next] = ms;
+		frames.next                      = (frames.next + 1) % FRAME_HISTORY;
+		frames.count                     = std::min(frames.count + 1, FRAME_HISTORY);
+		frames.max_ms                    = std::max(frames.max_ms, ms);
+	}
+	frames.last_flip    = now;
+	frames.guest_width  = guest_width;
+	frames.guest_height = guest_height;
+	frames.flips++;
+}
+
+bool PerformanceOverlayEnabled() noexcept {
+	return Common::DebugCounters::Enabled();
+}
+
+void TogglePerformanceOverlay() noexcept {
+	SetOverlayEnabled(!Common::DebugCounters::Enabled());
+	g_revision.fetch_add(1, std::memory_order_acq_rel);
+}
+
+void TogglePerformanceOverlayDetails() noexcept {
+	if (Common::DebugCounters::Enabled()) {
+		g_details.store(!g_details.load(std::memory_order_acquire), std::memory_order_release);
+	} else {
+		g_details.store(true, std::memory_order_release);
+		SetOverlayEnabled(true);
+	}
+	g_revision.fetch_add(1, std::memory_order_acq_rel);
+}
+
+uint64_t PerformanceOverlayRevision() noexcept {
+	return g_revision.load(std::memory_order_acquire);
+}
+
+float DrawPerformanceOverlay(const GraphicContext& graphics, vk::Extent2D extent) {
+	if (!PerformanceOverlayEnabled()) {
+		return 0.0f;
+	}
+	EnsureSampler();
+
+	static Snapshot shown;
+	static uint64_t shown_generation = 0;
+	static bool     shown_details    = false;
+	const auto      generation       = g_generation.load(std::memory_order_acquire);
+	const bool      details          = g_details.load(std::memory_order_acquire);
+	const auto      now              = Clock::now();
+	if (generation != shown_generation) {
+		shown            = {};
+		shown_generation = generation;
+	}
+	if (shown.sample_time == Clock::time_point {} || now - shown.sample_time >= REFRESH_INTERVAL ||
+	    details != shown_details) {
+		{
+			std::scoped_lock lock(g_frame_mutex);
+			auto&            frames = g_frames;
+			shown.history_count     = frames.count;
+			for (size_t i = 0; i < frames.count; i++) {
+				shown.history[i] =
+				    frames.intervals_ms[(frames.next + FRAME_HISTORY - frames.count + i) %
+				                        FRAME_HISTORY];
+			}
+			if (frames.window_start == Clock::time_point {}) {
+				frames.window_start = now;
+			}
+			const double seconds = std::chrono::duration<double>(now - frames.window_start).count();
+			shown.fps            = seconds > 0.0 ? frames.flips / seconds : 0.0;
+			shown.frame_ms       = frames.flips > 0 ? seconds * 1000.0 / frames.flips : 0.0;
+			shown.max_frame_ms   = frames.max_ms;
+			shown.stalled_s   = frames.last_flip == Clock::time_point {}
+			                        ? 0.0
+			                        : std::chrono::duration<double>(now - frames.last_flip).count();
+			shown.guest_width = frames.guest_width;
+			shown.guest_height  = frames.guest_height;
+			frames.flips        = 0;
+			frames.max_ms       = 0.0f;
+			frames.window_start = now;
+		}
+		shown_details = details;
+		if (shown.history_count > 0) {
+			auto       sorted     = shown.history;
+			const auto end        = sorted.begin() + shown.history_count;
+			const auto percentile = sorted.begin() + shown.history_count * 99 / 100;
+			std::nth_element(sorted.begin(), percentile, end);
+			shown.low_fps = *percentile > 0.0f ? 1000.0 / *percentile : 0.0;
+		}
+		Refresh(shown, graphics, now, generation);
+	}
+
+	const float scale = std::clamp(std::min(static_cast<float>(extent.width) / 1920.0f,
+	                                        static_cast<float>(extent.height) / 1080.0f),
+	                               0.75f, 1.5f);
+	ImGui::SetNextWindowPos({static_cast<float>(extent.width) - 12.0f * scale, 12.0f * scale},
+	                        ImGuiCond_Always, {1.0f, 0.0f});
+	ImGui::SetNextWindowBgAlpha(details ? 0.82f : 0.72f);
+	constexpr ImGuiWindowFlags FLAGS =
+	    ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoNav |
+	    ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings |
+	    ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoBringToFrontOnFocus |
+	    ImGuiWindowFlags_AlwaysAutoResize;
+	ImGui::PushFont(nullptr, (details ? 13.0f : 15.0f) * scale);
+	ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 8.0f * scale);
+	ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, {10.0f * scale, 8.0f * scale});
+	ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, {8.0f * scale, 2.0f * scale});
+	ImGui::PushStyleVar(ImGuiStyleVar_CellPadding, {4.0f * scale, 1.0f * scale});
+	if (ImGui::Begin("##kyty_performance_overlay", nullptr, FLAGS)) {
+		if (shown.fps > 0.0) {
+			ImGui::TextColored(Color(FrameTimeColor(shown.frame_ms)), "%.1f FPS   %.1f ms",
+			                   shown.fps, shown.frame_ms);
+		} else if (shown.stalled_s >= 1.0) {
+			ImGui::TextColored(Color(BAD), "No frames for %.0f s", shown.stalled_s);
+		} else {
+			ImGui::TextDisabled("Waiting for frames");
+		}
+		DrawFrameGraph(shown.history, shown.history_count, (details ? 330.0f : 260.0f) * scale,
+		               46.0f * scale);
+		if (details) {
+			// Three columns keep the detailed panel within a 720p window.
+			if (ImGui::BeginTable("##details", 3, TABLE_FLAGS)) {
+				ImGui::TableNextRow();
+				ImGui::TableNextColumn();
+				DrawFramesAndCpu(shown, extent);
+				ImGui::TableNextColumn();
+				DrawGpu(shown, graphics);
+				ImGui::TableNextColumn();
+				DrawMemoryAndIo(shown);
+				ImGui::EndTable();
+			}
+		} else {
+			DrawCompact(shown);
+		}
+#if defined(__APPLE__)
+		ImGui::TextDisabled(details ? "Cmd+Shift+P compact   Cmd+P hide"
+		                            : "Cmd+Shift+P details   Cmd+P hide");
+#else
+		ImGui::TextDisabled(details ? "Shift+F2 compact   F2 hide" : "Shift+F2 details   F2 hide");
+#endif
+	}
+	const float bottom = ImGui::GetWindowPos().y + ImGui::GetWindowSize().y;
+	ImGui::End();
+	ImGui::PopStyleVar(4);
+	ImGui::PopFont();
+	return bottom;
+}
+
+} // namespace Libs::Graphics
@@ -0,0 +1,30 @@
+#ifndef EMULATOR_SRC_GRAPHICS_PRESENTATION_PERFORMANCEOVERLAY_H_
+#define EMULATOR_SRC_GRAPHICS_PRESENTATION_PERFORMANCEOVERLAY_H_
+
+#include "graphics/host_gpu/vulkanCommon.h"
+
+#include <cstdint>
+
+namespace Libs::Graphics {
+
+struct GraphicContext;
+
+// Called for each main-bus guest flip, with the guest's video-out size.
+void PerformanceOverlayRecordFlip(uint32_t guest_width, uint32_t guest_height) noexcept;
+
+[[nodiscard]] bool PerformanceOverlayEnabled() noexcept;
+void               TogglePerformanceOverlay() noexcept;
+// Switches between the compact and the detailed panel, showing the panel if it was hidden.
+void TogglePerformanceOverlayDetails() noexcept;
+
+// Changes when the panel needs a repaint without a guest flip (toggled, or the guest stalled).
+[[nodiscard]] uint64_t PerformanceOverlayRevision() noexcept;
+
+// Must run between ImGui::NewFrame() and ImGui::Render(), on the present thread while the
+// graphics subsystem is alive. Draws in the top-right corner and returns the panel's bottom
+// edge, or 0 when hidden.
+float DrawPerformanceOverlay(const GraphicContext& graphics, vk::Extent2D extent);
+
+} // namespace Libs::Graphics
+
+#endif // EMULATOR_SRC_GRAPHICS_PRESENTATION_PERFORMANCEOVERLAY_H_
@@ -162,7 +162,8 @@ void RenderDocOnGuestFlip(RenderContext& renderer) {
 		return;
 	}
 	if (state == RenderDocState::Capturing) {
-		LOGF("RenderDoc: captured guest flip %u/2\n", ++g_captured_flips);
+		++g_captured_flips;
+		LOGF("RenderDoc: captured guest flip %u/2\n", g_captured_flips);
 		if (g_captured_flips < 2) {
 			return;
 		}
@@ -1,18 +1,19 @@
 #include "graphics/presentation/systemOverlay.h"

-#include <SDL3/SDL.h>
-
 #include "common/assert.h"
 #include "common/emulatorConfig.h"
 #include "common/file.h"
+#include "common/localization.h"
 #include "common/logging/log.h"
 #include "common/stringUtils.h"
 #include "gpu_blit_shaders/gpu_imgui_hdr_spv.h"
 #include "graphics/host_gpu/graphicContext.h"
 #include "graphics/presentation/ddsImage.h"
+#include "graphics/presentation/performanceOverlay.h"
+#include "graphics/presentation/window/hostInput.h"
 #include "imgui.h"
-#include "imgui_internal.h"
 #include "imgui_impl_vulkan.h"
+#include "imgui_internal.h"
 #include "libs/controller.h"
 #include "libs/dialog.h"
 #include "libs/ime.h"
@@ -20,6 +21,7 @@
 #include "loader/systemContent.h"
 #include "stb_image.h"

+#include <SDL3/SDL.h>
 #include <algorithm>
 #include <array>
 #include <atomic>
@@ -29,6 +31,7 @@
 #include <cstring>
 #include <deque>
 #include <fmt/format.h>
+#include <initializer_list>
 #include <limits>
 #include <memory>
 #include <mutex>
@@ -149,6 +152,47 @@ bool GetOverlaySnapshot(OverlaySnapshot* snapshot) {
 }

 constexpr size_t INPUT_QUEUE_CAPACITY = 128;
+constexpr int    MAX_TOUCH_CURSOR_IMAGE_DIMENSION = 2048;
+constexpr float  TOUCH_CURSOR_IMAGE_SIZE          = 48.0f;
+
+enum class TouchParticleSkin : uint8_t { Classic, BlueNeon, Monochrome, Crimson, RedBlue };
+
+TouchParticleSkin GetTouchParticleSkin() {
+	static const auto skin = [] {
+		for (const auto& value: Config::GetKeymap()) {
+			constexpr std::string_view key = "TouchParticleSkin=";
+			if (std::string_view(value).starts_with(key)) {
+				const auto name = std::string_view(value).substr(key.size());
+				if (name == "BlueNeon") {
+					return TouchParticleSkin::BlueNeon;
+				}
+				if (name == "Monochrome") {
+					return TouchParticleSkin::Monochrome;
+				}
+				if (name == "Crimson") {
+					return TouchParticleSkin::Crimson;
+				}
+				if (name == "RedBlue") {
+					return TouchParticleSkin::RedBlue;
+				}
+			}
+		}
+		return TouchParticleSkin::Classic;
+	}();
+	return skin;
+}
+
+bool TouchCursorImageEnabled() {
+	static const bool enabled = [] {
+		for (const auto& value: Config::GetKeymap()) {
+			if (std::string_view(value) == "TouchCursorImage=Off") {
+				return false;
+			}
+		}
+		return true;
+	}();
+	return enabled;
+}

 enum class InputKind : uint8_t {
 	Button,
@@ -238,6 +282,61 @@ std::vector<std::string_view> WrapTrophyTitle(std::string_view text, float font_
 	}
 }

+// ImGui's built-in font covers Latin only. Merge installed fonts for the selected console language.
+void AddSystemFontFallbacks(ImGuiIO& io) {
+	io.Fonts->AddFontDefault();
+	const auto add = [&](std::initializer_list<const char*> paths) {
+		for (const char* path: paths) {
+			std::error_code error;
+			if (std::filesystem::is_regular_file(path, error)) {
+				ImFontConfig config;
+				config.MergeMode = true;
+				config.Flags = ImFontFlags_NoLoadError;
+				if (io.Fonts->AddFontFromFileTTF(path, 0.0f, &config) != nullptr) {
+					return true;
+				}
+			}
+		}
+		return false;
+	};
+	bool found =
+	    add({"C:/Windows/Fonts/segoeui.ttf", "/System/Library/Fonts/Supplemental/Arial Unicode.ttf",
+	         "/Library/Fonts/Arial Unicode.ttf", "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+	         "/usr/share/fonts/TTF/DejaVuSans.ttf", "/usr/share/fonts/noto/NotoSans-Regular.ttf"});
+	const auto  locale     = Common::Localization::LocaleName(Config::GetConsoleLanguage());
+	const char* noto_cjk[] = {"/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc",
+	                          "/usr/share/fonts/noto-cjk/NotoSansCJK-Regular.ttc",
+	                          "/usr/share/fonts/google-noto-cjk/NotoSansCJK-Regular.ttc"};
+	if (locale == "ja-JP") {
+		found = add({"C:/Windows/Fonts/meiryo.ttc", "C:/Windows/Fonts/YuGothM.ttc",
+		             "/System/Library/Fonts/ヒラギノ角ゴシック W3.ttc", noto_cjk[0], noto_cjk[1],
+		             noto_cjk[2]});
+	} else if (locale == "ko-KR") {
+		found = add({"C:/Windows/Fonts/malgun.ttf", "/System/Library/Fonts/AppleSDGothicNeo.ttc",
+		             noto_cjk[0], noto_cjk[1], noto_cjk[2]});
+	} else if (locale == "zh-Hans" || locale == "zh-Hant") {
+		found =
+		    add({locale == "zh-Hans" ? "C:/Windows/Fonts/msyh.ttc" : "C:/Windows/Fonts/msjh.ttc",
+		         "/System/Library/Fonts/PingFang.ttc", noto_cjk[0], noto_cjk[1], noto_cjk[2]});
+	} else if (locale == "th-TH") {
+		found = add({"C:/Windows/Fonts/leelawui.ttf", "C:/Windows/Fonts/tahoma.ttf",
+		             "/System/Library/Fonts/Supplemental/Ayuthaya.ttf",
+		             "/usr/share/fonts/truetype/tlwg/Garuda.ttf",
+		             "/usr/share/fonts/truetype/noto/NotoSansThai-Regular.ttf",
+		             "/usr/share/fonts/noto/NotoSansThai-Regular.ttf"});
+	} else if (locale == "ar-AE") {
+		found = add({"C:/Windows/Fonts/tahoma.ttf", "/System/Library/Fonts/Supplemental/Arial.ttf",
+		             "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+		             "/usr/share/fonts/TTF/DejaVuSans.ttf",
+		             "/usr/share/fonts/truetype/noto/NotoSansArabic-Regular.ttf",
+		             "/usr/share/fonts/noto/NotoSansArabic-Regular.ttf"});
+	}
+	if (!found) {
+		LOGF("[Trophy] no installed fallback font for %.*s\n", static_cast<int>(locale.size()),
+		     locale.data());
+	}
+}
+
 void ClearInputEvents() {
 	std::scoped_lock lock(g_input_mutex);
 	g_input_events.clear();
@@ -399,6 +498,63 @@ std::u16string Utf8ToUtf16(std::string_view text) {
 	return result;
 }

+// The Arabic notification is a single RTL run. Use presentation forms because ImGui does not
+// shape Arabic. This intentionally applies only to the catalog subtitle, never game-provided names.
+std::string PrepareTrophySubtitle(int language) {
+	const auto text = Common::Localization::Get(language, "trophy.toast.earned");
+	if (Common::Localization::LocaleName(language) != "ar-AE") {
+		return std::string(text);
+	}
+	struct ArabicForm {
+		char16_t letter;
+		char16_t isolated;
+		bool     joins_next;
+	};
+	static constexpr ArabicForm FORMS[] = {
+	    {0x0621, 0xfe80, false}, {0x0622, 0xfe81, false}, {0x0623, 0xfe83, false},
+	    {0x0624, 0xfe85, false}, {0x0625, 0xfe87, false}, {0x0626, 0xfe89, true},
+	    {0x0627, 0xfe8d, false}, {0x0628, 0xfe8f, true},  {0x0629, 0xfe93, false},
+	    {0x062a, 0xfe95, true},  {0x062b, 0xfe99, true},  {0x062c, 0xfe9d, true},
+	    {0x062d, 0xfea1, true},  {0x062e, 0xfea5, true},  {0x062f, 0xfea9, false},
+	    {0x0630, 0xfeab, false}, {0x0631, 0xfead, false}, {0x0632, 0xfeaf, false},
+	    {0x0633, 0xfeb1, true},  {0x0634, 0xfeb5, true},  {0x0635, 0xfeb9, true},
+	    {0x0636, 0xfebd, true},  {0x0637, 0xfec1, true},  {0x0638, 0xfec5, true},
+	    {0x0639, 0xfec9, true},  {0x063a, 0xfecd, true},  {0x0641, 0xfed1, true},
+	    {0x0642, 0xfed5, true},  {0x0643, 0xfed9, true},  {0x0644, 0xfedd, true},
+	    {0x0645, 0xfee1, true},  {0x0646, 0xfee5, true},  {0x0647, 0xfee9, true},
+	    {0x0648, 0xfeed, false}, {0x0649, 0xfeef, false}, {0x064a, 0xfef1, true},
+	};
+	const auto form = [](char16_t c) -> const ArabicForm* {
+		for (const auto& value: FORMS) {
+			if (value.letter == c) {
+				return &value;
+			}
+		}
+		return nullptr;
+	};
+	const auto logical = Utf8ToUtf16(text);
+	if (std::none_of(logical.begin(), logical.end(),
+	                 [](char16_t c) { return c >= 0x0600 && c <= 0x06ff; })) {
+		return std::string(text);
+	}
+	auto visual = logical;
+	for (size_t i = 0; i < logical.size(); ++i) {
+		const auto* current = form(logical[i]);
+		if (current == nullptr) {
+			continue;
+		}
+		const auto* previous = i > 0 ? form(logical[i - 1]) : nullptr;
+		const auto* next     = i + 1 < logical.size() ? form(logical[i + 1]) : nullptr;
+		const bool  joins_previous =
+		    previous != nullptr && previous->joins_next && current->letter != 0x0621;
+		const bool joins_next = current->joins_next && next != nullptr && next->letter != 0x0621;
+		visual[i]             = static_cast<char16_t>(current->isolated + (joins_next ? 2 : 0) +
+		                                              (joins_previous ? 1 : 0));
+	}
+	std::reverse(visual.begin(), visual.end());
+	return Common::Utf16ToUtf8(visual);
+}
+
 std::string VisibleText(const Ime::HostSnapshot& snapshot, size_t max_units) {
 	const size_t cursor        = std::min<size_t>(snapshot.cursor, snapshot.text.size());
 	const size_t payload_units = max_units > 4 ? max_units - 4 : 1;
@@ -552,9 +708,12 @@ SystemOverlayVisualState GetSystemOverlayVisualState() noexcept {
 	const auto system = SystemDialog::GetVisualState();
 	const bool trophy_active = g_trophy_notification_active.load(std::memory_order_acquire);
 	const bool splash        = g_splash_active.load(std::memory_order_acquire);
-	return {core.active || dialog.active || system.active || trophy_active || splash,
+	const auto cursor        = GetHostInputTouchPadVisualState();
+	return {core.active || dialog.active || system.active || trophy_active || splash ||
+	            (cursor.enabled && cursor.cursor_visible),
 	        core.revision + dialog.revision + system.revision + (trophy_active ? 1u : 0u) +
-	            (splash ? 2u : 0u)};
+	            (splash ? 2u : 0u) + static_cast<decltype(core.revision)>(cursor.revision) +
+	            PerformanceOverlayRevision()};
 }

 bool ProcessSystemOverlayInput(const SDL_Event& event) {
@@ -694,6 +853,20 @@ void NotifyTrophyUnlocked(std::string_view name, int32_t grade,
 }

 struct SystemOverlay::Impl {
+	enum class TouchParticleIcon : uint8_t { Square, Triangle, Cross, Circle };
+
+	struct TouchParticle {
+		ImVec2            position;
+		Clock::time_point born;
+		TouchParticleIcon icon;
+	};
+
+	struct TouchTrailSegment {
+		ImVec2            from;
+		ImVec2            to;
+		Clock::time_point born;
+	};
+
 	explicit Impl(GraphicContext& context): graphics(context) {}

 	~Impl() {
@@ -705,6 +878,12 @@ struct SystemOverlay::Impl {
 		ReleaseVulkan();
 		if (imgui_context != nullptr) {
 			ImGui::SetCurrentContext(imgui_context);
+			if (hand_cursor_image) {
+				ImGui::UnregisterUserTexture(hand_cursor_image.get());
+			}
+			if (drawing_cursor_image) {
+				ImGui::UnregisterUserTexture(drawing_cursor_image.get());
+			}
 			if (trophy_notification_image) {
 				ImGui::UnregisterUserTexture(trophy_notification_image.get());
 			}
@@ -730,11 +909,14 @@ struct SystemOverlay::Impl {
 		io.ConfigNavCursorVisibleAlways = true;
 		io.BackendFlags |= ImGuiBackendFlags_HasGamepad;
 		io.BackendPlatformName = "Kyty system overlay input";
+		AddSystemFontFallbacks(io);
 		ImGui::StyleColorsDark();
 		auto& style          = ImGui::GetStyle();
 		style.WindowRounding = 10.0f;
 		style.FrameRounding  = 6.0f;
 		style.ItemSpacing    = {8.0f, 8.0f};
+		hand_cursor_image    = LoadTouchCursorImage("hand.png");
+		drawing_cursor_image = LoadTouchCursorImage("drawing.png");
 	}

 	void PlayTrophySound() {
@@ -775,6 +957,55 @@ struct SystemOverlay::Impl {
 		}
 	}

+	std::unique_ptr<ImTextureData> LoadTouchCursorImage(std::string_view filename) {
+		const char* base_path = SDL_GetBasePath();
+		if (base_path == nullptr) {
+			LOGF("Could not locate the emulator folder for touchpad cursor images: %s\n",
+			     SDL_GetError());
+			return nullptr;
+		}
+		const std::filesystem::path path =
+		    std::filesystem::path(base_path) / "assets" / "cursors" / std::string(filename);
+
+		Common::File file;
+		if (!file.Open(path, Common::File::Mode::Read)) {
+			LOGF("Touchpad cursor image not found: %s\n", Common::PathToString(path).c_str());
+			return nullptr;
+		}
+		const auto encoded = file.ReadWholeBuffer();
+		if (encoded.empty() ||
+		    encoded.size() > static_cast<std::size_t>(std::numeric_limits<int>::max())) {
+			LOGF("Touchpad cursor image is empty or too large: %s\n",
+			     Common::PathToString(path).c_str());
+			return nullptr;
+		}
+
+		int width = 0;
+		int height = 0;
+		auto* pixels = stbi_load_from_memory(
+		    reinterpret_cast<const stbi_uc*>(encoded.data()), static_cast<int>(encoded.size()),
+		    &width, &height, nullptr, 4);
+		if (pixels == nullptr || width <= 0 || height <= 0 ||
+		    width > MAX_TOUCH_CURSOR_IMAGE_DIMENSION ||
+		    height > MAX_TOUCH_CURSOR_IMAGE_DIMENSION) {
+			LOGF("Could not load touchpad cursor image %s: %s\n",
+			     Common::PathToString(path).c_str(),
+			     pixels == nullptr ? stbi_failure_reason() : "image dimensions exceed 2048x2048");
+			stbi_image_free(pixels);
+			return nullptr;
+		}
+
+		auto texture = std::make_unique<ImTextureData>();
+		texture->Create(ImTextureFormat_RGBA32, width, height);
+		std::memcpy(texture->Pixels, pixels,
+		            static_cast<std::size_t>(width) * static_cast<std::size_t>(height) * 4);
+		texture->UseColors = true;
+		stbi_image_free(pixels);
+		ImGui::RegisterUserTexture(texture.get());
+		LOGF("Loaded touchpad cursor image: %s\n", Common::PathToString(path).c_str());
+		return texture;
+	}
+
 	std::unique_ptr<ImTextureData> LoadTrophyIcon(std::span<const std::byte> encoded) {
 		if (encoded.empty() ||
 		    encoded.size() > static_cast<std::size_t>(std::numeric_limits<int>::max())) {
@@ -1191,7 +1422,248 @@ struct SystemOverlay::Impl {
 		}
 	}

-	void DrawTrophyNotification(vk::Extent2D frame_extent, Clock::time_point now) {
+	void EmitTouchParticles(ImVec2 from, ImVec2 to, Clock::time_point now) {
+		const float dx       = to.x - from.x;
+		const float dy       = to.y - from.y;
+		const float distance = std::hypot(dx, dy);
+		if (distance < 0.01f) {
+			return;
+		}
+		if (distance >= 1.0f) {
+			trail_segments.push_back({from, to, now});
+			if (trail_segments.size() > MAX_TOUCH_TRAIL_SEGMENTS) {
+				trail_segments.erase(trail_segments.begin());
+			}
+		}
+
+		constexpr float PARTICLE_SPACING = 24.0f;
+		float           traveled         = 0.0f;
+		while (particle_distance + distance - traveled >= PARTICLE_SPACING) {
+			traveled += PARTICLE_SPACING - particle_distance;
+			const float fraction = std::clamp(traveled / distance, 0.0f, 1.0f);
+			particles.push_back(
+			    {{from.x + dx * fraction, from.y + dy * fraction}, now, next_particle_icon});
+			next_particle_icon = static_cast<TouchParticleIcon>(
+			    (static_cast<uint8_t>(next_particle_icon) + 1) % 4);
+			if (particles.size() > MAX_TOUCH_PARTICLES) {
+				particles.erase(particles.begin());
+			}
+			particle_distance = 0.0f;
+		}
+		particle_distance += distance - traveled;
+	}
+
+	void DrawTouchParticles(ImDrawList* draw, Clock::time_point now) {
+		const auto skin = GetTouchParticleSkin();
+		constexpr float PARTICLE_LIFETIME = 1.0f;
+		constexpr float TRAIL_LIFETIME    = 0.35f;
+		std::erase_if(trail_segments, [now](const auto& segment) {
+			return std::chrono::duration<float>(now - segment.born).count() >= TRAIL_LIFETIME;
+		});
+		std::erase_if(particles, [now](const auto& particle) {
+			return std::chrono::duration<float>(now - particle.born).count() >=
+			       PARTICLE_LIFETIME;
+		});
+		for (const auto& segment: trail_segments) {
+			const float age =
+			    std::chrono::duration<float>(now - segment.born).count() / TRAIL_LIFETIME;
+			const float fade = 1.0f - age;
+			if (skin == TouchParticleSkin::RedBlue) {
+				draw->AddLine(segment.from, segment.to,
+				              IM_COL32(20, 75, 220, static_cast<int>(105.0f * fade)),
+				              9.0f * (1.0f - age * 0.5f));
+				draw->AddLine(segment.from, segment.to,
+				              IM_COL32(255, 45, 65, static_cast<int>(230.0f * fade)),
+				              4.0f * (1.0f - age * 0.5f));
+			} else if (skin == TouchParticleSkin::Crimson) {
+				draw->AddLine(segment.from, segment.to,
+				              IM_COL32(110, 0, 8, static_cast<int>(130.0f * fade)),
+				              9.0f * (1.0f - age * 0.5f));
+				draw->AddLine(segment.from, segment.to,
+				              IM_COL32(255, 35, 20, static_cast<int>(235.0f * fade)),
+				              4.0f * (1.0f - age * 0.5f));
+			} else {
+				draw->AddLine(segment.from, segment.to,
+				              IM_COL32(35, 145, 255, static_cast<int>(180.0f * fade)),
+				              5.0f * (1.0f - age * 0.5f));
+			}
+		}
+
+		for (const auto& particle: particles) {
+			const float age =
+			    std::chrono::duration<float>(now - particle.born).count() / PARTICLE_LIFETIME;
+			const float alpha = 1.0f - age;
+			const float size  = 9.0f * (1.0f - age * 0.35f);
+			const float drift = (static_cast<uint8_t>(particle.icon) % 2 == 0 ? -1.0f : 1.0f) *
+			                    8.0f * age;
+			const ImVec2 center {particle.position.x + drift, particle.position.y - 18.0f * age};
+			const auto faded = [alpha, skin, icon = particle.icon](int r, int g, int b) {
+				if (skin == TouchParticleSkin::BlueNeon) {
+					r = 75;
+					g = 220;
+					b = 255;
+				} else if (skin == TouchParticleSkin::RedBlue) {
+					const bool red = icon == TouchParticleIcon::Square ||
+					                 icon == TouchParticleIcon::Cross;
+					r = red ? 255 : 75;
+					g = red ? 65 : 175;
+					b = red ? 85 : 255;
+				} else if (skin == TouchParticleSkin::Monochrome) {
+					r = 235;
+					g = 245;
+					b = 255;
+				} else if (skin == TouchParticleSkin::Crimson) {
+					const bool ember = icon == TouchParticleIcon::Triangle ||
+					                   icon == TouchParticleIcon::Circle;
+					r = 255;
+					g = ember ? 205 : 115;
+					b = ember ? 70 : 15;
+				}
+				return IM_COL32(r, g, b, static_cast<int>(255.0f * alpha));
+			};
+
+			if (skin != TouchParticleSkin::Classic) {
+				const ImU32 glow =
+				    skin == TouchParticleSkin::BlueNeon
+				        ? IM_COL32(0, 115, 255, static_cast<int>(38.0f * alpha))
+				        : (skin == TouchParticleSkin::RedBlue
+				               ? IM_COL32(75, 100, 255, static_cast<int>(55.0f * alpha))
+				               : (skin == TouchParticleSkin::Crimson
+				               ? IM_COL32(255, 70, 0, static_cast<int>(70.0f * alpha))
+				               : IM_COL32(115, 165, 255, static_cast<int>(30.0f * alpha))));
+				draw->AddCircleFilled(center, size + 6.0f, glow);
+			}
+			const ImU32 particle_glow =
+			    skin == TouchParticleSkin::Crimson
+			        ? (particle.icon == TouchParticleIcon::Triangle ||
+			                   particle.icon == TouchParticleIcon::Circle
+			               ? IM_COL32(255, 195, 30, static_cast<int>(135.0f * alpha))
+			               : IM_COL32(255, 95, 0, static_cast<int>(135.0f * alpha)))
+			        : (skin == TouchParticleSkin::RedBlue
+			               ? (particle.icon == TouchParticleIcon::Square ||
+			                          particle.icon == TouchParticleIcon::Cross
+			                      ? IM_COL32(255, 40, 65, static_cast<int>(105.0f * alpha))
+			                      : IM_COL32(35, 125, 255, static_cast<int>(105.0f * alpha)))
+			               : IM_COL32(35, 145, 255,
+			                          static_cast<int>((skin == TouchParticleSkin::BlueNeon
+			                                                ? 100.0f
+			                                                : 65.0f) *
+			                                           alpha)));
+			draw->AddCircleFilled(center, size + 2.0f, particle_glow);
+			switch (particle.icon) {
+				case TouchParticleIcon::Square:
+					draw->AddRect({center.x - size * 0.65f, center.y - size * 0.65f},
+					              {center.x + size * 0.65f, center.y + size * 0.65f},
+					              faded(255, 105, 180), 2.0f, 0, 2.2f);
+					break;
+				case TouchParticleIcon::Triangle:
+					draw->AddLine({center.x, center.y - size}, {center.x - size, center.y + size},
+					              faded(80, 230, 130), 2.2f);
+					draw->AddLine({center.x - size, center.y + size},
+					              {center.x + size, center.y + size}, faded(80, 230, 130), 2.2f);
+					draw->AddLine({center.x + size, center.y + size},
+					              {center.x, center.y - size}, faded(80, 230, 130), 2.2f);
+					break;
+				case TouchParticleIcon::Cross:
+					draw->AddLine({center.x - size * 0.75f, center.y - size * 0.75f},
+					              {center.x + size * 0.75f, center.y + size * 0.75f},
+					              faded(90, 170, 255), 2.5f);
+					draw->AddLine({center.x + size * 0.75f, center.y - size * 0.75f},
+					              {center.x - size * 0.75f, center.y + size * 0.75f},
+					              faded(90, 170, 255), 2.5f);
+					break;
+				case TouchParticleIcon::Circle:
+					draw->AddCircle(center, size * 0.8f, faded(255, 105, 105), 0, 2.2f);
+					break;
+			}
+		}
+	}
+
+	void DrawTouchPadCursor(const HostInputTouchPadVisualState& state) {
+		if (!TouchCursorImageEnabled()) {
+			particles.clear();
+			trail_segments.clear();
+			return;
+		}
+		const auto now = Clock::now();
+		if (state.enabled && state.position_valid) {
+			const ImVec2 target {state.x * extent.width, state.y * extent.height};
+			if (!cursor_initialized || state.gesture != cursor_gesture) {
+				cursor_position    = target;
+				cursor_initialized = true;
+				cursor_gesture     = state.gesture;
+				particle_distance  = 0.0f;
+			} else {
+				const float dt = last_cursor_update == Clock::time_point {}
+				                     ? 1.0f / 60.0f
+				                     : std::clamp(std::chrono::duration<float>(now -
+				                                                             last_cursor_update)
+				                                      .count(),
+				                                  1.0f / 1000.0f, 0.05f);
+				const ImVec2 previous = cursor_position;
+				const float  follow   = 1.0f - std::exp(-18.0f * dt);
+				cursor_position.x += (target.x - cursor_position.x) * follow;
+				cursor_position.y += (target.y - cursor_position.y) * follow;
+				if (state.drawing) {
+					EmitTouchParticles(previous, cursor_position, now);
+				}
+			}
+			last_cursor_update = now;
+		}
+		auto* draw = ImGui::GetForegroundDrawList();
+		DrawTouchParticles(draw, now);
+		if (!state.enabled || !state.cursor_visible ||
+		    !state.position_valid || !cursor_initialized) {
+			return;
+		}
+
+		const ImVec2 position = cursor_position;
+		const auto& cursor_image =
+		    state.drawing ? drawing_cursor_image : hand_cursor_image;
+		if (cursor_image != nullptr) {
+			const float scale = TOUCH_CURSOR_IMAGE_SIZE /
+			                    static_cast<float>(std::max(cursor_image->Height, 1));
+			const ImVec2 size {static_cast<float>(cursor_image->Width) * scale,
+			                   static_cast<float>(cursor_image->Height) * scale};
+			draw->AddImage(cursor_image->GetTexRef(), position,
+			               {position.x + size.x, position.y + size.y});
+			return;
+		}
+
+		const ImU32  blue     = IM_COL32(35, 145, 255, 220);
+		const ImVec2 hand[] = {
+		    {position.x, position.y},         {position.x, position.y + 20.0f},
+		    {position.x + 4.0f, position.y + 16.0f},
+		    {position.x + 9.0f, position.y + 27.0f},
+		    {position.x + 13.0f, position.y + 25.0f},
+		    {position.x + 10.0f, position.y + 17.0f},
+		    {position.x + 18.0f, position.y + 18.0f},
+		    {position.x + 20.0f, position.y + 15.0f},
+		    {position.x + 19.0f, position.y + 12.0f},
+		    {position.x + 12.0f, position.y + 10.0f},
+		    {position.x + 12.0f, position.y + 4.0f},
+		    {position.x + 10.0f, position.y + 2.0f},
+		    {position.x + 8.0f, position.y + 3.0f},
+		    {position.x + 8.0f, position.y + 10.0f},
+		    {position.x + 6.0f, position.y + 2.0f},
+		    {position.x + 4.0f, position.y + 2.0f},
+		    {position.x + 3.0f, position.y + 10.0f},
+		    {position.x + 2.0f, position.y + 1.0f},
+		};
+		draw->AddConvexPolyFilled(hand, IM_ARRAYSIZE(hand), IM_COL32(250, 250, 250, 255));
+		for (std::size_t i = 0; i < IM_ARRAYSIZE(hand); i++) {
+			draw->AddLine(hand[i], hand[(i + 1) % IM_ARRAYSIZE(hand)],
+			              IM_COL32(20, 25, 35, 255), 1.5f);
+		}
+		if (state.drawing) {
+			const ImVec2 pen_start {position.x + 12.0f, position.y + 8.0f};
+			const ImVec2 pen_end {position.x + 23.0f, position.y - 3.0f};
+			draw->AddLine(pen_start, pen_end, IM_COL32(10, 45, 95, 255), 5.0f);
+			draw->AddLine(pen_start, pen_end, blue, 2.5f);
+		}
+	}
+
+	void DrawTrophyNotification(vk::Extent2D frame_extent, Clock::time_point now, float min_top) {
 		std::erase_if(retired_trophy_images, [](const auto& texture) {
 			if (texture->Status != ImTextureStatus_Destroyed) {
 				return false;
@@ -1199,7 +1671,7 @@ struct SystemOverlay::Impl {
 			ImGui::UnregisterUserTexture(texture.get());
 			return true;
 		});
-		constexpr float TOAST_LIFETIME = 5.0f;
+		const float TOAST_LIFETIME = static_cast<float>(Config::GetTrophyDurationSeconds());
 		if (trophy_notification &&
 		    std::chrono::duration<float>(now - trophy_notification_born).count() >=
 		        TOAST_LIFETIME) {
@@ -1221,8 +1693,9 @@ struct SystemOverlay::Impl {
 				trophy_notification = std::move(g_trophy_notifications.front());
 				g_trophy_notifications.pop_front();
 			}
-			trophy_notification_born  = now;
-			trophy_notification_image = LoadTrophyIcon(trophy_notification->icon_png);
+			trophy_notification_subtitle = PrepareTrophySubtitle(Config::GetConsoleLanguage());
+			trophy_notification_born     = now;
+			trophy_notification_image    = LoadTrophyIcon(trophy_notification->icon_png);
 			PlayTrophySound();
 		}
 		const float age = std::chrono::duration<float>(now - trophy_notification_born).count();
@@ -1258,7 +1731,7 @@ struct SystemOverlay::Impl {
 		const float  alpha    = std::min(fade_in, fade_out);
 		const float  slide    = (1.0f - fade_in) * (width + 24.0f);
 		const ImVec2 top_left {static_cast<float>(frame_extent.width) - 32.0f - width + slide,
-		                       32.0f};
+		                       std::max(32.0f, min_top + 12.0f)};
 		const ImVec2 bottom_right {top_left.x + width, top_left.y + height};
 		auto*        draw = ImGui::GetForegroundDrawList();
 		const auto   fade = [alpha](int r, int g, int b, int a) {
@@ -1306,8 +1779,17 @@ struct SystemOverlay::Impl {
 			              line.data(), line.data() + line.size());
 			line_y += line_height;
 		}
-		draw->AddText(nullptr, 20.0f * screen_scale, {text_left, line_y + 8.0f * screen_scale},
-		              fade(176, 180, 192, 255), "Trophy earned!");
+		const float subtitle_size = 20.0f * screen_scale;
+		const float subtitle_width =
+		    ImGui::GetFont()
+		        ->CalcTextSizeA(subtitle_size, std::numeric_limits<float>::max(), 0.0f,
+		                        trophy_notification_subtitle.c_str())
+		        .x;
+		const float available_width = std::max(1.0f, width - text_offset - text_padding);
+		const float fitted_size = std::max(
+		    1.0f, subtitle_size * std::min(1.0f, available_width / std::max(1.0f, subtitle_width)));
+		draw->AddText(nullptr, fitted_size, {text_left, line_y + 8.0f * screen_scale},
+		              fade(176, 180, 192, 255), trophy_notification_subtitle.c_str());
 		draw->PopClipRect();
 	}

@@ -1316,7 +1798,8 @@ struct SystemOverlay::Impl {
 		const bool      has_overlay = GetOverlaySnapshot(&snapshot);
 		const auto now = Clock::now();
 		if (!has_overlay && !g_trophy_notification_active.load(std::memory_order_acquire) &&
-		    !g_splash_active.load(std::memory_order_acquire)) {
+		    !g_splash_active.load(std::memory_order_acquire) &&
+		    !GetHostInputTouchPadVisualState().enabled && !PerformanceOverlayEnabled()) {
 			return false;
 		}
 		const auto prepared_session = snapshot.session;
@@ -1347,6 +1830,7 @@ struct SystemOverlay::Impl {
 		ImGui_ImplVulkan_NewFrame();
 		ImGui::NewFrame();
 		DrawSplash(frame_extent);
+		const float performance_bottom = DrawPerformanceOverlay(graphics, frame_extent);
 		GetOverlaySnapshot(&snapshot);
 		if (has_overlay && snapshot.session == prepared_session) {
 			if (snapshot.session.kind == OverlayKind::Dialog) {
@@ -1355,7 +1839,8 @@ struct SystemOverlay::Impl {
 				DrawIme(snapshot.ime, frame_extent);
 			}
 		}
-		DrawTrophyNotification(frame_extent, now);
+		DrawTrophyNotification(frame_extent, now, performance_bottom);
+		DrawTouchPadCursor(GetHostInputTouchPadVisualState());
 		ImGui::Render();
 		extent = frame_extent;
 		return true;
@@ -1410,7 +1895,20 @@ struct SystemOverlay::Impl {
 	ImVec2                                right_stick {};
 	OverlaySession                              session;
 	std::unique_ptr<ImTextureData>              trophy_notification_image;
+	std::unique_ptr<ImTextureData>              hand_cursor_image;
+	std::unique_ptr<ImTextureData>              drawing_cursor_image;
+	bool                                        cursor_initialized = false;
+	ImVec2                                      cursor_position {};
+	float                                       particle_distance  = 0.0f;
+	TouchParticleIcon                           next_particle_icon = TouchParticleIcon::Square;
+	Clock::time_point                           last_cursor_update;
+	uint64_t                                    cursor_gesture = 0;
+	std::vector<TouchParticle>                  particles;
+	std::vector<TouchTrailSegment>              trail_segments;
+	static constexpr std::size_t                MAX_TOUCH_PARTICLES      = 64;
+	static constexpr std::size_t                MAX_TOUCH_TRAIL_SEGMENTS = 128;
 	std::optional<TrophyNotification>           trophy_notification;
+	std::string                                 trophy_notification_subtitle;
 	Clock::time_point                           trophy_notification_born;
 	std::vector<std::unique_ptr<ImTextureData>> retired_trophy_images;
 	std::array<std::unique_ptr<DdsImage>, 2>      splash_dds;
@@ -3,6 +3,7 @@
 #include "common/abi.h"
 #include "common/assert.h"
 #include "common/common.h"
+#include "common/debugCounters.h"
 #include "common/emulatorConfig.h"
 #include "common/logging/log.h"
 #include "common/profiler.h"
@@ -15,6 +16,7 @@
 #include "graphics/host_gpu/renderer/image/imageInfo.h"
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/renderer/renderContext.h"
+#include "graphics/presentation/performanceOverlay.h"
 #include "graphics/presentation/presenter.h"
 #include "graphics/presentation/renderDoc.h"
 #include "kernel/pthread.h"
@@ -145,6 +147,7 @@ struct VideoOutOutputStatus {
 	uint64_t flags        = 0;
 	uint64_t reserved[3]  = {};
 };
+static_assert(sizeof(VideoOutOutputStatus) == 0x30); // Also used by VideoOutVrrStatus.

 struct VideoOutOutputOptions {
 	uint32_t internalData[16] = {};
@@ -908,6 +911,9 @@ void VideoOutDriver::Impl::PresentThread(std::stop_token token) {

 		const auto frame_end = Common::Timer::QueryPerformanceCounter();
 		total_wait += static_cast<int64_t>(period) - static_cast<int64_t>(frame_end - frame_begin);
+		if (total_wait < 0) {
+			Common::DebugCounters::Add(Common::DebugCounters::Counter::LateVblanks);
+		}
 	}
 }

@@ -937,6 +943,7 @@ bool FlipQueue::Reserve(VideoOutConfig& cfg, int index, int64_t flip_arg, FlipRe
 		m_done_cond_var.SignalAll();
 	}
 	if (cfg.flip_status.flipPendingNum >= VIDEO_OUT_FLIP_QUEUE_CAPACITY) {
+		Common::DebugCounters::Add(Common::DebugCounters::Counter::FlipsRejected);
 		return false;
 	}
 	auto& pending = source == FlipRequestSource::GpuEop ? m_requests : m_cpu_requests;
@@ -964,6 +971,7 @@ bool FlipQueue::Reserve(VideoOutConfig& cfg, int index, int64_t flip_arg, FlipRe

 	pending.push_back(r);
 	request_id = r.id;
+	Common::DebugCounters::Add(Common::DebugCounters::Counter::FlipsRequested);

 	cfg.flip_status.flipPendingNum++;
 	cfg.flip_status.submitProcessTimeCounter = r.submit_ptc;
@@ -1242,6 +1250,9 @@ bool FlipQueue::Flip(uint32_t micros) {
 	}
 	if (due) {
 		m_presenter.Present(std::span(layers.data(), count));
+		if (requests[0].cfg->bus == 0) {
+			Graphics::PerformanceOverlayRecordFlip(requests[0].cfg->width, requests[0].cfg->height);
+		}
 	}

 	m_mutex.Lock();
@@ -12,8 +12,10 @@
 #include <cmath>
 #include <cstddef>
 #include <cstdlib>
+#include <mutex>
 #include <string>
 #include <string_view>
+#include <unordered_map>

 namespace Libs::Graphics {

@@ -27,6 +29,8 @@ struct ControlInfo {
 	float            touch_x  = 0.0f;

 	Controller::Setting setting {};
+	bool                gyro          = false;
+	bool                touchpad_mode = false;
 };

 static constexpr std::array CONTROL_INFO = {
@@ -61,10 +65,66 @@ static constexpr std::array CONTROL_INFO = {
    ControlInfo {.name = "VibrationIntensity", .setting = Controller::Setting::VibrationIntensity},
    ControlInfo {.name    = "TriggerEffectIntensity",
                 .setting = Controller::Setting::TriggerEffectIntensity},
+    ControlInfo {.name = "GyroToggle", .gyro = true},
+    ControlInfo {.name = "TouchPadMode", .touchpad_mode = true},
 };

 constexpr std::size_t INVALID_CONTROL = CONTROL_INFO.size();

+struct PadSource {
+	std::string_view name;
+	int              button; // SDL_GamepadButton, or -1 for an analog trigger
+};
+
+constexpr std::array PAD_SOURCES = {
+    PadSource {"South", SDL_GAMEPAD_BUTTON_SOUTH},
+    PadSource {"East", SDL_GAMEPAD_BUTTON_EAST},
+    PadSource {"West", SDL_GAMEPAD_BUTTON_WEST},
+    PadSource {"North", SDL_GAMEPAD_BUTTON_NORTH},
+    PadSource {"Back", SDL_GAMEPAD_BUTTON_BACK},
+    PadSource {"Guide", SDL_GAMEPAD_BUTTON_GUIDE},
+    PadSource {"Start", SDL_GAMEPAD_BUTTON_START},
+    PadSource {"LeftStick", SDL_GAMEPAD_BUTTON_LEFT_STICK},
+    PadSource {"RightStick", SDL_GAMEPAD_BUTTON_RIGHT_STICK},
+    PadSource {"LeftShoulder", SDL_GAMEPAD_BUTTON_LEFT_SHOULDER},
+    PadSource {"RightShoulder", SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER},
+    PadSource {"DpadUp", SDL_GAMEPAD_BUTTON_DPAD_UP},
+    PadSource {"DpadDown", SDL_GAMEPAD_BUTTON_DPAD_DOWN},
+    PadSource {"DpadLeft", SDL_GAMEPAD_BUTTON_DPAD_LEFT},
+    PadSource {"DpadRight", SDL_GAMEPAD_BUTTON_DPAD_RIGHT},
+    PadSource {"Misc1", SDL_GAMEPAD_BUTTON_MISC1},
+    PadSource {"RightPaddle1", SDL_GAMEPAD_BUTTON_RIGHT_PADDLE1},
+    PadSource {"LeftPaddle1", SDL_GAMEPAD_BUTTON_LEFT_PADDLE1},
+    PadSource {"RightPaddle2", SDL_GAMEPAD_BUTTON_RIGHT_PADDLE2},
+    PadSource {"LeftPaddle2", SDL_GAMEPAD_BUTTON_LEFT_PADDLE2},
+    PadSource {"Touchpad", SDL_GAMEPAD_BUTTON_TOUCHPAD},
+    PadSource {"LeftTrigger", -1},
+    PadSource {"RightTrigger", -1},
+};
+
+constexpr std::size_t LEFT_TRIGGER_SOURCE  = PAD_SOURCES.size() - 2;
+constexpr std::size_t RIGHT_TRIGGER_SOURCE = PAD_SOURCES.size() - 1;
+constexpr std::size_t INVALID_SOURCE       = PAD_SOURCES.size();
+
+struct PadDefault {
+	std::string_view control;
+	std::string_view source;
+};
+
+constexpr std::array PAD_DEFAULTS = {
+    PadDefault {"Cross", "South"},         PadDefault {"Circle", "East"},
+    PadDefault {"Square", "West"},         PadDefault {"Triangle", "North"},
+    PadDefault {"Options", "Start"},       PadDefault {"L3", "LeftStick"},
+    PadDefault {"R3", "RightStick"},       PadDefault {"L1", "LeftShoulder"},
+    PadDefault {"R1", "RightShoulder"},    PadDefault {"L2", "LeftTrigger"},
+    PadDefault {"R2", "RightTrigger"},     PadDefault {"Up", "DpadUp"},
+    PadDefault {"Down", "DpadDown"},       PadDefault {"Left", "DpadLeft"},
+    PadDefault {"Right", "DpadRight"},     PadDefault {"TouchPad", "Touchpad"},
+    PadDefault {"GyroToggle", "Back"},
+};
+
+constexpr std::string_view PAD_PREFIX = "Pad:";
+
 struct Binding {
 	SDL_Keycode key          = SDLK_UNKNOWN;
 	uint8_t     mouse_button = 0;
@@ -74,6 +134,7 @@ struct Binding {
 constexpr int              MOUSE_POLL_INTERVAL_MS = 33;
 constexpr uint64_t         CURSOR_IDLE_HIDE_MS    = 2000;
 constexpr std::string_view MOUSE_SENSITIVITY      = "MouseSensitivity=";
+constexpr std::string_view TOUCH_PARTICLE_SKIN    = "TouchParticleSkin=";

 struct MouseJoystickState {
 	bool     enabled   = false;
@@ -85,6 +146,38 @@ MouseJoystickState g_mouse;
 SDL_Window*        g_mouse_window   = nullptr;
 uint64_t           g_cursor_hide_at = 0;

+struct MouseTouchPadState {
+	bool     enabled        = false;
+	bool     cursor_visible = true;
+	bool     drawing        = false;
+	bool     position_valid = false;
+	float    x              = 0.5f;
+	float    y              = 0.5f;
+	uint64_t revision       = 0;
+	uint64_t gesture        = 0;
+};
+
+struct GamepadTouchPadState {
+	bool     enabled   = false;
+	bool     drawing   = false;
+	int      id        = -1;
+	int      x_axis    = 128;
+	int      y_axis    = 128;
+	float    x         = 0.5f;
+	float    y         = 0.5f;
+	uint64_t next_poll = 0;
+	uint64_t last_poll = 0;
+};
+
+constexpr int   GAMEPAD_TOUCHPAD_POLL_MS = 8;
+constexpr int   GAMEPAD_TOUCHPAD_DEADZONE = 18;
+constexpr float GAMEPAD_TOUCHPAD_SPEED    = 0.8f;
+
+MouseTouchPadState   g_mouse_touchpad;
+GamepadTouchPadState g_gamepad_touchpad;
+std::mutex           g_touchpad_mutex;
+std::unordered_map<int, std::array<bool, 2>> g_pad_trigger_pressed;
+
 std::size_t ControlFromName(std::string_view name) {
 	const auto info = std::find_if(CONTROL_INFO.begin(), CONTROL_INFO.end(),
 	                               [name](const auto& item) { return item.name == name; });
@@ -126,6 +219,14 @@ public:
 	InputMap() {
 		for (const auto& value: Config::GetKeymap()) {
 			const std::string_view entry = value;
+			if (entry == "Keyboard=Disabled") {
+				m_custom = true;
+				continue;
+			}
+			if (entry == "Pad=Disabled") {
+				m_custom_pad = true;
+				continue;
+			}
 			if (entry.starts_with(MOUSE_SENSITIVITY)) {
 				const float sensitivity =
 				    std::strtof(value.c_str() + MOUSE_SENSITIVITY.size(), nullptr);
@@ -133,6 +234,13 @@ public:
 				    std::clamp(std::isfinite(sensitivity) ? sensitivity : 1.0f, 0.1f, 5.0f);
 				continue;
 			}
+			if (entry.starts_with(TOUCH_PARTICLE_SKIN) || entry.starts_with("TouchCursorImage=")) {
+				continue;
+			}
+			if (entry.starts_with(PAD_PREFIX)) {
+				AddPadEntry(entry.substr(PAD_PREFIX.size()), value);
+				continue;
+			}
 			const auto split = entry.find('=');

 			Binding binding;
@@ -146,17 +254,33 @@ public:
 			}

 			const bool reserved = binding.key == SDLK_ESCAPE || binding.key == SDLK_F1 ||
-			                      binding.key == SDLK_F7 || binding.key == SDLK_F11;
+			                      binding.key == SDLK_F2 || binding.key == SDLK_F7 ||
+			                      binding.key == SDLK_F8 || binding.key == SDLK_F11;
 			if (binding.control == INVALID_CONTROL || reserved ||
 			    (binding.key == SDLK_UNKNOWN && binding.mouse_button == 0)) {
 				EXIT("Invalid input mapping: %s\n", value.c_str());
 			}
 			Add(binding);
 		}
+		if (!m_custom_pad) {
+			for (const auto& item: PAD_DEFAULTS) {
+				AssignPad(ControlFromName(item.control), SourceFromName(item.source));
+			}
+		}
 	}
-	[[nodiscard]] bool  Custom() const { return m_size != 0; }
+	[[nodiscard]] bool  Custom() const { return m_custom; }
 	[[nodiscard]] float MouseSensitivity() const { return m_mouse_sensitivity; }

+	[[nodiscard]] std::size_t PadControl(std::size_t source) const {
+		return source < m_pad_controls.size() ? m_pad_controls[source] : INVALID_CONTROL;
+	}
+
+	static std::size_t SourceFromButton(int button) {
+		const auto item = std::find_if(PAD_SOURCES.begin(), PAD_SOURCES.end(),
+		                               [button](const auto& s) { return s.button == button; });
+		return static_cast<std::size_t>(std::distance(PAD_SOURCES.begin(), item));
+	}
+
 	[[nodiscard]] std::size_t FindKey(int key_code) const {
 		key_code = NormalizeKey(static_cast<SDL_Keycode>(key_code));
 		const auto binding =
@@ -173,7 +297,39 @@ public:
 	}

 private:
+	static std::size_t SourceFromName(std::string_view name) {
+		const auto item = std::find_if(PAD_SOURCES.begin(), PAD_SOURCES.end(),
+		                               [name](const auto& s) { return s.name == name; });
+		return static_cast<std::size_t>(std::distance(PAD_SOURCES.begin(), item));
+	}
+
+	void AssignPad(std::size_t control, std::size_t source) {
+		for (auto& existing: m_pad_controls) {
+			if (existing == control) {
+				existing = INVALID_CONTROL;
+			}
+		}
+		m_pad_controls[source] = control;
+	}
+
+	void AddPadEntry(std::string_view entry, const std::string& original) {
+		const auto split   = entry.find('=');
+		const auto control = split != std::string_view::npos ? ControlFromName(entry.substr(0, split))
+		                                                     : INVALID_CONTROL;
+		const auto source  = split != std::string_view::npos ? SourceFromName(entry.substr(split + 1))
+		                                                     : INVALID_SOURCE;
+		if (control == INVALID_CONTROL || source == INVALID_SOURCE) {
+			EXIT("Invalid input mapping: %s\n", original.c_str());
+		}
+		const auto& info = CONTROL_INFO[control];
+		if (info.button == 0 && !info.gyro && info.axis != Controller::Axis::AxisMax) {
+			EXIT("Invalid input mapping: %s\n", original.c_str());
+		}
+		m_custom_pad = true;
+		AssignPad(control, source);
+	}
 	void Add(const Binding& binding) {
+		m_custom = true;
 		for (std::size_t index = 0; index < m_size;) {
 			if (Conflicts(m_bindings[index], binding)) {
 				m_bindings[index] = m_bindings[--m_size];
@@ -186,6 +342,13 @@ private:
 	}

 	std::array<Binding, CONTROL_INFO.size()> m_bindings {};
+	std::array<std::size_t, PAD_SOURCES.size()> m_pad_controls = [] {
+		std::array<std::size_t, PAD_SOURCES.size()> a {};
+		a.fill(INVALID_CONTROL);
+		return a;
+	}();
+	bool                                     m_custom = false;
+	bool                                     m_custom_pad = false;
 	std::size_t                              m_size              = 0;
 	float                                    m_mouse_sensitivity = 1.0f;
 };
@@ -211,6 +374,39 @@ void SetTouchPad(float x, bool down) {
 	Controller::SetTouchPad(Controller::HOST_INPUT_CONTROLLER_ID, 0, down, x, 0.5f);
 }

+void SetSwipeTouchPad(bool down, float x, float y) {
+	Controller::SetTouchPad(Controller::HOST_INPUT_CONTROLLER_ID, 1, down, x, y);
+}
+
+void RecordMouseTouchPadPosition(float x, float y) {
+	int width  = 0;
+	int height = 0;
+	if (g_mouse_window != nullptr) {
+		SDL_GetWindowSize(g_mouse_window, &width, &height);
+	}
+	if (width > 0 && height > 0) {
+		x = std::clamp(x / static_cast<float>(width), 0.0f, 1.0f);
+		y = std::clamp(y / static_cast<float>(height), 0.0f, 1.0f);
+	} else {
+		x = 0.5f;
+		y = 0.5f;
+	}
+
+	std::scoped_lock lock(g_touchpad_mutex);
+	if (!g_mouse_touchpad.enabled) {
+		return;
+	}
+	g_mouse_touchpad.x              = x;
+	g_mouse_touchpad.y              = y;
+	g_mouse_touchpad.position_valid = true;
+	g_mouse_touchpad.revision++;
+}
+
+bool TouchPadModeActive() {
+	std::scoped_lock lock(g_touchpad_mutex);
+	return g_mouse_touchpad.enabled || g_gamepad_touchpad.enabled;
+}
+
 uint32_t DefaultKeyboardButton(int key_code) {
 	switch (NormalizeKey(static_cast<SDL_Keycode>(key_code))) {
 		case SDLK_UP: return Controller::PAD_BUTTON_UP;
@@ -270,6 +466,18 @@ void SetControl(std::size_t control, bool down) {
 		SetButton(info.button, down);
 		return;
 	}
+	if (info.gyro) {
+		if (down) {
+			Controller::ToggleGyroEmulation(Controller::HOST_INPUT_CONTROLLER_ID);
+		}
+		return;
+	}
+	if (info.touchpad_mode) {
+		if (down) {
+			HostInputToggleTouchPadMode();
+		}
+		return;
+	}
 	if (info.axis == Controller::Axis::AxisMax) {
 		CycleSettingOnPress(info.setting, down);
 		return;
@@ -297,6 +505,11 @@ void DefaultKeyboardInput(int key_code, bool down) {

 	switch (NormalizeKey(static_cast<SDL_Keycode>(key_code))) {
 		case SDLK_BACKSPACE: SetTouchPad(0.25f, down); return;
+		case SDLK_F6:
+			if (down) {
+				HostInputToggleTouchPadMode();
+			}
+			return;
 		case SDLK_TAB: SetTouchPad(0.75f, down); return;
 		case SDLK_1: CycleSettingOnPress(Controller::Setting::SpeakerVolume, down); return;
 		case SDLK_2: CycleSettingOnPress(Controller::Setting::VibrationIntensity, down); return;
@@ -399,8 +612,134 @@ bool IsCursorActivity(const SDL_Event& event) {
 	return which != SDL_TOUCH_MOUSEID && which != SDL_PEN_MOUSEID;
 }

+std::array<int, 2> GamepadLeftStick(int id) {
+	auto* pad = SDL_GetGamepadFromID(id);
+	if (pad == nullptr) {
+		return {128, 128};
+	}
+	const auto value = [pad](SDL_GamepadAxis axis) {
+		return Controller::controller_get_axis(SDL_JOYSTICK_AXIS_MIN, SDL_JOYSTICK_AXIS_MAX,
+		                                       SDL_GetGamepadAxis(pad, axis));
+	};
+	return {value(SDL_GAMEPAD_AXIS_LEFTX), value(SDL_GAMEPAD_AXIS_LEFTY)};
+}
+
+void ApplyPadControl(int id, std::size_t control, std::size_t source, bool down) {
+	if (control == INVALID_CONTROL) {
+		return;
+	}
+	const auto& info = CONTROL_INFO[control];
+	if (info.gyro) {
+		if (down) {
+			Controller::ToggleGyroEmulation(id);
+		}
+	} else if (info.touchpad_mode) {
+		if (down) {
+			HostInputToggleGamepadTouchPad(id);
+		}
+	} else if (info.button == Controller::PAD_BUTTON_CROSS && HostInputGamepadDrawButton(id, down)) {
+		return;
+	} else if (info.button == Controller::PAD_BUTTON_TOUCH_PAD) {
+		// Real touchpads report their own finger position; other inputs emulate a click.
+		if (source != PAD_SOURCES.size() && PAD_SOURCES[source].button != SDL_GAMEPAD_BUTTON_TOUCHPAD) {
+			Controller::SetTouchPad(id, 0, down, info.touch_x != 0.0f ? info.touch_x : 0.5f, 0.5f);
+		}
+		Controller::SetButton(id, Controller::PAD_BUTTON_TOUCH_PAD, down);
+	} else if (info.button == Controller::PAD_BUTTON_L2) {
+		Controller::SetAxis(id, Controller::Axis::TriggerLeft, down ? 255 : 0);
+	} else if (info.button == Controller::PAD_BUTTON_R2) {
+		Controller::SetAxis(id, Controller::Axis::TriggerRight, down ? 255 : 0);
+	} else if (info.button != 0) {
+		Controller::SetButton(id, info.button, down);
+	} else if (info.axis == Controller::Axis::AxisMax) {
+		CycleSettingOnPress(info.setting, down);
+	}
+}
+
+int PollGamepadTouchPad(uint64_t now_ms) {
+	float x       = 0;
+	float y       = 0;
+	int   id      = -1;
+	bool  drawing = false;
+	{
+		std::scoped_lock lock(g_touchpad_mutex);
+		if (!g_gamepad_touchpad.enabled) {
+			return -1;
+		}
+		if (now_ms < g_gamepad_touchpad.next_poll) {
+			return static_cast<int>(g_gamepad_touchpad.next_poll - now_ms);
+		}
+
+		const float dt = g_gamepad_touchpad.last_poll == 0 || now_ms <= g_gamepad_touchpad.last_poll
+		                     ? 0.008f
+		                     : std::min(static_cast<float>(now_ms - g_gamepad_touchpad.last_poll) *
+		                                    0.001f,
+		                                0.05f);
+		g_gamepad_touchpad.last_poll = now_ms;
+		g_gamepad_touchpad.next_poll = now_ms + GAMEPAD_TOUCHPAD_POLL_MS;
+		const auto velocity          = [](int axis) {
+            const int offset = axis - 128;
+            if (std::abs(offset) <= GAMEPAD_TOUCHPAD_DEADZONE) {
+                return 0.0f;
+            }
+            const int adjusted =
+                offset > 0 ? offset - GAMEPAD_TOUCHPAD_DEADZONE : offset + GAMEPAD_TOUCHPAD_DEADZONE;
+            return static_cast<float>(adjusted) / static_cast<float>(127 - GAMEPAD_TOUCHPAD_DEADZONE);
+		};
+		const float old_x = g_gamepad_touchpad.x;
+		const float old_y = g_gamepad_touchpad.y;
+		g_gamepad_touchpad.x = std::clamp(
+		    old_x + velocity(g_gamepad_touchpad.x_axis) * GAMEPAD_TOUCHPAD_SPEED * dt, 0.0f, 1.0f);
+		g_gamepad_touchpad.y = std::clamp(
+		    old_y + velocity(g_gamepad_touchpad.y_axis) * GAMEPAD_TOUCHPAD_SPEED * dt, 0.0f, 1.0f);
+		if (old_x != g_gamepad_touchpad.x || old_y != g_gamepad_touchpad.y) {
+			g_mouse_touchpad.revision++;
+		}
+		id      = g_gamepad_touchpad.id;
+		x       = g_gamepad_touchpad.x;
+		y       = g_gamepad_touchpad.y;
+		drawing = g_gamepad_touchpad.drawing;
+	}
+	if (drawing) {
+		Controller::SetTouchPad(id, 1, true, x, y);
+	}
+	return GAMEPAD_TOUCHPAD_POLL_MS;
+}
+
 } // namespace

+void HostInputPadButton(int id, int button, bool down) {
+	const auto  source = InputMap::SourceFromButton(button);
+	const auto& map    = GetInputMap();
+	ApplyPadControl(id, map.PadControl(source), source, down);
+}
+
+void HostInputPadTrigger(int id, bool left, int value) {
+	const auto  source     = left ? LEFT_TRIGGER_SOURCE : RIGHT_TRIGGER_SOURCE;
+	const auto  control    = GetInputMap().PadControl(source);
+	if (control == INVALID_CONTROL) {
+		return;
+	}
+	const auto& info = CONTROL_INFO[control];
+	if (info.button == Controller::PAD_BUTTON_L2) {
+		Controller::SetAxis(id, Controller::Axis::TriggerLeft, value);
+	} else if (info.button == Controller::PAD_BUTTON_R2) {
+		Controller::SetAxis(id, Controller::Axis::TriggerRight, value);
+	} else {
+		auto& state = g_pad_trigger_pressed[id][left ? 0 : 1];
+		const bool down = state ? value > 32 : value > 96;
+		if (down != state) {
+			state = down;
+			ApplyPadControl(id, control, source, down);
+		}
+	}
+}
+
+void HostInputDisconnectGamepad(int id) {
+	g_pad_trigger_pressed.erase(id);
+	HostInputDisconnectGamepadTouchPad(id);
+}
+
 void HostInputInit(SDL_Window* window) {
 	GetInputMap();
 	g_mouse_window = window;
@@ -410,6 +749,16 @@ void HostInputInit(SDL_Window* window) {
 }

 void HostInputShutdown() {
+	g_pad_trigger_pressed.clear();
+	HostInputSetTouchPadMode(false);
+	int gamepad_touch_id = -1;
+	{
+		std::scoped_lock lock(g_touchpad_mutex);
+		gamepad_touch_id = g_gamepad_touchpad.enabled ? g_gamepad_touchpad.id : -1;
+	}
+	if (gamepad_touch_id >= 0) {
+		HostInputDisconnectGamepadTouchPad(gamepad_touch_id);
+	}
 	if (g_mouse.enabled) {
 		SetRelativeMouseMode(false);
 		CenterMouseStick();
@@ -438,6 +787,219 @@ void HostInputMouseButton(uint8_t mouse_button, bool down) {
 	}
 }

+void HostInputMouseTouchPad(bool down, float x, float y) {
+	RecordMouseTouchPadPosition(x, y);
+	{
+		std::scoped_lock lock(g_touchpad_mutex);
+		if (!g_mouse_touchpad.enabled) {
+			return;
+		}
+		if (down && !g_mouse_touchpad.drawing) {
+			g_mouse_touchpad.gesture++;
+		}
+		g_mouse_touchpad.drawing = down;
+		g_mouse_touchpad.revision++;
+		x = g_mouse_touchpad.x;
+		y = g_mouse_touchpad.y;
+	}
+	SetSwipeTouchPad(down, x, y);
+}
+
+void HostInputMouseMotion(float x, float y) {
+	RecordMouseTouchPadPosition(x, y);
+	std::scoped_lock lock(g_touchpad_mutex);
+	if (g_mouse_touchpad.enabled && g_mouse_touchpad.drawing) {
+		SetSwipeTouchPad(true, g_mouse_touchpad.x, g_mouse_touchpad.y);
+	}
+}
+
+void HostInputSetTouchPadMode(bool enabled) {
+	if (enabled) {
+		int gamepad_id = -1;
+		{
+			std::scoped_lock lock(g_touchpad_mutex);
+			if (g_gamepad_touchpad.enabled) {
+				gamepad_id = g_gamepad_touchpad.id;
+			}
+		}
+		if (gamepad_id >= 0) {
+			HostInputDisconnectGamepadTouchPad(gamepad_id);
+		}
+	}
+	{
+		std::scoped_lock lock(g_touchpad_mutex);
+		if (g_mouse_touchpad.enabled == enabled) {
+			return;
+		}
+	}
+	if (!enabled) {
+		float x = 0;
+		float y = 0;
+		(void) SDL_GetMouseState(&x, &y);
+		HostInputMouseTouchPad(false, x, y);
+	}
+	bool show_system_cursor = false;
+	{
+		std::scoped_lock lock(g_touchpad_mutex);
+		g_mouse_touchpad.enabled        = enabled;
+		g_mouse_touchpad.cursor_visible = true;
+		g_mouse_touchpad.drawing        = false;
+		g_mouse_touchpad.position_valid = false;
+		g_mouse_touchpad.gesture++;
+		g_mouse_touchpad.revision++;
+		show_system_cursor = !enabled && !g_gamepad_touchpad.enabled;
+	}
+	if (enabled) {
+		if (!SDL_HideCursor()) {
+			LOGF("Failed to hide mouse cursor for touchpad mode: %s\n", SDL_GetError());
+		}
+	} else if (show_system_cursor && !Config::HideCursorEnabled() && !SDL_ShowCursor()) {
+		LOGF("Failed to restore mouse cursor after touchpad mode: %s\n", SDL_GetError());
+	}
+	LOGF("Mouse touchpad mode: %s\n", enabled ? "enabled" : "disabled");
+}
+
+void HostInputToggleTouchPadMode() {
+	bool enabled = false;
+	{
+		std::scoped_lock lock(g_touchpad_mutex);
+		enabled = !g_mouse_touchpad.enabled;
+	}
+	HostInputSetTouchPadMode(enabled);
+}
+
+void HostInputToggleGamepadTouchPad(int id) {
+	bool mouse_mode = false;
+	{
+		std::scoped_lock lock(g_touchpad_mutex);
+		mouse_mode = g_mouse_touchpad.enabled;
+	}
+	if (mouse_mode) {
+		HostInputSetTouchPadMode(false);
+	}
+
+	const auto stick = GamepadLeftStick(id);
+	bool  enabled = false;
+	float x       = 0.5f;
+	float y       = 0.5f;
+	{
+		std::scoped_lock lock(g_touchpad_mutex);
+		if (g_gamepad_touchpad.enabled && g_gamepad_touchpad.id != id) {
+			return;
+		}
+		enabled = !g_gamepad_touchpad.enabled;
+		if (enabled) {
+			g_gamepad_touchpad           = {};
+			g_gamepad_touchpad.enabled   = true;
+			g_gamepad_touchpad.id        = id;
+			g_gamepad_touchpad.x_axis    = stick[0];
+			g_gamepad_touchpad.y_axis    = stick[1];
+			g_gamepad_touchpad.last_poll = SDL_GetTicks();
+			g_gamepad_touchpad.next_poll = g_gamepad_touchpad.last_poll + GAMEPAD_TOUCHPAD_POLL_MS;
+			g_mouse_touchpad.gesture++;
+		} else {
+			x                          = g_gamepad_touchpad.x;
+			y                          = g_gamepad_touchpad.y;
+			g_gamepad_touchpad         = {};
+		}
+		g_mouse_touchpad.revision++;
+	}
+	Controller::SetAxis(id, Controller::Axis::LeftX, enabled ? 128 : stick[0]);
+	Controller::SetAxis(id, Controller::Axis::LeftY, enabled ? 128 : stick[1]);
+	if (enabled) {
+		if (!SDL_HideCursor()) {
+			LOGF("Failed to hide mouse cursor for gamepad touchpad mode: %s\n", SDL_GetError());
+		}
+	} else {
+		Controller::SetTouchPad(id, 1, false, x, y);
+		if (!Config::HideCursorEnabled() && !SDL_ShowCursor()) {
+			LOGF("Failed to restore mouse cursor after gamepad touchpad mode: %s\n",
+			     SDL_GetError());
+		}
+	}
+	LOGF("Gamepad touchpad mode: %s\n", enabled ? "enabled" : "disabled");
+}
+
+bool HostInputGamepadDrawButton(int id, bool down) {
+	float x = 0;
+	float y = 0;
+	{
+		std::scoped_lock lock(g_touchpad_mutex);
+		if (!g_gamepad_touchpad.enabled || g_gamepad_touchpad.id != id) {
+			return false;
+		}
+		if (!down && !g_gamepad_touchpad.drawing) {
+			return false;
+		}
+		if (down && !g_gamepad_touchpad.drawing) {
+			g_mouse_touchpad.gesture++;
+		}
+		g_gamepad_touchpad.drawing = down;
+		x                          = g_gamepad_touchpad.x;
+		y                          = g_gamepad_touchpad.y;
+		g_mouse_touchpad.revision++;
+	}
+	Controller::SetTouchPad(id, 1, down, x, y);
+	return true;
+}
+
+bool HostInputGamepadAxis(int id, bool horizontal, int value) {
+	std::scoped_lock lock(g_touchpad_mutex);
+	if (!g_gamepad_touchpad.enabled || g_gamepad_touchpad.id != id) {
+		return false;
+	}
+	(horizontal ? g_gamepad_touchpad.x_axis : g_gamepad_touchpad.y_axis) = std::clamp(value, 0, 255);
+	g_gamepad_touchpad.next_poll = SDL_GetTicks();
+	return true;
+}
+
+void HostInputDisconnectGamepadTouchPad(int id) {
+	float x = 0;
+	float y = 0;
+	{
+		std::scoped_lock lock(g_touchpad_mutex);
+		if (!g_gamepad_touchpad.enabled || g_gamepad_touchpad.id != id) {
+			return;
+		}
+		x                  = g_gamepad_touchpad.x;
+		y                  = g_gamepad_touchpad.y;
+		g_gamepad_touchpad = {};
+		g_mouse_touchpad.revision++;
+	}
+	Controller::SetTouchPad(id, 1, false, x, y);
+	const auto stick = GamepadLeftStick(id);
+	Controller::SetAxis(id, Controller::Axis::LeftX, stick[0]);
+	Controller::SetAxis(id, Controller::Axis::LeftY, stick[1]);
+	if (!TouchPadModeActive() && !Config::HideCursorEnabled() && !SDL_ShowCursor()) {
+		LOGF("Failed to restore mouse cursor after gamepad disconnect: %s\n", SDL_GetError());
+	}
+}
+
+HostInputTouchPadVisualState GetHostInputTouchPadVisualState() {
+	std::scoped_lock             lock(g_touchpad_mutex);
+	HostInputTouchPadVisualState state {};
+	if (g_gamepad_touchpad.enabled) {
+		state.enabled        = true;
+		state.cursor_visible = true;
+		state.drawing        = g_gamepad_touchpad.drawing;
+		state.x              = g_gamepad_touchpad.x;
+		state.y              = g_gamepad_touchpad.y;
+		state.revision       = g_mouse_touchpad.revision;
+		state.gesture        = g_mouse_touchpad.gesture;
+		state.position_valid = true;
+		return state;
+	}
+	state.enabled        = g_mouse_touchpad.enabled;
+	state.cursor_visible = g_mouse_touchpad.cursor_visible;
+	state.drawing        = g_mouse_touchpad.drawing;
+	state.x              = g_mouse_touchpad.x;
+	state.y              = g_mouse_touchpad.y;
+	state.revision       = g_mouse_touchpad.revision;
+	state.gesture        = g_mouse_touchpad.gesture;
+	state.position_valid = g_mouse_touchpad.position_valid;
+	return state;
+}
+
 void HostInputToggleMouseToJoystick() {
 	if (g_mouse.enabled) {
 		SetRelativeMouseMode(false);
@@ -467,16 +1029,19 @@ bool HostInputWaitEvent(SDL_Event* event, int max_wait_ms) {
 		timeout = PollMouse(SDL_GetTicks());
 	}

-	if (g_cursor_hide_at != 0) {
+	if (g_cursor_hide_at != 0 && !TouchPadModeActive()) {
 		const auto now_ms = SDL_GetTicks();
 		const int  cursor_timeout =
 		    now_ms < g_cursor_hide_at ? static_cast<int>(g_cursor_hide_at - now_ms) : 0;
 		timeout = timeout < 0 ? cursor_timeout : std::min(timeout, cursor_timeout);
 	}
+	if (const int touch_timeout = PollGamepadTouchPad(SDL_GetTicks()); touch_timeout >= 0) {
+		timeout = timeout < 0 ? touch_timeout : std::min(timeout, touch_timeout);
+	}
 	timeout              = timeout < 0 ? max_wait_ms : std::min(timeout, max_wait_ms);
 	const bool has_event = SDL_WaitEventTimeout(event, timeout);

-	if (Config::HideCursorEnabled()) {
+	if (Config::HideCursorEnabled() && !TouchPadModeActive()) {
 		const auto now_ms = SDL_GetTicks();
 		if (has_event && !g_mouse.enabled && IsCursorActivity(*event) &&
 		    SDL_GetWindowFromEvent(event) == g_mouse_window) {
@@ -8,10 +8,33 @@ union SDL_Event;

 namespace Libs::Graphics {

+struct HostInputTouchPadVisualState {
+	bool     enabled        = false;
+	bool     cursor_visible = true;
+	bool     drawing        = false;
+	bool     position_valid = false;
+	float    x              = 0.5f;
+	float    y              = 0.5f;
+	uint64_t revision       = 0;
+	uint64_t gesture        = 0;
+};
+
 void               HostInputInit(SDL_Window* window);
 void               HostInputShutdown();
 void               HostInputKey(int key_code, bool down);
 void               HostInputMouseButton(uint8_t mouse_button, bool down);
+void               HostInputMouseTouchPad(bool down, float x, float y);
+void               HostInputMouseMotion(float x, float y);
+void               HostInputPadButton(int id, int sdl_button, bool down);
+void               HostInputPadTrigger(int id, bool left, int value);
+void               HostInputDisconnectGamepad(int id);
+void               HostInputSetTouchPadMode(bool enabled);
+void               HostInputToggleTouchPadMode();
+void               HostInputToggleGamepadTouchPad(int id);
+[[nodiscard]] bool HostInputGamepadDrawButton(int id, bool down);
+[[nodiscard]] bool HostInputGamepadAxis(int id, bool horizontal, int value);
+void               HostInputDisconnectGamepadTouchPad(int id);
+[[nodiscard]] HostInputTouchPadVisualState GetHostInputTouchPadVisualState();
 void               HostInputToggleMouseToJoystick();
 [[nodiscard]] bool HostInputWaitEvent(SDL_Event* event, int max_wait_ms);

@@ -1,5 +1,6 @@
 #include "common/assert.h"
 #include "common/common.h"
+#include "common/debugCounters.h"
 #include "common/emulatorConfig.h"
 #include "common/logging/log.h"
 #include "common/profiler.h"
@@ -10,6 +11,7 @@
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/renderer/renderContext.h"
 #include "graphics/host_gpu/vulkanCommon.h"
+#include "graphics/presentation/performanceOverlay.h"
 #include "graphics/presentation/presenter.h"
 #include "graphics/presentation/systemOverlay.h"
 #include "graphics/presentation/videoOut.h"
@@ -266,7 +268,7 @@ public:
 	void                 Create();
 	void                 Recreate(bool surface_lost = false);
 	[[nodiscard]] bool   NeedsResize() const;
-	[[nodiscard]] Status AcquireNextImage();
+	[[nodiscard]] Status AcquireNextImage(CommandScheduler& scheduler);
 	[[nodiscard]] bool   PrepareSystemOverlay();
 	void     RecordPresentCommands(CommandBuffer& command, Presenter::Frame* source,
 	                               const Presenter::Layer& overlay, bool draw_system_overlay);
@@ -301,6 +303,7 @@ private:
 	std::vector<vk::Image>         m_images;
 	std::vector<vk::ImageView>     m_image_views;
 	std::vector<vk::Semaphore>     m_image_acquired;
+	std::vector<uint64_t>          m_image_acquired_ticks;
 	std::vector<vk::Semaphore>     m_render_complete;
 	std::unique_ptr<SystemOverlay> m_system_overlay;
 	vk::DescriptorSetLayout        m_overlay_descriptors = nullptr;
@@ -323,6 +326,7 @@ struct Presenter::Impl {
 	void RecoverSwapchain(Swapchain::Status status) {
 		LOGF("Recovering Vulkan swapchain%s\n",
 		     status == Swapchain::Status::SurfaceLost ? " and surface" : "");
+		Common::DebugCounters::Add(Common::DebugCounters::Counter::SwapchainRecreations);
 		swapchain.Recreate(status == Swapchain::Status::SurfaceLost);
 		frames.SetFormat(swapchain.Format());
 	}
@@ -501,6 +505,7 @@ void Swapchain::Create() {
 	vk::SemaphoreCreateInfo semaphore_info {};
 	semaphore_info.sType = vk::StructureType::eSemaphoreCreateInfo;
 	m_image_acquired.resize(m_images.size());
+	m_image_acquired_ticks.assign(m_images.size(), 0);
 	m_render_complete.resize(m_images.size());
 	for (size_t i = 0; i < m_images.size(); i++) {
 		RequireVulkanSuccess(
@@ -569,6 +574,7 @@ void Swapchain::Destroy() {
 	m_images.clear();
 	m_image_views.clear();
 	m_image_acquired.clear();
+	m_image_acquired_ticks.clear();
 	m_render_complete.clear();
 }

@@ -594,8 +600,11 @@ bool Swapchain::NeedsResize() const {
 	       m_window_extent.height != m_window.graphic_ctx.screen_height;
 }

-Swapchain::Status Swapchain::AcquireNextImage() {
+Swapchain::Status Swapchain::AcquireNextImage(CommandScheduler& scheduler) {
 	EXIT_IF(m_handle == nullptr || m_frame_index >= m_image_acquired.size());
+	// Repeated frames can wrap the semaphore ring without acquiring a new source frame.
+	// Wait for the submission that consumed this slot before signaling it again.
+	scheduler.Wait(m_image_acquired_ticks[m_frame_index]);
 	m_image_index     = static_cast<uint32_t>(-1);
 	const auto result = m_window.graphic_ctx.device.acquireNextImageKHR(
 	    m_handle, std::numeric_limits<uint64_t>::max(), m_image_acquired[m_frame_index], nullptr,
@@ -867,7 +876,9 @@ uint64_t Swapchain::Submit(CommandScheduler& scheduler) {
 	SubmitInfo submit;
 	submit.AddWait(m_image_acquired[m_frame_index], 1, vk::PipelineStageFlagBits::eTransfer);
 	submit.AddSignal(m_render_complete[m_image_index]);
-	return scheduler.Submit(submit);
+	const auto tick                       = scheduler.Submit(submit);
+	m_image_acquired_ticks[m_frame_index] = tick;
+	return tick;
 }

 Swapchain::Status Swapchain::Present() {
@@ -937,7 +948,6 @@ Presenter::Frame& Presenter::PrepareBlankFrame(uint32_t width, uint32_t height,
 	auto*             frame  = m_impl->frames.Acquire({width, height}, format);
 	frame->hdr   = false;
 	frame->blank = true;
-	Common::LockGuard render_lock(m_impl->renderer.GetMutex());
 	frame->Configure(m_impl->window.graphic_ctx, {width, height}, format);
 	vk::ClearColorValue clear {};
 	clear.float32[3] = opaque ? 1.0f : 0.0f;
@@ -945,6 +955,7 @@ Presenter::Frame& Presenter::PrepareBlankFrame(uint32_t width, uint32_t height,
 		EXIT_IF(producer->IsInvalid());
 		frame->Clear(*producer, clear);
 	} else {
+		Common::LockGuard lock(m_impl->present_mutex);
 		auto& command = m_impl->present_scheduler.BeginCommand();
 		frame->Clear(command, clear);
 		frame->present_tick = m_impl->present_scheduler.Submit();
@@ -1023,23 +1034,22 @@ void Presenter::Impl::Present() {
 		RecoverSwapchain(Swapchain::Status::Recreate);
 	}
 	for (uint32_t attempt = 0; attempt < 2; attempt++) {
-		auto status = swapchain.AcquireNextImage();
+		auto status = swapchain.AcquireNextImage(present_scheduler);
 		if (status != Swapchain::Status::Success) {
 			RecoverSwapchain(status);
 			continue;
 		}
-		{
-			Common::LockGuard render_lock(renderer.GetMutex());
-			auto&             command = present_scheduler.BeginCommand();
-			const bool        draw_system_overlay =
-			    overlay_visual.active && swapchain.PrepareSystemOverlay();
-			swapchain.RecordPresentCommands(command, layers[0].frame, layers[1],
-			                                draw_system_overlay);
-			const auto tick = swapchain.Submit(present_scheduler);
-			for (const auto& layer: layers) {
-				if (layer.frame != nullptr) {
-					layer.frame->present_tick = tick;
-				}
+		// present_mutex owns the prepared frames and this scheduler. Only queue submission
+		// is shared with rendering, and it has its own queue_mutex.
+		auto&      command = present_scheduler.BeginCommand();
+		const bool draw_system_overlay = (overlay_visual.active || PerformanceOverlayEnabled()) &&
+		                                 swapchain.PrepareSystemOverlay();
+		swapchain.RecordPresentCommands(command, layers[0].frame, layers[1],
+		                                draw_system_overlay);
+		const auto tick = swapchain.Submit(present_scheduler);
+		for (const auto& layer: layers) {
+			if (layer.frame != nullptr) {
+				layer.frame->present_tick = tick;
 			}
 		}
 		status = swapchain.Present();
@@ -1053,6 +1063,7 @@ void Presenter::Impl::Present() {
 		return;
 	}
 	LOGF("Vulkan presentation retry exhausted; dropping frame\n");
+	Common::DebugCounters::Add(Common::DebugCounters::Counter::DroppedPresents);
 }

 void Presenter::Discard(Frame& frame) {
@@ -63,6 +63,8 @@ vk::PhysicalDeviceVulkan12Features WindowContext::RequiredVulkan12Features() noe
 	features.shaderBufferInt64Atomics  = VK_TRUE;
 	features.storageBuffer8BitAccess   = VK_TRUE;
 	features.shaderSampledImageArrayNonUniformIndexing = VK_TRUE;
+	features.shaderStorageImageArrayNonUniformIndexing = VK_TRUE;
+	features.shaderStorageBufferArrayNonUniformIndexing = VK_TRUE;
 	return features;
 }

@@ -215,6 +217,7 @@ static void VulkanFindPhysicalDevice(vk::Instance instance, vk::SurfaceKHR surfa

 		vk::PhysicalDeviceVulkan12Features features12 {};
 		vk::PhysicalDeviceVulkan11Features features11 {};
+		vk::PhysicalDeviceRobustness2FeaturesEXT robustness2 {};
 #if defined(__APPLE__)
 		features12.pNext = &depth_clip_control;
 #else
@@ -222,7 +225,8 @@ static void VulkanFindPhysicalDevice(vk::Instance instance, vk::SurfaceKHR surfa
 		fragment_barycentric.pNext = &depth_clip_control;
 		features12.pNext           = &fragment_barycentric;
 #endif
-		features11.pNext       = features12.pNext;
+		robustness2.pNext      = features12.pNext;
+		features11.pNext       = &robustness2;
 		features12.pNext       = &features11;
 		features13.pNext       = &features12;
 		device_features2.pNext = &features13;
@@ -262,7 +266,6 @@ static void VulkanFindPhysicalDevice(vk::Instance instance, vk::SurfaceKHR surfa
 #endif
 #if !defined(__APPLE__)
 		check_feature(device_features2.features.depthClamp, "depthClamp");
-		check_feature(fragment_barycentric.fragmentShaderBarycentric, "fragmentShaderBarycentric");
 #endif

 		check_feature(features12.samplerMirrorClampToEdge, "samplerMirrorClampToEdge",
@@ -284,7 +287,14 @@ static void VulkanFindPhysicalDevice(vk::Instance instance, vk::SurfaceKHR surfa
 		check_feature(features12.shaderSampledImageArrayNonUniformIndexing,
 		              "shaderSampledImageArrayNonUniformIndexing",
 		              required_features12.shaderSampledImageArrayNonUniformIndexing);
+		check_feature(features12.shaderStorageImageArrayNonUniformIndexing,
+		              "shaderStorageImageArrayNonUniformIndexing",
+		              required_features12.shaderStorageImageArrayNonUniformIndexing);
+		check_feature(features12.shaderStorageBufferArrayNonUniformIndexing,
+		              "shaderStorageBufferArrayNonUniformIndexing",
+		              required_features12.shaderStorageBufferArrayNonUniformIndexing);
 		check_feature(features13.robustImageAccess, "robustImageAccess");
+		check_feature(robustness2.nullDescriptor, "nullDescriptor");
 		check_feature(features13.dynamicRendering, "dynamicRendering",
 		              required_features13.dynamicRendering);
 		check_feature(features13.synchronization2, "synchronization2",
@@ -446,14 +456,9 @@ static vk::Device VulkanCreateDevice(GraphicContext& graphics,
 	vk::PhysicalDeviceVulkan13Features supported_features13 {};
 	supported_features13.pNext = &supported_features12;

-	const auto robustness2_ext_enabled =
-	    HasExtension(device_extensions, VK_EXT_ROBUSTNESS_2_EXTENSION_NAME);
-
 	vk::PhysicalDeviceRobustness2FeaturesEXT supported_robustness2 {};
-	if (robustness2_ext_enabled) {
-		supported_robustness2.pNext = supported_features13.pNext;
-		supported_features13.pNext = &supported_robustness2;
-	}
+	supported_robustness2.pNext = supported_features13.pNext;
+	supported_features13.pNext = &supported_robustness2;

 	const bool mesh_extension = HasExtension(device_extensions, VK_EXT_MESH_SHADER_EXTENSION_NAME);
 	vk::PhysicalDeviceMeshShaderFeaturesEXT supported_mesh {};
@@ -492,7 +497,21 @@ static vk::Device VulkanCreateDevice(GraphicContext& graphics,
 		image_atomic_int64.pNext = supported_features2.pNext;
 		supported_features2.pNext = &image_atomic_int64;
 	}
+	const bool barycentric_extension =
+	    HasExtension(device_extensions, VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME);
+	vk::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR supported_barycentric {};
+	if (barycentric_extension) {
+		supported_barycentric.pNext = supported_features2.pNext;
+		supported_features2.pNext   = &supported_barycentric;
+	}
 	physical_device.getFeatures2(&supported_features2);
+	const bool barycentric_supported =
+	    barycentric_extension && supported_barycentric.fragmentShaderBarycentric == VK_TRUE;
+	if (!barycentric_supported) {
+		Log::WriteToConsoleAndLog(
+		    "WARNING: Your GPU is not fully supported (fragmentShaderBarycentric is unavailable). "
+		    "Some games may render incorrectly or crash.\n");
+	}
 	graphics.shader_image_int64_atomics_enabled = image_atomic_int64.shaderImageInt64Atomics;

 	auto features12 = WindowContext::RequiredVulkan12Features();
@@ -529,6 +548,7 @@ static vk::Device VulkanCreateDevice(GraphicContext& graphics,
 		subgroup_size_control.pNext = &graphics.mesh_shader_properties;
 	}
 	physical_device.getProperties2(&properties2);
+	EXIT_NOT_IMPLEMENTED(!(properties11.subgroupSupportedOperations & vk::SubgroupFeatureFlagBits::eVote));

 	graphics.subgroup_size                 = properties11.subgroupSize;
 	graphics.min_subgroup_size             = subgroup_size_control.minSubgroupSize;
@@ -549,9 +569,9 @@ static vk::Device VulkanCreateDevice(GraphicContext& graphics,
 	graphics.attachment_feedback_loop_enabled =
 	    feedback_extensions && feedback_layout.attachmentFeedbackLoopLayout &&
 	    feedback_dynamic.attachmentFeedbackLoopDynamicState;
-	graphics.depth_color_copy_enabled = maintenance8_extension && maintenance8.maintenance8;
-	LOGF("Vulkan depth/color copy support: %s\n",
-	     graphics.depth_color_copy_enabled ? "true" : "false");
+	graphics.maintenance8_enabled = maintenance8_extension && maintenance8.maintenance8;
+	LOGF("Vulkan maintenance8 support: %s\n",
+	     graphics.maintenance8_enabled ? "true" : "false");
 	LOGF("Vulkan depth feedback support: %s\n",
 	     graphics.attachment_feedback_loop_enabled ? "true" : "false");
 	if (graphics.mesh_shader_enabled) {
@@ -603,31 +623,27 @@ static vk::Device VulkanCreateDevice(GraphicContext& graphics,
 	robustness2.pNext = &features12;
 #else
 	vk::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR fragment_barycentric {};
-	fragment_barycentric.pNext                     = &features12;
-	fragment_barycentric.fragmentShaderBarycentric = VK_TRUE;
-	robustness2.pNext                              = &fragment_barycentric;
-#endif
-	if (robustness2_ext_enabled) {
-		robustness2.robustBufferAccess2 = supported_robustness2.robustBufferAccess2;
-		robustness2.robustImageAccess2  = supported_robustness2.robustImageAccess2;
-		robustness2.nullDescriptor      = supported_robustness2.nullDescriptor;
+	if (barycentric_supported) {
+		fragment_barycentric.pNext                     = &features12;
+		fragment_barycentric.fragmentShaderBarycentric = VK_TRUE;
+		robustness2.pNext                              = &fragment_barycentric;
+	} else {
+		robustness2.pNext = &features12;
 	}
+#endif
+	robustness2.robustBufferAccess2 = supported_robustness2.robustBufferAccess2;
+	robustness2.robustImageAccess2  = supported_robustness2.robustImageAccess2;
+	robustness2.nullDescriptor      = VK_TRUE;

 	auto features13 = WindowContext::RequiredVulkan13Features();
-#if defined(__APPLE__)
-	features13.pNext = robustness2_ext_enabled ? static_cast<void*>(&robustness2)
-	                                           : static_cast<void*>(&features12);
-#else
-	features13.pNext = robustness2_ext_enabled ? static_cast<void*>(&robustness2)
-	                                           : static_cast<void*>(&fragment_barycentric);
-#endif
+	features13.pNext = &robustness2;
 	features13.robustImageAccess   = supported_features13.robustImageAccess;
 	features13.subgroupSizeControl =
 	    graphics.compute_subgroup_size_control_enabled ? VK_TRUE : VK_FALSE;

 	LOGF("Vulkan robustness: robustImageAccess=%s robustImageAccess2=%s\n",
 	     features13.robustImageAccess == VK_TRUE ? "true" : "false",
-	     robustness2_ext_enabled && robustness2.robustImageAccess2 == VK_TRUE ? "true" : "false");
+	     robustness2.robustImageAccess2 == VK_TRUE ? "true" : "false");

 	vk::DeviceCreateInfo create_info {};
 	vk::PhysicalDeviceMeshShaderFeaturesEXT mesh_features {};
@@ -648,7 +664,7 @@ static vk::Device VulkanCreateDevice(GraphicContext& graphics,
 		image_atomic_int64.sparseImageInt64Atomics = VK_FALSE;
 		create_info.pNext = &image_atomic_int64;
 	}
-	if (graphics.depth_color_copy_enabled) {
+	if (graphics.maintenance8_enabled) {
 		maintenance8.pNext = const_cast<void*>(create_info.pNext);
 		create_info.pNext = &maintenance8;
 	}
@@ -957,7 +973,7 @@ void WindowContext::CreateVulkan() {
 	std::vector<const char*> device_extensions = {
 	    VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME,
 	    VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME,
-	    "VK_KHR_maintenance1"};
+	    VK_EXT_ROBUSTNESS_2_EXTENSION_NAME, "VK_KHR_maintenance1"};

 #if defined(__APPLE__)
 	// MoltenVK lacks VK_EXT_depth_clip_enable and VK_EXT_color_write_enable; the renderer
@@ -967,7 +983,6 @@ void WindowContext::CreateVulkan() {
 #else
 	device_extensions.push_back(VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME);
 	device_extensions.push_back(VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME);
-	device_extensions.push_back(VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME);
 #endif

 #ifdef KYTY_ENABLE_DEBUG_PRINTF
@@ -1020,13 +1035,13 @@ void WindowContext::CreateVulkan() {
 			device_extensions.push_back(VK_EXT_MEMORY_BUDGET_EXTENSION_NAME);
 			graphic_ctx.memory_budget_ext_enabled = true;
 		}
-		for (const auto* extension: {VK_EXT_ROBUSTNESS_2_EXTENSION_NAME,
-		                             VK_KHR_MAINTENANCE_8_EXTENSION_NAME,
+		for (const auto* extension: {VK_KHR_MAINTENANCE_8_EXTENSION_NAME,
 		                             VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME,
 		                             VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME,
 		                             VK_EXT_MESH_SHADER_EXTENSION_NAME,
 		                             VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME,
-		                             VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME}) {
+		                             VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME,
+		                             VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME}) {
 			if (HasExtension(available_extensions, extension)) {
 				device_extensions.push_back(extension);
 			}
@@ -1,6 +1,4 @@
-#include "graphics/presentation/window.h"
-
-#include <SDL3/SDL.h>
+#include "graphics/presentation/window.h"

 #include "common/assert.h"
 #include "common/common.h"
@@ -8,14 +6,15 @@
 #include "common/file.h"
 #include "common/logging/log.h"
 #include "common/profiler.h"
+#include "common/stringUtils.h"
 #include "common/systemInfo.h"
 #include "common/threads.h"
 #include "common/timer.h"
-#include "common/stringUtils.h"
 #include "graphics/host_gpu/graphicContext.h"
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/renderer/renderContext.h"
 #include "graphics/host_gpu/vulkanCommon.h"
+#include "graphics/presentation/performanceOverlay.h"
 #include "graphics/presentation/renderDoc.h"
 #include "graphics/presentation/systemOverlay.h"
 #include "graphics/presentation/window/hostInput.h"
@@ -24,13 +23,14 @@
 #include "libs/controller.h"
 #include "loader/systemContent.h"

+#include <SDL3/SDL.h>
 #include <cstdlib>
+#include <filesystem>
 #include <fmt/format.h>
 #include <memory>
 #include <string>
 #include <vector>
 #include <vulkan/vk_platform.h>
-#include <filesystem>

 #define STB_IMAGE_IMPLEMENTATION
 #define STBI_NO_SIMD
@@ -54,25 +54,6 @@ struct EventKeyboard {
 	double   timestamp_seconds;
 };

-static uint32_t ControllerButtonToPadButton(int button) {
-	switch (button) {
-		case SDL_GAMEPAD_BUTTON_SOUTH: return Controller::PAD_BUTTON_CROSS;
-		case SDL_GAMEPAD_BUTTON_EAST: return Controller::PAD_BUTTON_CIRCLE;
-		case SDL_GAMEPAD_BUTTON_WEST: return Controller::PAD_BUTTON_SQUARE;
-		case SDL_GAMEPAD_BUTTON_NORTH: return Controller::PAD_BUTTON_TRIANGLE;
-		case SDL_GAMEPAD_BUTTON_START: return Controller::PAD_BUTTON_OPTIONS;
-		case SDL_GAMEPAD_BUTTON_LEFT_STICK: return Controller::PAD_BUTTON_L3;
-		case SDL_GAMEPAD_BUTTON_RIGHT_STICK: return Controller::PAD_BUTTON_R3;
-		case SDL_GAMEPAD_BUTTON_LEFT_SHOULDER: return Controller::PAD_BUTTON_L1;
-		case SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER: return Controller::PAD_BUTTON_R1;
-		case SDL_GAMEPAD_BUTTON_DPAD_UP: return Controller::PAD_BUTTON_UP;
-		case SDL_GAMEPAD_BUTTON_DPAD_DOWN: return Controller::PAD_BUTTON_DOWN;
-		case SDL_GAMEPAD_BUTTON_DPAD_LEFT: return Controller::PAD_BUTTON_LEFT;
-		case SDL_GAMEPAD_BUTTON_DPAD_RIGHT: return Controller::PAD_BUTTON_RIGHT;
-		case SDL_GAMEPAD_BUTTON_TOUCHPAD: return Controller::PAD_BUTTON_TOUCH_PAD;
-		default: return 0;
-	}
-}

 static Controller::Axis ControllerAxisFromSdl(int axis_id) {
 	switch (axis_id) {
@@ -268,6 +249,15 @@ static void GameEventMouse([[maybe_unused]] const EventMouse& mb) {
 		}

 		HostInputMouseButton(mouse_button, mb.down);
+		if (!mb.touch && mb.left) {
+			HostInputMouseTouchPad(mb.down, static_cast<float>(mb.x), static_cast<float>(mb.y));
+		}
+	} else if (mb.motion && !mb.touch) {
+		if (mb.left) {
+			HostInputMouseTouchPad(true, static_cast<float>(mb.x), static_cast<float>(mb.y));
+		} else {
+			HostInputMouseMotion(static_cast<float>(mb.x), static_cast<float>(mb.y));
+		}
 	}
 }

@@ -316,6 +306,7 @@ static void GameEventController([[maybe_unused]] const EventController& f) {
 	}

 	if (f.removed) {
+		HostInputDisconnectGamepad(f.id);
 		if (auto* pad = SDL_GetGamepadFromID(f.id); pad != nullptr) {
 			Controller::Disconnect(f.id);
 			SDL_CloseGamepad(pad);
@@ -323,30 +314,22 @@ static void GameEventController([[maybe_unused]] const EventController& f) {
 	}

 	if (f.down || f.up) {
-		const auto button = ControllerButtonToPadButton(f.button);
-		if (button != 0) {
-			Controller::SetButton(f.id, button, f.down);
-		} else if (f.button == SDL_GAMEPAD_BUTTON_BACK) {
-			// Pads without a touchpad (Switch, Xbox, ...) have no way to click it, which
-			// blocks games that require it. Use their Back/Select button as a centered click.
-			auto* pad = SDL_GetGamepadFromID(f.id);
-			if (pad != nullptr && SDL_GetNumGamepadTouchpads(pad) == 0) {
-				if (f.down) {
-					Controller::SetTouchPad(f.id, 0, true, 0.5f, 0.5f);
-				}
-				Controller::SetButton(f.id, Controller::PAD_BUTTON_TOUCH_PAD, f.down);
-				if (f.up) {
-					Controller::SetTouchPad(f.id, 0, false, 0.5f, 0.5f);
-				}
-			}
-		}
+		HostInputPadButton(f.id, f.button, f.down);
 	}

 	if (f.axis) {
-		const auto axis = ControllerAxisFromSdl(f.axis_id);
-		if (axis != Controller::Axis::AxisMax) {
-			Controller::SetAxis(f.id, axis,
+		if (f.axis_id == SDL_GAMEPAD_AXIS_LEFT_TRIGGER ||
+		    f.axis_id == SDL_GAMEPAD_AXIS_RIGHT_TRIGGER) {
+			HostInputPadTrigger(f.id, f.axis_id == SDL_GAMEPAD_AXIS_LEFT_TRIGGER,
 			                    ControllerAxisValueFromSdl(f.axis_id, f.axis_value));
+		} else if (const auto axis = ControllerAxisFromSdl(f.axis_id);
+		           axis != Controller::Axis::AxisMax) {
+			const int value = ControllerAxisValueFromSdl(f.axis_id, f.axis_value);
+			if ((f.axis_id == SDL_GAMEPAD_AXIS_LEFTX || f.axis_id == SDL_GAMEPAD_AXIS_LEFTY) &&
+			    HostInputGamepadAxis(f.id, f.axis_id == SDL_GAMEPAD_AXIS_LEFTX, value)) {
+				return;
+			}
+			Controller::SetAxis(f.id, axis, value);
 		}
 	}
 }
@@ -431,6 +414,7 @@ void WindowContext::ProcessWindowEvent(const SDL_WindowEvent& event) {
 			break;
 		case SDL_EVENT_WINDOW_MOUSE_LEAVE:
 			LOGF("Mouse left window %" PRIu32 "\n", window_event.windowID);
+			HostInputSetTouchPadMode(false);
 			break;
 		case SDL_EVENT_WINDOW_FOCUS_GAINED:
 			LOGF("Window %" PRIu32 " gained keyboard focus\n", window_event.windowID);
@@ -475,12 +459,37 @@ void WindowContext::ProcessDisplayEvent(const SDL_DisplayEvent& display) {
 void WindowContext::ProcessEvent(double time_s) {
 	auto& game  = loop;
 	auto* event = &game.event;
-	if ((event->type == SDL_EVENT_KEY_DOWN || event->type == SDL_EVENT_KEY_UP) &&
-	    event->key.key == SDLK_F7) {
-		if (event->type == SDL_EVENT_KEY_DOWN && event->key.repeat == 0) {
-			HostInputToggleMouseToJoystick();
+	if (event->type == SDL_EVENT_KEY_DOWN || event->type == SDL_EVENT_KEY_UP) {
+		const bool pressed = event->type == SDL_EVENT_KEY_DOWN && event->key.repeat == 0;
+		switch (event->key.key) {
+			case SDLK_F7:
+				if (pressed) {
+					HostInputToggleMouseToJoystick();
+				}
+				return;
+			case SDLK_F8:
+				if (pressed) {
+					Controller::CycleKeyboardPlayer();
+				}
+				return;
+#if defined(__APPLE__)
+			case SDLK_P:
+				if ((event->key.mod & SDL_KMOD_GUI) == 0) {
+					break;
+				}
+				[[fallthrough]];
+#endif
+			case SDLK_F2:
+				if (pressed) {
+					if ((event->key.mod & SDL_KMOD_SHIFT) != 0) {
+						TogglePerformanceOverlayDetails();
+					} else {
+						TogglePerformanceOverlay();
+					}
+				}
+				return;
+			default: break;
 		}
-		return;
 	}
 	if (ProcessSystemOverlayInput(*event)) {
 		return;
--- a/Show More
+++ b/Show More