TEST

.patch/boost/0001-clang-cl.patch

@@ -0,0 +1,13 @@
+diff --git a/libs/cobalt/include/boost/cobalt/concepts.hpp b/libs/cobalt/include/boost/cobalt/concepts.hpp
+index d49f2ec..a9bdb80 100644
+--- a/libs/cobalt/include/boost/cobalt/concepts.hpp
++++ b/libs/cobalt/include/boost/cobalt/concepts.hpp
+@@ -62,7 +62,7 @@ struct enable_awaitables
+ template <typename T>
+ concept with_get_executor = requires (T& t)
+ {
+-  {t.get_executor()} -> asio::execution::executor;
++  t.get_executor();
+ };
+ 
+ 

CMakeLists.txt

@@ -417,9 +417,12 @@ AddJsonPackage(boost)
 set(BOOST_NO_HEADERS ${Boost_ADDED})
 
 if (Boost_ADDED)
-    add_compile_definitions(YUZU_BOOST_v1)
+    if (MSVC OR ANDROID)
+        add_compile_definitions(YUZU_BOOST_v1)
+    endif()
+
     if (NOT MSVC OR CXX_CLANG)
-        # solaris sucks
+        # boost sucks
         if (SOLARIS)
             add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-pthreads>)
         endif()
@@ -428,7 +431,8 @@ if (Boost_ADDED)
         target_compile_options(boost_icl INTERFACE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-shadow>)
         target_compile_options(boost_asio INTERFACE
             $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-conversion>
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-fallthrough>)
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-fallthrough>
+        )
     endif()
 endif()
 

cpmfile.json

@@ -6,19 +6,22 @@
         "version": "v0.19.0"
     },
     "boost": {
-        "artifact": "boost-%VERSION%.tar.zst",
+        "artifact": "%VERSION%-cmake.tar.xz",
         "find_args": "CONFIG OPTIONAL_COMPONENTS headers context system fiber filesystem",
-        "hash": "681d97be4386767662e230b2e7c9754d45e709cc5db4e747c23c27d1f5b0e87770bdf19b0bc44dcb0e8349324887bbb8fffb432098f4d0ce74a5043021a90afc",
+        "hash": "6ae6e94664fe7f2fb01976b59b276ac5df8085c7503fa829d810fbfe495960cfec44fa2c36e2cb23480bc19c956ed199d4952b02639a00a6c07625d4e7130c2d",
         "min_version": "1.57",
         "package": "Boost",
-        "repo": "eden-emulator/ext-boost",
-        "version": "1.92.0"
+        "patches": [
+            "0001-clang-cl.patch"
+        ],
+        "repo": "boostorg/boost",
+        "version": "boost-1.90.0"
     },
     "boost_headers": {
         "bundled": true,
-        "hash": "c5fa2cd72f6e6666b7963b97bc359c75284b8fb540c30f3629a028b85270c9bc66c8a051383964f2bd4c1e005a4691593d15696e7ef39ea87cf6cff9e5691fb2",
+        "hash": "4ef845775e2277a8104ded6ddf749aa262ce52cf8438042869a048f9a0156dd772fbbcfa74efa1378fecef339b7286f6fe4b4feb5c45d49966b35d08e3e83507",
         "repo": "boostorg/headers",
-        "version": "boost-1.91.0"
+        "version": "boost-1.90.0"
     },
     "catch2": {
         "hash": "7eea385d79d88a5690cde131fe7ccda97d5c54ea09d6f515000d7bf07c828809d61c1ac99912c1ee507cf933f61c1c47ecdcc45df7850ffa82714034b0fccf35",

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt

@@ -27,6 +27,7 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     RENDERER_ASYNCHRONOUS_GPU_EMULATION("use_asynchronous_gpu_emulation"),
     RENDERER_ASYNC_PRESENTATION("async_presentation"),
     RENDERER_ASYNCHRONOUS_SHADERS("use_asynchronous_shaders"),
+    RENDERER_UNIFIED_MEMORY("use_unified_memory"),
     RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
     ENABLE_BUFFER_HISTORY("enable_buffer_history"),
     USE_OPTIMIZED_VERTEX_BUFFERS("use_optimized_vertex_buffers"),

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt

@@ -785,6 +785,13 @@ abstract class SettingsItem(
                     descriptionId = R.string.renderer_asynchronous_shaders_description
                 )
             )
+            put(
+                SwitchSetting(
+                    BooleanSetting.RENDERER_UNIFIED_MEMORY,
+                    titleId = R.string.renderer_unified_memory,
+                    descriptionId = R.string.renderer_unified_memory_description
+                )
+            )
             put(
                 SingleChoiceSetting(
                     IntSetting.FAST_GPU_TIME,

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt

@@ -558,6 +558,7 @@ class SettingsFragmentPresenter(
             add(BooleanSetting.FIX_BLOOM_EFFECTS.key)
             add(BooleanSetting.EMULATE_BGR565.key)
             add(BooleanSetting.RENDERER_ASYNCHRONOUS_SHADERS.key)
+            add(BooleanSetting.RENDERER_UNIFIED_MEMORY.key)
             add(IntSetting.ANDROID_PIPELINE_WORKERS.key)
             add(BooleanSetting.RENDERER_ASYNCHRONOUS_GPU_EMULATION.key)
             add(BooleanSetting.RENDERER_ASYNC_PRESENTATION.key)

src/android/app/src/main/res/values/strings.xml

@@ -605,6 +605,8 @@
     <string name="rescale_hack_description">Enables a legacy handling for the rescale configuration pass for games by using a quick rescale path</string>
     <string name="renderer_asynchronous_shaders">Use asynchronous shaders</string>
     <string name="renderer_asynchronous_shaders_description">Compiles shaders asynchronously. This may reduce stutters but may also introduce glitches.</string>
+    <string name="renderer_unified_memory">Unified memory access</string>
+    <string name="renderer_unified_memory_description">Allows GPU write buffer readbacks directly into guest memory, skipping the CPU staging copy.</string>
     <string name="gpu_unswizzle_settings">GPU Unswizzle Settings</string>
     <string name="gpu_unswizzle_settings_description">Configure GPU-based texture unswizzling parameters or disable it entirely. Adjust these settings to balance performance and texture loading quality.</string>
     <string name="gpu_unswizzle_enable">Enable GPU Unswizzle</string>

src/common/CMakeLists.txt

@@ -76,6 +76,7 @@ add_library(
     logging.h
     lz4_compression.cpp
     lz4_compression.h
+    make_unique_for_overwrite.h
     math_util.h
     memory_detect.cpp
     memory_detect.h

src/common/heap_tracker.cpp

@@ -4,34 +4,17 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <fstream>
 #include "common/heap_tracker.h"
 #include "common/logging.h"
+#include "common/memory_detect.h"
 #include "common/assert.h"
 
 namespace Common {
 
-namespace {
-
-s64 GetMaxPermissibleResidentMapCount() {
-    // Default value.
-    s64 value = 65530;
-
-    // Try to read how many mappings we can make.
-    std::ifstream s("/proc/sys/vm/max_map_count");
-    s >> value;
-
-    // Print, for debug.
-    LOG_INFO(HW_Memory, "Current maximum map count: {}", value);
-
-    // Allow 20000 maps for other code and to account for split inaccuracy.
-    return std::max<s64>(value - 20000, 0);
-}
-
-} // namespace
-
 HeapTracker::HeapTracker(Common::HostMemory& buffer)
-    : m_buffer(buffer), m_max_resident_map_count(GetMaxPermissibleResidentMapCount()) {}
+    : m_buffer(buffer),
+      m_has_hardware_buffer_backing(!buffer.BackingHardwareBuffers().empty()),
+      m_max_resident_map_count(static_cast<s64>(GetPermissibleMapCount())) {}
 HeapTracker::~HeapTracker() = default;
 
 void HeapTracker::Map(size_t virtual_offset, size_t host_offset, size_t length,
@@ -85,7 +68,8 @@ void HeapTracker::Unmap(size_t virtual_offset, size_t size, bool is_separate_hea
 
             // If resident, erase from resident map.
             if (item->is_resident) {
-                ASSERT(--m_resident_map_count >= 0);
+                m_resident_map_count -= this->HostMapCount(item->paddr, item->size);
+                ASSERT(m_resident_map_count >= 0);
                 m_resident_mappings.erase(m_resident_mappings.iterator_to(*item));
             }
 
@@ -191,7 +175,7 @@ bool HeapTracker::DeferredMapSeparateHeap(size_t virtual_offset) {
 
         // This map is now resident.
         it->is_resident = true;
-        m_resident_map_count++;
+        m_resident_map_count += this->HostMapCount(it->paddr, it->size);
         m_resident_mappings.insert(*it);
     }
 
@@ -213,17 +197,17 @@ void HeapTracker::RebuildSeparateHeapAddressSpace() {
     // Despite being worse in theory, this has proven to be better in practice than more
     // regularly dumping a smaller amount, because it significantly reduces average case
     // lock contention.
-    std::size_t const desired_count = (std::min)(m_resident_map_count, m_max_resident_map_count) / 2;
-    std::size_t const evict_count = m_resident_map_count - desired_count;
+    s64 const desired_count = (std::min)(m_resident_map_count, m_max_resident_map_count) / 2;
     auto it = m_resident_mappings.begin();
 
-    for (size_t i = 0; i < evict_count && it != m_resident_mappings.end(); i++) {
+    while (m_resident_map_count > desired_count && it != m_resident_mappings.end()) {
         // Unmark and unmap.
         it->is_resident = false;
         m_buffer.Unmap(it->vaddr, it->size, false);
 
         // Advance.
-        ASSERT(--m_resident_map_count >= 0);
+        m_resident_map_count -= this->HostMapCount(it->paddr, it->size);
+        ASSERT(m_resident_map_count >= 0);
         it = m_resident_mappings.erase(it);
     }
 }
@@ -245,6 +229,7 @@ void HeapTracker::SplitHeapMapLocked(VAddr offset) {
     // Cache the original values.
     auto* const left = std::addressof(*it);
     const size_t orig_size = left->size;
+    const s64 orig_host_map_count = this->HostMapCount(left->paddr, orig_size);
 
     // Adjust the left map.
     const size_t left_size = offset - left->vaddr;
@@ -266,11 +251,20 @@ void HeapTracker::SplitHeapMapLocked(VAddr offset) {
 
     // If resident, also insert into resident map.
     if (right->is_resident) {
-        m_resident_map_count++;
+        m_resident_map_count += this->HostMapCount(left->paddr, left->size) +
+                                this->HostMapCount(right->paddr, right->size) -
+                                orig_host_map_count;
         m_resident_mappings.insert(*right);
     }
 }
 
+s64 HeapTracker::HostMapCount(PAddr paddr, size_t size) const {
+    if (!m_has_hardware_buffer_backing) {
+        return size != 0 ? 1 : 0;
+    }
+    return static_cast<s64>(m_buffer.BackingMapCount(paddr, size));
+}
+
 HeapTracker::AddrTree::iterator HeapTracker::GetNearestHeapMapLocked(VAddr offset) {
     const SeparateHeapMap key{
         .vaddr = offset,

src/common/heap_tracker.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -82,10 +85,13 @@ private:
 
     AddrTree::iterator GetNearestHeapMapLocked(VAddr offset);
 
+    s64 HostMapCount(PAddr paddr, size_t size) const;
+
     void RebuildSeparateHeapAddressSpace();
 
 private:
     Common::HostMemory& m_buffer;
+    const bool m_has_hardware_buffer_backing;
     const s64 m_max_resident_map_count;
 
     std::shared_mutex m_rebuild_lock{};

src/common/host_memory.cpp

@@ -51,14 +51,65 @@
 
 #endif // ^^^ POSIX ^^^
 
+#include <atomic>
 #include <mutex>
 #include <random>
+#include <vector>
 
 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/free_region_manager.h"
 #include "common/host_memory.h"
 #include "common/logging.h"
+#include "common/memory_detect.h"
+#include "common/settings.h"
+
+#ifdef __ANDROID__
+#include <cerrno>
+#include <dlfcn.h>
+#include <sys/ioctl.h>
+#include <android/hardware_buffer.h>
+
+namespace {
+
+struct NativeHandle {
+    int version;
+    int numFds;
+    int numInts;
+    int data[1];
+};
+
+using PFN_AHardwareBuffer_getNativeHandle = const NativeHandle* (*)(const AHardwareBuffer*);
+
+PFN_AHardwareBuffer_getNativeHandle ResolveGetNativeHandle() {
+    void* const lib = dlopen("libnativewindow.so", RTLD_NOW);
+    if (lib == nullptr) {
+        return nullptr;
+    }
+    return reinterpret_cast<PFN_AHardwareBuffer_getNativeHandle>(
+        dlsym(lib, "AHardwareBuffer_getNativeHandle"));
+}
+
+struct DmaBufSync {
+    u64 flags;
+};
+
+constexpr u64 DmaBufSyncRead = 1ULL << 0;
+constexpr u64 DmaBufSyncWrite = 1ULL << 1;
+constexpr u64 DmaBufSyncStart = 0ULL << 2;
+constexpr u64 DmaBufSyncEnd = 1ULL << 2;
+
+void SyncDmaBufCpuAccess(int fd, u64 phase) {
+    DmaBufSync sync{.flags = phase | DmaBufSyncRead | DmaBufSyncWrite};
+    while (ioctl(fd, _IOW('b', 0, DmaBufSync), &sync) != 0) {
+        if (errno != EINTR) {
+            return;
+        }
+    }
+}
+
+} // namespace
+#endif
 
 #if defined(__ANDROID__) && __ANDROID_API__ < 30
 #include <sys/syscall.h>
@@ -75,6 +126,12 @@ namespace Common {
 [[maybe_unused]] constexpr size_t PageAlignment = 0x1000;
 [[maybe_unused]] constexpr size_t HugePageSize = 0x200000;
 
+static std::atomic<u64> committed_backing_size{};
+
+u64 GetCommittedBackingSize() noexcept {
+    return committed_backing_size.load(std::memory_order_relaxed);
+}
+
 #ifdef _WIN32
 
 // Manually imported for MinGW compatibility
@@ -122,7 +179,7 @@ static void GetFuncAddress(Common::DynamicLibrary& dll, const char* name, T& pfn
 
 class HostMemory::Impl {
 public:
-    explicit Impl(size_t backing_size_, size_t virtual_size_)
+    explicit Impl(size_t backing_size_, size_t virtual_size_, size_t)
         : backing_size{backing_size_}
         , virtual_size{virtual_size_}
         , process{GetCurrentProcess()}
@@ -236,6 +293,10 @@ public:
         UNREACHABLE();
     }
 
+    bool IsBackingShared() const noexcept {
+        return true;
+    }
+
     const size_t backing_size; ///< Size of the backing memory in bytes
     const size_t virtual_size; ///< Size of the virtual address placeholder in bytes
 
@@ -512,9 +573,10 @@ static int shm_open_anon(int flags, mode_t mode) {
 
 class HostMemory::Impl {
 public:
-    explicit Impl(size_t backing_size_, size_t virtual_size_)
+    explicit Impl(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_)
         : backing_size{backing_size_}
         , virtual_size{virtual_size_}
+        , preferred_offset{preferred_offset_}
     {}
 
     bool Init() {
@@ -554,10 +616,15 @@ public:
             LOG_WARNING(Common_Memory, "Using private mappings instead of shared ones");
             backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_NOCORE, -1, 0));
             if (fd > 0) {
-                fd = -1;
                 close(fd);
             }
+            fd = -1;
         } else {
+#ifdef __ANDROID__
+            if (InitAhbBacking()) {
+                return InitVirtual();
+            }
+#endif
             backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NOCORE, fd, 0));
         }
         if (backing_base == MAP_FAILED) {
@@ -565,7 +632,10 @@ public:
             return false;
         }
 
-        // Virtual memory initialization
+        return InitVirtual();
+    }
+
+    bool InitVirtual() {
         virtual_base = virtual_map_base = static_cast<u8*>(ChooseVirtualBase(virtual_size));
         if (virtual_base == MAP_FAILED) {
             LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
@@ -578,6 +648,244 @@ public:
         return true;
     }
 
+#ifdef __ANDROID__
+    static AHardwareBuffer_Desc MakeBlobDesc(size_t len) {
+        return AHardwareBuffer_Desc{
+            .width = static_cast<u32>(len),
+            .height = 1,
+            .layers = 1,
+            .format = AHARDWAREBUFFER_FORMAT_BLOB,
+            .usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
+                     AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
+                     AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER,
+            .stride = 0,
+            .rfu0 = 0,
+            .rfu1 = 0,
+        };
+    }
+
+    static bool ProbeAhbBacking(PFN_AHardwareBuffer_getNativeHandle get_native_handle) {
+        const AHardwareBuffer_Desc desc = MakeBlobDesc(PageAlignment * 2);
+        AHardwareBuffer* buffer{};
+        if (AHardwareBuffer_allocate(&desc, &buffer) != 0 || buffer == nullptr) {
+            return false;
+        }
+        const NativeHandle* const handle = get_native_handle(buffer);
+        if (handle == nullptr || handle->numFds < 1) {
+            AHardwareBuffer_release(buffer);
+            return false;
+        }
+        const int probe_fd = handle->data[0];
+        bool ok = true;
+        const auto try_map = [&](int prot, off_t offset) {
+            if (!ok) {
+                return;
+            }
+            void* const ptr = mmap(nullptr, PageAlignment, prot, MAP_SHARED, probe_fd, offset);
+            if (ptr == MAP_FAILED) {
+                ok = false;
+                return;
+            }
+            munmap(ptr, PageAlignment);
+        };
+        try_map(PROT_READ | PROT_WRITE, 0);
+        try_map(PROT_READ | PROT_WRITE, static_cast<off_t>(PageAlignment));
+#ifdef ARCHITECTURE_arm64
+        try_map(PROT_READ | PROT_EXEC, 0);
+#endif
+        AHardwareBuffer_release(buffer);
+        return ok;
+    }
+
+    size_t ComputeAhbBudget(size_t window_size) const {
+        const u64 total_physical = Common::GetMemInfo().TotalPhysicalMemory;
+        constexpr u64 BaselineFootprint = 6ULL << 30;
+        if (total_physical <= BaselineFootprint) {
+            return 0;
+        }
+        const u64 permissible_maps = Common::GetPermissibleMapCount();
+        if (permissible_maps == 0) {
+            return 0;
+        }
+        u64 budget = (total_physical - BaselineFootprint) / 2;
+        constexpr u64 MapSlotsPerWindow = 64;
+        const u64 affordable_windows = permissible_maps / MapSlotsPerWindow;
+        budget = (std::min)(budget, affordable_windows * window_size);
+        const u64 available = Common::GetAvailablePhysicalMemory();
+        if (available != 0) {
+            budget = (std::min)(budget, available / 2);
+        }
+        budget = (std::min)(budget, static_cast<u64>(backing_size));
+        budget = Common::AlignDown(budget, window_size);
+        constexpr u64 MinimumBudget = 256ULL << 20;
+        if (budget < MinimumBudget) {
+            return 0;
+        }
+        return static_cast<size_t>(budget);
+    }
+
+    bool InitAhbBacking() {
+        if (!Settings::values.use_unified_memory.GetValue()) {
+            return false;
+        }
+        static const PFN_AHardwareBuffer_getNativeHandle get_native_handle =
+            ResolveGetNativeHandle();
+        if (get_native_handle == nullptr) {
+            return false;
+        }
+        constexpr size_t window_size = 256ULL << 20;
+        const size_t budget = ComputeAhbBudget(window_size);
+        if (budget == 0) {
+            return false;
+        }
+        if (!ProbeAhbBacking(get_native_handle)) {
+            return false;
+        }
+        const size_t aligned_backing = Common::AlignDown(backing_size, window_size);
+        const size_t max_windows = (std::min)(budget, aligned_backing) / window_size;
+
+        std::vector<AHardwareBuffer*> buffers;
+        std::vector<int> buffer_fds;
+        const auto cleanup = [&] {
+            for (AHardwareBuffer* buffer : buffers) {
+                AHardwareBuffer_release(buffer);
+            }
+            buffers.clear();
+            buffer_fds.clear();
+        };
+        for (size_t i = 0; i < max_windows; ++i) {
+            const AHardwareBuffer_Desc desc = MakeBlobDesc(window_size);
+            AHardwareBuffer* buffer{};
+            if (AHardwareBuffer_allocate(&desc, &buffer) != 0 || buffer == nullptr) {
+                break;
+            }
+            const NativeHandle* const handle = get_native_handle(buffer);
+            if (handle == nullptr || handle->numFds < 1) {
+                AHardwareBuffer_release(buffer);
+                break;
+            }
+            const int buffer_fd = handle->data[0];
+            const off_t buffer_len = lseek(buffer_fd, 0, SEEK_END);
+            if (buffer_len < static_cast<off_t>(window_size)) {
+                AHardwareBuffer_release(buffer);
+                break;
+            }
+            buffers.push_back(buffer);
+            buffer_fds.push_back(buffer_fd);
+        }
+        const size_t num_windows = buffers.size();
+        if (num_windows == 0) {
+            return false;
+        }
+        const size_t region_size = num_windows * window_size;
+        const size_t region_base = Common::AlignDown(
+            (std::min)(preferred_offset, aligned_backing - region_size), window_size);
+        u8* const base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_NONE,
+                                               MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0));
+        if (base == MAP_FAILED) {
+            cleanup();
+            return false;
+        }
+        const auto map_over_reservation = [&](size_t offset, size_t len, int map_fd,
+                                              off_t map_offset) {
+            if (len == 0) {
+                return true;
+            }
+            if (mmap(base + offset, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, map_fd,
+                     map_offset) == MAP_FAILED) {
+                munmap(base, backing_size);
+                cleanup();
+                return false;
+            }
+            return true;
+        };
+        if (!map_over_reservation(0, region_base, fd, 0)) {
+            return false;
+        }
+        for (size_t i = 0; i < num_windows; ++i) {
+            if (!map_over_reservation(region_base + i * window_size, window_size, buffer_fds[i],
+                                      0)) {
+                return false;
+            }
+        }
+        const size_t tail_offset = region_base + region_size;
+        if (!map_over_reservation(tail_offset, backing_size - tail_offset, fd,
+                                  static_cast<off_t>(tail_offset))) {
+            return false;
+        }
+        backing_base = base;
+        ahb_windows = std::move(buffers);
+        ahb_fds = std::move(buffer_fds);
+        ahb_window_size = window_size;
+        ahb_base = region_base;
+        ahb_bytes = region_size;
+        committed_backing_size.store(region_size, std::memory_order_relaxed);
+        for (const int window_fd : ahb_fds) {
+            SyncDmaBufCpuAccess(window_fd, DmaBufSyncStart);
+        }
+        return true;
+    }
+
+    void MapBackingRange(size_t virtual_offset, size_t host_offset, size_t length, int prot_flags) {
+        while (length > 0) {
+            int map_fd = fd;
+            off_t map_offset = static_cast<off_t>(host_offset);
+            size_t chunk = length;
+            if (host_offset < ahb_base) {
+                chunk = (std::min)(chunk, ahb_base - host_offset);
+            } else if (host_offset < ahb_base + ahb_bytes) {
+                const size_t relative = host_offset - ahb_base;
+                const size_t window = relative / ahb_window_size;
+                const size_t local = relative % ahb_window_size;
+                map_fd = ahb_fds[window];
+                map_offset = static_cast<off_t>(local);
+                chunk = (std::min)(chunk, ahb_window_size - local);
+            }
+            void* const ret = mmap(virtual_base + virtual_offset, chunk, prot_flags,
+                                   MAP_SHARED | MAP_FIXED, map_fd, map_offset);
+            ASSERT_MSG(ret != MAP_FAILED, "mmap: {}", strerror(errno));
+            virtual_offset += chunk;
+            host_offset += chunk;
+            length -= chunk;
+        }
+    }
+
+    size_t BackingMapCount(size_t host_offset, size_t length) const noexcept {
+        if (length == 0) {
+            return 0;
+        }
+        if (ahb_bytes == 0) {
+            return 1;
+        }
+        size_t count = 0;
+        while (length > 0) {
+            size_t chunk = length;
+            if (host_offset < ahb_base) {
+                chunk = (std::min)(chunk, ahb_base - host_offset);
+            } else if (host_offset < ahb_base + ahb_bytes) {
+                const size_t local = (host_offset - ahb_base) % ahb_window_size;
+                chunk = (std::min)(chunk, ahb_window_size - local);
+            }
+            host_offset += chunk;
+            length -= chunk;
+            ++count;
+        }
+        return count;
+    }
+
+    std::span<AHardwareBuffer* const> AhbWindows() const noexcept {
+        return ahb_windows;
+    }
+
+    size_t AhbWindowSize() const noexcept {
+        return ahb_bytes != 0 ? ahb_window_size : 0;
+    }
+
+    size_t AhbBase() const noexcept {
+        return ahb_base;
+    }
+#endif
+
     ~Impl() {
         Release();
     }
@@ -606,6 +914,12 @@ public:
 #ifdef ARCHITECTURE_arm64
         if (True(perms & MemoryPermission::Execute))
             prot_flags |= PROT_EXEC;
+#endif
+#ifdef __ANDROID__
+        if (ahb_bytes != 0) {
+            MapBackingRange(virtual_offset, host_offset, length, prot_flags);
+            return;
+        }
 #endif
         int flags = (fd >= 0 ? MAP_SHARED : MAP_PRIVATE) | MAP_FIXED;
         void* ret = mmap(virtual_base + virtual_offset, length, prot_flags, flags, fd, host_offset);
@@ -651,8 +965,18 @@ public:
         virtual_base = nullptr;
     }
 
+    bool IsBackingShared() const noexcept {
+#ifdef __ANDROID__
+        if (ahb_bytes != 0) {
+            return true;
+        }
+#endif
+        return fd >= 0;
+    }
+
     const size_t backing_size; ///< Size of the backing memory in bytes
     const size_t virtual_size; ///< Size of the virtual address placeholder in bytes
+    const size_t preferred_offset;
 
     u8* backing_base{reinterpret_cast<u8*>(MAP_FAILED)};
     u8* virtual_base{reinterpret_cast<u8*>(MAP_FAILED)};
@@ -675,6 +999,21 @@ private:
             int ret = close(fd);
             ASSERT_MSG(ret == 0, "close failed: {}", strerror(errno));
         }
+
+#ifdef __ANDROID__
+        for (const int window_fd : ahb_fds) {
+            SyncDmaBufCpuAccess(window_fd, DmaBufSyncEnd);
+        }
+        for (AHardwareBuffer* buffer : ahb_windows) {
+            AHardwareBuffer_release(buffer);
+        }
+        ahb_windows.clear();
+        ahb_fds.clear();
+        if (ahb_bytes != 0) {
+            committed_backing_size.store(0, std::memory_order_relaxed);
+            ahb_bytes = 0;
+        }
+#endif
     }
 
     void AdjustMap(size_t* virtual_offset, size_t* length) {
@@ -700,11 +1039,19 @@ private:
 
     int fd{-1}; // memfd file descriptor, -1 is the error value of memfd_create
     FreeRegionManager free_manager{};
+
+#ifdef __ANDROID__
+    std::vector<AHardwareBuffer*> ahb_windows;
+    std::vector<int> ahb_fds;
+    size_t ahb_window_size{};
+    size_t ahb_base{};
+    size_t ahb_bytes{};
+#endif
 };
 
 #endif // ^^^ POSIX ^^^
 
-HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
+HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_)
     : backing_size(backing_size_)
     , virtual_size(virtual_size_)
 {
@@ -714,7 +1061,7 @@ HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
     virtual_base = nullptr;
 #else
     // Try to allocate a fastmem arena.
-    impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize);
+    impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize, preferred_offset_);
     if (impl->Init()) {
         backing_base = impl->backing_base;
         virtual_base = impl->virtual_base;
@@ -794,6 +1141,46 @@ void HostMemory::ClearBackingRegion(size_t physical_offset, size_t length, u32 f
     std::memset(backing_base + physical_offset, fill_value, length);
 }
 
+std::span<AHardwareBuffer* const> HostMemory::BackingHardwareBuffers() const noexcept {
+#ifdef __ANDROID__
+    return impl ? impl->AhbWindows() : std::span<AHardwareBuffer* const>{};
+#else
+    return {};
+#endif
+}
+
+size_t HostMemory::BackingMapCount(size_t host_offset, size_t length) const noexcept {
+#ifdef __ANDROID__
+    return impl ? impl->BackingMapCount(host_offset, length) : (length != 0 ? 1 : 0);
+#else
+    return length != 0 ? 1 : 0;
+#endif
+}
+
+size_t HostMemory::BackingHardwareBufferWindowSize() const noexcept {
+#ifdef __ANDROID__
+    return impl ? impl->AhbWindowSize() : 0;
+#else
+    return 0;
+#endif
+}
+
+bool HostMemory::IsBackingShared() const noexcept {
+#if defined(__OPENORBIS__) || defined(__managarm__)
+    return false;
+#else
+    return impl && impl->IsBackingShared();
+#endif
+}
+
+size_t HostMemory::BackingHardwareBufferBase() const noexcept {
+#ifdef __ANDROID__
+    return impl ? impl->AhbBase() : 0;
+#else
+    return 0;
+#endif
+}
+
 void HostMemory::EnableDirectMappedAddress() {
 #if !(defined(__OPENORBIS__) || defined(__managarm__))
     if (impl) {

src/common/host_memory.h

@@ -8,11 +8,16 @@
 
 #include <memory>
 #include <optional>
+#include <span>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 
+struct AHardwareBuffer;
+
 namespace Common {
 
+[[nodiscard]] u64 GetCommittedBackingSize() noexcept;
+
 enum class MemoryPermission : u32 {
     Read = 1 << 0,
     Write = 1 << 1,
@@ -27,7 +32,7 @@ DECLARE_ENUM_FLAG_OPERATORS(MemoryPermission)
  */
 class HostMemory {
 public:
-    explicit HostMemory(size_t backing_size_, size_t virtual_size_);
+    explicit HostMemory(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_ = 0);
     ~HostMemory();
 
     /**
@@ -61,6 +66,20 @@ public:
         return backing_base;
     }
 
+    [[nodiscard]] size_t BackingSize() const noexcept {
+        return backing_size;
+    }
+
+    [[nodiscard]] size_t BackingMapCount(size_t host_offset, size_t length) const noexcept;
+
+    [[nodiscard]] std::span<AHardwareBuffer* const> BackingHardwareBuffers() const noexcept;
+
+    [[nodiscard]] size_t BackingHardwareBufferWindowSize() const noexcept;
+
+    [[nodiscard]] size_t BackingHardwareBufferBase() const noexcept;
+
+    [[nodiscard]] bool IsBackingShared() const noexcept;
+
     [[nodiscard]] u8* VirtualBasePointer() noexcept {
         return virtual_base;
     }

src/common/make_unique_for_overwrite.h

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <type_traits>
+
+namespace Common {
+
+template <class T>
+    requires(!std::is_array_v<T>)
+std::unique_ptr<T> make_unique_for_overwrite() {
+    return std::unique_ptr<T>(new T);
+}
+
+template <class T>
+    requires std::is_unbounded_array_v<T>
+std::unique_ptr<T> make_unique_for_overwrite(std::size_t n) {
+    return std::unique_ptr<T>(new std::remove_extent_t<T>[n]);
+}
+
+template <class T, class... Args>
+    requires std::is_bounded_array_v<T>
+void make_unique_for_overwrite(Args&&...) = delete;
+
+} // namespace Common

src/common/memory_detect.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -17,6 +20,10 @@
 #endif
 #endif
 
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
 #include "common/memory_detect.h"
 
 namespace Common {
@@ -69,4 +76,61 @@ const MemoryInfo& GetMemInfo() {
     return mem_info;
 }
 
+u64 GetPermissibleMapCount() {
+    constexpr u64 DefaultMapCount = 65530;
+    constexpr u64 ReservedMaps = 20000;
+    u64 count = DefaultMapCount;
+#ifdef __linux__
+    if (std::FILE* const file = std::fopen("/proc/sys/vm/max_map_count", "re")) {
+        char line[32];
+        if (std::fgets(line, sizeof(line), file) != nullptr) {
+            const u64 parsed = std::strtoull(line, nullptr, 10);
+            if (parsed != 0) {
+                count = parsed;
+            }
+        }
+        std::fclose(file);
+    }
+#endif
+    if (count <= ReservedMaps) {
+        return 0;
+    }
+    return count - ReservedMaps;
+}
+
+u64 GetAvailablePhysicalMemory() {
+#ifdef _WIN32
+    MEMORYSTATUSEX memorystatus;
+    memorystatus.dwLength = sizeof(memorystatus);
+    if (GlobalMemoryStatusEx(&memorystatus) == 0) {
+        return 0;
+    }
+    return memorystatus.ullAvailPhys;
+#elif defined(__linux__)
+    static constexpr char AvailableKey[] = "MemAvailable:";
+    if (std::FILE* const file = std::fopen("/proc/meminfo", "re")) {
+        char line[256];
+        u64 available = 0;
+        while (std::fgets(line, sizeof(line), file) != nullptr) {
+            if (std::strncmp(line, AvailableKey, sizeof(AvailableKey) - 1) != 0) {
+                continue;
+            }
+            available = std::strtoull(line + sizeof(AvailableKey) - 1, nullptr, 10) * 1024;
+            break;
+        }
+        std::fclose(file);
+        if (available != 0) {
+            return available;
+        }
+    }
+    struct sysinfo meminfo;
+    if (sysinfo(&meminfo) != 0) {
+        return 0;
+    }
+    return static_cast<u64>(meminfo.freeram) * static_cast<u64>(meminfo.mem_unit);
+#else
+    return 0;
+#endif
+}
+
 } // namespace Common

src/common/memory_detect.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -18,4 +21,8 @@ struct MemoryInfo {
  */
 [[nodiscard]] const MemoryInfo& GetMemInfo();
 
+[[nodiscard]] u64 GetPermissibleMapCount();
+
+[[nodiscard]] u64 GetAvailablePhysicalMemory();
+
 } // namespace Common

src/common/scratch_buffer.h

@@ -8,7 +8,8 @@
 
 #include <iterator>
 #include <cstring>
-#include <memory>
+
+#include "common/make_unique_for_overwrite.h"
 
 namespace Common {
 
@@ -37,9 +38,8 @@ public:
     ScratchBuffer() = default;
 
     explicit ScratchBuffer(size_type initial_capacity)
-        : last_requested_size{initial_capacity}
-        , buffer_capacity{initial_capacity}
-        , buffer{std::make_unique_for_overwrite<T[]>(initial_capacity)} {}
+        : last_requested_size{initial_capacity}, buffer_capacity{initial_capacity},
+          buffer{Common::make_unique_for_overwrite<T[]>(initial_capacity)} {}
 
     ~ScratchBuffer() = default;
     ScratchBuffer(const ScratchBuffer&) = delete;
@@ -64,7 +64,7 @@ public:
     /// The previously held data will remain intact.
     void resize(size_type size) {
         if (size > buffer_capacity) {
-            auto new_buffer = std::make_unique_for_overwrite<T[]>(size);
+            auto new_buffer = Common::make_unique_for_overwrite<T[]>(size);
             std::memcpy(new_buffer.get(), buffer.get(), buffer_capacity * sizeof(T));
             buffer = std::move(new_buffer);
             buffer_capacity = size;
@@ -77,7 +77,7 @@ public:
     void resize_destructive(size_type size) {
         if (size > buffer_capacity) {
             buffer_capacity = size;
-            buffer = std::make_unique_for_overwrite<T[]>(buffer_capacity);
+            buffer = Common::make_unique_for_overwrite<T[]>(buffer_capacity);
         }
         last_requested_size = size;
     }

src/common/settings.h

@@ -666,6 +666,9 @@ struct Values {
     SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                      Category::RendererHacks};
 
+    SwitchableSetting<bool> use_unified_memory{linkage, false, "use_unified_memory",
+                                               Category::RendererHacks};
+
     SwitchableSetting<GpuUnswizzleSize> gpu_unswizzle_texture_size{linkage,
                                                   GpuUnswizzleSize::Large,
                                                   "gpu_unswizzle_texture_size",

src/core/CMakeLists.txt

@@ -810,8 +810,6 @@ add_library(core STATIC
     hle/service/ns/ecommerce_interface.h
     hle/service/ns/factory_reset_interface.cpp
     hle/service/ns/factory_reset_interface.h
-    hle/service/ns/i_async_result.cpp
-    hle/service/ns/i_async_result.h
     hle/service/ns/language.cpp
     hle/service/ns/language.h
     hle/service/ns/ns.cpp

src/core/core.cpp

@@ -120,6 +120,7 @@ struct System::Impl {
 
         is_multicore = Settings::values.use_multi_core.GetValue();
         extended_memory_layout = Settings::values.memory_layout_mode.GetValue() != Settings::MemoryLayout::Memory_4Gb;
+        unified_memory = Settings::values.use_unified_memory.GetValue();
 
         core_timing.SetMulticore(is_multicore);
         core_timing.Initialize([&system]() { system.RegisterHostThread(); });
@@ -147,7 +148,8 @@ struct System::Impl {
             !device_memory.has_value() ||
             is_multicore != Settings::values.use_multi_core.GetValue() ||
             extended_memory_layout != (Settings::values.memory_layout_mode.GetValue() !=
-                                       Settings::MemoryLayout::Memory_4Gb);
+                                       Settings::MemoryLayout::Memory_4Gb) ||
+            unified_memory != Settings::values.use_unified_memory.GetValue();
 
         if (!must_reinitialize) {
             return;
@@ -158,6 +160,7 @@ struct System::Impl {
         is_multicore = Settings::values.use_multi_core.GetValue();
         extended_memory_layout =
             Settings::values.memory_layout_mode.GetValue() != Settings::MemoryLayout::Memory_4Gb;
+        unified_memory = Settings::values.use_unified_memory.GetValue();
 
         Initialize(system);
     }
@@ -535,6 +538,7 @@ struct System::Impl {
     std::atomic_bool is_powered_on{};
     bool is_multicore : 1 = false;
     bool extended_memory_layout : 1 = false;
+    bool unified_memory : 1 = false;
     bool exit_locked : 1 = false;
     bool exit_requested : 1 = false;
 

src/core/device_memory.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -12,9 +15,18 @@ constexpr size_t VirtualReserveSize = 1ULL << 38;
 constexpr size_t VirtualReserveSize = 1ULL << 39;
 #endif
 
+namespace {
+size_t ApplicationPoolOffset() {
+    using Init = Kernel::Board::Nintendo::Nx::KSystemControl::Init;
+    const size_t dram_size = Init::GetIntendedMemorySize();
+    const size_t application_pool_size = Init::GetApplicationPoolSize();
+    return dram_size > application_pool_size ? dram_size - application_pool_size : 0;
+}
+}
+
 DeviceMemory::DeviceMemory()
     : buffer{Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize(),
-             VirtualReserveSize} {}
+             VirtualReserveSize, ApplicationPoolOffset()} {}
 
 DeviceMemory::~DeviceMemory() = default;
 

src/core/device_memory_manager.h

@@ -20,6 +20,8 @@
 #include "common/scratch_buffer.h"
 #include "common/sparse_large_vector.h"
 
+struct AHardwareBuffer;
+
 namespace Core {
 
 constexpr size_t DEVICE_PAGEBITS = 12ULL;
@@ -95,6 +97,34 @@ public:
         ApplyOpOnPAddr(address, buffer, operation);
     }
 
+    u8* GetPhysicalBase() noexcept {
+        return reinterpret_cast<u8*>(physical_base);
+    }
+
+    const u8* GetPhysicalBase() const noexcept {
+        return reinterpret_cast<const u8*>(physical_base);
+    }
+
+    size_t GetPhysicalSize() const noexcept {
+        return physical_size;
+    }
+
+    std::span<AHardwareBuffer* const> GetBackingHardwareBuffers() const noexcept {
+        return ahb_windows;
+    }
+
+    size_t GetBackingHardwareBufferWindowSize() const noexcept {
+        return ahb_window_size;
+    }
+
+    size_t GetBackingHardwareBufferBase() const noexcept {
+        return ahb_base;
+    }
+
+    bool IsBackingShared() const noexcept {
+        return backing_is_shared;
+    }
+
     PAddr GetPhysicalRawAddressFromDAddr(DAddr address) const {
         PAddr subbits = PAddr(address & page_mask);
         auto paddr = tracked_entries[(address >> page_bits)].compressed_physical_ptr;
@@ -171,6 +201,11 @@ private:
     std::unique_ptr<DeviceMemoryManagerAllocator<Traits>> impl;
 
     const uintptr_t physical_base;
+    const size_t physical_size;
+    const std::span<AHardwareBuffer* const> ahb_windows;
+    const size_t ahb_window_size;
+    const size_t ahb_base;
+    const bool backing_is_shared;
     DeviceInterface* device_inter;
 
     struct TrackedEntry {

src/core/device_memory_manager.inc

@@ -171,6 +171,11 @@ struct DeviceMemoryManagerAllocator {
 template <typename Traits>
 DeviceMemoryManager<Traits>::DeviceMemoryManager(const DeviceMemory& device_memory_)
     : physical_base{uintptr_t(device_memory_.buffer.BackingBasePointer())}
+    , physical_size{device_memory_.buffer.BackingSize()}
+    , ahb_windows{device_memory_.buffer.BackingHardwareBuffers()}
+    , ahb_window_size{device_memory_.buffer.BackingHardwareBufferWindowSize()}
+    , ahb_base{device_memory_.buffer.BackingHardwareBufferBase()}
+    , backing_is_shared{device_memory_.buffer.IsBackingShared()}
     , device_inter{nullptr}
     , compressed_device_addr(1ULL << ((Settings::values.memory_layout_mode.GetValue() == Settings::MemoryLayout::Memory_4Gb ? physical_min_bits : physical_max_bits) - Memory::YUZU_PAGEBITS))
     , tracked_entries(device_as_size >> Memory::YUZU_PAGEBITS)

src/core/file_sys/vfs/vfs_real.cpp

@@ -109,7 +109,8 @@ VirtualFile RealVfsFilesystem::OpenFileFromEntry(std::string_view path_, std::op
     auto reference = std::make_unique<FileReference>();
     this->InsertReferenceIntoListLocked(*reference);
 
-    auto file = std::make_shared<RealVfsFile>(*this, std::move(reference), path, perms, size, std::move(parent_path));
+    auto file = std::shared_ptr<RealVfsFile>(
+        new RealVfsFile(*this, std::move(reference), path, perms, size, std::move(parent_path)));
     cache[path] = file;
 
     return file;
@@ -176,7 +177,7 @@ bool RealVfsFilesystem::DeleteFile(std::string_view path_) {
 
 VirtualDir RealVfsFilesystem::OpenDirectory(std::string_view path_, OpenMode perms) {
     const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault);
-    return std::make_shared<RealVfsDirectory>(*this, path, perms);
+    return std::shared_ptr<RealVfsDirectory>(new RealVfsDirectory(*this, path, perms));
 }
 
 VirtualDir RealVfsFilesystem::CreateDirectory(std::string_view path_, OpenMode perms) {
@@ -184,7 +185,7 @@ VirtualDir RealVfsFilesystem::CreateDirectory(std::string_view path_, OpenMode p
     if (!FS::CreateDirs(path)) {
         return nullptr;
     }
-    return std::make_shared<RealVfsDirectory>(*this, path, perms);
+    return std::shared_ptr<RealVfsDirectory>(new RealVfsDirectory(*this, path, perms));
 }
 
 VirtualDir RealVfsFilesystem::CopyDirectory(std::string_view old_path_,

src/core/file_sys/vfs/vfs_real.h

@@ -82,9 +82,6 @@ class RealVfsFile : public VfsFile {
     friend class RealVfsFilesystem;
 
 public:
-    RealVfsFile(RealVfsFilesystem& base, std::unique_ptr<FileReference> reference,
-                const std::string& path, OpenMode perms = OpenMode::Read,
-                std::optional<u64> size = {}, std::optional<std::string> parent_path = {});
     ~RealVfsFile() override;
 
     std::string GetName() const override;
@@ -98,6 +95,9 @@ public:
     bool Rename(std::string_view name) override;
 
 private:
+    RealVfsFile(RealVfsFilesystem& base, std::unique_ptr<FileReference> reference,
+                const std::string& path, OpenMode perms = OpenMode::Read,
+                std::optional<u64> size = {}, std::optional<std::string> parent_path = {});
 
     RealVfsFilesystem& base;
     std::unique_ptr<FileReference> reference;
@@ -113,8 +113,6 @@ class RealVfsDirectory : public VfsDirectory {
     friend class RealVfsFilesystem;
 
 public:
-    RealVfsDirectory(RealVfsFilesystem& base, const std::string& path,
-                     OpenMode perms = OpenMode::Read);
     ~RealVfsDirectory() override;
 
     VirtualFile GetFileRelative(std::string_view relative_path) const override;
@@ -140,6 +138,9 @@ public:
     std::map<std::string, VfsEntryType, std::less<>> GetEntries() const override;
 
 private:
+    RealVfsDirectory(RealVfsFilesystem& base, const std::string& path,
+                     OpenMode perms = OpenMode::Read);
+
     template <typename T, typename R>
     std::vector<std::shared_ptr<R>> IterateEntries() const;
 

src/core/hle/service/ns/application_manager_interface.cpp

@@ -228,9 +228,9 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
         {930, nullptr, "Unknown930"}, //20.0.0+
         {931, nullptr, "Unknown931"}, //20.0.0+
         {933, nullptr, "Unknown933"}, //20.0.0+
-        {934, nullptr, "Unknown934"}, //21.0.0+
-        {935, nullptr, "Unknown935"}, //21.0.0+
-        {936, D<&IApplicationManagerInterface::Unknown936>, "Unknown936"}, //21.0.0+
+        {934, nullptr, "Unknown934"}, //20.0.0+
+        {935, nullptr, "Unknown935"}, //20.0.0+
+        {936, nullptr, "Unknown936"}, //20.0.0+
         {1000, nullptr, "RequestVerifyApplicationDeprecated"},
         {1001, nullptr, "CorruptApplicationForDebug"},
         {1002, nullptr, "RequestVerifyAddOnContentsRights"},
@@ -422,7 +422,7 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
         {4039, nullptr, "Unknown4039"}, //20.0.0+
         {4040, nullptr, "Unknown4040"}, //20.0.0+
         {4041, nullptr, "Unknown4041"}, //20.0.0+
-        {4042, D<&IApplicationManagerInterface::Unknown4042>, "Unknown4042"}, //20.0.0+
+        {4042, nullptr, "Unknown4042"}, //20.0.0+
         {4043, nullptr, "Unknown4043"}, //20.0.0+
         {4044, nullptr, "Unknown4044"}, //20.0.0+
         {4045, nullptr, "Unknown4045"}, //20.0.0+
@@ -639,12 +639,6 @@ Result IApplicationManagerInterface::IsGameCardApplicationRunning(Out<bool> out_
     R_SUCCEED();
 }
 
-Result IApplicationManagerInterface::Unknown936(Out<u64> out_result) {
-    LOG_WARNING(Service_NS, "(STUBBED) called.");
-    *out_result = 0;
-    R_SUCCEED();
-}
-
 Result IApplicationManagerInterface::IsAnyApplicationEntityInstalled(
     Out<bool> out_is_any_application_entity_installed) {
     LOG_WARNING(Service_NS, "(STUBBED) called");
@@ -868,15 +862,6 @@ Result IApplicationManagerInterface::Unknown4023(Out<u64> out_result) {
     R_SUCCEED();
 }
 
-Result IApplicationManagerInterface::Unknown4042(OutInterface<IAsyncResult> out_interface,
-                                                 OutCopyHandle<Kernel::KReadableEvent> out_event,
-                                                 u64 arg1, u64 arg2) {
-    LOG_WARNING(Service_NS, "(STUBBED) called, arg1={:016X}, arg2={:016X}", arg1, arg2);
-    *out_event = unknown_event.GetHandle();
-    *out_interface = std::make_shared<IAsyncResult>(system, &unknown_event);
-    R_SUCCEED();
-}
-
 Result IApplicationManagerInterface::Unknown4053() {
     LOG_WARNING(Service_NS, "(STUBBED) called.");
     R_SUCCEED();

src/core/hle/service/ns/application_manager_interface.h

@@ -7,7 +7,6 @@
 #pragma once
 
 #include "core/hle/service/cmif_types.h"
-#include "core/hle/service/ns/i_async_result.h"
 #include "core/hle/service/ns/language.h"
 #include "core/hle/service/ns/ns_types.h"
 #include "core/hle/service/os/event.h"
@@ -35,7 +34,6 @@ public:
     Result GetGameCardMountFailureEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result GetGameCardWakenReadyEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result IsGameCardApplicationRunning(Out<bool> out_is_running);
-    Result Unknown936(Out<u64> out_result);
     Result IsAnyApplicationEntityInstalled(Out<bool> out_is_any_application_entity_installed);
     Result GetApplicationViewDeprecated(
         OutArray<ApplicationViewV19, BufferAttr_HipcMapAlias> out_application_views,
@@ -73,9 +71,6 @@ public:
                                   InBuffer<BufferAttr_HipcMapAlias> logo_path_buffer);
     Result Unknown4022(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result Unknown4023(Out<u64> out_result);
-    Result Unknown4042(OutInterface<IAsyncResult> out_interface,
-                       OutCopyHandle<Kernel::KReadableEvent> out_event,
-                       u64 arg1, u64 arg2);
     Result Unknown4053();
     Result Unknown4105();
 

src/core/hle/service/ns/i_async_result.cpp

@@ -1,35 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/ns/i_async_result.h"
-
-#include <cstring>
-
-namespace Service::NS {
-
-IAsyncResult::IAsyncResult(Core::System& system_, Service::Event* event_)
-    : ServiceFramework{system_, "nn::ns::detail::IAsyncResult"}, event{event_} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "Get"},
-        {1, D<&IAsyncResult::Cancel>, "Cancel"},
-        {2, nullptr, "GetErrorContext"}, // 4.0.0+
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IAsyncResult::~IAsyncResult() = default;
-
-Result IAsyncResult::Cancel() {
-    LOG_DEBUG(Service_NS, "called");
-    if (event != nullptr) {
-        event->Signal(system.Kernel());
-    }
-
-    R_SUCCEED();
-}
-
-} // namespace Service::NS

src/core/hle/service/ns/i_async_result.h

@@ -1,19 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/hle/service/service.h"
-
-namespace Service::NS {
-
-class IAsyncResult final : public ServiceFramework<IAsyncResult> {
-public:
-    explicit IAsyncResult(Core::System& system_, Service::Event* event_);
-    ~IAsyncResult() override;
-
-private:
-    Result Cancel();
-
-    Service::Event* event{};
-};
-
-} // namespace Service::NS

src/core/hle/service/psc/ovln/receiver_service.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -24,7 +24,7 @@ IReceiverService::~IReceiverService() = default;
 
 Result IReceiverService::OpenReceiver(Out<SharedPointer<IReceiver>> out_receiver) {
     LOG_DEBUG(Service_PSC, "called");
-    *out_receiver = std::make_shared<IReceiver>(system);
+    *out_receiver = std::shared_ptr<IReceiver>(new IReceiver(system));
     R_SUCCEED();
 }
 

src/qt_common/config/shared_translation.cpp

@@ -23,7 +23,7 @@ namespace ConfigurationShared {
 
 std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
     std::unique_ptr<TranslationMap> translations = std::make_unique<TranslationMap>();
-    const auto& tr = [](const char* text) -> QString { return QCoreApplication::translate("ConfigurationShared", text); };
+    const auto& tr = [parent](const char* text) -> QString { return parent->tr(text); };
 
 #define INSERT(SETTINGS, ID, NAME, TOOLTIP)                                                        \
     translations->insert(std::pair{SETTINGS::values.ID.Id(), std::pair{(NAME), (TOOLTIP)}})
@@ -151,9 +151,6 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
            tr("The anti-aliasing method to use.\nSMAA offers the best quality.\nFXAA "
               "can produce a more stable picture in lower resolutions."));
     INSERT(Settings, post_shader_chain, QString(), QString());
-    INSERT(Settings, post_shader_preset, QString(), QString());
-    INSERT(Settings, post_shader_enabled, tr("Enable post-processing effects"),
-           tr("Applies post-processing effects to the final image."));
     INSERT(Settings, fullscreen_mode, tr("Fullscreen Mode:"),
            tr("The method used to render the window in fullscreen.\nBorderless offers the best "
               "compatibility with the on-screen keyboard that some games request for "
@@ -231,6 +228,8 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
            tr("Preserves GPU-modified data by reading it back before uploading.\nSome games require this to render certain effects properly."));
     INSERT(Settings, use_asynchronous_shaders, tr("Enable asynchronous shader compilation"),
            tr("May reduce shader stutter."));
+    INSERT(Settings, use_unified_memory, tr("Enable unified memory access"),
+           tr("Lets the GPU write buffer readbacks directly into guest memory."));
     INSERT(Settings, gpu_clock, tr("GPU Clocks"),
            tr("Makes the game believe GPU work finishes faster than it does, so it stops lowering "
               "resolution and render distance to fit the Switch's clocks."));
@@ -371,8 +370,8 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
 std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {
     std::unique_ptr<ComboboxTranslationMap> translations =
         std::make_unique<ComboboxTranslationMap>();
-    const auto& tr = [](const char* text, const char* context = "") {
-        return QCoreApplication::translate("ConfigurationShared", text, context);
+    const auto& tr = [&](const char* text, const char* context = "") {
+        return parent->tr(text, context);
     };
 
 #define PAIR(ENUM, VALUE, TRANSLATION) {static_cast<u32>(Settings::ENUM::VALUE), (TRANSLATION)}

src/shader_recompiler/backend/spirv/emit_spirv_atomic.cpp

@@ -13,6 +13,7 @@
 namespace Shader::Backend::SPIRV {
 namespace {
 Id SharedPointer(EmitContext& ctx, Id offset, u32 index_offset = 0) {
+    offset = ctx.BoundSharedOffset(offset, 4 + index_offset * 4);
     const Id shift_id{ctx.Const(2U)};
     Id index{ctx.OpShiftRightArithmetic(ctx.U32[1], offset, shift_id)};
     if (index_offset > 0) {
@@ -160,7 +161,8 @@ Id EmitSharedAtomicExchange32(EmitContext& ctx, Id offset, Id value) {
 Id EmitSharedAtomicExchange64(EmitContext& ctx, Id offset, Id value) {
     if (ctx.profile.support_shared_int64_atomics && ctx.uses_explicit_workgroup_layout) {
         const Id shift_id{ctx.Const(3U)};
-        const Id index{ctx.OpShiftRightArithmetic(ctx.U32[1], offset, shift_id)};
+        const Id index{
+            ctx.OpShiftRightArithmetic(ctx.U32[1], ctx.BoundSharedOffset(offset, 8), shift_id)};
         const Id pointer{
             ctx.OpAccessChain(ctx.shared_u64, ctx.shared_memory_u64, ctx.u32_zero_value, index)};
         const auto [scope, semantics]{AtomicArgs(ctx)};

src/shader_recompiler/backend/spirv/emit_spirv_shared_memory.cpp

@@ -31,6 +31,7 @@ std::pair<Id, Id> ExtractArgs(EmitContext& ctx, Id offset, u32 mask, u32 count)
 } // Anonymous namespace
 
 Id EmitLoadSharedU8(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 1);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{
             ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
@@ -42,6 +43,7 @@ Id EmitLoadSharedU8(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedS8(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 1);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{
             ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
@@ -53,6 +55,7 @@ Id EmitLoadSharedS8(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedU16(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 2);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
         return ctx.OpUConvert(ctx.U32[1], ctx.OpLoad(ctx.U16, pointer));
@@ -63,6 +66,7 @@ Id EmitLoadSharedU16(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedS16(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 2);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
         return ctx.OpSConvert(ctx.U32[1], ctx.OpLoad(ctx.U16, pointer));
@@ -73,6 +77,7 @@ Id EmitLoadSharedS16(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedU32(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 4);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u32, ctx.shared_memory_u32, offset, 2)};
         return ctx.OpLoad(ctx.U32[1], pointer);
@@ -82,6 +87,7 @@ Id EmitLoadSharedU32(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedU64(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 8);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u32x2, ctx.shared_memory_u32x2, offset, 3)};
         return ctx.OpLoad(ctx.U32[2], pointer);
@@ -97,6 +103,7 @@ Id EmitLoadSharedU64(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedU128(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 16);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u32x4, ctx.shared_memory_u32x4, offset, 4)};
         return ctx.OpLoad(ctx.U32[4], pointer);
@@ -113,6 +120,7 @@ Id EmitLoadSharedU128(EmitContext& ctx, Id offset) {
 }
 
 void EmitWriteSharedU8(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 1);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{
             ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
@@ -123,6 +131,7 @@ void EmitWriteSharedU8(EmitContext& ctx, Id offset, Id value) {
 }
 
 void EmitWriteSharedU16(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 2);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
         ctx.OpStore(pointer, ctx.OpUConvert(ctx.U16, value));
@@ -132,6 +141,7 @@ void EmitWriteSharedU16(EmitContext& ctx, Id offset, Id value) {
 }
 
 void EmitWriteSharedU32(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 4);
     Id pointer{};
     if (ctx.uses_explicit_workgroup_layout) {
         pointer = Pointer(ctx, ctx.shared_u32, ctx.shared_memory_u32, offset, 2);
@@ -144,6 +154,7 @@ void EmitWriteSharedU32(EmitContext& ctx, Id offset, Id value) {
 }
 
 void EmitWriteSharedU64(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 8);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u32x2, ctx.shared_memory_u32x2, offset, 3)};
         ctx.OpStore(pointer, value);
@@ -159,6 +170,7 @@ void EmitWriteSharedU64(EmitContext& ctx, Id offset, Id value) {
 }
 
 void EmitWriteSharedU128(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 16);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u32x4, ctx.shared_memory_u32x4, offset, 4)};
         ctx.OpStore(pointer, value);

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -600,6 +600,16 @@ void EmitContext::DefineLocalMemory(const IR::Program& program) {
     }
 }
 
+Id EmitContext::BoundSharedOffset(Id offset, u32 access_bytes) {
+    if (shared_memory_declared_bytes == 0) {
+        return offset;
+    }
+    const u32 last_valid{shared_memory_declared_bytes > access_bytes
+                             ? shared_memory_declared_bytes - access_bytes
+                             : 0U};
+    return OpUMin(U32[1], offset, Const(last_valid));
+}
+
 void EmitContext::DefineSharedMemory(const IR::Program& program) {
     uses_explicit_workgroup_layout =
         profile.support_explicit_workgroup_layout &&
@@ -608,8 +618,15 @@ void EmitContext::DefineSharedMemory(const IR::Program& program) {
     if (program.shared_memory_size == 0) {
         return;
     }
+    const u32 device_limit{profile.max_shared_memory_size};
+    const u32 shared_memory_size{device_limit != 0 && program.shared_memory_size > device_limit
+                                     ? device_limit
+                                     : program.shared_memory_size};
+    if (shared_memory_size != program.shared_memory_size) {
+        shared_memory_declared_bytes = shared_memory_size;
+    }
     const auto make{[&](Id element_type, u32 element_size) {
-        const u32 num_elements{Common::DivCeil(program.shared_memory_size, element_size)};
+        const u32 num_elements{Common::DivCeil(shared_memory_size, element_size)};
         const Id array_type{TypeArray(element_type, Const(num_elements))};
         Decorate(array_type, spv::Decoration::ArrayStride, element_size);
 
@@ -644,7 +661,7 @@ void EmitContext::DefineSharedMemory(const IR::Program& program) {
         std::tie(shared_memory_u32x4, shared_u32x4, std::ignore) = make(U32[4], 16);
         return;
     }
-    const u32 num_elements{Common::DivCeil(program.shared_memory_size, 4U)};
+    const u32 num_elements{Common::DivCeil(shared_memory_size, 4U)};
     const Id type{TypeArray(U32[1], Const(num_elements))};
     shared_memory_u32_type = TypePointer(spv::StorageClass::Workgroup, type);
 

src/shader_recompiler/backend/spirv/spirv_emit_context.h

@@ -312,6 +312,8 @@ public:
     Id local_memory{};
 
     bool uses_explicit_workgroup_layout{};
+    u32 shared_memory_declared_bytes{};
+    [[nodiscard]] Id BoundSharedOffset(Id offset, u32 access_bytes);
     Id shared_memory_u8{};
     Id shared_memory_u16{};
     Id shared_memory_u32{};

src/shader_recompiler/profile.h

@@ -105,6 +105,9 @@ struct Profile {
 
     u32 gl_max_compute_smem_size{};
 
+    /// Largest workgroup shared memory allocation the device accepts, 0 when unconstrained
+    u32 max_shared_memory_size{};
+
     /// Maxwell and earlier nVidia architectures have broken robust support
     bool has_broken_robust{};
 

src/video_core/buffer_cache/buffer_cache.h

@@ -78,6 +78,11 @@ void BufferCache<P>::TickFrame() {
         return;
     }
     runtime.TickFrame(slot_buffers);
+    if constexpr (USE_UNIFIED_MEMORY) {
+        if (!unified_written_ranges.Empty() && runtime.KnownGpuTick() >= unified_write_tick) {
+            unified_written_ranges.Clear();
+        }
+    }
 
     // Calculate hits and shots and move hit bits to the right
     const u32 hits = std::reduce(channel_state->uniform_cache_hits.begin(),
@@ -565,7 +570,8 @@ void BufferCache<P>::FlushCachedWrites() {
 
 template <class P>
 bool BufferCache<P>::HasUncommittedFlushes() const noexcept {
-    return !uncommitted_gpu_modified_ranges.Empty() || !committed_gpu_modified_ranges.empty();
+    return !uncommitted_gpu_modified_ranges.Empty() || !committed_gpu_modified_ranges.empty() ||
+           uncommitted_unified_writes;
 }
 
 template <class P>
@@ -578,14 +584,22 @@ void BufferCache<P>::AccumulateFlushes() {
 
 template <class P>
 bool BufferCache<P>::ShouldWaitAsyncFlushes() const noexcept {
-    return (!async_buffers.empty() && async_buffers.front().has_value());
+    if (async_buffers.empty()) {
+        return false;
+    }
+    return async_buffers.front().has_value() ||
+           !pending_downloads.front().unified_copies.empty() ||
+           pending_downloads.front().unified_writes;
 }
 
 template <class P>
 void BufferCache<P>::CommitAsyncFlushesHigh() {
     AccumulateFlushes();
+    const bool unified_writes = uncommitted_unified_writes;
+    uncommitted_unified_writes = false;
 
     if (committed_gpu_modified_ranges.empty()) {
+        pending_downloads.emplace_back(AsyncDownloadBatch{.unified_writes = unified_writes});
         async_buffers.emplace_back(std::optional<Async_Buffer>{});
         return;
     }
@@ -645,27 +659,85 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
     }
     committed_gpu_modified_ranges.clear();
     if (downloads.empty()) {
+        pending_downloads.emplace_back(AsyncDownloadBatch{.unified_writes = unified_writes});
         async_buffers.emplace_back(std::optional<Async_Buffer>{});
         return;
     }
-    auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes, true);
-    boost::container::small_vector<BufferCopy, 4> normalized_copies;
-    runtime.PreCopyBarrier();
+
+    struct QueuedUnifiedCopy {
+        u64 window;
+        BufferId buffer_id;
+        boost::container::small_vector<BufferCopy, 16> copies;
+    };
+
+    AsyncDownloadBatch batch;
+    boost::container::small_vector<std::pair<BufferCopy, BufferId>, 16> staging_downloads;
+    boost::container::small_vector<QueuedUnifiedCopy, 4> unified_copy_queue;
+    boost::container::small_vector<u64, 4> window_ids;
+    UnifiedWindowGroups groups;
+    u64 staging_size_bytes = 0;
     for (auto& [copy, buffer_id] : downloads) {
-        copy.dst_offset += download_staging.offset;
-        const std::array copies{copy};
-        BufferCopy second_copy{copy};
         Buffer& buffer = slot_buffers[buffer_id];
-        second_copy.src_offset = static_cast<size_t>(buffer.CpuAddr()) + copy.src_offset;
-        const DAddr orig_device_addr = static_cast<DAddr>(second_copy.src_offset);
+        const DAddr orig_device_addr = buffer.CpuAddr() + copy.src_offset;
+        bool unified = false;
+        if constexpr (USE_UNIFIED_MEMORY) {
+            if (runtime.HasUnifiedMemory()) {
+                window_ids.clear();
+                groups.clear();
+                unified = ResolveUnifiedWindows(orig_device_addr, copy.src_offset, copy.size,
+                                                window_ids, groups);
+            }
+        }
+        BufferCopy record{copy};
+        record.src_offset = static_cast<size_t>(orig_device_addr);
+        if (unified) {
+            async_downloads.Add(orig_device_addr, copy.size);
+            buffer.MarkUsage(copy.src_offset, copy.size);
+            for (size_t i = 0; i < window_ids.size(); ++i) {
+                unified_copy_queue.push_back(
+                    QueuedUnifiedCopy{window_ids[i], buffer_id, std::move(groups[i])});
+            }
+            batch.unified_copies.push_back(record);
+            continue;
+        }
+        copy.dst_offset = staging_size_bytes;
+        constexpr u64 align = 64ULL;
+        staging_size_bytes += (copy.size + align - 1) & ~(align - 1ULL);
+        staging_downloads.push_back({copy, buffer_id});
+    }
+
+    std::optional<Async_Buffer> download_staging;
+    if (!staging_downloads.empty()) {
+        download_staging = runtime.DownloadStagingBuffer(staging_size_bytes, true);
+    }
+    runtime.PreCopyBarrier();
+    for (auto& [copy, buffer_id] : staging_downloads) {
+        copy.dst_offset += download_staging->offset;
+        const std::array copies{copy};
+        Buffer& buffer = slot_buffers[buffer_id];
+        BufferCopy record{copy};
+        record.src_offset = static_cast<size_t>(buffer.CpuAddr()) + copy.src_offset;
+        const DAddr orig_device_addr = static_cast<DAddr>(record.src_offset);
         async_downloads.Add(orig_device_addr, copy.size);
         buffer.MarkUsage(copy.src_offset, copy.size);
-        runtime.CopyBuffer(download_staging.buffer, buffer, copies, false);
-        normalized_copies.push_back(second_copy);
+        runtime.CopyBuffer(download_staging->buffer, buffer, copies, false);
+        batch.staging_copies.push_back(record);
+    }
+    if constexpr (USE_UNIFIED_MEMORY) {
+        for (const auto& queued : unified_copy_queue) {
+            const std::span<const BufferCopy> group_span(queued.copies.data(),
+                                                         queued.copies.size());
+            runtime.CopyToUnifiedMemory(queued.window, slot_buffers[queued.buffer_id], group_span);
+        }
+        if (!unified_copy_queue.empty()) {
+            runtime.FlushUnifiedMemoryCopies();
+            runtime.UnifiedMemoryHostBarrier();
+        }
     }
     runtime.PostCopyBarrier();
-    pending_downloads.emplace_back(std::move(normalized_copies));
-    async_buffers.emplace_back(download_staging);
+    batch.unified_writes = unified_writes;
+    pending_downloads.emplace_back(std::move(batch));
+    async_buffers.emplace_back(std::move(download_staging));
 }
 
 template <class P>
@@ -680,32 +752,49 @@ void BufferCache<P>::PopAsyncFlushes() {
 
 template <class P>
 void BufferCache<P>::PopAsyncBuffers() {
+    struct Writeback {
+        DAddr addr;
+        const u8* src;
+        u64 size;
+    };
+    boost::container::small_vector<Writeback, 8> writebacks;
+    {
+        std::scoped_lock lock{mutex};
     if (async_buffers.empty()) {
         return;
     }
-    if (!async_buffers.front().has_value()) {
-        async_buffers.pop_front();
-        return;
-    }
-    auto& downloads = pending_downloads.front();
+        auto& batch = pending_downloads.front();
     auto& async_buffer = async_buffers.front();
-    u8* base = async_buffer->mapped_span.data();
+        if (async_buffer.has_value()) {
+            const u8* base = async_buffer->mapped_span.data();
     const size_t base_offset = async_buffer->offset;
-    for (const auto& copy : downloads) {
+            for (const auto& copy : batch.staging_copies) {
         const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
         const u64 dst_offset = copy.dst_offset - base_offset;
         const u8* read_mapped_memory = base + dst_offset;
-        async_downloads.ForEachInRange(device_addr, copy.size, [&](DAddr start, DAddr end, s32) {
-            device_memory.WriteBlockUnsafe(start, &read_mapped_memory[start - device_addr],
-                                           end - start);
+                async_downloads.ForEachInRange(
+                    device_addr, copy.size, [&](DAddr start, DAddr end, s32) {
+                        writebacks.push_back(
+                            {start, &read_mapped_memory[start - device_addr], end - start});
         });
         async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
             gpu_modified_ranges.Subtract(start, end - start);
         });
     }
     async_buffers_death_ring.emplace_back(*async_buffer);
+        }
+        for (const auto& copy : batch.unified_copies) {
+            const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
+            async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
+                gpu_modified_ranges.Subtract(start, end - start);
+            });
+        }
     async_buffers.pop_front();
     pending_downloads.pop_front();
+    }
+    for (const auto& wb : writebacks) {
+        device_memory.WriteBlockUnsafe(wb.addr, wb.src, wb.size);
+    }
 }
 
 template <class P>
@@ -749,6 +838,9 @@ void BufferCache<P>::BindHostIndexBuffer() {
     const u32 size = channel_state->index_buffer.size;
     const auto& draw_state = maxwell3d->draw_manager.draw_state;
     if (draw_state.inline_index_draw_indexes.empty()) {
+        if (BindVirtualIndexBuffer()) {
+            return;
+        }
         SynchronizeBuffer(buffer, channel_state->index_buffer.device_addr, size);
     } else {
         if constexpr (USE_MEMORY_MAPS_FOR_UPLOADS) {
@@ -802,6 +894,7 @@ void BufferCache<P>::UpdateVertexBufferSlot(u32 index, const Binding& binding) {
         enabled_vertex_buffers_mask |= (1u << index);
     } else {
         enabled_vertex_buffers_mask &= ~(1u << index);
+        virtual_vertex_buffers_mask &= ~(1u << index);
     }
 }
 
@@ -834,8 +927,16 @@ void BufferCache<P>::BindHostVertexBuffers() {
             const Binding& binding = VertexBufferSlot(index);
             Buffer& buffer = slot_buffers[binding.buffer_id];
             TouchBuffer(buffer, binding.buffer_id);
+            if (StageVirtualVertexBuffer(index, binding, false)) {
+                continue;
+            }
+            bool needs_bind = flags[Dirty::VertexBuffer0 + index];
+            if (((virtual_vertex_buffers_mask >> index) & 1) != 0) {
+                virtual_vertex_buffers_mask &= ~(1u << index);
+                needs_bind = true;
+            }
             SynchronizeBuffer(buffer, binding.device_addr, binding.size);
-            if (!flags[Dirty::VertexBuffer0 + index]) {
+            if (!needs_bind) {
                 flush_bindings();
                 continue;
             }
@@ -856,6 +957,7 @@ void BufferCache<P>::BindHostVertexBuffers() {
             last_index = index;
         }
         flush_bindings();
+        BindStagedVertexBuffers();
     } else {
         HostBindings<typename P::Buffer> host_bindings;
         bool any_valid{false};
@@ -864,8 +966,17 @@ void BufferCache<P>::BindHostVertexBuffers() {
             const Binding& binding = channel_state->vertex_buffers[index];
             Buffer& buffer = slot_buffers[binding.buffer_id];
             TouchBuffer(buffer, binding.buffer_id);
+            if (((enabled_vertex_buffers_mask >> index) & 1) != 0 &&
+                StageVirtualVertexBuffer(index, binding, true)) {
+                continue;
+            }
+            bool needs_bind = flags[Dirty::VertexBuffer0 + index];
+            if (((virtual_vertex_buffers_mask >> index) & 1) != 0) {
+                virtual_vertex_buffers_mask &= ~(1u << index);
+                needs_bind = true;
+            }
             SynchronizeBuffer(buffer, binding.device_addr, binding.size);
-            if (!flags[Dirty::VertexBuffer0 + index]) {
+            if (!needs_bind) {
                 continue;
             }
             flags[Dirty::VertexBuffer0 + index] = false;
@@ -894,6 +1005,7 @@ void BufferCache<P>::BindHostVertexBuffers() {
             }
             runtime.BindVertexBuffers(host_bindings);
         }
+        BindStagedVertexBuffers();
     }
 }
 
@@ -949,8 +1061,12 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
     }();
     const bool use_fast_buffer = needs_alignment_stream
         || (has_host_buffer && size <= channel_state->uniform_buffer_skip_cache_size
-            && !memory_tracker.IsRegionGpuModified(device_addr, size));
+            && !memory_tracker.IsRegionGpuModified(device_addr, size)
+            && !HasPendingUnifiedWrites(device_addr, size));
     if (use_fast_buffer) {
+        if (needs_alignment_stream) {
+            WaitForUnifiedWrites(device_addr, size);
+        }
         if constexpr (IS_OPENGL) {
             if (runtime.HasFastBufferSubData()) {
                 // Fast path for Nvidia
@@ -1046,6 +1162,34 @@ void BufferCache<P>::ResolveMultiRangeStorage(Binding& binding, bool is_written,
 template <class P>
 bool BufferCache<P>::BindMultiRangeStorage(const Binding& binding, bool is_written,
                                            std::span<const MultiRangeSegment> pool) {
+    if constexpr (requires { runtime.BindMultiRangeStorageBuffer(u64{}, bool{}); }) {
+        const u64 key = GeometryKey(binding.gpu_addr, 0);
+        if (!PushMultiRangeSources(binding, is_written, pool, key)) {
+            return false;
+        }
+        return runtime.BindMultiRangeStorageBuffer(key, is_written);
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+u64 BufferCache<P>::GeometryKey(GPUVAddr gpu_addr, u64 salt) const {
+    return ((static_cast<u64>(gpu_memory->GetID()) << 48) ^ gpu_addr) ^ salt;
+}
+
+template <class P>
+u32 BufferCache<P>::ClampToMappedRange(GPUVAddr gpu_addr, u32 size) const {
+    const size_t mapped = gpu_memory->MaxMappedRange(gpu_addr, size);
+    if (mapped == 0 || mapped >= size) {
+        return size;
+    }
+    return static_cast<u32>(mapped);
+}
+
+template <class P>
+bool BufferCache<P>::PushMultiRangeSources(const Binding& binding, bool is_written,
+                                           std::span<const MultiRangeSegment> pool, u64 key) {
     if constexpr (requires { runtime.BindMultiRangeStorageBuffer(u64{}, bool{}); }) {
         if (binding.segment_count < 2) {
             return false;
@@ -1053,23 +1197,273 @@ bool BufferCache<P>::BindMultiRangeStorage(const Binding& binding, bool is_writt
         if (binding.segment_first + binding.segment_count > pool.size()) {
             return false;
         }
-        const u64 key = (static_cast<u64>(gpu_memory->GetID()) << 48) ^ binding.gpu_addr;
+        const std::span<const MultiRangeSegment> segments =
+            pool.subspan(binding.segment_first, binding.segment_count);
+        boost::container::small_vector<BufferId, 8> buffer_ids;
+        for (const MultiRangeSegment& segment : segments) {
+            BufferId buffer_id = segment.buffer_id;
+            if (!buffer_id) {
+                buffer_id = page_table[segment.device_addr >> CACHING_PAGEBITS];
+            }
+            if (!buffer_id ||
+                !slot_buffers[buffer_id].IsInBounds(segment.device_addr, segment.size)) {
+                return false;
+            }
+            buffer_ids.push_back(buffer_id);
+        }
         runtime.ResetMultiRange();
         for (u32 index = 0; index < binding.segment_count; ++index) {
-            const MultiRangeSegment& segment = pool[binding.segment_first + index];
-            Buffer& buffer = slot_buffers[segment.buffer_id];
-            TouchBuffer(buffer, segment.buffer_id);
-            if (SynchronizeBuffer(buffer, segment.device_addr, segment.size)) {
+            const MultiRangeSegment& segment = segments[index];
+            const BufferId buffer_id = buffer_ids[index];
+            Buffer& buffer = slot_buffers[buffer_id];
+            TouchBuffer(buffer, buffer_id);
+            if (!SynchronizeBuffer(buffer, segment.device_addr, segment.size)) {
                 runtime.InvalidateMultiRange(key);
             }
             const u32 offset = buffer.Offset(segment.device_addr);
             buffer.MarkUsage(offset, segment.size);
             if (is_written) {
-                MarkWrittenBuffer(segment.buffer_id, segment.device_addr, segment.size);
+                MarkWrittenBuffer(buffer_id, segment.device_addr, segment.size);
             }
             runtime.PushMultiRangeSource(buffer, offset, segment.size);
         }
-        return runtime.BindMultiRangeStorageBuffer(key, is_written);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+bool BufferCache<P>::TryResolveUnifiedSegments(
+    [[maybe_unused]] const Binding& binding,
+    [[maybe_unused]] std::span<const MultiRangeSegment> pool,
+    [[maybe_unused]] UnifiedExtents& extents) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        extents.clear();
+        const auto push = [&](DAddr device_addr, u64 size) {
+            const std::optional<u64> relative = TryResolveUnifiedRange(device_addr, size);
+            if (!relative) {
+                return false;
+            }
+            if (!extents.empty() && extents.back().relative + extents.back().size == *relative) {
+                extents.back().size += size;
+                return true;
+            }
+            extents.push_back(UnifiedExtent{.relative = *relative, .size = size});
+            return true;
+        };
+        if (binding.segment_count < 2) {
+            return push(binding.device_addr, binding.size);
+        }
+        if (binding.segment_first + binding.segment_count > pool.size()) {
+            return false;
+        }
+        for (const MultiRangeSegment& segment :
+             pool.subspan(binding.segment_first, binding.segment_count)) {
+            if (!push(segment.device_addr, segment.size)) {
+                return false;
+            }
+        }
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+void BufferCache<P>::ResolveGeometrySegments([[maybe_unused]] bool is_indexed) {
+    if constexpr (requires { runtime.BindStagedVertexBuffers(); }) {
+        const auto& draw_state = maxwell3d->draw_manager.draw_state;
+        if (is_indexed && draw_state.inline_index_draw_indexes.empty()) {
+            ResolveMultiRangeStorage(channel_state->index_buffer, false, graphics_segments);
+        }
+        u32 enabled_mask = enabled_vertex_buffers_mask;
+        while (enabled_mask != 0) {
+            const u32 index = std::countr_zero(enabled_mask);
+            enabled_mask &= enabled_mask - 1;
+            Binding& slot = VertexBufferSlot(index);
+            ResolveMultiRangeStorage(slot, false, graphics_segments);
+            Binding& channel_binding = channel_state->vertex_buffers[index];
+            channel_binding.segment_first = slot.segment_first;
+            channel_binding.segment_count = slot.segment_count;
+        }
+    }
+}
+
+template <class P>
+bool BufferCache<P>::StageVirtualVertexBuffer([[maybe_unused]] u32 index,
+                                              [[maybe_unused]] const Binding& binding,
+                                              [[maybe_unused]] bool force) {
+    if constexpr (requires { runtime.BindStagedVertexBuffers(); }) {
+        auto& flags = maxwell3d->dirty.flags;
+        const bool rebind = force || flags[Dirty::VertexBuffer0 + index] ||
+                            ((virtual_vertex_buffers_mask >> index) & 1) == 0;
+        const u32 stride = maxwell3d->regs.vertex_streams[index].stride;
+        const u64 salt = VERTEX_GEOMETRY_SALT + (u64{index} << 40);
+        bool staged = false;
+        if constexpr (USE_UNIFIED_MEMORY) {
+            UnifiedExtents extents;
+            if (TryResolveUnifiedSegments(binding, graphics_segments, extents)) {
+                const u64 view_key = GeometryKey(binding.gpu_addr, salt + VIEW_GEOMETRY_SALT);
+                staged = runtime.StageUnifiedVertexBuffer(index, view_key, extents, binding.size,
+                                                          stride, rebind);
+            }
+        }
+        if (!staged) {
+            const u64 key = GeometryKey(binding.gpu_addr, salt);
+            if (PushMultiRangeSources(binding, false, graphics_segments, key)) {
+                staged = runtime.StageMultiRangeVertexBuffer(index, key, binding.size, stride,
+                                                             rebind);
+            }
+        }
+        if (!staged) {
+            return false;
+        }
+        flags[Dirty::VertexBuffer0 + index] = false;
+        virtual_vertex_buffers_mask |= 1u << index;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+bool BufferCache<P>::BindVirtualIndexBuffer() {
+    if constexpr (!HAS_FULL_INDEX_AND_PRIMITIVE_SUPPORT &&
+                  requires { runtime.BindStagedVertexBuffers(); }) {
+        const Binding& binding = channel_state->index_buffer;
+        const auto& draw_state = maxwell3d->draw_manager.draw_state;
+        const auto& index_ref = draw_state.index_buffer;
+        if constexpr (USE_UNIFIED_MEMORY) {
+            UnifiedExtents extents;
+            const u64 view_key =
+                GeometryKey(binding.gpu_addr, INDEX_GEOMETRY_SALT + VIEW_GEOMETRY_SALT);
+            if (TryResolveUnifiedSegments(binding, graphics_segments, extents) &&
+                runtime.BindUnifiedIndexBuffer(draw_state.topology, index_ref.format,
+                                               index_ref.first, index_ref.count, view_key,
+                                               extents, binding.size)) {
+                return true;
+            }
+        }
+        const u64 key = GeometryKey(binding.gpu_addr, INDEX_GEOMETRY_SALT);
+        if (!PushMultiRangeSources(binding, false, graphics_segments, key)) {
+            return false;
+        }
+        return runtime.BindMultiRangeIndexBuffer(draw_state.topology, index_ref.format,
+                                                 index_ref.first, index_ref.count, key,
+                                                 binding.size);
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+void BufferCache<P>::BindStagedVertexBuffers() {
+    if constexpr (requires { runtime.BindStagedVertexBuffers(); }) {
+        runtime.BindStagedVertexBuffers();
+    }
+}
+
+template <class P>
+bool BufferCache<P>::HasPendingUnifiedWrites([[maybe_unused]] DAddr device_addr,
+                                             [[maybe_unused]] u64 size) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        if (unified_written_ranges.Empty()) {
+            return false;
+        }
+        if (runtime.KnownGpuTick() >= unified_write_tick) {
+            unified_written_ranges.Clear();
+            return false;
+        }
+        bool overlaps = false;
+        unified_written_ranges.ForEachInRange(device_addr, size,
+                                              [&overlaps](DAddr, DAddr) { overlaps = true; });
+        return overlaps;
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+void BufferCache<P>::WaitForUnifiedWrites([[maybe_unused]] DAddr device_addr,
+                                          [[maybe_unused]] u64 size) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        if (!HasPendingUnifiedWrites(device_addr, size)) {
+            return;
+        }
+        runtime.Wait(unified_write_tick);
+        unified_written_ranges.Clear();
+    }
+}
+
+template <class P>
+template <typename Func>
+bool BufferCache<P>::CopyUnifiedWrites([[maybe_unused]] Buffer& buffer,
+                                       [[maybe_unused]] DAddr device_addr,
+                                       [[maybe_unused]] u64 size,
+                                       [[maybe_unused]] Func&& add_upload) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        if (!HasPendingUnifiedWrites(device_addr, size)) {
+            return false;
+        }
+        boost::container::small_vector<std::pair<DAddr, DAddr>, 4> overlaps;
+        unified_written_ranges.ForEachInRange(device_addr, size,
+                                              [&overlaps](DAddr start, DAddr end) {
+                                                  overlaps.emplace_back(start, end);
+                                              });
+        const DAddr buffer_start = buffer.CpuAddr();
+        boost::container::small_vector<u64, 4> window_ids;
+        UnifiedWindowGroups groups;
+        for (const auto& [start, end] : overlaps) {
+            if (!ResolveUnifiedWindows(start, start - buffer_start, end - start, window_ids,
+                                       groups)) {
+                runtime.Wait(unified_write_tick);
+                unified_written_ranges.Clear();
+                return false;
+            }
+        }
+        for (size_t i = 0; i < window_ids.size(); ++i) {
+            const std::span<const BufferCopy> group_span(groups[i].data(), groups[i].size());
+            runtime.CopyFromUnifiedMemory(window_ids[i], buffer, group_span);
+        }
+        DAddr cursor = device_addr;
+        for (const auto& [start, end] : overlaps) {
+            buffer.MarkUsage(start - buffer_start, end - start);
+            if (start > cursor) {
+                add_upload(cursor, start - cursor);
+            }
+            cursor = end;
+        }
+        if (cursor < device_addr + size) {
+            add_upload(cursor, device_addr + size - cursor);
+        }
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+bool BufferCache<P>::BindUnifiedStorage([[maybe_unused]] const Binding& binding,
+                                        [[maybe_unused]] bool is_written) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        const auto relative = TryResolveUnifiedRange(binding.device_addr, binding.size);
+        if (!relative) {
+            return false;
+        }
+        const auto range = runtime.ResolveUnifiedStorage(*relative, binding.size);
+        if (!range) {
+            return false;
+        }
+        if (is_written) {
+            memory_tracker.MarkRegionAsCpuModified(binding.device_addr, binding.size);
+            unified_written_ranges.Add(binding.device_addr, binding.size);
+            unified_write_tick = runtime.CurrentTick();
+            uncommitted_unified_writes = true;
+        }
+        runtime.BindStorageBuffer(range->buffer, range->address, range->offset,
+                                  binding.size, is_written);
+        return true;
     } else {
         return false;
     }
@@ -1086,7 +1480,11 @@ void BufferCache<P>::BindHostGraphicsStorageBuffers(size_t stage) {
         }
         Buffer& buffer = slot_buffers[binding.buffer_id];
         TouchBuffer(buffer, binding.buffer_id);
+        if (BindUnifiedStorage(binding, is_written)) {
+            return;
+        }
         const u32 size = binding.size;
+
         SynchronizeBuffer(buffer, binding.device_addr, size);
 
         const u32 offset = buffer.Offset(binding.device_addr);
@@ -1195,6 +1593,7 @@ void BufferCache<P>::BindHostComputeUniformBuffers() {
         }();
         if constexpr (!IS_OPENGL) {
             if (needs_alignment_stream) {
+                WaitForUnifiedWrites(binding.device_addr, size);
                 const std::span<u8> span =
                     runtime.BindMappedUniformBuffer(0, binding_index, size);
                 device_memory.ReadBlockUnsafe(binding.device_addr, span.data(), size);
@@ -1226,6 +1625,9 @@ void BufferCache<P>::BindHostComputeStorageBuffers() {
         }
         Buffer& buffer = slot_buffers[binding.buffer_id];
         TouchBuffer(buffer, binding.buffer_id);
+        if (BindUnifiedStorage(binding, is_written)) {
+            return;
+        }
         const u32 size = binding.size;
         SynchronizeBuffer(buffer, binding.device_addr, size);
 
@@ -1282,6 +1684,7 @@ void BufferCache<P>::DoUpdateGraphicsBuffers(bool is_indexed) {
             UpdateIndexBuffer();
         }
         UpdateVertexBuffers();
+        ResolveGeometrySegments(is_indexed);
         UpdateTransformFeedbackBuffers();
         for (size_t stage = 0; stage < NUM_STAGES; ++stage) {
             UpdateUniformBuffers(stage);
@@ -1338,13 +1741,17 @@ void BufferCache<P>::UpdateIndexBuffer() {
     const std::optional<DAddr> device_addr = gpu_memory->GpuToCpuAddress(gpu_addr_begin);
     const u32 address_size = static_cast<u32>(gpu_addr_end - gpu_addr_begin);
     const u32 draw_size = (index_buffer_ref.count + index_buffer_ref.first) * u32(index_buffer_ref.FormatSizeInBytes());
-    const u32 size = (std::min)(address_size, draw_size);
+    u32 size = (std::min)(address_size, draw_size);
     if (size == 0 || !device_addr) {
         channel_state->index_buffer = NULL_BINDING;
         return;
     }
+    if constexpr (requires { runtime.BindStagedVertexBuffers(); }) {
+        size = ClampToMappedRange(gpu_addr_begin, size);
+    }
     channel_state->index_buffer = Binding{
         .device_addr = *device_addr,
+        .gpu_addr = gpu_addr_begin,
         .size = size,
         .buffer_id = FindBuffer(*device_addr, size, false),
     };
@@ -1382,10 +1789,13 @@ void BufferCache<P>::UpdateVertexBuffer(u32 index) {
     }
     if (!gpu_memory->IsWithinGPUAddressRange(gpu_addr_end) || size >= 64_MiB) {
         size = static_cast<u32>(gpu_memory->MaxContinuousRange(gpu_addr_begin, size));
+    } else if constexpr (requires { runtime.BindStagedVertexBuffers(); }) {
+        size = ClampToMappedRange(gpu_addr_begin, size);
     }
     const BufferId buffer_id = FindBuffer(*device_addr, size, false);
     const Binding binding{
         .device_addr = *device_addr,
+        .gpu_addr = gpu_addr_begin,
         .size = size,
         .buffer_id = buffer_id,
     };
@@ -1742,16 +2152,28 @@ bool BufferCache<P>::SynchronizeBuffer(Buffer& buffer, DAddr device_addr, u32 si
     u64 total_size_bytes = 0;
     u64 largest_copy = 0;
     const DAddr buffer_start = buffer.cpu_addr_cached;
-    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 device_addr_out, u64 range_size) {
+    const auto add_upload = [&](u64 upload_addr, u64 upload_size) {
         upload_copies.push_back(BufferCopy{
             .src_offset = total_size_bytes,
-            .dst_offset = device_addr_out - buffer_start,
-            .size = range_size,
+            .dst_offset = upload_addr - buffer_start,
+            .size = upload_size,
         });
-        total_size_bytes += range_size;
-        largest_copy = (std::max)(largest_copy, range_size);
+        total_size_bytes += upload_size;
+        largest_copy = (std::max)(largest_copy, upload_size);
+    };
+    bool copied_from_windows = false;
+    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 device_addr_out, u64 range_size) {
+        if (CopyUnifiedWrites(buffer, device_addr_out, range_size, add_upload)) {
+            copied_from_windows = true;
+            return;
+        }
+        add_upload(device_addr_out, range_size);
     });
     if (total_size_bytes == 0) {
+        if (copied_from_windows) {
+            any_buffer_uploaded = true;
+            return false;
+        }
         return true;
     }
     const std::span<BufferCopy> copies_span(upload_copies.data(), upload_copies.size());
@@ -1799,6 +2221,130 @@ void BufferCache<P>::ImmediateUploadMemory([[maybe_unused]] Buffer& buffer,
     }
 }
 
+template <class P>
+bool BufferCache<P>::ResolveUnifiedWindows(
+    [[maybe_unused]] DAddr device_addr, [[maybe_unused]] u64 buffer_offset,
+    [[maybe_unused]] u64 size, [[maybe_unused]] boost::container::small_vector<u64, 4>& window_ids,
+    [[maybe_unused]] UnifiedWindowGroups& groups) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        const u8* const physical_base = device_memory.GetPhysicalBase();
+        const u64 unified_base = runtime.UnifiedMemoryBase();
+        const u64 unified_size = runtime.UnifiedMemorySize();
+        const u64 window_size = runtime.UnifiedMemoryWindowSize();
+        if (window_size == 0) {
+            return false;
+        }
+        const auto group_for = [&](u64 window) -> boost::container::small_vector<BufferCopy, 16>& {
+            for (size_t i = 0; i < window_ids.size(); ++i) {
+                if (window_ids[i] == window) {
+                    return groups[i];
+                }
+            }
+            window_ids.push_back(window);
+            groups.emplace_back();
+            return groups.back();
+        };
+        u64 downloaded = 0;
+        while (downloaded < size) {
+            const DAddr page_addr = device_addr + downloaded;
+            const u8* const ptr = device_memory.GetPointer<u8>(page_addr);
+            if (ptr == nullptr) {
+                return false;
+            }
+            const u64 page_offset = page_addr & Core::DEVICE_PAGEMASK;
+            u64 chunk = (std::min)(size - downloaded,
+                                   static_cast<u64>(Core::DEVICE_PAGESIZE) - page_offset);
+            const u64 phys_offset = static_cast<u64>(ptr - physical_base);
+            if (phys_offset < unified_base || phys_offset - unified_base + chunk > unified_size) {
+                return false;
+            }
+            const u64 relative = phys_offset - unified_base;
+            const u64 window = relative / window_size;
+            const u64 local_offset = relative % window_size;
+            chunk = (std::min)(chunk, window_size - local_offset);
+            auto& group = group_for(window);
+            if (!group.empty()) {
+                BufferCopy& last = group.back();
+                if (last.src_offset + last.size == buffer_offset + downloaded &&
+                    last.dst_offset + last.size == local_offset) {
+                    last.size += chunk;
+                    downloaded += chunk;
+                    continue;
+                }
+            }
+            group.push_back(BufferCopy{
+                .src_offset = buffer_offset + downloaded,
+                .dst_offset = local_offset,
+                .size = chunk,
+            });
+            downloaded += chunk;
+        }
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+std::optional<u64> BufferCache<P>::TryResolveUnifiedRange([[maybe_unused]] DAddr device_addr,
+                                                          [[maybe_unused]] u64 size) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        if (size == 0 || !runtime.IsUnifiedMemoryBindable()) {
+            return std::nullopt;
+        }
+        const u8* const first = device_memory.GetSpan(device_addr, size);
+        if (first == nullptr) {
+            return std::nullopt;
+        }
+        const u64 phys_offset = static_cast<u64>(first - device_memory.GetPhysicalBase());
+        const u64 unified_base = runtime.UnifiedMemoryBase();
+        if (phys_offset < unified_base) {
+            return std::nullopt;
+        }
+        const u64 relative = phys_offset - unified_base;
+        const u64 unified_size = runtime.UnifiedMemorySize();
+        if (relative >= unified_size || unified_size - relative < size) {
+            return std::nullopt;
+        }
+        if (memory_tracker.IsRegionGpuModified(device_addr, size) ||
+            IsRegionGpuModified(device_addr, size)) {
+            return std::nullopt;
+        }
+        return relative;
+    } else {
+        return std::nullopt;
+    }
+}
+
+template <class P>
+bool BufferCache<P>::TryUnifiedDownloadMemory([[maybe_unused]] Buffer& buffer,
+                                              [[maybe_unused]] std::span<BufferCopy> copies) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        boost::container::small_vector<u64, 4> window_ids;
+        UnifiedWindowGroups groups;
+        for (const BufferCopy& copy : copies) {
+            if (!ResolveUnifiedWindows(buffer.CpuAddr() + copy.src_offset, copy.src_offset,
+                                       copy.size, window_ids, groups)) {
+                return false;
+            }
+        }
+        for (const BufferCopy& copy : copies) {
+            buffer.MarkUsage(copy.src_offset, copy.size);
+        }
+        runtime.PreCopyBarrier();
+        for (size_t i = 0; i < window_ids.size(); ++i) {
+            const std::span<const BufferCopy> group_span(groups[i].data(), groups[i].size());
+            runtime.CopyToUnifiedMemory(window_ids[i], buffer, group_span);
+        }
+        runtime.FlushUnifiedMemoryCopies();
+        runtime.UnifiedMemoryHostBarrier();
+        runtime.Finish();
+        return true;
+    } else {
+        return false;
+    }
+}
+
 template <class P>
 void BufferCache<P>::MappedUploadMemory([[maybe_unused]] Buffer& buffer,
                                         [[maybe_unused]] u64 total_size_bytes,
@@ -1902,6 +2448,12 @@ void BufferCache<P>::DownloadBufferMemory(Buffer& buffer, DAddr device_addr, u64
     }
 
     if constexpr (USE_MEMORY_MAPS) {
+        if constexpr (USE_UNIFIED_MEMORY) {
+            if (runtime.HasUnifiedMemory() &&
+                TryUnifiedDownloadMemory(buffer, std::span(copies.data(), copies.size()))) {
+                return;
+            }
+        }
         auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes);
         const u8* const mapped_memory = download_staging.mapped_span.data();
         const std::span<BufferCopy> copies_span(copies.data(), copies.data() + copies.size());
@@ -1963,6 +2515,15 @@ void BufferCache<P>::DeleteBuffer(BufferId buffer_id, bool do_not_mark) {
     replace(channel_state->transform_feedback_buffers);
     replace(channel_state->compute_uniform_buffers);
     replace(channel_state->compute_storage_buffers);
+    const auto drop_segments = [buffer_id](std::vector<MultiRangeSegment>& pool) {
+        for (MultiRangeSegment& segment : pool) {
+            if (segment.buffer_id == buffer_id) {
+                segment.buffer_id = BufferId{};
+            }
+        }
+    };
+    drop_segments(graphics_segments);
+    drop_segments(compute_segments);
 
     // Mark the whole buffer as CPU written to stop tracking CPU writes
     if (!do_not_mark) {

src/video_core/buffer_cache/buffer_cache_base.h

@@ -12,6 +12,7 @@
 #include <functional>
 #include <memory>
 #include <mutex>
+#include <optional>
 #include <numeric>
 #include <span>
 #include <vector>
@@ -95,6 +96,11 @@ struct MultiRangeSegment {
     u32 size{};
 };
 
+struct UnifiedExtent {
+    u64 relative{};
+    u64 size{};
+};
+
 struct TextureBufferBinding : Binding {
     PixelFormat format;
 };
@@ -190,6 +196,10 @@ class BufferCache : public VideoCommon::ChannelSetupCaches<BufferCacheChannelInf
     static constexpr bool USE_MEMORY_MAPS = P::USE_MEMORY_MAPS;
     static constexpr bool SEPARATE_IMAGE_BUFFERS_BINDINGS = P::SEPARATE_IMAGE_BUFFER_BINDINGS;
     static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = P::USE_MEMORY_MAPS_FOR_UPLOADS;
+    static constexpr bool USE_UNIFIED_MEMORY = P::USE_UNIFIED_MEMORY;
+    static constexpr u64 VERTEX_GEOMETRY_SALT = u64{1} << 47;
+    static constexpr u64 INDEX_GEOMETRY_SALT = u64{1} << 46;
+    static constexpr u64 VIEW_GEOMETRY_SALT = u64{1} << 45;
 
 #ifdef YUZU_LEGACY
     static constexpr s64 TARGET_THRESHOLD = 3_GiB;
@@ -228,6 +238,11 @@ public:
     bool BindMultiRangeStorage(const Binding& binding, bool is_written,
                                std::span<const MultiRangeSegment> pool);
 
+    bool BindUnifiedStorage(const Binding& binding, bool is_written);
+
+    bool PushMultiRangeSources(const Binding& binding, bool is_written,
+                               std::span<const MultiRangeSegment> pool, u64 key);
+
     void ResolveMultiRangeStorage(Binding& binding, bool is_written,
                                   std::vector<MultiRangeSegment>& pool);
 
@@ -462,6 +477,41 @@ private:
 
     void MappedUploadMemory(Buffer& buffer, u64 total_size_bytes, std::span<BufferCopy> copies);
 
+    bool TryUnifiedDownloadMemory(Buffer& buffer, std::span<BufferCopy> copies);
+
+    std::optional<u64> TryResolveUnifiedRange(DAddr device_addr, u64 size);
+
+    using UnifiedExtents = boost::container::small_vector<UnifiedExtent, 8>;
+
+    bool TryResolveUnifiedSegments(const Binding& binding, std::span<const MultiRangeSegment> pool,
+                                   UnifiedExtents& extents);
+
+    void ResolveGeometrySegments(bool is_indexed);
+
+    bool StageVirtualVertexBuffer(u32 index, const Binding& binding, bool force);
+
+    bool BindVirtualIndexBuffer();
+
+    void BindStagedVertexBuffers();
+
+    [[nodiscard]] u64 GeometryKey(GPUVAddr gpu_addr, u64 salt) const;
+
+    [[nodiscard]] u32 ClampToMappedRange(GPUVAddr gpu_addr, u32 size) const;
+
+    bool HasPendingUnifiedWrites(DAddr device_addr, u64 size);
+
+    void WaitForUnifiedWrites(DAddr device_addr, u64 size);
+
+    template <typename Func>
+    bool CopyUnifiedWrites(Buffer& buffer, DAddr device_addr, u64 size, Func&& add_upload);
+
+    using UnifiedWindowGroups =
+        boost::container::small_vector<boost::container::small_vector<BufferCopy, 16>, 4>;
+
+    bool ResolveUnifiedWindows(DAddr device_addr, u64 buffer_offset, u64 size,
+                               boost::container::small_vector<u64, 4>& window_ids,
+                               UnifiedWindowGroups& groups);
+
     void DownloadBufferMemory(Buffer& buffer_id);
 
     void DownloadBufferMemory(Buffer& buffer_id, DAddr device_addr, u64 size);
@@ -506,6 +556,7 @@ private:
     u32 last_index_count = 0;
 
     u32 enabled_vertex_buffers_mask = 0;
+    u32 virtual_vertex_buffers_mask = 0;
     u64 vertex_buffers_serial = 0;
     std::array<Binding, 32> v_buffer{};
 
@@ -515,11 +566,20 @@ private:
     Common::RangeSet<DAddr> uncommitted_gpu_modified_ranges;
     Common::RangeSet<DAddr> gpu_modified_ranges;
     std::deque<Common::RangeSet<DAddr>> committed_gpu_modified_ranges;
+    Common::RangeSet<DAddr> unified_written_ranges;
+    u64 unified_write_tick = 0;
+    bool uncommitted_unified_writes = false;
 
     // Async Buffers
+    struct AsyncDownloadBatch {
+        boost::container::small_vector<BufferCopy, 4> staging_copies;
+        boost::container::small_vector<BufferCopy, 4> unified_copies;
+        bool unified_writes = false;
+    };
+
     Common::OverlapRangeSet<DAddr> async_downloads;
     std::deque<std::optional<Async_Buffer>> async_buffers;
-    std::deque<boost::container::small_vector<BufferCopy, 4>> pending_downloads;
+    std::deque<AsyncDownloadBatch> pending_downloads;
     std::optional<Async_Buffer> current_buffer;
 
     std::deque<Async_Buffer> async_buffers_death_ring;

src/video_core/host_shaders/CMakeLists.txt

@@ -16,13 +16,16 @@ set(GLSL_INCLUDES
 set(SHADER_FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/astc_decoder.comp
     ${CMAKE_CURRENT_SOURCE_DIR}/blit_color_float.frag
+    ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_swizzle_2d_buffer.comp
     ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_2d.comp
+    ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_2d_buffer.comp
     ${CMAKE_CURRENT_SOURCE_DIR}/blit_color_msaa.frag
     ${CMAKE_CURRENT_SOURCE_DIR}/blit_depth.frag
     ${CMAKE_CURRENT_SOURCE_DIR}/blit_depth_msaa.frag
     ${CMAKE_CURRENT_SOURCE_DIR}/blit_depth_stencil_msaa.frag
     ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_3d.comp
     ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_3d_bcn.comp
+    ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_3d_buffer.comp
     ${CMAKE_CURRENT_SOURCE_DIR}/convert_abgr8_to_d24s8.frag
     ${CMAKE_CURRENT_SOURCE_DIR}/convert_abgr8_to_d32f.frag
     ${CMAKE_CURRENT_SOURCE_DIR}/convert_d32f_to_abgr8.frag

src/video_core/host_shaders/block_linear_swizzle_2d_buffer.comp

@@ -0,0 +1,83 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#version 430
+
+#define BINDING_INPUT_BUFFER 0
+#define BINDING_OUTPUT_BUFFER 1
+
+layout(push_constant) uniform PushConstants {
+    uvec3 dim;
+    uint bytes_per_block_log2;
+
+    uvec3 origin;
+    uint layer_stride;
+
+    uint block_size;
+    uint x_shift;
+    uint block_height;
+    uint block_height_mask;
+} pc;
+
+layout(binding = BINDING_INPUT_BUFFER, std430) readonly buffer InputBuffer {
+    uint in_u32[];
+};
+
+layout(binding = BINDING_OUTPUT_BUFFER, std430) buffer OutputBuffer {
+    uint out_u32[];
+};
+
+layout(local_size_x = 16, local_size_y = 8, local_size_z = 1) in;
+
+const uint GOB_SIZE_X = 64;
+const uint GOB_SIZE_Y = 8;
+
+const uint GOB_SIZE_X_SHIFT = 6;
+const uint GOB_SIZE_Y_SHIFT = 3;
+const uint GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT;
+
+const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1u, GOB_SIZE_Y - 1u);
+
+uint SwizzleTable(uint pos) {
+    const uint t[8] = uint[](
+        0x12100200, 0x13110301, 0x16140604, 0x17150705,
+        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
+    );
+    const uint i = pos >> 4;
+    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
+    return (h << 4) | (pos & 0xf);
+}
+
+uint SwizzleOffset(uvec2 pos) {
+    pos = pos & SWIZZLE_MASK;
+    return SwizzleTable(pos.y * 64u + pos.x);
+}
+
+void main() {
+    uvec3 coord = gl_GlobalInvocationID;
+    if (coord.x >= pc.dim.x || coord.y >= pc.dim.y || coord.z >= pc.dim.z) {
+        return;
+    }
+
+    uvec3 pos = coord + pc.origin;
+    pos.x <<= pc.bytes_per_block_log2;
+
+    uint swizzle = SwizzleOffset(pos.xy);
+    uint block_y = pos.y >> GOB_SIZE_Y_SHIFT;
+
+    uint offset = 0u;
+    offset += pos.z * pc.layer_stride;
+    offset += (block_y >> pc.block_height) * pc.block_size;
+    offset += (block_y & pc.block_height_mask) << GOB_SIZE_SHIFT;
+    offset += (pos.x >> GOB_SIZE_X_SHIFT) << pc.x_shift;
+    offset += swizzle;
+
+    uint words = 1u << (pc.bytes_per_block_log2 - 2u);
+    uint linear_index = coord.x + coord.y * pc.dim.x + coord.z * pc.dim.x * pc.dim.y;
+    uint in_idx = linear_index * words;
+    uint out_idx = offset >> 2u;
+
+    for (uint word = 0u; word < words; ++word) {
+        out_u32[out_idx + word] = in_u32[in_idx + word];
+    }
+}

src/video_core/host_shaders/block_linear_unswizzle_2d_buffer.comp

@@ -0,0 +1,104 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#version 430
+
+#extension GL_EXT_shader_16bit_storage : require
+#extension GL_EXT_shader_8bit_storage : require
+
+#define BINDING_INPUT_BUFFER 0
+#define BINDING_OUTPUT_BUFFER 1
+
+layout(push_constant) uniform PushConstants {
+    uvec3 dim;
+    uint bytes_per_block_log2;
+
+    uvec3 origin;
+    uint layer_stride;
+
+    uint block_size;
+    uint x_shift;
+    uint block_height;
+    uint block_height_mask;
+} pc;
+
+layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU32 { uint u32data[]; };
+layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU64 { uvec2 u64data[]; };
+layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU128 { uvec4 u128data[]; };
+
+layout(binding = BINDING_OUTPUT_BUFFER, std430) writeonly buffer OutputBuffer {
+    uint out_u32[];
+};
+
+layout(local_size_x = 16, local_size_y = 8, local_size_z = 1) in;
+
+const uint GOB_SIZE_X = 64;
+const uint GOB_SIZE_Y = 8;
+
+const uint GOB_SIZE_X_SHIFT = 6;
+const uint GOB_SIZE_Y_SHIFT = 3;
+const uint GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT;
+
+const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1u, GOB_SIZE_Y - 1u);
+
+uint SwizzleTable(uint pos) {
+    const uint t[8] = uint[](
+        0x12100200, 0x13110301, 0x16140604, 0x17150705,
+        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
+    );
+    const uint i = pos >> 4;
+    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
+    return (h << 4) | (pos & 0xf);
+}
+
+uint SwizzleOffset(uvec2 pos) {
+    pos = pos & SWIZZLE_MASK;
+    return SwizzleTable(pos.y * 64u + pos.x);
+}
+
+uvec4 ReadTexel(uint offset) {
+    switch (pc.bytes_per_block_log2) {
+    case 2u:
+        return uvec4(u32data[offset / 4u], 0u, 0u, 0u);
+    case 3u:
+        return uvec4(u64data[offset / 8u], 0u, 0u);
+    case 4u:
+        return u128data[offset / 16u];
+    }
+    return uvec4(0u);
+}
+
+void main() {
+    uvec3 coord = gl_GlobalInvocationID;
+    if (coord.x >= pc.dim.x || coord.y >= pc.dim.y || coord.z >= pc.dim.z) {
+        return;
+    }
+
+    uvec3 pos = coord + pc.origin;
+    pos.x <<= pc.bytes_per_block_log2;
+
+    uint swizzle = SwizzleOffset(pos.xy);
+    uint block_y = pos.y >> GOB_SIZE_Y_SHIFT;
+
+    uint offset = 0u;
+    offset += pos.z * pc.layer_stride;
+    offset += (block_y >> pc.block_height) * pc.block_size;
+    offset += (block_y & pc.block_height_mask) << GOB_SIZE_SHIFT;
+    offset += (pos.x >> GOB_SIZE_X_SHIFT) << pc.x_shift;
+    offset += swizzle;
+
+    uvec4 texel = ReadTexel(offset);
+
+    uint words = 1u << (pc.bytes_per_block_log2 - 2u);
+    uint linear_index = coord.x + coord.y * pc.dim.x + coord.z * pc.dim.x * pc.dim.y;
+    uint out_idx = linear_index * words;
+
+    out_u32[out_idx] = texel.x;
+    if (words > 1u) {
+        out_u32[out_idx + 1u] = texel.y;
+    }
+    if (words > 2u) {
+        out_u32[out_idx + 2u] = texel.z;
+        out_u32[out_idx + 3u] = texel.w;
+    }
+}

src/video_core/host_shaders/block_linear_unswizzle_3d_buffer.comp

@@ -0,0 +1,105 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#version 430
+
+#define BINDING_INPUT_BUFFER 0
+#define BINDING_OUTPUT_BUFFER 1
+
+layout(push_constant) uniform PushConstants {
+    uvec3 dim;
+    uint bytes_per_block_log2;
+
+    uvec3 origin;
+    uint slice_size;
+
+    uint block_size;
+    uint x_shift;
+    uint block_height;
+    uint block_height_mask;
+
+    uint block_depth;
+    uint block_depth_mask;
+} pc;
+
+layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU32 { uint u32data[]; };
+layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU64 { uvec2 u64data[]; };
+layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU128 { uvec4 u128data[]; };
+
+layout(binding = BINDING_OUTPUT_BUFFER, std430) writeonly buffer OutputBuffer {
+    uint out_u32[];
+};
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 4) in;
+
+const uint GOB_SIZE_X = 64;
+const uint GOB_SIZE_Y = 8;
+
+const uint GOB_SIZE_X_SHIFT = 6;
+const uint GOB_SIZE_Y_SHIFT = 3;
+const uint GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT;
+
+const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1u, GOB_SIZE_Y - 1u);
+
+uint SwizzleTable(uint pos) {
+    const uint t[8] = uint[](
+        0x12100200, 0x13110301, 0x16140604, 0x17150705,
+        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
+    );
+    const uint i = pos >> 4;
+    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
+    return (h << 4) | (pos & 0xf);
+}
+
+uint SwizzleOffset(uvec2 pos) {
+    pos = pos & SWIZZLE_MASK;
+    return SwizzleTable(pos.y * 64u + pos.x);
+}
+
+uvec4 ReadTexel(uint offset) {
+    switch (pc.bytes_per_block_log2) {
+    case 2u:
+        return uvec4(u32data[offset / 4u], 0u, 0u, 0u);
+    case 3u:
+        return uvec4(u64data[offset / 8u], 0u, 0u);
+    case 4u:
+        return u128data[offset / 16u];
+    }
+    return uvec4(0u);
+}
+
+void main() {
+    uvec3 coord = gl_GlobalInvocationID;
+    if (coord.x >= pc.dim.x || coord.y >= pc.dim.y || coord.z >= pc.dim.z) {
+        return;
+    }
+
+    uvec3 pos = coord + pc.origin;
+    pos.x <<= pc.bytes_per_block_log2;
+
+    uint swizzle = SwizzleOffset(pos.xy);
+    uint block_y = pos.y >> GOB_SIZE_Y_SHIFT;
+
+    uint offset = 0u;
+    offset += (pos.z >> pc.block_depth) * pc.slice_size;
+    offset += (pos.z & pc.block_depth_mask) << (GOB_SIZE_SHIFT + pc.block_height);
+    offset += (block_y >> pc.block_height) * pc.block_size;
+    offset += (block_y & pc.block_height_mask) << GOB_SIZE_SHIFT;
+    offset += (pos.x >> GOB_SIZE_X_SHIFT) << pc.x_shift;
+    offset += swizzle;
+
+    uvec4 texel = ReadTexel(offset);
+
+    uint words = 1u << (pc.bytes_per_block_log2 - 2u);
+    uint linear_index = coord.x + coord.y * pc.dim.x + coord.z * pc.dim.x * pc.dim.y;
+    uint out_idx = linear_index * words;
+
+    out_u32[out_idx] = texel.x;
+    if (words > 1u) {
+        out_u32[out_idx + 1u] = texel.y;
+    }
+    if (words > 2u) {
+        out_u32[out_idx + 2u] = texel.z;
+        out_u32[out_idx + 3u] = texel.w;
+    }
+}

src/video_core/host_shaders/sgsr1_shader_mobile.frag

@@ -6,9 +6,9 @@
 precision highp float;
 precision highp int;
 
-// Operation modes: RGBA -> 1, RGBY -> 3, LERP -> 4
-#define OPERATION_MODE 1
 #define EDGE_THRESHOLD (8.0 / 255.0)
+#define DIRECTION_EPSILON 6.5e-05
+#define DEVIATION_FLOOR 6.0e-02
 
 layout(push_constant) uniform constants {
     vec2 scale;
@@ -21,20 +21,37 @@ layout(set = 0, binding = 0) uniform sampler2D sampler0;
 layout(location=0) in vec2 texcoord;
 layout(location=0) out vec4 frag_color;
 
-vec4 weightY(vec4 dx, vec4 dy, vec4 std) {
-    vec4 x = ((dx * dx) + (dy * dy)) * 0.55f + std;
-    return (x - 1.f) * (x - 4.f) * 3.8125f; // approx. of (x - 1) * (x - 4)^3
+mediump vec4 fastLanczos2(mediump vec4 x) {
+    mediump vec4 wA = x - 4.0f;
+    mediump vec4 wB = x * wA - wA;
+    wA *= wA;
+    return wB * wA;
+}
+
+mediump vec2 edgeDirection(mediump vec4 left, mediump vec4 right) {
+    mediump float RxLz = right.x - left.z;
+    mediump float RwLy = right.w - left.y;
+    mediump vec2 delta = vec2(RxLz + RwLy, RxLz - RwLy);
+    mediump float length_inv =
+        inversesqrt((delta.x * delta.x + DIRECTION_EPSILON) + delta.y * delta.y);
+    return delta * length_inv;
+}
+
+mediump vec4 weightY(mediump vec4 dx, mediump vec4 dy, mediump vec4 c, mediump float std,
+                     mediump vec2 dir) {
+    mediump vec4 edge_dis = dx * dir.y + dy * dir.x;
+    mediump vec4 x = (dx * dx + dy * dy) +
+                     (edge_dis * edge_dis) * (clamp((c * c) * std, 0.0f, 1.0f) * 0.7f - 1.0f);
+    return fastLanczos2(x);
 }
 
 void main() {
-    vec4 color = textureLod(sampler0, texcoord.xy, 0.0f);
-    // image coord
-    vec2 icoord = (texcoord * size + vec2(-0.5f, 0.5f));
-    vec2 icoord_pixel = floor(icoord);
-    vec2 coord = icoord_pixel * scale;
-    vec2 pl = icoord - icoord_pixel;
-    // left: 0, right: 1, upDown: 2
-    mat3x4 dg = mat3x4(
+    mediump vec4 color = textureLod(sampler0, texcoord.xy, 0.0f);
+    highp vec2 icoord = (texcoord * size + vec2(-0.5f, 0.5f));
+    highp vec2 icoord_pixel = floor(icoord);
+    highp vec2 coord = icoord_pixel * scale;
+    mediump vec2 pl = icoord - icoord_pixel;
+    mediump mat3x4 dg = mat3x4(
         textureGather(sampler0, coord, 1),
         textureGather(sampler0, coord + vec2(2.f * scale.x, 0.0f), 1),
         vec4(
@@ -42,42 +59,40 @@ void main() {
             textureGather(sampler0, coord + vec2(scale.x, +scale.y), 1).yx
         )
     );
-    float edgeVote = abs(dg[0].z - dg[0].y) + abs(color.y - dg[0].y) + abs(color.y - dg[0].z);
+    mediump float edgeVote =
+        abs(dg[0].z - dg[0].y) + abs(color.y - dg[0].y) + abs(color.y - dg[0].z);
     if (edgeVote > EDGE_THRESHOLD) {
-        float mean = (dg[0].y + dg[0].z + dg[1].x + dg[1].w) * 0.25f;
+        mediump float mean = (dg[0].y + dg[0].z + dg[1].x + dg[1].w) * 0.25f;
         dg = dg - mean;
-        vec4 sum = abs(dg[0]) + abs(dg[1]) + abs(dg[2]);
-        float std = 2.181818f / (sum.x + sum.y + sum.z + sum.w);
-        mat2x4 w = mat2x4(
-            weightY(
-                pl.xxxx + vec4(+1.0f, +0.0f, +0.0f, +1.0f),
-                pl.yyyy + vec4(-1.0f, -1.0f, +0.0f, +0.0f),
-                clamp(abs(dg[0]) * std, 0.0f, 1.0f)
-            ) + weightY(
-                pl.xxxx + vec4(-1.0f, -2.0f, -2.0f, -1.0f),
-                pl.yyyy + vec4(-1.0f, -1.0f, +0.0f, +0.0f),
-                clamp(abs(dg[1]) * std, 0.0f, 1.0f)
-            ) + weightY(
-                pl.xxxx + vec4(+0.0f, -1.0f, -1.0f, +0.0f),
-                pl.yyyy + vec4(+1.0f, +1.0f, -2.0f, -2.0f),
-                clamp(abs(dg[2]) * std, 0.0f, 1.0f)
-            ),
-            dg[0] + dg[1] + dg[2]
+        mediump float sum = dot(abs(dg[0]) + abs(dg[1]) + abs(dg[2]), vec4(1.0f));
+        mediump float sum_mean = 1.014185e+01f / max(sum, DEVIATION_FLOOR);
+        mediump float std = sum_mean * sum_mean;
+        mediump vec2 dir = edgeDirection(dg[0], dg[1]);
+        mediump vec4 w0 = weightY(
+            pl.xxxx + vec4(+1.0f, +0.0f, +0.0f, +1.0f),
+            pl.yyyy + vec4(-1.0f, -1.0f, +0.0f, +0.0f),
+            dg[0], std, dir
         );
-        // compute final y with bounds
-        vec2 yb = vec2(
-            min(min(dg[0].y, dg[0].z), min(dg[1].x, dg[1].w)), // min
-            max(max(dg[0].y, dg[0].z), max(dg[1].x, dg[1].w))  // max
+        mediump vec4 w1 = weightY(
+            pl.xxxx + vec4(-1.0f, -2.0f, -2.0f, -1.0f),
+            pl.yyyy + vec4(-1.0f, -1.0f, +0.0f, +0.0f),
+            dg[1], std, dir
         );
-        vec2 fvy = vec2(
-            w[0].x + w[0].y + w[0].z + w[0].w,
-            w[1].x + w[1].y + w[1].z + w[1].w
+        mediump vec4 w2 = weightY(
+            pl.xxxx + vec4(+0.0f, -1.0f, -1.0f, +0.0f),
+            pl.yyyy + vec4(+1.0f, +1.0f, -2.0f, -2.0f),
+            dg[2], std, dir
         );
-        float fy = clamp((fvy.y / fvy.x) * edge_sharpness, yb[0], yb[1]);
-        // Smooth high contrast input
-        float dy = clamp(fy - color.y + mean, -23.0f / 255.0f, 23.0f / 255.0f);
+        mediump float sum_w = dot(w0 + w1 + w2, vec4(1.0f));
+        mediump float sum_wc = dot(w0 * dg[0] + w1 * dg[1] + w2 * dg[2], vec4(1.0f));
+        mediump vec2 yb = vec2(
+            min(min(dg[0].y, dg[0].z), min(dg[1].x, dg[1].w)),
+            max(max(dg[0].y, dg[0].z), max(dg[1].x, dg[1].w))
+        );
+        mediump float fy = clamp((sum_wc / sum_w) * edge_sharpness, yb[0], yb[1]);
+        mediump float dy = clamp(fy - color.y + mean, -23.0f / 255.0f, 23.0f / 255.0f);
         color = clamp(color + dy, 0.0f, 1.0f);
     }
-    color.w = 1.0f;  //assume alpha channel is not used
+    color.w = 1.0f;
     frag_color.xyzw = color;
-}
+}

src/video_core/memory_manager.cpp

@@ -529,6 +529,29 @@ size_t MemoryManager::MaxContinuousRange(GPUVAddr gpu_addr, size_t size) const {
     return range_so_far;
 }
 
+size_t MemoryManager::MaxMappedRange(GPUVAddr gpu_addr, size_t size) const {
+    size_t range_so_far = 0;
+    bool stopped{false};
+    auto stop = [&]([[maybe_unused]] std::size_t page_index, [[maybe_unused]] std::size_t offset,
+                    [[maybe_unused]] std::size_t copy_amount) {
+        stopped = true;
+        return true;
+    };
+    auto accumulate = [&]([[maybe_unused]] std::size_t page_index,
+                          [[maybe_unused]] std::size_t offset, std::size_t copy_amount) {
+        range_so_far += copy_amount;
+        return false;
+    };
+    auto check_short_pages = [&](std::size_t page_index, std::size_t offset,
+                                 std::size_t copy_amount) {
+        GPUVAddr base = (page_index << big_page_bits) + offset;
+        MemoryOperation(base, copy_amount, false, accumulate, stop, stop);
+        return stopped;
+    };
+    MemoryOperation(gpu_addr, size, true, accumulate, stop, check_short_pages);
+    return range_so_far;
+}
+
 size_t MemoryManager::GetMemoryLayoutSize(GPUVAddr gpu_addr, size_t max_size) const {
     std::unique_lock<std::mutex> lock(guard);
     return kind_map.GetContinuousSizeFrom(gpu_addr);

src/video_core/memory_manager.h

@@ -141,6 +141,8 @@ public:
 
     size_t MaxContinuousRange(GPUVAddr gpu_addr, size_t size) const;
 
+    size_t MaxMappedRange(GPUVAddr gpu_addr, size_t size) const;
+
     bool IsWithinGPUAddressRange(GPUVAddr gpu_addr) const {
         return gpu_addr < address_space_size;
     }

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -262,6 +262,7 @@ struct BufferCacheParams {
 
     // TODO: Investigate why OpenGL seems to perform worse with persistently mapped buffer uploads
     static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = false;
+    static constexpr bool USE_UNIFIED_MEMORY = false;
 };
 
 using BufferCache = VideoCommon::BufferCache<BufferCacheParams>;

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -238,6 +238,7 @@ ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
           .has_gl_bool_ref_bug = device.HasBoolRefBug(),
           .ignore_nan_fp_comparisons = true,
           .gl_max_compute_smem_size = device.GetMaxComputeSharedMemorySize(),
+          .max_shared_memory_size = device.GetMaxComputeSharedMemorySize(),
           .min_ssbo_alignment = device.GetShaderStorageBufferAlignment(),
           // Use the host limit, but never more than the guest can produce. Maxwell exposes 8 clip
           // distances and the SPIR-V output array is sized for at most 8, so clamping here keeps a

src/video_core/renderer_opengl/gl_texture_cache.h

@@ -373,6 +373,7 @@ struct TextureCacheParams {
     static constexpr bool HAS_DEVICE_MEMORY_INFO = true;
     static constexpr bool IMPLEMENTS_ASYNC_DOWNLOADS = true;
     static constexpr bool HAS_MSAA_DOWNLOADS = false;
+    static constexpr bool USE_UNIFIED_MEMORY = false;
 
     using Runtime = OpenGL::TextureCacheRuntime;
     using Image = OpenGL::Image;

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -7,9 +7,12 @@
 #include <algorithm>
 #include <array>
 #include <cstring>
+#include <limits>
 #include <span>
+#include <utility>
 #include <vector>
 
+#include "common/alignment.h"
 #include "video_core/buffer_cache/buffer_cache_base.h"
 #include "video_core/renderer_vulkan/vk_buffer_cache.h"
 
@@ -32,6 +35,32 @@ VkBufferCopy MakeBufferCopy(const VideoCommon::BufferCopy& copy) {
     };
 }
 
+constexpr size_t MAX_WINDOW_BARRIER_RANGES = 8;
+
+using WindowRange = std::pair<VkDeviceSize, VkDeviceSize>;
+using WindowRanges = boost::container::small_vector<WindowRange, MAX_WINDOW_BARRIER_RANGES>;
+
+void CoalesceWindowRanges(WindowRanges& ranges) {
+    if (ranges.size() < 2) {
+        return;
+    }
+    std::sort(ranges.begin(), ranges.end());
+    size_t merged = 0;
+    for (size_t index = 1; index < ranges.size(); ++index) {
+        if (ranges[index].first <= ranges[merged].second) {
+            ranges[merged].second = (std::max)(ranges[merged].second, ranges[index].second);
+        } else {
+            ranges[++merged] = ranges[index];
+        }
+    }
+    ranges.resize(merged + 1);
+    if (ranges.size() > MAX_WINDOW_BARRIER_RANGES) {
+        const WindowRange bounding{ranges.front().first, ranges.back().second};
+        ranges.clear();
+        ranges.push_back(bounding);
+    }
+}
+
 VkIndexType IndexTypeFromNumElements(const Device& device, u32 num_elements) {
     if (num_elements <= 0xff && device.IsExtIndexTypeUint8Supported()) {
         return VK_INDEX_TYPE_UINT8_EXT;
@@ -42,6 +71,16 @@ VkIndexType IndexTypeFromNumElements(const Device& device, u32 num_elements) {
     return VK_INDEX_TYPE_UINT32;
 }
 
+u32 GrowIndexCount(u32 current, u32 requested) {
+    constexpr u32 MinimumIndices = 4096;
+    constexpr u32 GrowthLimit = (std::numeric_limits<u32>::max)() / 2;
+    u32 grown = (std::max)(requested, MinimumIndices);
+    if (current <= GrowthLimit) {
+        grown = (std::max)(grown, current * 2);
+    }
+    return grown;
+}
+
 size_t BytesPerIndex(VkIndexType index_type) {
     switch (index_type) {
     case VK_INDEX_TYPE_UINT8_EXT:
@@ -166,13 +205,12 @@ public:
     virtual ~QuadIndexBuffer() = default;
 
     void UpdateBuffer(u32 num_indices_) {
+        ReleaseRetiredBuffers();
         if (num_indices_ <= num_indices) {
             return;
         }
 
-        scheduler.Finish();
-
-        num_indices = num_indices_;
+        num_indices = GrowIndexCount(num_indices, num_indices_);
         index_type = IndexTypeFromNumElements(device, num_indices);
 
         const u32 num_quads = GetQuadsNum(num_indices);
@@ -190,6 +228,12 @@ public:
             .queueFamilyIndexCount = 0,
             .pQueueFamilyIndices = nullptr,
         };
+        if (buffer) {
+            retired_buffers.push_back(RetiredBuffer{
+                .buffer = std::move(buffer),
+                .tick = scheduler.CurrentTick(),
+            });
+        }
         buffer = memory_allocator.CreateBuffer(buffer_ci, MemoryUsage::DeviceLocal);
         if (device.HasDebuggingToolAttached()) {
             buffer.SetObjectNameEXT("Quad LUT");
@@ -257,6 +301,17 @@ protected:
 
     virtual void MakeAndUpdateIndices(u8* staging_data, size_t quad_size, u32 quad, u32 first) = 0;
 
+    struct RetiredBuffer {
+        vk::Buffer buffer;
+        u64 tick;
+    };
+
+    void ReleaseRetiredBuffers() {
+        std::erase_if(retired_buffers, [this](const RetiredBuffer& entry) {
+            return scheduler.IsFree(entry.tick);
+        });
+    }
+
     const Device& device;
     MemoryAllocator& memory_allocator;
     Scheduler& scheduler;
@@ -264,6 +319,7 @@ protected:
 
     vk::Buffer buffer{};
     MemoryCommit memory_commit{};
+    std::vector<RetiredBuffer> retired_buffers;
     VkIndexType index_type{};
     u32 num_indices = 0;
 };
@@ -374,6 +430,211 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_, MemoryAllocator& m
                                                                      scheduler_, staging_pool_);
 }
 
+void BufferCacheRuntime::TryEnableUnifiedMemory(void* base, size_t size,
+                                                std::span<AHardwareBuffer* const> hardware_buffers,
+                                                size_t hardware_buffer_window,
+                                                size_t hardware_buffer_base) {
+    unified_memory = memory_allocator.CreateHostMemoryImport(
+        base, size, hardware_buffers, hardware_buffer_window, hardware_buffer_base);
+    if (unified_memory) {
+        unified_memory->CreateMirror(scheduler.submit_mutex,
+                                     device.GetSparseAddressSpaceSize() / 2);
+        multi_range_buffers.ReserveSparseAddressSpace(unified_memory->GetMirrorSize());
+    }
+}
+
+void BufferCacheRuntime::CopyToUnifiedMemory(
+    size_t window_index, VkBuffer src_buffer,
+    std::span<const VideoCommon::BufferCopy> copies) {
+    if (!unified_memory || src_buffer == VK_NULL_HANDLE || copies.empty() ||
+        window_index >= unified_memory->GetWindowCount() ||
+        unified_memory->GetWindowBuffer(window_index) == VK_NULL_HANDLE) {
+        return;
+    }
+    PendingUnifiedCopy& pending = pending_unified_copies.emplace_back();
+    pending.window = window_index;
+    pending.buffer = src_buffer;
+    pending.copies.resize(copies.size());
+    std::ranges::transform(copies, pending.copies.begin(), MakeBufferCopy);
+}
+
+void BufferCacheRuntime::CopyFromUnifiedMemory(
+    size_t window_index, VkBuffer dst_buffer, std::span<const VideoCommon::BufferCopy> copies) {
+    if (!unified_memory || dst_buffer == VK_NULL_HANDLE || copies.empty() ||
+        window_index >= unified_memory->GetWindowCount()) {
+        return;
+    }
+    const VkBuffer window_buffer = unified_memory->GetWindowBuffer(window_index);
+    if (window_buffer == VK_NULL_HANDLE) {
+        return;
+    }
+    const bool foreign = unified_memory->NeedsForeignOwnershipTransfer();
+    const u32 queue_family = device.GetGraphicsFamily();
+    boost::container::small_vector<VkBufferCopy, 8> vk_copies;
+    WindowRanges ranges;
+    for (const VideoCommon::BufferCopy& copy : copies) {
+        vk_copies.push_back(VkBufferCopy{
+            .srcOffset = static_cast<VkDeviceSize>(copy.dst_offset),
+            .dstOffset = static_cast<VkDeviceSize>(copy.src_offset),
+            .size = static_cast<VkDeviceSize>(copy.size),
+        });
+        ranges.emplace_back(copy.dst_offset, copy.dst_offset + copy.size);
+    }
+    CoalesceWindowRanges(ranges);
+    boost::container::small_vector<VkBufferMemoryBarrier, MAX_WINDOW_BARRIER_RANGES> acquire;
+    boost::container::small_vector<VkBufferMemoryBarrier, MAX_WINDOW_BARRIER_RANGES> release;
+    if (foreign) {
+        for (const WindowRange& range : ranges) {
+            acquire.push_back(VkBufferMemoryBarrier{
+                .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = 0,
+                .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT,
+                .dstQueueFamilyIndex = queue_family,
+                .buffer = window_buffer,
+                .offset = range.first,
+                .size = range.second - range.first,
+            });
+            release.push_back(VkBufferMemoryBarrier{
+                .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
+                .dstAccessMask = 0,
+                .srcQueueFamilyIndex = queue_family,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT,
+                .buffer = window_buffer,
+                .offset = range.first,
+                .size = range.second - range.first,
+            });
+        }
+    }
+    scheduler.RequestOutsideRenderPassOperationContext();
+    scheduler.Record([window_buffer, dst_buffer, vk_copies, acquire = std::move(acquire),
+                      release = std::move(release)](vk::CommandBuffer cmdbuf) {
+        if (!acquire.empty()) {
+            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                                   VK_PIPELINE_STAGE_TRANSFER_BIT, 0, {},
+                                   VideoCommon::FixSmallVectorADL(acquire), {});
+        }
+        cmdbuf.CopyBuffer(window_buffer, dst_buffer, VideoCommon::FixSmallVectorADL(vk_copies));
+        if (!release.empty()) {
+            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
+                                   VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, {},
+                                   VideoCommon::FixSmallVectorADL(release), {});
+        }
+    });
+}
+
+void BufferCacheRuntime::FlushUnifiedMemoryCopies() {
+    if (pending_unified_copies.empty()) {
+        return;
+    }
+    struct UnifiedCopyCommand {
+        VkBuffer buffer;
+        boost::container::small_vector<VkBufferCopy, 8> copies;
+    };
+
+    std::stable_sort(pending_unified_copies.begin(), pending_unified_copies.end(),
+                     [](const PendingUnifiedCopy& lhs, const PendingUnifiedCopy& rhs) {
+                             return lhs.window < rhs.window;
+                     });
+
+    const bool foreign = unified_memory->NeedsForeignOwnershipTransfer();
+    const u32 queue_family = device.GetGraphicsFamily();
+
+    size_t group_begin = 0;
+    while (group_begin < pending_unified_copies.size()) {
+        const size_t window = pending_unified_copies[group_begin].window;
+        size_t group_end = group_begin;
+        while (group_end < pending_unified_copies.size() &&
+               pending_unified_copies[group_end].window == window) {
+            ++group_end;
+        }
+        const VkBuffer window_buffer = unified_memory->GetWindowBuffer(window);
+
+        WindowRanges ranges;
+        for (size_t index = group_begin; index < group_end; ++index) {
+            for (const VkBufferCopy& copy : pending_unified_copies[index].copies) {
+                ranges.emplace_back(copy.dstOffset, copy.dstOffset + copy.size);
+            }
+        }
+        CoalesceWindowRanges(ranges);
+
+        boost::container::small_vector<VkBufferMemoryBarrier, MAX_WINDOW_BARRIER_RANGES> acquire;
+        boost::container::small_vector<VkBufferMemoryBarrier, MAX_WINDOW_BARRIER_RANGES> release;
+        if (foreign) {
+            for (const WindowRange& range : ranges) {
+                acquire.push_back(VkBufferMemoryBarrier{
+                .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = 0,
+                    .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT,
+                .dstQueueFamilyIndex = queue_family,
+                    .buffer = window_buffer,
+                    .offset = range.first,
+                    .size = range.second - range.first,
+                });
+                release.push_back(VkBufferMemoryBarrier{
+                .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+                .pNext = nullptr,
+                    .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+                .dstAccessMask = 0,
+                .srcQueueFamilyIndex = queue_family,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT,
+                    .buffer = window_buffer,
+                    .offset = range.first,
+                    .size = range.second - range.first,
+                });
+            }
+        }
+
+        boost::container::small_vector<UnifiedCopyCommand, 4> commands;
+        commands.reserve(group_end - group_begin);
+        for (size_t index = group_begin; index < group_end; ++index) {
+            PendingUnifiedCopy& pending = pending_unified_copies[index];
+            commands.push_back(UnifiedCopyCommand{pending.buffer, std::move(pending.copies)});
+        }
+
+        scheduler.RequestOutsideRenderPassOperationContext();
+        scheduler.Record([window_buffer, acquire = std::move(acquire), release = std::move(release),
+                          commands = std::move(commands)](vk::CommandBuffer cmdbuf) {
+            if (!acquire.empty()) {
+                cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                                       VK_PIPELINE_STAGE_TRANSFER_BIT, 0, {},
+                                       VideoCommon::FixSmallVectorADL(acquire), {});
+            }
+            for (const UnifiedCopyCommand& command : commands) {
+                    cmdbuf.CopyBuffer(command.buffer, window_buffer,
+                                      VideoCommon::FixSmallVectorADL(command.copies));
+                }
+            if (!release.empty()) {
+                cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
+                                       VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, {},
+                                       VideoCommon::FixSmallVectorADL(release), {});
+        }
+    });
+
+        group_begin = group_end;
+    }
+    pending_unified_copies.clear();
+}
+
+void BufferCacheRuntime::UnifiedMemoryHostBarrier() {
+    static constexpr VkMemoryBarrier HOST_BARRIER{
+        .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
+        .pNext = nullptr,
+        .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+        .dstAccessMask = VK_ACCESS_HOST_READ_BIT,
+    };
+    scheduler.RequestOutsideRenderPassOperationContext();
+    scheduler.Record([](vk::CommandBuffer cmdbuf) {
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0,
+                               HOST_BARRIER);
+    });
+}
+
 StagingBufferRef BufferCacheRuntime::UploadStagingBuffer(size_t size) {
     return staging_pool.Request(size, MemoryUsage::Upload);
 }
@@ -411,6 +672,7 @@ u32 BufferCacheRuntime::GetStorageBufferAlignment() const {
 }
 
 void BufferCacheRuntime::TickFrame(Common::SlotVector<Buffer>& slot_buffers) noexcept {
+    FlushUnifiedMemoryCopies();
     for (auto it = slot_buffers.begin(); it != slot_buffers.end(); it++) {
         if (scheduler.IsFree(it->LastUsageTick())) {
             it->ResetUsageTracking();
@@ -545,17 +807,17 @@ void BufferCacheRuntime::ClearBuffer(VkBuffer dest_buffer, u32 offset, size_t si
     });
 }
 
-bool BufferCacheRuntime::BindMultiRangeStorageBuffer(u64 key, bool is_written) {
+MultiRangeRef BufferCacheRuntime::AcquireMultiRange(u64 key, bool require_sparse) {
     if (multi_range_sources.empty() || multi_range_total == 0) {
-        return false;
+        return MultiRangeRef{};
     }
     const MultiRangeRef ref = multi_range_buffers.Get(device, scheduler, memory_allocator, key,
                                                      multi_range_sources, multi_range_total);
     if (ref.handle == VK_NULL_HANDLE) {
-        return false;
+        return MultiRangeRef{};
     }
-    if (is_written && !ref.sparse) {
-        return false;
+    if (require_sparse && !ref.sparse) {
+        return MultiRangeRef{};
     }
     if (ref.needs_gather) {
         PreCopyBarrier();
@@ -572,10 +834,220 @@ bool BufferCacheRuntime::BindMultiRangeStorageBuffer(u64 key, bool is_written) {
         PostCopyBarrier();
         multi_range_buffers.MarkGathered(key);
     }
+    return ref;
+}
+
+bool BufferCacheRuntime::BindMultiRangeStorageBuffer(u64 key, bool is_written) {
+    const MultiRangeRef ref = AcquireMultiRange(key, is_written);
+    if (ref.handle == VK_NULL_HANDLE) {
+        return false;
+    }
     guest_descriptor_queue.AddBuffer(ref.handle, ref.address, 0, ref.size);
     return true;
 }
 
+std::optional<HostMemoryImport::Range> BufferCacheRuntime::ResolveUnifiedExtents(
+    u64 key, std::span<const VideoCommon::UnifiedExtent> extents, u32 size) {
+    if (extents.size() == 1) {
+        return unified_memory->ResolveRange(extents.front().relative, size);
+    }
+    return AcquireUnifiedView(key, extents);
+}
+
+std::optional<HostMemoryImport::Range> BufferCacheRuntime::AcquireUnifiedView(
+    u64 key, std::span<const VideoCommon::UnifiedExtent> extents) {
+    const VkBufferUsageFlags usage = unified_memory->GetViewUsage();
+    if (usage == 0 || !multi_range_buffers.use_sparse || extents.size() < 2) {
+        return std::nullopt;
+    }
+    const VkDeviceSize block = multi_range_buffers.block_size;
+    boost::container::small_vector<MultiRangeSource, 16> sources;
+    VkDeviceSize total = 0;
+    VkDeviceSize padding = 0;
+    for (size_t index = 0; index < extents.size(); ++index) {
+        VkDeviceSize begin = extents[index].relative;
+        VkDeviceSize end = begin + extents[index].size;
+        if (index == 0) {
+            padding = begin % block;
+            begin -= padding;
+        } else if ((begin % block) != 0) {
+            return std::nullopt;
+        }
+        if (index + 1 == extents.size()) {
+            end = Common::AlignUp(end, block);
+        } else if ((end % block) != 0) {
+            return std::nullopt;
+        }
+        while (begin < end) {
+            const auto memory = unified_memory->ResolveViewMemory(begin);
+            if (!memory || (memory->offset % block) != 0) {
+                return std::nullopt;
+            }
+            const VkDeviceSize length = (std::min)(end - begin, memory->available);
+            if ((length % block) != 0) {
+                return std::nullopt;
+            }
+            sources.push_back(MultiRangeSource{
+                .handle = memory->buffer,
+                .memory = memory->memory,
+                .memory_offset = 0,
+                .offset = memory->offset,
+                .size = length,
+                .write_tick = 0,
+                .memory_type = memory->memory_type,
+            });
+            total += length;
+            begin += length;
+        }
+    }
+    const MultiRangeRef ref = multi_range_buffers.GetView(
+        device, scheduler, key, sources, total, usage,
+        VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID);
+    if (ref.handle == VK_NULL_HANDLE) {
+        return std::nullopt;
+    }
+    return HostMemoryImport::Range{
+        .buffer = ref.handle,
+        .address = ref.address,
+        .offset = padding,
+    };
+}
+
+bool BufferCacheRuntime::StageUnifiedVertexBuffer(
+    u32 index, u64 key, std::span<const VideoCommon::UnifiedExtent> extents, u32 size, u32 stride,
+    bool force) {
+    if (!unified_memory ||
+        (unified_memory->GetUsage() & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT) == 0) {
+        return false;
+    }
+    const auto range = ResolveUnifiedExtents(key, extents, size);
+    if (!range) {
+        return false;
+    }
+    StageVertexBuffer(
+        StagedVertexBuffer{
+            .index = index,
+            .buffer = range->buffer,
+            .offset = range->offset,
+            .size = size,
+            .stride = stride,
+        },
+        force);
+    return true;
+}
+
+bool BufferCacheRuntime::StageMultiRangeVertexBuffer(u32 index, u64 key, u32 size, u32 stride,
+                                                     bool force) {
+    const MultiRangeRef ref = AcquireMultiRange(key, false);
+    if (ref.handle == VK_NULL_HANDLE) {
+        return false;
+    }
+    StageVertexBuffer(
+        StagedVertexBuffer{
+            .index = index,
+            .buffer = ref.handle,
+            .offset = 0,
+            .size = size,
+            .stride = stride,
+        },
+        force);
+    return true;
+}
+
+void BufferCacheRuntime::StageVertexBuffer(const StagedVertexBuffer& target, bool force) {
+    StagedVertexBuffer& bound = bound_vertex_buffers[target.index];
+    if (!force && bound == target) {
+        return;
+    }
+    bound = target;
+    if (target.index < device.GetMaxVertexInputBindings()) {
+        staged_vertex_buffers.push_back(target);
+    }
+}
+
+void BufferCacheRuntime::BindStagedVertexBuffers() {
+    if (staged_vertex_buffers.empty()) {
+        return;
+    }
+    scheduler.Record([staged = staged_vertex_buffers,
+                      extended = device.IsExtExtendedDynamicStateSupported()](
+                         vk::CommandBuffer cmdbuf) {
+        std::array<VkBuffer, VideoCommon::NUM_VERTEX_BUFFERS> buffers{};
+        std::array<VkDeviceSize, VideoCommon::NUM_VERTEX_BUFFERS> offsets{};
+        std::array<VkDeviceSize, VideoCommon::NUM_VERTEX_BUFFERS> sizes{};
+        std::array<VkDeviceSize, VideoCommon::NUM_VERTEX_BUFFERS> strides{};
+        size_t begin = 0;
+        while (begin < staged.size()) {
+            const u32 first = staged[begin].index;
+            u32 count = 0;
+            while (begin + count < staged.size() && staged[begin + count].index == first + count) {
+                const StagedVertexBuffer& entry = staged[begin + count];
+                buffers[count] = entry.buffer;
+                offsets[count] = entry.offset;
+                sizes[count] = entry.size;
+                strides[count] = entry.stride;
+                ++count;
+            }
+            if (extended) {
+                cmdbuf.BindVertexBuffers2EXT(first, count, buffers.data(), offsets.data(),
+                                             sizes.data(), strides.data());
+            } else {
+                cmdbuf.BindVertexBuffers(first, count, buffers.data(), offsets.data());
+            }
+            begin += count;
+        }
+    });
+    staged_vertex_buffers.clear();
+}
+
+bool BufferCacheRuntime::IsIndexRangeUsable(PrimitiveTopology topology, IndexFormat index_format,
+                                            VkDeviceSize offset, u32 size) const {
+    const VkIndexType vk_index_type = MaxwellToVK::IndexFormat(index_format);
+    const bool is_quad =
+        topology == PrimitiveTopology::Quads || topology == PrimitiveTopology::QuadStrip;
+    const bool is_emulated_uint8 =
+        vk_index_type == VK_INDEX_TYPE_UINT8_EXT && !device.IsExtIndexTypeUint8Supported();
+    if (is_quad || is_emulated_uint8) {
+        return size <= device.GetMaxStorageBufferRange() &&
+               (offset % device.GetStorageBufferAlignment()) == 0;
+    }
+    return (offset % BytesPerIndex(vk_index_type)) == 0;
+}
+
+bool BufferCacheRuntime::BindUnifiedIndexBuffer(PrimitiveTopology topology,
+                                                IndexFormat index_format, u32 base_vertex,
+                                                u32 num_indices, u64 key,
+                                                std::span<const VideoCommon::UnifiedExtent> extents,
+                                                u32 size) {
+    constexpr VkBufferUsageFlags GeometryUsage =
+        VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+    if (!unified_memory || (unified_memory->GetUsage() & GeometryUsage) != GeometryUsage) {
+        return false;
+    }
+    const auto range = ResolveUnifiedExtents(key, extents, size);
+    if (!range || range->offset > (std::numeric_limits<u32>::max)() - size ||
+        !IsIndexRangeUsable(topology, index_format, range->offset, size)) {
+        return false;
+    }
+    BindIndexBuffer(topology, index_format, base_vertex, num_indices, range->buffer,
+                    static_cast<u32>(range->offset), size);
+    return true;
+}
+
+bool BufferCacheRuntime::BindMultiRangeIndexBuffer(PrimitiveTopology topology,
+                                                   IndexFormat index_format, u32 base_vertex,
+                                                   u32 num_indices, u64 key, u32 size) {
+    if (!IsIndexRangeUsable(topology, index_format, 0, size)) {
+        return false;
+    }
+    const MultiRangeRef ref = AcquireMultiRange(key, false);
+    if (ref.handle == VK_NULL_HANDLE) {
+        return false;
+    }
+    BindIndexBuffer(topology, index_format, base_vertex, num_indices, ref.handle, 0, size);
+    return true;
+}
+
 void BufferCacheRuntime::BindIndexBuffer(PrimitiveTopology topology, IndexFormat index_format,
                                          u32 base_vertex, u32 num_indices, VkBuffer buffer,
                                          u32 offset, [[maybe_unused]] u32 size) {

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -7,6 +7,8 @@
 #pragma once
 
 #include <limits>
+#include <memory>
+#include <span>
 
 #include <boost/container/small_vector.hpp>
 
@@ -110,6 +112,36 @@ public:
 
     void TickFrame(Common::SlotVector<Buffer>& slot_buffers) noexcept;
 
+    void TryEnableUnifiedMemory(void* base, size_t size,
+                                std::span<AHardwareBuffer* const> hardware_buffers,
+                                size_t hardware_buffer_window, size_t hardware_buffer_base);
+
+    [[nodiscard]] bool HasUnifiedMemory() const noexcept {
+        return unified_memory != nullptr && unified_memory->IsValid();
+    }
+
+    [[nodiscard]] u64 UnifiedMemorySize() const noexcept {
+        return unified_memory ? unified_memory->GetSize() : 0;
+    }
+
+    [[nodiscard]] u64 UnifiedMemoryBase() const noexcept {
+        return unified_memory ? unified_memory->GetBaseOffset() : 0;
+    }
+
+    [[nodiscard]] u64 UnifiedMemoryWindowSize() const noexcept {
+        return unified_memory ? unified_memory->GetWindowSize() : 0;
+    }
+
+    void CopyToUnifiedMemory(size_t window_index, VkBuffer src_buffer,
+                             std::span<const VideoCommon::BufferCopy> copies);
+
+    void CopyFromUnifiedMemory(size_t window_index, VkBuffer dst_buffer,
+                               std::span<const VideoCommon::BufferCopy> copies);
+
+    void FlushUnifiedMemoryCopies();
+
+    void UnifiedMemoryHostBarrier();
+
     u64 CurrentTick();
 
     u64 KnownGpuTick();
@@ -200,6 +232,21 @@ public:
 
     bool BindMultiRangeStorageBuffer(u64 key, bool is_written);
 
+    bool StageUnifiedVertexBuffer(u32 index, u64 key,
+                                  std::span<const VideoCommon::UnifiedExtent> extents, u32 size,
+                                  u32 stride, bool force);
+
+    bool StageMultiRangeVertexBuffer(u32 index, u64 key, u32 size, u32 stride, bool force);
+
+    void BindStagedVertexBuffers();
+
+    bool BindUnifiedIndexBuffer(PrimitiveTopology topology, IndexFormat index_format,
+                                u32 base_vertex, u32 num_indices, u64 key,
+                                std::span<const VideoCommon::UnifiedExtent> extents, u32 size);
+
+    bool BindMultiRangeIndexBuffer(PrimitiveTopology topology, IndexFormat index_format,
+                                   u32 base_vertex, u32 num_indices, u64 key, u32 size);
+
     void InvalidateMultiRange(u64 key) {
         multi_range_buffers.Invalidate(key);
     }
@@ -217,6 +264,28 @@ public:
         BindBuffer(buffer, offset, size);
     }
 
+    void BindStorageBuffer(VkBuffer buffer, VkDeviceAddress address, VkDeviceSize offset, u32 size,
+                           [[maybe_unused]] bool is_written) {
+        guest_descriptor_queue.AddBuffer(buffer, address, offset, size);
+    }
+
+    [[nodiscard]] bool IsUnifiedMemoryBindable() const noexcept {
+        return unified_memory != nullptr && unified_memory->IsValid() &&
+               unified_memory->IsBindable();
+    }
+
+    [[nodiscard]] std::optional<HostMemoryImport::Range> ResolveUnifiedStorage(u64 relative,
+                                                                             u32 size) const {
+        if (size > device.GetMaxStorageBufferRange()) {
+            return std::nullopt;
+        }
+        const auto range = unified_memory->ResolveRange(relative, size);
+        if (!range || (range->offset % device.GetStorageBufferAlignment()) != 0) {
+            return std::nullopt;
+        }
+        return range;
+    }
+
     void BindTextureBuffer(Buffer& buffer, u32 offset, u32 size,
                            VideoCore::Surface::PixelFormat format) {
         guest_descriptor_queue.AddTexelBuffer(buffer.View(offset, size, format),
@@ -233,6 +302,35 @@ public:
     }
 
 private:
+    struct PendingUnifiedCopy {
+        size_t window;
+        VkBuffer buffer;
+        boost::container::small_vector<VkBufferCopy, 8> copies;
+    };
+
+    struct StagedVertexBuffer {
+        u32 index;
+        VkBuffer buffer;
+        VkDeviceSize offset;
+        u32 size;
+        u32 stride;
+
+        bool operator==(const StagedVertexBuffer&) const = default;
+    };
+
+    [[nodiscard]] MultiRangeRef AcquireMultiRange(u64 key, bool require_sparse);
+
+    [[nodiscard]] std::optional<HostMemoryImport::Range> ResolveUnifiedExtents(
+        u64 key, std::span<const VideoCommon::UnifiedExtent> extents, u32 size);
+
+    [[nodiscard]] std::optional<HostMemoryImport::Range> AcquireUnifiedView(
+        u64 key, std::span<const VideoCommon::UnifiedExtent> extents);
+
+    void StageVertexBuffer(const StagedVertexBuffer& target, bool force);
+
+    [[nodiscard]] bool IsIndexRangeUsable(PrimitiveTopology topology, IndexFormat index_format,
+                                          VkDeviceSize offset, u32 size) const;
+
     void BindBuffer(const Buffer& buffer, u32 offset, u32 size) {
         const VkBuffer handle = buffer.Handle();
         if (handle == VK_NULL_HANDLE) {
@@ -257,6 +355,8 @@ private:
     std::shared_ptr<QuadStripIndexBuffer> quad_strip_index_buffer;
 
     vk::Buffer null_buffer;
+    HostMemoryImport* unified_memory{};
+    boost::container::small_vector<PendingUnifiedCopy, 8> pending_unified_copies;
 
     std::unique_ptr<Uint8Pass> uint8_pass;
     QuadIndexedPass quad_index_pass;
@@ -264,6 +364,9 @@ private:
     MultiRangeBufferCache multi_range_buffers;
     boost::container::small_vector<MultiRangeSource, 16> multi_range_sources;
     VkDeviceSize multi_range_total{};
+    boost::container::static_vector<StagedVertexBuffer, VideoCommon::NUM_VERTEX_BUFFERS>
+        staged_vertex_buffers;
+    std::array<StagedVertexBuffer, VideoCommon::NUM_VERTEX_BUFFERS> bound_vertex_buffers{};
 
     bool limit_dynamic_storage_buffers = false;
     u32 max_dynamic_storage_buffers = (std::numeric_limits<u32>::max)();
@@ -283,6 +386,7 @@ struct BufferCacheParams {
     static constexpr bool USE_MEMORY_MAPS = true;
     static constexpr bool SEPARATE_IMAGE_BUFFER_BINDINGS = false;
     static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = true;
+    static constexpr bool USE_UNIFIED_MEMORY = true;
 };
 
 using BufferCache = VideoCommon::BufferCache<BufferCacheParams>;

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -4,6 +4,7 @@
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <algorithm>
 #include <array>
 #include <memory>
 #include <numeric>
@@ -12,6 +13,7 @@
 
 #include "video_core/renderer_vulkan/vk_texture_cache.h"
 
+#include "common/alignment.h"
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/div_ceil.h"
@@ -22,7 +24,10 @@
 #include "video_core/host_shaders/resolve_conditional_render_comp_spv.h"
 #include "video_core/host_shaders/vulkan_quad_indexed_comp_spv.h"
 #include "video_core/host_shaders/vulkan_uint8_comp_spv.h"
+#include "video_core/host_shaders/block_linear_swizzle_2d_buffer_comp_spv.h"
+#include "video_core/host_shaders/block_linear_unswizzle_2d_buffer_comp_spv.h"
 #include "video_core/host_shaders/block_linear_unswizzle_3d_bcn_comp_spv.h"
+#include "video_core/host_shaders/block_linear_unswizzle_3d_buffer_comp_spv.h"
 #include "video_core/renderer_vulkan/vk_compute_pass.h"
 #include "video_core/surface.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
@@ -31,6 +36,7 @@
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
 #include "video_core/texture_cache/accelerated_swizzle.h"
 #include "video_core/texture_cache/types.h"
+#include "video_core/texture_cache/util.h"
 #include "video_core/textures/decoders.h"
 #include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
@@ -872,4 +878,672 @@ void BlockLinearUnswizzle3DPass::UnswizzleChunk(
     });
 }
 
+namespace {
+constexpr u32 BL2D_BINDING_INPUT_BUFFER = 0;
+constexpr u32 BL2D_BINDING_OUTPUT_BUFFER = 1;
+
+struct alignas(16) BlockLinearUnswizzle2DPushConstants {
+    std::array<u32, 3> dim;
+    u32 bytes_per_block_log2;
+    std::array<u32, 3> origin;
+    u32 layer_stride;
+    u32 block_size;
+    u32 x_shift;
+    u32 block_height;
+    u32 block_height_mask;
+};
+static_assert(sizeof(BlockLinearUnswizzle2DPushConstants) <= 128);
+
+constexpr std::array<VkDescriptorSetLayoutBinding, 2> BL2D_BINDINGS{{
+    {
+        .binding = BL2D_BINDING_INPUT_BUFFER,
+        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+        .descriptorCount = 1,
+        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
+        .pImmutableSamplers = nullptr,
+    },
+    {
+        .binding = BL2D_BINDING_OUTPUT_BUFFER,
+        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+        .descriptorCount = 1,
+        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
+        .pImmutableSamplers = nullptr,
+    },
+}};
+
+constexpr std::array<VkDescriptorUpdateTemplateEntry, 2> BL2D_TEMPLATE{{
+    {
+        .dstBinding = BL2D_BINDING_INPUT_BUFFER,
+        .dstArrayElement = 0,
+        .descriptorCount = 1,
+        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+        .offset = BL2D_BINDING_INPUT_BUFFER * sizeof(DescriptorUpdateEntry),
+        .stride = sizeof(DescriptorUpdateEntry),
+    },
+    {
+        .dstBinding = BL2D_BINDING_OUTPUT_BUFFER,
+        .dstArrayElement = 0,
+        .descriptorCount = 1,
+        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+        .offset = BL2D_BINDING_OUTPUT_BUFFER * sizeof(DescriptorUpdateEntry),
+        .stride = sizeof(DescriptorUpdateEntry),
+    },
+}};
+
+constexpr DescriptorBankInfo BL2D_BANK_INFO{
+    .uniform_buffers = 0,
+    .storage_buffers = 2,
+    .texture_buffers = 0,
+    .image_buffers = 0,
+    .textures = 0,
+    .images = 0,
+    .score = 2,
+};
+} // Anonymous namespace
+
+BlockLinearUnswizzle2DPass::BlockLinearUnswizzle2DPass(
+    const Device& device_, Scheduler& scheduler_, DescriptorPool& descriptor_pool_,
+    StagingBufferPool& staging_buffer_pool_,
+    ComputePassDescriptorQueue& compute_pass_descriptor_queue_)
+    : ComputePass(device_, scheduler_, descriptor_pool_, BL2D_BINDINGS, BL2D_TEMPLATE,
+                  BL2D_BANK_INFO,
+                  COMPUTE_PUSH_CONSTANT_RANGE<sizeof(BlockLinearUnswizzle2DPushConstants)>,
+                  BLOCK_LINEAR_UNSWIZZLE_2D_BUFFER_COMP_SPV),
+      scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
+      compute_pass_descriptor_queue{compute_pass_descriptor_queue_} {}
+
+BlockLinearUnswizzle2DPass::~BlockLinearUnswizzle2DPass() = default;
+
+bool BlockLinearUnswizzle2DPass::IsSupported(const Device& device,
+                                             const VideoCommon::ImageInfo& info) {
+    if (info.type != VideoCommon::ImageType::e2D) {
+        return false;
+    }
+    if (info.num_samples > 1) {
+        return false;
+    }
+    if (device.GetStorageBufferAlignment() > Tegra::Texture::GOB_SIZE) {
+        return false;
+    }
+    if (VideoCore::Surface::GetFormatType(info.format) !=
+        VideoCore::Surface::SurfaceType::ColorTexture) {
+        return false;
+    }
+    if (VideoCore::Surface::IsPixelFormatASTC(info.format) && !device.IsOptimalAstcSupported()) {
+        return false;
+    }
+    if (VideoCore::Surface::IsPixelFormatBCn(info.format) && !device.IsOptimalBcnSupported()) {
+        return false;
+    }
+    const u32 bytes_per_block = VideoCore::Surface::BytesPerBlock(info.format);
+    return bytes_per_block == 4 || bytes_per_block == 8 || bytes_per_block == 16;
+}
+
+void BlockLinearUnswizzle2DPass::Unswizzle(
+    Image& image, const StagingBufferRef& swizzled,
+    std::span<const VideoCommon::SwizzleParameters> swizzles) {
+    UnswizzleFrom(image, swizzled.buffer, swizzled.offset, swizzles);
+}
+
+void BlockLinearUnswizzle2DPass::UnswizzleFrom(
+    Image& image, VkBuffer source_buffer, VkDeviceSize source_offset,
+    std::span<const VideoCommon::SwizzleParameters> swizzles) {
+    const VkImage dst_image = image.Handle();
+    if (swizzles.empty() || source_buffer == VK_NULL_HANDLE || dst_image == VK_NULL_HANDLE) {
+        return;
+    }
+    const u32 layers = image.info.resources.layers;
+    const VkImageAspectFlags aspect = image.AspectMask();
+
+    const VkDeviceSize output_alignment =
+        (std::max)(device.GetStorageBufferAlignment(), VkDeviceSize{16});
+    VkDeviceSize total_output = 0;
+    for (const VideoCommon::SwizzleParameters& sw : swizzles) {
+        const auto params =
+            VideoCommon::Accelerated::MakeBlockLinearSwizzle2DParams(sw, image.info);
+        const VkDeviceSize level_size = static_cast<VkDeviceSize>(sw.num_tiles.width) *
+                                        sw.num_tiles.height * layers *
+                                        (1ULL << params.bytes_per_block_log2);
+        if (level_size == 0) {
+            continue;
+        }
+        total_output = Common::AlignUp(total_output, output_alignment) + level_size;
+    }
+    if (total_output == 0) {
+        return;
+    }
+    const StagingBufferRef output =
+        staging_buffer_pool.Request(static_cast<size_t>(total_output), MemoryUsage::DeviceLocal);
+    const VkBuffer out_buffer = output.buffer;
+    if (out_buffer == VK_NULL_HANDLE) {
+        return;
+    }
+    VkDeviceSize level_offset = 0;
+
+    scheduler.RequestOutsideRenderPassOperationContext();
+
+    VkAccessFlags pre_access = VK_ACCESS_NONE;
+    VkImageLayout pre_layout = VK_IMAGE_LAYOUT_UNDEFINED;
+    VkPipelineStageFlags pre_stage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+    if (image.ExchangeInitialization()) {
+        pre_access = VK_ACCESS_SHADER_READ_BIT;
+        pre_layout = VK_IMAGE_LAYOUT_GENERAL;
+        pre_stage = vk::PIPELINE_STAGE_GRAPHICS_COMPUTE;
+        }
+    scheduler.Record([dst_image, aspect, pre_access, pre_layout,
+                      pre_stage](vk::CommandBuffer cmdbuf) {
+        const VkImageMemoryBarrier barrier{
+            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+            .pNext = nullptr,
+            .srcAccessMask = pre_access,
+            .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+            .oldLayout = pre_layout,
+            .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .image = dst_image,
+            .subresourceRange{
+                .aspectMask = aspect,
+                .baseMipLevel = 0,
+                .levelCount = VK_REMAINING_MIP_LEVELS,
+                .baseArrayLayer = 0,
+                .layerCount = VK_REMAINING_ARRAY_LAYERS,
+            },
+        };
+        cmdbuf.PipelineBarrier(pre_stage, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, {}, {}, barrier);
+    });
+
+    for (const VideoCommon::SwizzleParameters& sw : swizzles) {
+        const auto params =
+            VideoCommon::Accelerated::MakeBlockLinearSwizzle2DParams(sw, image.info);
+        const u32 width = sw.num_tiles.width;
+        const u32 height = sw.num_tiles.height;
+        const u32 bytes_per_block = 1u << params.bytes_per_block_log2;
+        const VkDeviceSize output_size =
+            static_cast<VkDeviceSize>(width) * height * layers * bytes_per_block;
+        if (output_size == 0) {
+            continue;
+        }
+        const u32 level = static_cast<u32>(sw.level);
+        const u32 texel_width = (std::max)(1u, image.info.size.width >> level);
+        const u32 texel_height = (std::max)(1u, image.info.size.height >> level);
+
+        level_offset = Common::AlignUp(level_offset, output_alignment);
+        const VkDeviceSize out_offset = output.offset + level_offset;
+        level_offset += output_size;
+
+        BlockLinearUnswizzle2DPushConstants pc{};
+        pc.dim = {width, height, layers};
+        pc.bytes_per_block_log2 = params.bytes_per_block_log2;
+        pc.origin = params.origin;
+        pc.layer_stride = params.layer_stride;
+        pc.block_size = params.block_size;
+        pc.x_shift = params.x_shift;
+        pc.block_height = params.block_height;
+        pc.block_height_mask = params.block_height_mask;
+
+        compute_pass_descriptor_queue.Acquire(scheduler, 2);
+        compute_pass_descriptor_queue.AddBuffer(source_buffer, sw.buffer_offset + source_offset,
+                                                image.guest_size_bytes - sw.buffer_offset);
+        compute_pass_descriptor_queue.AddBuffer(out_buffer, out_offset, output_size);
+
+        const void* descriptor_data = compute_pass_descriptor_queue.UpdateData();
+        const VkDescriptorSet set = descriptor_allocator.Commit();
+
+        const u32 gx = Common::DivCeil(width, 16u);
+        const u32 gy = Common::DivCeil(height, 8u);
+
+        scheduler.Record([this, set, descriptor_data, pc, gx, gy, layers, output_size, out_buffer,
+                          out_offset, dst_image, aspect, texel_width, texel_height,
+                          level](vk::CommandBuffer cmdbuf) {
+            device.GetLogical().UpdateDescriptorSet(set, *descriptor_template, descriptor_data);
+            cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
+            cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});
+            cmdbuf.PushConstants(*layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(pc), &pc);
+            cmdbuf.Dispatch(gx, gy, layers);
+
+            const VkBufferMemoryBarrier buffer_barrier{
+                .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
+                .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .buffer = out_buffer,
+                .offset = out_offset,
+                .size = output_size,
+            };
+            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+                                   VK_PIPELINE_STAGE_TRANSFER_BIT, 0, {}, buffer_barrier, {});
+
+        const VkBufferImageCopy copy{
+            .bufferOffset = out_offset,
+            .bufferRowLength = 0,
+            .bufferImageHeight = 0,
+            .imageSubresource{
+                .aspectMask = aspect,
+                    .mipLevel = level,
+                .baseArrayLayer = 0,
+                    .layerCount = layers,
+            },
+            .imageOffset = {0, 0, 0},
+            .imageExtent = {texel_width, texel_height, 1},
+        };
+            cmdbuf.CopyBufferToImage(out_buffer, dst_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                                     copy);
+        });
+    }
+
+    scheduler.Record([dst_image, aspect](vk::CommandBuffer cmdbuf) {
+        const VkImageMemoryBarrier barrier{
+            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+            .pNext = nullptr,
+            .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+            .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
+            .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+            .newLayout = VK_IMAGE_LAYOUT_GENERAL,
+            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .image = dst_image,
+            .subresourceRange{
+                .aspectMask = aspect,
+                .baseMipLevel = 0,
+                .levelCount = VK_REMAINING_MIP_LEVELS,
+                .baseArrayLayer = 0,
+                .layerCount = VK_REMAINING_ARRAY_LAYERS,
+            },
+        };
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
+                               vk::PIPELINE_STAGE_GRAPHICS_COMPUTE, 0, {}, {}, barrier);
+    });
+}
+
+BlockLinearSwizzle2DPass::BlockLinearSwizzle2DPass(
+    const Device& device_, Scheduler& scheduler_, DescriptorPool& descriptor_pool_,
+    StagingBufferPool& staging_buffer_pool_,
+    ComputePassDescriptorQueue& compute_pass_descriptor_queue_)
+    : ComputePass(device_, scheduler_, descriptor_pool_, BL2D_BINDINGS, BL2D_TEMPLATE,
+                  BL2D_BANK_INFO,
+                  COMPUTE_PUSH_CONSTANT_RANGE<sizeof(BlockLinearUnswizzle2DPushConstants)>,
+                  BLOCK_LINEAR_SWIZZLE_2D_BUFFER_COMP_SPV),
+      scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
+      compute_pass_descriptor_queue{compute_pass_descriptor_queue_} {}
+
+BlockLinearSwizzle2DPass::~BlockLinearSwizzle2DPass() = default;
+
+void BlockLinearSwizzle2DPass::SwizzleInto(Image& image, VkBuffer dst_buffer,
+                                           VkDeviceSize dst_offset, bool foreign_ownership) {
+    const u32 layers = image.info.resources.layers;
+    const VkDeviceSize guest_size = image.guest_size_bytes;
+    const VkDeviceSize input_alignment =
+        (std::max)(device.GetStorageBufferAlignment(), VkDeviceSize{16});
+    auto copies = VideoCommon::FullDownloadCopies(image.info);
+    const auto swizzles = VideoCommon::FullUploadSwizzles(image.info);
+    VkDeviceSize total_size = 0;
+    for (VideoCommon::BufferImageCopy& copy : copies) {
+        total_size = Common::AlignUp(total_size, input_alignment);
+        copy.buffer_offset = static_cast<size_t>(total_size);
+        total_size += copy.buffer_size;
+    }
+    const StagingBufferRef scratch =
+        staging_buffer_pool.Request(static_cast<size_t>(total_size), MemoryUsage::DeviceLocal);
+    const VkBuffer scratch_buffer = scratch.buffer;
+    const VkDeviceSize scratch_offset = scratch.offset;
+    image.DownloadMemory(scratch_buffer, static_cast<size_t>(scratch_offset),
+                         std::span<const VideoCommon::BufferImageCopy>(copies.data(),
+                                                                       copies.size()));
+
+    const u32 queue_family = device.GetGraphicsFamily();
+    scheduler.RequestOutsideRenderPassOperationContext();
+    scheduler.Record([scratch_buffer, scratch_offset, total_size, dst_buffer, dst_offset,
+                      guest_size, queue_family, foreign_ownership](vk::CommandBuffer cmdbuf) {
+        const VkBufferMemoryBarrier scratch_barrier{
+            .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+            .pNext = nullptr,
+            .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+            .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
+            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .buffer = scratch_buffer,
+            .offset = scratch_offset,
+            .size = total_size,
+        };
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
+                               VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, scratch_barrier);
+        if (foreign_ownership) {
+            const VkBufferMemoryBarrier acquire{
+                .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = 0,
+                .dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT,
+                .dstQueueFamilyIndex = queue_family,
+                .buffer = dst_buffer,
+                .offset = dst_offset,
+                .size = guest_size,
+            };
+            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                                   VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, acquire);
+        }
+    });
+
+    for (size_t level = 0; level < copies.size(); ++level) {
+        const VideoCommon::SwizzleParameters& sw = swizzles[level];
+        const VideoCommon::BufferImageCopy& copy = copies[level];
+        const auto params =
+            VideoCommon::Accelerated::MakeBlockLinearSwizzle2DParams(sw, image.info);
+
+        BlockLinearUnswizzle2DPushConstants pc{};
+        pc.dim = {sw.num_tiles.width, sw.num_tiles.height, layers};
+        pc.bytes_per_block_log2 = params.bytes_per_block_log2;
+        pc.origin = params.origin;
+        pc.layer_stride = params.layer_stride;
+        pc.block_size = params.block_size;
+        pc.x_shift = params.x_shift;
+        pc.block_height = params.block_height;
+        pc.block_height_mask = params.block_height_mask;
+
+        compute_pass_descriptor_queue.Acquire(scheduler, 2);
+        compute_pass_descriptor_queue.AddBuffer(scratch_buffer, scratch_offset + copy.buffer_offset,
+                                                copy.buffer_size);
+        compute_pass_descriptor_queue.AddBuffer(dst_buffer, dst_offset + sw.buffer_offset,
+                                                guest_size - sw.buffer_offset);
+        const void* descriptor_data = compute_pass_descriptor_queue.UpdateData();
+        const VkDescriptorSet set = descriptor_allocator.Commit();
+
+        const u32 gx = Common::DivCeil(sw.num_tiles.width, 16u);
+        const u32 gy = Common::DivCeil(sw.num_tiles.height, 8u);
+
+        scheduler.Record(
+            [this, set, descriptor_data, pc, gx, gy, layers](vk::CommandBuffer cmdbuf) {
+                device.GetLogical().UpdateDescriptorSet(set, *descriptor_template,
+                                                        descriptor_data);
+                cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
+                cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});
+                cmdbuf.PushConstants(*layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(pc), &pc);
+                cmdbuf.Dispatch(gx, gy, layers);
+            });
+    }
+
+    scheduler.Record([dst_buffer, dst_offset, guest_size, queue_family,
+                      foreign_ownership](vk::CommandBuffer cmdbuf) {
+        if (foreign_ownership) {
+            const VkBufferMemoryBarrier release{
+                .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
+                .dstAccessMask = 0,
+                .srcQueueFamilyIndex = queue_family,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT,
+                .buffer = dst_buffer,
+                .offset = dst_offset,
+                .size = guest_size,
+            };
+            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+                                   VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, release);
+        }
+        static constexpr VkMemoryBarrier HOST_BARRIER{
+            .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
+            .pNext = nullptr,
+            .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
+            .dstAccessMask = VK_ACCESS_HOST_READ_BIT,
+        };
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT,
+                               0, HOST_BARRIER);
+    });
+}
+
+namespace {
+constexpr u32 BL3DB_BINDING_INPUT_BUFFER = 0;
+constexpr u32 BL3DB_BINDING_OUTPUT_BUFFER = 1;
+
+struct alignas(16) BlockLinearUnswizzle3DBufferPushConstants {
+    std::array<u32, 3> dim;
+    u32 bytes_per_block_log2;
+    std::array<u32, 3> origin;
+    u32 slice_size;
+    u32 block_size;
+    u32 x_shift;
+    u32 block_height;
+    u32 block_height_mask;
+    u32 block_depth;
+    u32 block_depth_mask;
+};
+static_assert(sizeof(BlockLinearUnswizzle3DBufferPushConstants) <= 128);
+
+constexpr std::array<VkDescriptorSetLayoutBinding, 2> BL3DB_BINDINGS{{
+    {
+        .binding = BL3DB_BINDING_INPUT_BUFFER,
+        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+        .descriptorCount = 1,
+        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
+        .pImmutableSamplers = nullptr,
+    },
+    {
+        .binding = BL3DB_BINDING_OUTPUT_BUFFER,
+        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+        .descriptorCount = 1,
+        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
+        .pImmutableSamplers = nullptr,
+    },
+}};
+
+constexpr std::array<VkDescriptorUpdateTemplateEntry, 2> BL3DB_TEMPLATE{{
+    {
+        .dstBinding = BL3DB_BINDING_INPUT_BUFFER,
+        .dstArrayElement = 0,
+        .descriptorCount = 1,
+        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+        .offset = BL3DB_BINDING_INPUT_BUFFER * sizeof(DescriptorUpdateEntry),
+        .stride = sizeof(DescriptorUpdateEntry),
+    },
+    {
+        .dstBinding = BL3DB_BINDING_OUTPUT_BUFFER,
+        .dstArrayElement = 0,
+        .descriptorCount = 1,
+        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+        .offset = BL3DB_BINDING_OUTPUT_BUFFER * sizeof(DescriptorUpdateEntry),
+        .stride = sizeof(DescriptorUpdateEntry),
+    },
+}};
+
+constexpr DescriptorBankInfo BL3DB_BANK_INFO{
+    .uniform_buffers = 0,
+    .storage_buffers = 2,
+    .texture_buffers = 0,
+    .image_buffers = 0,
+    .textures = 0,
+    .images = 0,
+    .score = 2,
+};
+} // Anonymous namespace
+
+BlockLinearUnswizzle3DBufferPass::BlockLinearUnswizzle3DBufferPass(
+    const Device& device_, Scheduler& scheduler_, DescriptorPool& descriptor_pool_,
+    StagingBufferPool& staging_buffer_pool_,
+    ComputePassDescriptorQueue& compute_pass_descriptor_queue_)
+    : ComputePass(device_, scheduler_, descriptor_pool_, BL3DB_BINDINGS, BL3DB_TEMPLATE,
+                  BL3DB_BANK_INFO,
+                  COMPUTE_PUSH_CONSTANT_RANGE<sizeof(BlockLinearUnswizzle3DBufferPushConstants)>,
+                  BLOCK_LINEAR_UNSWIZZLE_3D_BUFFER_COMP_SPV),
+      scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
+      compute_pass_descriptor_queue{compute_pass_descriptor_queue_} {}
+
+BlockLinearUnswizzle3DBufferPass::~BlockLinearUnswizzle3DBufferPass() = default;
+
+bool BlockLinearUnswizzle3DBufferPass::IsSupported(const Device& device,
+                                                   const VideoCommon::ImageInfo& info) {
+    if (info.type != VideoCommon::ImageType::e3D) {
+        return false;
+    }
+    if (info.resources.levels != 1 || info.resources.layers != 1) {
+        return false;
+    }
+    if (info.num_samples > 1) {
+        return false;
+    }
+    if (info.size.depth <= 1) {
+        return false;
+    }
+    if (VideoCore::Surface::GetFormatType(info.format) !=
+        VideoCore::Surface::SurfaceType::ColorTexture) {
+        return false;
+    }
+    if (VideoCore::Surface::IsPixelFormatASTC(info.format)) {
+        return false;
+    }
+    if (VideoCore::Surface::IsPixelFormatBCn(info.format) && !device.IsOptimalBcnSupported()) {
+        return false;
+    }
+    const u32 bytes_per_block = VideoCore::Surface::BytesPerBlock(info.format);
+    return bytes_per_block == 4 || bytes_per_block == 8 || bytes_per_block == 16;
+}
+
+void BlockLinearUnswizzle3DBufferPass::Unswizzle(
+    Image& image, const StagingBufferRef& swizzled,
+    std::span<const VideoCommon::SwizzleParameters> swizzles) {
+    if (swizzles.empty()) {
+        return;
+    }
+
+    const VideoCommon::SwizzleParameters& sw = swizzles.front();
+    const auto params = VideoCommon::Accelerated::MakeBlockLinearSwizzle3DParams(sw, image.info);
+
+    const u32 blocks_x = sw.num_tiles.width;
+    const u32 blocks_y = sw.num_tiles.height;
+    const u32 blocks_z = sw.num_tiles.depth;
+    const u32 bytes_per_block = 1u << params.bytes_per_block_log2;
+    const VkDeviceSize output_size =
+        static_cast<VkDeviceSize>(blocks_x) * blocks_y * blocks_z * bytes_per_block;
+
+    const StagingBufferRef output =
+        staging_buffer_pool.Request(static_cast<size_t>(output_size), MemoryUsage::DeviceLocal);
+
+    BlockLinearUnswizzle3DBufferPushConstants pc{};
+    pc.dim = {blocks_x, blocks_y, blocks_z};
+    pc.bytes_per_block_log2 = params.bytes_per_block_log2;
+    pc.origin = params.origin;
+    pc.slice_size = params.slice_size;
+    pc.block_size = params.block_size;
+    pc.x_shift = params.x_shift;
+    pc.block_height = params.block_height;
+    pc.block_height_mask = params.block_height_mask;
+    pc.block_depth = params.block_depth;
+    pc.block_depth_mask = params.block_depth_mask;
+
+    scheduler.RequestOutsideRenderPassOperationContext();
+
+    compute_pass_descriptor_queue.Acquire(scheduler, 2);
+    compute_pass_descriptor_queue.AddBuffer(swizzled.buffer, sw.buffer_offset + swizzled.offset,
+                                            image.guest_size_bytes - sw.buffer_offset);
+    compute_pass_descriptor_queue.AddBuffer(output.buffer, output.offset, output_size);
+
+    const void* descriptor_data = compute_pass_descriptor_queue.UpdateData();
+    const VkDescriptorSet set = descriptor_allocator.Commit();
+
+    const u32 gx = Common::DivCeil(blocks_x, 8u);
+    const u32 gy = Common::DivCeil(blocks_y, 8u);
+    const u32 gz = Common::DivCeil(blocks_z, 4u);
+    const bool is_initialized = image.ExchangeInitialization();
+
+    const VkBuffer out_buffer = output.buffer;
+    const VkDeviceSize out_offset = output.offset;
+    const VkImage dst_image = image.Handle();
+    const VkImageAspectFlags aspect = image.AspectMask();
+    const VkExtent3D extent{
+        .width = image.info.size.width,
+        .height = image.info.size.height,
+        .depth = image.info.size.depth,
+    };
+
+    scheduler.Record([this, set, descriptor_data, pc, gx, gy, gz, output_size, out_buffer,
+                      out_offset, dst_image, aspect, extent,
+                      is_initialized](vk::CommandBuffer cmdbuf) {
+        if (dst_image == VK_NULL_HANDLE || out_buffer == VK_NULL_HANDLE) {
+            return;
+        }
+        device.GetLogical().UpdateDescriptorSet(set, *descriptor_template, descriptor_data);
+        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
+        cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});
+        cmdbuf.PushConstants(*layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(pc), &pc);
+        cmdbuf.Dispatch(gx, gy, gz);
+
+        const VkBufferMemoryBarrier buffer_barrier{
+            .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+            .pNext = nullptr,
+            .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
+            .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
+            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .buffer = out_buffer,
+            .offset = out_offset,
+            .size = output_size,
+        };
+        VkAccessFlags pre_copy_access = VK_ACCESS_NONE;
+        VkImageLayout pre_copy_layout = VK_IMAGE_LAYOUT_UNDEFINED;
+        VkPipelineStageFlags pre_copy_stage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+        if (is_initialized) {
+            pre_copy_access = VK_ACCESS_SHADER_READ_BIT;
+            pre_copy_layout = VK_IMAGE_LAYOUT_GENERAL;
+            pre_copy_stage = vk::PIPELINE_STAGE_GRAPHICS_COMPUTE;
+        }
+        const VkImageMemoryBarrier pre_copy{
+            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+            .pNext = nullptr,
+            .srcAccessMask = pre_copy_access,
+            .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+            .oldLayout = pre_copy_layout,
+            .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .image = dst_image,
+            .subresourceRange{
+                .aspectMask = aspect,
+                .baseMipLevel = 0,
+                .levelCount = VK_REMAINING_MIP_LEVELS,
+                .baseArrayLayer = 0,
+                .layerCount = VK_REMAINING_ARRAY_LAYERS,
+            },
+        };
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT | pre_copy_stage,
+                               VK_PIPELINE_STAGE_TRANSFER_BIT, 0, {}, buffer_barrier, pre_copy);
+
+        const VkBufferImageCopy copy{
+            .bufferOffset = out_offset,
+            .bufferRowLength = 0,
+            .bufferImageHeight = 0,
+            .imageSubresource{
+                .aspectMask = aspect,
+                .mipLevel = 0,
+                .baseArrayLayer = 0,
+                .layerCount = 1,
+            },
+            .imageOffset = {0, 0, 0},
+            .imageExtent = extent,
+        };
+        cmdbuf.CopyBufferToImage(out_buffer, dst_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, copy);
+
+        const VkImageMemoryBarrier post_copy{
+            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+            .pNext = nullptr,
+            .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+            .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
+            .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+            .newLayout = VK_IMAGE_LAYOUT_GENERAL,
+            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .image = dst_image,
+            .subresourceRange{
+                .aspectMask = aspect,
+                .baseMipLevel = 0,
+                .levelCount = VK_REMAINING_MIP_LEVELS,
+                .baseArrayLayer = 0,
+                .layerCount = VK_REMAINING_ARRAY_LAYERS,
+            },
+        };
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
+                               0, {}, {}, post_copy);
+    });
+}
+
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_compute_pass.h

@@ -164,4 +164,63 @@ private:
     ComputePassDescriptorQueue& compute_pass_descriptor_queue;
 };
 
+class BlockLinearUnswizzle2DPass final : public ComputePass {
+public:
+    explicit BlockLinearUnswizzle2DPass(const Device& device_, Scheduler& scheduler_,
+                                        DescriptorPool& descriptor_pool_,
+                                        StagingBufferPool& staging_buffer_pool_,
+                                        ComputePassDescriptorQueue& compute_pass_descriptor_queue_);
+    ~BlockLinearUnswizzle2DPass();
+
+    [[nodiscard]] static bool IsSupported(const Device& device,
+                                          const VideoCommon::ImageInfo& info);
+
+    void Unswizzle(Image& image, const StagingBufferRef& swizzled,
+                   std::span<const VideoCommon::SwizzleParameters> swizzles);
+
+    void UnswizzleFrom(Image& image, VkBuffer source_buffer, VkDeviceSize source_offset,
+                       std::span<const VideoCommon::SwizzleParameters> swizzles);
+
+private:
+    Scheduler& scheduler;
+    StagingBufferPool& staging_buffer_pool;
+    ComputePassDescriptorQueue& compute_pass_descriptor_queue;
+};
+
+class BlockLinearSwizzle2DPass final : public ComputePass {
+public:
+    explicit BlockLinearSwizzle2DPass(const Device& device_, Scheduler& scheduler_,
+                                      DescriptorPool& descriptor_pool_,
+                                      StagingBufferPool& staging_buffer_pool_,
+                                      ComputePassDescriptorQueue& compute_pass_descriptor_queue_);
+    ~BlockLinearSwizzle2DPass();
+
+    void SwizzleInto(Image& image, VkBuffer dst_buffer, VkDeviceSize dst_offset,
+                     bool foreign_ownership);
+
+private:
+    Scheduler& scheduler;
+    StagingBufferPool& staging_buffer_pool;
+    ComputePassDescriptorQueue& compute_pass_descriptor_queue;
+};
+
+class BlockLinearUnswizzle3DBufferPass final : public ComputePass {
+public:
+    explicit BlockLinearUnswizzle3DBufferPass(
+        const Device& device_, Scheduler& scheduler_, DescriptorPool& descriptor_pool_,
+        StagingBufferPool& staging_buffer_pool_,
+        ComputePassDescriptorQueue& compute_pass_descriptor_queue_);
+    ~BlockLinearUnswizzle3DBufferPass();
+
+    [[nodiscard]] static bool IsSupported(const Device& device, const VideoCommon::ImageInfo& info);
+
+    void Unswizzle(Image& image, const StagingBufferRef& swizzled,
+                   std::span<const VideoCommon::SwizzleParameters> swizzles);
+
+private:
+    Scheduler& scheduler;
+    StagingBufferPool& staging_buffer_pool;
+    ComputePassDescriptorQueue& compute_pass_descriptor_queue;
+};
+
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_multi_range_buffer.cpp

@@ -13,7 +13,8 @@ namespace Vulkan {
 
 MultiRangeBufferCache::MultiRangeBufferCache(const Device& device) {
     sparse_usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
-                   VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+                   VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT |
+                   VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
     if (device.IsBufferDeviceAddressSupported()) {
         sparse_usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
     }
@@ -27,9 +28,14 @@ MultiRangeBufferCache::MultiRangeBufferCache(const Device& device) {
     }
     block_size = queried;
     sparse_memory_type_bits = memory_type_bits;
+    sparse_budget = device.GetSparseAddressSpaceSize();
     use_sparse = true;
 }
 
+void MultiRangeBufferCache::ReserveSparseAddressSpace(VkDeviceSize size) noexcept {
+    sparse_budget -= (std::min)(sparse_budget, size);
+}
+
 VkDeviceSize MultiRangeBufferCache::QueryBlockSize(const Device& device,
                                                    u32& memory_type_bits) const {
     const VkDevice logical = *device.GetLogical();
@@ -100,15 +106,26 @@ bool MultiRangeBufferCache::CanBindSparse(std::span<const MultiRangeSource> sour
 
 SparseBuffer MultiRangeBufferCache::CreateSparse(const Device& device, Scheduler& scheduler,
                                                  std::span<const MultiRangeSource> sources,
-                                                 VkDeviceSize total) {
+                                                 VkDeviceSize total, VkBufferCreateFlags flags,
+                                                 VkBufferUsageFlags usage,
+                                                 VkExternalMemoryHandleTypeFlags handle_types) {
     const VkDevice logical = *device.GetLogical();
     const auto& dld = device.GetDispatchLoader();
+    const VkExternalMemoryBufferCreateInfo external_info{
+        .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
+        .pNext = nullptr,
+        .handleTypes = handle_types,
+    };
+    const void* next = nullptr;
+    if (handle_types != 0) {
+        next = &external_info;
+    }
     const VkBufferCreateInfo buffer_ci{
         .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = VK_BUFFER_CREATE_SPARSE_BINDING_BIT | VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
+        .pNext = next,
+        .flags = flags,
         .size = total,
-        .usage = sparse_usage,
+        .usage = usage,
         .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
         .queueFamilyIndexCount = 0,
         .pQueueFamilyIndices = nullptr,
@@ -118,6 +135,27 @@ SparseBuffer MultiRangeBufferCache::CreateSparse(const Device& device, Scheduler
         return SparseBuffer{};
     }
     SparseBuffer handle{raw, logical, dld};
+    const VkBufferMemoryRequirementsInfo2 reqs_info{
+        .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
+        .pNext = nullptr,
+        .buffer = raw,
+    };
+    VkMemoryRequirements2 reqs2{
+        .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
+        .pNext = nullptr,
+        .memoryRequirements = {},
+    };
+    dld.vkGetBufferMemoryRequirements2(logical, &reqs_info, &reqs2);
+    const VkMemoryRequirements& requirements = reqs2.memoryRequirements;
+    if (requirements.alignment == 0 || (block_size % requirements.alignment) != 0) {
+        return SparseBuffer{};
+    }
+    for (const MultiRangeSource& source : sources) {
+        if (source.memory_type >= 32 ||
+            ((requirements.memoryTypeBits >> source.memory_type) & 1) == 0) {
+            return SparseBuffer{};
+        }
+    }
     std::vector<VkSparseMemoryBind> binds;
     binds.reserve(sources.size());
     VkDeviceSize resource_offset = 0;
@@ -185,10 +223,16 @@ void MultiRangeBufferCache::RetireEntry(Scheduler& scheduler, Entry& entry) {
         scheduler.Wait(oldest);
         DrainRetired(scheduler);
     }
+    VkDeviceSize sparse_size = 0;
+    if (entry.sparse_handle) {
+        sparse_size = entry.size;
+    }
+    sparse_retiring += sparse_size;
     retired.push_back(Retired{
         .handle = std::move(entry.sparse_handle),
         .gathered = std::move(entry.gathered),
         .tick = scheduler.CurrentTick(),
+        .sparse_size = sparse_size,
     });
 }
 
@@ -196,6 +240,8 @@ void MultiRangeBufferCache::DrainRetired(Scheduler& scheduler) {
     size_t index = 0;
     while (index < retired.size()) {
         if (scheduler.IsFree(retired[index].tick)) {
+            sparse_in_use -= (std::min)(sparse_in_use, retired[index].sparse_size);
+            sparse_retiring -= (std::min)(sparse_retiring, retired[index].sparse_size);
             if (index + 1 != retired.size()) {
                 retired[index] = std::move(retired.back());
             }
@@ -221,6 +267,7 @@ MultiRangeRef MultiRangeBufferCache::Get(const Device& device, Scheduler& schedu
     const auto it = entries.find(key);
     if (it != entries.end() && it->second.geometry == geometry && it->second.size == total) {
         Entry& entry = it->second;
+        entry.last_use = scheduler.CurrentTick();
         if (entry.content != content) {
             entry.content = content;
             entry.dirty = true;
@@ -248,9 +295,14 @@ MultiRangeRef MultiRangeBufferCache::Get(const Device& device, Scheduler& schedu
     entry.geometry = geometry;
     entry.content = content;
     entry.size = total;
-    if (CanBindSparse(sources)) {
-        entry.sparse_handle = CreateSparse(device, scheduler, sources, total);
+    entry.last_use = scheduler.CurrentTick();
+    if (CanBindSparse(sources) && FitsSparse(scheduler, total)) {
+        entry.sparse_handle = CreateSparse(
+            device, scheduler, sources, total,
+            VK_BUFFER_CREATE_SPARSE_BINDING_BIT | VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
+            sparse_usage, 0);
         if (entry.sparse_handle) {
+            sparse_in_use += total;
             entry.owners.reserve(sources.size());
             for (const MultiRangeSource& source : sources) {
                 entry.owners.push_back(source.handle);
@@ -260,7 +312,9 @@ MultiRangeRef MultiRangeBufferCache::Get(const Device& device, Scheduler& schedu
     if (!entry.sparse_handle) {
         VkBufferUsageFlags flags = VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
                                    VK_BUFFER_USAGE_TRANSFER_DST_BIT |
-                                   VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+                                   VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
+                                   VK_BUFFER_USAGE_VERTEX_BUFFER_BIT |
+                                   VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
         if (device.IsBufferDeviceAddressSupported()) {
             flags |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
         }
@@ -301,6 +355,86 @@ MultiRangeRef MultiRangeBufferCache::Get(const Device& device, Scheduler& schedu
     return ref;
 }
 
+MultiRangeRef MultiRangeBufferCache::GetView(const Device& device, Scheduler& scheduler, u64 key,
+                                             std::span<const MultiRangeSource> sources,
+                                             VkDeviceSize total, VkBufferUsageFlags usage,
+                                             VkExternalMemoryHandleTypeFlags handle_types) {
+    if (!use_sparse || !views_supported || sources.empty() || total == 0) {
+        return MultiRangeRef{};
+    }
+    if (!retired.empty()) {
+        DrainRetired(scheduler);
+    }
+    const u64 geometry = HashSources(sources);
+    const auto it = entries.find(key);
+    if (it != entries.end() && it->second.sparse_handle && it->second.geometry == geometry &&
+        it->second.size == total) {
+        it->second.last_use = scheduler.CurrentTick();
+        return MultiRangeRef{
+            .handle = *it->second.sparse_handle,
+            .address = it->second.address,
+            .size = total,
+            .sparse = true,
+            .needs_gather = false,
+        };
+    }
+    if (it != entries.end()) {
+        RetireEntry(scheduler, it->second);
+        entries.erase(it);
+    }
+    if (!FitsSparse(scheduler, total)) {
+        return MultiRangeRef{};
+    }
+    Entry entry{};
+    entry.sparse_handle = CreateSparse(device, scheduler, sources, total,
+                                       VK_BUFFER_CREATE_SPARSE_BINDING_BIT, usage, handle_types);
+    if (!entry.sparse_handle) {
+        views_supported = false;
+        return MultiRangeRef{};
+    }
+    sparse_in_use += total;
+    entry.geometry = geometry;
+    entry.size = total;
+    entry.last_use = scheduler.CurrentTick();
+    entry.dirty = false;
+    if ((usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) != 0) {
+        entry.address = device.GetLogical().GetBufferDeviceAddress(*entry.sparse_handle);
+    }
+    const MultiRangeRef ref{
+        .handle = *entry.sparse_handle,
+        .address = entry.address,
+        .size = total,
+        .sparse = true,
+        .needs_gather = false,
+    };
+    entries.emplace(key, std::move(entry));
+    return ref;
+}
+
+bool MultiRangeBufferCache::FitsSparse(Scheduler& scheduler, VkDeviceSize total) {
+    if (total > sparse_budget) {
+        return false;
+    }
+    const u64 current_tick = scheduler.CurrentTick();
+    while (sparse_in_use - sparse_retiring > sparse_budget - total) {
+        auto victim = entries.end();
+        for (auto it = entries.begin(); it != entries.end(); ++it) {
+            if (!it->second.sparse_handle || it->second.last_use >= current_tick) {
+                continue;
+            }
+            if (victim == entries.end() || it->second.last_use < victim->second.last_use) {
+                victim = it;
+            }
+        }
+        if (victim == entries.end()) {
+            break;
+        }
+        RetireEntry(scheduler, victim->second);
+        entries.erase(victim);
+    }
+    return sparse_in_use <= sparse_budget - total;
+}
+
 void MultiRangeBufferCache::MarkGathered(u64 key) {
     if (auto const it = entries.find(key); it != entries.end()) {
         it->second.dirty = false;

src/video_core/renderer_vulkan/vk_multi_range_buffer.h

@@ -53,12 +53,19 @@ public:
                                     std::span<const MultiRangeSource> sources,
                                     VkDeviceSize total);
 
+    [[nodiscard]] MultiRangeRef GetView(const Device& device, Scheduler& scheduler, u64 key,
+                                        std::span<const MultiRangeSource> sources,
+                                        VkDeviceSize total, VkBufferUsageFlags usage,
+                                        VkExternalMemoryHandleTypeFlags handle_types);
+
     void MarkGathered(u64 key);
 
     void Invalidate(u64 key);
 
     void DropOwner(Scheduler& scheduler, VkBuffer owner);
 
+    void ReserveSparseAddressSpace(VkDeviceSize size) noexcept;
+
     VkDeviceSize block_size{DEFAULT_BLOCK_SIZE};
     bool use_sparse{};
 
@@ -67,6 +74,7 @@ private:
         SparseBuffer handle;
         vk::Buffer gathered;
         u64 tick{};
+        VkDeviceSize sparse_size{};
     };
 
     struct Entry {
@@ -77,6 +85,7 @@ private:
         VkDeviceSize size{};
         u64 geometry{};
         u64 content{};
+        u64 last_use{};
         bool dirty{true};
     };
 
@@ -88,7 +97,11 @@ private:
 
     [[nodiscard]] SparseBuffer CreateSparse(const Device& device, Scheduler& scheduler,
                                             std::span<const MultiRangeSource> sources,
-                                            VkDeviceSize total);
+                                            VkDeviceSize total, VkBufferCreateFlags flags,
+                                            VkBufferUsageFlags usage,
+                                            VkExternalMemoryHandleTypeFlags handle_types);
+
+    [[nodiscard]] bool FitsSparse(Scheduler& scheduler, VkDeviceSize total);
 
     [[nodiscard]] VkDeviceSize QueryBlockSize(const Device& device, u32& memory_type_bits) const;
 
@@ -100,6 +113,10 @@ private:
     boost::container::static_vector<Retired, MAX_RETIRED> retired;
     u32 sparse_memory_type_bits{};
     VkBufferUsageFlags sparse_usage{};
+    VkDeviceSize sparse_budget{};
+    VkDeviceSize sparse_in_use{};
+    VkDeviceSize sparse_retiring{};
+    bool views_supported{true};
 };
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -451,6 +451,7 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
         .has_broken_fp32_denorm_flush = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
         .ignore_nan_fp_comparisons = false,
         .has_broken_spirv_subgroup_mask_vector_extract_dynamic = false,
+        .max_shared_memory_size = device.GetMaxComputeSharedMemorySize(),
         .has_broken_robust =
             device.IsNvidia() && device.GetNvidiaArch() <= NvidiaArchitecture::Arch_Pascal,
         .min_ssbo_alignment = device.GetStorageBufferAlignment(),
@@ -969,19 +970,6 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
     }
 
     auto program{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
-    const VkDriverIdKHR driver_id = device.GetDriverID();
-    const bool needs_shared_mem_clamp =
-        driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
-        driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
-    const u32 max_shared_memory = device.GetMaxComputeSharedMemorySize();
-    if (needs_shared_mem_clamp && program.shared_memory_size > max_shared_memory) {
-        LOG_WARNING(Render_Vulkan,
-                    "Compute shader {:#016x} requests {}KB shared memory but device max is {}KB - clamping",
-                    key.unique_hash,
-                    program.shared_memory_size / 1024,
-                    max_shared_memory / 1024);
-        program.shared_memory_size = max_shared_memory;
-    }
     const std::vector<u32> code{EmitSPIRV(profile, program)};
     device.SaveShader(code);
     vk::ShaderModule spv_module{BuildShader(device, code)};

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -225,6 +225,13 @@ RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra
       fence_manager(*this, gpu, texture_cache, buffer_cache, query_cache, device, scheduler),
       wfi_event(device.GetLogical().CreateEvent()) {
     scheduler.SetQueryCache(query_cache);
+    if (Settings::values.use_unified_memory.GetValue() && device_memory.IsBackingShared()) {
+        buffer_cache_runtime.TryEnableUnifiedMemory(
+            device_memory.GetPhysicalBase(), device_memory.GetPhysicalSize(),
+            device_memory.GetBackingHardwareBuffers(),
+            device_memory.GetBackingHardwareBufferWindowSize(),
+            device_memory.GetBackingHardwareBufferBase());
+    }
 }
 
 RasterizerVulkan::~RasterizerVulkan() {

src/video_core/renderer_vulkan/vk_scheduler.h

@@ -129,6 +129,10 @@ public:
         return master_semaphore->IsFree(tick);
     }
 
+    void RefreshTick() {
+        master_semaphore->Refresh();
+    }
+
     /// Waits for the given GPU tick, optionally pacing frames.
     void Wait(u64 tick, double target_fps = 0.0) {
         if (tick > 0) {

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -968,6 +968,12 @@ TextureCacheRuntime::TextureCacheRuntime(const Device& device_, Scheduler& sched
         bl3d_unswizzle_pass.emplace(device, scheduler, descriptor_pool,
                                    staging_buffer_pool, compute_pass_descriptor_queue);
     }
+    bl2d_unswizzle_pass.emplace(device, scheduler, descriptor_pool, staging_buffer_pool,
+                                compute_pass_descriptor_queue);
+    bl3db_unswizzle_pass.emplace(device, scheduler, descriptor_pool, staging_buffer_pool,
+                                 compute_pass_descriptor_queue);
+    bl2d_swizzle_pass.emplace(device, scheduler, descriptor_pool, staging_buffer_pool,
+                              compute_pass_descriptor_queue);
 }
 
 void TextureCacheRuntime::Finish() {
@@ -1894,6 +1900,12 @@ Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu
         }
         flags |= VideoCommon::ImageFlagBits::Converted;
         flags |= VideoCommon::ImageFlagBits::CostlyLoad;
+    } else if (runtime->bl2d_unswizzle_pass &&
+               BlockLinearUnswizzle2DPass::IsSupported(runtime->device, info)) {
+        flags |= VideoCommon::ImageFlagBits::AcceleratedUpload;
+    } else if (runtime->bl3db_unswizzle_pass &&
+               BlockLinearUnswizzle3DBufferPass::IsSupported(runtime->device, info)) {
+        flags |= VideoCommon::ImageFlagBits::AcceleratedUpload;
     }
     if (IsPixelFormatBCn(info.format) && !runtime->device.IsOptimalBcnSupported()) {
         flags |= VideoCommon::ImageFlagBits::Converted;
@@ -3137,10 +3149,19 @@ void TextureCacheRuntime::AccelerateImageUpload(
     std::span<const VideoCommon::SwizzleParameters> swizzles,
     u32 z_start, u32 z_count) {
 
-    if (IsPixelFormatASTC(image.info.format)) {
+    if (astc_decoder_pass && WillUseAcceleratedAstcDecode(device, image.info)) {
         return astc_decoder_pass->Assemble(image, map, swizzles);
     }
 
+    if (bl2d_unswizzle_pass && BlockLinearUnswizzle2DPass::IsSupported(device, image.info)) {
+        return bl2d_unswizzle_pass->Unswizzle(image, map, swizzles);
+    }
+
+    if (bl3db_unswizzle_pass && z_count == 0 &&
+        BlockLinearUnswizzle3DBufferPass::IsSupported(device, image.info)) {
+        return bl3db_unswizzle_pass->Unswizzle(image, map, swizzles);
+    }
+
     if (!Settings::values.gpu_unswizzle_enabled.GetValue() || !bl3d_unswizzle_pass) {
         if (IsPixelFormatBCn(image.info.format) && image.info.type == ImageType::e3D) {
             ASSERT(false && "GPU unswizzle is disabled for BCn 3D texture");
@@ -3156,6 +3177,89 @@ void TextureCacheRuntime::AccelerateImageUpload(
     ASSERT(false);
 }
 
+bool TextureCacheRuntime::IsUnifiedMemoryBindable() const noexcept {
+    const HostMemoryImport* const import = memory_allocator.GetHostMemoryImport();
+    return import != nullptr && import->IsValid() && import->IsBindable();
+}
+
+u64 TextureCacheRuntime::UnifiedMemoryBase() const noexcept {
+    const HostMemoryImport* const import = memory_allocator.GetHostMemoryImport();
+    if (import == nullptr) {
+        return 0;
+    }
+    return import->GetBaseOffset();
+}
+
+u64 TextureCacheRuntime::UnifiedMemorySize() const noexcept {
+    const HostMemoryImport* const import = memory_allocator.GetHostMemoryImport();
+    if (import == nullptr) {
+        return 0;
+    }
+    return import->GetSize();
+}
+
+bool TextureCacheRuntime::CanUploadImageDirectly(const VideoCommon::ImageInfo& info) const {
+    return bl2d_unswizzle_pass.has_value() &&
+           BlockLinearUnswizzle2DPass::IsSupported(device, info);
+}
+
+std::optional<HostMemoryImport::Range> TextureCacheRuntime::ResolveDirectRange(u64 relative,
+                                                                              u64 size) const {
+    if (size > device.GetMaxStorageBufferRange()) {
+        return std::nullopt;
+    }
+    const HostMemoryImport* const import = memory_allocator.GetHostMemoryImport();
+    if (import == nullptr) {
+        return std::nullopt;
+    }
+    const auto range = import->ResolveRange(relative, size);
+    if (!range || range->buffer == VK_NULL_HANDLE ||
+        (range->offset % device.GetStorageBufferAlignment()) != 0) {
+        return std::nullopt;
+    }
+    return range;
+}
+
+bool TextureCacheRuntime::UploadImageDirectly(
+    Image& image, u64 relative, std::span<const VideoCommon::SwizzleParameters> swizzles) {
+    const auto range = ResolveDirectRange(relative, image.guest_size_bytes);
+    if (!range) {
+        return false;
+    }
+    bl2d_unswizzle_pass->UnswizzleFrom(image, range->buffer, range->offset, swizzles);
+    return true;
+}
+
+bool TextureCacheRuntime::CanDownloadImageDirectly(const VideoCommon::ImageInfo& info) const {
+    return bl2d_swizzle_pass.has_value() && BlockLinearUnswizzle2DPass::IsSupported(device, info);
+}
+
+bool TextureCacheRuntime::DownloadImageDirectly(Image& image, u64 relative) {
+    if (image.unswizzled_size_bytes > device.GetMaxStorageBufferRange()) {
+        return false;
+    }
+    const auto range = ResolveDirectRange(relative, image.guest_size_bytes);
+    if (!range) {
+        return false;
+    }
+    const HostMemoryImport* const import = memory_allocator.GetHostMemoryImport();
+    bl2d_swizzle_pass->SwizzleInto(image, range->buffer, range->offset,
+                                   import->NeedsForeignOwnershipTransfer());
+    return true;
+}
+
+u64 TextureCacheRuntime::CurrentTick() const noexcept {
+    return scheduler.CurrentTick();
+}
+
+bool TextureCacheRuntime::IsTickRetired(u64 tick) {
+    if (scheduler.IsFree(tick)) {
+        return true;
+    }
+    scheduler.RefreshTick();
+    return scheduler.IsFree(tick);
+}
+
 void TextureCacheRuntime::TransitionImageLayout(Image& image) {
     if (!image.ExchangeInitialization()) {
         VkImageMemoryBarrier barrier{

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -101,6 +101,28 @@ public:
                                std::span<const VideoCommon::SwizzleParameters>,
                                u32 z_start, u32 z_count);
 
+    [[nodiscard]] bool IsUnifiedMemoryBindable() const noexcept;
+
+    [[nodiscard]] u64 UnifiedMemoryBase() const noexcept;
+
+    [[nodiscard]] u64 UnifiedMemorySize() const noexcept;
+
+    [[nodiscard]] bool CanUploadImageDirectly(const VideoCommon::ImageInfo& info) const;
+
+    bool UploadImageDirectly(Image& image, u64 relative,
+                             std::span<const VideoCommon::SwizzleParameters> swizzles);
+
+    [[nodiscard]] bool CanDownloadImageDirectly(const VideoCommon::ImageInfo& info) const;
+
+    bool DownloadImageDirectly(Image& image, u64 relative);
+
+    [[nodiscard]] std::optional<HostMemoryImport::Range> ResolveDirectRange(u64 relative,
+                                                                            u64 size) const;
+
+    [[nodiscard]] u64 CurrentTick() const noexcept;
+
+    [[nodiscard]] bool IsTickRetired(u64 tick);
+
     void InsertUploadMemoryBarrier() {}
 
     void TransitionImageLayout(Image& image);
@@ -159,6 +181,9 @@ public:
     std::optional<ASTCDecoderPass> astc_decoder_pass;
 
     std::optional<BlockLinearUnswizzle3DPass> bl3d_unswizzle_pass;
+    std::optional<BlockLinearUnswizzle2DPass> bl2d_unswizzle_pass;
+    std::optional<BlockLinearUnswizzle3DBufferPass> bl3db_unswizzle_pass;
+    std::optional<BlockLinearSwizzle2DPass> bl2d_swizzle_pass;
     const Settings::ResolutionScalingInfo& resolution;
     std::array<std::vector<VkFormat>, VideoCore::Surface::MaxPixelFormat> view_formats;
 
@@ -586,6 +611,7 @@ struct TextureCacheParams {
     static constexpr bool HAS_DEVICE_MEMORY_INFO = true;
     static constexpr bool IMPLEMENTS_ASYNC_DOWNLOADS = true;
     static constexpr bool HAS_MSAA_DOWNLOADS = true;
+    static constexpr bool USE_UNIFIED_MEMORY = true;
 
     using Runtime = Vulkan::TextureCacheRuntime;
     using Image = Vulkan::Image;

src/video_core/texture_cache/image_base.h

@@ -95,6 +95,11 @@ struct ImageBase {
     u32 scale_rating = 0;
     u64 scale_tick = 0;
     bool has_scaled = false;
+    u64 direct_upload_tick = 0;
+    bool direct_upload_blocked = false;
+    bool eviction_pending = false;
+    u64 eviction_tick = 0;
+    u64 eviction_modification_tick = 0;
 
     size_t channel = 0;
 

src/video_core/texture_cache/texture_cache.h

@@ -119,13 +119,16 @@ void TextureCache<P>::RunGarbageCollector() {
     bool aggressive_mode = false;
     u64 ticks_to_destroy = 0;
     size_t num_iterations = 0;
+    size_t num_downloads = 0;
     const auto Configure = [&](bool allow_aggressive) {
         high_priority_mode = total_used_memory >= expected_memory;
         aggressive_mode = allow_aggressive && total_used_memory >= critical_memory;
         ticks_to_destroy = aggressive_mode ? 10ULL : high_priority_mode ? 25ULL : 50ULL;
         num_iterations = aggressive_mode ? 40 : (high_priority_mode ? 20 : 10);
+        num_downloads = MAX_GC_DOWNLOADS_PER_PASS;
     };
-    const auto Cleanup = [this, &num_iterations, &high_priority_mode, &aggressive_mode](ImageId image_id) {
+    const auto Cleanup = [this, &num_iterations, &num_downloads, &high_priority_mode,
+                          &aggressive_mode](ImageId image_id) {
         if (num_iterations == 0) {
             return true;
         }
@@ -134,11 +137,21 @@ void TextureCache<P>::RunGarbageCollector() {
         if (True(image.flags & ImageFlagBits::IsDecoding)) {
             return false;
         }
+        if (image.eviction_pending) {
+            return false;
+        }
         const bool must_download = IsDownloadable(image) && False(image.flags & ImageFlagBits::BadOverlap);
         if ((!aggressive_mode && True(image.flags & ImageFlagBits::CostlyLoad)) || (!high_priority_mode && must_download)) {
             return false;
         }
         if (must_download) {
+            if (num_downloads == 0) {
+                return false;
+            }
+            --num_downloads;
+            if (StartEviction(image_id, image)) {
+                return false;
+            }
             auto map = runtime.DownloadStagingBuffer(image.unswizzled_size_bytes);
             const auto copies = FixSmallVectorADL(FullDownloadCopies(image.info));
             image.DownloadMemory(map, copies);
@@ -169,6 +182,7 @@ void TextureCache<P>::RunGarbageCollector() {
 
 template <class P>
 void TextureCache<P>::TickFrame() {
+    FinishEvictions();
     // If we can obtain the memory info, use it instead of the estimate.
     if (runtime.CanReportMemoryUsage()) {
         total_used_memory = runtime.GetDeviceMemoryUsage();
@@ -585,6 +599,15 @@ FramebufferId TextureCache<P>::GetFramebufferId(const RenderTargets& key) {
 template <class P>
 void TextureCache<P>::WriteMemory(DAddr cpu_addr, size_t size) {
     ForEachImageInRegion(cpu_addr, size, [this](ImageId image_id, Image& image) {
+        if constexpr (USE_UNIFIED_MEMORY) {
+            if (image.direct_upload_tick != 0) {
+                const u64 upload_tick = image.direct_upload_tick;
+                image.direct_upload_tick = 0;
+                if (!runtime.IsTickRetired(upload_tick)) {
+            image.direct_upload_blocked = true;
+        }
+            }
+        }
         if (True(image.flags & ImageFlagBits::CpuModified)) {
             return;
         }
@@ -626,15 +649,24 @@ void TextureCache<P>::DownloadMemory(DAddr cpu_addr, size_t size) {
     std::ranges::sort(images, [this](ImageId lhs, ImageId rhs) {
         return slot_images[lhs].modification_tick < slot_images[rhs].modification_tick;
     });
+    bool pending_unified = false;
     for (const ImageId image_id : images) {
         Image& image = slot_images[image_id];
+        if (TryDownloadToUnifiedMemory(image)) {
+            pending_unified = true;
+            continue;
+        }
         auto map = runtime.DownloadStagingBuffer(image.unswizzled_size_bytes);
         const auto copies = FixSmallVectorADL(FullDownloadCopies(image.info));
         image.DownloadMemory(map, copies);
         runtime.Finish();
+        pending_unified = false;
         SwizzleImage(*gpu_memory, image.gpu_addr, image.info, copies, map.mapped_span,
                      swizzle_data_buffer);
     }
+    if (pending_unified) {
+        runtime.Finish();
+    }
 }
 
 template <class P>
@@ -1145,11 +1177,143 @@ void TextureCache<P>::RefreshContents(Image& image, ImageId image_id) {
         QueueAsyncUnswizzle(image, image_id);
         return;
     }
+    if (True(image.flags & ImageFlagBits::AcceleratedUpload) &&
+        TryUploadFromUnifiedMemory(image)) {
+        runtime.InsertUploadMemoryBarrier();
+        return;
+    }
     auto staging = runtime.UploadStagingBuffer(MapSizeBytes(image));
     UploadImageContents(image, staging);
     runtime.InsertUploadMemoryBarrier();
 }
 
+template <class P>
+std::optional<u64> TextureCache<P>::ResolveUnifiedImageOffset(
+    [[maybe_unused]] const ImageBase& image) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        if (image.guest_size_bytes == 0 || !runtime.IsUnifiedMemoryBindable()) {
+            return std::nullopt;
+        }
+        const u8* const first = gpu_memory->GetSpan(image.gpu_addr, image.guest_size_bytes);
+        if (first == nullptr) {
+            return std::nullopt;
+        }
+        const u64 phys_offset = static_cast<u64>(first - device_memory.GetPhysicalBase());
+        const u64 unified_base = runtime.UnifiedMemoryBase();
+        if (phys_offset < unified_base) {
+            return std::nullopt;
+        }
+        const u64 relative = phys_offset - unified_base;
+        const u64 unified_size = runtime.UnifiedMemorySize();
+        if (relative >= unified_size || unified_size - relative < image.guest_size_bytes) {
+            return std::nullopt;
+        }
+        return relative;
+    } else {
+        return std::nullopt;
+    }
+}
+
+template <class P>
+bool TextureCache<P>::TryUploadFromUnifiedMemory([[maybe_unused]] Image& image) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        if (image.direct_upload_blocked || !runtime.CanUploadImageDirectly(image.info)) {
+            return false;
+        }
+        const auto relative = ResolveUnifiedImageOffset(image);
+        if (!relative) {
+            return false;
+        }
+        const auto swizzles = FullUploadSwizzles(image.info);
+        if (!runtime.UploadImageDirectly(image, *relative, FixSmallVectorADL(swizzles))) {
+            return false;
+        }
+        image.direct_upload_tick = runtime.CurrentTick();
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+bool TextureCache<P>::TryDownloadToUnifiedMemory([[maybe_unused]] Image& image) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        if (!runtime.CanDownloadImageDirectly(image.info)) {
+            return false;
+        }
+        if (image.info.resources.layers > 1 &&
+            image.info.layer_stride != CalculateLayerStride(image.info)) {
+            return false;
+        }
+        const auto relative = ResolveUnifiedImageOffset(image);
+        if (!relative) {
+            return false;
+        }
+        return runtime.DownloadImageDirectly(image, *relative);
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+bool TextureCache<P>::StartEviction([[maybe_unused]] ImageId image_id,
+                                    [[maybe_unused]] Image& image) {
+    if constexpr (requires { runtime.IsTickRetired(u64{}); }) {
+        auto staging = runtime.DownloadStagingBuffer(image.unswizzled_size_bytes, true);
+        const auto copies = FixSmallVectorADL(FullDownloadCopies(image.info));
+        image.DownloadMemory(staging, copies);
+        eviction_staging.emplace_back(image_id, staging);
+        image.eviction_pending = true;
+        image.eviction_tick = runtime.CurrentTick();
+        image.eviction_modification_tick = image.modification_tick;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+void TextureCache<P>::FinishEvictions() {
+    if constexpr (requires { runtime.IsTickRetired(u64{}); }) {
+        size_t index = 0;
+        while (index < eviction_staging.size()) {
+            const ImageId image_id = eviction_staging[index].first;
+            Image& image = slot_images[image_id];
+            if (!runtime.IsTickRetired(image.eviction_tick)) {
+                ++index;
+                continue;
+            }
+            const bool unchanged = image.modification_tick == image.eviction_modification_tick;
+            if (unchanged && False(image.flags & ImageFlagBits::CpuModified)) {
+                const auto copies = FixSmallVectorADL(FullDownloadCopies(image.info));
+                SwizzleImage(*gpu_memory, image.gpu_addr, image.info, copies,
+                             eviction_staging[index].second.mapped_span, swizzle_data_buffer);
+            }
+            CancelEviction(image_id);
+            if (!unchanged) {
+                continue;
+            }
+            if (True(image.flags & ImageFlagBits::Tracked)) {
+                UntrackImage(image, image_id);
+            }
+            UnregisterImage(image_id);
+            DeleteImage(image_id, image.scale_tick > frame_tick + 5);
+        }
+    }
+}
+
+template <class P>
+void TextureCache<P>::CancelEviction(ImageId image_id) {
+    slot_images[image_id].eviction_pending = false;
+    const auto it = std::ranges::find_if(
+        eviction_staging, [image_id](const auto& entry) { return entry.first == image_id; });
+    if (it == eviction_staging.end()) {
+        return;
+    }
+    async_buffers_death_ring.emplace_back(std::move(it->second));
+    eviction_staging.erase(it);
+}
+
 template <class P>
 template <typename StagingBuffer>
 void TextureCache<P>::UploadImageContents(Image& image, StagingBuffer& staging) {
@@ -2316,6 +2480,9 @@ void TextureCache<P>::UntrackImage(ImageBase& image, ImageId image_id) {
 template <class P>
 void TextureCache<P>::DeleteImage(ImageId image_id, bool immediate_delete) {
     ImageBase& image = slot_images[image_id];
+    if (image.eviction_pending) {
+        CancelEviction(image_id);
+    }
     if (image.HasScaled()) {
         total_used_memory -= GetScaledImageSizeBytes(image);
     }
@@ -2503,6 +2670,9 @@ void TextureCache<P>::SynchronizeAliases(ImageId image_id) {
 template <class P>
 void TextureCache<P>::PrepareImage(ImageId image_id, bool is_modification, bool invalidate) {
     Image& image = slot_images[image_id];
+    if (image.eviction_pending) {
+        CancelEviction(image_id);
+    }
     if (invalidate) {
         image.flags &= ~(ImageFlagBits::CpuModified | ImageFlagBits::GpuModified);
         if (False(image.flags & ImageFlagBits::Tracked)) {

src/video_core/texture_cache/texture_cache_base.h

@@ -109,6 +109,7 @@ class TextureCache : public VideoCommon::ChannelSetupCaches<TextureCacheChannelI
     static constexpr bool HAS_DEVICE_MEMORY_INFO = P::HAS_DEVICE_MEMORY_INFO;
     /// True when the API can do asynchronous texture downloads.
     static constexpr bool IMPLEMENTS_ASYNC_DOWNLOADS = P::IMPLEMENTS_ASYNC_DOWNLOADS;
+    static constexpr bool USE_UNIFIED_MEMORY = P::USE_UNIFIED_MEMORY;
 
     static constexpr size_t UNSET_CHANNEL{(std::numeric_limits<size_t>::max)()};
 
@@ -121,6 +122,7 @@ class TextureCache : public VideoCommon::ChannelSetupCaches<TextureCacheChannelI
     static constexpr s64 DEFAULT_EXPECTED_MEMORY = 1_GiB + 125_MiB;
     static constexpr s64 DEFAULT_CRITICAL_MEMORY = 1_GiB + 625_MiB;
     static constexpr size_t GC_EMERGENCY_COUNTS = 2;
+    static constexpr size_t MAX_GC_DOWNLOADS_PER_PASS = 4;
 
     using Runtime = typename P::Runtime;
     using Image = typename P::Image;
@@ -308,6 +310,18 @@ private:
 
     void RefreshContents(Image& image, ImageId image_id);
 
+    [[nodiscard]] std::optional<u64> ResolveUnifiedImageOffset(const ImageBase& image);
+
+    bool TryUploadFromUnifiedMemory(Image& image);
+
+    bool TryDownloadToUnifiedMemory(Image& image);
+
+    bool StartEviction(ImageId image_id, Image& image);
+
+    void FinishEvictions();
+
+    void CancelEviction(ImageId image_id);
+
     /// Upload data from guest to an image
     template <typename StagingBuffer>
     void UploadImageContents(Image& image, StagingBuffer& staging_buffer);
@@ -484,6 +498,7 @@ private:
     std::vector<AsyncBuffer> uncommitted_async_buffers;
     std::deque<std::vector<AsyncBuffer>> async_buffers;
     std::deque<AsyncBuffer> async_buffers_death_ring;
+    std::vector<std::pair<ImageId, AsyncBuffer>> eviction_staging;
 
     struct LRUItemParams {
         using ObjectType = ImageId;

src/video_core/vulkan_common/vulkan_device.cpp

@@ -21,6 +21,7 @@
 #include "common/assert.h"
 #include "common/fs/fs.h"
 #include "common/fs/path_util.h"
+#include "common/host_memory.h"
 #include "common/literals.h"
 #include <ranges>
 #include "common/settings.h"
@@ -1045,6 +1046,7 @@ bool Device::GetSuitability(bool requires_swapchain) {
 
     FOR_EACH_VK_FEATURE_EXT(FEATURE_EXTENSION);
     FOR_EACH_VK_EXTENSION(EXTENSION);
+    FOR_EACH_VK_PLATFORM_EXTENSION(EXTENSION);
 
     extensions.depth_stencil_resolve =
         extensions.depth_stencil_resolve &&
@@ -1063,6 +1065,13 @@ bool Device::GetSuitability(bool requires_swapchain) {
         extensions.robustness_2 = false;
     }
 
+#ifdef __ANDROID__
+    if (extensions.external_memory_ahb && !extensions.queue_family_foreign) {
+        loaded_extensions.erase(VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME);
+        extensions.external_memory_ahb = false;
+    }
+#endif
+
 #undef FEATURE_EXTENSION
 #undef EXTENSION
 
@@ -1229,6 +1238,21 @@ bool Device::GetSuitability(bool requires_swapchain) {
             VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
         SetNext(next, properties.custom_border_color);
     }
+    if (extensions.external_memory_host) {
+        properties.external_memory_host.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
+        SetNext(next, properties.external_memory_host);
+    }
+    if (extensions.maintenance3 || instance_version >= VK_API_VERSION_1_1) {
+        properties.maintenance3.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
+        SetNext(next, properties.maintenance3);
+    }
+    if (extensions.maintenance4 || features.maintenance4.maintenance4) {
+        properties.maintenance4.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
+        SetNext(next, properties.maintenance4);
+    }
 
     // Perform the property fetch.
     physical.GetProperties2(properties2);
@@ -1623,12 +1647,27 @@ void Device::CollectPhysicalMemoryInfo() {
     device_access_memory = 0;
     u64 device_initial_usage = 0;
     u64 local_memory = 0;
+    const auto heap_has_usable_type = [&mem_properties](size_t heap) {
+        for (u32 index = 0; index < mem_properties.memoryTypeCount; ++index) {
+            if (mem_properties.memoryTypes[index].heapIndex != heap) {
+                continue;
+            }
+            if ((mem_properties.memoryTypes[index].propertyFlags &
+                 VK_MEMORY_PROPERTY_PROTECTED_BIT) == 0) {
+                return true;
+            }
+        }
+        return false;
+    };
     for (size_t element = 0; element < num_properties; ++element) {
         const bool is_heap_local =
             (mem_properties.memoryHeaps[element].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0;
         if (!is_integrated && !is_heap_local) {
             continue;
         }
+        if (!heap_has_usable_type(element)) {
+            continue;
+        }
         valid_heap_memory.push_back(element);
         if (is_heap_local) {
             local_memory += mem_properties.memoryHeaps[element].size;
@@ -1640,6 +1679,12 @@ void Device::CollectPhysicalMemoryInfo() {
         }
         device_access_memory += mem_properties.memoryHeaps[element].size;
     }
+    const u64 committed_backing = Common::GetCommittedBackingSize();
+    if (committed_backing != 0) {
+        LOG_INFO(Render_Vulkan, "Discounting {} MiB of guest memory committed by the host",
+                 committed_backing >> 20);
+        local_memory -= (std::min)(local_memory, committed_backing);
+    }
     if (is_integrated) {
         const s64 available_memory = static_cast<s64>(device_access_memory - device_initial_usage);
         const u64 memory_size = Settings::values.vram_usage_mode.GetValue() == Settings::VramUsageMode::Aggressive ? 6_GiB : 4_GiB;
@@ -1654,6 +1699,7 @@ void Device::CollectPhysicalMemoryInfo() {
             device_access_memory = std::min<u64>(device_access_memory, normal_memory + scaler_memory);
         }
     }
+    device_access_memory -= (std::min)(device_access_memory, committed_backing);
 }
 
 void Device::CollectToolingInfo() {

src/video_core/vulkan_common/vulkan_device.h

@@ -86,6 +86,7 @@ VK_DEFINE_HANDLE(VmaAllocator)
     EXTENSION(EXT, CONDITIONAL_RENDERING, conditional_rendering)                                   \
     EXTENSION(EXT, CONSERVATIVE_RASTERIZATION, conservative_rasterization)                         \
     EXTENSION(EXT, DEPTH_RANGE_UNRESTRICTED, depth_range_unrestricted)                             \
+    EXTENSION(EXT, EXTERNAL_MEMORY_HOST, external_memory_host)                                     \
     EXTENSION(EXT, MEMORY_BUDGET, memory_budget)                                                   \
     EXTENSION(EXT, ROBUSTNESS_2, robustness_2)                                                     \
     EXTENSION(EXT, SAMPLER_FILTER_MINMAX, sampler_filter_minmax)                                   \
@@ -117,6 +118,14 @@ VK_DEFINE_HANDLE(VmaAllocator)
     EXTENSION(IMG, FILTER_CUBIC, filter_cubic_img)                                                 \
     EXTENSION(QCOM, FILTER_CUBIC_WEIGHTS, filter_cubic_weights)
 
+#ifdef __ANDROID__
+#define FOR_EACH_VK_PLATFORM_EXTENSION(EXTENSION)                                                  \
+    EXTENSION(EXT, QUEUE_FAMILY_FOREIGN, queue_family_foreign)                                     \
+    EXTENSION(ANDROID, EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER, external_memory_ahb)
+#else
+#define FOR_EACH_VK_PLATFORM_EXTENSION(EXTENSION)
+#endif
+
 // Define extensions which must be supported.
 #define FOR_EACH_VK_MANDATORY_EXTENSION(EXTENSION_NAME)                                            \
     EXTENSION_NAME(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)                                 \
@@ -891,6 +900,34 @@ FN_MAX_LIMIT_LIST
         return extensions.conditional_rendering;
     }
 
+    bool IsExtExternalMemoryHostSupported() const {
+        return extensions.external_memory_host;
+    }
+
+    bool IsExtExternalMemoryAhbSupported() const {
+#ifdef __ANDROID__
+        return extensions.external_memory_ahb && extensions.queue_family_foreign;
+#else
+        return false;
+#endif
+    }
+
+    u64 GetMinImportedHostPointerAlignment() const {
+        return properties.external_memory_host.minImportedHostPointerAlignment;
+    }
+
+    u64 GetMaxBufferSize() const {
+        return properties.maintenance4.maxBufferSize;
+    }
+
+    u64 GetSparseAddressSpaceSize() const {
+        return properties.properties.limits.sparseAddressSpaceSize;
+    }
+
+    u64 GetMaxMemoryAllocationSize() const {
+        return properties.maintenance3.maxMemoryAllocationSize;
+    }
+
     bool IsExtAstcDecodeModeSupported() const {
         return extensions.astc_decode_mode;
     }
@@ -1163,6 +1200,7 @@ private:
         FOR_EACH_VK_FEATURE_1_4(FEATURE);
         FOR_EACH_VK_FEATURE_EXT(FEATURE);
         FOR_EACH_VK_EXTENSION(EXTENSION);
+        FOR_EACH_VK_PLATFORM_EXTENSION(EXTENSION);
 
 #undef EXTENSION
 #undef FEATURE
@@ -1194,9 +1232,12 @@ private:
         VkPhysicalDeviceDescriptorBufferPropertiesEXT descriptor_buffer{};
         VkPhysicalDeviceSubgroupSizeControlProperties subgroup_size_control{};
         VkPhysicalDeviceTransformFeedbackPropertiesEXT transform_feedback{};
+        VkPhysicalDeviceMaintenance3Properties maintenance3{};
+        VkPhysicalDeviceMaintenance4Properties maintenance4{};
         VkPhysicalDeviceMaintenance5PropertiesKHR maintenance5{};
         VkPhysicalDeviceDepthStencilResolveProperties depth_stencil_resolve{};
         VkPhysicalDeviceCustomBorderColorPropertiesEXT custom_border_color{};
+        VkPhysicalDeviceExternalMemoryHostPropertiesEXT external_memory_host{};
 
         VkPhysicalDeviceProperties properties{};
     };

src/video_core/vulkan_common/vulkan_memory_allocator.cpp

@@ -25,9 +25,34 @@
 #include "video_core/gpu_logging/gpu_logging.h"
 #include "common/settings.h"
 
+#ifdef __ANDROID__
+#include <android/hardware_buffer.h>
+#endif
+
 namespace Vulkan {
 namespace {
 
+        [[nodiscard]] std::optional<u32> FindImportMemoryType(
+                const VkPhysicalDeviceMemoryProperties &props, u32 type_mask) {
+            const auto find = [&](VkMemoryPropertyFlags wanted) -> std::optional<u32> {
+                for (u32 i = 0; i < props.memoryTypeCount; ++i) {
+                    if (((type_mask >> i) & 1u) != 0 &&
+                        (props.memoryTypes[i].propertyFlags & wanted) == wanted) {
+                        return i;
+                    }
+                }
+                return std::nullopt;
+            };
+            auto type_index = find(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                                   VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
+                                   VK_MEMORY_PROPERTY_HOST_CACHED_BIT);
+            if (!type_index) {
+                type_index = find(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                                  VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+            }
+            return type_index;
+        }
+
 // Helpers translating MemoryUsage to flags/usage
 
     [[maybe_unused]] VkMemoryPropertyFlags MemoryUsagePropertyFlags(MemoryUsage usage) {
@@ -181,6 +206,512 @@ void MemoryCommit::Release() {
     size = 0;
 }
 
+HostMemoryImport::HostMemoryImport(const Device &device_, void *base, size_t size,
+                                   std::span<AHardwareBuffer *const> hardware_buffers,
+                                   size_t hardware_buffer_window, size_t hardware_buffer_base)
+        : device{device_} {
+    if (ImportHardwareBuffers(hardware_buffers, hardware_buffer_window, hardware_buffer_base,
+                              size)) {
+        return;
+    }
+        if (device.IsTiler()) {
+            return;
+        }
+        if (!hardware_buffers.empty()) {
+        return;
+    }
+    if (ImportHostPointer(base, size)) {
+        return;
+    }
+    LOG_INFO(Render_Vulkan, "Unified memory disabled, no host memory import path");
+}
+
+bool HostMemoryImport::ImportHostPointer(void *base, size_t size) {
+    if (!device.IsExtExternalMemoryHostSupported()) {
+        return false;
+    }
+    const u64 alignment = device.GetMinImportedHostPointerAlignment();
+    if (alignment == 0 || !Common::IsAligned(reinterpret_cast<uintptr_t>(base), alignment) ||
+        !Common::IsAligned(size, alignment)) {
+        return false;
+    }
+    using namespace Common::Literals;
+        constexpr VkDeviceSize DesktopWindowSize = 4_GiB;
+        VkDeviceSize candidate_window = DesktopWindowSize;
+    const u64 max_buffer_size = device.GetMaxBufferSize();
+    if (max_buffer_size != 0 && max_buffer_size < candidate_window) {
+        candidate_window = max_buffer_size;
+    }
+    const u64 max_allocation_size = device.GetMaxMemoryAllocationSize();
+    if (max_allocation_size != 0 && max_allocation_size < candidate_window) {
+        candidate_window = max_allocation_size;
+    }
+    candidate_window = Common::AlignDown(candidate_window, alignment);
+    if (candidate_window == 0) {
+        return false;
+    }
+    window_size = candidate_window;
+    buffer_usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+    const auto &logical = device.GetLogical();
+    const auto memory_props = device.GetPhysical().GetMemoryProperties().memoryProperties;
+
+    for (size_t offset = 0; offset < size; offset += window_size) {
+        u8 *const window_base = static_cast<u8 *>(base) + offset;
+        const VkDeviceSize window_len =
+                (std::min)(static_cast<VkDeviceSize>(size - offset), window_size);
+        VkMemoryHostPointerPropertiesEXT host_props{
+                .sType = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
+                .pNext = nullptr,
+                .memoryTypeBits = 0,
+        };
+        if (logical.GetMemoryHostPointerPropertiesEXT(
+                    VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, window_base,
+                    &host_props) != VK_SUCCESS ||
+            host_props.memoryTypeBits == 0) {
+            break;
+        }
+        const VkExternalMemoryBufferCreateInfo external_info{
+                .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
+                .pNext = nullptr,
+                .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
+        };
+        const VkBufferCreateInfo buffer_ci{
+                .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+                .pNext = &external_info,
+                .flags = 0,
+                .size = window_len,
+                .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+                .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+                .queueFamilyIndexCount = 0,
+                .pQueueFamilyIndices = nullptr,
+        };
+        VkBuffer new_buffer{};
+        if (logical.CreateBufferRaw(buffer_ci, &new_buffer) != VK_SUCCESS) {
+            break;
+        }
+        const VkMemoryRequirements requirements =
+                logical.GetBufferMemoryRequirements(new_buffer);
+        const u32 type_mask = requirements.memoryTypeBits & host_props.memoryTypeBits;
+        if (type_mask == 0 || requirements.size > window_len) {
+            logical.DestroyBufferRaw(new_buffer);
+            break;
+        }
+        const auto type_index = FindImportMemoryType(memory_props, type_mask);
+        if (!type_index) {
+            logical.DestroyBufferRaw(new_buffer);
+            break;
+        }
+        const u32 heap_index = memory_props.memoryTypes[*type_index].heapIndex;
+        const VkDeviceSize heap_size = memory_props.memoryHeaps[heap_index].size;
+            if (imported_size + window_len > heap_size / 2) {
+            logical.DestroyBufferRaw(new_buffer);
+            break;
+        }
+        const VkImportMemoryHostPointerInfoEXT import_info{
+                .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
+                .pNext = nullptr,
+                .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
+                .pHostPointer = window_base,
+        };
+        const VkMemoryAllocateInfo alloc_info{
+                .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+                .pNext = &import_info,
+                .allocationSize = window_len,
+                .memoryTypeIndex = *type_index,
+        };
+        vk::DeviceMemory memory = logical.TryAllocateMemory(alloc_info);
+        if (!memory) {
+            logical.DestroyBufferRaw(new_buffer);
+            break;
+        }
+        if (logical.BindBufferMemory(new_buffer, *memory, 0) != VK_SUCCESS) {
+            logical.DestroyBufferRaw(new_buffer);
+            break;
+        }
+        windows.push_back(Window{
+                .memory = std::move(memory),
+                .buffer = new_buffer,
+                .address = 0,
+                .size = window_len,
+                .memory_type = *type_index,
+        });
+        imported_size += static_cast<size_t>(window_len);
+    }
+    if (windows.empty()) {
+        return false;
+    }
+    return true;
+}
+
+bool HostMemoryImport::ImportHardwareBuffers(
+        [[maybe_unused]] std::span<AHardwareBuffer *const> hardware_buffers,
+        [[maybe_unused]] size_t hardware_buffer_window,
+        [[maybe_unused]] size_t hardware_buffer_base, [[maybe_unused]] size_t size) {
+#ifdef __ANDROID__
+    if (hardware_buffers.empty() || hardware_buffer_window == 0 ||
+        !device.IsExtExternalMemoryAhbSupported()) {
+        return false;
+    }
+        const u64 max_allocation_size = device.GetMaxMemoryAllocationSize();
+    if (max_allocation_size != 0 && hardware_buffer_window > max_allocation_size) {
+        return false;
+    }
+    if (hardware_buffer_base >= size) {
+        return false;
+    }
+    const auto &logical = device.GetLogical();
+    const auto memory_props = device.GetPhysical().GetMemoryProperties().memoryProperties;
+    window_size = hardware_buffer_window;
+    base_offset = hardware_buffer_base;
+
+        const auto import_all = [&](VkBufferUsageFlags usage, bool want_address, bool dedicated) {
+    for (size_t i = 0; i < hardware_buffers.size(); ++i) {
+        const size_t offset = hardware_buffer_base + i * hardware_buffer_window;
+        if (offset >= size) {
+            break;
+        }
+        const VkDeviceSize window_len = (std::min)(
+                static_cast<VkDeviceSize>(size - offset),
+                static_cast<VkDeviceSize>(hardware_buffer_window));
+        VkAndroidHardwareBufferPropertiesANDROID ahb_props{
+                .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
+                .pNext = nullptr,
+                .allocationSize = 0,
+                .memoryTypeBits = 0,
+        };
+        if (logical.GetAndroidHardwareBufferPropertiesANDROID(hardware_buffers[i],
+                                                              &ahb_props) != VK_SUCCESS ||
+            ahb_props.memoryTypeBits == 0 || ahb_props.allocationSize < window_len) {
+            break;
+        }
+        const VkExternalMemoryBufferCreateInfo external_info{
+                .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
+                .pNext = nullptr,
+                .handleTypes =
+                        VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
+        };
+        const VkBufferCreateInfo buffer_ci{
+                .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+                .pNext = &external_info,
+                .flags = 0,
+                .size = window_len,
+                        .usage = usage,
+                .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+                .queueFamilyIndexCount = 0,
+                .pQueueFamilyIndices = nullptr,
+        };
+        VkBuffer new_buffer{};
+        if (logical.CreateBufferRaw(buffer_ci, &new_buffer) != VK_SUCCESS) {
+            break;
+        }
+        const VkMemoryRequirements requirements =
+                logical.GetBufferMemoryRequirements(new_buffer);
+        const u32 type_mask = requirements.memoryTypeBits & ahb_props.memoryTypeBits;
+        if (type_mask == 0 || requirements.size > ahb_props.allocationSize) {
+            logical.DestroyBufferRaw(new_buffer);
+            break;
+        }
+        const auto type_index = FindImportMemoryType(memory_props, type_mask);
+        if (!type_index) {
+            logical.DestroyBufferRaw(new_buffer);
+            break;
+        }
+        const VkImportAndroidHardwareBufferInfoANDROID import_info{
+                .sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
+                .pNext = nullptr,
+                .buffer = hardware_buffers[i],
+        };
+        const VkMemoryDedicatedAllocateInfo dedicated_info{
+                .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
+                .pNext = &import_info,
+                .image = VK_NULL_HANDLE,
+                .buffer = new_buffer,
+        };
+                const void *memory_next = &import_info;
+                if (dedicated) {
+                    memory_next = &dedicated_info;
+                }
+                const VkMemoryAllocateFlagsInfo flags_info{
+                        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
+                        .pNext = memory_next,
+                        .flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
+                        .deviceMask = 0,
+                };
+                const void *alloc_next = memory_next;
+                if (want_address) {
+                    alloc_next = &flags_info;
+                }
+        const VkMemoryAllocateInfo alloc_info{
+                .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+                        .pNext = alloc_next,
+                .allocationSize = ahb_props.allocationSize,
+                .memoryTypeIndex = *type_index,
+        };
+        vk::DeviceMemory memory = logical.TryAllocateMemory(alloc_info);
+        if (!memory) {
+            logical.DestroyBufferRaw(new_buffer);
+            break;
+        }
+        if (logical.BindBufferMemory(new_buffer, *memory, 0) != VK_SUCCESS) {
+            logical.DestroyBufferRaw(new_buffer);
+            break;
+        }
+                VkDeviceAddress address = 0;
+                if (want_address) {
+                    address = logical.GetBufferDeviceAddress(new_buffer);
+                }
+        windows.push_back(Window{
+                .memory = std::move(memory),
+                .buffer = new_buffer,
+                        .address = address,
+                        .size = window_len,
+                        .memory_type = *type_index,
+        });
+        imported_size += static_cast<size_t>(window_len);
+    }
+            return !windows.empty();
+        };
+
+        constexpr VkBufferUsageFlags TransferUsage =
+                VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+        VkBufferUsageFlags shader_usage = TransferUsage |
+                VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT |
+                VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT |
+                VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT |
+                VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
+        const bool want_address = device.IsBufferDeviceAddressSupported();
+        VkBufferUsageFlags minimal_usage = TransferUsage | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+        if (want_address) {
+            shader_usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
+            minimal_usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
+        }
+
+        const auto reset_windows = [&] {
+            for (Window &window : windows) {
+                if (window.buffer != VK_NULL_HANDLE) {
+                    logical.DestroyBufferRaw(window.buffer);
+                }
+            }
+            windows.clear();
+            imported_size = 0;
+        };
+
+        mirror_capable = SupportsMirror(shader_usage);
+        buffer_usage = shader_usage;
+        bindable = import_all(shader_usage, want_address, !mirror_capable);
+        if (!bindable && mirror_capable) {
+            mirror_capable = false;
+            reset_windows();
+            bindable = import_all(shader_usage, want_address, true);
+        }
+        if (bindable) {
+            mirror_usage = shader_usage;
+        }
+        if (!bindable) {
+            reset_windows();
+            buffer_usage = minimal_usage;
+            bindable = import_all(minimal_usage, want_address, true);
+        }
+        if (!bindable) {
+            reset_windows();
+            buffer_usage = TransferUsage;
+            import_all(TransferUsage, false, true);
+        }
+    if (windows.empty()) {
+        window_size = 0;
+        base_offset = 0;
+        return false;
+    }
+    foreign_ownership = true;
+    return true;
+#else
+    return false;
+#endif
+}
+
+bool HostMemoryImport::SupportsMirror([[maybe_unused]] VkBufferUsageFlags usage) const {
+#ifdef __ANDROID__
+    if (!device.IsSparseBindingSupported()) {
+        return false;
+    }
+    const auto supports = [&](VkBufferCreateFlags flags) {
+        const VkExternalMemoryProperties properties =
+                device.GetPhysical().GetExternalBufferProperties(
+                        flags, usage,
+                        VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID);
+        const VkExternalMemoryFeatureFlags features = properties.externalMemoryFeatures;
+        return (features & VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT) != 0 &&
+               (features & VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) == 0;
+    };
+    return supports(0) && supports(VK_BUFFER_CREATE_SPARSE_BINDING_BIT);
+#else
+    return false;
+#endif
+}
+
+std::optional<HostMemoryImport::Range> HostMemoryImport::ResolveRange(
+        VkDeviceSize relative, VkDeviceSize size) const noexcept {
+    if (window_size == 0 || size == 0 || relative >= imported_size ||
+        imported_size - relative < size) {
+        return std::nullopt;
+    }
+    const size_t index = static_cast<size_t>(relative / window_size);
+    const VkDeviceSize local_offset = relative % window_size;
+    if (index < windows.size() && windows[index].buffer != VK_NULL_HANDLE &&
+        local_offset < windows[index].size && windows[index].size - local_offset >= size) {
+        return Range{
+                .buffer = windows[index].buffer,
+                .address = windows[index].address,
+                .offset = local_offset,
+        };
+    }
+    if (mirror_buffer != VK_NULL_HANDLE && relative < mirror_size &&
+        mirror_size - relative >= size) {
+        return Range{
+                .buffer = mirror_buffer,
+                .address = mirror_address,
+                .offset = relative,
+        };
+    }
+    return std::nullopt;
+}
+
+std::optional<HostMemoryImport::ViewMemory> HostMemoryImport::ResolveViewMemory(
+        VkDeviceSize relative) const noexcept {
+    if (!mirror_capable || !bindable || window_size == 0) {
+        return std::nullopt;
+    }
+    const size_t index = static_cast<size_t>(relative / window_size);
+    if (index >= windows.size()) {
+        return std::nullopt;
+    }
+    const Window &window = windows[index];
+    const VkDeviceSize local_offset = relative % window_size;
+    if (window.buffer == VK_NULL_HANDLE || local_offset >= window.size) {
+        return std::nullopt;
+    }
+    return ViewMemory{
+            .buffer = window.buffer,
+            .memory = *window.memory,
+            .offset = local_offset,
+            .available = window.size - local_offset,
+            .memory_type = window.memory_type,
+    };
+}
+
+void HostMemoryImport::CreateMirror(std::mutex &submit_mutex, VkDeviceSize max_size) {
+    if (!mirror_capable || mirror_usage == 0 || !bindable || window_size == 0) {
+        return;
+    }
+    size_t mirror_windows = 0;
+    while (mirror_windows < windows.size() && windows[mirror_windows].size == window_size) {
+        ++mirror_windows;
+    }
+    mirror_windows = (std::min)(mirror_windows, static_cast<size_t>(max_size / window_size));
+    const u64 max_buffer_size = device.GetMaxBufferSize();
+    if (max_buffer_size != 0) {
+        const size_t max_windows = static_cast<size_t>(max_buffer_size / window_size);
+        mirror_windows = (std::min)(mirror_windows, max_windows);
+    }
+    if (mirror_windows < 2) {
+        return;
+    }
+    const auto &logical = device.GetLogical();
+    const VkDeviceSize total_size = static_cast<VkDeviceSize>(mirror_windows) * window_size;
+    const VkExternalMemoryBufferCreateInfo external_info{
+            .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
+            .pNext = nullptr,
+            .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
+    };
+    const VkBufferCreateInfo buffer_ci{
+            .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+            .pNext = &external_info,
+            .flags = VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
+            .size = total_size,
+            .usage = mirror_usage,
+            .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+            .queueFamilyIndexCount = 0,
+            .pQueueFamilyIndices = nullptr,
+    };
+    VkBuffer buffer{};
+    if (logical.CreateBufferRaw(buffer_ci, &buffer) != VK_SUCCESS) {
+        return;
+    }
+    const VkMemoryRequirements requirements = logical.GetBufferMemoryRequirements(buffer);
+    bool compatible = requirements.alignment != 0 &&
+                      (window_size % requirements.alignment) == 0 &&
+                      requirements.size <= total_size;
+    for (size_t index = 0; index < mirror_windows && compatible; ++index) {
+        compatible = ((requirements.memoryTypeBits >> windows[index].memory_type) & 1u) != 0;
+    }
+    if (!compatible) {
+        logical.DestroyBufferRaw(buffer);
+        return;
+    }
+    std::vector<VkSparseMemoryBind> binds;
+    binds.reserve(mirror_windows);
+    for (size_t index = 0; index < mirror_windows; ++index) {
+        binds.push_back(VkSparseMemoryBind{
+                .resourceOffset = static_cast<VkDeviceSize>(index) * window_size,
+                .size = window_size,
+                .memory = *windows[index].memory,
+                .memoryOffset = 0,
+                .flags = 0,
+        });
+    }
+    const VkSparseBufferMemoryBindInfo buffer_bind{
+            .buffer = buffer,
+            .bindCount = static_cast<u32>(binds.size()),
+            .pBinds = binds.data(),
+    };
+    const VkBindSparseInfo bind_info{
+            .sType = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,
+            .pNext = nullptr,
+            .waitSemaphoreCount = 0,
+            .pWaitSemaphores = nullptr,
+            .bufferBindCount = 1,
+            .pBufferBinds = &buffer_bind,
+            .imageOpaqueBindCount = 0,
+            .pImageOpaqueBinds = nullptr,
+            .imageBindCount = 0,
+            .pImageBinds = nullptr,
+            .signalSemaphoreCount = 0,
+            .pSignalSemaphores = nullptr,
+    };
+    vk::Fence fence = logical.CreateFence(VkFenceCreateInfo{
+            .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
+            .pNext = nullptr,
+            .flags = 0,
+    });
+    VkResult result = VK_ERROR_UNKNOWN;
+    {
+        std::scoped_lock lock{submit_mutex};
+        result = device.GetGraphicsQueue().BindSparse(bind_info, *fence);
+    }
+    if (result != VK_SUCCESS) {
+        logical.DestroyBufferRaw(buffer);
+        return;
+    }
+    fence.Wait();
+    mirror_buffer = buffer;
+    mirror_size = total_size;
+    if ((mirror_usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) != 0) {
+        mirror_address = logical.GetBufferDeviceAddress(buffer);
+    }
+}
+
+HostMemoryImport::~HostMemoryImport() {
+    if (mirror_buffer != VK_NULL_HANDLE) {
+        device.GetLogical().DestroyBufferRaw(mirror_buffer);
+    }
+    for (Window &window : windows) {
+        if (window.buffer != VK_NULL_HANDLE) {
+            device.GetLogical().DestroyBufferRaw(window.buffer);
+        }
+    }
+}
+
 MemoryAllocator::MemoryAllocator(const Device &device_)
         : device{device_}, allocator{device.GetAllocator()},
             properties{device_.GetPhysical().GetMemoryProperties().memoryProperties},
@@ -367,6 +898,17 @@ MemoryCommit MemoryAllocator::Commit(const VkMemoryRequirements &reqs, MemoryUsa
     return MemoryCommit(allocator, a, info);
 }
 
+HostMemoryImport *MemoryAllocator::CreateHostMemoryImport(
+    void *base, size_t size, std::span<AHardwareBuffer *const> hardware_buffers,
+    size_t hardware_buffer_window, size_t hardware_buffer_base) {
+    unified_memory = std::make_unique<HostMemoryImport>(
+        device, base, size, hardware_buffers, hardware_buffer_window, hardware_buffer_base);
+    if (!unified_memory->IsValid()) {
+        unified_memory.reset();
+    }
+    return unified_memory.get();
+}
+
 MemoryCommit MemoryAllocator::Commit(const vk::Buffer &buffer, MemoryUsage usage) {
     // Allocate memory appropriate for this buffer automatically
     const auto vma_usage = MemoryUsageVma(usage);

src/video_core/vulkan_common/vulkan_memory_allocator.h

@@ -7,6 +7,8 @@
 #pragma once
 
 #include <memory>
+#include <mutex>
+#include <optional>
 #include <span>
 #include <vector>
 
@@ -15,6 +17,8 @@
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 #include "video_core/vulkan_common/vma.h"
 
+struct AHardwareBuffer;
+
 namespace Vulkan {
 
     class Device;
@@ -84,6 +88,123 @@ namespace Vulkan {
         void *mapped_ptr{};  ///< Optional persistent mapped pointer
     };
 
+    class HostMemoryImport {
+    public:
+        explicit HostMemoryImport(const Device &device_, void *base, size_t size,
+                                  std::span<AHardwareBuffer *const> hardware_buffers,
+                                  size_t hardware_buffer_window, size_t hardware_buffer_base);
+
+        ~HostMemoryImport();
+
+        HostMemoryImport(const HostMemoryImport &) = delete;
+
+        HostMemoryImport &operator=(const HostMemoryImport &) = delete;
+
+        [[nodiscard]] bool IsValid() const noexcept {
+            return !windows.empty();
+        }
+
+        [[nodiscard]] size_t GetSize() const noexcept {
+            return imported_size;
+        }
+
+        [[nodiscard]] size_t GetBaseOffset() const noexcept {
+            return base_offset;
+        }
+
+        [[nodiscard]] bool NeedsForeignOwnershipTransfer() const noexcept {
+            return foreign_ownership;
+        }
+
+        [[nodiscard]] VkDeviceSize GetWindowSize() const noexcept {
+            return window_size;
+        }
+
+        [[nodiscard]] VkBuffer GetWindowBuffer(size_t index) const noexcept {
+            return windows[index].buffer;
+        }
+
+        [[nodiscard]] VkDeviceAddress GetWindowAddress(size_t index) const noexcept {
+            return windows[index].address;
+        }
+
+        [[nodiscard]] size_t GetWindowCount() const noexcept {
+            return windows.size();
+        }
+
+        [[nodiscard]] bool IsBindable() const noexcept {
+            return bindable;
+        }
+
+        [[nodiscard]] VkBufferUsageFlags GetUsage() const noexcept {
+            return buffer_usage;
+        }
+
+        struct Range {
+            VkBuffer buffer{};
+            VkDeviceAddress address{};
+            VkDeviceSize offset{};
+        };
+
+        [[nodiscard]] std::optional<Range> ResolveRange(VkDeviceSize relative,
+                                                        VkDeviceSize size) const noexcept;
+
+        struct ViewMemory {
+            VkBuffer buffer{};
+            VkDeviceMemory memory{};
+            VkDeviceSize offset{};
+            VkDeviceSize available{};
+            u32 memory_type{};
+        };
+
+        [[nodiscard]] std::optional<ViewMemory> ResolveViewMemory(
+                VkDeviceSize relative) const noexcept;
+
+        [[nodiscard]] VkBufferUsageFlags GetViewUsage() const noexcept {
+            if (!mirror_capable || !bindable) {
+                return 0;
+            }
+            return mirror_usage;
+        }
+
+        void CreateMirror(std::mutex &submit_mutex, VkDeviceSize max_size);
+
+        [[nodiscard]] VkDeviceSize GetMirrorSize() const noexcept {
+            return mirror_size;
+        }
+
+    private:
+        struct Window {
+            vk::DeviceMemory memory;
+            VkBuffer buffer{};
+            VkDeviceAddress address{};
+            VkDeviceSize size{};
+            u32 memory_type{};
+        };
+
+        [[nodiscard]] bool SupportsMirror(VkBufferUsageFlags usage) const;
+
+        bool ImportHostPointer(void *base, size_t size);
+
+        bool ImportHardwareBuffers(std::span<AHardwareBuffer *const> hardware_buffers,
+                                   size_t hardware_buffer_window, size_t hardware_buffer_base,
+                                   size_t size);
+
+        const Device &device;
+        std::vector<Window> windows;
+        VkDeviceSize window_size{};
+        size_t imported_size{};
+        size_t base_offset{};
+        bool foreign_ownership{};
+        bool bindable{};
+        bool mirror_capable{};
+        VkBufferUsageFlags buffer_usage{};
+        VkBufferUsageFlags mirror_usage{};
+        VkBuffer mirror_buffer{};
+        VkDeviceAddress mirror_address{};
+        VkDeviceSize mirror_size{};
+    };
+
 /// Memory allocator container.
 /// Allocates and releases memory allocations on demand.
     class MemoryAllocator {
@@ -123,6 +244,15 @@ namespace Vulkan {
         /// Commits memory required by the buffer and binds it (for buffers created outside VMA).
         MemoryCommit Commit(const vk::Buffer &buffer, MemoryUsage usage);
 
+        HostMemoryImport *CreateHostMemoryImport(void *base, size_t size,
+                                                 std::span<AHardwareBuffer *const> hardware_buffers,
+                                                 size_t hardware_buffer_window,
+                                                 size_t hardware_buffer_base);
+
+        [[nodiscard]] HostMemoryImport *GetHostMemoryImport() const noexcept {
+            return unified_memory.get();
+        }
+
     private:
         static bool IsAutoUsage(VmaMemoryUsage u) noexcept {
             switch (u) {
@@ -140,6 +270,7 @@ namespace Vulkan {
         const VkPhysicalDeviceMemoryProperties properties; ///< Physical device memory properties.
         VkDeviceSize buffer_image_granularity;            ///< Adjacent buffer/image granularity
         u32 valid_memory_types{~0u};
+        std::unique_ptr<HostMemoryImport> unified_memory;
     };
 
 } // namespace Vulkan

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -217,12 +217,16 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkGetBufferMemoryRequirements2);
     X(vkGetDeviceQueue);
     X(vkGetEventStatus);
+    X(vkGetMemoryHostPointerPropertiesEXT);
     X(vkGetFenceStatus);
     X(vkGetImageMemoryRequirements);
     X(vkGetPipelineCacheData);
     X(vkGetMemoryFdKHR);
 #ifdef _WIN32
     X(vkGetMemoryWin32HandleKHR);
+#endif
+#ifdef __ANDROID__
+    X(vkGetAndroidHardwareBufferPropertiesANDROID);
 #endif
     X(vkGetQueryPoolResults);
     X(vkGetPipelineExecutablePropertiesKHR);
@@ -312,6 +316,7 @@ bool Load(VkInstance instance, InstanceDispatch& dld) noexcept {
     X(vkDestroyDebugUtilsMessengerEXT);
     X(vkDestroyDebugReportCallbackEXT);
     X(vkDestroySurfaceKHR);
+    X(vkGetPhysicalDeviceExternalBufferProperties);
     X(vkGetPhysicalDeviceFeatures2);
     X(vkGetPhysicalDeviceFormatProperties2);
     X(vkGetPhysicalDeviceProperties2);
@@ -460,20 +465,8 @@ Instance Instance::Create(u32 version, Span<const char*> layers, Span<const char
 #else
     constexpr VkFlags ci_flags{};
 #endif
-    // DO NOT TOUCH OR CHANGE THE ENGINE NAME/APPLICATION NAME, breaks RNDA3!!
-    // AMD drivers have fixes for Yuzu
-    // if remove => gloom + yellow line glitch appears
-#ifdef __ANDROID__
-    const VkApplicationInfo application_info{
-        .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
-        .pNext = nullptr,
-        .pApplicationName = "PUBGMobile",
-        .applicationVersion = VK_MAKE_VERSION(1, 7, 0),
-        .pEngineName = "UnrealEngine",
-        .engineVersion = VK_MAKE_VERSION(4, 23, 0),
-        .apiVersion = VK_API_VERSION_1_3,
-    };
-#else
+    // DO NOT TOUCH, breaks RNDA3!!
+    // Don't know why, but gloom + yellow line glitch appears
     const VkApplicationInfo application_info{
         .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
         .pNext = nullptr,
@@ -483,7 +476,6 @@ Instance Instance::Create(u32 version, Span<const char*> layers, Span<const char
         .engineVersion = VK_MAKE_VERSION(1, 3, 0),
         .apiVersion = VK_API_VERSION_1_3,
     };
-#endif
     const VkInstanceCreateInfo ci{
         .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
         .pNext = nullptr,
@@ -1034,6 +1026,28 @@ VkPhysicalDeviceMemoryProperties2 PhysicalDevice::GetMemoryProperties(
     return properties;
 }
 
+VkExternalMemoryProperties PhysicalDevice::GetExternalBufferProperties(
+    VkBufferCreateFlags flags, VkBufferUsageFlags usage,
+    VkExternalMemoryHandleTypeFlagBits handle_type) const noexcept {
+    VkExternalBufferProperties properties{
+        .sType = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
+        .pNext = nullptr,
+        .externalMemoryProperties = {},
+    };
+    if (!dld->vkGetPhysicalDeviceExternalBufferProperties) {
+        return properties.externalMemoryProperties;
+    }
+    const VkPhysicalDeviceExternalBufferInfo info{
+        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
+        .pNext = nullptr,
+        .flags = flags,
+        .usage = usage,
+        .handleType = handle_type,
+    };
+    dld->vkGetPhysicalDeviceExternalBufferProperties(physical_device, &info, &properties);
+    return properties.externalMemoryProperties;
+}
+
 u32 AvailableVersion(const InstanceDispatch& dld) noexcept {
     PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion;
     if (!Proc(vkEnumerateInstanceVersion, dld, "vkEnumerateInstanceVersion")) {

src/video_core/vulkan_common/vulkan_wrapper.h

@@ -178,6 +178,7 @@ struct InstanceDispatch {
     PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties{};
     PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices{};
     PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr{};
+    PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties{};
     PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2{};
     PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties{};
     PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2{};
@@ -333,12 +334,16 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2{};
     PFN_vkGetDeviceQueue vkGetDeviceQueue{};
     PFN_vkGetEventStatus vkGetEventStatus{};
+    PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT{};
     PFN_vkGetFenceStatus vkGetFenceStatus{};
     PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements{};
     PFN_vkGetPipelineCacheData vkGetPipelineCacheData{};
     PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR{};
 #ifdef _WIN32
     PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR{};
+#endif
+#ifdef __ANDROID__
+    PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID{};
 #endif
     PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR{};
     PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR{};
@@ -1104,6 +1109,34 @@ public:
     VkMemoryRequirements GetBufferMemoryRequirements(VkBuffer buffer,
                                                      void* pnext = nullptr) const noexcept;
 
+    VkResult GetMemoryHostPointerPropertiesEXT(
+        VkExternalMemoryHandleTypeFlagBits handle_type, const void* host_pointer,
+        VkMemoryHostPointerPropertiesEXT* out_properties) const noexcept {
+        return dld->vkGetMemoryHostPointerPropertiesEXT(handle, handle_type, host_pointer,
+                                                        out_properties);
+    }
+
+#ifdef __ANDROID__
+    VkResult GetAndroidHardwareBufferPropertiesANDROID(
+        const struct AHardwareBuffer* buffer,
+        VkAndroidHardwareBufferPropertiesANDROID* out_properties) const noexcept {
+        return dld->vkGetAndroidHardwareBufferPropertiesANDROID(handle, buffer, out_properties);
+    }
+#endif
+
+    VkResult CreateBufferRaw(const VkBufferCreateInfo& ci, VkBuffer* out_buffer) const noexcept {
+        return dld->vkCreateBuffer(handle, &ci, nullptr, out_buffer);
+    }
+
+    void DestroyBufferRaw(VkBuffer buffer) const noexcept {
+        dld->vkDestroyBuffer(handle, buffer, nullptr);
+    }
+
+    VkResult BindBufferMemory(VkBuffer buffer, VkDeviceMemory memory,
+                              VkDeviceSize offset) const noexcept {
+        return dld->vkBindBufferMemory(handle, buffer, memory, offset);
+    }
+
     VkMemoryRequirements GetImageMemoryRequirements(VkImage image) const noexcept;
 
     std::vector<VkPipelineExecutablePropertiesKHR> GetPipelineExecutablePropertiesKHR(
@@ -1211,6 +1244,10 @@ public:
     VkPhysicalDeviceMemoryProperties2 GetMemoryProperties(
         void* next_structures = nullptr) const noexcept;
 
+    VkExternalMemoryProperties GetExternalBufferProperties(
+        VkBufferCreateFlags flags, VkBufferUsageFlags usage,
+        VkExternalMemoryHandleTypeFlagBits handle_type) const noexcept;
+
 private:
     VkPhysicalDevice physical_device = nullptr;
     const InstanceDispatch* dld = nullptr;

src/yuzu/configuration/configure_graphics.cpp

@@ -37,10 +37,6 @@
 #include "yuzu/configuration/configure_graphics.h"
 #include "yuzu/configuration/shared_widget.h"
 
-#ifdef HAS_RESHADE
-#include "yuzu/configuration/configure_post_processing.h"
-#endif
-
 ConfigureGraphics::ConfigureGraphics(
     const Core::System& system_, std::vector<VkDeviceInfo::Record>& records_,
     const std::function<void()>& expose_compute_option_,
@@ -220,12 +216,6 @@ void ConfigureGraphics::Setup(const ConfigurationShared::Builder& builder) {
     std::vector<QWidget*> hold_api;
 
     for (const auto setting : Settings::values.linkage.by_category[Settings::Category::Renderer]) {
-#ifndef HAS_RESHADE
-        if (setting->Id() == Settings::values.post_shader_enabled.Id()) {
-            continue;
-        }
-#endif
-
         ConfigurationShared::Widget* widget = [&]() {
             if (setting->Id() == Settings::values.fsr_sharpening_slider.Id()) {
                 // FSR needs a reversed slider and a 0.5 multiplier
@@ -305,23 +295,6 @@ void ConfigureGraphics::Setup(const ConfigurationShared::Builder& builder) {
             // Keep track of the resolution combobox to update other UI tabs that need it
             resolution_combobox = widget->combobox;
             hold_graphics.emplace(setting->Id(), widget);
-#ifdef HAS_RESHADE
-        } else if (setting->Id() == Settings::values.post_shader_enabled.Id()) {
-            QPushButton* post_shader_button = new QPushButton(tr("Configure Effects..."), widget);
-            post_shader_button->setVisible(widget->checkbox->isChecked());
-
-            connect(post_shader_button, &QAbstractButton::clicked, this, [this]() {
-                ConfigurePostProcessing dialog(this);
-                dialog.exec();
-            });
-            connect(widget->checkbox, &QCheckBox::toggled, post_shader_button,
-                    &QWidget::setVisible);
-
-            QBoxLayout* row = qobject_cast<QBoxLayout*>(widget->layout());
-            row->insertWidget(1, post_shader_button);
-
-            hold_graphics.emplace(setting->Id(), widget);
-#endif
         } else {
             hold_graphics.emplace(setting->Id(), widget);
         }

src/yuzu/configuration/configure_post_processing.cpp

@@ -70,8 +70,10 @@ ConfigurePostProcessing::ConfigurePostProcessing(QWidget* parent) : QDialog(pare
 
     auto* root = new QVBoxLayout(this);
 
-    auto* description =
-        new QLabel(tr("Changes apply immediately while a game is running."), this);
+    auto* description = new QLabel(
+        tr("ReShade FX effects are loaded from the post_shaders folder in the Eden data "
+           "directory. Changes apply immediately while a game is running."),
+        this);
     description->setWordWrap(true);
     root->addWidget(description);
 
@@ -126,15 +128,17 @@ ConfigurePostProcessing::ConfigurePostProcessing(QWidget* parent) : QDialog(pare
     });
     preset_row->addWidget(save_button);
 
-    auto* clear_button = new QPushButton(tr("Clear"), this);
-    clear_button->setToolTip(tr("Remove every effect in use and deselect the preset."));
-    connect(clear_button, &QPushButton::clicked, this, [this]() {
-        VideoCore::FxChain::Instance().Clear();
-        VideoCore::SetActiveFxPreset(std::string());
-        preset_combo->setCurrentIndex(0);
-        ApplyStructuralChange();
+    auto* delete_button = new QPushButton(tr("Delete"), this);
+    connect(delete_button, &QPushButton::clicked, this, [this]() {
+        const QString name = preset_combo->currentData().toString();
+        if (name.isEmpty()) {
+            return;
+        }
+        VideoCore::DeleteFxPreset(name.toStdString());
+        PopulatePresetCombo();
+        RefreshPresetStatus();
     });
-    preset_row->addWidget(clear_button);
+    preset_row->addWidget(delete_button);
 
     root->addLayout(preset_row);
 
@@ -199,7 +203,6 @@ void ConfigurePostProcessing::ApplyStructuralChange() {
 void ConfigurePostProcessing::PopulatePresetCombo() {
     const QString previous = preset_combo->currentData().toString();
     preset_combo->clear();
-    preset_combo->addItem(tr("None"), QString());
 
     for (const auto& preset : VideoCore::GetFxPresetCatalog()) {
         const QString name = QString::fromStdString(preset.name);
@@ -209,7 +212,7 @@ void ConfigurePostProcessing::PopulatePresetCombo() {
     }
 
     const int restored = preset_combo->findData(previous);
-    if (!previous.isEmpty() && restored >= 0) {
+    if (restored >= 0) {
         preset_combo->setCurrentIndex(restored);
         return;
     }
@@ -217,21 +220,12 @@ void ConfigurePostProcessing::PopulatePresetCombo() {
     const int active = preset_combo->findData(QString::fromStdString(VideoCore::GetActiveFxPreset()));
     if (active >= 0) {
         preset_combo->setCurrentIndex(active);
-        return;
     }
-
-    preset_combo->setCurrentIndex(0);
 }
 
 void ConfigurePostProcessing::RefreshPresetStatus() {
     const std::string active = VideoCore::GetActiveFxPreset();
     if (active.empty()) {
-        if (VideoCore::FxChain::Instance().Size() == 0) {
-            preset_status->setText(
-                tr("No effects in use. Pick a preset and press Apply, or add effects one "
-                   "by one."));
-            return;
-        }
         preset_status->setText(tr("Custom chain. Pick a preset above and press Apply to replace it."));
         return;
     }

src/yuzu/main_window.cpp

@@ -15,7 +15,6 @@
 #include "render/performance_overlay.h"
 #ifdef HAS_RESHADE
 #include "configuration/configure_post_processing.h"
-#include "video_core/post_processing/fx_preset.h"
 #endif
 #include "updater/update_dialog.h"
 
@@ -1091,41 +1090,6 @@ void MainWindow::InitializeWidgets() {
 
     statusBar()->insertPermanentWidget(0, volume_button);
 
-#ifdef HAS_RESHADE
-    post_shader_status_button = new QPushButton();
-    post_shader_status_button->setObjectName(QStringLiteral("TogglableStatusBarButton"));
-    post_shader_status_button->setFocusPolicy(Qt::NoFocus);
-    post_shader_status_button->setCheckable(true);
-    connect(post_shader_status_button, &QPushButton::clicked, this, [this] {
-        const bool enabled = Settings::values.post_shader_enabled.GetValue();
-        Settings::values.post_shader_enabled.SetValue(!enabled);
-        UpdatePostShaderText();
-    });
-    UpdatePostShaderText();
-    post_shader_status_button->setContextMenuPolicy(Qt::CustomContextMenu);
-    connect(post_shader_status_button, &QPushButton::customContextMenuRequested,
-            [this](const QPoint& menu_location) {
-                QMenu context_menu;
-
-                for (auto const& preset : VideoCore::GetFxPresetCatalog()) {
-                    context_menu.addAction(QString::fromStdString(preset.name),
-                                           [this, name = preset.name] {
-                                               VideoCore::ApplyFxPreset(name);
-                                               Settings::values.post_shader_enabled.SetValue(true);
-                                               UpdatePostShaderText();
-                                           });
-                }
-
-                context_menu.addSeparator();
-                context_menu.addAction(tr("Configure Effects..."), this,
-                                       &MainWindow::OnPostProcessingShaders);
-
-                context_menu.exec(post_shader_status_button->mapToGlobal(menu_location));
-                post_shader_status_button->repaint();
-            });
-    statusBar()->insertPermanentWidget(0, post_shader_status_button);
-#endif
-
     // setup AA button
     aa_status_button = new QPushButton();
     aa_status_button->setObjectName(QStringLiteral("TogglableStatusBarButton"));
@@ -3944,7 +3908,6 @@ void MainWindow::OnPostProcessingShaders() {
         connect(post_processing_dialog, &QDialog::finished, post_processing_dialog, [this]() {
             post_processing_dialog->deleteLater();
             post_processing_dialog = nullptr;
-            UpdatePostShaderText();
         });
     }
 
@@ -4299,26 +4262,6 @@ void MainWindow::UpdateAAText() {
                                   : aa_text.toUpper());
 }
 
-#ifdef HAS_RESHADE
-void MainWindow::UpdatePostShaderText() {
-    const bool enabled = Settings::values.post_shader_enabled.GetValue();
-    post_shader_status_button->setChecked(enabled);
-
-    if (!enabled) {
-        post_shader_status_button->setText(tr("NO FX"));
-        return;
-    }
-
-    const std::string preset = VideoCore::GetActiveFxPreset();
-    if (preset.empty()) {
-        post_shader_status_button->setText(tr("FX"));
-        return;
-    }
-
-    post_shader_status_button->setText(QString::fromStdString(preset).toUpper());
-}
-#endif
-
 void MainWindow::UpdateVolumeUI() {
     const auto volume_value = static_cast<int>(Settings::values.volume.GetValue());
     volume_slider->setValue(volume_value);

src/yuzu/main_window.h

@@ -448,7 +448,6 @@ private:
     void UpdateAPIText();
     void UpdateFilterText();
     void UpdateAAText();
-    void UpdatePostShaderText();
     void UpdateVolumeUI();
     void UpdateStatusBar();
     void UpdateGPUAccuracyButton();
@@ -525,7 +524,6 @@ private:
     QPushButton* dock_status_button = nullptr;
     QPushButton* filter_status_button = nullptr;
     QPushButton* aa_status_button = nullptr;
-    QPushButton* post_shader_status_button = nullptr;
     VolumeButton* volume_button = nullptr;
     QWidget* volume_popup = nullptr;
     QSlider* volume_slider = nullptr;