guest_gpu: fix private AGC shader register regression

2026-10-21 19:36:55 +02:00 · 2026-09-01 04:08:41 +04:00
511 changed files with 41026 additions and 120864 deletions
@@ -1,37 +0,0 @@
-# yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json
-
-# Keep inherited review profiles, automatic reviews, tools, and pre-merge checks.
-inheritance: true
-
-reviews:
-  # Trim supplemental output and keep the remaining walkthrough collapsed.
-  high_level_summary: false
-  review_status: false
-  review_details: false
-  collapse_walkthrough: true
-  changed_files_summary: false
-  sequence_diagrams: false
-  estimate_code_review_effort: false
-  related_issues: false
-  related_prs: false
-  in_progress_fortune: false
-  poem: false
-  enable_prompt_for_ai_agents: false
-
-  # Hide standard finishing-touch controls; this also disables their commands.
-  finishing_touches:
-    docstrings:
-      enabled: false
-    unit_tests:
-      enabled: false
-    simplify:
-      enabled: false
-    autofix:
-      enabled: false
-    fix_ci:
-      enabled: false
-    resolve_merge_conflict:
-      enabled: false
-
-chat:
-  art: false
@@ -6,12 +6,7 @@ on:
    branches: [ main, master ]
  pull_request:

-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
 env:
-  SCCACHE_GHA_ENABLED: "true"
  KYTY_BUILD_ORIGIN: ${{ github.repository != 'KytyPS5/KytyPS5' && 'Fork' || github.event_name == 'push' && 'Official' || 'Source' }}
  KYTY_BUILD_REPOSITORY: ${{ github.repository }}

@@ -43,6 +38,9 @@ jobs:
      - name: Setup Visual Studio environment
        uses: ilammy/msvc-dev-cmd@v1

+      - name: Setup Ninja
+        uses: seanmiddleditch/gha-setup-ninja@v5
+
      - name: Locate vcpkg
        id: vcpkg
        shell: pwsh
@@ -80,9 +78,6 @@ jobs:
          arch: win64_msvc2022_64
          cache: true

-      - name: Setup sccache
-        uses: mozilla-actions/sccache-action@v0.0.11
-
      - name: Verify toolchain
        shell: cmd
        run: |
@@ -105,23 +100,17 @@ jobs:
            -DKYTY_RELEASE_TAG=${{ needs.metadata.outputs.release_tag }} ^
            -DCMAKE_C_COMPILER=clang-cl ^
            -DCMAKE_CXX_COMPILER=clang-cl ^
-            -DCMAKE_C_COMPILER_LAUNCHER=sccache ^
-            -DCMAKE_CXX_COMPILER_LAUNCHER=sccache ^
            -DCMAKE_PREFIX_PATH="%Qt6_DIR%"

      - name: Build
        shell: cmd
        run: |
-          cmake --build _Build/windows --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 ^
-            shader_recompiler_compute_tests ^
-            resource_tracking_tests scalar_provenance_tests ^
-            resource_materialization_tests shader_vertex_metadata_tests archive_file_tests avplayer_file_tests --parallel
+          cmake --build _Build/windows --target launcher audio_out2_port_tests ime_dialog_tests virtual_memory_allocation_tests --parallel

      - name: Test
        shell: cmd
        run: |
-          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)$"
+          ctest --test-dir _Build/windows --output-on-failure -R "^(audio_out2_port|ime_dialog|virtual_memory_allocation)$"

      - name: Install
        shell: cmd
@@ -156,7 +145,7 @@ jobs:

      - name: Install build dependencies
        shell: bash
-        run: brew install glslang
+        run: brew install glslang ninja

      - name: Install Qt 6.10.3
        uses: jurplel/install-qt-action@v4
@@ -167,9 +156,6 @@ jobs:
          arch: clang_64
          cache: true

-      - name: Setup sccache
-        uses: mozilla-actions/sccache-action@v0.0.11
-
      - name: Verify toolchain
        shell: bash
        run: |
@@ -194,25 +180,20 @@ jobs:
            -DCMAKE_OSX_ARCHITECTURES=x86_64 \
            -DCMAKE_C_COMPILER=clang \
            -DCMAKE_CXX_COMPILER=clang++ \
-            -DCMAKE_C_COMPILER_LAUNCHER=sccache \
-            -DCMAKE_CXX_COMPILER_LAUNCHER=sccache \
            -DCMAKE_PREFIX_PATH="$QT_ROOT_DIR"

      - name: Build
        shell: bash
        run: |
          cmake --build _Build/macos \
-            --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 \
+            --target launcher audio_out2_port_tests ime_dialog_tests virtual_memory_allocation_tests \
            --parallel

      - name: Test
        shell: bash
        run: |
          ctest --test-dir _Build/macos --output-on-failure \
-            -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)$'
+            -R '^(audio_out2_port|ime_dialog|virtual_memory_allocation)$'

      - name: Install
        shell: bash
@@ -257,7 +238,6 @@ jobs:
            "$install_dir/libMoltenVK.dylib" \
            "$app_dir/Contents/MacOS/KytyPS5" \
            "$app_dir/Contents/MacOS/kyty_emulator" \
-            "$app_dir/Contents/MacOS/kyty_updater" \
            "$app_dir/Contents/Frameworks/libMoltenVK.dylib"; do
            file "$binary"
            lipo "$binary" -verify_arch x86_64
@@ -267,7 +247,6 @@ jobs:
            "$install_dir/libMoltenVK.dylib" \
            "$app_dir/Contents/MacOS/KytyPS5" \
            "$app_dir/Contents/MacOS/kyty_emulator" \
-            "$app_dir/Contents/MacOS/kyty_updater" \
            "$app_dir/Contents/Frameworks/libMoltenVK.dylib"; do
            codesign --verify --strict "$binary"
          done
@@ -323,9 +302,8 @@ jobs:
            libxkbcommon-dev \
            libxrandr-dev \
            libxss-dev \
-            libxtst-dev \
            lld \
-            pkg-config \
+            ninja-build \
            wayland-protocols

      - name: Install Qt 6.10.3
@@ -337,9 +315,6 @@ jobs:
          arch: linux_gcc_64
          cache: true

-      - name: Setup sccache
-        uses: mozilla-actions/sccache-action@v0.0.11
-
      - name: Verify toolchain
        shell: bash
        run: |
@@ -364,12 +339,10 @@ jobs:
            -DKYTY_RELEASE_TAG="${{ needs.metadata.outputs.release_tag }}" \
            -DCMAKE_C_COMPILER=clang \
            -DCMAKE_CXX_COMPILER=clang++ \
-            -DCMAKE_C_COMPILER_LAUNCHER=sccache \
-            -DCMAKE_CXX_COMPILER_LAUNCHER=sccache \
            -DCMAKE_PREFIX_PATH="$Qt6_DIR" 2>&1 | tee _Build/configure.log
          exit "${PIPESTATUS[0]}"

-      - name: Verify SDL3 backends
+      - name: Verify SDL2 backends
        shell: bash
        run: |
          status=0
@@ -388,16 +361,14 @@ jobs:
        run: |
          cmake --build _Build/linux \
            --target launcher page_manager_tests memory_tracker_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 \
+              audio_out2_port_tests ime_dialog_tests virtual_memory_allocation_tests \
            --parallel

      - name: Test
        shell: bash
        run: |
          ctest --test-dir _Build/linux --output-on-failure \
-            -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)$'
+            -R '^(audio_out2_port|ime_dialog|page_manager|memory_tracker|virtual_memory_allocation)$'

      - name: Install
        shell: bash
@@ -407,12 +378,11 @@ jobs:
      - name: Verify artifacts
        shell: bash
        run: |
-          file _Build/linux/install/kyty_launcher
+          file _Build/linux/install/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/kyty_launcher | grep -q 'RPATH.*\$ORIGIN/lib'
+          readelf -d _Build/linux/install/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 +391,8 @@ jobs:
                sed -n 's/.*Shared library: \[\(libQt6[^]]*\|libicu[^]]*\)\].*/\1/p'
            )
          done < <(
-            find _Build/linux/install/kyty_launcher _Build/linux/install/plugins \
-              -type f \( -name kyty_launcher -o -name '*.so' \) -print0
+            find _Build/linux/install/launcher _Build/linux/install/plugins \
+              -type f \( -name launcher -o -name '*.so' \) -print0
          )
          _Build/linux/install/kyty_emulator --help > /dev/null

@@ -497,9 +467,8 @@ jobs:
          linux_dir="artifacts/KytyPS5-Linux-x86_64"
          test -d "$linux_dir"
          chmod a+x \
-            "$linux_dir/kyty_launcher" \
-            "$linux_dir/kyty_emulator" \
-            "$linux_dir/kyty_updater"
+            "$linux_dir/launcher" \
+            "$linux_dir/kyty_emulator"
          tar -C "$linux_dir" -czf \
            "$GITHUB_WORKSPACE/$RELEASE_NAME-Linux-x86_64.tar.gz" .

@@ -1,7 +1,7 @@
-[submodule "3rdparty/SDL3"]
-	path = 3rdparty/SDL3
+[submodule "3rdparty/SDL2"]
+	path = 3rdparty/SDL2
 	url = https://github.com/libsdl-org/SDL.git
-	branch = release-3.4.x
+	branch = SDL2
 [submodule "3rdparty/magic_enum"]
 	path = 3rdparty/magic_enum
 	url = https://github.com/Neargye/magic_enum.git
@@ -22,7 +22,7 @@
 	url = https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.git
 [submodule "3rdparty/ffmpeg-core"]
 	path = 3rdparty/ffmpeg-core
-	url = https://github.com/KytyPS5/ext-ffmpeg-core.git
+	url = https://github.com/shadps4-emu/ext-ffmpeg-core.git
 	shallow = true
 [submodule "3rdparty/fmt"]
 	path = 3rdparty/fmt
@@ -5,7 +5,7 @@
            "name": "Debug launcher UI",
            "type": "cppvsdbg",
            "request": "launch",
-            "program": "${workspaceFolder}\\_Build\\vscode-clang\\launcher\\kyty_launcher.exe",
+            "program": "${workspaceFolder}\\_Build\\vscode-clang\\launcher\\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/kyty_launcher",
+                "program": "${workspaceFolder}/_Build/vscode-clang/launcher/launcher",
                "cwd": "${workspaceFolder}/_Build/vscode-clang/launcher",
                "MIMode": "gdb",
                "miDebuggerPath": "/usr/bin/gdb"
@@ -2,17 +2,15 @@
    "cmake.sourceDirectory": "${workspaceFolder}",
    "cmake.buildDirectory": "${workspaceFolder}/_Build/vscode-clang",
    "cmake.generator": "Ninja",
-    "cmake.useVsDeveloperEnvironment": "always",
    "cmake.environment": {
        "CC": "clang-cl",
-        "CXX": "clang-cl"
+        "CXX": "clang-cl",
+        "PATH": "${env:ProgramFiles}/Microsoft Visual Studio/18/Community/VC/Tools/Llvm/x64/bin;${env:ProgramFiles}/Microsoft Visual Studio/18/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/Ninja;${env:PATH}"
    },
    "cmake.configureSettings": {
        "CMAKE_C_COMPILER": "clang-cl",
        "CMAKE_CXX_COMPILER": "clang-cl",
        "CMAKE_PREFIX_PATH": "C:/Qt/6.11.0/msvc2022_64"
-    },
-    "C_Cpp.default.intelliSenseMode": "windows-clang-x64",
-    "C_Cpp.default.compileCommands": "${workspaceFolder}/_Build/vscode-clang/compile_commands.json",
-    "C_Cpp.default.cppStandard": "c++20"
+    }
 }
+
@@ -2,31 +2,10 @@ set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)

 add_subdirectory(cpuinfo)

+# The Windows guest red-zone patcher needs a decoder/encoder and a small
+# trampoline assembler. Pin the same revisions used by shadPS4's implementation.
 include(FetchContent)

-# The Bluetooth DualSense transports speaker audio as fixed-size Opus packets.
-set(kyty_build_testing_saved "${BUILD_TESTING}")
-set(BUILD_TESTING OFF)
-set(OPUS_BUILD_PROGRAMS OFF CACHE BOOL "" FORCE)
-set(OPUS_INSTALL_PKG_CONFIG_MODULE OFF CACHE BOOL "" FORCE)
-set(OPUS_INSTALL_CMAKE_CONFIG_MODULE OFF CACHE BOOL "" FORCE)
-if(MSVC AND CMAKE_C_COMPILER_ID STREQUAL "Clang")
-	# Opus assumes MSVC accepts SSE4.1 intrinsics without per-file flags, but
-	# clang-cl rejects them in its baseline x64 files. Its AVX2 dispatch also
-	# depends on the SSE4.1 declarations, so retain the x64 SSE2 baseline only.
-	set(OPUS_X86_MAY_HAVE_SSE4_1 OFF CACHE BOOL "" FORCE)
-	set(OPUS_X86_MAY_HAVE_AVX2 OFF CACHE BOOL "" FORCE)
-endif()
-FetchContent_Declare(opus
-	GIT_REPOSITORY https://github.com/xiph/opus.git
-	GIT_TAG ddbe48383984d56acd9e1ab6a090c54ca6b735a6
-	GIT_SHALLOW FALSE)
-FetchContent_MakeAvailable(opus)
-set(BUILD_TESTING "${kyty_build_testing_saved}")
-install(FILES "${opus_SOURCE_DIR}/COPYING" DESTINATION "licenses/opus")
-
-# The guest instruction patcher needs a decoder/encoder and a small
-# trampoline assembler. Pin the same revisions used by shadPS4's implementation.
 set(XBYAK_BUILD_TESTS OFF CACHE BOOL "" FORCE)
 FetchContent_Declare(
 	xbyak
@@ -48,57 +27,9 @@ FetchContent_Declare(
 )

 FetchContent_MakeAvailable(xbyak zydis)
-target_compile_definitions(xbyak INTERFACE XBYAK_NO_EXCEPTION)
-
-# ZArchive provides random-access reads for compressed game dumps. Build only
-# the reader/writer library and its zstd dependency; the command-line tool is
-# not part of KytyPS5's runtime distribution.
-set(ZSTD_BUILD_PROGRAMS OFF CACHE BOOL "" FORCE)
-set(ZSTD_BUILD_SHARED OFF CACHE BOOL "" FORCE)
-set(ZSTD_BUILD_STATIC ON CACHE BOOL "" FORCE)
-set(ZSTD_BUILD_TESTS OFF CACHE BOOL "" FORCE)
-set(ZSTD_LEGACY_SUPPORT OFF CACHE BOOL "" FORCE)
-set(ZSTD_MULTITHREAD_SUPPORT OFF CACHE BOOL "" FORCE)
-FetchContent_Declare(
-	zstd
-	GIT_REPOSITORY https://github.com/facebook/zstd.git
-	GIT_TAG f8745da6ff1ad1e7bab384bd1f9d742439278e99
-	GIT_SHALLOW FALSE
-	SOURCE_SUBDIR build/cmake
-)
-FetchContent_Declare(
-	zarchive_source
-	GIT_REPOSITORY https://github.com/Exzap/ZArchive.git
-	GIT_TAG d2c717730092c7bf8cbb033b12fd4001b7c4d932
-	GIT_SHALLOW FALSE
-	PATCH_COMMAND "${GIT_EXECUTABLE}" apply --ignore-whitespace
-		"${CMAKE_CURRENT_SOURCE_DIR}/patches/zarchive-reader.patch"
-	SOURCE_SUBDIR kyty-library-only
-)
-FetchContent_MakeAvailable(zstd zarchive_source)
-
-add_library(zarchive STATIC
-	"${zarchive_source_SOURCE_DIR}/src/zarchivereader.cpp"
-	"${zarchive_source_SOURCE_DIR}/src/zarchivewriter.cpp"
-	"${zarchive_source_SOURCE_DIR}/src/sha_256.c"
-)
-add_library(ZArchive::zarchive ALIAS zarchive)
-target_include_directories(zarchive SYSTEM PUBLIC "${zarchive_source_SOURCE_DIR}/include")
-target_include_directories(zarchive PRIVATE "${zstd_SOURCE_DIR}/lib")
-target_link_libraries(zarchive PRIVATE libzstd_static)
-target_compile_features(zarchive PRIVATE cxx_std_20)
-if(MSVC)
-	target_compile_options(zarchive PRIVATE /W0)
-else()
-	target_compile_options(zarchive PRIVATE -w)
-endif()

 set(SDL_SHARED OFF CACHE BOOL "" FORCE)
-if(APPLE)
-	# SDL's built-in iconv fallback does not support CP932.
-	set(SDL_SYSTEM_ICONV ON CACHE BOOL "Use system iconv for CP932 conversion" FORCE)
-endif()
-add_subdirectory(SDL3)
+add_subdirectory(SDL2)

 add_library(Vulkan-Headers INTERFACE)
 add_library(Vulkan::Headers ALIAS Vulkan-Headers)
@@ -155,9 +86,6 @@ set(SPDLOG_BUILD_WARNINGS OFF CACHE BOOL "" FORCE)
 set(SPDLOG_INSTALL OFF CACHE BOOL "" FORCE)
 set(SPDLOG_FMT_EXTERNAL ON CACHE BOOL "" FORCE)
 set(SPDLOG_NO_EXCEPTIONS ON CACHE BOOL "" FORCE)
-if(WIN32)
-	set(SPDLOG_WCHAR_FILENAMES ON CACHE BOOL "" FORCE)
-endif()
 add_subdirectory(spdlog EXCLUDE_FROM_ALL)

 if (NOT TARGET FFmpeg::ffmpeg)
@@ -189,7 +117,6 @@ endif()

 set(TRACY_STATIC ON CACHE BOOL "" FORCE)
 set(TRACY_ENABLE ON CACHE BOOL "" FORCE)
-set(TRACY_NO_CRASH_HANDLER ON CACHE BOOL "" FORCE)
 set(TRACY_ON_DEMAND ON CACHE BOOL "" FORCE)
 set(TRACY_DELAYED_INIT ON CACHE BOOL "" FORCE)
 set(TRACY_MANUAL_LIFETIME ON CACHE BOOL "" FORCE)
@@ -14,7 +14,7 @@
 #include <cpuinfo/internal-api.h>
 #include <cpuinfo/log.h>

-/* Polyfill recent CPUFAMILY_ARM_* values for older platform headers */
+/* Polyfill recent CPUFAMILY_ARM_* values for older SDKs */
 #ifndef CPUFAMILY_ARM_MONSOON_MISTRAL
 	#define CPUFAMILY_ARM_MONSOON_MISTRAL   0xE81E7EF6
 #endif
@@ -1,100 +0,0 @@
--- a/include/zarchive/zarchivecommon.h
-+++ b/include/zarchive/zarchivecommon.h
-@@ -256,7 +256,7 @@
- 
- 			bool IsWithinValidRange(uint64_t fileSize) const
- 			{
-				return (offset + size) <= fileSize;
-+				return offset <= fileSize && size <= fileSize - offset;
- 			}
- 		};
- 
--- a/src/zarchivereader.cpp
-+++ b/src/zarchivereader.cpp
-@@ -14,6 +14,7 @@
- 
- static bool _ifstream_readBytes(std::ifstream& file, uint64_t offset, void* buffer, uint32_t size)
- {
-+	file.clear();
- 	file.seekg(offset, std::ios_base::beg);
- 	file.read((char*)buffer, size);
- 	return file.gcount() == size;
-@@ -80,9 +81,27 @@
- 	// verify file tree
- 	if (fileTree[0].IsFile())
- 		return nullptr; // first entry must be root directory
-	auto rootName = GetName(nameTable, fileTree[0].GetNameOffset());
-	if (!rootName.empty())
-+	if (fileTree[0].GetNameOffset() != 0x7FFFFFFF)
- 		return nullptr; // root node must not have a name
-+	const uint64_t dataCapacity = (uint64_t)offsetRecords.size() * _ZARCHIVE::ENTRIES_PER_OFFSETRECORD * _ZARCHIVE::COMPRESSED_BLOCK_SIZE;
-+	for (size_t i = 0; i < fileTree.size(); ++i)
-+	{
-+		auto& entry = fileTree[i];
-+		if (i != 0)
-+		{
-+			auto name = GetName(nameTable, entry.GetNameOffset());
-+			if (name.empty() || name == "." || name == ".." || name.find_first_of("/\\") != std::string_view::npos || name.find('\0') != std::string_view::npos)
-+				return nullptr;
-+		}
-+		if (entry.IsFile())
-+		{
-+			if (entry.GetFileOffset() > dataCapacity || entry.GetFileSize() > dataCapacity - entry.GetFileOffset())
-+				return nullptr;
-+		}
-+		else if (entry.directoryRecord.nodeStartIndex > fileTree.size() ||
-+			entry.directoryRecord.count > fileTree.size() - entry.directoryRecord.nodeStartIndex)
-+			return nullptr;
-+	}
- 	// read meta data
- 	// todo
- 
-@@ -238,7 +257,7 @@
- 		uint32_t stepSize = std::min<uint32_t>(remainingBytes, _ZARCHIVE::COMPRESSED_BLOCK_SIZE - blockOffset);
- 		CacheBlock* block = GetCachedBlock(blockIdx);
- 		if (!block)
-			return 0;
-+			return bytesToRead - remainingBytes;
- 		std::memcpy(bufferU8, block->data + blockOffset, stepSize);
- 		rawReadOffset += stepSize;
- 		remainingBytes -= stepSize;
-@@ -325,14 +344,18 @@
- 	// determine offset and size of compressed block
- 	auto& record = m_offsetRecords[recordIndex];
- 	uint64_t offset = record.baseOffset;
-+	if (offset > m_compressedDataSize)
-+		return false;
- 	for (uint32_t i = 0; i < recordSubIndex; i++)
- 	{
-		offset += (uint64_t)record.size[i];
-		offset++;
-+		const uint64_t size = (uint64_t)record.size[i] + 1;
-+		if (size > m_compressedDataSize - offset)
-+			return false;
-+		offset += size;
- 	}
- 	uint32_t compressedSize = (uint32_t)record.size[recordSubIndex] + 1;
- 	// load file data
-	if ((offset + compressedSize) > m_compressedDataSize)
-+	if (compressedSize > m_compressedDataSize - offset)
- 		return false;
- 	offset += m_compressedDataOffset;
- 	if (compressedSize == _ZARCHIVE::COMPRESSED_BLOCK_SIZE)
-@@ -350,7 +373,7 @@
- // returns empty view on failure
- std::string_view ZArchiveReader::GetName(const std::vector<uint8_t>& nameTable, uint32_t nameOffset)
- {
-	if (nameOffset == 0x7FFFFFFF || nameOffset > nameTable.size())
-+	if (nameOffset == 0x7FFFFFFF || nameOffset >= nameTable.size())
- 		return "";
- 	// parse header
- 	uint16_t nameLength = nameTable[nameOffset] & 0x7F;
-@@ -359,7 +382,7 @@
- 		// extended 2-byte length
- 		if (nameOffset + 1 >= nameTable.size())
- 			return "";
-		nameLength |= ((uint16_t)nameTable[nameOffset] << 7);
-+		nameLength |= ((uint16_t)nameTable[nameOffset + 1] << 7);
- 		nameOffset += 2;
- 	}
- 	else
@@ -1,7 +1,7 @@
-cmake_minimum_required(VERSION 3.19...4.3)
+cmake_minimum_required(VERSION 3.12...4.3)

 if(CMAKE_VERSION VERSION_GREATER_EQUAL 4.0)
-	set(CMAKE_POLICY_VERSION_MINIMUM 3.10 CACHE STRING "Minimum policy version for bundled dependencies")
+	set(CMAKE_POLICY_VERSION_MINIMUM 3.5 CACHE STRING "Minimum policy version for bundled dependencies")
 endif()

 get_property(KYTY_GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
@@ -12,22 +12,6 @@ endif()

 project(Kyty)

-find_program(SCCACHE_PROGRAM sccache)
-find_program(CCACHE_PROGRAM ccache)
-
-foreach(lang IN ITEMS C CXX)
-    # An explicitly empty launcher disables caching for this language.
-    if(NOT DEFINED CMAKE_${lang}_COMPILER_LAUNCHER)
-        if(SCCACHE_PROGRAM)
-            set(CMAKE_${lang}_COMPILER_LAUNCHER "${SCCACHE_PROGRAM}")
-            message(STATUS "sccache enabled for ${lang}: ${SCCACHE_PROGRAM}")
-        elseif(CCACHE_PROGRAM)
-            set(CMAKE_${lang}_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
-            message(STATUS "ccache enabled for ${lang}: ${CCACHE_PROGRAM}")
-        endif()
-    endif()
-endforeach()
-
 set(KYTY_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src")
 set(KYTY_TESTS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/tests")
 set(KYTY_THIRD_PARTY_DIR "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty")
@@ -40,11 +24,6 @@ if (NOT (WIN32 OR LINUX OR APPLE))
    message(FATAL_ERROR "only Windows, Linux, and macOS builds are supported")
 endif()

-if(WIN32)
-	# Prevent Windows headers from defining min/max macros in all targets.
-	add_compile_definitions(NOMINMAX)
-endif()
-
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
@@ -147,7 +126,7 @@ if (KYTY_LINKER STREQUAL LD AND NOT LINUX)
 	set(KYTY_LD_OPTIONS "-Wl,--image-base=0x100000000000")
 endif()

-project(Kyty${KYTY_PROJECT_NAME}${CMAKE_BUILD_TYPE}${KYTY_COMPILER} VERSION 0.3.0)
+project(Kyty${KYTY_PROJECT_NAME}${CMAKE_BUILD_TYPE}${KYTY_COMPILER} VERSION 0.2.2)

 include_directories(
 	${KYTY_THIRD_PARTY_DIR}/gtest/include
@@ -249,7 +228,7 @@ file(GLOB kyty_emulator_src CONFIGURE_DEPENDS
 	"${KYTY_SOURCE_DIR}/loader/*.h"
 )

-find_program(KYTY_GLSLANG_VALIDATOR NAMES glslangValidator glslang REQUIRED)
+find_program(KYTY_GLSLANG_VALIDATOR glslangValidator REQUIRED)
 set(gpu_tiler_shader_dir "${KYTY_SOURCE_DIR}/graphics/host_gpu/shaders")
 set(gpu_tiler_generated_dir "${PROJECT_BINARY_DIR}/gpu_tiler_shaders")
 set(gpu_tiler_shader_names
@@ -264,7 +243,7 @@ set(gpu_tiler_shader_names
 	depth
 	promote_d16
 	demote_d16
-	color_transform
+	swap_bgra16
 )
 file(GLOB gpu_tiler_shader_includes CONFIGURE_DEPENDS "${gpu_tiler_shader_dir}/gpu_tiler_*.inc")
 foreach(shader_name IN LISTS gpu_tiler_shader_names)
@@ -303,27 +282,27 @@ list(APPEND kyty_emulator_src "${fault_buffer_shader_header}")
 list(APPEND kyty_emulator_src ${gpu_tiler_shader_headers})

 set(gpu_blit_generated_dir "${PROJECT_BINARY_DIR}/gpu_blit_shaders")
-function(add_gpu_blit_shader shader_name shader_file)
-	set(shader_source "${gpu_tiler_shader_dir}/${shader_file}")
+set(gpu_blit_shader_sources
+	"${gpu_tiler_shader_dir}/gpu_blit_fs_triangle.vert"
+	"${gpu_tiler_shader_dir}/gpu_blit_color_to_ms_depth.frag"
+)
+foreach(shader_source IN LISTS gpu_blit_shader_sources)
+	get_filename_component(shader_name "${shader_source}" NAME_WE)
 	set(shader_spv "${gpu_blit_generated_dir}/${shader_name}.spv")
 	set(shader_header "${gpu_blit_generated_dir}/${shader_name}_spv.h")
 	string(TOUPPER "${shader_name}_SPV" shader_symbol)
 	add_custom_command(
 		OUTPUT "${shader_header}"
 		COMMAND ${CMAKE_COMMAND} -E make_directory "${gpu_blit_generated_dir}"
-		COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.3 -Os ${ARGN}
+		COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.3 -Os
 		        "-I${gpu_tiler_shader_dir}" -o "${shader_spv}" "${shader_source}"
 		COMMAND ${CMAKE_COMMAND} -DINPUT=${shader_spv} -DOUTPUT=${shader_header}
 		        -DSYMBOL=${shader_symbol} -P "${KYTY_SOURCE_DIR}/embed_spirv.cmake"
 		DEPENDS "${shader_source}"
 		VERBATIM
 	)
-	set(gpu_blit_shader_headers ${gpu_blit_shader_headers} "${shader_header}" PARENT_SCOPE)
-endfunction()
-add_gpu_blit_shader(gpu_blit_fs_triangle gpu_blit_fs_triangle.vert)
-add_gpu_blit_shader(gpu_blit_color_to_ms_depth gpu_blit_color_to_ms_depth.frag)
-add_gpu_blit_shader(gpu_video_out_overlay gpu_video_out_overlay.frag)
-add_gpu_blit_shader(gpu_imgui_hdr gpu_video_out_overlay.frag -DIMGUI_HDR=1)
+	list(APPEND gpu_blit_shader_headers "${shader_header}")
+endforeach()
 list(APPEND kyty_emulator_src ${gpu_blit_shader_headers})

 list(APPEND kyty_emulator_src
@@ -336,21 +315,35 @@ if (KYTY_CLANG_CL)
 	set_source_files_properties(${kyty_emulator_src} PROPERTIES COMPILE_FLAGS "-Wno-pragma-pack -Wno-deprecated-declarations -D_TIMESPEC_DEFINED")
 endif()

-set(kyty_emulator_link_libraries common Vulkan::Headers spirv-tools-opt spirv-tools SDL3::SDL3-static imgui xxhash FFmpeg::ffmpeg fmt::fmt nlohmann_json::nlohmann_json LibAtrac9 kyty_git_version Zydis::Zydis xbyak::xbyak opus)
+set(kyty_emulator_link_libraries common Vulkan::Headers spirv-tools-opt spirv-tools SDL2-static imgui xxhash FFmpeg::ffmpeg fmt::fmt nlohmann_json::nlohmann_json LibAtrac9 kyty_git_version Zydis::Zydis xbyak::xbyak)

-# Linux system libraries.
+# Linux system libraries required by the static FFmpeg archive.
 if(LINUX)
 	find_package(Threads REQUIRED)
 	list(APPEND kyty_emulator_link_libraries m ${CMAKE_DL_LIBS} Threads::Threads)
+
+	# Optional FFmpeg dependencies.
+	find_package(ZLIB)
+	if(ZLIB_FOUND)
+		list(APPEND kyty_emulator_link_libraries ZLIB::ZLIB)
+	endif()
+	find_library(KYTY_BZ2_LIBRARY bz2)
+	if(KYTY_BZ2_LIBRARY)
+		list(APPEND kyty_emulator_link_libraries ${KYTY_BZ2_LIBRARY})
+	endif()
+	find_library(KYTY_LZMA_LIBRARY lzma)
+	if(KYTY_LZMA_LIBRARY)
+		list(APPEND kyty_emulator_link_libraries ${KYTY_LZMA_LIBRARY})
+	endif()
 endif()

 set(inc_headers
 	${KYTY_SOURCE_DIR}
+	${KYTY_THIRD_PARTY_DIR}/SDL2/include
 	${KYTY_THIRD_PARTY_DIR}/VulkanMemoryAllocator/include
 	${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
@@ -397,13 +390,11 @@ add_kyty_full_emulator_test(shader_cfg_tests "${KYTY_TESTS_DIR}/shaderCfgTests.c

 add_executable(scalar_provenance_tests EXCLUDE_FROM_ALL
 	"${KYTY_TESTS_DIR}/ScalarProvenanceTests.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/gpu_format.cpp"
 	"${KYTY_SOURCE_DIR}/graphics/host_gpu/hostMemory.cpp"
 	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ReadLaneElimination.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ResourceMaterialization.cpp"
 	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/SrtWalker.cpp"
 )
-target_link_libraries(scalar_provenance_tests fmt::fmt xbyak::xbyak)
+target_link_libraries(scalar_provenance_tests fmt::fmt)
 target_include_directories(scalar_provenance_tests PRIVATE ${inc_headers})

 add_executable(page_manager_tests EXCLUDE_FROM_ALL
@@ -413,43 +404,11 @@ add_executable(page_manager_tests EXCLUDE_FROM_ALL
 target_link_libraries(page_manager_tests common)
 target_include_directories(page_manager_tests PRIVATE ${inc_headers})

-add_executable(archive_file_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/ArchiveFileTests.cpp"
-)
-target_link_libraries(archive_file_tests common ZArchive::zarchive)
-target_include_directories(archive_file_tests PRIVATE ${inc_headers})
-
-add_executable(trophy_system_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/TrophySystemTests.cpp"
-)
-target_link_libraries(trophy_system_tests common)
-target_include_directories(trophy_system_tests PRIVATE ${inc_headers})
-
-add_executable(avplayer_file_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/AvPlayerFileTests.cpp"
-	"${KYTY_SOURCE_DIR}/loader/timer.cpp"
-)
-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"
 )
 target_include_directories(bit_array_tests PRIVATE ${inc_headers})

-add_executable(lru_cache_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/LruCacheTests.cpp"
-)
-target_include_directories(lru_cache_tests PRIVATE ${inc_headers})
-
 add_executable(ime_dialog_tests EXCLUDE_FROM_ALL
 	"${KYTY_TESTS_DIR}/ImeDialogTests.cpp"
 	"${KYTY_SOURCE_DIR}/libs/imeCommon.cpp"
@@ -472,15 +431,16 @@ add_executable(shader_vertex_metadata_tests EXCLUDE_FROM_ALL
 )
 target_include_directories(shader_vertex_metadata_tests PRIVATE ${inc_headers})

-add_executable(resource_materialization_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/ResourceMaterializationTests.cpp"
+add_executable(shader_stage_runtime_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/ShaderStageRuntimeTests.cpp"
 	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/gpu_format.cpp"
 	"${KYTY_SOURCE_DIR}/graphics/host_gpu/hostMemory.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/shaderStageRuntime.cpp"
 	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ResourceMaterialization.cpp"
 	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/SrtWalker.cpp"
 )
-target_link_libraries(resource_materialization_tests fmt::fmt xbyak::xbyak)
-target_include_directories(resource_materialization_tests PRIVATE ${inc_headers})
+target_link_libraries(shader_stage_runtime_tests fmt::fmt)
+target_include_directories(shader_stage_runtime_tests PRIVATE ${inc_headers})

 add_executable(resource_tracking_tests EXCLUDE_FROM_ALL
 	"${KYTY_TESTS_DIR}/ResourceTrackingTests.cpp"
@@ -491,8 +451,9 @@ add_executable(resource_tracking_tests EXCLUDE_FROM_ALL
 	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ResourceTracking.cpp"
 	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ResourceMaterialization.cpp"
 	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ShaderInfoCollection.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/BindingLayout.cpp"
 )
-target_link_libraries(resource_tracking_tests fmt::fmt xbyak::xbyak)
+target_link_libraries(resource_tracking_tests fmt::fmt)
 target_include_directories(resource_tracking_tests PRIVATE ${inc_headers})

 add_executable(audio_out2_port_tests EXCLUDE_FROM_ALL
@@ -503,57 +464,6 @@ add_executable(audio_out2_port_tests EXCLUDE_FROM_ALL
 target_link_libraries(audio_out2_port_tests common fmt::fmt)
 target_include_directories(audio_out2_port_tests PRIVATE ${inc_headers})

-add_executable(audio_out_timing_tests EXCLUDE_FROM_ALL "${KYTY_TESTS_DIR}/AudioOutTimingTests.cpp")
-target_link_libraries(audio_out_timing_tests common fmt::fmt SDL3::SDL3-static)
-target_include_directories(audio_out_timing_tests PRIVATE ${inc_headers})
-
-add_executable(ngs2_sampler_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/Ngs2SamplerTests.cpp"
-	"${KYTY_SOURCE_DIR}/loader/timer.cpp"
-)
-target_link_libraries(ngs2_sampler_tests common fmt::fmt LibAtrac9)
-target_include_directories(ngs2_sampler_tests PRIVATE ${inc_headers})
-
-add_executable(pad_haptics_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/PadHapticsTests.cpp"
-)
-target_link_libraries(pad_haptics_tests common fmt::fmt SDL3::SDL3-static opus)
-target_include_directories(pad_haptics_tests PRIVATE ${inc_headers})
-
-add_executable(controller_settings_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/ControllerSettingsTests.cpp"
-)
-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"
-)
-target_link_libraries(save_data_memory_tests common fmt::fmt)
-target_include_directories(save_data_memory_tests PRIVATE ${inc_headers})
-
-add_executable(png_enc_tests EXCLUDE_FROM_ALL "${KYTY_TESTS_DIR}/PngEncTests.cpp")
-target_link_libraries(png_enc_tests common fmt::fmt)
-target_include_directories(png_enc_tests PRIVATE ${inc_headers})
-
-add_executable(ces_tests EXCLUDE_FROM_ALL "${KYTY_TESTS_DIR}/CesTests.cpp")
-target_link_libraries(ces_tests common fmt::fmt SDL3::SDL3-static)
-target_include_directories(ces_tests PRIVATE ${inc_headers})
-
-add_executable(save_data_dialog_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/SaveDataDialogTests.cpp"
-	"${KYTY_SOURCE_DIR}/libs/dialog.cpp"
-)
-target_link_libraries(save_data_dialog_tests common fmt::fmt)
-target_include_directories(save_data_dialog_tests PRIVATE ${inc_headers})
-
-add_kyty_full_emulator_test(http_uri_parse_tests
-	"${KYTY_TESTS_DIR}/HttpUriParseTests.cpp")
-
 add_executable(event_queue_lifetime_tests EXCLUDE_FROM_ALL
 	"${KYTY_TESTS_DIR}/EventQueueLifetimeTests.cpp"
 	"${KYTY_SOURCE_DIR}/kernel/eventQueue.cpp"
@@ -564,7 +474,6 @@ target_include_directories(event_queue_lifetime_tests PRIVATE ${inc_headers})

 add_kyty_full_emulator_test(kernel_file_system_tests
 	"${KYTY_TESTS_DIR}/KernelFileSystemTests.cpp")
-target_link_libraries(kernel_file_system_tests ZArchive::zarchive)

 add_executable(sync_on_address_tests EXCLUDE_FROM_ALL
 	"${KYTY_TESTS_DIR}/SyncOnAddressTests.cpp"
@@ -631,36 +540,17 @@ if(BUILD_TESTING)
 	add_test(NAME image_page_table COMMAND $<TARGET_FILE:image_page_table_tests>)
 	add_test(NAME memory_tracker COMMAND $<TARGET_FILE:memory_tracker_tests>)
 	add_test(NAME page_manager COMMAND $<TARGET_FILE:page_manager_tests>)
-	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>)
-	add_test(NAME resource_materialization COMMAND $<TARGET_FILE:resource_materialization_tests>)
+	add_test(NAME shader_stage_runtime COMMAND $<TARGET_FILE:shader_stage_runtime_tests>)
 	add_test(NAME resource_tracking COMMAND $<TARGET_FILE:resource_tracking_tests>)
 	add_test(NAME event_queue_lifetime COMMAND $<TARGET_FILE:event_queue_lifetime_tests>)
 	add_test(NAME kernel_file_system COMMAND $<TARGET_FILE:kernel_file_system_tests>)
 	add_test(NAME sync_on_address COMMAND $<TARGET_FILE:sync_on_address_tests>)
 	add_test(NAME audio_out2_port COMMAND $<TARGET_FILE:audio_out2_port_tests>)
-	add_test(NAME audio_out_timing COMMAND $<TARGET_FILE:audio_out_timing_tests>)
-	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>)
-	add_test(NAME save_data_dialog COMMAND $<TARGET_FILE:save_data_dialog_tests>)
-	add_test(NAME http_uri_parse COMMAND $<TARGET_FILE:http_uri_parse_tests>)
 	add_test(NAME shader_recompiler_compute COMMAND $<TARGET_FILE:shader_recompiler_compute_tests>)
 	add_test(NAME shader_recompiler_alignbyte
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --alignbyte-only)
-	add_test(NAME graphics_pipeline_rasterization
-		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --polygon-mode-only)
-	add_test(NAME graphics_draw_offsets
-		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --draw-offset-only)
 	add_test(NAME virtual_memory_allocation
 		COMMAND $<TARGET_FILE:virtual_memory_allocation_tests>)
 	add_test(NAME guest_red_zone_patcher
@@ -675,32 +565,27 @@ if(BUILD_TESTING)
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --context-state-only)
 	add_test(NAME gpu_tiler
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --gpu-tiler-only)
-	add_test(NAME image_transfer_layout
-		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --image-layout-only)

 	add_test(NAME texture_cache_layered_image
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --layered-image-only)
-	add_test(NAME host_image_allocation
-		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --host-image-allocation-only)
 	add_test(NAME texture_cache_image_views
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --image-view-cache-only)
 	add_test(NAME texture_cache_storage_sampled
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --storage-sampled-only)
 	add_test(NAME texture_cache_depth_readback
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --depth-readback-only)
-	add_test(NAME compute_meta_clear_classification
-		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --compute-meta-clear-only)
 	add_test(NAME buffer_cache_dirty_gc
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --buffer-cache-gc-only)
-	add_test(NAME color_render_target_1d
-		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --rt1d-only)

-	add_test(NAME texture_cache_image_overlap
-		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --image-overlap-only)
-	add_test(NAME texture_cache_htile_clear
-		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --htile-clear-only)
-	add_test(NAME buffer_cache_ranges
-		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --buffer-cache-range-only)
+	if(WIN32)
+		# These tests still depend on the Windows multisample-depth path.
+		add_test(NAME texture_cache_image_overlap
+			COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --image-overlap-only)
+		add_test(NAME texture_cache_htile_clear
+			COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --htile-clear-only)
+		add_test(NAME buffer_cache_ranges
+			COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --buffer-cache-range-only)
+	endif()

 	add_custom_target(kyty_tests DEPENDS
 		ime_dialog_tests
@@ -709,14 +594,9 @@ if(BUILD_TESTING)
 		image_page_table_tests
 		memory_tracker_tests
 		page_manager_tests
-		archive_file_tests
-		trophy_system_tests
-		avplayer_file_tests
-		vdecsw_tests
 		bit_array_tests
-		lru_cache_tests
 		shader_vertex_metadata_tests
-		resource_materialization_tests
+		shader_stage_runtime_tests
 		resource_tracking_tests
 		event_queue_lifetime_tests
 		kernel_file_system_tests
@@ -724,56 +604,13 @@ if(BUILD_TESTING)
 		shader_recompiler_compute_tests
 		virtual_memory_allocation_tests
 		audio_out2_port_tests
-		audio_out_timing_tests
-		ngs2_sampler_tests
-		pad_haptics_tests
-		controller_settings_tests
-		host_input_tests
-		save_data_memory_tests
-		png_enc_tests
-		ces_tests
-		save_data_dialog_tests
-		http_uri_parse_tests
 	)
 endif()

-# Test Darwin signal-context restoration for SSE4a instructions.
-if(APPLE AND (CMAKE_OSX_ARCHITECTURES STREQUAL "x86_64" OR
-		(NOT CMAKE_OSX_ARCHITECTURES AND CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64)$")))
-	add_executable(macos_sse4a_tests EXCLUDE_FROM_ALL
-		"${KYTY_TESTS_DIR}/macosSse4aTests.cpp"
-		"${KYTY_SOURCE_DIR}/loader/x64InstructionEmulator.cpp"
-		"${KYTY_SOURCE_DIR}/loader/guestInstructionPatcher.cpp"
-	)
-	target_link_libraries(macos_sse4a_tests common fmt::fmt Zydis::Zydis xbyak::xbyak)
-	target_include_directories(macos_sse4a_tests PRIVATE ${inc_headers})
-	if(BUILD_TESTING)
-		add_test(NAME macos_sse4a COMMAND $<TARGET_FILE:macos_sse4a_tests>)
-		set_tests_properties(macos_sse4a PROPERTIES TIMEOUT 15)
-		add_dependencies(kyty_tests macos_sse4a_tests)
-	endif()
-endif()

 add_executable(kyty_emulator "${KYTY_SOURCE_DIR}/main.cpp" ${kyty_emulator_src})
 configure_macos_guest_address_space(kyty_emulator)

-set(KYTY_TROPHY_UNLOCK_SOUND "${CMAKE_CURRENT_SOURCE_DIR}/assets/sounds/trophy-unlock.wav")
-add_custom_target(kyty_trophy_sound
-	COMMAND ${CMAKE_COMMAND} -E make_directory "$<TARGET_FILE_DIR:kyty_emulator>/assets/sounds"
-	COMMAND ${CMAKE_COMMAND} -E copy_if_different "${KYTY_TROPHY_UNLOCK_SOUND}"
-		"$<TARGET_FILE_DIR:kyty_emulator>/assets/sounds/trophy-unlock.wav"
-	VERBATIM)
-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)
@@ -809,16 +646,7 @@ if(KYTY_CLANG_CL)
 	)
 	add_custom_command(TARGET kyty_emulator POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${KYTY_THIRD_PARTY_DIR}/winpthread/bin/libwinpthread-1.dll" $<TARGET_FILE_DIR:kyty_emulator>/libwinpthread-1.dll)
 elseif(WIN32 OR LINUX)
-	set_target_properties(kyty_emulator PROPERTIES LINK_FLAGS "${KYTY_LD_OPTIONS}")
-	# LINK_FLAGS is a space-delimited string: a -Map path containing spaces would
-	# be split into bogus arguments, so pass it as a discrete link option instead.
-	target_link_options(kyty_emulator PRIVATE "-Wl,-Map=${KYTY_EMULATOR_MAP_LINK_PATH}")
-endif()
-
-if(LINUX)
-    target_link_options(kyty_emulator PRIVATE
-        $<$<CONFIG:Release>:-Wl,--strip-all>
-    )
+	set_target_properties(kyty_emulator PROPERTIES LINK_FLAGS "${KYTY_LD_OPTIONS} -Wl,-Map=${KYTY_EMULATOR_MAP_LINK_PATH}")
 endif()

 if(APPLE)
@@ -836,10 +664,6 @@ endif()
 install(TARGETS kyty_emulator DESTINATION .)
 if(KYTY_BUILD_LAUNCHER)
 	add_subdirectory("${KYTY_SOURCE_DIR}/launcher" "${CMAKE_CURRENT_BINARY_DIR}/launcher")
-
-	if(LINUX)
-		target_link_options(launcher PRIVATE $<$<CONFIG:Release>:-Wl,--strip-all>)
-	endif()
 endif()
 if(KYTY_CLANG_CL)
 	install(FILES "${KYTY_THIRD_PARTY_DIR}/winpthread/bin/libwinpthread-1.dll" DESTINATION .)
@@ -1,20 +1,16 @@
 # KytyPS5

-[![Build KytyPS5 (Windows)](https://img.shields.io/github/check-runs/KytyPS5/KytyPS5/main?nameFilter=Build%20KytyPS5%20%28Windows%29&label=Build%20KytyPS5%20%28Windows%29)](https://github.com/KytyPS5/KytyPS5/actions/workflows/build.yml)
-[![Build KytyPS5 (Linux)](https://img.shields.io/github/check-runs/KytyPS5/KytyPS5/main?nameFilter=Build%20KytyPS5%20%28Linux%29&label=Build%20KytyPS5%20%28Linux%29)](https://github.com/KytyPS5/KytyPS5/actions/workflows/build.yml)
-[![Build KytyPS5 (macOS)](https://img.shields.io/github/check-runs/KytyPS5/KytyPS5/main?nameFilter=Build%20KytyPS5%20%28macOS%29&label=Build%20KytyPS5%20%28macOS%29)](https://github.com/KytyPS5/KytyPS5/actions/workflows/build.yml)
+[![Build KytyPS5 (Windows)](https://img.shields.io/github/actions/workflow/status/KytyPS5/KytyPS5/build.yml?branch=main&event=push&label=Build%20KytyPS5%20%28Windows%29)](https://github.com/KytyPS5/KytyPS5/actions/workflows/build.yml)
+[![Build KytyPS5 (Linux)](https://img.shields.io/github/actions/workflow/status/KytyPS5/KytyPS5/build.yml?branch=main&event=push&label=Build%20KytyPS5%20%28Linux%29)](https://github.com/KytyPS5/KytyPS5/actions/workflows/build.yml)
+[![Build KytyPS5 (macOS)](https://img.shields.io/github/actions/workflow/status/KytyPS5/KytyPS5/build.yml?branch=main&event=push&label=Build%20KytyPS5%20%28macOS%29)](https://github.com/KytyPS5/KytyPS5/actions/workflows/build.yml)
 [![Platform](https://img.shields.io/badge/platform-Windows%20x64%20%7C%20Linux%20x64%20%7C%20macOS%20x86__64-0078D4.svg)](#system-requirements)
-[![Status](https://img.shields.io/badge/status-active%20development-orange.svg)](#current-status)
+[![Status](https://img.shields.io/badge/status-early%20development-orange.svg)](#current-status)
 [![License](https://img.shields.io/badge/license-GPL--2.0-blue.svg)](LICENSE)

-**[Weekly updates](https://github.com/KytyPS5/KytyPS5/discussions/862)** — game progress, recent fixes, and ongoing development.
-
-**[Development on Discord](https://discord.gg/UNrkMqGaBg)** — KytyPS5 development.
-
-KytyPS5 is a free and open-source PlayStation 5 translation layer written in C++ for Windows
-and Linux, with experimental macOS support. It is based on a heavily modified version of
-[Kyty](https://github.com/InoriRus/Kyty). The project is in active development, and behavior
-can change significantly between builds.
+KytyPS5 is a free and open-source PlayStation 5 emulator written in C++ for Windows and Linux,
+with experimental macOS support. It is based on a heavily modified version of
+[Kyty](https://github.com/InoriRus/Kyty). The project is in an early stage of development, so
+compatibility is limited and behavior may change significantly between builds.

 > [!IMPORTANT]
 > KytyPS5 is not affiliated with Sony Interactive Entertainment or PlayStation. The project does
@@ -23,13 +19,13 @@ can change significantly between builds.

 ## Current Status

-KytyPS5 can boot 2D and 3D games, including titles built with Unreal Engine
-4/5, Unity, and custom engines. External low-level emulation modules are neither required nor
-planned.
+KytyPS5 can boot 2D games and a selection of 3D games, including titles built with Unreal Engine
+4/5, Unity, and custom engines. No external low-level emulation modules are currently required.

-Development is currently focused on expanding game compatibility and improving boot reliability.
+Development is focused on compatibility and boot reliability.

-Windows and Linux are the primary target platforms and receive the most testing.
+Windows is the primary platform and receives the most testing. Linux builds and runs; see
+[Building on Linux](#building-on-linux).

 macOS support is experimental. The emulator is built for x86-64 and runs on Apple Silicon under
 Rosetta 2, with Vulkan provided by MoltenVK. A small number of titles have been verified in-game
@@ -40,20 +36,20 @@ Community game test results are available in the

 ## Bugs and Issues

-Compatibility, stability, and performance can vary between versions. You may encounter crashes
-or graphical glitches, so please include the version you tested when reporting an issue.
+The project is in an early stage, so please be mindful when opening new issues. Expect crashes,
+graphical glitches, low compatibility, and poor performance.

 ## Screenshots

 <table align="center">
  <tr>
    <td align="center">
-      <strong>Astro Bot</strong><br>
-      <img src="docs/screenshots/ps5-01.png" width="300" alt="Astro Bot running in KytyPS5">
+      <strong>Disgaea 6</strong><br>
+      <img src="docs/screenshots/ps5-01.png" width="300" alt="Disgaea 6 running in KytyPS5">
    </td>
    <td align="center">
-      <strong>Saros</strong><br>
-      <img src="docs/screenshots/ps5-03.png" width="300" alt="Saros running in KytyPS5">
+      <strong>Dreaming Sarah</strong><br>
+      <img src="docs/screenshots/ps5-03.png" width="300" alt="Dreaming Sarah running in KytyPS5">
    </td>
  </tr>
  <tr>
@@ -68,12 +64,12 @@ or graphical glitches, so please include the version you tested when reporting a
  </tr>
  <tr>
    <td align="center">
-      <strong>Demon's Souls</strong><br>
-      <img src="docs/screenshots/ps5-02.png" width="300" alt="Demon's Souls running in KytyPS5">
+      <strong>Hellboy</strong><br>
+      <img src="docs/screenshots/ps5-02.png" width="300" alt="Hellboy running in KytyPS5">
    </td>
    <td align="center">
-      <strong>UFC 6</strong><br>
-      <img src="docs/screenshots/ps5-06.jpg" width="300" alt="UFC 6 running in KytyPS5">
+      <strong>Paleo Pines</strong><br>
+      <img src="docs/screenshots/ps5-06.png" width="300" alt="Paleo Pines running in KytyPS5">
    </td>
  </tr>
 </table>
@@ -83,31 +79,19 @@ or graphical glitches, so please include the version you tested when reporting a
 ## Contributing

 Testing games and submitting detailed bug reports are useful ways to contribute. Search existing
-issues first, then use the **Game Emulation Status Report** template and attach the complete log file.
+issues first, then use the **Game Emulation Bug Report** template and attach the complete log file.

-**Pull requests for general fixes, architectural changes, or refactoring that do not address a concrete bug or launch problem in a specific game will be automatically closed.**
-
-**Large, unfocused commits or pull requests that bundle unrelated changes without a clear purpose or game-related benefit will also be automatically closed.**
-
-Keep each PR focused. Name the affected game, describe the exact problem, and provide evidence showing what the change fixes.
-
-Windows and Linux are the primary target platforms, so changes to shared code should not
-introduce regressions on either platform. Changes confined to a platform's own code paths
-only need to build on that platform. Because KytyPS5 is still evolving quickly, consider
-opening an issue before starting a large change.
+Code contributions should be focused, build successfully on the platforms they touch, and include
+relevant tests where practical. Windows is the primary target, so a change that alters shared code
+should not regress it; changes confined to a platform's own code paths only need to build there. Because KytyPS5 is still evolving quickly, consider opening an issue before
+starting a large change.

 ### Formatting

-Set up the clang-format hook after cloning.
+Set up the clang-format hook after cloning:

-Install `pre-commit` using the method appropriate for your platform:
-
- **Arch Linux / CachyOS:** `sudo pacman -S pre-commit`
- **Other Linux / macOS / Windows:** `python -m pip install pre-commit`
-
-Then install the Git hook:
-
-```bash
+```powershell
+python -m pip install pre-commit
 python -m pre_commit install --install-hooks
 ```

@@ -142,13 +126,11 @@ the Vulkan/SPIR-V validation rules.
 ### Build requirements (Windows)

 - Git
- CMake 3.22.1 or newer
+- CMake 3.12 or newer
 - Ninja
 - Visual Studio 2022 or Build Tools 2022 with the **Desktop development with C++** workload and
  **C++ Clang tools for Windows** component
 - Qt 6 for MSVC 2022 64-bit, including Concurrent, Network, and Widgets
- [glslang](https://github.com/KhronosGroup/glslang/releases) (`glslang` or `glslangValidator`) on `PATH`
- Python 3 on `PATH`; the bundled SPIRV-Tools runs it at configure time

 The Microsoft C++ compiler (`cl.exe`) is not supported; use `clang-cl`.

@@ -177,20 +159,20 @@ The finished application and its runtime dependencies will be placed in

 ### Building on Linux

-Install the toolchain and the libraries the bundled SDL3 needs. Without the audio, Wayland, and
-udev development packages, SDL3 quietly configures itself without those backends, and the resulting
-build has no working audio or gamepad hotplug support:
+Install the toolchain and the libraries the bundled SDL2 needs. Without the audio, Wayland and
+udev development packages SDL2 quietly configures itself without those backends, and the resulting
+build has no working sound and no gamepad hotplug:

 ```bash
 sudo apt-get install --no-install-recommends \
-  clang lld ninja-build cmake git glslang-tools python3 pkg-config \
+  clang lld ninja-build cmake git glslang-tools \
  libgl1-mesa-dev libx11-dev libxcursor-dev libxext-dev libxfixes-dev \
-  libxi-dev libxrandr-dev libxss-dev libxtst-dev libxkbcommon-dev \
+  libxi-dev libxrandr-dev libxss-dev libxkbcommon-dev \
  libasound2-dev libpulse-dev libudev-dev libdbus-1-dev libwayland-dev wayland-protocols
 ```

-Qt 6 (Concurrent, Network, and Widgets) is required for the launcher. Use your distribution's
-packages (`qt6-base-dev`) or an official Qt installation.
+Qt 6 (Concurrent, Network, Widgets) is also required — either the distribution packages
+(`qt6-base-dev`) or an official Qt installation.

 ```bash
 git submodule update --init --recursive
@@ -204,87 +186,13 @@ cmake --install _Build/linux --prefix _Build/linux/install
 ```

 The install step copies the Qt libraries and plugins next to the binaries, so
-`_Build/linux/install` runs without a matching system Qt installation. FFmpeg is linked statically
-from the pinned [KytyPS5 FFmpeg core](https://github.com/KytyPS5/ext-ffmpeg-core)
-release, including VP9 and WebM support. System FFmpeg packages are not required.
-
-To build `kyty_emulator` and the `kyty_tests` target without Qt, use a separate build directory:
-
-```bash
-git submodule update --init --recursive
-
-cmake -S . -B _Build/linux-no-qt -G Ninja -DCMAKE_BUILD_TYPE=Release \
-  -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ \
-  -DKYTY_BUILD_LAUNCHER=OFF
-
-cmake --build _Build/linux-no-qt --target kyty_emulator kyty_tests --parallel
-```
+`_Build/linux/install` runs without a matching system Qt.

 As on Windows, the MSVC compiler is not used; Clang is required. `cl.exe` is rejected at configure
 time.

 The CMake source root is the repository root.

-### Building on NixOS
-
-A development shell provides Clang, CMake, Ninja, Qt 6, the Vulkan headers, and the SDL3 backend
-libraries. Enter it and configure exactly as on other Linux distributions; the shell exports
-`CMAKE_PREFIX_PATH` and `QT_PLUGIN_PATH`, so the `-DCMAKE_PREFIX_PATH="$Qt6_DIR"` argument is not
-needed:
-
-```bash
-nix-shell # or: nix develop
-git submodule update --init --recursive
-
-cmake -S . -B _Build/linux -G Ninja -DCMAKE_BUILD_TYPE=Release \
-  -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
-
-cmake --build _Build/linux --target launcher --parallel
-cmake --install _Build/linux --prefix _Build/linux/install
-```
-
-The configure step downloads the FFmpeg prebuilts and the `xbyak`, `zydis`, `zstd`, and ZArchive
-sources, so it needs network access; a fully sandboxed `nix build` would require vendoring those
-inputs. A Vulkan 1.3 driver must be available at runtime (on NixOS,
-`hardware.graphics.enable = true`).
-
-### Building on Fedora and Fedora Atomic (Bazzite, Bluefin, Silverblue)
-
-On regular Fedora, install dependencies on the host. On Fedora Atomic variants such as Bazzite,
-Bluefin and Silverblue, use [Distrobox](https://distrobox.it/) and run the install and build steps
-inside the container. Keep the checkout in your home directory so it is shared with the container.
-Add `--nvidia` to the create command for hosts using the proprietary NVIDIA driver:
-
-```bash
-distrobox create --name kyty-build --image registry.fedoraproject.org/fedora:latest
-distrobox enter kyty-build
-```
-
-Install the toolchain, Qt 6 and SDL3 dependencies:
-
-```bash
-sudo dnf install -y \
-  clang lld ninja-build cmake git glslang python3 pkgconf-pkg-config \
-  mesa-libGL-devel libX11-devel libXcursor-devel libXext-devel libXfixes-devel \
-  libXi-devel libXrandr-devel libXScrnSaver-devel libXtst-devel libxkbcommon-devel \
-  alsa-lib-devel pulseaudio-libs-devel systemd-devel dbus-devel \
-  wayland-devel wayland-protocols-devel qt6-qtbase-devel
-```
-
-From the repository root, follow the launcher configure, build and install steps in
-[Building on Linux](#building-on-linux), omitting `-DCMAKE_PREFIX_PATH="$Qt6_DIR"`; CMake finds
-Fedora's packaged Qt 6 automatically.
-
-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/kyty_launcher
-```
-
-Qt libraries and plugins are bundled. You can also launch directly on a Fedora Atomic host
-if its other system libraries are compatible with the container build.
-
 ### Building on macOS

 macOS builds target x86-64 and run under Rosetta 2 on Apple Silicon, so the PS5's x86-64 game
@@ -295,8 +203,8 @@ Requirements:

 - An Apple Silicon Mac with Rosetta 2 installed (`softwareupdate --install-rosetta`)
 - Xcode (or the Command Line Tools)
- Homebrew packages: `brew install cmake ninja glslang python`
- Qt 6 (Concurrent, Network, and Widgets) with x86-64 support. The official Qt installation is
+- Homebrew packages: `brew install cmake ninja glslang`
+- Qt 6 (Concurrent, Network, Widgets) with x86-64 support. The official Qt installation is
  universal and works; Homebrew's Qt is arm64-only and will not link

 ```bash
@@ -312,14 +220,14 @@ cmake --install _Build/macos --prefix _Build/macos/install
 ```

 The build re-signs `kyty_emulator` with the JIT entitlements it needs to execute translated
-guest code; no manual signing step is required. When the launcher is built, the installation
+guest code; no manual signing step is required. When the launcher is built, the install
 also produces `_Build/macos/install/KytyPS5.app` — double-click to launch the GUI.
 A flat `kyty_emulator` is kept for CLI usage.

 Vulkan comes from MoltenVK. Download `MoltenVK-macos.tar` from the
 [MoltenVK releases](https://github.com/KhronosGroup/MoltenVK/releases), then copy
 `MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib` next to the flat `kyty_emulator`
-(and, for the bundle, into `KytyPS5.app/Contents/Frameworks/`) and sign it with an ad hoc signature:
+(and, for the bundle, into `KytyPS5.app/Contents/Frameworks/`) and ad-hoc sign it:

 ```bash
 codesign --force --sign - _Build/macos/install/libMoltenVK.dylib
@@ -345,7 +253,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
-`kyty_launcher.exe` and `kyty_emulator.exe`. It is Windows-only: VS Code settings cannot select a
+`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 +273,11 @@ Update your graphics driver before reporting rendering problems.
 To use the graphical launcher:

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

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

 ```bash
@@ -377,29 +285,17 @@ open _Build/macos/install/KytyPS5.app  # or double-click in Finder
 ```

 On first launch, add one or more game folders in the global settings. The launcher searches those
-folders recursively for game directories containing `eboot.bin` and ZArchive (`.zar`) game dumps
-whose archive root contains `eboot.bin`. Select a detected game and run it from the game list.
-ZArchive dumps are mounted read-only and streamed directly; they do not need to be extracted first.
+folders recursively for game directories containing `eboot.bin`. Select a detected game and run it
+from the game list.

-Official release builds include a built-in updater. Leave **Check for updates on startup** enabled,
-or click **Check for updates**, then choose **Install Update**. The launcher downloads the package
-for your platform from GitHub, checks its SHA-256 checksum, and restarts after installation. Close
-any running games first. Settings, saves, patches, and other files outside the release package are
-preserved; replacement failures restore the previous files. The installation folder must be writable.
-If a package cannot be installed automatically, the updater offers the GitHub release page.
-Source builds and builds from forks do not replace themselves with official releases.
-
-The emulator can also be started directly with a legally obtained game directory, ELF file, or
-ZArchive dump:
+The emulator can also be started directly with a legally obtained game directory or ELF file:

 ```powershell
 .\_Build\windows\install\kyty_emulator.exe --game "D:\Games\ExampleGame"
-.\_Build\windows\install\kyty_emulator.exe --game "D:\Games\ExampleGame.zar"
 ```

 ```bash
 ./_Build/linux/install/kyty_emulator --game "/games/ExampleGame"
-./_Build/linux/install/kyty_emulator --game "/games/ExampleGame.zar"
 ```

 On macOS, the adjacent flat or app-bundled `libMoltenVK.dylib` is found automatically; no
@@ -443,6 +339,5 @@ licenses included with those components.

 - [InoriRus/Kyty](https://github.com/InoriRus/Kyty) — KytyPS5 is based on a heavily modified version
  of the original Kyty project.
- [shadps4-emu/shadPS4](https://github.com/shadps4-emu/shadPS4) — reference for understanding PS4
-  memory behavior, GPU resource aliasing, cache coherency,
-  and the AVPlayer implementation.
+- [shadps4-emu/shadPS4](https://github.com/shadps4-emu/shadPS4) — reference for memory-model
+  understanding and the AVPlayer implementation.
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "تم كسب الكأس!",
-  "user.guest": "ضيف"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Trofej získána!",
-  "user.guest": "Host"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Trofæ optjent!",
-  "user.guest": "Gæst"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Trophäe erhalten!",
-  "user.guest": "Gast"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Κερδίσατε ένα τρόπαιο!",
-  "user.guest": "Επισκ."
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Trophy earned!",
-  "user.guest": "Guest"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Trophy earned!",
-  "user.guest": "Guest"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "¡Ganaste un trofeo!",
-  "user.guest": "Invitado"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "¡Ganaste un trofeo!",
-  "user.guest": "Invitado"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Pokaali ansaittu!",
-  "user.guest": "Vieras"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Trophée obtenu !",
-  "user.guest": "Invité"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Trophée obtenu !",
-  "user.guest": "Invité"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Trófea megszerezve!",
-  "user.guest": "Vendég"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Trofi diperoleh!",
-  "user.guest": "Tamu"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Trofeo ottenuto!",
-  "user.guest": "Ospite"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "トロフィーを獲得しました！",
-  "user.guest": "ゲスト"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "트로피를 획득했습니다!",
-  "user.guest": "게스트"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Trofee behaald!",
-  "user.guest": "Gast"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Trofé opptjent!",
-  "user.guest": "Gjest"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Zdobyto trofeum!",
-  "user.guest": "Gość"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Troféu conquistado!",
-  "user.guest": "Convidado"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Troféu conquistado!",
-  "user.guest": "Convidado"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Trofeu câștigat!",
-  "user.guest": "Invitat"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Трофей получен!",
-  "user.guest": "Гость"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Trofé intjänad!",
-  "user.guest": "Gäst"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "ได้รับถ้วยรางวัลแล้ว!",
-  "user.guest": "แขก"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Kupa kazanıldı!",
-  "user.guest": "Misafir"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "Đã nhận cúp!",
-  "user.guest": "Khách"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "已获得奖杯！",
-  "user.guest": "访客"
-}
@@ -1,4 +0,0 @@
-{
-  "trophy.toast.earned": "已獲得獎盃！",
-  "user.guest": "訪客"
-}
@@ -1,20 +0,0 @@
-# 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.
@@ -1,27 +0,0 @@
-{
-  "nodes": {
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1789426278,
-        "narHash": "sha256-GnotcvKtbTMnoVx6G4E7ZdUX6487Dky74dqq3pU7iRk=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "efe6f071ede9d21c37462d2d6682d5e670099684",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "nixpkgs": "nixpkgs"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}
@@ -1,20 +0,0 @@
-{
-  description = "KytyPS5 development shell";
-
-  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
-
-  outputs = { self, nixpkgs }:
-    let
-      systems = [ "x86_64-linux" ];
-      forAllSystems = nixpkgs.lib.genAttrs systems;
-    in
-    {
-      devShells = forAllSystems (system:
-        let
-          pkgs = import nixpkgs { inherit system; };
-        in
-        {
-          default = import ./nix/devshell.nix { inherit pkgs; };
-        });
-    };
-}
@@ -1,85 +0,0 @@
-{ pkgs }:
-
-let
-  # Build-time dependencies for the bundled SDL3 audio, video and input backends.
-  buildDeps = with pkgs; [
-    qt6.qtbase # Concurrent, Network, Widgets (launcher)
-    vulkan-headers
-    vulkan-loader
-    vulkan-tools
-    vulkan-validation-layers
-    libglvnd
-    # X11 / input
-    libX11
-    libXcursor
-    libXext
-    libXfixes
-    libXi
-    libXrandr
-    libXScrnSaver
-    libXtst
-    libxkbcommon
-    # Wayland
-    wayland
-    wayland-protocols
-    libdecor
-    # audio + device/dbus
-    alsa-lib
-    libpulseaudio
-    systemd # libudev
-    dbus
-  ];
-
-  # Libraries the built binaries need at runtime.
-  runtimeLibs = with pkgs; [
-    stdenv.cc.cc.lib # libstdc++ / libgcc_s
-    libgcc.lib
-    qt6.qtbase # libQt6Concurrent/Network/Widgets
-    vulkan-loader
-    libglvnd
-    alsa-lib
-    libpulseaudio
-    libX11
-    libXcursor
-    libXext
-    libXfixes
-    libXi
-    libXrandr
-    libXScrnSaver
-    libXtst
-    libxkbcommon
-    wayland
-    libdecor
-    systemd
-    dbus
-  ];
-in
-pkgs.mkShell {
-  name = "kytyps5";
-
-  nativeBuildInputs = with pkgs; [
-    clang
-    lld
-    cmake
-    ninja
-    pkg-config
-    git
-    glslang # provides glslangValidator for the bundled shaders
-  ];
-
-  buildInputs = buildDeps;
-
-  shellHook = ''
-    export CMAKE_PREFIX_PATH="${pkgs.qt6.qtbase}:''${CMAKE_PREFIX_PATH:-}"
-    export QT_PLUGIN_PATH="${pkgs.qt6.qtbase}/lib/qt-6/plugins:${pkgs.qt6.qtbase}/lib/qt6/plugins:''${QT_PLUGIN_PATH:-}"
-    export LD_LIBRARY_PATH="${pkgs.lib.makeLibraryPath runtimeLibs}:''${LD_LIBRARY_PATH:-}"
-
-    if [ -z "''${KYTY_SHELL_QUIET:-}" ]; then
-      echo "KytyPS5 dev shell"
-      echo "  cmake -S . -B _Build/linux -G Ninja -DCMAKE_BUILD_TYPE=Release \\"
-      echo "    -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++"
-      echo "  cmake --build _Build/linux --target launcher --parallel"
-      echo "  cmake --install _Build/linux --prefix _Build/linux/install"
-    fi
-  '';
-}
@@ -1,4 +0,0 @@
-let
-  pkgs = import <nixpkgs> { };
-in
-import ./nix/devshell.nix { inherit pkgs; }
@@ -12,23 +12,9 @@ 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
 )

@@ -40,13 +26,7 @@ target_link_libraries(common
 		cpuinfo
 		kyty_git_version
 		spdlog::spdlog
-		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})
@@ -1,112 +0,0 @@
-#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
@@ -1,23 +0,0 @@
-#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_ */
@@ -1,25 +0,0 @@
-// SPDX-FileCopyrightText: 2014 Jannik Vogel <email@jannikvogel.de>
-// SPDX-License-Identifier: CC0-1.0
-
-#pragma once
-
-#include <cstddef>
-#include <type_traits>
-
-namespace Common {
-
-template <typename T>
-[[nodiscard]] constexpr T AlignUp(T value, std::size_t size) {
-	static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
-	auto mod{static_cast<T>(value % size)};
-	value -= mod;
-	return static_cast<T>(mod == T{0} ? value : value + size);
-}
-
-template <typename T>
-[[nodiscard]] constexpr T AlignDown(T value, std::size_t size) {
-	static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
-	return static_cast<T>(value - value % size);
-}
-
-} // namespace Common
@@ -1,397 +0,0 @@
-#include "common/archive.h"
-
-#include "common/stringUtils.h"
-
-#include <algorithm>
-#include <condition_variable>
-#include <cstring>
-#include <mutex>
-#include <optional>
-#include <string_view>
-#include <thread>
-#include <unordered_map>
-#include <utility>
-#include <zarchive/zarchivereader.h>
-
-// POSIX hosts and MinGW's pthread-backed libstdc++ have cancellable condition waits.
-// MSVC/ClangCL and MinGW's native Win32 threading backend do not use pthread waits.
-#if !defined(_WIN32) || defined(_GLIBCXX_GCC_GTHR_POSIX_H)
-#include <pthread.h>
-#define KYTY_ARCHIVE_PTHREAD_CANCELLATION
-#endif
-
-namespace Common {
-
-// Backends expose immutable metadata and offset-based reads. Cursor management, path routing,
-// reader lifetime and the host-stack worker are shared by every archive format.
-class ArchiveReader {
-public:
-	struct Entry {
-		uint64_t id;
-		uint64_t size;
-		bool     is_file;
-	};
-
-	virtual ~ArchiveReader()                                                       = default;
-	virtual std::optional<Entry>        Find(std::string_view member)              = 0;
-	virtual std::vector<File::DirEntry> List(std::string_view member)              = 0;
-	virtual uint64_t Read(uint64_t id, uint64_t offset, uint32_t size, void* data) = 0;
-};
-
-namespace {
-
-class ZArchiveReaderBackend final: public ArchiveReader {
-public:
-	explicit ZArchiveReaderBackend(std::unique_ptr<ZArchiveReader> reader)
-	    : m_reader(std::move(reader)) {}
-
-	std::optional<Entry> Find(std::string_view member) override {
-		const auto node = m_reader->LookUp(member);
-		if (node == ZARCHIVE_INVALID_NODE) {
-			return {};
-		}
-		return Entry {node, m_reader->GetFileSize(node), m_reader->IsFile(node)};
-	}
-
-	std::vector<File::DirEntry> List(std::string_view member) override {
-		const auto node = m_reader->LookUp(member);
-		if (!m_reader->IsDirectory(node)) {
-			return {};
-		}
-		const auto count = m_reader->GetDirEntryCount(node);
-		if (count > (1u << 20u)) {
-			return {};
-		}
-		std::vector<File::DirEntry> result;
-		result.reserve(count);
-		for (uint32_t index = 0; index < count; ++index) {
-			ZArchiveReader::DirEntry entry {};
-			if (m_reader->GetDirEntry(node, index, entry)) {
-				result.push_back({std::string(entry.name), entry.isFile});
-			}
-		}
-		return result;
-	}
-
-	uint64_t Read(uint64_t id, uint64_t offset, uint32_t size, void* data) override {
-		// ZArchiveReader already serializes access to its stream and decompression cache.
-		return m_reader->ReadFromFile(static_cast<ZArchiveNodeHandle>(id), offset, size, data);
-	}
-
-private:
-	std::unique_ptr<ZArchiveReader> m_reader;
-};
-
-std::shared_ptr<ArchiveReader> OpenZArchive(const std::filesystem::path& path) {
-	auto reader = std::unique_ptr<ZArchiveReader>(ZArchiveReader::OpenFromFile(path));
-	return reader ? std::make_shared<ZArchiveReaderBackend>(std::move(reader)) : nullptr;
-}
-
-struct ArchiveFormat {
-	std::string_view extension;
-	std::shared_ptr<ArchiveReader> (*open)(const std::filesystem::path&);
-};
-
-constexpr ArchiveFormat Formats[] = {{".zar", OpenZArchive}};
-using NativeView                  = std::basic_string_view<std::filesystem::path::value_type>;
-
-const ArchiveFormat* FindFormat(NativeView path) {
-	for (const auto& format: Formats) {
-		if (path.size() < format.extension.size()) {
-			continue;
-		}
-		const auto extension = path.substr(path.size() - format.extension.size());
-		if (std::equal(
-		        extension.begin(), extension.end(), format.extension.begin(),
-		        [](auto a, char b) { return (a >= 'A' && a <= 'Z' ? a + ('a' - 'A') : a) == b; })) {
-			return &format;
-		}
-	}
-	return nullptr;
-}
-
-size_t FindMarker(NativeView path) {
-	// Native files use this check on every operation. The usual path has no marker and allocates
-	// nothing.
-	for (auto marker = path.find('!'); marker != NativeView::npos;
-	     marker      = path.find('!', marker + 1)) {
-		if ((marker + 1 == path.size() || path[marker + 1] == '/' || path[marker + 1] == '\\') &&
-		    FindFormat(path.substr(0, marker)) != nullptr) {
-			return marker;
-		}
-	}
-	return NativeView::npos;
-}
-
-struct ParsedPath {
-	std::filesystem::path archive;
-	std::string           member;
-};
-
-std::optional<ParsedPath> ParsePath(const std::filesystem::path& path) {
-	const auto& native = path.native();
-	const auto  marker = FindMarker(native);
-	if (marker == NativeView::npos) {
-		return {};
-	}
-	ParsedPath parsed {.archive = std::filesystem::path(native.substr(0, marker))};
-	auto       member = PathToGenericString(std::filesystem::path(native.substr(marker + 1)));
-	std::replace(member.begin(), member.end(), '\\', '/');
-	std::string_view remaining = member;
-	while (!remaining.empty()) {
-		const auto separator = remaining.find('/');
-		const auto component = remaining.substr(0, separator);
-		remaining.remove_prefix(separator == std::string_view::npos ? remaining.size() : separator + 1);
-		if (component.empty() || component == ".") {
-			continue;
-		}
-		if (component == "..") {
-			if (parsed.member.empty()) {
-				return {};
-			}
-			const auto separator = parsed.member.rfind('/');
-			parsed.member.resize(separator == std::string::npos ? 0 : separator);
-		} else {
-			if (!parsed.member.empty()) {
-				parsed.member += '/';
-			}
-			parsed.member += component;
-		}
-	}
-	return parsed;
-}
-
-std::mutex                                                              g_readers_mutex;
-std::unordered_map<std::filesystem::path, std::weak_ptr<ArchiveReader>> g_readers;
-
-// Guest stacks can be only 64 KiB. Decompress on an ordinary host stack, then copy into guest
-// memory on the caller so GPU-tracked writes use its fault handler. A single worker bounds host
-// threads and avoids duplicating the archive's own block cache. Requests live on waiting callers.
-class ArchiveIoThread {
-public:
-	static ArchiveIoThread& Instance() {
-		// Guest exit can run static destructors while other guest threads are still reading.
-		// Keep the worker alive until process termination, as with the guest threads themselves.
-		static auto* instance = new ArchiveIoThread;
-		return *instance;
-	}
-
-	uint64_t Read(ArchiveReader& reader, uint64_t id, uint64_t offset, uint32_t size, void* data) {
-		Request          request {reader, id, offset, size, data};
-		std::unique_lock lock(m_mutex);
-		if (m_last != nullptr) {
-			m_last->next = &request;
-		} else {
-			m_first = &request;
-		}
-		m_last = &request;
-		m_wake.notify_one();
-		request.ready.wait(lock, [&] { return request.done; });
-		return request.result;
-	}
-
-	KYTY_CLASS_NO_COPY(ArchiveIoThread);
-
-private:
-	struct Request {
-		ArchiveReader&          reader;
-		uint64_t                id;
-		uint64_t                offset;
-		uint32_t                size;
-		void*                   data;
-		Request*                next   = nullptr;
-		uint64_t                result = 0;
-		bool                    done   = false;
-		std::condition_variable ready {};
-	};
-
-	ArchiveIoThread() {
-		std::thread([this] { Loop(); }).detach();
-	}
-
-	void Loop() {
-		for (;;) {
-			Request* request;
-			{
-				std::unique_lock lock(m_mutex);
-				m_wake.wait(lock, [this] { return m_first != nullptr; });
-				request = m_first;
-				m_first = request->next;
-				if (m_first == nullptr) {
-					m_last = nullptr;
-				}
-			}
-			const auto result =
-			    request->reader.Read(request->id, request->offset, request->size, request->data);
-			{
-				std::lock_guard lock(m_mutex);
-				request->result = result;
-				request->done   = true;
-				// Notify before releasing the mutex: the waiting caller owns the condition
-				// variable.
-				request->ready.notify_one();
-			}
-		}
-	}
-
-	std::mutex              m_mutex;
-	std::condition_variable m_wake;
-	Request*                m_first = nullptr;
-	Request*                m_last  = nullptr;
-};
-
-} // namespace
-
-struct ArchiveFile::Private {
-	std::shared_ptr<ArchiveReader> reader;
-	ArchiveReader::Entry           entry;
-	uint64_t                       position = 0;
-};
-
-ArchiveFile::ArchiveFile(std::unique_ptr<Private> p): m_p(std::move(p)) {}
-ArchiveFile::~ArchiveFile() = default;
-
-uint64_t ArchiveFile::Size() const {
-	return m_p->entry.size;
-}
-uint64_t ArchiveFile::Tell() const {
-	return m_p->position;
-}
-bool ArchiveFile::Seek(uint64_t offset) {
-	m_p->position = offset;
-	return true;
-}
-
-void ArchiveFile::Read(void* data, uint32_t size, uint32_t* bytes_read) {
-#if defined(KYTY_ARCHIVE_PTHREAD_CANCELLATION)
-	// A pending cancellation must not destroy the waiting request or its TLS buffer while the
-	// worker still uses them. Restore the caller's state only after the copy is complete.
-	int cancellation_state = PTHREAD_CANCEL_ENABLE;
-	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cancellation_state);
-#endif
-	constexpr uint32_t                chunk_size = 1u << 20u;
-	thread_local std::vector<uint8_t> chunk;
-	uint32_t                          read = 0;
-	if (data != nullptr && size != 0 && m_p->position < Size()) {
-		const auto requested =
-		    static_cast<uint32_t>(std::min<uint64_t>(size, Size() - m_p->position));
-		if (chunk.size() < std::min(chunk_size, requested)) {
-			chunk.resize(std::min(chunk_size, requested));
-		}
-		while (read < requested) {
-			const auto step = std::min(chunk_size, requested - read);
-			const auto got  = ArchiveIoThread::Instance().Read(*m_p->reader, m_p->entry.id,
-			                                                   m_p->position, step, chunk.data());
-			if (got == 0 || got > step) {
-				break;
-			}
-			std::memcpy(static_cast<uint8_t*>(data) + read, chunk.data(), got);
-			read += static_cast<uint32_t>(got);
-			m_p->position += got;
-			if (got < step) {
-				break;
-			}
-		}
-	}
-	if (bytes_read != nullptr) {
-		*bytes_read = read;
-	}
-#if defined(KYTY_ARCHIVE_PTHREAD_CANCELLATION)
-	pthread_setcancelstate(cancellation_state, nullptr);
-#endif
-}
-
-std::filesystem::path MakeArchivePath(const std::filesystem::path& archive,
-                                      const std::filesystem::path& member) {
-	auto root = archive;
-	root += "!";
-	return member.empty() ? root : root / member.relative_path();
-}
-
-bool IsSupportedArchive(const std::filesystem::path& path) {
-	return FindFormat(path.native()) != nullptr;
-}
-
-bool IsArchivePath(const std::filesystem::path& path) {
-	return FindMarker(path.native()) != NativeView::npos;
-}
-
-std::filesystem::path GetArchiveHostPath(const std::filesystem::path& path) {
-	const auto marker = FindMarker(path.native());
-	return marker == NativeView::npos ? std::filesystem::path {}
-	                                  : std::filesystem::path(path.native().substr(0, marker));
-}
-
-std::shared_ptr<ArchiveReader> OpenArchive(const std::filesystem::path& path) {
-	const auto  archive = IsArchivePath(path) ? GetArchiveHostPath(path) : path;
-	const auto* format  = FindFormat(archive.native());
-	if (format == nullptr) {
-		return {};
-	}
-	std::error_code error;
-	auto            key = std::filesystem::absolute(archive, error);
-	if (error) {
-		return {};
-	}
-	{
-		std::lock_guard lock(g_readers_mutex);
-		if (auto it = g_readers.find(key); it != g_readers.end()) {
-			if (auto reader = it->second.lock()) {
-				return reader;
-			}
-		}
-	}
-	// Do not hold the cache mutex while opening an unrelated archive from disk.
-	auto reader = format->open(archive);
-	if (reader == nullptr) {
-		return {};
-	}
-	std::lock_guard lock(g_readers_mutex);
-	std::erase_if(g_readers, [](const auto& entry) { return entry.second.expired(); });
-	auto& cached = g_readers[key];
-	if (auto existing = cached.lock()) {
-		return existing;
-	}
-	cached = reader;
-	return reader;
-}
-
-std::optional<File::Info> GetArchiveInfo(const std::filesystem::path& path) {
-	const auto parsed = ParsePath(path);
-	if (parsed) {
-		if (auto reader = OpenArchive(parsed->archive)) {
-			if (auto entry = reader->Find(parsed->member)) {
-				return File::Info {entry->is_file, entry->size};
-			}
-		}
-	}
-	return {};
-}
-
-std::vector<File::DirEntry> GetArchiveDirEntries(const std::filesystem::path& path) {
-	const auto parsed = ParsePath(path);
-	if (parsed) {
-		if (auto reader = OpenArchive(parsed->archive)) {
-			return reader->List(parsed->member);
-		}
-	}
-	return {};
-}
-
-std::unique_ptr<ArchiveFile> OpenArchiveFile(const std::filesystem::path& path) {
-	auto parsed = ParsePath(path);
-	if (!parsed) {
-		return {};
-	}
-	auto       reader = OpenArchive(parsed->archive);
-	const auto entry  = reader ? reader->Find(parsed->member) : std::nullopt;
-	if (!entry || !entry->is_file) {
-		return {};
-	}
-	auto p     = std::make_unique<ArchiveFile::Private>();
-	p->reader  = std::move(reader);
-	p->entry   = *entry;
-	return std::unique_ptr<ArchiveFile>(new ArchiveFile(std::move(p)));
-}
-
-} // namespace Common
@@ -1,50 +0,0 @@
-#ifndef KYTY_COMMON_ARCHIVE_H_
-#define KYTY_COMMON_ARCHIVE_H_
-
-#include "common/file.h"
-
-#include <cstdint>
-#include <filesystem>
-#include <memory>
-#include <vector>
-
-namespace Common {
-
-class ArchiveReader;
-
-class ArchiveFile {
-public:
-	~ArchiveFile();
-
-	[[nodiscard]] uint64_t Size() const;
-	[[nodiscard]] uint64_t Tell() const;
-	bool                   Seek(uint64_t offset);
-	void                   Read(void* data, uint32_t size, uint32_t* bytes_read);
-
-	KYTY_CLASS_NO_COPY(ArchiveFile);
-
-private:
-	struct Private;
-	explicit ArchiveFile(std::unique_ptr<Private> p);
-	std::unique_ptr<Private> m_p;
-
-	friend std::unique_ptr<ArchiveFile> OpenArchiveFile(const std::filesystem::path& path);
-};
-
-// Virtual paths use "archive.ext!/member" and retain native host-path encoding.
-[[nodiscard]] std::filesystem::path       MakeArchivePath(const std::filesystem::path& archive,
-                                                          const std::filesystem::path& member = {});
-[[nodiscard]] bool                        IsSupportedArchive(const std::filesystem::path& path);
-[[nodiscard]] bool                        IsArchivePath(const std::filesystem::path& path);
-[[nodiscard]] std::optional<File::Info>   GetArchiveInfo(const std::filesystem::path& path);
-[[nodiscard]] std::vector<File::DirEntry> GetArchiveDirEntries(const std::filesystem::path& path);
-[[nodiscard]] std::filesystem::path       GetArchiveHostPath(const std::filesystem::path& path);
-[[nodiscard]] std::unique_ptr<ArchiveFile> OpenArchiveFile(const std::filesystem::path& path);
-
-// Retain this handle while a mount or metadata scan is active to reuse the index and block cache.
-// Accepts either a host archive filename or a virtual path inside the archive.
-[[nodiscard]] std::shared_ptr<ArchiveReader> OpenArchive(const std::filesystem::path& path);
-
-} // namespace Common
-
-#endif /* KYTY_COMMON_ARCHIVE_H_ */
@@ -1,5 +1,6 @@
 #include "common/assert.h"

+#include "common/debug.h"
 #include "common/logging/log.h"
 #include "common/subsystems.h"
 #include "kytyGitVersion.h"
@@ -11,10 +12,25 @@

 namespace Common {

+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS && KYTY_BUILD == KYTY_BUILD_DEBUG &&                    \
+    KYTY_COMPILER == KYTY_COMPILER_CLANG
+constexpr int PRINT_STACK_FROM = 4;
+#else
+constexpr int PRINT_STACK_FROM = 2;
+#endif
+
 static std::string BuildFatalReport(const char* title, std::string_view text, const char* file,
                                    int line) {
-	return fmt::format("--- Build ---\n{}\n{}\n{} in {}:{}\n", KYTY_BUILD_LABEL, title, text, file,
-	                   line);
+	DebugStack stack;
+	DebugStack::Trace(&stack);
+
+	std::string report = "--- Build ---\n" KYTY_BUILD_LABEL "\n--- Stack Trace ---\n";
+	for (int i = PRINT_STACK_FROM; i < stack.depth; i++) {
+		report += fmt::format("[{}] {:016x}\n", i - PRINT_STACK_FROM,
+		                      static_cast<uint64_t>(stack.GetAddr(i)));
+	}
+	report += fmt::format("{}\n{} in {}:{}\n", title, text, file, line);
+	return report;
 }

 static int DbgReport(const char* title, std::string_view text, const char* file, int line) {
@@ -43,7 +59,6 @@ int DbgExitHandler(const char* file, int line, fmt::text_style style, std::strin
 }

 void DbgExit(int status) {
-	Subsystems::EmergencyShutdownActive();
 	std::fflush(nullptr);
 	std::_Exit(status);
 }
@@ -29,7 +29,11 @@ void DbgExit(int status);

 } // namespace Common

+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS || KYTY_PLATFORM == KYTY_PLATFORM_LINUX
 #define EXIT_HALT() (Common::DbgExit(321), 1)
+#else
+#define EXIT_HALT() (std::_Exit(321), 1)
+#endif

 #ifndef KYTY_FINAL
 #define EXIT_IF(x)                                                                                 \
@@ -0,0 +1,166 @@
+#ifndef KYTY_COMMON_BYTEBUFFER_H_
+#define KYTY_COMMON_BYTEBUFFER_H_
+
+#include "common/assert.h"
+#include "common/common.h"
+
+#include <algorithm>
+#include <cstddef> // IWYU pragma: export
+#include <cstring>
+#include <utility>
+#include <vector>
+
+namespace Common {
+
+using Byte = std::byte;
+
+class ByteBuffer {
+public:
+	using DataType = std::vector<Byte>;
+
+	static constexpr uint32_t INVALID_INDEX = static_cast<uint32_t>(-1);
+
+	using iterator       = DataType::iterator;
+	using const_iterator = DataType::const_iterator;
+
+	ByteBuffer()                  = default;
+	ByteBuffer(const ByteBuffer&) = default;
+	ByteBuffer(ByteBuffer&&)      = default;
+
+	ByteBuffer& operator=(const ByteBuffer&) = default;
+	ByteBuffer& operator=(ByteBuffer&&)      = default;
+
+	explicit ByteBuffer(uint32_t size): m_data(size) {}
+
+	ByteBuffer(std::initializer_list<uint8_t> list) {
+		for (const uint8_t& e: list) {
+			m_data.emplace_back(static_cast<Byte>(e));
+		}
+	}
+
+	explicit ByteBuffer(const void* buf, uint32_t size)
+	    : ByteBuffer(size) // @suppress("Ambiguous problem")
+	{
+		EXIT_IF(buf == nullptr && size != 0);
+
+		if (size != 0) {
+			std::memcpy(m_data.data(), buf, size);
+		}
+	}
+
+	[[nodiscard]] uint32_t Size() const { return static_cast<uint32_t>(m_data.size()); }
+	[[nodiscard]] bool     IsEmpty() const { return m_data.empty(); }
+
+	void Clear() { m_data.clear(); }
+
+	void Add(const Byte& val) { m_data.push_back(val); }
+	void Add(Byte&& val) { m_data.push_back(std::move(val)); }
+
+	void Add(const Byte* val, uint32_t num) {
+		EXIT_IF(val == nullptr && num != 0);
+		m_data.insert(m_data.end(), val, val + num);
+	}
+
+	void Add(const ByteBuffer& v) {
+		if (this == &v) {
+			const ByteBuffer copy(v);
+			Add(copy.GetDataConst(), copy.Size());
+			return;
+		}
+		Add(v.GetDataConst(), v.Size());
+	}
+
+	void InsertAt(uint32_t index, const Byte& val) {
+		EXIT_IF(index > Size());
+		m_data.insert(m_data.begin() + index, val);
+	}
+
+	void InsertAt(uint32_t index, Byte&& val) {
+		EXIT_IF(index > Size());
+		m_data.insert(m_data.begin() + index, std::move(val));
+	}
+
+	[[nodiscard]] uint32_t Find(const Byte& t) const {
+		const auto it = std::find(m_data.begin(), m_data.end(), t);
+		return (it == m_data.end() ? INVALID_INDEX
+		                           : static_cast<uint32_t>(std::distance(m_data.begin(), it)));
+	}
+
+	[[nodiscard]] bool Contains(const Byte& t) const { return Find(t) != INVALID_INDEX; }
+
+	bool Remove(const Byte& t) {
+		const auto it = std::find(m_data.begin(), m_data.end(), t);
+		if (it == m_data.end()) {
+			return false;
+		}
+		m_data.erase(it);
+		return true;
+	}
+
+	bool RemoveAt(uint32_t index, uint32_t count = 1) {
+		if (index >= Size() || count == 0) {
+			return false;
+		}
+
+		const uint32_t erase_count = std::min(count, Size() - index);
+		m_data.erase(m_data.begin() + index, m_data.begin() + index + erase_count);
+		return true;
+	}
+
+	[[nodiscard]] bool IndexValid(uint32_t index) const { return index < Size(); }
+
+	Byte& operator[](uint32_t index) {
+		EXIT_IF(index >= Size());
+		return m_data[index];
+	}
+
+	const Byte& operator[](uint32_t index) const {
+		EXIT_IF(index >= Size());
+		return m_data[index];
+	}
+
+	[[nodiscard]] const Byte& At(uint32_t index) const {
+		EXIT_IF(index >= Size());
+		return m_data[index];
+	}
+
+	Byte*                     GetData() { return m_data.data(); }
+	[[nodiscard]] const Byte* GetData() const { return m_data.data(); }
+	[[nodiscard]] const Byte* GetDataConst() const { return m_data.data(); }
+
+	void Sort() {
+		std::sort(m_data.begin(), m_data.end(), [](Byte a, Byte b) {
+			return std::to_integer<uint8_t>(a) < std::to_integer<uint8_t>(b);
+		});
+	}
+
+	template <typename OP>
+	void Sort(OP&& comp_func) {
+		std::sort(m_data.begin(), m_data.end(), std::forward<OP>(comp_func));
+	}
+
+	bool operator==(const ByteBuffer& s) const { return m_data == s.m_data; }
+	bool operator!=(const ByteBuffer& s) const { return !(*this == s); }
+
+	iterator begin() { return m_data.begin(); } // NOLINT(readability-identifier-naming)
+	iterator end() { return m_data.end(); }     // NOLINT(readability-identifier-naming)
+	[[nodiscard]] const_iterator begin() const {
+		return m_data.begin();
+	} // NOLINT(readability-identifier-naming)
+	[[nodiscard]] const_iterator end() const {
+		return m_data.end();
+	} // NOLINT(readability-identifier-naming)
+	[[nodiscard]] const_iterator cbegin() const {
+		return m_data.cbegin();
+	} // NOLINT(readability-identifier-naming)
+	[[nodiscard]] const_iterator cend() const {
+		return m_data.cend();
+	} // NOLINT(readability-identifier-naming)
+
+private:
+	DataType m_data;
+};
+
+} // namespace Common
+
+#endif /* KYTY_COMMON_BYTEBUFFER_H_ */
@@ -1,7 +1,20 @@
 #include "common/debug.h"

+#include "common/platform/sysDbg.h"
+
 namespace Common {

+void DebugStack::Print(int from, [[maybe_unused]] bool with_name) const {
+	for (int i = from; i < depth; i++) {
+		printf("[%d] %016" PRIx64 "\n", i - from, static_cast<uint64_t>(GetAddr(i)));
+	}
+}
+
+void DebugStack::Trace(DebugStack* stack) {
+	stack->depth = DEBUG_MAX_STACK_DEPTH;
+	SysStackWalk(stack->stack.data(), &stack->depth);
+}
+
 std::string Debug::GetCompiler() {
 #if KYTY_COMPILER == KYTY_COMPILER_CLANG
 	return "clang";
@@ -24,4 +37,8 @@ std::string Debug::GetLinker() {
 #endif
 }

+std::string Debug::GetBitness() {
+	return "64";
+}
+
 } // namespace Common
@@ -2,16 +2,42 @@
 #define KYTY_COMMON_DEBUG_H_

 #include "common/common.h"
+#include "common/stringUtils.h"

-#include <string>
+#include <array>
+#include <cstring>

 namespace Common {

+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS && KYTY_BUILD == KYTY_BUILD_DEBUG &&                    \
+    KYTY_COMPILER == KYTY_COMPILER_CLANG
+constexpr int DEBUG_MAX_STACK_DEPTH = 20;
+#else
+constexpr int DEBUG_MAX_STACK_DEPTH = 15;
+#endif
+
 namespace Debug {
 std::string GetCompiler();
 std::string GetLinker();
+std::string GetBitness();
 } // namespace Debug

+struct DebugStack {
+	int                                      depth {0};
+	std::array<void*, DEBUG_MAX_STACK_DEPTH> stack {};
+
+	[[nodiscard]] uintptr_t GetAddr(int i) const { return reinterpret_cast<uintptr_t>(stack[i]); }
+
+	void Print(int from, bool with_name = true) const;
+
+	void CopyTo(DebugStack* s) const {
+		std::memcpy(s->stack.data(), stack.data(), sizeof(void*) * depth);
+		s->depth = depth;
+	}
+
+	static void Trace(DebugStack* stack);
+};
+
 } // namespace Common

 #endif /* KYTY_COMMON_DEBUG_H_ */
@@ -1,117 +0,0 @@
-#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,7 +1,6 @@
 #include "common/emulatorConfig.h"

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

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

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

@@ -25,11 +23,8 @@ void Load(const ConfigOptions& cfg) {
 	EXIT_IF(g_config == nullptr);
 	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() {
@@ -48,43 +43,6 @@ int32_t GetUserId() {
 	return g_config->user_id;
 }

-const std::string& GetAudioInputDevice() {
-	return g_config->audio_input_device;
-}
-
-const std::optional<ControllerColor>& GetControllerColor() {
-	return g_config->controller_color;
-}
-
-uint32_t GetControllerSpeakerVolume() {
-	return g_config->controller_speaker_volume;
-}
-
-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;
 }
@@ -97,22 +55,6 @@ bool FullscreenEnabled() {
 	return g_config->fullscreen_enabled;
 }

-bool HdrEnabled() {
-	return g_config->hdr_enabled;
-}
-
-bool HideCursorEnabled() {
-	return g_config->hide_cursor_enabled;
-}
-
-bool VrEnabled() {
-	return g_config->vr_enabled;
-}
-
-bool AmdCpuEnabled() {
-	return g_config->amd_cpu_enabled;
-}
-
 uint32_t GetVblankFrequency() {
 	return std::clamp(g_config->vblank_frequency, 30u, 360u);
 }
@@ -125,10 +67,6 @@ bool VulkanValidationEnabled() {
 	return g_config->vulkan_validation_enabled;
 }

-bool IsNetworkConnected() {
-	return g_config->network_connected;
-}
-
 bool ShaderValidationEnabled() {
 	return g_config->shader_validation_enabled;
 }
@@ -137,7 +75,7 @@ ShaderOptimizationType GetShaderOptimizationType() {
 	return g_config->shader_optimization_type;
 }

-LogDirection GetShaderLogDirection() {
+ShaderLogDirection GetShaderLogDirection() {
 	return g_config->shader_log_direction;
 }

@@ -157,7 +95,7 @@ bool GraphicsDebugDumpEnabled() {
 	return g_config->graphics_debug_dump_enabled;
 }

-LogDirection GetPrintfDirection() {
+OutputDirection GetPrintfDirection() {
 	return g_config->printf_direction;
 }

@@ -165,8 +103,8 @@ std::filesystem::path GetPrintfOutputFile() {
 	return g_config->printf_output_file;
 }

-bool ProfilerEnabled() {
-	return g_config->profiler_enabled;
+ProfilerDirection GetProfilerDirection() {
+	return g_config->profiler_direction;
 }

 bool SpirvDebugPrintfEnabled() {
@@ -185,30 +123,10 @@ bool ReadbackLinearImagesEnabled() {
 	return g_config->readback_linear_images;
 }

-bool SyncRawImageBuffersEnabled() {
-	return g_config->sync_raw_image_buffers;
-}
-
-bool TessellationEnabled() {
-	return g_config->tessellation_enabled;
-}
-
-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;
 }

-bool SkipNoticeScreen() {
-	return g_config->skip_notice_screen;
-}
-
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 bool RedZoneProtectionEnabled() {
 	return g_config->red_zone_protection_enabled;
@@ -219,8 +137,4 @@ const Keymap& GetKeymap() {
 	return g_config->keymap;
 }

-const std::vector<std::string>& GetGuestArguments() {
-	return g_config->guest_arguments;
-}
-
 } // namespace Config
@@ -4,10 +4,7 @@
 #include "common/common.h"

 #include <cstddef>
-#include <array>
 #include <filesystem>
-#include <limits>
-#include <optional>
 #include <string>
 #include <vector>

@@ -24,28 +21,25 @@ struct Lifecycle {

 enum class ShaderOptimizationType { None, Size, Performance };

-enum class LogDirection { Silent, Console, File };
+enum class ShaderLogDirection { Silent, Console, File };
+
+enum class ProfilerDirection { None, Network };
+
+enum class OutputDirection { Silent, Console, File };

 enum class PresentMode { Fifo, Mailbox, Immediate };

 using Keymap = std::vector<std::string>;
-using ControllerColor = std::array<uint8_t, 3>;

 constexpr uint32_t DEFAULT_CONSOLE_LANGUAGE = 1;
 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 <= MAX_USER_ID && user_id != USER_ID_EVERYONE &&
-	       user_id != USER_ID_SYSTEM;
+	return user_id >= 0 && user_id != USER_ID_EVERYONE && user_id != USER_ID_SYSTEM;
 }

 struct ConfigOptions {
@@ -53,51 +47,31 @@ struct ConfigOptions {
 	uint32_t               screen_height               = 720;
 	std::string            user_name                   = "Kyty";
 	int32_t                user_id                     = DEFAULT_USER_ID;
-	std::string            audio_input_device;
-	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;
+	PresentMode            present_mode                = PresentMode::Fifo;
 	int32_t                gpu_index                   = -1;
 	bool                   fullscreen_enabled          = false;
-	bool                   hdr_enabled                 = false;
-	bool                   hide_cursor_enabled         = false;
-	bool                   splash_enabled              = true;
-	bool                   vr_enabled                  = false;
-	bool                   amd_cpu_enabled             = false;
-	bool                   network_connected           = false;
 	uint32_t               vblank_frequency            = 60;
 	uint32_t               console_language            = DEFAULT_CONSOLE_LANGUAGE;
 	bool                   vulkan_validation_enabled   = false;
 	bool                   shader_validation_enabled   = false;
 	ShaderOptimizationType shader_optimization_type    = ShaderOptimizationType::None;
-	LogDirection           shader_log_direction        = LogDirection::Silent;
+	ShaderLogDirection     shader_log_direction        = ShaderLogDirection::Silent;
 	std::filesystem::path  shader_log_folder           = "_Shaders";
 	bool                   command_buffer_dump_enabled = false;
 	std::filesystem::path  command_buffer_dump_folder  = "_Buffers";
 	bool                   graphics_debug_dump_enabled = false;
-	LogDirection           printf_direction            = LogDirection::Silent;
+	OutputDirection        printf_direction            = OutputDirection::Silent;
 	std::filesystem::path  printf_output_file          = "_kyty.txt";
-	bool                   profiler_enabled            = false;
+	ProfilerDirection      profiler_direction          = ProfilerDirection::None;
 	bool                   spirv_debug_printf_enabled  = false;
 	bool                   gpu_assisted_validation_enabled = false;
 	bool                   renderdoc_enabled           = false;
 	bool                   readback_linear_images      = false;
-	bool                   sync_raw_image_buffers      = 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
 	bool red_zone_protection_enabled = false;
 #endif
 	Keymap keymap;
-	// Ordinary boots need a non-null argv[0]; --guest-exec supplies the caller's arguments.
-	std::vector<std::string> guest_arguments {""};
 };

 void Load(const ConfigOptions& cfg);
@@ -106,32 +80,16 @@ uint32_t GetScreenWidth();
 uint32_t GetScreenHeight();
 const std::string& GetUserName();
 int32_t  GetUserId();
-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();
-bool     HdrEnabled();
-bool     HideCursorEnabled();
-bool     VrEnabled();
-bool     AmdCpuEnabled();
-bool     IsNetworkConnected();
 uint32_t GetVblankFrequency();
 uint32_t GetConsoleLanguage();
 bool     VulkanValidationEnabled();

 bool                   ShaderValidationEnabled();
 ShaderOptimizationType GetShaderOptimizationType();
-LogDirection           GetShaderLogDirection();
+ShaderLogDirection     GetShaderLogDirection();
 std::filesystem::path  GetShaderLogFolder();

 bool                  CommandBufferDumpEnabled();
@@ -139,10 +97,10 @@ std::filesystem::path GetCommandBufferDumpFolder();

 bool GraphicsDebugDumpEnabled();

-LogDirection          GetPrintfDirection();
+OutputDirection       GetPrintfDirection();
 std::filesystem::path GetPrintfOutputFile();

-bool ProfilerEnabled();
+ProfilerDirection GetProfilerDirection();

 bool SpirvDebugPrintfEnabled();

@@ -150,18 +108,12 @@ bool GpuAssistedValidationEnabled();

 bool RenderDocEnabled();
 bool ReadbackLinearImagesEnabled();
-bool SyncRawImageBuffersEnabled();
-bool TessellationEnabled();
-bool TrophyEnabled();
-uint32_t GetTrophyDurationSeconds();
 bool PlayGoHackEnabled();
-bool SkipNoticeScreen();
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 bool RedZoneProtectionEnabled();
 #endif

 const Keymap& GetKeymap();
-const std::vector<std::string>& GetGuestArguments();

 } // namespace Config

@@ -1,6 +1,5 @@
 #include "common/file.h"

-#include "common/archive.h"
 #include "common/assert.h"
 #include "common/common.h"
 #include "common/platform/sysFileIO.h"
@@ -62,8 +61,7 @@ SysFileTimeStruct DateTimeToFileTimeUtc(const DateTime& date_time) {
 } // namespace

 struct File::FilePrivate {
-	sys_file_t*                  f;
-	std::unique_ptr<ArchiveFile> archive;
+	sys_file_t* f;
 };

 File::File(): m_p(std::make_unique<FilePrivate>()) {
@@ -71,7 +69,7 @@ File::File(): m_p(std::make_unique<FilePrivate>()) {
 }

 File::~File() {
-	Close();
+	EXIT_IF(m_p->f != nullptr);
 }

 File::File(const std::filesystem::path& name): m_p(std::make_unique<FilePrivate>()) {
@@ -87,15 +85,11 @@ File::File(const std::filesystem::path& name, Mode mode): m_p(std::make_unique<F
 }

 bool File::IsInvalid() const {
-	return m_p->f == nullptr && m_p->archive == nullptr;
+	return m_p->f == nullptr;
 }

 bool File::Create(const std::filesystem::path& name) {
-	EXIT_IF(!IsInvalid());
-
-	if (IsArchivePath(name)) {
-		return false;
-	}
+	EXIT_IF(m_p->f != nullptr);

 	m_file_name = name;

@@ -110,16 +104,9 @@ bool File::Create(const std::filesystem::path& name) {
 }

 bool File::Open(const std::filesystem::path& name, Mode mode) {
-	EXIT_IF(!IsInvalid());
+	EXIT_IF(m_p->f != nullptr);

 	m_file_name = name;
-	if (IsArchivePath(name)) {
-		if (mode != Mode::Read) {
-			return false;
-		}
-		m_p->archive = OpenArchiveFile(name);
-		return m_p->archive != nullptr;
-	}

 	switch (mode) {
 		case Mode::Read: m_p->f = SysFileOpenR(name); break;
@@ -137,7 +124,7 @@ bool File::Open(const std::filesystem::path& name, Mode mode) {
 }

 bool File::OpenInMem(void* buf, uint32_t buf_size) {
-	EXIT_IF(!IsInvalid());
+	EXIT_IF(m_p->f != nullptr);

 	m_p->f = SysFileOpen(static_cast<uint8_t*>(buf), buf_size);

@@ -149,8 +136,12 @@ bool File::OpenInMem(void* buf, uint32_t buf_size) {
 	return true;
 }

+bool File::OpenInMem(ByteBuffer& buf) {
+	return OpenInMem(buf.GetData(), buf.Size());
+}
+
 bool File::CreateInMem() {
-	EXIT_IF(!IsInvalid());
+	EXIT_IF(m_p->f != nullptr);

 	m_p->f = SysFileCreate();

@@ -163,7 +154,6 @@ bool File::CreateInMem() {
 }

 void File::Close() {
-	m_p->archive.reset();
 	if (m_p->f != nullptr) {
 		SysFileClose(m_p->f);
 		m_p->f = nullptr;
@@ -171,11 +161,7 @@ void File::Close() {
 }

 uint64_t File::Size() const {
-	EXIT_IF(IsInvalid());
-
-	if (m_p->archive != nullptr) {
-		return m_p->archive->Size();
-	}
+	EXIT_IF(m_p->f == nullptr);

 	if (m_p->f == nullptr) {
 		return 0;
@@ -185,76 +171,41 @@ uint64_t File::Size() const {
 }

 uint64_t File::Remaining() const {
-	EXIT_IF(IsInvalid());
+	EXIT_IF(m_p->f == nullptr);

-	const auto size     = Size();
-	const auto position = Tell();
-	return position < size ? size - position : 0;
+	return Size() - Tell();
 }

 uint64_t File::Size(const std::filesystem::path& name) {
-	if (IsArchivePath(name)) {
-		const auto info = GetArchiveInfo(name);
-		return info ? info->size : 0;
-	}
 	return SysFileSize(name);
 }

-std::optional<File::Info> File::GetInfo(const std::filesystem::path& name) {
-	if (IsArchivePath(name)) {
-		return GetArchiveInfo(name);
-	}
-	Info info {};
-	return SysFileGetInfo(name, &info.is_file, &info.size) ? std::optional(info) : std::nullopt;
-}
-
 bool File::Seek(uint64_t offset) {
-	EXIT_IF(IsInvalid());
-
-	if (m_p->archive != nullptr) {
-		return m_p->archive->Seek(offset);
-	}
+	EXIT_IF(m_p->f == nullptr);

 	return SysFileSeek(*m_p->f, offset);
 }

 bool File::Truncate(uint64_t size) {
-	EXIT_IF(IsInvalid());
-
-	if (m_p->archive != nullptr) {
-		return false;
-	}
+	EXIT_IF(m_p->f == nullptr);

 	return SysFileTruncate(*m_p->f, size);
 }

 bool File::Unlink() {
-	EXIT_IF(IsInvalid());
-
-	if (m_p->archive != nullptr) {
-		return false;
-	}
+	EXIT_IF(m_p->f == nullptr);

 	return SysFileUnlink(*m_p->f, m_file_name);
 }

 uint64_t File::Tell() const {
-	EXIT_IF(IsInvalid());
-
-	if (m_p->archive != nullptr) {
-		return m_p->archive->Tell();
-	}
+	EXIT_IF(m_p->f == nullptr);

 	return SysFileTell(*m_p->f);
 }

 void File::Read(void* data, uint32_t size, uint32_t* bytes_read) {
-	EXIT_IF(IsInvalid());
-
-	if (m_p->archive != nullptr) {
-		m_p->archive->Read(data, size, bytes_read);
-		return;
-	}
+	EXIT_IF(m_p->f == nullptr);

 	if (m_p->f != nullptr) {
 		SysFileRead(data, size, *m_p->f, bytes_read);
@@ -262,14 +213,7 @@ void File::Read(void* data, uint32_t size, uint32_t* bytes_read) {
 }

 void File::Write(const void* data, uint32_t size, uint32_t* bytes_written) {
-	EXIT_IF(IsInvalid());
-
-	if (m_p->archive != nullptr) {
-		if (bytes_written != nullptr) {
-			*bytes_written = 0;
-		}
-		return;
-	}
+	EXIT_IF(m_p->f == nullptr);

 	SysFileWrite(data, size, *m_p->f, bytes_written);
 }
@@ -305,120 +249,103 @@ void File::Printf(const char* format, ...) {
 	Write(s.data(), static_cast<uint32_t>(s.size()));
 }

-static std::filesystem::path WithoutTrailingSeparator(
-	const std::filesystem::path& path) {
-		if (!path.empty() && !path.has_filename() &&
-			path != path.root_path()) {
-			return path.parent_path();
-		}
-
-		return path;
-}
-
-
 bool File::IsDirectoryExisting(const std::filesystem::path& path) {
-	if (IsArchivePath(path)) {
-		const auto info = GetArchiveInfo(path);
-		return info && !info->is_file;
-	}
-	return SysFileIsDirectoryExisting(WithoutTrailingSeparator(path));
+	auto path_str = PathToGenericString(path);
+	return SysFileIsDirectoryExisting(
+	    Common::EndsWith(path_str, "/") ? Common::RemoveLast(path_str, 1) : path_str);
 }

 bool File::IsFileExisting(const std::filesystem::path& name) {
-	if (IsArchivePath(name)) {
-		const auto info = GetArchiveInfo(name);
-		return info && info->is_file;
-	}
 	return SysFileIsFileExisting(name);
 }

-bool File::CreateDirectory(const std::filesystem::path& path) {
-	if (IsArchivePath(path)) {
-		return false;
-	}
-    return SysFileCreateDirectory(
-        WithoutTrailingSeparator(path));
+bool File::CreateDirectory(
+    const std::filesystem::path& path) // @suppress("Member declaration not found")
+{
+	auto path_str = PathToGenericString(path);
+	return SysFileCreateDirectory(Common::EndsWith(path_str, "/") ? Common::RemoveLast(path_str, 1)
+	                                                              : path_str);
 }

 bool File::DeleteDirectory(const std::filesystem::path& path) {
-	if (IsArchivePath(path)) {
-		return false;
-	}
-    return SysFileDeleteDirectory(
-        WithoutTrailingSeparator(path));
+	auto path_str = PathToGenericString(path);
+	return SysFileDeleteDirectory(Common::EndsWith(path_str, "/") ? Common::RemoveLast(path_str, 1)
+	                                                              : path_str);
 }

 bool File::CreateDirectories(const std::filesystem::path& path) {
-	if (IsArchivePath(path)) {
-		return false;
+	std::string real_path = Common::ReplaceChar(PathToGenericString(path), '\\', '/');
+
+	std::vector<std::string> list = Common::Split(real_path, "/");
+
+	std::string p;
+
+	for (uint32_t si = 0; si < list.size(); si++) {
+		const std::string& s = list[si];
+
+		if (si != 0 || Common::StartsWith(real_path, "/")) {
+			p += "/";
+		}
+
+		p += s;
+
+		if (IsDirectoryExisting(p)) {
+			continue;
+		}
+
+		if (!CreateDirectory(p)) // @suppress("Invalid arguments")
+		{
+			return false;
+		}
 	}
-    const auto normalized_path =
-        WithoutTrailingSeparator(path);

-    auto current_path = normalized_path.root_path();
-
-    for (const auto& component:
-         normalized_path.relative_path()) {
-        current_path /= component;
-
-        if (IsDirectoryExisting(current_path)) {
-            continue;
-        }
-
-        if (!CreateDirectory(current_path)) {
-            return false;
-        }
-    }
-
-    return true;
+	return true;
 }

 bool File::DeleteDirectories(const std::filesystem::path& path) {
-	if (IsArchivePath(path)) {
-		return false;
+	std::string real_path = Common::ReplaceChar(PathToGenericString(path), '\\', '/');
+
+	std::vector<std::string> list = Common::Split(real_path, "/");
+
+	std::string              p;
+	std::vector<std::string> list2;
+
+	for (uint32_t si = 0; si < list.size(); si++) {
+		const std::string& s = list[si];
+
+		if (si != 0 || Common::StartsWith(real_path, "/")) {
+			p += "/";
+		}
+
+		p += s;
+
+		list2.push_back(p);
 	}
-    const auto normalized_path =
-        WithoutTrailingSeparator(path);

-    std::vector<std::filesystem::path> directories;
-    auto current_path = normalized_path.root_path();
+	uint32_t num = list2.size();

-    for (const auto& component:
-         normalized_path.relative_path()) {
-        current_path /= component;
-        directories.push_back(current_path);
-    }
+	for (uint32_t si = num - 1; si < num; si--) {
+		if (!DeleteDirectory(list2[si])) {
+			return false;
+		}
+	}

-    for (auto it = directories.rbegin();
-         it != directories.rend(); ++it) {
-        if (!DeleteDirectory(*it)) {
-            return false;
-        }
-    }
-
-    return true;
+	return true;
 }

 bool File::DeleteFile(
    const std::filesystem::path& name) // @suppress("Member declaration not found")
 {
-	if (IsArchivePath(name)) {
-		return false;
-	}
 	return SysFileDeleteFile(name);
 }

 bool File::Flush() {
-	EXIT_IF(IsInvalid());
-
-	if (m_p->archive != nullptr) {
-		return true;
-	}
+	EXIT_IF(m_p->f == nullptr);

 	return SysFileFlush(*m_p->f);
 }

-std::vector<std::byte> File::ReadWholeBuffer() {
+ByteBuffer File::ReadWholeBuffer() {
 	EXIT_IF(IsInvalid());
 	EXIT_IF(Tell() != 0);

@@ -426,18 +353,26 @@ std::vector<std::byte> File::ReadWholeBuffer() {

 	EXIT_IF((s >> 32u) != 0);

-	const auto            read_size = static_cast<uint32_t>(s);
-	std::vector<std::byte> buf(read_size);
+	ByteBuffer buf(s);

-	Read(buf.data(), read_size);
+	Read(buf.GetData(), s);

 	return buf;
 }

+ByteBuffer File::Read(uint32_t size) {
+	ByteBuffer buf(size);
+	uint32_t   b = 0;
+	Read(buf.GetData(), size, &b);
+	buf.RemoveAt(b, size - b);
+	return buf;
+}
+
+void File::Write(const ByteBuffer& buf, uint32_t* bytes_written) {
+	Write(buf.GetDataConst(), buf.Size(), bytes_written);
+}
+
 DateTime File::GetLastAccessTimeUTC(const std::filesystem::path& name) {
-	if (IsArchivePath(name)) {
-		return GetLastAccessTimeUTC(GetArchiveHostPath(name));
-	}
 	SysTimeStruct t {};
 	SysFileToSystemTimeUtc(SysFileGetLastAccessTimeUtc(name), t);

@@ -449,9 +384,6 @@ DateTime File::GetLastAccessTimeUTC(const std::filesystem::path& name) {
 }

 DateTime File::GetLastWriteTimeUTC(const std::filesystem::path& name) {
-	if (IsArchivePath(name)) {
-		return GetLastWriteTimeUTC(GetArchiveHostPath(name));
-	}
 	SysTimeStruct t {};
 	SysFileToSystemTimeUtc(SysFileGetLastWriteTimeUtc(name), t);

@@ -466,10 +398,6 @@ void File::GetLastAccessAndWriteTimeUTC(const std::filesystem::path& name, DateT
                                        DateTime* write) {
 	EXIT_IF(access == nullptr);
 	EXIT_IF(write == nullptr);
-	if (IsArchivePath(name)) {
-		GetLastAccessAndWriteTimeUTC(GetArchiveHostPath(name), access, write);
-		return;
-	}

 	SysTimeStruct     at {};
 	SysTimeStruct     wt {};
@@ -496,12 +424,7 @@ void File::GetLastAccessAndWriteTimeUTC(DateTime* access, DateTime* write) {
 	EXIT_IF(access == nullptr);
 	EXIT_IF(write == nullptr);

-	EXIT_IF(IsInvalid());
-
-	if (m_p->archive != nullptr) {
-		GetLastAccessAndWriteTimeUTC(m_file_name, access, write);
-		return;
-	}
+	EXIT_IF(m_p->f == nullptr);

 	if (m_p->f == nullptr) {
 		*access = DateTime();
@@ -531,35 +454,68 @@ void File::GetLastAccessAndWriteTimeUTC(DateTime* access, DateTime* write) {
 }

 bool File::SetLastAccessTimeUTC(const std::filesystem::path& name, const DateTime& dt) {
-	if (IsArchivePath(name)) {
-		return false;
-	}
 	auto f = DateTimeToFileTimeUtc(dt);
 	return SysFileSetLastAccessTimeUtc(name, f);
 }

 bool File::SetLastWriteTimeUTC(const std::filesystem::path& name, const DateTime& dt) {
-	if (IsArchivePath(name)) {
-		return false;
-	}
 	auto f = DateTimeToFileTimeUtc(dt);
 	return SysFileSetLastWriteTimeUtc(name, f);
 }

 bool File::SetLastAccessAndWriteTimeUTC(const std::filesystem::path& name, const DateTime& access,
                                        const DateTime& write) {
-	if (IsArchivePath(name)) {
-		return false;
-	}
 	auto af = DateTimeToFileTimeUtc(access);
 	auto wf = DateTimeToFileTimeUtc(write);
 	return SysFileSetLastAccessAndWriteTimeUtc(name, af, wf);
 }

-std::vector<File::DirEntry> File::GetDirEntries(const std::filesystem::path& path) {
-	if (IsArchivePath(path)) {
-		return GetArchiveDirEntries(path);
+std::vector<File::FindInfo> File::FindFiles(const std::filesystem::path& path) {
+	std::vector<sys_file_find_t> files;
+
+	SysFileFindFiles(path, files);
+
+	auto     path_str = PathToGenericString(path);
+	uint32_t len      = static_cast<uint32_t>(path_str.size());
+
+	if (!Common::EndsWith(path_str, "/") && !Common::EndsWith(path_str, "\\")) {
+		len++;
 	}
+
+	std::vector<File::FindInfo> ret;
+	ret.reserve(files.size());
+
+	for (const auto& f: files) {
+		File::FindInfo r {};
+
+		r.path_with_name     = f.path_with_name;
+		r.rel_path_with_name = Common::Mid(PathToGenericString(f.path_with_name), len);
+		r.size               = f.size;
+
+		SysTimeStruct at {};
+		SysTimeStruct wt {};
+
+		SysFileToSystemTimeUtc(f.last_access_time, at);
+		SysFileToSystemTimeUtc(f.last_write_time, wt);
+
+		if (!at.is_invalid && !wt.is_invalid) {
+			r.last_access_time = DateTime(Date(at.Year, at.Month, at.Day),
+			                              Time(at.Hour, at.Minute, at.Second, at.Milliseconds));
+			r.last_write_time  = DateTime(Date(wt.Year, wt.Month, wt.Day),
+			                              Time(wt.Hour, wt.Minute, wt.Second, wt.Milliseconds));
+		}
+
+		// printf("%s, %s, %" PRIu64", %s, %s\n", r.path_with_name.c_str(),
+		// r.rel_path_with_name.c_str(), r.size, r.last_access_time.ToString().c_str(),
+		// r.last_write_time.ToString().c_str());
+
+		ret.push_back(std::move(r));
+	}
+
+	return ret;
+}
+
+std::vector<File::DirEntry> File::GetDirEntries(const std::filesystem::path& path) {
 	std::vector<sys_dir_entry_t> files;

 	SysFileGetDents(path, files);
@@ -567,8 +523,13 @@ std::vector<File::DirEntry> File::GetDirEntries(const std::filesystem::path& pat
 	std::vector<File::DirEntry> ret;
 	ret.reserve(files.size());

-	for (auto& f: files) {
-		ret.emplace_back(std::move(f.name), f.is_file);
+	for (const auto& f: files) {
+		File::DirEntry r {};
+
+		r.name    = f.name;
+		r.is_file = f.is_file;
+
+		ret.push_back(std::move(r));
 	}

 	return ret;
@@ -577,18 +538,12 @@ std::vector<File::DirEntry> File::GetDirEntries(const std::filesystem::path& pat
 bool File::CopyFile(const std::filesystem::path& src,
                    const std::filesystem::path& dst) // @suppress("Member declaration not found")
 {
-	if (IsArchivePath(src) || IsArchivePath(dst)) {
-		return false;
-	}
 	return SysFileCopyFile(src, dst);
 }

 bool File::RenameFile(const std::filesystem::path& src,
                      const std::filesystem::path& dst) // @suppress("Member declaration not found")
 {
-	if (IsArchivePath(src) || IsArchivePath(dst)) {
-		return false;
-	}
 	if (IsFileExisting(dst)) {
 		DeleteFile(dst); // @suppress("Invalid arguments")
 	}
@@ -597,9 +552,6 @@ bool File::RenameFile(const std::filesystem::path& src,
 }

 void File::RemoveReadonly(const std::filesystem::path& name) {
-	if (IsArchivePath(name)) {
-		return;
-	}
 	SysFileRemoveReadonly(name);
 }

@@ -1,13 +1,12 @@
 #ifndef KYTY_COMMON_FILE_H_
 #define KYTY_COMMON_FILE_H_

+#include "common/byteBuffer.h"
 #include "common/common.h"
 #include "common/dateTime.h"

-#include <cstddef>
 #include <filesystem>
 #include <memory>
-#include <optional>
 #include <string>
 #include <vector>

@@ -31,14 +30,18 @@ class File {
 public:
 	enum class Mode { Read, Write, ReadWrite, WriteRead };

+	struct FindInfo {
+		std::filesystem::path path_with_name;
+		std::filesystem::path rel_path_with_name;
+		DateTime              last_access_time;
+		DateTime              last_write_time;
+		uint64_t              size;
+	};
+
 	struct DirEntry {
 		std::string name;
 		bool        is_file;
 	};
-	struct Info {
-		bool     is_file;
-		uint64_t size;
-	};

 	File();
 	explicit File(const std::filesystem::path& name);
@@ -48,6 +51,7 @@ public:
 	bool Create(const std::filesystem::path& name);
 	bool Open(const std::filesystem::path& name, Mode mode);
 	bool OpenInMem(void* buf, uint32_t buf_size);
+	bool OpenInMem(ByteBuffer& buf); // NOLINT(google-runtime-references)
 	bool CreateInMem();

 	void Close();
@@ -69,15 +73,16 @@ public:

 	void GetLastAccessAndWriteTimeUTC(DateTime* access, DateTime* write);

-	void Read(void* data, uint32_t size, uint32_t* bytes_read = nullptr);
-	void Write(const void* data, uint32_t size, uint32_t* bytes_written = nullptr);
+	void       Read(void* data, uint32_t size, uint32_t* bytes_read = nullptr);
+	ByteBuffer Read(uint32_t size);
+	void       Write(const void* data, uint32_t size, uint32_t* bytes_written = nullptr);
+	void       Write(const ByteBuffer& buf, uint32_t* bytes_written = nullptr);

 	void Printf(const char* format, ...) KYTY_FORMAT_PRINTF(2, 3);

-	std::vector<std::byte> ReadWholeBuffer();
+	ByteBuffer ReadWholeBuffer();

 	static uint64_t Size(const std::filesystem::path& name);
-	static std::optional<Info> GetInfo(const std::filesystem::path& name);

 	static bool IsDirectoryExisting(const std::filesystem::path& path);
 	static bool IsFileExisting(const std::filesystem::path& name);
@@ -96,6 +101,7 @@ public:
 	static bool SetLastAccessAndWriteTimeUTC(const std::filesystem::path& name,
 	                                         const DateTime& access, const DateTime& write);

+	static std::vector<FindInfo> FindFiles(const std::filesystem::path& path);
 	static std::vector<DirEntry> GetDirEntries(const std::filesystem::path& path);
 	static bool CopyFile(const std::filesystem::path& src, const std::filesystem::path& dst);
 	static bool RenameFile(const std::filesystem::path& src, const std::filesystem::path& dst);
@@ -54,6 +54,103 @@ inline uint32_t hash(const void* key, uint32_t key_len) {
 	return hash;
 }

+inline uint32_t hash8(uint8_t key) {
+	uint32_t hash = 0;
+
+	uint8_t* ptr = &key;
+
+	hash += ptr[0];
+	hash += (hash << 10u);
+	hash ^= (hash >> 6u);
+
+	hash += (hash << 3u);
+	hash ^= (hash >> 11u);
+	hash += (hash << 15u);
+
+	return hash;
+}
+
+inline uint32_t hash16(uint16_t key) {
+	uint32_t hash = 0;
+
+	auto* ptr = reinterpret_cast<uint8_t*>(&key);
+
+	hash += ptr[0];
+	hash += (hash << 10u);
+	hash ^= (hash >> 6u);
+	hash += ptr[1];
+	hash += (hash << 10u);
+	hash ^= (hash >> 6u);
+
+	hash += (hash << 3u);
+	hash ^= (hash >> 11u);
+	hash += (hash << 15u);
+
+	return hash;
+}
+
+inline uint32_t hash32(uint32_t key) {
+	uint32_t hash = 0;
+
+	auto* ptr = reinterpret_cast<uint8_t*>(&key);
+
+	hash += ptr[0];
+	hash += (hash << 10u);
+	hash ^= (hash >> 6u);
+	hash += ptr[1];
+	hash += (hash << 10u);
+	hash ^= (hash >> 6u);
+	hash += ptr[2];
+	hash += (hash << 10u);
+	hash ^= (hash >> 6u);
+	hash += ptr[3];
+	hash += (hash << 10u);
+	hash ^= (hash >> 6u);
+
+	hash += (hash << 3u);
+	hash ^= (hash >> 11u);
+	hash += (hash << 15u);
+
+	return hash;
+}
+
+inline uint32_t hash64(uint64_t key) {
+	uint32_t hash = 0;
+
+	auto* ptr = reinterpret_cast<uint8_t*>(&key);
+
+	hash += ptr[0];
+	hash += (hash << 10u);
+	hash ^= (hash >> 6u);
+	hash += ptr[1];
+	hash += (hash << 10u);
+	hash ^= (hash >> 6u);
+	hash += ptr[2];
+	hash += (hash << 10u);
+	hash ^= (hash >> 6u);
+	hash += ptr[3];
+	hash += (hash << 10u);
+	hash ^= (hash >> 6u);
+	hash += ptr[4];
+	hash += (hash << 10u);
+	hash ^= (hash >> 6u);
+	hash += ptr[5];
+	hash += (hash << 10u);
+	hash ^= (hash >> 6u);
+	hash += ptr[6];
+	hash += (hash << 10u);
+	hash ^= (hash >> 6u);
+	hash += ptr[7];
+	hash += (hash << 10u);
+	hash ^= (hash >> 6u);
+
+	hash += (hash << 3u);
+	hash ^= (hash >> 11u);
+	hash += (hash << 15u);
+
+	return hash;
+}
+
 } // namespace Common

 #endif /* KYTY_COMMON_HASH_H_ */
@@ -5,17 +5,14 @@

 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 #include <windows.h> // IWYU pragma: keep
-#else
-#include <algorithm>
+#elif defined(__APPLE__)
 #include <csignal>
-#include <cstdlib>
-#include <initializer_list>
-#include <unistd.h>
-#if defined(__APPLE__)
 #include <sys/ucontext.h>
 #else
+#include <csignal>
+#include <initializer_list>
 #include <ucontext.h> // IWYU pragma: keep
-#endif
+#include <unistd.h>
 #endif

 // IWYU pragma: no_include <errhandlingapi.h>
@@ -35,51 +32,6 @@ static_assert(decltype(g_handler)::is_always_lock_free);
 static_assert(decltype(g_install_state)::is_always_lock_free);
 #endif

-#if KYTY_PLATFORM == KYTY_PLATFORM_LINUX
-
-// macOS uses the same POSIX platform setting and needs a signal stack too.
-class ThreadSignalStack {
-public:
-	ThreadSignalStack() {
-		const auto page_size = static_cast<size_t>(::getpagesize());
-		const auto stack_size =
-		    (std::max<size_t>(64 * 1024, MINSIGSTKSZ) + page_size - 1) & ~(page_size - 1);
-		if (::posix_memalign(&m_memory, page_size, stack_size) != 0) {
-			return;
-		}
-
-		stack_t stack {};
-		stack.ss_sp   = m_memory;
-		stack.ss_size = stack_size;
-		if (::sigaltstack(&stack, &m_previous) != 0) {
-			std::free(m_memory);
-			m_memory = nullptr;
-		}
-	}
-
-	~ThreadSignalStack() {
-		if (m_memory != nullptr && ::sigaltstack(&m_previous, nullptr) == 0) {
-			std::free(m_memory);
-		}
-	}
-
-	[[nodiscard]] bool IsInitialized() const { return m_memory != nullptr; }
-
-	KYTY_CLASS_NO_COPY(ThreadSignalStack)
-
-private:
-	void*   m_memory = nullptr;
-	stack_t m_previous {};
-};
-
-bool InitializeThreadSignalStack() {
-	// Keep fault handling off guest stacks, which GPU tracking can make read-only.
-	thread_local ThreadSignalStack signal_stack;
-	return signal_stack.IsInitialized();
-}
-
-#endif
-
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS

 static LONG WINAPI ExceptionFilter(PEXCEPTION_POINTERS exception) noexcept {
@@ -301,7 +253,7 @@ bool InstallHandler(Handler handler) {
 #elif defined(__APPLE__)
 	struct sigaction sa {};
 	sa.sa_sigaction = SignalHandler;
-	sa.sa_flags     = SA_SIGINFO | SA_ONSTACK;
+	sa.sa_flags     = SA_SIGINFO;
 	sigemptyset(&sa.sa_mask);
 	// The guest signal-dispatch path (KernelRaiseException) interrupts threads with
 	// SIGUSR1; block it while a fault is being resolved so a stop-the-world request
@@ -322,7 +274,8 @@ bool InstallHandler(Handler handler) {
 	struct sigaction action {};
 	action.sa_sigaction = SignalHandler;
 	sigemptyset(&action.sa_mask);
-	action.sa_flags = SA_SIGINFO | SA_RESTART | SA_ONSTACK;
+	// Fault resolution needs the normal thread stack.
+	action.sa_flags = SA_SIGINFO | SA_RESTART;

 	for (const int signal_number: {SIGSEGV, SIGBUS, SIGILL}) {
 		if (::sigaction(signal_number, &action, nullptr) != 0) {
@@ -39,10 +39,6 @@ using Handler = bool (*)(const ExceptionInfo&);

 bool InstallHandler(Handler handler);

-#if KYTY_PLATFORM == KYTY_PLATFORM_LINUX
-bool InitializeThreadSignalStack();
-#endif
-
 } // namespace Common::HostException

 #endif /* KYTY_COMMON_HOST_EXCEPTION_H_ */
@@ -1,580 +0,0 @@
-#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
@@ -1,86 +0,0 @@
-#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_ */
@@ -1,53 +0,0 @@
-#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
@@ -1,13 +0,0 @@
-#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
@@ -3,9 +3,9 @@

 #include "common/assert.h"
 #include "common/emulatorConfig.h"
+#include "common/stringUtils.h"

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

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

@@ -129,14 +129,6 @@ static void WriteImpl(std::string_view text, fmt::text_style style = {}) {
 	}
 }

-void WriteToConsoleAndLog(std::string_view text) {
-	WriteImpl(text);
-	if (g_initialized && g_direction != Direction::Console) {
-		WriteStdout(text);
-	}
-	Flush();
-}
-
 void WriteFatal(std::string_view text) {
 	if (g_direction == Direction::Silent || !g_initialized) {
 		WriteStdout(text);
@@ -160,9 +152,9 @@ void WriteFatal(fmt::text_style style, std::string_view text) {
 void Initialize() {
 	g_initialized = true;
 	switch (Config::GetPrintfDirection()) {
-		case Config::LogDirection::Silent: g_direction = Direction::Silent; break;
-		case Config::LogDirection::Console: g_direction = Direction::Console; break;
-		case Config::LogDirection::File: g_direction = Direction::File; break;
+		case Config::OutputDirection::Silent: g_direction = Direction::Silent; break;
+		case Config::OutputDirection::Console: g_direction = Direction::Console; break;
+		case Config::OutputDirection::File: g_direction = Direction::File; break;
 	}
 	g_output_file =
 	    (g_direction == Direction::File ? Config::GetPrintfOutputFile() : std::filesystem::path {});
@@ -21,15 +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);
 void      Write(fmt::text_style style, std::string_view text);
-void      WriteToConsoleAndLog(std::string_view text);
 void      WriteFatal(std::string_view text);
 void      WriteFatal(fmt::text_style style, std::string_view text);
 void      Flush();
@@ -0,0 +1,42 @@
+#ifndef KYTY_COMMON_MAGICENUM_H_
+#define KYTY_COMMON_MAGICENUM_H_
+
+#include "common/common.h"
+#include "common/stringUtils.h"
+#include "magic_enum.hpp" // IWYU pragma: export
+
+namespace Common {
+
+template <typename E>
+inline std::string EnumName(E v) {
+	auto str = magic_enum::enum_name(v);
+	return std::string(str.data(), str.length());
+}
+
+template <typename E>
+inline std::string EnumName8(E v) {
+	auto str = magic_enum::enum_name(v);
+	return std::string(str.data(), str.length());
+}
+
+template <typename E>
+inline E EnumValue(const std::string& str, E default_value) {
+	auto v = magic_enum::enum_cast<E>(str.c_str());
+	if (v.has_value()) {
+		return v.value();
+	}
+	return default_value;
+}
+
+#define KYTY_ENUM_RANGE(e, mx, mn)                                                                 \
+	namespace magic_enum::customize {                                                              \
+	template <>                                                                                    \
+	struct enum_range<e> {                                                                         \
+		static constexpr int min = (mx);                                                           \
+		static constexpr int max = (mn);                                                           \
+	};                                                                                             \
+	}
+
+} // namespace Common
+
+#endif /* KYTY_COMMON_MAGICENUM_H_ */
@@ -30,6 +30,8 @@ struct sys_dbg_stack_info_t {
 #endif
 };

-void SysStackUsage(sys_dbg_stack_info_t& s); // NOLINT(google-runtime-references)
+void SysStackWalk(void** stack, int* depth);
+void SysStackUsage(sys_dbg_stack_info_t& s);          // NOLINT(google-runtime-references)
+void SysStackUsagePrint(sys_dbg_stack_info_t& stack); // NOLINT(google-runtime-references)

 #endif /* KYTY_COMMON_PLATFORM_SYSDBG_H_ */
@@ -18,6 +18,14 @@ enum sys_file_cache_type_t {
 	SYS_FILE_CACHE_SEQUENTIAL_SCAN = 2  // NOLINT(readability-identifier-naming)
 };

+// NOLINTNEXTLINE(readability-identifier-naming)
+struct sys_file_find_t {
+	std::filesystem::path path_with_name;
+	SysFileTimeStruct     last_access_time;
+	SysFileTimeStruct     last_write_time;
+	uint64_t              size;
+};
+
 // NOLINTNEXTLINE(readability-identifier-naming)
 struct sys_dir_entry_t {
 	std::string name;
@@ -44,8 +52,8 @@ uint64_t    SysFileTell(sys_file_t& f);                    // NOLINT(google-runt
 bool        SysFileTruncate(sys_file_t& f, uint64_t size); // NOLINT(google-runtime-references)
 bool        SysFileUnlink(sys_file_t&                  f,
                          const std::filesystem::path& name); // NOLINT(google-runtime-references)
+void        SysFileWrite(uint32_t n, sys_file_t& f);          // NOLINT(google-runtime-references)
 uint64_t    SysFileSize(const std::filesystem::path& file_name);
-bool        SysFileGetInfo(const std::filesystem::path& name, bool* is_file, uint64_t* size);
 bool        SysFileIsError(sys_file_t& f); // NOLINT(google-runtime-references)
 bool        SysFileIsDirectoryExisting(const std::filesystem::path& path);
 bool        SysFileIsFileExisting(const std::filesystem::path& name);
@@ -68,6 +76,8 @@ bool SysFileSetLastWriteTimeUtc(const std::filesystem::path& name, SysFileTimeSt
 bool SysFileSetLastAccessAndWriteTimeUtc(const std::filesystem::path& name,
                                         SysFileTimeStruct& access, SysFileTimeStruct& write);
 // NOLINTNEXTLINE(google-runtime-references)
+void SysFileFindFiles(const std::filesystem::path& path, std::vector<sys_file_find_t>& out);
+// NOLINTNEXTLINE(google-runtime-references)
 void SysFileGetDents(const std::filesystem::path& path, std::vector<sys_dir_entry_t>& out);
 bool SysFileCopyFile(const std::filesystem::path& src, const std::filesystem::path& dst);
 bool SysFileRenameFile(const std::filesystem::path& src, const std::filesystem::path& dst);
@@ -8,6 +8,7 @@

 #include <cstdlib>
 #include <cstring>
+#include <execinfo.h>
 #include <pthread.h>
 #include <sys/param.h>
 #include <sys/types.h>
@@ -16,6 +17,56 @@
 #include <libgen.h> // POSIX basename() lives here on macOS, not in <cstring>
 #endif

+// Avoid unwinding a guest-owned stack.
+static bool OnOwnStack() {
+	const char* probe = reinterpret_cast<const char*>(&probe);
+
+	pthread_attr_t attr {};
+#if defined(__APPLE__)
+	const auto* top  = static_cast<const char*>(pthread_get_stackaddr_np(pthread_self()));
+	const auto  size = pthread_get_stacksize_np(pthread_self());
+	(void)attr;
+	return top != nullptr && size != 0 && probe < top && probe >= top - size;
+#else
+	if (pthread_getattr_np(pthread_self(), &attr) != 0) {
+		return false;
+	}
+	void*      base = nullptr;
+	size_t     size = 0;
+	const bool ok = pthread_attr_getstack(&attr, &base, &size) == 0 && base != nullptr && size != 0;
+	pthread_attr_destroy(&attr);
+	if (!ok) {
+		return false;
+	}
+	const auto* low = static_cast<const char*>(base);
+	return probe >= low && probe < low + size;
+#endif
+}
+
+void SysStackWalk(void** stack, int* depth) {
+	if (stack == nullptr || depth == nullptr || *depth <= 0) {
+		if (depth != nullptr) {
+			*depth = 0;
+		}
+		return;
+	}
+
+	if (!OnOwnStack()) {
+		*depth = 0;
+		return;
+	}
+
+	const int n = ::backtrace(stack, *depth);
+	*depth      = (n < 0 ? 0 : n);
+}
+
+void SysStackUsagePrint(sys_dbg_stack_info_t& stack) {
+	printf("stack: (0x%" PRIx64 ", %" PRIu64 ")\n", static_cast<uint64_t>(stack.commited_addr),
+	       static_cast<uint64_t>(stack.commited_size));
+	printf("code: (0x%" PRIx64 ", %" PRIu64 ")\n", static_cast<uint64_t>(stack.code_addr),
+	       static_cast<uint64_t>(stack.code_size));
+}
+
 void SysStackUsage(sys_dbg_stack_info_t& s) {
 	pid_t pid = getpid();

@@ -11,7 +11,6 @@

 #include <cerrno>
 #include <cstdlib>
-#include <cstring>
 #include <dirent.h>
 #include <fcntl.h>
 #include <filesystem>
@@ -54,7 +53,7 @@ struct sys_file_t {
 #endif

 static std::filesystem::path get_internal_name(const std::filesystem::path& name) {
-	return name.empty() || name.is_absolute() ? name : (std::filesystem::path(".") / name);
+	return name.is_absolute() ? name : (std::filesystem::path(".") / name);
 }

 // Pass access-pattern hints to the host.
@@ -152,29 +151,46 @@ void SysFileWrite(const void* data, uint32_t size, sys_file_t& f, uint32_t* byte
 	}
 }

-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;
-	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;
+void SysFileWrite(uint32_t n, sys_file_t& f) {
+	SysFileWrite(&n, 4, f);
 }

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

 sys_file_t* SysFileOpenR(const std::filesystem::path& file_name, sys_file_cache_type_t cache_type) {
-	return OpenHostFile(file_name, "r", 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;
 }

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

 sys_file_t* SysFileOpenW(const std::filesystem::path& file_name, sys_file_cache_type_t cache_type) {
-	return OpenHostFile(file_name, "r+", 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;
 }

 sys_file_t* SysFileOpenRw(const std::filesystem::path& file_name,
                          sys_file_cache_type_t        cache_type) {
-	return OpenHostFile(file_name, "r+", 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;
 }

 void SysFileClose(sys_file_t* f) {
@@ -250,21 +300,10 @@ uint64_t SysFileSize(sys_file_t& f) {
 	return 0;
 }

-bool SysFileGetInfo(const std::filesystem::path& name, bool* is_file, uint64_t* size) {
-	const auto path = get_internal_name(name);
-	struct stat info {};
-	if (stat(path.c_str(), &info) != 0) {
-		return false;
-	}
-	*is_file = !S_ISDIR(info.st_mode);
-	*size = *is_file ? static_cast<uint64_t>(info.st_size) : 0;
-	return true;
-}
-
 uint64_t SysFileSize(const std::filesystem::path& file_name) {
-	bool is_file;
-	uint64_t size = 0;
-	SysFileGetInfo(file_name, &is_file, &size);
+	sys_file_t* f    = SysFileOpenR(file_name);
+	uint64_t    size = SysFileSize(*f);
+	SysFileClose(f);
 	return size;
 }

@@ -317,15 +356,29 @@ bool SysFileIsError(sys_file_t& f) {
 }

 bool SysFileIsDirectoryExisting(const std::filesystem::path& path) {
-	bool is_file;
-	uint64_t size;
-	return SysFileGetInfo(path, &is_file, &size) && !is_file;
+	auto real_name     = get_internal_name(path);
+	auto real_name_str = real_name.string();
+
+	struct stat s {};
+
+	if (0 != stat(real_name_str.c_str(), &s)) {
+		return false;
+	}
+
+	return S_ISDIR(s.st_mode); // NOLINT
 }

 bool SysFileIsFileExisting(const std::filesystem::path& name) {
-	bool is_file;
-	uint64_t size;
-	return SysFileGetInfo(name, &is_file, &size) && is_file;
+	auto real_name     = get_internal_name(name);
+	auto real_name_str = real_name.string();
+
+	struct stat s {};
+
+	if (0 != stat(real_name_str.c_str(), &s)) {
+		return false;
+	}
+
+	return !S_ISDIR(s.st_mode); // NOLINT
 }

 bool SysFileCreateDirectory(const std::filesystem::path& path) {
@@ -367,7 +420,7 @@ bool SysFileDeleteFile(const std::filesystem::path& name) {

 bool SysFileFlush(sys_file_t& f) {
 	if (f.type == SYS_FILE_FILE && f.f != nullptr) {
-		return fflush(f.f) == 0 && fsync(fileno(f.f)) == 0;
+		return (fflush(f.f) == 0);
 	}

 	return false;
@@ -560,6 +613,51 @@ bool SysFileSetLastAccessAndWriteTimeUtc(const std::filesystem::path& name,
 	//	}
 }

+// Recursively collect regular files.
+void SysFileFindFiles(const std::filesystem::path& path, std::vector<sys_file_find_t>& out) {
+	auto real_path = get_internal_name(path);
+
+	DIR* dir = opendir(real_path.string().c_str());
+	if (dir == nullptr) {
+		return;
+	}
+
+	for (const dirent* entry = readdir(dir); entry != nullptr; entry = readdir(dir)) {
+		const std::string file_name(entry->d_name);
+
+		if (file_name == "." || file_name == "..") {
+			continue;
+		}
+
+		auto        child = real_path / file_name;
+		struct stat s {};
+
+		// lstat, so a symlink is never followed into a cycle during the recursive walk.
+		if (0 != lstat(child.string().c_str(), &s)) {
+			continue;
+		}
+
+		if (S_ISDIR(s.st_mode)) {
+			SysFileFindFiles(child, out);
+		} else if (S_ISREG(s.st_mode)) {
+			sys_file_find_t r {};
+
+			r.path_with_name              = child;
+			r.size                        = static_cast<uint64_t>(s.st_size);
+			r.last_access_time.is_invalid = false;
+			r.last_access_time.time       = s.st_atime;
+			r.last_access_time.nanos      = KYTY_STAT_ATIME_NS(s);
+			r.last_write_time.is_invalid  = false;
+			r.last_write_time.time        = s.st_mtime;
+			r.last_write_time.nanos       = KYTY_STAT_MTIME_NS(s);
+
+			out.push_back(r);
+		}
+	}
+
+	closedir(dir);
+}
+
 // Keep "." and ".." to match FindFirstFileW.
 void SysFileGetDents(const std::filesystem::path& path, std::vector<sys_dir_entry_t>& out) {
 	auto real_path = get_internal_name(path);
@@ -5,6 +5,7 @@
 #else

 #include "common/assert.h"
+#include "common/platform/sysVirtual.h"
 #include "common/virtualMemory.h"

 #include <atomic>
@@ -27,12 +28,13 @@
 #define KYTY_FIXED_NOREPLACE
 #endif

-namespace Common::VirtualMemory {
+namespace Common {

 static pthread_mutex_t              g_virtual_mutex {};
-static std::map<uintptr_t, size_t>* g_allocs = nullptr;
+static std::map<uintptr_t, size_t>* g_allocs   = nullptr;
+static std::map<uintptr_t, int>*    g_protects = nullptr;

-void Init() {
+void SysVirtualInit() {
 	pthread_mutexattr_t attr {};

 	pthread_mutexattr_init(&attr);
@@ -44,27 +46,43 @@ void Init() {
 	pthread_mutex_init(&g_virtual_mutex, &attr);
 	pthread_mutexattr_destroy(&attr);

-	g_allocs = new std::map<uintptr_t, size_t>;
+	g_allocs   = new std::map<uintptr_t, size_t>;
+	g_protects = new std::map<uintptr_t, int>;
 }

-static int get_protection_flag(Mode mode) {
+static int get_protection_flag(VirtualMemory::Mode mode) {
 	int protect = PROT_NONE;
 	switch (mode) {
-		case Mode::Read: protect = PROT_READ; break;
-		case Mode::Write:
-		case Mode::ReadWrite: protect = PROT_READ | PROT_WRITE; break; // NOLINT
-		case Mode::Execute: protect = PROT_EXEC; break;
-		case Mode::ExecuteRead: protect = PROT_EXEC | PROT_READ; break; // NOLINT
-		case Mode::ExecuteWrite:
-		case Mode::ExecuteReadWrite:
+		case VirtualMemory::Mode::Read: protect = PROT_READ; break;
+		case VirtualMemory::Mode::Write:
+		case VirtualMemory::Mode::ReadWrite: protect = PROT_READ | PROT_WRITE; break; // NOLINT
+		case VirtualMemory::Mode::Execute: protect = PROT_EXEC; break;
+		case VirtualMemory::Mode::ExecuteRead: protect = PROT_EXEC | PROT_READ; break; // NOLINT
+		case VirtualMemory::Mode::ExecuteWrite:
+		case VirtualMemory::Mode::ExecuteReadWrite:
 			protect = PROT_EXEC | PROT_WRITE | PROT_READ;
 			break; // NOLINT
-		case Mode::NoAccess:
+		case VirtualMemory::Mode::NoAccess:
 		default: protect = PROT_NONE; break;
 	}
 	return protect;
 }

+static VirtualMemory::Mode get_protection_flag(int mode) {
+	switch (mode) {
+		case PROT_NONE: return VirtualMemory::Mode::NoAccess;
+		case PROT_READ: return VirtualMemory::Mode::Read;
+		case PROT_WRITE: return VirtualMemory::Mode::Write;
+		case PROT_READ | PROT_WRITE: return VirtualMemory::Mode::ReadWrite; // NOLINT
+		case PROT_EXEC: return VirtualMemory::Mode::Execute;
+		case PROT_EXEC | PROT_WRITE: return VirtualMemory::Mode::ExecuteWrite; // NOLINT
+		case PROT_EXEC | PROT_READ: return VirtualMemory::Mode::ExecuteRead;   // NOLINT
+		case PROT_EXEC | PROT_WRITE | PROT_READ:
+			return VirtualMemory::Mode::ExecuteReadWrite; // NOLINT
+		default: return VirtualMemory::Mode::NoAccess;
+	}
+}
+
 // Keep automatic mappings inside the guest and GPU-addressable low window.
 #ifdef KYTY_FIXED_NOREPLACE
 static constexpr uintptr_t LOW_ARENA_LIMIT = 0x000000FC00000000ULL; // libc mspace window ceiling
@@ -129,7 +147,7 @@ static void* map_anonymous(uintptr_t addr, size_t size, int protect, int flags)
 	return mmap(nullptr, size, protect, flags, -1, 0); // NOLINT
 }

-uint64_t Alloc(uint64_t address, uint64_t size, Mode mode) {
+uint64_t SysVirtualAlloc(uint64_t address, uint64_t size, VirtualMemory::Mode mode) {
 	EXIT_IF(g_allocs == nullptr);

 	auto addr = static_cast<uintptr_t>(address);
@@ -143,6 +161,11 @@ uint64_t Alloc(uint64_t address, uint64_t size, Mode mode) {
 	if (ptr != MAP_FAILED) {
 		pthread_mutex_lock(&g_virtual_mutex);
 		record_alloc(ret_addr, size);
+		uintptr_t page_start = ret_addr >> 12u;
+		uintptr_t page_end   = (ret_addr + size - 1) >> 12u;
+		for (uintptr_t page = page_start; page <= page_end; page++) {
+			(*g_protects)[page] = protect;
+		}
 		pthread_mutex_unlock(&g_virtual_mutex);
 	}

@@ -153,7 +176,8 @@ static uintptr_t align_up(uintptr_t addr, uint64_t alignment) {
 	return (addr + alignment - 1) & ~(alignment - 1);
 }

-uint64_t AllocAligned(uint64_t address, uint64_t size, Mode mode, uint64_t alignment) {
+uint64_t SysVirtualAllocAligned(uint64_t address, uint64_t size, VirtualMemory::Mode mode,
+                                uint64_t alignment) {
 	if (alignment == 0) {
 		return 0;
 	}
@@ -222,11 +246,16 @@ uint64_t AllocAligned(uint64_t address, uint64_t size, Mode mode, uint64_t align
 	}

 	if (ptr == MAP_FAILED) {
-		return AllocAligned(address, size, mode, alignment << 1u);
+		return SysVirtualAllocAligned(address, size, mode, alignment << 1u);
 	}

 	pthread_mutex_lock(&g_virtual_mutex);
 	record_alloc(ret_addr, size);
+	uintptr_t page_start = ret_addr >> 12u;
+	uintptr_t page_end   = (ret_addr + size - 1) >> 12u;
+	for (uintptr_t page = page_start; page <= page_end; page++) {
+		(*g_protects)[page] = protect;
+	}
 	pthread_mutex_unlock(&g_virtual_mutex);

 	return ret_addr;
@@ -279,7 +308,7 @@ static bool is_mapped(void* ptr, size_t length) {
 }
 #endif

-bool AllocFixed(uint64_t address, uint64_t size, Mode mode) {
+bool SysVirtualAllocFixed(uint64_t address, uint64_t size, VirtualMemory::Mode mode) {
 	EXIT_IF(g_allocs == nullptr);

 	auto addr    = static_cast<uintptr_t>(address);
@@ -308,6 +337,11 @@ bool AllocFixed(uint64_t address, uint64_t size, Mode mode) {
 	if (ptr != MAP_FAILED) {
 		pthread_mutex_lock(&g_virtual_mutex);
 		record_alloc(ret_addr, size);
+		uintptr_t page_start = ret_addr >> 12u;
+		uintptr_t page_end   = (ret_addr + size - 1) >> 12u;
+		for (uintptr_t page = page_start; page <= page_end; page++) {
+			(*g_protects)[page] = protect;
+		}
 		pthread_mutex_unlock(&g_virtual_mutex);

 		return true;
@@ -316,15 +350,15 @@ bool AllocFixed(uint64_t address, uint64_t size, Mode mode) {
 	return false;
 }

-bool Commit(uint64_t address, uint64_t size, Mode mode) {
-	return Protect(address, size, mode);
+bool SysVirtualCommit(uint64_t address, uint64_t size, VirtualMemory::Mode mode) {
+	return SysVirtualProtect(address, size, mode);
 }

-uint64_t Reserve(uint64_t address, uint64_t size) {
-	return ReserveAligned(address, size, 1);
+uint64_t SysVirtualReserve(uint64_t address, uint64_t size) {
+	return SysVirtualReserveAligned(address, size, 1);
 }

-uint64_t ReserveAligned(uint64_t address, uint64_t size, uint64_t alignment) {
+uint64_t SysVirtualReserveAligned(uint64_t address, uint64_t size, uint64_t alignment) {
 	if (alignment == 0) {
 		return 0;
 	}
@@ -393,7 +427,7 @@ uint64_t ReserveAligned(uint64_t address, uint64_t size, uint64_t alignment) {
 	}

 	if (ptr == MAP_FAILED) {
-		return ReserveAligned(address, size, alignment << 1u);
+		return SysVirtualReserveAligned(address, size, alignment << 1u);
 	}

 	pthread_mutex_lock(&g_virtual_mutex);
@@ -403,7 +437,7 @@ uint64_t ReserveAligned(uint64_t address, uint64_t size, uint64_t alignment) {
 	return ret_addr;
 }

-bool ReserveFixed(uint64_t address, uint64_t size) {
+bool SysVirtualReserveFixed(uint64_t address, uint64_t size) {
 	EXIT_IF(g_allocs == nullptr);

 	auto addr = static_cast<uintptr_t>(address);
@@ -439,9 +473,9 @@ bool ReserveFixed(uint64_t address, uint64_t size) {
 	return false;
 }

-bool Decommit(uint64_t address, uint64_t size) {
+bool SysVirtualDecommit(uint64_t address, uint64_t size) {
 	// Drop physical pages while preserving the reservation.
-	if (!Protect(address, size, Mode::NoAccess)) {
+	if (!SysVirtualProtect(address, size, VirtualMemory::Mode::NoAccess)) {
 		return false;
 	}

@@ -465,7 +499,7 @@ bool Decommit(uint64_t address, uint64_t size) {
 	return true;
 }

-bool Free(uint64_t address) {
+bool SysVirtualFree(uint64_t address) {
 	EXIT_IF(g_allocs == nullptr);
 	size_t size = 0;

@@ -482,10 +516,21 @@ bool Free(uint64_t address) {
 		return false;
 	}

-	return munmap(reinterpret_cast<void*>(addr), size) == 0;
+	if (munmap(reinterpret_cast<void*>(addr), size) == 0) {
+		uintptr_t page_start = addr >> 12u;
+		uintptr_t page_end   = (addr + size - 1) >> 12u;
+		pthread_mutex_lock(&g_virtual_mutex);
+		for (uintptr_t page = page_start; page <= page_end; page++) {
+			g_protects->erase(page);
+		}
+		pthread_mutex_unlock(&g_virtual_mutex);
+		return true;
+	}
+
+	return false;
 }

-bool FreeRange(uint64_t address, uint64_t size) {
+bool SysVirtualFreeRange(uint64_t address, uint64_t size) {
 	EXIT_IF(g_allocs == nullptr);
 	if (size == 0 || (address & 0xfffu) != 0 || (size & 0xfffu) != 0) {
 		return false;
@@ -537,22 +582,46 @@ bool FreeRange(uint64_t address, uint64_t size) {
 	if (end < alloc_end) {
 		(*g_allocs)[end] = alloc_end - end;
 	}
+	for (uintptr_t page = addr >> 12u; page <= (end - 1u) >> 12u; page++) {
+		g_protects->erase(page);
+	}
 	pthread_mutex_unlock(&g_virtual_mutex);
 	return true;
 }

-bool Protect(uint64_t address, uint64_t size, Mode mode) {
-	const auto addr       = static_cast<uintptr_t>(address);
-	const auto page_start = addr >> 12u;
-	const auto page_end   = (addr + size - 1) >> 12u;
-	return mprotect(reinterpret_cast<void*>(page_start << 12u), (page_end - page_start + 1) << 12u,
-	                get_protection_flag(mode)) == 0;
+bool SysVirtualProtect(uint64_t address, uint64_t size, VirtualMemory::Mode mode,
+                       VirtualMemory::Mode* old_mode) {
+	auto addr = static_cast<uintptr_t>(address);
+
+	pthread_mutex_lock(&g_virtual_mutex);
+	if (old_mode != nullptr) {
+		if (auto s = g_protects->find(addr >> 12u); s != g_protects->end()) {
+			*old_mode = get_protection_flag(s->second);
+		} else {
+			*old_mode = VirtualMemory::Mode::NoAccess;
+		}
+	}
+	pthread_mutex_unlock(&g_virtual_mutex);
+
+	uintptr_t page_start = addr >> 12u;
+	uintptr_t page_end   = (addr + size - 1) >> 12u;
+	if (mprotect(reinterpret_cast<void*>(page_start << 12u), (page_end - page_start + 1) << 12u,
+	             get_protection_flag(mode)) == 0) {
+		pthread_mutex_lock(&g_virtual_mutex);
+		for (uintptr_t page = page_start; page <= page_end; page++) {
+			(*g_protects)[page] = get_protection_flag(mode);
+		}
+		pthread_mutex_unlock(&g_virtual_mutex);
+		return true;
+	}
+
+	return false;
 }

-bool FlushInstructionCache(uint64_t /*address*/, uint64_t /*size*/) {
+bool SysVirtualFlushInstructionCache(uint64_t /*address*/, uint64_t /*size*/) {
 	return true;
 }

-} // namespace Common::VirtualMemory
+} // namespace Common

 #endif
@@ -0,0 +1,53 @@
+#ifndef KYTY_COMMON_PLATFORM_SYSSWAPBYTEORDER_H_
+#define KYTY_COMMON_PLATFORM_SYSSWAPBYTEORDER_H_
+
+#include "common/common.h"
+
+#include <type_traits>
+
+inline uint16_t SwapByteOrder16(uint16_t value) {
+	uint16_t hi = value << 8u;
+	uint16_t lo = value >> 8u;
+	return hi | lo;
+}
+
+inline uint32_t SwapByteOrder32(uint32_t value) {
+	return __builtin_bswap32(value);
+}
+
+inline uint64_t SwapByteOrder64(uint64_t value) {
+	return __builtin_bswap64(value);
+}
+
+template <typename T>
+inline void SwapByteOrder(T& x) {
+	if (sizeof(x) == 2) {
+		if (std::is_signed_v<T>) {
+			x = static_cast<std::make_signed_t<T>>(
+			    SwapByteOrder16(static_cast<std::make_unsigned_t<uint16_t>>(x)));
+		} else {
+			x = SwapByteOrder16(x);
+		}
+	}
+	if (sizeof(x) == 4) {
+		if (std::is_signed_v<T>) {
+			x = static_cast<std::make_signed_t<T>>(
+			    SwapByteOrder32(static_cast<std::make_unsigned_t<uint32_t>>(x)));
+		} else {
+			x = SwapByteOrder32(x);
+		}
+	}
+	if (sizeof(x) == 8) {
+		if (std::is_signed_v<T>) {
+			x = static_cast<std::make_signed_t<T>>(
+			    SwapByteOrder64(static_cast<std::make_unsigned_t<uint64_t>>(x)));
+		} else {
+			x = SwapByteOrder64(x);
+		}
+	}
+}
+
+template <typename T>
+inline void NoSwapByteOrder(T& x) {}
+
+#endif /* KYTY_COMMON_PLATFORM_SYSSWAPBYTEORDER_H_ */
@@ -151,6 +151,10 @@ inline void SysTimeTToSystem(time_t t, SysTimeStruct& s) {
 	SysFileToSystemTimeUtc(ft, s);
 }

+inline time_t SysTimegm(struct tm* tm) {
+	return timegm(tm);
+}
+
 inline void SysSystemToFileTimeUtc(const SysTimeStruct& f, SysFileTimeStruct& t) {
 	struct tm i {};

@@ -161,7 +165,7 @@ inline void SysSystemToFileTimeUtc(const SysTimeStruct& f, SysFileTimeStruct& t)
 	i.tm_min  = f.Minute;
 	i.tm_sec  = f.Second;

-	t.is_invalid = (f.is_invalid || (t.time = ::timegm(&i)) == static_cast<time_t>(-1));
+	t.is_invalid = (f.is_invalid || (t.time = SysTimegm(&i)) == static_cast<time_t>(-1));
 }

 // Retrieves the current local date and time.
@@ -0,0 +1,28 @@
+#ifndef KYTY_COMMON_PLATFORM_SYSVIRTUAL_H_
+#define KYTY_COMMON_PLATFORM_SYSVIRTUAL_H_
+
+#include "common/common.h"
+#include "common/virtualMemory.h"
+
+namespace Common {
+
+void SysVirtualInit();
+
+uint64_t SysVirtualAlloc(uint64_t address, uint64_t size, VirtualMemory::Mode mode);
+uint64_t SysVirtualAllocAligned(uint64_t address, uint64_t size, VirtualMemory::Mode mode,
+                                uint64_t alignment);
+bool     SysVirtualAllocFixed(uint64_t address, uint64_t size, VirtualMemory::Mode mode);
+bool     SysVirtualCommit(uint64_t address, uint64_t size, VirtualMemory::Mode mode);
+uint64_t SysVirtualReserve(uint64_t address, uint64_t size);
+uint64_t SysVirtualReserveAligned(uint64_t address, uint64_t size, uint64_t alignment);
+bool     SysVirtualReserveFixed(uint64_t address, uint64_t size);
+bool     SysVirtualDecommit(uint64_t address, uint64_t size);
+bool     SysVirtualFree(uint64_t address);
+bool     SysVirtualFreeRange(uint64_t address, uint64_t size);
+bool     SysVirtualProtect(uint64_t address, uint64_t size, VirtualMemory::Mode mode,
+                           VirtualMemory::Mode* old_mode = nullptr);
+bool     SysVirtualFlushInstructionCache(uint64_t address, uint64_t size);
+
+} // namespace Common
+
+#endif /* KYTY_COMMON_PLATFORM_SYSVIRTUAL_H_ */
@@ -15,6 +15,18 @@
 #include "common/assert.h"
 #include "common/platform/sysDbg.h"

+void SysStackWalk(void** stack, int* depth) {
+	*depth = static_cast<int>(CaptureStackBackTrace(0, static_cast<DWORD>(*depth), stack, nullptr));
+}
+
+void SysStackUsagePrint(sys_dbg_stack_info_t& stack) {
+	printf("stack: (0x%" PRIx64 ", %" PRIu64 ") + (0x%" PRIx64 ", %" PRIu64 ") + (0x%" PRIx64
+	       ", %" PRIu64 ")\n",
+	       static_cast<uint64_t>(stack.reserved_addr), static_cast<uint64_t>(stack.reserved_size),
+	       static_cast<uint64_t>(stack.guard_addr), static_cast<uint64_t>(stack.guard_size),
+	       static_cast<uint64_t>(stack.commited_addr), static_cast<uint64_t>(stack.commited_size));
+}
+
 void SysStackUsage(sys_dbg_stack_info_t& s) {
 	MEMORY_BASIC_INFORMATION mbi {};
 	[[maybe_unused]] size_t  ss = VirtualQuery(&mbi, &mbi, sizeof(mbi));
@@ -14,7 +14,6 @@
 #include "common/stringUtils.h"

 #include <cstdlib>
-#include <cstring>
 #include <vector>

 // NOLINTNEXTLINE(readability-identifier-naming)
@@ -57,10 +56,10 @@ static DWORD GetCacheAccessType(sys_file_cache_type_t t) {
 	}

 	if (t == SYS_FILE_CACHE_SEQUENTIAL_SCAN) {
-		return FILE_FLAG_SEQUENTIAL_SCAN;
+		return SYS_FILE_CACHE_SEQUENTIAL_SCAN;
 	}

-	return FILE_ATTRIBUTE_NORMAL;
+	return SYS_FILE_CACHE_AUTO;
 }

 void SysFileRead(void* data, uint32_t size, sys_file_t& f, uint32_t* bytes_read) {
@@ -136,6 +135,10 @@ void SysFileWrite(const void* data, uint32_t size, sys_file_t& f, uint32_t* byte
 	}
 }

+void SysFileWrite(uint32_t n, sys_file_t& f) {
+	SysFileWrite(&n, 4, f);
+}
+
 sys_file_t* SysFileCreate(const std::filesystem::path& file_name) {
 	auto* ret = new sys_file_t;

@@ -266,27 +269,19 @@ uint64_t SysFileSize(sys_file_t& f) {
 	return 0;
 }

-bool SysFileGetInfo(const std::filesystem::path& name, bool* is_file, uint64_t* size) {
-	const bool directory_path = !name.empty() && !name.has_filename() && name != name.root_path();
-	WIN32_FILE_ATTRIBUTE_DATA info {};
-	if (GetFileAttributesExW(directory_path ? name.parent_path().c_str() : name.c_str(),
-	                         GetFileExInfoStandard, &info) == 0) {
-		return false;
-	}
-	const bool file = (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0;
-	if (directory_path && file) {
-		return false;
-	}
-	*is_file = file;
-	*size = *is_file ? ((static_cast<uint64_t>(info.nFileSizeHigh) << 32u) | info.nFileSizeLow) : 0;
-	return true;
-}
-
 uint64_t SysFileSize(const std::filesystem::path& file_name) {
-	bool is_file;
-	uint64_t size = 0;
-	SysFileGetInfo(file_name, &is_file, &size);
-	return size;
+	LARGE_INTEGER             s;
+	WIN32_FILE_ATTRIBUTE_DATA a;
+
+	auto wide = file_name.wstring();
+	if (GetFileAttributesExW(wide.c_str(), GetFileExInfoStandard, &a) == 0) {
+		return 0;
+	}
+
+	s.HighPart = static_cast<LONG>(a.nFileSizeHigh);
+	s.LowPart  = a.nFileSizeLow;
+
+	return s.QuadPart;
 }

 bool SysFileTruncate(sys_file_t& f, uint64_t size) {
@@ -354,15 +349,17 @@ bool SysFileIsError(sys_file_t& f) {
 }

 bool SysFileIsDirectoryExisting(const std::filesystem::path& path) {
-	bool is_file;
-	uint64_t size;
-	return SysFileGetInfo(path, &is_file, &size) && !is_file;
+	auto  wide = path.wstring();
+	DWORD a    = GetFileAttributesW(wide.c_str());
+	return a != INVALID_FILE_ATTRIBUTES &&
+	       ((a & static_cast<DWORD>(FILE_ATTRIBUTE_DIRECTORY)) != 0u);
 }

 bool SysFileIsFileExisting(const std::filesystem::path& name) {
-	bool is_file;
-	uint64_t size;
-	return SysFileGetInfo(name, &is_file, &size) && is_file;
+	auto  wide = name.wstring();
+	DWORD a    = GetFileAttributesW(wide.c_str());
+	return a != INVALID_FILE_ATTRIBUTES &&
+	       ((a & static_cast<DWORD>(FILE_ATTRIBUTE_DIRECTORY)) == 0u);
 }

 bool SysFileCreateDirectory(const std::filesystem::path& path) {
@@ -482,11 +479,66 @@ bool SysFileSetLastAccessAndWriteTimeUtc(const std::filesystem::path& name,
 	return ok;
 }

-void SysFileGetDents(const std::filesystem::path& path, std::vector<sys_dir_entry_t>& out) {
-	const auto pattern = path / L"*";
+void SysFileFindFiles(const std::filesystem::path& path, std::vector<sys_file_find_t>& out) {
+	std::string real_path = Common::ReplaceChar(Common::PathToGenericString(path), '\\', '/');
+	if (!Common::EndsWith(real_path, "/")) {
+		real_path += "/";
+	}

-	WIN32_FIND_DATAW data {};
-	HANDLE h = FindFirstFileW(pattern.c_str(), &data);
+	std::string pattern = real_path + "*";
+
+	HANDLE           h = nullptr;
+	WIN32_FIND_DATAW data;
+
+	auto wide_pattern = std::filesystem::path(pattern).wstring();
+	h                 = FindFirstFileW(wide_pattern.c_str(), &data);
+
+	if (h == INVALID_HANDLE_VALUE) {
+		return;
+	}
+
+	do {
+		std::filesystem::path file_name(data.cFileName);
+		auto                  file_name_str = Common::PathToString(file_name);
+
+		if (file_name_str == "." || file_name_str == "..") {
+			continue;
+		}
+
+		if ((data.dwFileAttributes & static_cast<DWORD>(FILE_ATTRIBUTE_DIRECTORY)) != 0u) {
+			SysFileFindFiles(std::filesystem::path(real_path) / file_name, out);
+		} else {
+			sys_file_find_t r {};
+
+			r.path_with_name              = std::filesystem::path(real_path) / file_name;
+			r.size                        = (static_cast<uint64_t>(data.nFileSizeHigh) << 32u) +
+			                                static_cast<uint64_t>(data.nFileSizeLow);
+			r.last_access_time.is_invalid = false;
+			r.last_access_time.time       = data.ftLastAccessTime;
+			r.last_write_time.is_invalid  = false;
+			r.last_write_time.time        = data.ftLastWriteTime;
+
+			out.push_back(r);
+		}
+
+	} while (FindNextFileW(h, &data) != 0);
+
+	FindClose(h);
+}
+
+void SysFileGetDents(const std::filesystem::path& path, std::vector<sys_dir_entry_t>& out) {
+	std::string real_path = Common::ReplaceChar(Common::PathToGenericString(path), '\\', '/');
+	if (!Common::EndsWith(real_path, "/")) {
+		real_path += "/";
+	}
+
+	std::string pattern = real_path + "*";
+
+	HANDLE           h = nullptr;
+	WIN32_FIND_DATAW data;
+
+	auto wide_pattern = std::filesystem::path(pattern).wstring();
+	h                 = FindFirstFileW(wide_pattern.c_str(), &data);

 	if (h == INVALID_HANDLE_VALUE) {
 		return;
@@ -500,7 +552,7 @@ void SysFileGetDents(const std::filesystem::path& path, std::vector<sys_dir_entr
 		r.is_file = ((data.dwFileAttributes & static_cast<DWORD>(FILE_ATTRIBUTE_DIRECTORY)) == 0u);
 		r.name    = Common::PathToString(file_name);

-		out.push_back(std::move(r));
+		out.push_back(r);

 	} while (FindNextFileW(h, &data) != 0);

@@ -10,6 +10,7 @@
 #include <windows.h> // IWYU pragma: keep

 #include "common/assert.h"
+#include "common/platform/sysVirtual.h"
 #include "common/virtualMemory.h"

 // IWYU pragma: no_include <basetsd.h>
@@ -21,33 +22,45 @@
 // IWYU pragma: no_include <winerror.h>
 // IWYU pragma: no_include <wtypes.h>

-namespace Common::VirtualMemory {
+namespace Common {

-static DWORD GetProtectionFlag(Mode mode) {
+static DWORD GetProtectionFlag(VirtualMemory::Mode mode) {
 	DWORD protect = PAGE_NOACCESS;
 	switch (mode) {
-		case Mode::Read: protect = PAGE_READONLY; break;
+		case VirtualMemory::Mode::Read: protect = PAGE_READONLY; break;

-		case Mode::Write:
-		case Mode::ReadWrite: protect = PAGE_READWRITE; break;
+		case VirtualMemory::Mode::Write:
+		case VirtualMemory::Mode::ReadWrite: protect = PAGE_READWRITE; break;

-		case Mode::Execute: protect = PAGE_EXECUTE; break;
+		case VirtualMemory::Mode::Execute: protect = PAGE_EXECUTE; break;

-		case Mode::ExecuteRead: protect = PAGE_EXECUTE_READ; break;
+		case VirtualMemory::Mode::ExecuteRead: protect = PAGE_EXECUTE_READ; break;

-		case Mode::ExecuteWrite:
-		case Mode::ExecuteReadWrite: protect = PAGE_EXECUTE_READWRITE; break;
+		case VirtualMemory::Mode::ExecuteWrite:
+		case VirtualMemory::Mode::ExecuteReadWrite: protect = PAGE_EXECUTE_READWRITE; break;

-		case Mode::NoAccess:
+		case VirtualMemory::Mode::NoAccess:
 		default: protect = PAGE_NOACCESS; break;
 	}
 	return protect;
 }

-void Init() {}
+static VirtualMemory::Mode GetProtectionFlag(DWORD mode) {
+	switch (mode) {
+		case PAGE_NOACCESS: return VirtualMemory::Mode::NoAccess;
+		case PAGE_READONLY: return VirtualMemory::Mode::Read;
+		case PAGE_READWRITE: return VirtualMemory::Mode::ReadWrite;
+		case PAGE_EXECUTE: return VirtualMemory::Mode::Execute;
+		case PAGE_EXECUTE_READ: return VirtualMemory::Mode::ExecuteRead;
+		case PAGE_EXECUTE_READWRITE: return VirtualMemory::Mode::ExecuteReadWrite;
+		default: return VirtualMemory::Mode::NoAccess;
+	}
+}

-uint64_t Alloc(uint64_t address, uint64_t size, Mode mode) {
-	auto ptr = (address == 0 ? AllocAligned(address, size, mode, 1)
+void SysVirtualInit() {}
+
+uint64_t SysVirtualAlloc(uint64_t address, uint64_t size, VirtualMemory::Mode mode) {
+	auto ptr = (address == 0 ? SysVirtualAllocAligned(address, size, mode, 1)
 	                         : reinterpret_cast<uintptr_t>(VirtualAlloc(
 	                               reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)), size,
 	                               static_cast<DWORD>(MEM_COMMIT) | static_cast<DWORD>(MEM_RESERVE),
@@ -58,7 +71,7 @@ uint64_t Alloc(uint64_t address, uint64_t size, Mode mode) {
 		if (err != ERROR_INVALID_ADDRESS) {
 			printf("VirtualAlloc() failed: 0x%08" PRIx32 "\n", err);
 		} else {
-			return AllocAligned(address, size, mode, 1);
+			return SysVirtualAllocAligned(address, size, mode, 1);
 		}
 	}
 	return ptr;
@@ -79,7 +92,8 @@ static uint64_t AlignUp(uint64_t addr, uint64_t alignment) {
 	return (addr + alignment - 1) & ~(alignment - 1);
 }

-uint64_t AllocAligned(uint64_t address, uint64_t size, Mode mode, uint64_t alignment) {
+uint64_t SysVirtualAllocAligned(uint64_t address, uint64_t size, VirtualMemory::Mode mode,
+                                uint64_t alignment) {
 	if (alignment == 0) {
 		printf("VirtualAlloc2 failed: 0x%08" PRIx32 "\n", static_cast<uint32_t>(GetLastError()));
 		return 0;
@@ -133,13 +147,13 @@ uint64_t AllocAligned(uint64_t address, uint64_t size, Mode mode, uint64_t align
 			printf("VirtualAlloc2(alignment = 0x%016" PRIx64 ") failed: 0x%08" PRIx32 "\n",
 			       alignment, err);
 		} else {
-			return AllocAligned(address, size, mode, alignment << 1u);
+			return SysVirtualAllocAligned(address, size, mode, alignment << 1u);
 		}
 	}
 	return ptr;
 }

-bool AllocFixed(uint64_t address, uint64_t size, Mode mode) {
+bool SysVirtualAllocFixed(uint64_t address, uint64_t size, VirtualMemory::Mode mode) {
 	auto ptr = reinterpret_cast<uintptr_t>(VirtualAlloc(
 	    reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)), size,
 	    static_cast<DWORD>(MEM_COMMIT) | static_cast<DWORD>(MEM_RESERVE), GetProtectionFlag(mode)));
@@ -159,7 +173,7 @@ bool AllocFixed(uint64_t address, uint64_t size, Mode mode) {
 	return true;
 }

-bool Commit(uint64_t address, uint64_t size, Mode mode) {
+bool SysVirtualCommit(uint64_t address, uint64_t size, VirtualMemory::Mode mode) {
 	auto ptr = reinterpret_cast<uintptr_t>(
 	    VirtualAlloc(reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)), size,
 	                 static_cast<DWORD>(MEM_COMMIT), GetProtectionFlag(mode)));
@@ -177,8 +191,8 @@ bool Commit(uint64_t address, uint64_t size, Mode mode) {
 	return true;
 }

-uint64_t Reserve(uint64_t address, uint64_t size) {
-	auto ptr = (address == 0 ? ReserveAligned(address, size, 1)
+uint64_t SysVirtualReserve(uint64_t address, uint64_t size) {
+	auto ptr = (address == 0 ? SysVirtualReserveAligned(address, size, 1)
 	                         : reinterpret_cast<uintptr_t>(VirtualAlloc(
 	                               reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)), size,
 	                               static_cast<DWORD>(MEM_RESERVE), PAGE_NOACCESS)));
@@ -188,13 +202,13 @@ uint64_t Reserve(uint64_t address, uint64_t size) {
 		if (err != ERROR_INVALID_ADDRESS) {
 			printf("VirtualAlloc(MEM_RESERVE) failed: 0x%08" PRIx32 "\n", err);
 		} else {
-			return ReserveAligned(address, size, 1);
+			return SysVirtualReserveAligned(address, size, 1);
 		}
 	}
 	return ptr;
 }

-uint64_t ReserveAligned(uint64_t address, uint64_t size, uint64_t alignment) {
+uint64_t SysVirtualReserveAligned(uint64_t address, uint64_t size, uint64_t alignment) {
 	if (alignment == 0) {
 		printf("VirtualAlloc2(MEM_RESERVE) failed: 0x%08" PRIx32 "\n",
 		       static_cast<uint32_t>(GetLastError()));
@@ -248,13 +262,13 @@ uint64_t ReserveAligned(uint64_t address, uint64_t size, uint64_t alignment) {
 			       "\n",
 			       alignment, err);
 		} else {
-			return ReserveAligned(address, size, alignment << 1u);
+			return SysVirtualReserveAligned(address, size, alignment << 1u);
 		}
 	}
 	return ptr;
 }

-bool ReserveFixed(uint64_t address, uint64_t size) {
+bool SysVirtualReserveFixed(uint64_t address, uint64_t size) {
 	auto ptr = reinterpret_cast<uintptr_t>(
 	    VirtualAlloc(reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)), size,
 	                 static_cast<DWORD>(MEM_RESERVE), PAGE_NOACCESS));
@@ -274,7 +288,7 @@ bool ReserveFixed(uint64_t address, uint64_t size) {
 	return true;
 }

-bool Decommit(uint64_t address, uint64_t size) {
+bool SysVirtualDecommit(uint64_t address, uint64_t size) {
 	if (VirtualFree(reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)), size,
 	                MEM_DECOMMIT) == 0) {
 		printf("VirtualFree(MEM_DECOMMIT) failed: 0x%08" PRIx32 "\n",
@@ -284,7 +298,7 @@ bool Decommit(uint64_t address, uint64_t size) {
 	return true;
 }

-bool Free(uint64_t address) {
+bool SysVirtualFree(uint64_t address) {
 	if (VirtualFree(reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)), 0, MEM_RELEASE) ==
 	    0) {
 		printf("VirtualFree() failed: 0x%08" PRIx32 "\n", static_cast<uint32_t>(GetLastError()));
@@ -293,7 +307,7 @@ bool Free(uint64_t address) {
 	return true;
 }

-bool FreeRange(uint64_t address, uint64_t size) {
+bool SysVirtualFreeRange(uint64_t address, uint64_t size) {
 	if (address == 0 || size == 0) {
 		return false;
 	}
@@ -311,20 +325,24 @@ bool FreeRange(uint64_t address, uint64_t size) {
 		}
 		current = next;
 	}
-	return current - address == size && Free(address);
+	return current - address == size && SysVirtualFree(address);
 }

-bool Protect(uint64_t address, uint64_t size, Mode mode) {
+bool SysVirtualProtect(uint64_t address, uint64_t size, VirtualMemory::Mode mode,
+                       VirtualMemory::Mode* old_mode) {
 	DWORD old_protect = 0;
 	if (VirtualProtect(reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)), size,
 	                   GetProtectionFlag(mode), &old_protect) == 0) {
 		printf("VirtualProtect() failed: 0x%08" PRIx32 "\n", static_cast<uint32_t>(GetLastError()));
 		return false;
 	}
+	if (old_mode != nullptr) {
+		*old_mode = GetProtectionFlag(old_protect);
+	}
 	return true;
 }

-bool FlushInstructionCache(uint64_t address, uint64_t size) {
+bool SysVirtualFlushInstructionCache(uint64_t address, uint64_t size) {
 	if (::FlushInstructionCache(GetCurrentProcess(),
 	                            reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)),
 	                            size) == 0) {
@@ -335,6 +353,6 @@ bool FlushInstructionCache(uint64_t address, uint64_t size) {
 	return true;
 }

-} // namespace Common::VirtualMemory
+} // namespace Common

 #endif
@@ -2,13 +2,52 @@

 #include "common/emulatorConfig.h"

+#include <algorithm>
 #include <common/TracyProtocol.hpp>
 #include <common/TracyVersion.hpp>
 #include <cstdio>
 #include <tracy/Tracy.hpp>
+#include <vector>
+
+namespace {
+
+thread_local std::vector<Profiler::ScopedBlock*> g_block_stack;
+
+void RemoveBlock(Profiler::ScopedBlock* block) {
+	auto block_it = std::find(g_block_stack.rbegin(), g_block_stack.rend(), block);
+	if (block_it != g_block_stack.rend()) {
+		g_block_stack.erase(std::next(block_it).base());
+	}
+}
+
+} // namespace

 namespace Profiler {

+ScopedBlock::ScopedBlock(const tracy::SourceLocationData* source_location) {
+	if (tracy::ProfilerAvailable()) {
+		m_zone.emplace(source_location, TRACY_CALLSTACK, true);
+		g_block_stack.push_back(this);
+	}
+}
+
+ScopedBlock::~ScopedBlock() {
+	End();
+}
+
+void ScopedBlock::End() {
+	if (m_zone.has_value()) {
+		m_zone.reset();
+		RemoveBlock(this);
+	}
+}
+
+void EndBlock() {
+	if (!g_block_stack.empty()) {
+		g_block_stack.back()->End();
+	}
+}
+
 void SetThreadName(const char* name) {
 	if (tracy::ProfilerAvailable() && name != nullptr) {
 		tracy::SetThreadName(name);
@@ -16,13 +55,19 @@ void SetThreadName(const char* name) {
 }

 void Initialize() {
-	if (Config::ProfilerEnabled() && !tracy::ProfilerAvailable()) {
-		tracy::StartupProfiler();
-		TracySetProgramName("KytyPS5");
-		::printf("Tracy profiler enabled: client %d.%d.%d, protocol %u, "
-		         "broadcast %u, connect to 127.0.0.1:8086\n",
-		         tracy::Version::Major, tracy::Version::Minor, tracy::Version::Patch,
-		         tracy::ProtocolVersion, tracy::BroadcastVersion);
+	switch (Config::GetProfilerDirection()) {
+		case Config::ProfilerDirection::Network:
+			if (!tracy::ProfilerAvailable()) {
+				tracy::StartupProfiler();
+				TracySetProgramName("KytyPS5");
+				::printf("Tracy profiler enabled: client %d.%d.%d, protocol %u, "
+				         "broadcast %u, connect to 127.0.0.1:8086\n",
+				         tracy::Version::Major, tracy::Version::Minor, tracy::Version::Patch,
+				         tracy::ProtocolVersion, tracy::BroadcastVersion);
+			}
+			break;
+		case Config::ProfilerDirection::None:
+		default: break;
 	}
 }

@@ -4,6 +4,7 @@
 #include "common/common.h"

 #include <cstdint>
+#include <optional>
 #include <tracy/Tracy.hpp> // IWYU pragma: export

 namespace profiler::colors {
@@ -22,6 +23,22 @@ inline constexpr uint32_t DeepOrangeA200 = 0xff6e40;

 namespace Profiler {

+class ScopedBlock {
+public:
+	explicit ScopedBlock(const tracy::SourceLocationData* source_location);
+	ScopedBlock(const ScopedBlock&)            = delete;
+	ScopedBlock& operator=(const ScopedBlock&) = delete;
+	ScopedBlock(ScopedBlock&&)                 = delete;
+	ScopedBlock& operator=(ScopedBlock&&)      = delete;
+	~ScopedBlock();
+
+	void End();
+
+private:
+	std::optional<tracy::ScopedZone> m_zone;
+};
+
+void EndBlock();
 void SetThreadName(const char* name);

 void Initialize();
@@ -49,11 +66,19 @@ struct Lifecycle {
 	    kyty_profiler_source_location_, line) {name, TracyFunction, TracyFile,                     \
 	                                           static_cast<uint32_t>(line),                        \
 	                                           KYTY_PROFILER_COLOR_OR_DEFAULT(0, __VA_ARGS__)};    \
-	tracy::ScopedZone KYTY_PROFILER_CONCAT(kyty_profiler_block_, line)(                           \
-	    &KYTY_PROFILER_CONCAT(kyty_profiler_source_location_, line),                              \
-	    TRACY_CALLSTACK, tracy::ProfilerAvailable())
+	Profiler::ScopedBlock KYTY_PROFILER_CONCAT(kyty_profiler_block_, line)(                        \
+	    &KYTY_PROFILER_CONCAT(kyty_profiler_source_location_, line))

-#define KYTY_PROFILER_FUNCTION(...) KYTY_PROFILER_BLOCK(nullptr __VA_OPT__(, ) __VA_ARGS__)
+#define KYTY_PROFILER_FUNCTION(...) KYTY_PROFILER_FUNCTION_IMPL(__LINE__ __VA_OPT__(, ) __VA_ARGS__)
+#define KYTY_PROFILER_FUNCTION_IMPL(line, ...)                                                     \
+	static constexpr tracy::SourceLocationData KYTY_PROFILER_CONCAT(                               \
+	    kyty_profiler_source_location_, line) {nullptr, TracyFunction, TracyFile,                  \
+	                                           static_cast<uint32_t>(line),                        \
+	                                           KYTY_PROFILER_COLOR_OR_DEFAULT(0, __VA_ARGS__)};    \
+	Profiler::ScopedBlock KYTY_PROFILER_CONCAT(kyty_profiler_block_, line)(                        \
+	    &KYTY_PROFILER_CONCAT(kyty_profiler_source_location_, line))
+
+#define KYTY_PROFILER_END_BLOCK Profiler::EndBlock()

 #define KYTY_PROFILER_THREAD(name) Profiler::SetThreadName(name)

@@ -1,6 +1,7 @@
 #ifndef KYTY_COMMON_STRING_UTILS_H_
 #define KYTY_COMMON_STRING_UTILS_H_

+#include "common/byteBuffer.h"
 #include "common/common.h"

 #include <algorithm>
@@ -8,6 +9,7 @@
 #include <charconv>
 #include <codecvt>
 #include <filesystem>
+#include <fmt/format.h>
 #include <locale>
 #include <string>
 #include <string_view>
@@ -16,6 +18,8 @@

 namespace Common {

+constexpr uint32_t FIND_INVALID_INDEX = static_cast<uint32_t>(-1);
+
 inline std::string PathToString(const std::filesystem::path& path) {
 #if defined(__cpp_char8_t)
 	auto u8 = path.u8string();
@@ -34,12 +38,8 @@ inline std::string PathToGenericString(const std::filesystem::path& path) {
 #endif
 }

-inline std::filesystem::path PathFromUtf8(std::string_view text) {
-#if defined(__cpp_char8_t)
-	return std::filesystem::path(std::u8string(text.begin(), text.end()));
-#else
-	return std::filesystem::u8path(text.begin(), text.end());
-#endif
+inline bool IsSpace(char c) {
+	return std::isspace(static_cast<unsigned char>(c)) != 0;
 }

 inline bool EqualNoCase(std::string_view lhs, std::string_view rhs) {
@@ -63,6 +63,65 @@ inline std::string ToLower(std::string_view text) {
 	return ret;
 }

+inline bool ContainsStr(std::string_view text, std::string_view needle) {
+	return text.find(needle) != std::string_view::npos;
+}
+
+inline bool StartsWith(std::string_view text, std::string_view prefix) {
+	return text.starts_with(prefix);
+}
+
+inline bool StartsWith(std::string_view text, char prefix) {
+	return !text.empty() && text.front() == prefix;
+}
+
+inline bool EndsWith(std::string_view text, std::string_view suffix) {
+	return text.ends_with(suffix);
+}
+
+inline bool EndsWith(std::string_view text, char suffix) {
+	return !text.empty() && text.back() == suffix;
+}
+
+inline bool ContainsChar(std::string_view text, char needle) {
+	return text.find(needle) != std::string_view::npos;
+}
+
+inline bool IndexValid(std::string_view text, uint32_t index) {
+	return index < text.size();
+}
+
+inline uint32_t FindIndex(std::string_view text, std::string_view needle, size_t from = 0) {
+	const auto pos = text.find(needle, from);
+	return pos == std::string_view::npos ? FIND_INVALID_INDEX : static_cast<uint32_t>(pos);
+}
+
+inline uint32_t FindIndex(std::string_view text, char needle, size_t from = 0) {
+	const auto pos = text.find(needle, from);
+	return pos == std::string_view::npos ? FIND_INVALID_INDEX : static_cast<uint32_t>(pos);
+}
+
+inline uint32_t FindLastIndex(std::string_view text, std::string_view needle,
+                              size_t from = FIND_INVALID_INDEX) {
+	if (needle.empty()) {
+		return 0;
+	}
+	if (from == FIND_INVALID_INDEX || from > text.size()) {
+		from = text.size();
+	}
+	const auto pos = text.rfind(needle, from);
+	return pos == std::string_view::npos ? FIND_INVALID_INDEX : static_cast<uint32_t>(pos);
+}
+
+inline uint32_t FindLastIndex(std::string_view text, char needle,
+                              size_t from = FIND_INVALID_INDEX) {
+	if (from == FIND_INVALID_INDEX || from > text.size()) {
+		from = text.size();
+	}
+	const auto pos = text.rfind(needle, from);
+	return pos == std::string_view::npos ? FIND_INVALID_INDEX : static_cast<uint32_t>(pos);
+}
+
 inline std::string Mid(std::string_view text, size_t first, size_t count = std::string_view::npos) {
 	if (first >= text.size()) {
 		return {};
@@ -70,18 +129,49 @@ inline std::string Mid(std::string_view text, size_t first, size_t count = std::
 	return std::string(text.substr(first, count));
 }

+inline std::string Left(std::string_view text, size_t count) {
+	return Mid(text, 0, count);
+}
+
+inline std::string Right(std::string_view text, size_t count) {
+	if (count >= text.size()) {
+		return std::string(text);
+	}
+	return Mid(text, text.size() - count, count);
+}
+
 inline std::string RemoveLast(std::string_view text, size_t count) {
 	if (count >= text.size()) {
 		return {};
 	}
-	return std::string(text.substr(0, text.size() - count));
+	return Left(text, text.size() - count);
 }

 inline std::string RemoveFirst(std::string_view text, size_t count) {
 	if (count >= text.size()) {
 		return {};
 	}
-	return std::string(text.substr(count));
+	return Right(text, text.size() - count);
+}
+
+inline std::string TrimRight(std::string_view text) {
+	size_t end = text.size();
+	while (end > 0 && IsSpace(text[end - 1])) {
+		end--;
+	}
+	return std::string(text.substr(0, end));
+}
+
+inline std::string TrimLeft(std::string_view text) {
+	size_t first = 0;
+	while (first < text.size() && IsSpace(text[first])) {
+		first++;
+	}
+	return std::string(text.substr(first));
+}
+
+inline std::string Trim(std::string_view text) {
+	return TrimRight(TrimLeft(text));
 }

 inline std::string ReplaceChar(std::string_view text, char old_char, char new_char) {
@@ -114,6 +204,16 @@ inline std::string FilenameWithoutDirectory(std::string_view text) {
 	return pos == std::string_view::npos ? std::string(text) : std::string(text.substr(pos + 1));
 }

+inline std::string FilenameWithoutExtension(std::string_view text) {
+	const auto pos = text.find_last_of('.');
+	return pos == std::string_view::npos ? std::string(text) : std::string(text.substr(0, pos));
+}
+
+inline std::string ExtensionWithoutFilename(std::string_view text) {
+	const auto pos = text.find_last_of('.');
+	return pos == std::string_view::npos ? std::string() : std::string(text.substr(pos));
+}
+
 inline std::string FixFilenameSlash(std::string_view text) {
 	return ReplaceChar(text, '\\', '/');
 }
@@ -157,18 +257,86 @@ inline std::vector<std::string> Split(std::string_view text, char sep, bool keep
 	return Split(text, std::string_view(&sep, 1), keep_empty);
 }

+inline std::string Concat(const std::vector<std::string>& list, std::string_view sep) {
+	std::string ret;
+	for (size_t i = 0; i < list.size(); i++) {
+		if (i != 0) {
+			ret += sep;
+		}
+		ret += list[i];
+	}
+	return ret;
+}
+
+inline std::string Concat(const std::vector<std::string>& list, char sep) {
+	return Concat(list, std::string_view(&sep, 1));
+}
+
+inline uint32_t ToUint32(std::string_view text, int base = 10) {
+	uint32_t value = 0;
+	std::from_chars(text.data(), text.data() + text.size(), value, base);
+	return value;
+}
+
+inline uint64_t ToUint64(std::string_view text, int base = 10) {
+	uint64_t value = 0;
+	std::from_chars(text.data(), text.data() + text.size(), value, base);
+	return value;
+}
+
 inline int32_t ToInt32(std::string_view text, int base = 10) {
 	int32_t value = 0;
 	std::from_chars(text.data(), text.data() + text.size(), value, base);
 	return value;
 }

-inline std::string Utf16ToUtf8(std::u16string_view utf16) {
-	if (utf16.empty()) {
-		return {};
+inline int64_t ToInt64(std::string_view text, int base = 10) {
+	int64_t value = 0;
+	std::from_chars(text.data(), text.data() + text.size(), value, base);
+	return value;
+}
+
+inline double ToDouble(std::string_view text) {
+	return std::stod(std::string(text));
+}
+
+inline float ToFloat(std::string_view text) {
+	return std::stof(std::string(text));
+}
+
+inline std::string SafeCsv(std::string_view text) {
+	const bool add_space =
+	    !text.empty() && (text.front() == '+' || text.front() == '=' || text.front() == '-');
+	if (text.find('"') != std::string_view::npos || text.find(';') != std::string_view::npos ||
+	    text.find('+') != std::string_view::npos || text.find('=') != std::string_view::npos ||
+	    text.find('-') != std::string_view::npos) {
+		return "\"" + std::string(add_space ? " " : "") +
+		       ReplaceStr(std::string(text), "\"", "\"\"") + "\"";
 	}
+	return std::string(text);
+}
+
+inline std::string Utf16ToUtf8(const char16_t* utf16) {
+	std::u16string                                                    input(utf16);
 	std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
-	return convert.to_bytes(utf16.data(), utf16.data() + utf16.size());
+	return convert.to_bytes(input);
+}
+
+inline ByteBuffer HexToBin(std::string_view text) {
+	ByteBuffer ret;
+	for (size_t i = 0; i + 1 < text.size(); i += 2) {
+		ret.Add(static_cast<Byte>((ToUint32(text.substr(i, 2), 16) & 0xffu)));
+	}
+	return ret;
+}
+
+inline std::string HexFromBin(const ByteBuffer& bin) {
+	std::string ret;
+	ret.reserve(bin.Size() * 2);
+	for (uint32_t i = 0; i < bin.Size(); i++) {
+		ret += fmt::format("{:02X}", std::to_integer<uint8_t>(bin.At(i)));
+	}
+	return ret;
 }

 } // namespace Common
--- a/Show More
+++ b/Show More