kernel: share directory streams across seeks and reads

Fix PS5 boot failure when an optional empty sound path opens /app0/ and the game seeks and reads that directory. Pack directory records once and share their bytes and position across raw reads, enumeration, seeking, and size reporting. Apply seek and read error semantics with checked offsets. Add multiblock directory regression coverage using the existing production Vulkan resource lifecycle. Existing CMake build and kernel_file_system test pass. Independent correctness, fixture, runtime, and final compactness audits passed; launch.json run reached Jurassic Park gameplay with 4560 sampled flips, no Vulkan validation errors, and normal window-close exit.
graphics: simplify texture upload and component mapping paths
2026-10-21 19:36:55 +02:00 · 2026-09-10 14:36:15 +04:00 · 2026-09-10 14:36:15 +04:00
463 changed files with 32328 additions and 101094 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)
@@ -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"
@@ -479,7 +438,7 @@ add_executable(resource_materialization_tests EXCLUDE_FROM_ALL
 	"${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_link_libraries(resource_materialization_tests fmt::fmt)
 target_include_directories(resource_materialization_tests PRIVATE ${inc_headers})

 add_executable(resource_tracking_tests EXCLUDE_FROM_ALL
@@ -491,8 +450,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 +463,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 +473,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,12 +539,7 @@ 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 resource_tracking COMMAND $<TARGET_FILE:resource_tracking_tests>)
@@ -644,23 +547,9 @@ if(BUILD_TESTING)
 	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,8 +564,6 @@ 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)
@@ -692,15 +579,16 @@ if(BUILD_TESTING)
 		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,12 +597,7 @@ 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
 		resource_tracking_tests
@@ -724,56 +607,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 +649,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 +667,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,3 +0,0 @@
-{
-  "trophy.toast.earned": "تم كسب الكأس!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Trofej získána!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Trofæ optjent!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Trophäe erhalten!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Κερδίσατε ένα τρόπαιο!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Trophy earned!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Trophy earned!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "¡Ganaste un trofeo!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "¡Ganaste un trofeo!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Pokaali ansaittu!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Trophée obtenu !"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Trophée obtenu !"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Trófea megszerezve!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Trofi diperoleh!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Trofeo ottenuto!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "トロフィーを獲得しました！"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "트로피를 획득했습니다!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Trofee behaald!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Trofé opptjent!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Zdobyto trofeum!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Troféu conquistado!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Troféu conquistado!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Trofeu câștigat!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Трофей получен!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Trofé intjänad!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "ได้รับถ้วยรางวัลแล้ว!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Kupa kazanıldı!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "Đã nhận cúp!"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "已获得奖杯！"
-}
@@ -1,3 +0,0 @@
-{
-  "trophy.toast.earned": "已獲得獎盃！"
-}
@@ -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,8 +26,6 @@ target_link_libraries(common
 		cpuinfo
 		kyty_git_version
 		spdlog::spdlog
-		ZArchive::zarchive
-		nlohmann_json::nlohmann_json
 )

 get_property(inc_headers TARGET common PROPERTY INCLUDE_DIRECTORIES)
@@ -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_ */
@@ -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_ */
@@ -24,4 +24,8 @@ std::string Debug::GetLinker() {
 #endif
 }

+std::string Debug::GetBitness() {
+	return "64";
+}
+
 } // namespace Common
@@ -10,6 +10,7 @@ namespace Common {
 namespace Debug {
 std::string GetCompiler();
 std::string GetLinker();
+std::string GetBitness();
 } // namespace Debug

 } // namespace Common
@@ -23,7 +23,6 @@ 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);

 	*g_config = cfg;
 }
@@ -44,22 +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;
-}
-
 PresentMode GetPresentMode() {
 	return g_config->present_mode;
 }
@@ -72,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);
 }
@@ -100,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;
 }
@@ -112,7 +75,7 @@ ShaderOptimizationType GetShaderOptimizationType() {
 	return g_config->shader_optimization_type;
 }

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

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

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

@@ -140,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() {
@@ -160,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;
@@ -194,8 +137,4 @@ const Keymap& GetKeymap() {
 	return g_config->keymap;
 }

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

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

@@ -23,12 +21,15 @@ 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;
@@ -46,48 +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;
-	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                   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);
@@ -96,25 +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();
 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();
@@ -122,10 +97,10 @@ std::filesystem::path GetCommandBufferDumpFolder();

 bool GraphicsDebugDumpEnabled();

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

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

 bool SpirvDebugPrintfEnabled();

@@ -133,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>()) {
@@ -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_ */
@@ -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_ */
@@ -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);
@@ -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) {
@@ -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_ */
@@ -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,12 +257,65 @@ 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 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(std::u16string_view utf16) {
 	if (utf16.empty()) {
 		return {};
@@ -171,6 +324,23 @@ inline std::string Utf16ToUtf8(std::u16string_view utf16) {
 	return convert.to_bytes(utf16.data(), utf16.data() + utf16.size());
 }

+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

 #endif /* KYTY_COMMON_STRING_UTILS_H_ */
@@ -2,11 +2,17 @@

 #include "common/assert.h"

+#include <algorithm>
 #include <atomic>
 #include <cerrno>
 #include <chrono>             // IWYU pragma: keep
 #include <condition_variable> // IWYU pragma: keep
 #include <mutex>
+#include <vector>
+
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS && KYTY_COMPILER == KYTY_COMPILER_CLANG
+#define KYTY_WIN_CS
+#endif

 // macOS has no clock_nanosleep.
 #if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS && !defined(__APPLE__)
@@ -18,10 +24,11 @@
 #include <string>
 #include <thread>

-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+#ifdef KYTY_WIN_CS
 #include <windows.h> // IWYU pragma: keep
 // IWYU pragma: no_include <winbase.h>
-constexpr DWORD KYTY_CS_SPIN_COUNT = 4000;
+constexpr DWORD    KYTY_CS_SPIN_COUNT          = 4000;
+constexpr uint64_t KYTY_SLEEP_SPIN_LIMIT_100NS = 500; // 50 us

 #ifndef CREATE_WAITABLE_TIMER_HIGH_RESOLUTION
 #define CREATE_WAITABLE_TIMER_HIGH_RESOLUTION 0x00000002
@@ -32,6 +39,30 @@ static void SleepHighResolution100ns(uint64_t units_100ns) {
 		return;
 	}

+	// Keep spinning only where a kernel transition is
+	// likely to cost more than the requested delay; ordinary millisecond sleeps use the
+	// per-thread high-resolution waitable timer below.
+	if (units_100ns <= KYTY_SLEEP_SPIN_LIMIT_100NS) {
+		LARGE_INTEGER frequency {};
+		LARGE_INTEGER start {};
+		if (QueryPerformanceFrequency(&frequency) != 0 && QueryPerformanceCounter(&start) != 0 &&
+		    frequency.QuadPart > 0) {
+			const auto wait_ticks =
+			    static_cast<LONGLONG>((static_cast<long double>(units_100ns) *
+			                           static_cast<long double>(frequency.QuadPart)) /
+			                          10000000.0L);
+			const auto    deadline = start.QuadPart + std::max<LONGLONG>(wait_ticks, 1);
+			LARGE_INTEGER now {};
+			do {
+				if (QueryPerformanceCounter(&now) == 0) {
+					break;
+				}
+				YieldProcessor();
+			} while (now.QuadPart < deadline);
+			return;
+		}
+	}
+
 	thread_local HANDLE timer = CreateWaitableTimerExW(
 	    nullptr, nullptr, CREATE_WAITABLE_TIMER_HIGH_RESOLUTION, TIMER_ALL_ACCESS);
 	if (timer == nullptr) {
@@ -101,13 +132,14 @@ static SleepConditionVariableCS_func_t ResolveSleepConditionVariableCS() {
 #endif

 #ifdef KYTY_POSIX_HIGH_RES_SLEEP
-// An absolute deadline preserves the requested sleep across signal interruptions.
+// Spin for very short waits; use an absolute deadline for longer waits.
 static void SleepHighResolutionNanos(uint64_t nanos) {
 	if (nanos == 0) {
 		return;
 	}

 	constexpr uint64_t NANOS_PER_SEC = 1000000000;
+	constexpr uint64_t SPIN_LIMIT_NS = 50000; // below this a context switch dominates

 	timespec deadline {};
 	if (clock_gettime(CLOCK_MONOTONIC, &deadline) != 0) {
@@ -119,6 +151,17 @@ static void SleepHighResolutionNanos(uint64_t nanos) {
 	deadline.tv_sec += static_cast<time_t>(target_nsec / NANOS_PER_SEC);
 	deadline.tv_nsec = static_cast<long>(target_nsec % NANOS_PER_SEC);

+	if (nanos <= SPIN_LIMIT_NS) {
+		timespec now {};
+		do {
+			if (clock_gettime(CLOCK_MONOTONIC, &now) != 0) {
+				return;
+			}
+		} while (now.tv_sec < deadline.tv_sec ||
+		         (now.tv_sec == deadline.tv_sec && now.tv_nsec < deadline.tv_nsec));
+		return;
+	}
+
 	while (clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &deadline, nullptr) == EINTR) {
 	}
 }
@@ -129,7 +172,7 @@ namespace Common {
 using thread_id_t = std::thread::id;

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

 struct CondVarPrivate {
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+#ifdef KYTY_WIN_CS
 	CondVarPrivate() {
 		static auto func = ResolveInitializeConditionVariable();
 		EXIT_NOT_IMPLEMENTED(func == nullptr);
@@ -154,7 +197,37 @@ struct CondVarPrivate {
 #endif
 };

-static wait_poll_func_t g_cond_wait_poll_callback = nullptr;
+static std::recursive_mutex                         g_cond_waiters_mutex;
+static std::vector<std::pair<int, CondVarPrivate*>> g_cond_waiters;
+static wait_poll_func_t                             g_cond_wait_poll_callback = nullptr;
+
+static void WakeCondVar(CondVarPrivate* cond_var) {
+#ifdef KYTY_WIN_CS
+	static auto func = ResolveWakeAllConditionVariable();
+	EXIT_NOT_IMPLEMENTED(func == nullptr);
+	func(&cond_var->m_cv);
+#else
+	cond_var->m_cv.notify_all();
+#endif
+}
+
+static void RegisterCondWaiter(CondVarPrivate* cond_var) {
+	std::lock_guard lock(g_cond_waiters_mutex);
+	g_cond_waiters.emplace_back(Thread::GetThreadIdUnique(), cond_var);
+}
+
+static void UnregisterCondWaiter(CondVarPrivate* cond_var) {
+	const auto      thread_id = Thread::GetThreadIdUnique();
+	std::lock_guard lock(g_cond_waiters_mutex);
+
+	const auto it = std::find_if(g_cond_waiters.begin(), g_cond_waiters.end(),
+	                             [thread_id, cond_var](const auto& waiter) {
+		                             return waiter.first == thread_id && waiter.second == cond_var;
+	                             });
+	if (it != g_cond_waiters.end()) {
+		g_cond_waiters.erase(it);
+	}
+}

 struct ThreadPrivate {
 	ThreadPrivate(thread_func_t f, void* a): func(f), arg(a), m_thread(&Run, this) {}
@@ -211,8 +284,12 @@ void Thread::Detach() {
 	m_thread->m_thread.detach();
 }

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

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

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

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

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

 void CondVar::Wait(Mutex* mutex) {
-#if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS
+	RegisterCondWaiter(m_cond_var.get());
+#ifndef KYTY_WIN_CS
 	std::unique_lock<std::recursive_mutex> cpp_lock(mutex->m_mutex->m_mutex, std::adopt_lock_t());
 #endif
 	auto poll_callback = [&] {
@@ -296,7 +374,7 @@ void CondVar::Wait(Mutex* mutex) {
 		if (callback == nullptr) {
 			return;
 		}
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+#if defined(KYTY_WIN_CS)
 		LeaveCriticalSection(&mutex->m_mutex->m_cs);
 		callback();
 		EnterCriticalSection(&mutex->m_mutex->m_cs);
@@ -306,7 +384,7 @@ void CondVar::Wait(Mutex* mutex) {
 		cpp_lock.lock();
 #endif
 	};
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+#ifdef KYTY_WIN_CS
 	static auto func = ResolveSleepConditionVariableCS();
 	EXIT_NOT_IMPLEMENTED(func == nullptr);
 	if (g_cond_wait_poll_callback == nullptr) {
@@ -328,6 +406,7 @@ void CondVar::Wait(Mutex* mutex) {
 	}
 	cpp_lock.release();
 #endif
+	UnregisterCondWaiter(m_cond_var.get());
 }

 void CondVar::SetWaitPollCallback(wait_poll_func_t callback) {
@@ -336,10 +415,11 @@ void CondVar::SetWaitPollCallback(wait_poll_func_t callback) {

 bool CondVar::WaitFor(Mutex* mutex, uint32_t micros) {
 	bool ok = false;
-#if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS
+	RegisterCondWaiter(m_cond_var.get());
+#ifndef KYTY_WIN_CS
 	std::unique_lock<std::recursive_mutex> cpp_lock(mutex->m_mutex->m_mutex, std::adopt_lock_t());
 #endif
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+#ifdef KYTY_WIN_CS
 	static auto func = ResolveSleepConditionVariableCS();
 	EXIT_NOT_IMPLEMENTED(func == nullptr);
 	ok = !(func(&m_cond_var->m_cv, &mutex->m_mutex->m_cs, (micros < 1000 ? 1 : micros / 1000)) ==
@@ -350,11 +430,12 @@ bool CondVar::WaitFor(Mutex* mutex, uint32_t micros) {
 	      std::cv_status::no_timeout);
 	cpp_lock.release();
 #endif
+	UnregisterCondWaiter(m_cond_var.get());
 	return ok;
 }

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

 void CondVar::SignalAll() {
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-	static auto func = ResolveWakeAllConditionVariable();
-	EXIT_NOT_IMPLEMENTED(func == nullptr);
-	func(&m_cond_var->m_cv);
-#else
-	m_cond_var->m_cv.notify_all();
-#endif
+	WakeCondVar(m_cond_var.get());
+}
+
+void CondVar::SignalThread(int thread_id) {
+	std::lock_guard lock(g_cond_waiters_mutex);
+	for (const auto& waiter: g_cond_waiters) {
+		if (waiter.first == thread_id) {
+			WakeCondVar(waiter.second);
+		}
+	}
 }

 int Thread::GetThreadIdUnique() {
@@ -31,6 +31,7 @@ public:
 	// The id is unique and can't be reused by another thread.
 	[[nodiscard]] int GetUniqueId() const;

+	static void Sleep(uint32_t millis);
 	static void SleepMicro(uint32_t micros);
 	static void SleepNano(uint64_t nanos);
 	static bool IsMainThread();
@@ -76,6 +77,7 @@ public:
 	void Signal();
 	void SignalAll();

+	static void SignalThread(int thread_id);
 	static void SetWaitPollCallback(wait_poll_func_t callback);

 	KYTY_CLASS_NO_COPY(CondVar);
@@ -38,7 +38,16 @@ bool Timer::IsPaused() const {

 // return time in milliseconds
 double Timer::GetTimeMs() const {
-	return GetTimeS() * 1000.0;
+	if (m_is_paused) {
+		return 1000.0 * (static_cast<double>(m_PauseTime - m_StartTime)) /
+		       static_cast<double>(m_Frequency);
+	}
+
+	uint64_t current_time = 0;
+	SysQueryPerformanceCounter(&current_time);
+
+	return 1000.0 * (static_cast<double>(current_time - m_StartTime)) /
+	       static_cast<double>(m_Frequency);
 }

 // return time in seconds
@@ -53,6 +62,23 @@ double Timer::GetTimeS() const {
 	return (static_cast<double>(current_time - m_StartTime)) / static_cast<double>(m_Frequency);
 }

+// return time in ticks
+uint64_t Timer::GetTicks() const {
+	if (m_is_paused) {
+		return (m_PauseTime - m_StartTime);
+	}
+
+	uint64_t current_time = 0;
+	SysQueryPerformanceCounter(&current_time);
+
+	return (current_time - m_StartTime);
+}
+
+// return ticks frequency
+uint64_t Timer::GetFrequency() const {
+	return m_Frequency;
+}
+
 uint64_t Timer::QueryPerformanceFrequency() {
 	uint64_t ret = 0;
 	SysQueryPerformanceFrequency(&ret);
@@ -24,6 +24,12 @@ public:
 	// return time in seconds
 	[[nodiscard]] double GetTimeS() const;

+	// return time in ticks
+	[[nodiscard]] uint64_t GetTicks() const;
+
+	// return ticks frequency
+	[[nodiscard]] uint64_t GetFrequency() const;
+
 	KYTY_CLASS_NO_COPY(Timer);

 	[[nodiscard]] static uint64_t QueryPerformanceFrequency();
@@ -1,447 +0,0 @@
-#include "common/trophies.h"
-
-#include "common/file.h"
-#include "common/localization.h"
-
-#include <algorithm>
-#include <charconv>
-#include <fmt/format.h>
-#include <nlohmann/json.hpp>
-#include <span>
-
-namespace Common::Trophies {
-namespace {
-
-using Json  = nlohmann::json;
-using Files = std::map<std::string_view, std::span<const std::byte>>;
-
-constexpr uint64_t MaxUnlocksSize = uint64_t {1} << 20u;
-constexpr uint64_t MaxPackageSize = uint64_t {1} << 30u;
-
-uint64_t ReadBigEndian(const std::byte* data, size_t size) {
-	uint64_t value = 0;
-	for (size_t i = 0; i < size; ++i) {
-		value = (value << 8u) | std::to_integer<uint8_t>(data[i]);
-	}
-	return value;
-}
-
-int ReadId(const Json& value) {
-	if (value.is_number_integer()) {
-		const auto number = value.get<int64_t>();
-		return number >= 0 && number <= INT32_MAX ? static_cast<int>(number) : -1;
-	}
-	if (!value.is_string()) {
-		return -1;
-	}
-	const auto& text        = value.get_ref<const std::string&>();
-	int         id          = -1;
-	const auto [end, error] = std::from_chars(text.data(), text.data() + text.size(), id);
-	return error == std::errc {} && end == text.data() + text.size() && id >= 0 ? id : -1;
-}
-
-std::optional<uint64_t> ReadUnsigned(const Json& value) {
-	if (value.is_number_unsigned()) {
-		return value.get<uint64_t>();
-	}
-	if (value.is_number_integer()) {
-		const auto number = value.get<int64_t>();
-		return number >= 0 ? std::optional<uint64_t>(static_cast<uint64_t>(number)) : std::nullopt;
-	}
-	if (!value.is_string()) {
-		return std::nullopt;
-	}
-	const auto& text        = value.get_ref<const std::string&>();
-	uint64_t    number      = 0;
-	const auto [end, error] = std::from_chars(text.data(), text.data() + text.size(), number);
-	return error == std::errc {} && end == text.data() + text.size()
-	           ? std::optional<uint64_t>(number)
-	           : std::nullopt;
-}
-
-Json ReadJson(const Files& files, std::string_view name) {
-	const auto entry = files.find(name);
-	if (entry == files.end()) {
-		return {};
-	}
-	return Json::parse(entry->second.begin(), entry->second.end(), nullptr, false);
-}
-
-bool ReadFiles(std::span<const std::byte> data, Files& files, uint64_t& size) {
-	if (data.size() < 0x40 || data.size() > MaxPackageSize ||
-	    ReadBigEndian(data.data(), 4) != 0xb228c60a || ReadBigEndian(data.data() + 4, 4) != 1) {
-		return false;
-	}
-	size             = ReadBigEndian(data.data() + 8, 8);
-	const auto count = ReadBigEndian(data.data() + 0x10, 4);
-	const auto toc   = ReadBigEndian(data.data() + 0x14, 4);
-	if (size < 0x40 || size > data.size() || count > 4096 || toc > size ||
-	    0x20 + count * 0x40 > size - toc) {
-		return false;
-	}
-	for (uint64_t i = 0; i < count; ++i) {
-		const auto*            entry = data.data() + toc + 0x20 + i * 0x40;
-		const auto*            name  = reinterpret_cast<const char*>(entry);
-		const std::string_view filename(name, std::find(name, name + 0x20, '\0') - name);
-		const auto             offset = ReadBigEndian(entry + 0x20, 8);
-		const auto             length = ReadBigEndian(entry + 0x28, 8);
-		if (offset > size || length > size - offset) {
-			return false;
-		}
-		files.emplace(filename, data.subspan(offset, length));
-	}
-	return true;
-}
-
-Package ParsePackage(std::span<const std::byte> data, int console_language) {
-	Files    files;
-	uint64_t size = 0;
-	if (!ReadFiles(data, files, size)) {
-		return {};
-	}
-	const auto conf = ReadJson(files, "tropconf.json");
-	if (!conf.is_object() || !conf.contains("trophies") || !conf["trophies"].is_array() ||
-	    conf["trophies"].size() > 1000 || !conf.contains("defaultLanguage") ||
-	    !conf["defaultLanguage"].is_string()) {
-		return {};
-	}
-	const auto locale = Localization::LocaleName(console_language);
-	auto meta = ReadJson(files, fmt::format("tropmeta_{}.json", locale));
-	if (meta.is_null()) {
-		meta = ReadJson(files, fmt::format("tropmeta_{}.json",
-		                                   conf["defaultLanguage"].get_ref<const std::string&>()));
-	}
-	if (!meta.is_object() || !meta.contains("metadata") || !meta["metadata"].is_object()) {
-		return {};
-	}
-	const auto& texts = meta["metadata"];
-	if (!texts.contains("titleMetadata") || !texts["titleMetadata"].is_object() ||
-	    !texts["titleMetadata"].contains("name") || !texts["titleMetadata"]["name"].is_string() ||
-	    !texts.contains("trophyMetadata") || !texts["trophyMetadata"].is_array()) {
-		return {};
-	}
-	Package package;
-	package.title = texts["titleMetadata"]["name"].get<std::string>();
-	package.groups.emplace(-1, package.title);
-	uint64_t icon_bytes = 0;
-	for (const auto& definition: conf["trophies"]) {
-		if (!definition.is_object() || !definition.contains("id") ||
-		    !definition.contains("grade") || !definition["grade"].is_string()) {
-			return {};
-		}
-		Trophy trophy;
-		trophy.id              = ReadId(definition["id"]);
-		const auto grade       = definition["grade"].get<std::string>();
-		const auto grade_index = std::string_view("PGSB").find(grade);
-		if (trophy.id < 0 || grade.size() != 1 || grade_index == std::string_view::npos) {
-			return {};
-		}
-		trophy.grade = static_cast<int>(grade_index) + 1;
-		if (definition.contains("groupId")) {
-			trophy.group_id = ReadId(definition["groupId"]);
-			if (trophy.group_id < 0) {
-				return {};
-			}
-		}
-		if (definition.contains("platinumTrophyId")) {
-			trophy.platinum_id = ReadId(definition["platinumTrophyId"]);
-		}
-		trophy.hidden     = definition.contains("hidden") && definition["hidden"] == true;
-		trophy.has_reward = definition.contains("hasReward") && definition["hasReward"] == true;
-		if (definition.contains("unlockCondition")) {
-			const auto& condition = definition["unlockCondition"];
-			if (condition.is_object()) {
-				trophy.progressive =
-				    condition.contains("progressive") && condition["progressive"] == true;
-				if (condition.contains("udsStatId")) {
-					trophy.uds_stat_id = ReadUnsigned(condition["udsStatId"]);
-					if (!trophy.uds_stat_id) {
-						return {};
-					}
-				}
-				if (condition.contains("targetValue")) {
-					trophy.target = ReadUnsigned(condition["targetValue"]);
-				}
-				const auto comparison = condition.find("comparator");
-				if (comparison != condition.end()) {
-					if (*comparison == "ge")
-						trophy.comparison = Comparison::GreaterEqual;
-					else if (*comparison == "gt")
-						trophy.comparison = Comparison::Greater;
-					else if (*comparison == "le")
-						trophy.comparison = Comparison::LessEqual;
-					else if (*comparison == "lt")
-						trophy.comparison = Comparison::Less;
-				}
-			}
-		}
-		const auto icon = files.find(fmt::format("trop{:04}.png", trophy.id));
-		if (icon != files.end()) {
-			if (icon->second.size() > size - icon_bytes) {
-				return {};
-			}
-			trophy.icon_png.assign(icon->second.begin(), icon->second.end());
-			icon_bytes += icon->second.size();
-		}
-		package.groups.try_emplace(trophy.group_id);
-		if (package.groups.size() > 50 ||
-		    !package.trophies.emplace(trophy.id, std::move(trophy)).second) {
-			return {};
-		}
-	}
-	if (texts.contains("groupMetadata") && texts["groupMetadata"].is_array()) {
-		for (const auto& group: texts["groupMetadata"]) {
-			if (group.is_object() && group.contains("id") && group.contains("name") &&
-			    group["name"].is_string()) {
-				const auto found = package.groups.find(ReadId(group["id"]));
-				if (found != package.groups.end()) {
-					found->second = group["name"].get<std::string>();
-				}
-			}
-		}
-	}
-	for (const auto& text: texts["trophyMetadata"]) {
-		if (!text.is_object() || !text.contains("id")) {
-			continue;
-		}
-		const auto found = package.trophies.find(ReadId(text["id"]));
-		if (found == package.trophies.end()) {
-			continue;
-		}
-		for (const auto& [key, field]: {std::pair {"name", &found->second.name},
-		                                {"detail", &found->second.description},
-		                                {"reward", &found->second.reward}}) {
-			if (text.contains(key) && text[key].is_string()) {
-				*field = text[key].get<std::string>();
-			}
-		}
-	}
-	return package;
-}
-
-} // namespace
-
-Package LoadPackage(const std::filesystem::path& path, int console_language) {
-	File file(path, File::Mode::Read);
-	if (file.IsInvalid() || file.Size() > MaxPackageSize) {
-		return {};
-	}
-	return ParsePackage(file.ReadWholeBuffer(), console_language);
-}
-
-std::filesystem::path PackagePath(uint32_t service_label) {
-	return std::filesystem::path(PackageDirectory) / fmt::format("trophy{:02}.ucp", service_label);
-}
-
-std::filesystem::path UnlocksPath(const std::filesystem::path& root, std::string_view title_id,
-                                  int user_id, uint32_t service_label) {
-	if (title_id.empty() || !std::all_of(title_id.begin(), title_id.end(), [](char c) {
-		    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||
-		           c == '_' || c == '-';
-	    })) {
-		return {};
-	}
-	return root / "_Trophies" / title_id /
-	       fmt::format("trophies_{}_{}.json", user_id, service_label);
-}
-
-UnlockData LoadUnlockData(const std::filesystem::path& path) {
-	File file(path, File::Mode::Read);
-	if (file.IsInvalid() || file.Size() > MaxUnlocksSize) {
-		return {};
-	}
-	const auto bytes = file.ReadWholeBuffer();
-	const auto json  = Json::parse(bytes.begin(), bytes.end(), nullptr, false);
-	if (!json.is_object() || !json.contains("unlockedTrophies") ||
-	    !json["unlockedTrophies"].is_array()) {
-		return {};
-	}
-	UnlockData unlocks;
-	for (const auto& value: json["unlockedTrophies"]) {
-		const auto id = ReadId(value);
-		if (id >= 0) {
-			unlocks.unlocked.insert(id);
-		}
-	}
-	if (json.contains("unlockedAt") && json["unlockedAt"].is_object()) {
-		for (auto it = json["unlockedAt"].begin(); it != json["unlockedAt"].end(); ++it) {
-			const auto id = ReadId(Json(it.key()));
-			if (id >= 0 && unlocks.unlocked.contains(id)) {
-				const auto tick = ReadUnsigned(it.value());
-				if (tick && *tick >= UnixEpochTick && *tick <= 315537897599999999ULL) {
-					unlocks.timestamps.emplace(id, *tick);
-				}
-			}
-		}
-	}
-	return unlocks;
-}
-
-bool SaveUnlockData(const std::filesystem::path& path, const UnlockData& unlocks) {
-	if (path.empty() || !File::CreateDirectories(path.parent_path())) {
-		return false;
-	}
-	Json timestamps = Json::object();
-	for (const auto& [id, tick]: unlocks.timestamps) {
-		if (unlocks.unlocked.contains(id)) {
-			timestamps[std::to_string(id)] = tick;
-		}
-	}
-	const auto text =
-	    Json {{"unlockedTrophies", unlocks.unlocked}, {"unlockedAt", timestamps}}.dump();
-	auto temporary = path;
-	temporary += ".tmp";
-	File file;
-	if (text.size() > MaxUnlocksSize || !file.Create(temporary)) {
-		return false;
-	}
-	uint32_t written = 0;
-	file.Write(text.data(), static_cast<uint32_t>(text.size()), &written);
-	const bool complete = written == text.size() && file.Flush();
-	file.Close();
-	std::error_code error;
-	if (complete) {
-		std::filesystem::rename(temporary, path, error);
-		if (!error) {
-			return true;
-		}
-	}
-	std::filesystem::remove(temporary, error);
-	return false;
-}
-
-UdsRules LoadUdsRules(const std::filesystem::path& path) {
-	File file(path, File::Mode::Read);
-	if (file.IsInvalid() || file.Size() > MaxPackageSize) {
-		return {};
-	}
-	const auto bytes = file.ReadWholeBuffer();
-	Files      files;
-	uint64_t   size = 0;
-	if (!ReadFiles(bytes, files, size)) {
-		return {};
-	}
-	const auto definitions = ReadJson(files, "stats_definition.json");
-	const auto extraction  = ReadJson(files, "stats_extraction.json");
-	if (!definitions.is_object() || !definitions.contains("statDefinitionArray") ||
-	    !definitions["statDefinitionArray"].is_array() || !extraction.is_object() ||
-	    !extraction.contains("statsExtractionRuleArray") ||
-	    !extraction["statsExtractionRuleArray"].is_array()) {
-		return {};
-	}
-	// Only direct unsigned latest-value stats are evaluated here. Aggregated stats
-	// and filtered/nested extraction require UDS state and event types we do not implement.
-	std::map<uint64_t, bool> stats;
-	for (const auto& definition: definitions["statDefinitionArray"]) {
-		if (!definition.is_object() || !definition.contains("statId") ||
-		    !definition.contains("aggregation") || definition["aggregation"] != "latest" ||
-		    !definition.contains("dataType")) {
-			continue;
-		}
-		const auto  id   = ReadUnsigned(definition["statId"]);
-		const auto& type = definition["dataType"];
-		if (!id || (type != "uint64" && type != "uint32")) {
-			continue;
-		}
-		const uint64_t maximum = type == "uint32" ? UINT32_MAX : UINT64_MAX;
-		if ((definition.contains("minValue") && ReadUnsigned(definition["minValue"]) != 0) ||
-		    (definition.contains("maxValue") && ReadUnsigned(definition["maxValue"]) != maximum)) {
-			continue;
-		}
-		stats.emplace(*id, type == "uint32");
-	}
-	UdsRules events;
-	for (const auto& rule: extraction["statsExtractionRuleArray"]) {
-		if (!rule.is_object() || !rule.contains("condition") || !rule.contains("action")) {
-			continue;
-		}
-		const auto& condition = rule["condition"];
-		const auto& action    = rule["action"];
-		if (!condition.is_object() || condition.size() != 1 || !condition.contains("eventName") ||
-		    !condition["eventName"].is_string() || !action.is_object() ||
-		    !action.contains("input") || !action["input"].is_string() ||
-		    !action.contains("output") || !action["output"].is_object() ||
-		    !action["output"].contains("statId")) {
-			continue;
-		}
-		const auto  id    = ReadUnsigned(action["output"]["statId"]);
-		const auto& input = action["input"].get_ref<const std::string&>();
-		if (!id || !stats.contains(*id) || !input.starts_with("$.") || input.size() == 2 ||
-		    input.find_first_not_of(
-		        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_", 2) !=
-		        std::string::npos) {
-			continue;
-		}
-		events[condition["eventName"].get<std::string>()].push_back(
-		    {*id, input.substr(2), stats.at(*id)});
-	}
-	return events;
-}
-
-std::filesystem::path UdsPackagePath(uint32_t service_label) {
-	return std::filesystem::path("sce_sys/uds") / fmt::format("uds{:02}.ucp", service_label);
-}
-
-std::vector<int> FindUdsTrophies(const Package& package, std::string_view event_name,
-                                 const std::map<std::string, UdsInteger>& properties) {
-	const auto rules = package.event_rules.find(std::string(event_name));
-	if (rules == package.event_rules.end()) {
-		return {};
-	}
-	std::vector<int> ids;
-	for (const auto& [id, trophy]: package.trophies) {
-		if (trophy.grade == 1 || !trophy.uds_stat_id || !trophy.target) {
-			continue;
-		}
-		for (const auto& rule: rules->second) {
-			const auto value = properties.find(rule.input);
-			if (rule.stat_id != *trophy.uds_stat_id || value == properties.end()) {
-				continue;
-			}
-			std::optional<uint64_t> number;
-			if (rule.is_uint32) {
-				if (const auto* input = std::get_if<uint32_t>(&value->second)) number = *input;
-			} else if (const auto* input = std::get_if<uint64_t>(&value->second)) {
-				number = *input;
-			}
-			if (!number) continue;
-			bool matched = false;
-			switch (trophy.comparison) {
-				case Comparison::GreaterEqual: matched = *number >= *trophy.target; break;
-				case Comparison::Greater: matched = *number > *trophy.target; break;
-				case Comparison::LessEqual: matched = *number <= *trophy.target; break;
-				case Comparison::Less: matched = *number < *trophy.target; break;
-				case Comparison::None: break;
-			}
-			if (matched) {
-				ids.push_back(id);
-				break;
-			}
-		}
-	}
-	return ids;
-}
-
-uint32_t Progress::Percentage() const {
-	const auto points        = total_grade[2] * 6 + total_grade[3] * 2 + total_grade[4];
-	const auto earned_points = earned_grade[2] * 6 + earned_grade[3] * 2 + earned_grade[4];
-	return points == 0 ? 0 : earned_points * 100 / points;
-}
-
-Progress GetProgress(const Package& package, const UnlockData& unlocks, std::optional<int> group) {
-	Progress progress;
-	for (const auto& [id, trophy]: package.trophies) {
-		if (group && trophy.group_id != *group) {
-			continue;
-		}
-		++progress.total;
-		++progress.total_grade[trophy.grade];
-		if (unlocks.unlocked.contains(id)) {
-			++progress.earned;
-			++progress.earned_grade[trophy.grade];
-		}
-	}
-	return progress;
-}
-
-} // namespace Common::Trophies
@@ -1,87 +0,0 @@
-#ifndef KYTY_COMMON_TROPHIES_H_
-#define KYTY_COMMON_TROPHIES_H_
-
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <filesystem>
-#include <map>
-#include <optional>
-#include <set>
-#include <string>
-#include <string_view>
-#include <variant>
-#include <vector>
-
-namespace Common::Trophies {
-
-inline constexpr char     PackageDirectory[] = "sce_sys/trophy2";
-inline constexpr uint64_t UnixEpochTick      = 62135596800000000ULL;
-
-enum class Comparison { None, GreaterEqual, Greater, LessEqual, Less };
-
-struct Trophy {
-	int                     id          = 0;
-	int                     group_id    = -1;
-	int                     platinum_id = -1;
-	int                     grade       = 0;
-	std::optional<uint64_t> target;
-	std::optional<uint64_t> uds_stat_id;
-	Comparison              comparison  = Comparison::None;
-	bool                    progressive = false;
-	std::string             name;
-	std::string             description;
-	std::string             reward;
-	std::vector<std::byte>  icon_png;
-	bool                    hidden     = false;
-	bool                    has_reward = false;
-};
-
-struct UdsRule {
-	uint64_t    stat_id;
-	std::string input;
-	bool        is_uint32;
-};
-
-using UdsRules   = std::map<std::string, std::vector<UdsRule>>;
-using UdsInteger = std::variant<int32_t, uint32_t, uint64_t>;
-
-struct Package {
-	std::string                title;
-	std::map<int, std::string> groups;
-	std::map<int, Trophy>      trophies;
-	UdsRules                   event_rules;
-};
-
-struct UnlockData {
-	std::set<int>           unlocked;
-	std::map<int, uint64_t> timestamps;
-};
-
-struct Progress {
-	std::array<uint32_t, 5> total_grade {};
-	std::array<uint32_t, 5> earned_grade {};
-	uint32_t                total  = 0;
-	uint32_t                earned = 0;
-
-	[[nodiscard]] uint32_t Percentage() const;
-};
-
-[[nodiscard]] Progress GetProgress(const Package& package, const UnlockData& unlocks,
-                                   std::optional<int> group = std::nullopt);
-
-[[nodiscard]] Package LoadPackage(const std::filesystem::path& path, int console_language);
-[[nodiscard]] std::filesystem::path PackagePath(uint32_t service_label);
-[[nodiscard]] std::filesystem::path UdsPackagePath(uint32_t service_label);
-[[nodiscard]] UdsRules              LoadUdsRules(const std::filesystem::path& path);
-[[nodiscard]] std::vector<int> FindUdsTrophies(const Package& package, std::string_view event_name,
-                                               const std::map<std::string, UdsInteger>& properties);
-[[nodiscard]] std::filesystem::path UnlocksPath(const std::filesystem::path& root,
-                                                std::string_view title_id, int user_id,
-                                                uint32_t service_label);
-[[nodiscard]] UnlockData            LoadUnlockData(const std::filesystem::path& path);
-[[nodiscard]] bool SaveUnlockData(const std::filesystem::path& path, const UnlockData& unlocks);
-
-} // namespace Common::Trophies
-
-#endif // KYTY_COMMON_TROPHIES_H_
@@ -0,0 +1,63 @@
+#include "common/virtualMemory.h"
+
+#include "common/platform/sysVirtual.h"
+
+namespace Common {
+
+namespace VirtualMemory {
+
+void Init() {
+	SysVirtualInit();
+}
+
+uint64_t Alloc(uint64_t address, uint64_t size, Mode mode) {
+	return SysVirtualAlloc(address, size, mode);
+}
+
+uint64_t AllocAligned(uint64_t address, uint64_t size, Mode mode, uint64_t alignment) {
+	return SysVirtualAllocAligned(address, size, mode, alignment);
+}
+
+bool AllocFixed(uint64_t address, uint64_t size, Mode mode) {
+	return SysVirtualAllocFixed(address, size, mode);
+}
+
+bool Commit(uint64_t address, uint64_t size, Mode mode) {
+	return SysVirtualCommit(address, size, mode);
+}
+
+uint64_t Reserve(uint64_t address, uint64_t size) {
+	return SysVirtualReserve(address, size);
+}
+
+uint64_t ReserveAligned(uint64_t address, uint64_t size, uint64_t alignment) {
+	return SysVirtualReserveAligned(address, size, alignment);
+}
+
+bool ReserveFixed(uint64_t address, uint64_t size) {
+	return SysVirtualReserveFixed(address, size);
+}
+
+bool Decommit(uint64_t address, uint64_t size) {
+	return SysVirtualDecommit(address, size);
+}
+
+bool Free(uint64_t address) {
+	return SysVirtualFree(address);
+}
+
+bool FreeRange(uint64_t address, uint64_t size) {
+	return SysVirtualFreeRange(address, size);
+}
+
+bool Protect(uint64_t address, uint64_t size, Mode mode, Mode* old_mode) {
+	return SysVirtualProtect(address, size, mode, old_mode);
+}
+
+bool FlushInstructionCache(uint64_t address, uint64_t size) {
+	return SysVirtualFlushInstructionCache(address, size);
+}
+
+} // namespace VirtualMemory
+
+} // namespace Common
@@ -35,7 +35,7 @@ bool     ReserveFixed(uint64_t address, uint64_t size);
 bool     Decommit(uint64_t address, uint64_t size);
 bool     Free(uint64_t address);
 bool     FreeRange(uint64_t address, uint64_t size);
-bool     Protect(uint64_t address, uint64_t size, Mode mode);
+bool     Protect(uint64_t address, uint64_t size, Mode mode, Mode* old_mode = nullptr);
 bool     FlushInstructionCache(uint64_t address, uint64_t size);

 } // namespace VirtualMemory
@@ -1,62 +0,0 @@
-if(NOT DEFINED INPUTS OR NOT DEFINED OUTPUT)
-	message(FATAL_ERROR "embed_localization.cmake requires INPUTS and OUTPUT")
-endif()
-
-set(contents "// Generated from assets/localization; do not edit.\n#pragma once\n#include <span>\n#include <string_view>\n\nnamespace {\n")
-set(lookup "std::span<const unsigned char> EmbeddedCatalog(std::string_view locale) {\n")
-set(continuation "[89ab][0-9a-f]")
-string(CONCAT utf8_character
-	"[0-7][0-9a-f]|(c[2-9a-f]|d[0-9a-f])${continuation}"
-	"|e0[ab][0-9a-f]${continuation}|e[1-9abcef]${continuation}${continuation}"
-	"|ed[89][0-9a-f]${continuation}|f0[9ab][0-9a-f]${continuation}${continuation}"
-	"|f[123]${continuation}${continuation}${continuation}|f48[0-9a-f]${continuation}${continuation}")
-foreach(catalog IN LISTS INPUTS)
-	file(READ "${catalog}" bytes HEX)
-	# Validate UTF-8, excluding overlong sequences, surrogates, and values above U+10FFFF.
-	if(NOT bytes MATCHES "^(${utf8_character})*$")
-		message(FATAL_ERROR "Localization must be UTF-8: ${catalog}")
-	endif()
-	file(READ "${catalog}" json)
-	string(JSON type ERROR_VARIABLE error TYPE "${json}")
-	if(error OR NOT type STREQUAL "OBJECT")
-		message(FATAL_ERROR "Invalid localization object in ${catalog}: ${error}")
-	endif()
-	string(JSON count LENGTH "${json}")
-	if(count GREATER 0)
-		math(EXPR last "${count} - 1")
-		foreach(index RANGE ${last})
-			string(JSON key MEMBER "${json}" ${index})
-			string(JSON type TYPE "${json}" "${key}")
-			if(NOT type STREQUAL "STRING")
-				message(FATAL_ERROR "Localization value '${key}' must be a string: ${catalog}")
-			endif()
-			string(JSON text GET "${json}" "${key}")
-			if(key STREQUAL "" OR text STREQUAL "")
-				message(FATAL_ERROR "Localization keys and values must not be empty: ${catalog}")
-			endif()
-		endforeach()
-	endif()
-	get_filename_component(locale "${catalog}" NAME_WE)
-	if(locale STREQUAL "en-US")
-		string(JSON earned ERROR_VARIABLE error GET "${json}" "trophy.toast.earned")
-		if(error OR earned STREQUAL "")
-			message(FATAL_ERROR "English localization requires trophy.toast.earned: ${catalog}")
-		endif()
-		set(english_found TRUE)
-	endif()
-	string(MAKE_C_IDENTIFIER "${locale}" symbol)
-	string(REGEX REPLACE "(..)" "0x\\1," bytes "${bytes}")
-	string(APPEND contents "constexpr unsigned char catalog_${symbol}[] = {${bytes}};\n")
-	string(APPEND lookup "\tif (locale == \"${locale}\") return catalog_${symbol};\n")
-endforeach()
-if(NOT english_found)
-	message(FATAL_ERROR "Localization requires an en-US.json fallback")
-endif()
-string(APPEND contents "\n${lookup}\treturn {};\n}\n} // namespace\n")
-
-get_filename_component(output_dir "${OUTPUT}" DIRECTORY)
-file(MAKE_DIRECTORY "${output_dir}")
-file(WRITE "${OUTPUT}.tmp" "${contents}")
-execute_process(COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${OUTPUT}.tmp" "${OUTPUT}"
-	COMMAND_ERROR_IS_FATAL ANY)
-file(REMOVE "${OUTPUT}.tmp")
@@ -11,7 +11,6 @@
 #include "common/subsystems.h"
 #include "common/systemInfo.h"
 #include "common/threads.h"
-#include "graphics/presentation/systemOverlay.h"
 #include "graphics/presentation/window.h"
 #include "kernel/fileSystem.h"
 #include "kernel/memory.h"
@@ -22,7 +21,6 @@
 #include "libs/controller.h"
 #include "libs/libs.h"
 #include "libs/network.h"
-#include "loader/additionalContent.h"
 #include "loader/runtimeLinker.h"
 #include "loader/systemContent.h"
 #include "loader/timer.h"
@@ -140,9 +138,6 @@ static void Init(const Config::ConfigOptions& cfg, const std::filesystem::path&
 			Libs::LibKernel::Memory::SetFlexibleMemorySize(flexible_memory_size);
 		}
 	}
-	if (cfg.splash_enabled) {
-		Libs::Graphics::InitializeSplashScreen(param_json.parent_path());
-	}

 	// Initialization order is explicit; destruction is automatic and reversed.
 	subsystems.Initialize<Loader::Timer::Lifecycle>();
@@ -201,18 +196,6 @@ void Run(const RunOptions& options) {
 	ClearDebugTextureFolder();

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

 	int ok = atexit(KytyClose);
 	EXIT_NOT_IMPLEMENTED(ok != 0);
@@ -226,7 +209,6 @@ void Run(const RunOptions& options) {

 	MountSandboxDirs();

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

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

 void Run(const RunOptions& options);
-int LoadExec(const char* path, const char* const argv[]);

 } // namespace Emulator

--- a/Show More
+++ b/Show More