144 files changed, 3591 insertions, 1895 deletions
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index 895ee53f1..a5e71d879 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -44,7 +44,6 @@ add_library(common STATIC
    detached_tasks.cpp
    detached_tasks.h
    bit_field.h
-    bit_set.h
    cityhash.cpp
    cityhash.h
    color.h
diff --git a/src/common/bit_set.h b/src/common/bit_set.h
deleted file mode 100644
index 5cd1352b2..000000000
--- a/src/common/bit_set.h
+++ /dev/null
@@ -1,244 +0,0 @@
-// This file is under the public domain.
-#pragma once
-#include <cstddef>
-#ifdef _WIN32
-#include <intrin.h>
-#endif
-#include <initializer_list>
-#include <new>
-#include <type_traits>
-#include "common/common_types.h"
-// namespace avoids conflict with OS X Carbon; don't use BitSet<T> directly
-namespace Common {
-// Helper functions:
-#ifdef _MSC_VER
-template <typename T>
-static inline int CountSetBits(T v) {
-    // from https://graphics.stanford.edu/~seander/bithacks.html
-    // GCC has this built in, but MSVC's intrinsic will only emit the actual
-    // POPCNT instruction, which we're not depending on
-    v = v - ((v >> 1) & (T) ~(T)0 / 3);
-    v = (v & (T) ~(T)0 / 15 * 3) + ((v >> 2) & (T) ~(T)0 / 15 * 3);
-    v = (v + (v >> 4)) & (T) ~(T)0 / 255 * 15;
-    return (T)(v * ((T) ~(T)0 / 255)) >> (sizeof(T) - 1) * 8;
-}
-static inline int LeastSignificantSetBit(u8 val) {
-    unsigned long index;
-    _BitScanForward(&index, val);
-    return (int)index;
-}
-static inline int LeastSignificantSetBit(u16 val) {
-    unsigned long index;
-    _BitScanForward(&index, val);
-    return (int)index;
-}
-static inline int LeastSignificantSetBit(u32 val) {
-    unsigned long index;
-    _BitScanForward(&index, val);
-    return (int)index;
-}
-static inline int LeastSignificantSetBit(u64 val) {
-    unsigned long index;
-    _BitScanForward64(&index, val);
-    return (int)index;
-}
-#else
-static inline int CountSetBits(u8 val) {
-    return __builtin_popcount(val);
-}
-static inline int CountSetBits(u16 val) {
-    return __builtin_popcount(val);
-}
-static inline int CountSetBits(u32 val) {
-    return __builtin_popcount(val);
-}
-static inline int CountSetBits(u64 val) {
-    return __builtin_popcountll(val);
-}
-static inline int LeastSignificantSetBit(u8 val) {
-    return __builtin_ctz(val);
-}
-static inline int LeastSignificantSetBit(u16 val) {
-    return __builtin_ctz(val);
-}
-static inline int LeastSignificantSetBit(u32 val) {
-    return __builtin_ctz(val);
-}
-static inline int LeastSignificantSetBit(u64 val) {
-    return __builtin_ctzll(val);
-}
-#endif
-// Similar to std::bitset, this is a class which encapsulates a bitset, i.e.
-// using the set bits of an integer to represent a set of integers.  Like that
-// class, it acts like an array of bools:
-//     BitSet32 bs;
-//     bs[1] = true;
-// but also like the underlying integer ([0] = least significant bit):
-//     BitSet32 bs2 = ...;
-//     bs = (bs ^ bs2) & BitSet32(0xffff);
-// The following additional functionality is provided:
-// - Construction using an initializer list.
-//     BitSet bs { 1, 2, 4, 8 };
-// - Efficiently iterating through the set bits:
-//     for (int i : bs)
-//         [i is the *index* of a set bit]
-//   (This uses the appropriate CPU instruction to find the next set bit in one
-//   operation.)
-// - Counting set bits using .Count() - see comment on that method.
-// TODO: use constexpr when MSVC gets out of the Dark Ages
-template <typename IntTy>
-class BitSet {
-    static_assert(!std::is_signed_v<IntTy>, "BitSet should not be used with signed types");
-public:
-    // A reference to a particular bit, returned from operator[].
-    class Ref {
-    public:
-        Ref(Ref&& other) : m_bs(other.m_bs), m_mask(other.m_mask) {}
-        Ref(BitSet* bs, IntTy mask) : m_bs(bs), m_mask(mask) {}
-        operator bool() const {
-            return (m_bs->m_val & m_mask) != 0;
-        }
-        bool operator=(bool set) {
-            m_bs->m_val = (m_bs->m_val & ~m_mask) | (set ? m_mask : 0);
-            return set;
-        }
-    private:
-        BitSet* m_bs;
-        IntTy m_mask;
-    };
-    // A STL-like iterator is required to be able to use range-based for loops.
-    class Iterator {
-    public:
-        Iterator(const Iterator& other) : m_val(other.m_val), m_bit(other.m_bit) {}
-        Iterator(IntTy val) : m_val(val), m_bit(0) {}
-        Iterator& operator=(Iterator other) {
-            new (this) Iterator(other);
-            return *this;
-        }
-        int operator*() {
-            return m_bit + ComputeLsb();
-        }
-        Iterator& operator++() {
-            int lsb = ComputeLsb();
-            m_val >>= lsb + 1;
-            m_bit += lsb + 1;
-            m_has_lsb = false;
-            return *this;
-        }
-        Iterator operator++(int _) {
-            Iterator other(*this);
-            ++*this;
-            return other;
-        }
-        bool operator==(Iterator other) const {
-            return m_val == other.m_val;
-        }
-        bool operator!=(Iterator other) const {
-            return m_val != other.m_val;
-        }
-    private:
-        int ComputeLsb() {
-            if (!m_has_lsb) {
-                m_lsb = LeastSignificantSetBit(m_val);
-                m_has_lsb = true;
-            }
-            return m_lsb;
-        }
-        IntTy m_val;
-        int m_bit;
-        int m_lsb = -1;
-        bool m_has_lsb = false;
-    };
-    BitSet() : m_val(0) {}
-    explicit BitSet(IntTy val) : m_val(val) {}
-    BitSet(std::initializer_list<int> init) {
-        m_val = 0;
-        for (int bit : init)
-            m_val |= (IntTy)1 << bit;
-    }
-    static BitSet AllTrue(std::size_t count) {
-        return BitSet(count == sizeof(IntTy) * 8 ? ~(IntTy)0 : (((IntTy)1 << count) - 1));
-    }
-    Ref operator[](std::size_t bit) {
-        return Ref(this, (IntTy)1 << bit);
-    }
-    const Ref operator[](std::size_t bit) const {
-        return (*const_cast<BitSet*>(this))[bit];
-    }
-    bool operator==(BitSet other) const {
-        return m_val == other.m_val;
-    }
-    bool operator!=(BitSet other) const {
-        return m_val != other.m_val;
-    }
-    bool operator<(BitSet other) const {
-        return m_val < other.m_val;
-    }
-    bool operator>(BitSet other) const {
-        return m_val > other.m_val;
-    }
-    BitSet operator|(BitSet other) const {
-        return BitSet(m_val | other.m_val);
-    }
-    BitSet operator&(BitSet other) const {
-        return BitSet(m_val & other.m_val);
-    }
-    BitSet operator^(BitSet other) const {
-        return BitSet(m_val ^ other.m_val);
-    }
-    BitSet operator~() const {
-        return BitSet(~m_val);
-    }
-    BitSet& operator|=(BitSet other) {
-        return *this = *this | other;
-    }
-    BitSet& operator&=(BitSet other) {
-        return *this = *this & other;
-    }
-    BitSet& operator^=(BitSet other) {
-        return *this = *this ^ other;
-    }
-    operator u32() = delete;
-    operator bool() {
-        return m_val != 0;
-    }
-    // Warning: Even though on modern CPUs this is a single fast instruction,
-    // Dolphin's official builds do not currently assume POPCNT support on x86,
-    // so slower explicit bit twiddling is generated.  Still should generally
-    // be faster than a loop.
-    unsigned int Count() const {
-        return CountSetBits(m_val);
-    }
-    Iterator begin() const {
-        return Iterator(m_val);
-    }
-    Iterator end() const {
-        return Iterator(0);
-    }
-    IntTy m_val;
-};
-} // namespace Common
-typedef Common::BitSet<u8> BitSet8;
-typedef Common::BitSet<u16> BitSet16;
-typedef Common::BitSet<u32> BitSet32;
-typedef Common::BitSet<u64> BitSet64;
diff --git a/src/common/thread.cpp b/src/common/thread.cpp
index 9e207118f..5144c0d9f 100644
--- a/src/common/thread.cpp
+++ b/src/common/thread.cpp
@@ -25,23 +25,6 @@
 namespace Common {
-int CurrentThreadId() {
-#ifdef _MSC_VER
-    return GetCurrentThreadId();
-#elif defined __APPLE__
-    return mach_thread_self();
-#else
-    return 0;
-#endif
-}
-#ifdef _WIN32
-// Supporting functions
-void SleepCurrentThread(int ms) {
-    Sleep(ms);
-}
-#endif
 #ifdef _MSC_VER
 void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask) {
@@ -62,7 +45,7 @@ void SwitchCurrentThread() {
 // This is implemented much nicer in upcoming msvc++, see:
 // http://msdn.microsoft.com/en-us/library/xcb2z8hs(VS.100).aspx
-void SetCurrentThreadName(const char* szThreadName) {
+void SetCurrentThreadName(const char* name) {
    static const DWORD MS_VC_EXCEPTION = 0x406D1388;
 #pragma pack(push, 8)
@@ -75,7 +58,7 @@ void SetCurrentThreadName(const char* szThreadName) {
 #pragma pack(pop)
    info.dwType = 0x1000;
-    info.szName = szThreadName;
+    info.szName = name;
    info.dwThreadID = -1; // dwThreadID;
    info.dwFlags = 0;
@@ -107,10 +90,6 @@ void SetCurrentThreadAffinity(u32 mask) {
 }
 #ifndef _WIN32
-void SleepCurrentThread(int ms) {
-    usleep(1000 * ms);
-}
 void SwitchCurrentThread() {
    usleep(1000 * 1);
 }
@@ -118,15 +97,15 @@ void SwitchCurrentThread() {
 // MinGW with the POSIX threading model does not support pthread_setname_np
 #if !defined(_WIN32) || defined(_MSC_VER)
-void SetCurrentThreadName(const char* szThreadName) {
+void SetCurrentThreadName(const char* name) {
 #ifdef __APPLE__
-    pthread_setname_np(szThreadName);
+    pthread_setname_np(name);
 #elif defined(__Bitrig__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
-    pthread_set_name_np(pthread_self(), szThreadName);
+    pthread_set_name_np(pthread_self(), name);
 #elif defined(__NetBSD__)
-    pthread_setname_np(pthread_self(), "%s", (void*)szThreadName);
+    pthread_setname_np(pthread_self(), "%s", (void*)name);
 #else
-    pthread_setname_np(pthread_self(), szThreadName);
+    pthread_setname_np(pthread_self(), name);
 #endif
 }
 #endif
diff --git a/src/common/thread.h b/src/common/thread.h
index 6cbdb96a3..2cf74452d 100644
--- a/src/common/thread.h
+++ b/src/common/thread.h
@@ -13,15 +13,8 @@
 namespace Common {
-int CurrentThreadId();
-void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask);
-void SetCurrentThreadAffinity(u32 mask);
 class Event {
 public:
-    Event() : is_set(false) {}
    void Set() {
        std::lock_guard<std::mutex> lk(mutex);
        if (!is_set) {
@@ -53,14 +46,14 @@ public:
    }
 private:
-    bool is_set;
+    bool is_set = false;
    std::condition_variable condvar;
    std::mutex mutex;
 };
 class Barrier {
 public:
-    explicit Barrier(std::size_t count_) : count(count_), waiting(0), generation(0) {}
+    explicit Barrier(std::size_t count_) : count(count_) {}
    /// Blocks until all "count" threads have called Sync()
    void Sync() {
@@ -80,12 +73,13 @@ public:
 private:
    std::condition_variable condvar;
    std::mutex mutex;
-    const std::size_t count;
+    std::size_t count;
-    std::size_t waiting;
+    std::size_t waiting = 0;
-    std::size_t generation; // Incremented once each time the barrier is used
+    std::size_t generation = 0; // Incremented once each time the barrier is used
 };
-void SleepCurrentThread(int ms);
+void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask);
+void SetCurrentThreadAffinity(u32 mask);
 void SwitchCurrentThread(); // On Linux, this is equal to sleep 1ms
 void SetCurrentThreadName(const char* name);
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index a355eaca6..e1f21a764 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -12,6 +12,8 @@ add_library(core STATIC
    core_timing.h
    core_timing_util.cpp
    core_timing_util.h
+    cpu_core_manager.cpp
+    cpu_core_manager.h
    crypto/aes_util.cpp
    crypto/aes_util.h
    crypto/encryption_layer.cpp
@@ -156,6 +158,8 @@ add_library(core STATIC
    hle/service/am/applets/applets.h
    hle/service/am/applets/software_keyboard.cpp
    hle/service/am/applets/software_keyboard.h
+    hle/service/am/applets/stub_applet.cpp
+    hle/service/am/applets/stub_applet.h
    hle/service/am/idle.cpp
    hle/service/am/idle.h
    hle/service/am/omm.cpp
diff --git a/src/core/core.cpp b/src/core/core.cpp
index 6c72fdf4a..795fabc65 100644
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -14,6 +14,7 @@
 #include "core/core.h"
 #include "core/core_cpu.h"
 #include "core/core_timing.h"
+#include "core/cpu_core_manager.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
@@ -28,7 +29,6 @@
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
 #include "core/perf_stats.h"
-#include "core/settings.h"
 #include "core/telemetry_session.h"
 #include "frontend/applets/software_keyboard.h"
 #include "video_core/debug_utils/debug_utils.h"
@@ -71,64 +71,22 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
    return vfs->OpenFile(path, FileSys::Mode::Read);
 }
-/// Runs a CPU core while the system is powered on
-void RunCpuCore(Cpu& cpu_state) {
-    while (Core::System::GetInstance().IsPoweredOn()) {
-        cpu_state.RunLoop(true);
-    }
-}
 } // Anonymous namespace
 struct System::Impl {
    Cpu& CurrentCpuCore() {
-        if (Settings::values.use_multi_core) {
+        return cpu_core_manager.GetCurrentCore();
-            const auto& search = thread_to_cpu.find(std::this_thread::get_id());
-            ASSERT(search != thread_to_cpu.end());
-            ASSERT(search->second);
-            return *search->second;
-        }
-        // Otherwise, use single-threaded mode active_core variable
-        return *cpu_cores[active_core];
    }
    ResultStatus RunLoop(bool tight_loop) {
        status = ResultStatus::Success;
-        // Update thread_to_cpu in case Core 0 is run from a different host thread
+        cpu_core_manager.RunLoop(tight_loop);
-        thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0].get();
-        if (GDBStub::IsServerEnabled()) {
-            GDBStub::HandlePacket();
-            // If the loop is halted and we want to step, use a tiny (1) number of instructions to
-            // execute. Otherwise, get out of the loop function.
-            if (GDBStub::GetCpuHaltFlag()) {
-                if (GDBStub::GetCpuStepFlag()) {
-                    tight_loop = false;
-                } else {
-                    return ResultStatus::Success;
-                }
-            }
-        }
-        for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
-            cpu_cores[active_core]->RunLoop(tight_loop);
-            if (Settings::values.use_multi_core) {
-                // Cores 1-3 are run on other threads in this mode
-                break;
-            }
-        }
-        if (GDBStub::IsServerEnabled()) {
-            GDBStub::SetCpuStepFlag(false);
-        }
        return status;
    }
-    ResultStatus Init(Frontend::EmuWindow& emu_window) {
+    ResultStatus Init(System& system, Frontend::EmuWindow& emu_window) {
        LOG_DEBUG(HW_Memory, "initialized OK");
        CoreTiming::Init();
@@ -145,12 +103,6 @@ struct System::Impl {
        auto main_process = Kernel::Process::Create(kernel, "main");
        kernel.MakeCurrentProcess(main_process.get());
-        cpu_barrier = std::make_unique<CpuBarrier>();
-        cpu_exclusive_monitor = Cpu::MakeExclusiveMonitor(cpu_cores.size());
-        for (std::size_t index = 0; index < cpu_cores.size(); ++index) {
-            cpu_cores[index] = std::make_unique<Cpu>(*cpu_exclusive_monitor, *cpu_barrier, index);
-        }
        telemetry_session = std::make_unique<Core::TelemetrySession>();
        service_manager = std::make_shared<Service::SM::ServiceManager>();
@@ -164,17 +116,8 @@ struct System::Impl {
        gpu_core = std::make_unique<Tegra::GPU>(renderer->Rasterizer());
-        // Create threads for CPU cores 1-3, and build thread_to_cpu map
+        cpu_core_manager.Initialize(system);
-        // CPU core 0 is run on the main thread
+        is_powered_on = true;
-        thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0].get();
-        if (Settings::values.use_multi_core) {
-            for (std::size_t index = 0; index < cpu_core_threads.size(); ++index) {
-                cpu_core_threads[index] =
-                    std::make_unique<std::thread>(RunCpuCore, std::ref(*cpu_cores[index + 1]));
-                thread_to_cpu[cpu_core_threads[index]->get_id()] = cpu_cores[index + 1].get();
-            }
-        }
        LOG_DEBUG(Core, "Initialized OK");
        // Reset counters and set time origin to current frame
@@ -184,7 +127,8 @@ struct System::Impl {
        return ResultStatus::Success;
    }
-    ResultStatus Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
+    ResultStatus Load(System& system, Frontend::EmuWindow& emu_window,
+                      const std::string& filepath) {
        app_loader = Loader::GetLoader(GetGameFileFromPath(virtual_filesystem, filepath));
        if (!app_loader) {
@@ -201,7 +145,7 @@ struct System::Impl {
            return ResultStatus::ErrorSystemMode;
        }
-        ResultStatus init_result{Init(emu_window)};
+        ResultStatus init_result{Init(system, emu_window)};
        if (init_result != ResultStatus::Success) {
            LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
                         static_cast<int>(init_result));
@@ -231,6 +175,8 @@ struct System::Impl {
        Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
                             perf_results.frametime * 1000.0);
+        is_powered_on = false;
        // Shutdown emulation session
        renderer.reset();
        GDBStub::Shutdown();
@@ -240,19 +186,7 @@ struct System::Impl {
        gpu_core.reset();
        // Close all CPU/threading state
-        cpu_barrier->NotifyEnd();
+        cpu_core_manager.Shutdown();
-        if (Settings::values.use_multi_core) {
-            for (auto& thread : cpu_core_threads) {
-                thread->join();
-                thread.reset();
-            }
-        }
-        thread_to_cpu.clear();
-        for (auto& cpu_core : cpu_cores) {
-            cpu_core.reset();
-        }
-        cpu_exclusive_monitor.reset();
-        cpu_barrier.reset();
        // Shutdown kernel and core timing
        kernel.Shutdown();
@@ -289,11 +223,8 @@ struct System::Impl {
    std::unique_ptr<VideoCore::RendererBase> renderer;
    std::unique_ptr<Tegra::GPU> gpu_core;
    std::shared_ptr<Tegra::DebugContext> debug_context;
-    std::unique_ptr<ExclusiveMonitor> cpu_exclusive_monitor;
+    CpuCoreManager cpu_core_manager;
-    std::unique_ptr<CpuBarrier> cpu_barrier;
+    bool is_powered_on = false;
-    std::array<std::unique_ptr<Cpu>, NUM_CPU_CORES> cpu_cores;
-    std::array<std::unique_ptr<std::thread>, NUM_CPU_CORES - 1> cpu_core_threads;
-    std::size_t active_core{}; ///< Active core, only used in single thread mode
    /// Frontend applets
    std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> software_keyboard;
@@ -307,9 +238,6 @@ struct System::Impl {
    ResultStatus status = ResultStatus::Success;
    std::string status_details = "";
-    /// Map of guest threads to CPU cores
-    std::map<std::thread::id, Cpu*> thread_to_cpu;
    Core::PerfStats perf_stats;
    Core::FrameLimiter frame_limiter;
 };
@@ -334,17 +262,15 @@ System::ResultStatus System::SingleStep() {
 }
 void System::InvalidateCpuInstructionCaches() {
-    for (auto& cpu : impl->cpu_cores) {
+    impl->cpu_core_manager.InvalidateAllInstructionCaches();
-        cpu->ArmInterface().ClearInstructionCache();
-    }
 }
 System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
-    return impl->Load(emu_window, filepath);
+    return impl->Load(*this, emu_window, filepath);
 }
 bool System::IsPoweredOn() const {
-    return impl->cpu_barrier && impl->cpu_barrier->IsAlive();
+    return impl->is_powered_on;
 }
 void System::PrepareReschedule() {
@@ -408,21 +334,20 @@ const ARM_Interface& System::ArmInterface(std::size_t core_index) const {
 }
 Cpu& System::CpuCore(std::size_t core_index) {
-    ASSERT(core_index < NUM_CPU_CORES);
+    return impl->cpu_core_manager.GetCore(core_index);
-    return *impl->cpu_cores[core_index];
 }
 const Cpu& System::CpuCore(std::size_t core_index) const {
    ASSERT(core_index < NUM_CPU_CORES);
-    return *impl->cpu_cores[core_index];
+    return impl->cpu_core_manager.GetCore(core_index);
 }
 ExclusiveMonitor& System::Monitor() {
-    return *impl->cpu_exclusive_monitor;
+    return impl->cpu_core_manager.GetExclusiveMonitor();
 }
 const ExclusiveMonitor& System::Monitor() const {
-    return *impl->cpu_exclusive_monitor;
+    return impl->cpu_core_manager.GetExclusiveMonitor();
 }
 Tegra::GPU& System::GPU() {
@@ -506,7 +431,7 @@ const Core::Frontend::SoftwareKeyboardApplet& System::GetSoftwareKeyboard() cons
 }
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
-    return impl->Init(emu_window);
+    return impl->Init(*this, emu_window);
 }
 void System::Shutdown() {
diff --git a/src/core/cpu_core_manager.cpp b/src/core/cpu_core_manager.cpp
new file mode 100644
index 000000000..769a6fefa
--- /dev/null
+++ b/src/core/cpu_core_manager.cpp
@@ -0,0 +1,142 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#include "common/assert.h"
+#include "core/arm/exclusive_monitor.h"
+#include "core/core.h"
+#include "core/core_cpu.h"
+#include "core/cpu_core_manager.h"
+#include "core/gdbstub/gdbstub.h"
+#include "core/settings.h"
+namespace Core {
+namespace {
+void RunCpuCore(const System& system, Cpu& cpu_state) {
+    while (system.IsPoweredOn()) {
+        cpu_state.RunLoop(true);
+    }
+}
+} // Anonymous namespace
+CpuCoreManager::CpuCoreManager() = default;
+CpuCoreManager::~CpuCoreManager() = default;
+void CpuCoreManager::Initialize(System& system) {
+    barrier = std::make_unique<CpuBarrier>();
+    exclusive_monitor = Cpu::MakeExclusiveMonitor(cores.size());
+    for (std::size_t index = 0; index < cores.size(); ++index) {
+        cores[index] = std::make_unique<Cpu>(*exclusive_monitor, *barrier, index);
+    }
+    // Create threads for CPU cores 1-3, and build thread_to_cpu map
+    // CPU core 0 is run on the main thread
+    thread_to_cpu[std::this_thread::get_id()] = cores[0].get();
+    if (!Settings::values.use_multi_core) {
+        return;
+    }
+    for (std::size_t index = 0; index < core_threads.size(); ++index) {
+        core_threads[index] = std::make_unique<std::thread>(RunCpuCore, std::cref(system),
+                                                            std::ref(*cores[index + 1]));
+        thread_to_cpu[core_threads[index]->get_id()] = cores[index + 1].get();
+    }
+}
+void CpuCoreManager::Shutdown() {
+    barrier->NotifyEnd();
+    if (Settings::values.use_multi_core) {
+        for (auto& thread : core_threads) {
+            thread->join();
+            thread.reset();
+        }
+    }
+    thread_to_cpu.clear();
+    for (auto& cpu_core : cores) {
+        cpu_core.reset();
+    }
+    exclusive_monitor.reset();
+    barrier.reset();
+}
+Cpu& CpuCoreManager::GetCore(std::size_t index) {
+    return *cores.at(index);
+}
+const Cpu& CpuCoreManager::GetCore(std::size_t index) const {
+    return *cores.at(index);
+}
+ExclusiveMonitor& CpuCoreManager::GetExclusiveMonitor() {
+    return *exclusive_monitor;
+}
+const ExclusiveMonitor& CpuCoreManager::GetExclusiveMonitor() const {
+    return *exclusive_monitor;
+}
+Cpu& CpuCoreManager::GetCurrentCore() {
+    if (Settings::values.use_multi_core) {
+        const auto& search = thread_to_cpu.find(std::this_thread::get_id());
+        ASSERT(search != thread_to_cpu.end());
+        ASSERT(search->second);
+        return *search->second;
+    }
+    // Otherwise, use single-threaded mode active_core variable
+    return *cores[active_core];
+}
+const Cpu& CpuCoreManager::GetCurrentCore() const {
+    if (Settings::values.use_multi_core) {
+        const auto& search = thread_to_cpu.find(std::this_thread::get_id());
+        ASSERT(search != thread_to_cpu.end());
+        ASSERT(search->second);
+        return *search->second;
+    }
+    // Otherwise, use single-threaded mode active_core variable
+    return *cores[active_core];
+}
+void CpuCoreManager::RunLoop(bool tight_loop) {
+    // Update thread_to_cpu in case Core 0 is run from a different host thread
+    thread_to_cpu[std::this_thread::get_id()] = cores[0].get();
+    if (GDBStub::IsServerEnabled()) {
+        GDBStub::HandlePacket();
+        // If the loop is halted and we want to step, use a tiny (1) number of instructions to
+        // execute. Otherwise, get out of the loop function.
+        if (GDBStub::GetCpuHaltFlag()) {
+            if (GDBStub::GetCpuStepFlag()) {
+                tight_loop = false;
+            } else {
+                return;
+            }
+        }
+    }
+    for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
+        cores[active_core]->RunLoop(tight_loop);
+        if (Settings::values.use_multi_core) {
+            // Cores 1-3 are run on other threads in this mode
+            break;
+        }
+    }
+    if (GDBStub::IsServerEnabled()) {
+        GDBStub::SetCpuStepFlag(false);
+    }
+}
+void CpuCoreManager::InvalidateAllInstructionCaches() {
+    for (auto& cpu : cores) {
+        cpu->ArmInterface().ClearInstructionCache();
+    }
+}
+} // namespace Core
diff --git a/src/core/cpu_core_manager.h b/src/core/cpu_core_manager.h
new file mode 100644
index 000000000..a4d70ec56
--- /dev/null
+++ b/src/core/cpu_core_manager.h
@@ -0,0 +1,59 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#pragma once
+#include <array>
+#include <map>
+#include <memory>
+#include <thread>
+namespace Core {
+class Cpu;
+class CpuBarrier;
+class ExclusiveMonitor;
+class System;
+class CpuCoreManager {
+public:
+    CpuCoreManager();
+    CpuCoreManager(const CpuCoreManager&) = delete;
+    CpuCoreManager(CpuCoreManager&&) = delete;
+    ~CpuCoreManager();
+    CpuCoreManager& operator=(const CpuCoreManager&) = delete;
+    CpuCoreManager& operator=(CpuCoreManager&&) = delete;
+    void Initialize(System& system);
+    void Shutdown();
+    Cpu& GetCore(std::size_t index);
+    const Cpu& GetCore(std::size_t index) const;
+    Cpu& GetCurrentCore();
+    const Cpu& GetCurrentCore() const;
+    ExclusiveMonitor& GetExclusiveMonitor();
+    const ExclusiveMonitor& GetExclusiveMonitor() const;
+    void RunLoop(bool tight_loop);
+    void InvalidateAllInstructionCaches();
+private:
+    static constexpr std::size_t NUM_CPU_CORES = 4;
+    std::unique_ptr<ExclusiveMonitor> exclusive_monitor;
+    std::unique_ptr<CpuBarrier> barrier;
+    std::array<std::unique_ptr<Cpu>, NUM_CPU_CORES> cores;
+    std::array<std::unique_ptr<std::thread>, NUM_CPU_CORES - 1> core_threads;
+    std::size_t active_core{}; ///< Active core, only used in single thread mode
+    /// Map of guest threads to CPU cores
+    std::map<std::thread::id, Cpu*> thread_to_cpu;
+};
+} // namespace Core
diff --git a/src/core/file_sys/control_metadata.cpp b/src/core/file_sys/control_metadata.cpp
index c8fa912bf..e065e592f 100644
--- a/src/core/file_sys/control_metadata.cpp
+++ b/src/core/file_sys/control_metadata.cpp
@@ -8,13 +8,23 @@
 namespace FileSys {
-const std::array<const char*, 15> LANGUAGE_NAMES = {
+const std::array<const char*, 15> LANGUAGE_NAMES{{
-    "AmericanEnglish", "BritishEnglish", "Japanese",
+    "AmericanEnglish",
-    "French",          "German",         "LatinAmericanSpanish",
+    "BritishEnglish",
-    "Spanish",         "Italian",        "Dutch",
+    "Japanese",
-    "CanadianFrench",  "Portugese",      "Russian",
+    "French",
-    "Korean",          "Taiwanese",      "Chinese",
+    "German",
-};
+    "LatinAmericanSpanish",
+    "Spanish",
+    "Italian",
+    "Dutch",
+    "CanadianFrench",
+    "Portuguese",
+    "Russian",
+    "Korean",
+    "Taiwanese",
+    "Chinese",
+}};
 std::string LanguageEntry::GetApplicationName() const {
    return Common::StringFromFixedZeroTerminatedBuffer(application_name.data(),
diff --git a/src/core/file_sys/patch_manager.cpp b/src/core/file_sys/patch_manager.cpp
index 8d062eb3e..e8df08724 100644
--- a/src/core/file_sys/patch_manager.cpp
+++ b/src/core/file_sys/patch_manager.cpp
@@ -26,6 +26,11 @@ namespace FileSys {
 constexpr u64 SINGLE_BYTE_MODULUS = 0x100;
 constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
+constexpr std::array<const char*, 14> EXEFS_FILE_NAMES{
+    "main",    "main.npdm", "rtld",    "sdk",     "subsdk0", "subsdk1", "subsdk2",
+    "subsdk3", "subsdk4",   "subsdk5", "subsdk6", "subsdk7", "subsdk8", "subsdk9",
+};
 struct NSOBuildHeader {
    u32_le magic;
    INSERT_PADDING_BYTES(0x3C);
@@ -57,6 +62,15 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
    if (exefs == nullptr)
        return exefs;
+    if (Settings::values.dump_exefs) {
+        LOG_INFO(Loader, "Dumping ExeFS for title_id={:016X}", title_id);
+        const auto dump_dir = Service::FileSystem::GetModificationDumpRoot(title_id);
+        if (dump_dir != nullptr) {
+            const auto exefs_dir = GetOrCreateDirectoryRelative(dump_dir, "/exefs");
+            VfsRawCopyD(exefs, exefs_dir);
+        }
+    }
    const auto installed = Service::FileSystem::GetUnionContents();
    // Game Updates
@@ -70,6 +84,30 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
        exefs = update->GetExeFS();
    }
+    // LayeredExeFS
+    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
+    if (load_dir != nullptr && load_dir->GetSize() > 0) {
+        auto patch_dirs = load_dir->GetSubdirectories();
+        std::sort(
+            patch_dirs.begin(), patch_dirs.end(),
+            [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
+        std::vector<VirtualDir> layers;
+        layers.reserve(patch_dirs.size() + 1);
+        for (const auto& subdir : patch_dirs) {
+            auto exefs_dir = subdir->GetSubdirectory("exefs");
+            if (exefs_dir != nullptr)
+                layers.push_back(std::move(exefs_dir));
+        }
+        layers.push_back(exefs);
+        auto layered = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers));
+        if (layered != nullptr) {
+            LOG_INFO(Loader, "    ExeFS: LayeredExeFS patches applied successfully");
+            exefs = std::move(layered);
+        }
+    }
    return exefs;
 }
@@ -314,18 +352,25 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
            if (IsDirValidAndNonEmpty(exefs_dir)) {
                bool ips = false;
                bool ipswitch = false;
+                bool layeredfs = false;
                for (const auto& file : exefs_dir->GetFiles()) {
-                    if (file->GetExtension() == "ips")
+                    if (file->GetExtension() == "ips") {
                        ips = true;
-                    else if (file->GetExtension() == "pchtxt")
+                    } else if (file->GetExtension() == "pchtxt") {
                        ipswitch = true;
+                    } else if (std::find(EXEFS_FILE_NAMES.begin(), EXEFS_FILE_NAMES.end(),
+                                         file->GetName()) != EXEFS_FILE_NAMES.end()) {
+                        layeredfs = true;
+                    }
                }
                if (ips)
                    AppendCommaIfNotEmpty(types, "IPS");
                if (ipswitch)
                    AppendCommaIfNotEmpty(types, "IPSwitch");
+                if (layeredfs)
+                    AppendCommaIfNotEmpty(types, "LayeredExeFS");
            }
            if (IsDirValidAndNonEmpty(mod->GetSubdirectory("romfs")))
                AppendCommaIfNotEmpty(types, "LayeredFS");
diff --git a/src/core/file_sys/registered_cache.cpp b/src/core/file_sys/registered_cache.cpp
index a3f8f2f73..07c3af64a 100644
--- a/src/core/file_sys/registered_cache.cpp
+++ b/src/core/file_sys/registered_cache.cpp
@@ -381,22 +381,22 @@ std::vector<RegisteredCacheEntry> RegisteredCache::ListEntriesFilter(
    return out;
 }
-static std::shared_ptr<NCA> GetNCAFromNSPForID(std::shared_ptr<NSP> nsp, const NcaID& id) {
+static std::shared_ptr<NCA> GetNCAFromNSPForID(const NSP& nsp, const NcaID& id) {
-    const auto file = nsp->GetFile(fmt::format("{}.nca", Common::HexArrayToString(id, false)));
+    const auto file = nsp.GetFile(fmt::format("{}.nca", Common::HexArrayToString(id, false)));
    if (file == nullptr)
        return nullptr;
    return std::make_shared<NCA>(file);
 }
-InstallResult RegisteredCache::InstallEntry(std::shared_ptr<XCI> xci, bool overwrite_if_exists,
+InstallResult RegisteredCache::InstallEntry(const XCI& xci, bool overwrite_if_exists,
                                            const VfsCopyFunction& copy) {
-    return InstallEntry(xci->GetSecurePartitionNSP(), overwrite_if_exists, copy);
+    return InstallEntry(*xci.GetSecurePartitionNSP(), overwrite_if_exists, copy);
 }
-InstallResult RegisteredCache::InstallEntry(std::shared_ptr<NSP> nsp, bool overwrite_if_exists,
+InstallResult RegisteredCache::InstallEntry(const NSP& nsp, bool overwrite_if_exists,
                                            const VfsCopyFunction& copy) {
-    const auto& ncas = nsp->GetNCAsCollapsed();
+    const auto ncas = nsp.GetNCAsCollapsed();
-    const auto& meta_iter = std::find_if(ncas.begin(), ncas.end(), [](std::shared_ptr<NCA> nca) {
+    const auto meta_iter = std::find_if(ncas.begin(), ncas.end(), [](const auto& nca) {
        return nca->GetType() == NCAContentType::Meta;
    });
@@ -410,7 +410,7 @@ InstallResult RegisteredCache::InstallEntry(std::shared_ptr<NSP> nsp, bool overw
    const auto meta_id_raw = (*meta_iter)->GetName().substr(0, 32);
    const auto meta_id = Common::HexStringToArray<16>(meta_id_raw);
-    const auto res = RawInstallNCA(*meta_iter, copy, overwrite_if_exists, meta_id);
+    const auto res = RawInstallNCA(**meta_iter, copy, overwrite_if_exists, meta_id);
    if (res != InstallResult::Success)
        return res;
@@ -422,7 +422,7 @@ InstallResult RegisteredCache::InstallEntry(std::shared_ptr<NSP> nsp, bool overw
        const auto nca = GetNCAFromNSPForID(nsp, record.nca_id);
        if (nca == nullptr)
            return InstallResult::ErrorCopyFailed;
-        const auto res2 = RawInstallNCA(nca, copy, overwrite_if_exists, record.nca_id);
+        const auto res2 = RawInstallNCA(*nca, copy, overwrite_if_exists, record.nca_id);
        if (res2 != InstallResult::Success)
            return res2;
    }
@@ -431,21 +431,21 @@ InstallResult RegisteredCache::InstallEntry(std::shared_ptr<NSP> nsp, bool overw
    return InstallResult::Success;
 }
-InstallResult RegisteredCache::InstallEntry(std::shared_ptr<NCA> nca, TitleType type,
+InstallResult RegisteredCache::InstallEntry(const NCA& nca, TitleType type,
                                            bool overwrite_if_exists, const VfsCopyFunction& copy) {
    CNMTHeader header{
-        nca->GetTitleId(), ///< Title ID
+        nca.GetTitleId(), ///< Title ID
-        0,                 ///< Ignore/Default title version
+        0,                ///< Ignore/Default title version
-        type,              ///< Type
+        type,             ///< Type
-        {},                ///< Padding
+        {},               ///< Padding
-        0x10,              ///< Default table offset
+        0x10,             ///< Default table offset
-        1,                 ///< 1 Content Entry
+        1,                ///< 1 Content Entry
-        0,                 ///< No Meta Entries
+        0,                ///< No Meta Entries
-        {},                ///< Padding
+        {},               ///< Padding
    };
    OptionalHeader opt_header{0, 0};
-    ContentRecord c_rec{{}, {}, {}, GetCRTypeFromNCAType(nca->GetType()), {}};
+    ContentRecord c_rec{{}, {}, {}, GetCRTypeFromNCAType(nca.GetType()), {}};
-    const auto& data = nca->GetBaseFile()->ReadBytes(0x100000);
+    const auto& data = nca.GetBaseFile()->ReadBytes(0x100000);
    mbedtls_sha256(data.data(), data.size(), c_rec.hash.data(), 0);
    memcpy(&c_rec.nca_id, &c_rec.hash, 16);
    const CNMT new_cnmt(header, opt_header, {c_rec}, {});
@@ -454,10 +454,10 @@ InstallResult RegisteredCache::InstallEntry(std::shared_ptr<NCA> nca, TitleType
    return RawInstallNCA(nca, copy, overwrite_if_exists, c_rec.nca_id);
 }
-InstallResult RegisteredCache::RawInstallNCA(std::shared_ptr<NCA> nca, const VfsCopyFunction& copy,
+InstallResult RegisteredCache::RawInstallNCA(const NCA& nca, const VfsCopyFunction& copy,
                                             bool overwrite_if_exists,
                                             std::optional<NcaID> override_id) {
-    const auto in = nca->GetBaseFile();
+    const auto in = nca.GetBaseFile();
    Core::Crypto::SHA256Hash hash{};
    // Calculate NcaID
diff --git a/src/core/file_sys/registered_cache.h b/src/core/file_sys/registered_cache.h
index 6b89db8de..3b77af4e0 100644
--- a/src/core/file_sys/registered_cache.h
+++ b/src/core/file_sys/registered_cache.h
@@ -6,7 +6,6 @@
 #include <array>
 #include <functional>
-#include <map>
 #include <memory>
 #include <string>
 #include <vector>
@@ -104,17 +103,16 @@ public:
    // Raw copies all the ncas from the xci/nsp to the csache. Does some quick checks to make sure
    // there is a meta NCA and all of them are accessible.
-    InstallResult InstallEntry(std::shared_ptr<XCI> xci, bool overwrite_if_exists = false,
+    InstallResult InstallEntry(const XCI& xci, bool overwrite_if_exists = false,
                               const VfsCopyFunction& copy = &VfsRawCopy);
-    InstallResult InstallEntry(std::shared_ptr<NSP> nsp, bool overwrite_if_exists = false,
+    InstallResult InstallEntry(const NSP& nsp, bool overwrite_if_exists = false,
                               const VfsCopyFunction& copy = &VfsRawCopy);
    // Due to the fact that we must use Meta-type NCAs to determine the existance of files, this
    // poses quite a challenge. Instead of creating a new meta NCA for this file, yuzu will create a
    // dir inside the NAND called 'yuzu_meta' and store the raw CNMT there.
    // TODO(DarkLordZach): Author real meta-type NCAs and install those.
-    InstallResult InstallEntry(std::shared_ptr<NCA> nca, TitleType type,
+    InstallResult InstallEntry(const NCA& nca, TitleType type, bool overwrite_if_exists = false,
-                               bool overwrite_if_exists = false,
                               const VfsCopyFunction& copy = &VfsRawCopy);
 private:
@@ -128,7 +126,7 @@ private:
    std::optional<NcaID> GetNcaIDFromMetadata(u64 title_id, ContentRecordType type) const;
    VirtualFile GetFileAtID(NcaID id) const;
    VirtualFile OpenFileOrDirectoryConcat(const VirtualDir& dir, std::string_view path) const;
-    InstallResult RawInstallNCA(std::shared_ptr<NCA> nca, const VfsCopyFunction& copy,
+    InstallResult RawInstallNCA(const NCA& nca, const VfsCopyFunction& copy,
                                bool overwrite_if_exists, std::optional<NcaID> override_id = {});
    bool RawInstallYuzuMeta(const CNMT& cnmt);
diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp
index bdcc889e0..e6b5171ee 100644
--- a/src/core/gdbstub/gdbstub.cpp
+++ b/src/core/gdbstub/gdbstub.cpp
@@ -71,10 +71,6 @@ constexpr u32 PSTATE_REGISTER = 33;
 constexpr u32 UC_ARM64_REG_Q0 = 34;
 constexpr u32 FPCR_REGISTER = 66;
-// TODO/WiP - Used while working on support for FPU
-constexpr u32 TODO_DUMMY_REG_997 = 997;
-constexpr u32 TODO_DUMMY_REG_998 = 998;
 // For sample XML files see the GDB source /gdb/features
 // GDB also wants the l character at the start
 // This XML defines what the registers are for this specific ARM device
@@ -260,6 +256,36 @@ static void RegWrite(std::size_t id, u64 val, Kernel::Thread* thread = nullptr)
    }
 }
+static u128 FpuRead(std::size_t id, Kernel::Thread* thread = nullptr) {
+    if (!thread) {
+        return u128{0};
+    }
+    auto& thread_context = thread->GetContext();
+    if (id >= UC_ARM64_REG_Q0 && id < FPCR_REGISTER) {
+        return thread_context.vector_registers[id - UC_ARM64_REG_Q0];
+    } else if (id == FPCR_REGISTER) {
+        return u128{thread_context.fpcr, 0};
+    } else {
+        return u128{0};
+    }
+}
+static void FpuWrite(std::size_t id, u128 val, Kernel::Thread* thread = nullptr) {
+    if (!thread) {
+        return;
+    }
+    auto& thread_context = thread->GetContext();
+    if (id >= UC_ARM64_REG_Q0 && id < FPCR_REGISTER) {
+        thread_context.vector_registers[id - UC_ARM64_REG_Q0] = val;
+    } else if (id == FPCR_REGISTER) {
+        thread_context.fpcr = static_cast<u32>(val[0]);
+    }
+}
 /**
 * Turns hex string character into the equivalent byte.
 *
@@ -409,6 +435,27 @@ static u64 GdbHexToLong(const u8* src) {
    return output;
 }
+/**
+ * Convert a gdb-formatted hex string into a u128.
+ *
+ * @param src Pointer to hex string.
+ */
+static u128 GdbHexToU128(const u8* src) {
+    u128 output;
+    for (int i = 0; i < 16; i += 2) {
+        output[0] = (output[0] << 4) | HexCharToValue(src[15 - i - 1]);
+        output[0] = (output[0] << 4) | HexCharToValue(src[15 - i]);
+    }
+    for (int i = 0; i < 16; i += 2) {
+        output[1] = (output[1] << 4) | HexCharToValue(src[16 + 15 - i - 1]);
+        output[1] = (output[1] << 4) | HexCharToValue(src[16 + 15 - i]);
+    }
+    return output;
+}
 /// Read a byte from the gdb client.
 static u8 ReadByte() {
    u8 c;
@@ -599,8 +646,7 @@ static void HandleQuery() {
        for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
            const auto& threads = Core::System::GetInstance().Scheduler(core).GetThreadList();
            for (const auto& thread : threads) {
-                val += fmt::format("{:x}", thread->GetThreadID());
+                val += fmt::format("{:x},", thread->GetThreadID());
-                val += ",";
            }
        }
        val.pop_back();
@@ -791,11 +837,15 @@ static void ReadRegister() {
    } else if (id == PSTATE_REGISTER) {
        IntToGdbHex(reply, static_cast<u32>(RegRead(id, current_thread)));
    } else if (id >= UC_ARM64_REG_Q0 && id < FPCR_REGISTER) {
-        LongToGdbHex(reply, RegRead(id, current_thread));
+        u128 r = FpuRead(id, current_thread);
+        LongToGdbHex(reply, r[0]);
+        LongToGdbHex(reply + 16, r[1]);
    } else if (id == FPCR_REGISTER) {
-        LongToGdbHex(reply, RegRead(TODO_DUMMY_REG_998, current_thread));
+        u128 r = FpuRead(id, current_thread);
-    } else {
+        IntToGdbHex(reply, static_cast<u32>(r[0]));
-        LongToGdbHex(reply, RegRead(TODO_DUMMY_REG_997, current_thread));
+    } else if (id == FPCR_REGISTER + 1) {
+        u128 r = FpuRead(id, current_thread);
+        IntToGdbHex(reply, static_cast<u32>(r[0] >> 32));
    }
    SendReply(reinterpret_cast<char*>(reply));
@@ -822,13 +872,18 @@ static void ReadRegisters() {
    bufptr += 8;
-    for (u32 reg = UC_ARM64_REG_Q0; reg <= UC_ARM64_REG_Q0 + 31; reg++) {
+    u128 r;
-        LongToGdbHex(bufptr + reg * 16, RegRead(reg, current_thread));
+    for (u32 reg = UC_ARM64_REG_Q0; reg < FPCR_REGISTER; reg++) {
+        r = FpuRead(reg, current_thread);
+        LongToGdbHex(bufptr + reg * 32, r[0]);
+        LongToGdbHex(bufptr + reg * 32 + 16, r[1]);
    }
    bufptr += 32 * 32;
-    LongToGdbHex(bufptr, RegRead(TODO_DUMMY_REG_998, current_thread));
+    r = FpuRead(FPCR_REGISTER, current_thread);
+    IntToGdbHex(bufptr, static_cast<u32>(r[0]));
    bufptr += 8;
@@ -853,14 +908,12 @@ static void WriteRegister() {
    } else if (id == PSTATE_REGISTER) {
        RegWrite(id, GdbHexToInt(buffer_ptr), current_thread);
    } else if (id >= UC_ARM64_REG_Q0 && id < FPCR_REGISTER) {
-        RegWrite(id, GdbHexToLong(buffer_ptr), current_thread);
+        FpuWrite(id, GdbHexToU128(buffer_ptr), current_thread);
    } else if (id == FPCR_REGISTER) {
-        RegWrite(TODO_DUMMY_REG_998, GdbHexToLong(buffer_ptr), current_thread);
+    } else if (id == FPCR_REGISTER + 1) {
-    } else {
-        RegWrite(TODO_DUMMY_REG_997, GdbHexToLong(buffer_ptr), current_thread);
    }
-    // Update Unicorn context skipping scheduler, no running threads at this point
+    // Update ARM context, skipping scheduler - no running threads at this point
    Core::System::GetInstance()
        .ArmInterface(current_core)
        .LoadContext(current_thread->GetContext());
@@ -885,13 +938,13 @@ static void WriteRegisters() {
        } else if (reg >= UC_ARM64_REG_Q0 && reg < FPCR_REGISTER) {
            RegWrite(reg, GdbHexToLong(buffer_ptr + i * 16), current_thread);
        } else if (reg == FPCR_REGISTER) {
-            RegWrite(TODO_DUMMY_REG_998, GdbHexToLong(buffer_ptr + i * 16), current_thread);
+            RegWrite(FPCR_REGISTER, GdbHexToLong(buffer_ptr + i * 16), current_thread);
-        } else {
+        } else if (reg == FPCR_REGISTER + 1) {
-            UNIMPLEMENTED();
+            RegWrite(FPCR_REGISTER, GdbHexToLong(buffer_ptr + i * 16), current_thread);
        }
    }
-    // Update Unicorn context skipping scheduler, no running threads at this point
+    // Update ARM context, skipping scheduler - no running threads at this point
    Core::System::GetInstance()
        .ArmInterface(current_core)
        .LoadContext(current_thread->GetContext());
@@ -917,12 +970,6 @@ static void ReadMemory() {
        SendReply("E01");
    }
-    const auto& vm_manager = Core::CurrentProcess()->VMManager();
-    if (addr < vm_manager.GetCodeRegionBaseAddress() ||
-        addr >= vm_manager.GetMapRegionEndAddress()) {
-        return SendReply("E00");
-    }
    if (!Memory::IsValidVirtualAddress(addr)) {
        return SendReply("E00");
    }
@@ -967,7 +1014,7 @@ void Break(bool is_memory_break) {
 static void Step() {
    if (command_length > 1) {
        RegWrite(PC_REGISTER, GdbHexToLong(command_buffer + 1), current_thread);
-        // Update Unicorn context skipping scheduler, no running threads at this point
+        // Update ARM context, skipping scheduler - no running threads at this point
        Core::System::GetInstance()
            .ArmInterface(current_core)
            .LoadContext(current_thread->GetContext());
@@ -1010,7 +1057,7 @@ static bool CommitBreakpoint(BreakpointType type, VAddr addr, u64 len) {
    breakpoint.addr = addr;
    breakpoint.len = len;
    Memory::ReadBlock(addr, breakpoint.inst.data(), breakpoint.inst.size());
-    static constexpr std::array<u8, 4> btrap{{0x00, 0x7d, 0x20, 0xd4}};
+    static constexpr std::array<u8, 4> btrap{0x00, 0x7d, 0x20, 0xd4};
    Memory::WriteBlock(addr, btrap.data(), btrap.size());
    Core::System::GetInstance().InvalidateCpuInstructionCaches();
    p.insert({addr, breakpoint});
@@ -1321,13 +1368,15 @@ void SetCpuStepFlag(bool is_step) {
 }
 void SendTrap(Kernel::Thread* thread, int trap) {
-    if (send_trap) {
+    if (!send_trap) {
-        if (!halt_loop || current_thread == thread) {
+        return;
-            current_thread = thread;
-            SendSignal(thread, trap);
-        }
-        halt_loop = true;
-        send_trap = false;
    }
+    if (!halt_loop || current_thread == thread) {
+        current_thread = thread;
+        SendSignal(thread, trap);
+    }
+    halt_loop = true;
+    send_trap = false;
 }
 }; // namespace GDBStub
diff --git a/src/core/hle/kernel/handle_table.cpp b/src/core/hle/kernel/handle_table.cpp
index 5ee5c05e3..1bf79b692 100644
--- a/src/core/hle/kernel/handle_table.cpp
+++ b/src/core/hle/kernel/handle_table.cpp
@@ -12,12 +12,23 @@
 #include "core/hle/kernel/thread.h"
 namespace Kernel {
+namespace {
+constexpr u16 GetSlot(Handle handle) {
+    return handle >> 15;
+}
+constexpr u16 GetGeneration(Handle handle) {
+    return handle & 0x7FFF;
+}
+} // Anonymous namespace
 HandleTable::HandleTable() {
    next_generation = 1;
    Clear();
 }
+HandleTable::~HandleTable() = default;
 ResultVal<Handle> HandleTable::Create(SharedPtr<Object> obj) {
    DEBUG_ASSERT(obj != nullptr);
diff --git a/src/core/hle/kernel/handle_table.h b/src/core/hle/kernel/handle_table.h
index 9e2f33e8a..e3f3e3fb8 100644
--- a/src/core/hle/kernel/handle_table.h
+++ b/src/core/hle/kernel/handle_table.h
@@ -43,6 +43,7 @@ enum KernelHandle : Handle {
 class HandleTable final : NonCopyable {
 public:
    HandleTable();
+    ~HandleTable();
    /**
     * Allocates a handle for the given object.
@@ -89,18 +90,8 @@ public:
    void Clear();
 private:
-    /**
+    /// This is the maximum limit of handles allowed per process in Horizon
-     * This is the maximum limit of handles allowed per process in CTR-OS. It can be further
+    static constexpr std::size_t MAX_COUNT = 1024;
-     * reduced by ExHeader values, but this is not emulated here.
-     */
-    static const std::size_t MAX_COUNT = 4096;
-    static u16 GetSlot(Handle handle) {
-        return handle >> 15;
-    }
-    static u16 GetGeneration(Handle handle) {
-        return handle & 0x7FFF;
-    }
    /// Stores the Object referenced by the handle or null if the slot is empty.
    std::array<SharedPtr<Object>, MAX_COUNT> objects;
diff --git a/src/core/hle/kernel/resource_limit.h b/src/core/hle/kernel/resource_limit.h
index bec065543..59dc11c22 100644
--- a/src/core/hle/kernel/resource_limit.h
+++ b/src/core/hle/kernel/resource_limit.h
@@ -14,7 +14,7 @@ namespace Kernel {
 class KernelCore;
-enum class ResourceType {
+enum class ResourceType : u32 {
    PhysicalMemory,
    Threads,
    Events,
@@ -25,6 +25,10 @@ enum class ResourceType {
    ResourceTypeCount
 };
+constexpr bool IsValidResourceType(ResourceType type) {
+    return type < ResourceType::ResourceTypeCount;
+}
 class ResourceLimit final : public Object {
 public:
    /**
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index b8b6b4d49..5e9660a48 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -63,56 +63,129 @@ bool IsInsideNewMapRegion(const VMManager& vm, VAddr address, u64 size) {
                                vm.GetNewMapRegionEndAddress());
 }
+// 8 GiB
+constexpr u64 MAIN_MEMORY_SIZE = 0x200000000;
 // Helper function that performs the common sanity checks for svcMapMemory
 // and svcUnmapMemory. This is doable, as both functions perform their sanitizing
 // in the same order.
 ResultCode MapUnmapMemorySanityChecks(const VMManager& vm_manager, VAddr dst_addr, VAddr src_addr,
                                      u64 size) {
-    if (!Common::Is4KBAligned(dst_addr) || !Common::Is4KBAligned(src_addr)) {
+    if (!Common::Is4KBAligned(dst_addr)) {
+        LOG_ERROR(Kernel_SVC, "Destination address is not aligned to 4KB, 0x{:016X}", dst_addr);
        return ERR_INVALID_ADDRESS;
    }
-    if (size == 0 || !Common::Is4KBAligned(size)) {
+    if (!Common::Is4KBAligned(src_addr)) {
+        LOG_ERROR(Kernel_SVC, "Source address is not aligned to 4KB, 0x{:016X}", src_addr);
+        return ERR_INVALID_SIZE;
+    }
+    if (size == 0) {
+        LOG_ERROR(Kernel_SVC, "Size is 0");
+        return ERR_INVALID_SIZE;
+    }
+    if (!Common::Is4KBAligned(size)) {
+        LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:016X}", size);
        return ERR_INVALID_SIZE;
    }
    if (!IsValidAddressRange(dst_addr, size)) {
+        LOG_ERROR(Kernel_SVC,
+                  "Destination is not a valid address range, addr=0x{:016X}, size=0x{:016X}",
+                  dst_addr, size);
        return ERR_INVALID_ADDRESS_STATE;
    }
    if (!IsValidAddressRange(src_addr, size)) {
+        LOG_ERROR(Kernel_SVC, "Source is not a valid address range, addr=0x{:016X}, size=0x{:016X}",
+                  src_addr, size);
        return ERR_INVALID_ADDRESS_STATE;
    }
    if (!IsInsideAddressSpace(vm_manager, src_addr, size)) {
+        LOG_ERROR(Kernel_SVC,
+                  "Source is not within the address space, addr=0x{:016X}, size=0x{:016X}",
+                  src_addr, size);
        return ERR_INVALID_ADDRESS_STATE;
    }
    if (!IsInsideNewMapRegion(vm_manager, dst_addr, size)) {
+        LOG_ERROR(Kernel_SVC,
+                  "Destination is not within the new map region, addr=0x{:016X}, size=0x{:016X}",
+                  dst_addr, size);
        return ERR_INVALID_MEMORY_RANGE;
    }
    const VAddr dst_end_address = dst_addr + size;
    if (dst_end_address > vm_manager.GetHeapRegionBaseAddress() &&
        vm_manager.GetHeapRegionEndAddress() > dst_addr) {
+        LOG_ERROR(Kernel_SVC,
+                  "Destination does not fit within the heap region, addr=0x{:016X}, "
+                  "size=0x{:016X}, end_addr=0x{:016X}",
+                  dst_addr, size, dst_end_address);
        return ERR_INVALID_MEMORY_RANGE;
    }
    if (dst_end_address > vm_manager.GetMapRegionBaseAddress() &&
        vm_manager.GetMapRegionEndAddress() > dst_addr) {
+        LOG_ERROR(Kernel_SVC,
+                  "Destination does not fit within the map region, addr=0x{:016X}, "
+                  "size=0x{:016X}, end_addr=0x{:016X}",
+                  dst_addr, size, dst_end_address);
        return ERR_INVALID_MEMORY_RANGE;
    }
    return RESULT_SUCCESS;
 }
+enum class ResourceLimitValueType {
+    CurrentValue,
+    LimitValue,
+};
+ResultVal<s64> RetrieveResourceLimitValue(Handle resource_limit, u32 resource_type,
+                                          ResourceLimitValueType value_type) {
+    const auto type = static_cast<ResourceType>(resource_type);
+    if (!IsValidResourceType(type)) {
+        LOG_ERROR(Kernel_SVC, "Invalid resource limit type: '{}'", resource_type);
+        return ERR_INVALID_ENUM_VALUE;
+    }
+    const auto& kernel = Core::System::GetInstance().Kernel();
+    const auto* const current_process = kernel.CurrentProcess();
+    ASSERT(current_process != nullptr);
+    const auto resource_limit_object =
+        current_process->GetHandleTable().Get<ResourceLimit>(resource_limit);
+    if (!resource_limit_object) {
+        LOG_ERROR(Kernel_SVC, "Handle to non-existent resource limit instance used. Handle={:08X}",
+                  resource_limit);
+        return ERR_INVALID_HANDLE;
+    }
+    if (value_type == ResourceLimitValueType::CurrentValue) {
+        return MakeResult(resource_limit_object->GetCurrentResourceValue(type));
+    }
+    return MakeResult(resource_limit_object->GetMaxResourceValue(type));
+}
 } // Anonymous namespace
 /// Set the process heap to a given Size. It can both extend and shrink the heap.
 static ResultCode SetHeapSize(VAddr* heap_addr, u64 heap_size) {
    LOG_TRACE(Kernel_SVC, "called, heap_size=0x{:X}", heap_size);
-    // Size must be a multiple of 0x200000 (2MB) and be equal to or less than 4GB.
+    // Size must be a multiple of 0x200000 (2MB) and be equal to or less than 8GB.
-    if ((heap_size & 0xFFFFFFFE001FFFFF) != 0) {
+    if ((heap_size % 0x200000) != 0) {
+        LOG_ERROR(Kernel_SVC, "The heap size is not a multiple of 2MB, heap_size=0x{:016X}",
+                  heap_size);
+        return ERR_INVALID_SIZE;
+    }
+    if (heap_size >= 0x200000000) {
+        LOG_ERROR(Kernel_SVC, "The heap size is not less than 8GB, heap_size=0x{:016X}", heap_size);
        return ERR_INVALID_SIZE;
    }
@@ -127,20 +200,31 @@ static ResultCode SetMemoryPermission(VAddr addr, u64 size, u32 prot) {
    LOG_TRACE(Kernel_SVC, "called, addr=0x{:X}, size=0x{:X}, prot=0x{:X}", addr, size, prot);
    if (!Common::Is4KBAligned(addr)) {
+        LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, addr=0x{:016X}", addr);
        return ERR_INVALID_ADDRESS;
    }
-    if (size == 0 || !Common::Is4KBAligned(size)) {
+    if (size == 0) {
+        LOG_ERROR(Kernel_SVC, "Size is 0");
+        return ERR_INVALID_SIZE;
+    }
+    if (!Common::Is4KBAligned(size)) {
+        LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, size=0x{:016X}", size);
        return ERR_INVALID_SIZE;
    }
    if (!IsValidAddressRange(addr, size)) {
+        LOG_ERROR(Kernel_SVC, "Region is not a valid address range, addr=0x{:016X}, size=0x{:016X}",
+                  addr, size);
        return ERR_INVALID_ADDRESS_STATE;
    }
    const auto permission = static_cast<MemoryPermission>(prot);
    if (permission != MemoryPermission::None && permission != MemoryPermission::Read &&
        permission != MemoryPermission::ReadWrite) {
+        LOG_ERROR(Kernel_SVC, "Invalid memory permission specified, Got memory permission=0x{:08X}",
+                  static_cast<u32>(permission));
        return ERR_INVALID_MEMORY_PERMISSIONS;
    }
@@ -148,11 +232,15 @@ static ResultCode SetMemoryPermission(VAddr addr, u64 size, u32 prot) {
    auto& vm_manager = current_process->VMManager();
    if (!IsInsideAddressSpace(vm_manager, addr, size)) {
+        LOG_ERROR(Kernel_SVC,
+                  "Source is not within the address space, addr=0x{:016X}, size=0x{:016X}", addr,
+                  size);
        return ERR_INVALID_ADDRESS_STATE;
    }
    const VMManager::VMAHandle iter = vm_manager.FindVMA(addr);
    if (iter == vm_manager.vma_map.end()) {
+        LOG_ERROR(Kernel_SVC, "Unable to find VMA for address=0x{:016X}", addr);
        return ERR_INVALID_ADDRESS_STATE;
    }
@@ -207,6 +295,9 @@ static ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
 /// Connect to an OS service given the port name, returns the handle to the port to out
 static ResultCode ConnectToNamedPort(Handle* out_handle, VAddr port_name_address) {
    if (!Memory::IsValidVirtualAddress(port_name_address)) {
+        LOG_ERROR(Kernel_SVC,
+                  "Port Name Address is not a valid virtual address, port_name_address=0x{:016X}",
+                  port_name_address);
        return ERR_NOT_FOUND;
    }
@@ -214,6 +305,8 @@ static ResultCode ConnectToNamedPort(Handle* out_handle, VAddr port_name_address
    // Read 1 char beyond the max allowed port name to detect names that are too long.
    std::string port_name = Memory::ReadCString(port_name_address, PortNameMaxLength + 1);
    if (port_name.size() > PortNameMaxLength) {
+        LOG_ERROR(Kernel_SVC, "Port name is too long, expected {} but got {}", PortNameMaxLength,
+                  port_name.size());
        return ERR_OUT_OF_RANGE;
    }
@@ -262,6 +355,7 @@ static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
    if (!thread) {
+        LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}", thread_handle);
        return ERR_INVALID_HANDLE;
    }
@@ -276,6 +370,8 @@ static ResultCode GetProcessId(u32* process_id, Handle process_handle) {
    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
    const SharedPtr<Process> process = handle_table.Get<Process>(process_handle);
    if (!process) {
+        LOG_ERROR(Kernel_SVC, "Process handle does not exist, process_handle=0x{:08X}",
+                  process_handle);
        return ERR_INVALID_HANDLE;
    }
@@ -305,12 +401,18 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
    LOG_TRACE(Kernel_SVC, "called handles_address=0x{:X}, handle_count={}, nano_seconds={}",
              handles_address, handle_count, nano_seconds);
-    if (!Memory::IsValidVirtualAddress(handles_address))
+    if (!Memory::IsValidVirtualAddress(handles_address)) {
+        LOG_ERROR(Kernel_SVC,
+                  "Handle address is not a valid virtual address, handle_address=0x{:016X}",
+                  handles_address);
        return ERR_INVALID_POINTER;
+    }
    static constexpr u64 MaxHandles = 0x40;
    if (handle_count > MaxHandles) {
+        LOG_ERROR(Kernel_SVC, "Handle count specified is too large, expected {} but got {}",
+                  MaxHandles, handle_count);
        return ERR_OUT_OF_RANGE;
    }
@@ -325,6 +427,7 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
        const auto object = handle_table.Get<WaitObject>(handle);
        if (object == nullptr) {
+            LOG_ERROR(Kernel_SVC, "Object is a nullptr");
            return ERR_INVALID_HANDLE;
        }
@@ -348,11 +451,13 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
    // If a timeout value of 0 was provided, just return the Timeout error code instead of
    // suspending the thread.
-    if (nano_seconds == 0)
+    if (nano_seconds == 0) {
        return RESULT_TIMEOUT;
+    }
-    for (auto& object : objects)
+    for (auto& object : objects) {
        object->AddWaitingThread(thread);
+    }
    thread->SetWaitObjects(std::move(objects));
    thread->SetStatus(ThreadStatus::WaitSynchAny);
@@ -373,6 +478,8 @@ static ResultCode CancelSynchronization(Handle thread_handle) {
    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
    if (!thread) {
+        LOG_ERROR(Kernel_SVC, "Thread handle does not exist, thread_handle=0x{:08X}",
+                  thread_handle);
        return ERR_INVALID_HANDLE;
    }
@@ -391,10 +498,13 @@ static ResultCode ArbitrateLock(Handle holding_thread_handle, VAddr mutex_addr,
              holding_thread_handle, mutex_addr, requesting_thread_handle);
    if (Memory::IsKernelVirtualAddress(mutex_addr)) {
+        LOG_ERROR(Kernel_SVC, "Mutex Address is a kernel virtual address, mutex_addr={:016X}",
+                  mutex_addr);
        return ERR_INVALID_ADDRESS_STATE;
    }
    if (!Common::IsWordAligned(mutex_addr)) {
+        LOG_ERROR(Kernel_SVC, "Mutex Address is not word aligned, mutex_addr={:016X}", mutex_addr);
        return ERR_INVALID_ADDRESS;
    }
@@ -408,10 +518,13 @@ static ResultCode ArbitrateUnlock(VAddr mutex_addr) {
    LOG_TRACE(Kernel_SVC, "called mutex_addr=0x{:X}", mutex_addr);
    if (Memory::IsKernelVirtualAddress(mutex_addr)) {
+        LOG_ERROR(Kernel_SVC, "Mutex Address is a kernel virtual address, mutex_addr={:016X}",
+                  mutex_addr);
        return ERR_INVALID_ADDRESS_STATE;
    }
    if (!Common::IsWordAligned(mutex_addr)) {
+        LOG_ERROR(Kernel_SVC, "Mutex Address is not word aligned, mutex_addr={:016X}", mutex_addr);
        return ERR_INVALID_ADDRESS;
    }
@@ -602,10 +715,14 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
        break;
    case GetInfoType::RandomEntropy:
        if (handle != 0) {
+            LOG_ERROR(Kernel_SVC, "Process Handle is non zero, expected 0 result but got {:016X}",
+                      handle);
            return ERR_INVALID_HANDLE;
        }
        if (info_sub_id >= Process::RANDOM_ENTROPY_SIZE) {
+            LOG_ERROR(Kernel_SVC, "Entropy size is out of range, expected {} but got {}",
+                      Process::RANDOM_ENTROPY_SIZE, info_sub_id);
            return ERR_INVALID_COMBINATION;
        }
@@ -643,12 +760,16 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
    case GetInfoType::ThreadTickCount: {
        constexpr u64 num_cpus = 4;
        if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id >= num_cpus) {
+            LOG_ERROR(Kernel_SVC, "Core count is out of range, expected {} but got {}", num_cpus,
+                      info_sub_id);
            return ERR_INVALID_COMBINATION;
        }
        const auto thread =
            current_process->GetHandleTable().Get<Thread>(static_cast<Handle>(handle));
        if (!thread) {
+            LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}",
+                      static_cast<Handle>(handle));
            return ERR_INVALID_HANDLE;
        }
@@ -671,7 +792,8 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
        break;
    }
    default:
-        UNIMPLEMENTED();
+        LOG_WARNING(Kernel_SVC, "(STUBBED) Unimplemented svcGetInfo id=0x{:016X}", info_id);
+        return ERR_INVALID_ENUM_VALUE;
    }
    return RESULT_SUCCESS;
@@ -690,14 +812,22 @@ static ResultCode GetThreadContext(VAddr thread_context, Handle handle) {
    const auto* current_process = Core::CurrentProcess();
    const SharedPtr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
    if (!thread) {
+        LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}", handle);
        return ERR_INVALID_HANDLE;
    }
    if (thread->GetOwnerProcess() != current_process) {
+        LOG_ERROR(Kernel_SVC,
+                  "The current process does not own the current thread, thread_handle={:08X} "
+                  "thread_pid={}, "
+                  "current_process_pid={}",
+                  handle, thread->GetOwnerProcess()->GetProcessID(),
+                  current_process->GetProcessID());
        return ERR_INVALID_HANDLE;
    }
    if (thread == GetCurrentThread()) {
+        LOG_ERROR(Kernel_SVC, "The thread handle specified is the current running thread");
        return ERR_ALREADY_REGISTERED;
    }
@@ -718,9 +848,12 @@ static ResultCode GetThreadContext(VAddr thread_context, Handle handle) {
 /// Gets the priority for the specified thread
 static ResultCode GetThreadPriority(u32* priority, Handle handle) {
+    LOG_TRACE(Kernel_SVC, "called");
    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
    const SharedPtr<Thread> thread = handle_table.Get<Thread>(handle);
    if (!thread) {
+        LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}", handle);
        return ERR_INVALID_HANDLE;
    }
@@ -730,7 +863,13 @@ static ResultCode GetThreadPriority(u32* priority, Handle handle) {
 /// Sets the priority for the specified thread
 static ResultCode SetThreadPriority(Handle handle, u32 priority) {
+    LOG_TRACE(Kernel_SVC, "called");
    if (priority > THREADPRIO_LOWEST) {
+        LOG_ERROR(
+            Kernel_SVC,
+            "An invalid priority was specified, expected {} but got {} for thread_handle={:08X}",
+            THREADPRIO_LOWEST, priority, handle);
        return ERR_INVALID_THREAD_PRIORITY;
    }
@@ -738,6 +877,7 @@ static ResultCode SetThreadPriority(Handle handle, u32 priority) {
    SharedPtr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
    if (!thread) {
+        LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}", handle);
        return ERR_INVALID_HANDLE;
    }
@@ -760,32 +900,46 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
              shared_memory_handle, addr, size, permissions);
    if (!Common::Is4KBAligned(addr)) {
+        LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, addr=0x{:016X}", addr);
        return ERR_INVALID_ADDRESS;
    }
-    if (size == 0 || !Common::Is4KBAligned(size)) {
+    if (size == 0) {
+        LOG_ERROR(Kernel_SVC, "Size is 0");
+        return ERR_INVALID_SIZE;
+    }
+    if (!Common::Is4KBAligned(size)) {
+        LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, size=0x{:016X}", size);
        return ERR_INVALID_SIZE;
    }
    if (!IsValidAddressRange(addr, size)) {
+        LOG_ERROR(Kernel_SVC, "Region is not a valid address range, addr=0x{:016X}, size=0x{:016X}",
+                  addr, size);
        return ERR_INVALID_ADDRESS_STATE;
    }
    const auto permissions_type = static_cast<MemoryPermission>(permissions);
    if (permissions_type != MemoryPermission::Read &&
        permissions_type != MemoryPermission::ReadWrite) {
-        LOG_ERROR(Kernel_SVC, "Invalid permissions=0x{:08X}", permissions);
+        LOG_ERROR(Kernel_SVC, "Expected Read or ReadWrite permission but got permissions=0x{:08X}",
+                  permissions);
        return ERR_INVALID_MEMORY_PERMISSIONS;
    }
    auto* const current_process = Core::CurrentProcess();
    auto shared_memory = current_process->GetHandleTable().Get<SharedMemory>(shared_memory_handle);
    if (!shared_memory) {
+        LOG_ERROR(Kernel_SVC, "Shared memory does not exist, shared_memory_handle=0x{:08X}",
+                  shared_memory_handle);
        return ERR_INVALID_HANDLE;
    }
    const auto& vm_manager = current_process->VMManager();
    if (!vm_manager.IsWithinASLRRegion(addr, size)) {
+        LOG_ERROR(Kernel_SVC, "Region is not within the ASLR region. addr=0x{:016X}, size={:016X}",
+                  addr, size);
        return ERR_INVALID_MEMORY_RANGE;
    }
@@ -797,25 +951,38 @@ static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64
                shared_memory_handle, addr, size);
    if (!Common::Is4KBAligned(addr)) {
+        LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, addr=0x{:016X}", addr);
        return ERR_INVALID_ADDRESS;
    }
-    if (size == 0 || !Common::Is4KBAligned(size)) {
+    if (size == 0) {
+        LOG_ERROR(Kernel_SVC, "Size is 0");
+        return ERR_INVALID_SIZE;
+    }
+    if (!Common::Is4KBAligned(size)) {
+        LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, size=0x{:016X}", size);
        return ERR_INVALID_SIZE;
    }
    if (!IsValidAddressRange(addr, size)) {
+        LOG_ERROR(Kernel_SVC, "Region is not a valid address range, addr=0x{:016X}, size=0x{:016X}",
+                  addr, size);
        return ERR_INVALID_ADDRESS_STATE;
    }
    auto* const current_process = Core::CurrentProcess();
    auto shared_memory = current_process->GetHandleTable().Get<SharedMemory>(shared_memory_handle);
    if (!shared_memory) {
+        LOG_ERROR(Kernel_SVC, "Shared memory does not exist, shared_memory_handle=0x{:08X}",
+                  shared_memory_handle);
        return ERR_INVALID_HANDLE;
    }
    const auto& vm_manager = current_process->VMManager();
    if (!vm_manager.IsWithinASLRRegion(addr, size)) {
+        LOG_ERROR(Kernel_SVC, "Region is not within the ASLR region. addr=0x{:016X}, size={:016X}",
+                  addr, size);
        return ERR_INVALID_MEMORY_RANGE;
    }
@@ -825,9 +992,12 @@ static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64
 /// Query process memory
 static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_info*/,
                                     Handle process_handle, u64 addr) {
+    LOG_TRACE(Kernel_SVC, "called process=0x{:08X} addr={:X}", process_handle, addr);
    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
    SharedPtr<Process> process = handle_table.Get<Process>(process_handle);
    if (!process) {
+        LOG_ERROR(Kernel_SVC, "Process handle does not exist, process_handle=0x{:08X}",
+                  process_handle);
        return ERR_INVALID_HANDLE;
    }
    auto vma = process->VMManager().FindVMA(addr);
@@ -843,8 +1013,6 @@ static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_i
        memory_info->size = vma->second.size;
        memory_info->type = static_cast<u32>(vma->second.meminfo_state);
    }
-    LOG_TRACE(Kernel_SVC, "called process=0x{:08X} addr={:X}", process_handle, addr);
    return RESULT_SUCCESS;
 }
@@ -873,7 +1041,14 @@ static void ExitProcess() {
 /// Creates a new thread
 static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, VAddr stack_top,
                               u32 priority, s32 processor_id) {
+    LOG_TRACE(Kernel_SVC,
+              "called entrypoint=0x{:08X} ({}), arg=0x{:08X}, stacktop=0x{:08X}, "
+              "threadpriority=0x{:08X}, processorid=0x{:08X} : created handle=0x{:08X}",
+              entry_point, name, arg, stack_top, priority, processor_id, *out_handle);
    if (priority > THREADPRIO_LOWEST) {
+        LOG_ERROR(Kernel_SVC, "An invalid priority was specified, expected {} but got {}",
+                  THREADPRIO_LOWEST, priority);
        return ERR_INVALID_THREAD_PRIORITY;
    }
@@ -904,6 +1079,8 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
    const auto new_guest_handle = current_process->GetHandleTable().Create(thread);
    if (new_guest_handle.Failed()) {
+        LOG_ERROR(Kernel_SVC, "Failed to create handle with error=0x{:X}",
+                  new_guest_handle.Code().raw);
        return new_guest_handle.Code();
    }
    thread->SetGuestHandle(*new_guest_handle);
@@ -911,11 +1088,6 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
    Core::System::GetInstance().CpuCore(thread->GetProcessorID()).PrepareReschedule();
-    LOG_TRACE(Kernel_SVC,
-              "called entrypoint=0x{:08X} ({}), arg=0x{:08X}, stacktop=0x{:08X}, "
-              "threadpriority=0x{:08X}, processorid=0x{:08X} : created handle=0x{:08X}",
-              entry_point, name, arg, stack_top, priority, processor_id, *out_handle);
    return RESULT_SUCCESS;
 }
@@ -926,6 +1098,8 @@ static ResultCode StartThread(Handle thread_handle) {
    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
    if (!thread) {
+        LOG_ERROR(Kernel_SVC, "Thread handle does not exist, thread_handle=0x{:08X}",
+                  thread_handle);
        return ERR_INVALID_HANDLE;
    }
@@ -1105,10 +1279,12 @@ static ResultCode WaitForAddress(VAddr address, u32 type, s32 value, s64 timeout
                address, type, value, timeout);
    // If the passed address is a kernel virtual address, return invalid memory state.
    if (Memory::IsKernelVirtualAddress(address)) {
+        LOG_ERROR(Kernel_SVC, "Address is a kernel virtual address, address={:016X}", address);
        return ERR_INVALID_ADDRESS_STATE;
    }
    // If the address is not properly aligned to 4 bytes, return invalid address.
-    if (address % sizeof(u32) != 0) {
+    if (!Common::IsWordAligned(address)) {
+        LOG_ERROR(Kernel_SVC, "Address is not word aligned, address={:016X}", address);
        return ERR_INVALID_ADDRESS;
    }
@@ -1120,6 +1296,10 @@ static ResultCode WaitForAddress(VAddr address, u32 type, s32 value, s64 timeout
    case AddressArbiter::ArbitrationType::WaitIfEqual:
        return AddressArbiter::WaitForAddressIfEqual(address, value, timeout);
    default:
+        LOG_ERROR(Kernel_SVC,
+                  "Invalid arbitration type, expected WaitIfLessThan, DecrementAndWaitIfLessThan "
+                  "or WaitIfEqual but got {}",
+                  type);
        return ERR_INVALID_ENUM_VALUE;
    }
 }
@@ -1130,10 +1310,12 @@ static ResultCode SignalToAddress(VAddr address, u32 type, s32 value, s32 num_to
                address, type, value, num_to_wake);
    // If the passed address is a kernel virtual address, return invalid memory state.
    if (Memory::IsKernelVirtualAddress(address)) {
+        LOG_ERROR(Kernel_SVC, "Address is a kernel virtual address, address={:016X}", address);
        return ERR_INVALID_ADDRESS_STATE;
    }
    // If the address is not properly aligned to 4 bytes, return invalid address.
-    if (address % sizeof(u32) != 0) {
+    if (!Common::IsWordAligned(address)) {
+        LOG_ERROR(Kernel_SVC, "Address is not word aligned, address={:016X}", address);
        return ERR_INVALID_ADDRESS;
    }
@@ -1146,12 +1328,18 @@ static ResultCode SignalToAddress(VAddr address, u32 type, s32 value, s32 num_to
        return AddressArbiter::ModifyByWaitingCountAndSignalToAddressIfEqual(address, value,
                                                                             num_to_wake);
    default:
+        LOG_ERROR(Kernel_SVC,
+                  "Invalid signal type, expected Signal, IncrementAndSignalIfEqual "
+                  "or ModifyByWaitingCountAndSignalIfEqual but got {}",
+                  type);
        return ERR_INVALID_ENUM_VALUE;
    }
 }
 /// This returns the total CPU ticks elapsed since the CPU was powered-on
 static u64 GetSystemTick() {
+    LOG_TRACE(Kernel_SVC, "called");
    const u64 result{CoreTiming::GetTicks()};
    // Advance time to defeat dumb games that busy-wait for the frame to end.
@@ -1225,6 +1413,8 @@ static ResultCode GetThreadCoreMask(Handle thread_handle, u32* core, u64* mask)
    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
    if (!thread) {
+        LOG_ERROR(Kernel_SVC, "Thread handle does not exist, thread_handle=0x{:08X}",
+                  thread_handle);
        return ERR_INVALID_HANDLE;
    }
@@ -1235,12 +1425,14 @@ static ResultCode GetThreadCoreMask(Handle thread_handle, u32* core, u64* mask)
 }
 static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
-    LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, mask=0x{:16X}, core=0x{:X}", thread_handle,
+    LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, mask=0x{:016X}, core=0x{:X}", thread_handle,
              mask, core);
    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
    if (!thread) {
+        LOG_ERROR(Kernel_SVC, "Thread handle does not exist, thread_handle=0x{:08X}",
+                  thread_handle);
        return ERR_INVALID_HANDLE;
    }
@@ -1255,6 +1447,7 @@ static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
    }
    if (mask == 0) {
+        LOG_ERROR(Kernel_SVC, "Mask is 0");
        return ERR_INVALID_COMBINATION;
    }
@@ -1264,11 +1457,14 @@ static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
    if (core == OnlyChangeMask) {
        core = thread->GetIdealCore();
    } else if (core >= Core::NUM_CPU_CORES && core != static_cast<u32>(-1)) {
+        LOG_ERROR(Kernel_SVC, "Invalid core specified, got {}", core);
        return ERR_INVALID_PROCESSOR_ID;
    }
    // Error out if the input core isn't enabled in the input mask.
    if (core < Core::NUM_CPU_CORES && (mask & (1ull << core)) == 0) {
+        LOG_ERROR(Kernel_SVC, "Core is not enabled for the current mask, core={}, mask={:016X}",
+                  core, mask);
        return ERR_INVALID_COMBINATION;
    }
@@ -1281,21 +1477,36 @@ static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permiss
                                     u32 remote_permissions) {
    LOG_TRACE(Kernel_SVC, "called, size=0x{:X}, localPerms=0x{:08X}, remotePerms=0x{:08X}", size,
              local_permissions, remote_permissions);
+    if (size == 0) {
+        LOG_ERROR(Kernel_SVC, "Size is 0");
+        return ERR_INVALID_SIZE;
+    }
+    if (!Common::Is4KBAligned(size)) {
+        LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:016X}", size);
+        return ERR_INVALID_SIZE;
+    }
-    // Size must be a multiple of 4KB and be less than or equal to
+    if (size >= MAIN_MEMORY_SIZE) {
-    // approx. 8 GB (actually (1GB - 512B) * 8)
+        LOG_ERROR(Kernel_SVC, "Size is not less than 8GB, 0x{:016X}", size);
-    if (size == 0 || (size & 0xFFFFFFFE00000FFF) != 0) {
        return ERR_INVALID_SIZE;
    }
    const auto local_perms = static_cast<MemoryPermission>(local_permissions);
    if (local_perms != MemoryPermission::Read && local_perms != MemoryPermission::ReadWrite) {
+        LOG_ERROR(Kernel_SVC,
+                  "Invalid local memory permissions, expected Read or ReadWrite but got "
+                  "local_permissions={}",
+                  static_cast<u32>(local_permissions));
        return ERR_INVALID_MEMORY_PERMISSIONS;
    }
    const auto remote_perms = static_cast<MemoryPermission>(remote_permissions);
    if (remote_perms != MemoryPermission::Read && remote_perms != MemoryPermission::ReadWrite &&
        remote_perms != MemoryPermission::DontCare) {
+        LOG_ERROR(Kernel_SVC,
+                  "Invalid remote memory permissions, expected Read, ReadWrite or DontCare but got "
+                  "remote_permissions={}",
+                  static_cast<u32>(remote_permissions));
        return ERR_INVALID_MEMORY_PERMISSIONS;
    }
@@ -1315,6 +1526,7 @@ static ResultCode ClearEvent(Handle handle) {
    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
    SharedPtr<Event> evt = handle_table.Get<Event>(handle);
    if (evt == nullptr) {
+        LOG_ERROR(Kernel_SVC, "Event handle does not exist, handle=0x{:08X}", handle);
        return ERR_INVALID_HANDLE;
    }
@@ -1333,11 +1545,14 @@ static ResultCode GetProcessInfo(u64* out, Handle process_handle, u32 type) {
    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
    const auto process = handle_table.Get<Process>(process_handle);
    if (!process) {
+        LOG_ERROR(Kernel_SVC, "Process handle does not exist, process_handle=0x{:08X}",
+                  process_handle);
        return ERR_INVALID_HANDLE;
    }
    const auto info_type = static_cast<InfoType>(type);
    if (info_type != InfoType::Status) {
+        LOG_ERROR(Kernel_SVC, "Expected info_type to be Status but got {} instead", type);
        return ERR_INVALID_ENUM_VALUE;
    }
@@ -1345,6 +1560,87 @@ static ResultCode GetProcessInfo(u64* out, Handle process_handle, u32 type) {
    return RESULT_SUCCESS;
 }
+static ResultCode CreateResourceLimit(Handle* out_handle) {
+    LOG_DEBUG(Kernel_SVC, "called");
+    auto& kernel = Core::System::GetInstance().Kernel();
+    auto resource_limit = ResourceLimit::Create(kernel);
+    auto* const current_process = kernel.CurrentProcess();
+    ASSERT(current_process != nullptr);
+    const auto handle = current_process->GetHandleTable().Create(std::move(resource_limit));
+    if (handle.Failed()) {
+        return handle.Code();
+    }
+    *out_handle = *handle;
+    return RESULT_SUCCESS;
+}
+static ResultCode GetResourceLimitLimitValue(u64* out_value, Handle resource_limit,
+                                             u32 resource_type) {
+    LOG_DEBUG(Kernel_SVC, "called. Handle={:08X}, Resource type={}", resource_limit, resource_type);
+    const auto limit_value = RetrieveResourceLimitValue(resource_limit, resource_type,
+                                                        ResourceLimitValueType::LimitValue);
+    if (limit_value.Failed()) {
+        return limit_value.Code();
+    }
+    *out_value = static_cast<u64>(*limit_value);
+    return RESULT_SUCCESS;
+}
+static ResultCode GetResourceLimitCurrentValue(u64* out_value, Handle resource_limit,
+                                               u32 resource_type) {
+    LOG_DEBUG(Kernel_SVC, "called. Handle={:08X}, Resource type={}", resource_limit, resource_type);
+    const auto current_value = RetrieveResourceLimitValue(resource_limit, resource_type,
+                                                          ResourceLimitValueType::CurrentValue);
+    if (current_value.Failed()) {
+        return current_value.Code();
+    }
+    *out_value = static_cast<u64>(*current_value);
+    return RESULT_SUCCESS;
+}
+static ResultCode SetResourceLimitLimitValue(Handle resource_limit, u32 resource_type, u64 value) {
+    LOG_DEBUG(Kernel_SVC, "called. Handle={:08X}, Resource type={}, Value={}", resource_limit,
+              resource_type, value);
+    const auto type = static_cast<ResourceType>(resource_type);
+    if (!IsValidResourceType(type)) {
+        LOG_ERROR(Kernel_SVC, "Invalid resource limit type: '{}'", resource_type);
+        return ERR_INVALID_ENUM_VALUE;
+    }
+    auto& kernel = Core::System::GetInstance().Kernel();
+    auto* const current_process = kernel.CurrentProcess();
+    ASSERT(current_process != nullptr);
+    auto resource_limit_object =
+        current_process->GetHandleTable().Get<ResourceLimit>(resource_limit);
+    if (!resource_limit_object) {
+        LOG_ERROR(Kernel_SVC, "Handle to non-existent resource limit instance used. Handle={:08X}",
+                  resource_limit);
+        return ERR_INVALID_HANDLE;
+    }
+    const auto set_result = resource_limit_object->SetLimitValue(type, static_cast<s64>(value));
+    if (set_result.IsError()) {
+        LOG_ERROR(
+            Kernel_SVC,
+            "Attempted to lower resource limit ({}) for category '{}' below its current value ({})",
+            resource_limit_object->GetMaxResourceValue(type), resource_type,
+            resource_limit_object->GetCurrentResourceValue(type));
+        return set_result;
+    }
+    return RESULT_SUCCESS;
+}
 namespace {
 struct FunctionDef {
    using Func = void();
@@ -1404,8 +1700,8 @@ static const FunctionDef SVC_Table[] = {
    {0x2D, nullptr, "UnmapPhysicalMemory"},
    {0x2E, nullptr, "GetFutureThreadInfo"},
    {0x2F, nullptr, "GetLastThreadInfo"},
-    {0x30, nullptr, "GetResourceLimitLimitValue"},
+    {0x30, SvcWrap<GetResourceLimitLimitValue>, "GetResourceLimitLimitValue"},
-    {0x31, nullptr, "GetResourceLimitCurrentValue"},
+    {0x31, SvcWrap<GetResourceLimitCurrentValue>, "GetResourceLimitCurrentValue"},
    {0x32, SvcWrap<SetThreadActivity>, "SetThreadActivity"},
    {0x33, SvcWrap<GetThreadContext>, "GetThreadContext"},
    {0x34, SvcWrap<WaitForAddress>, "WaitForAddress"},
@@ -1481,8 +1777,8 @@ static const FunctionDef SVC_Table[] = {
    {0x7A, nullptr, "StartProcess"},
    {0x7B, nullptr, "TerminateProcess"},
    {0x7C, SvcWrap<GetProcessInfo>, "GetProcessInfo"},
-    {0x7D, nullptr, "CreateResourceLimit"},
+    {0x7D, SvcWrap<CreateResourceLimit>, "CreateResourceLimit"},
-    {0x7E, nullptr, "SetResourceLimitLimitValue"},
+    {0x7E, SvcWrap<SetResourceLimitLimitValue>, "SetResourceLimitLimitValue"},
    {0x7F, nullptr, "CallSecureMonitor"},
 };
diff --git a/src/core/hle/kernel/svc_wrap.h b/src/core/hle/kernel/svc_wrap.h
index 233a99fb0..fa1116624 100644
--- a/src/core/hle/kernel/svc_wrap.h
+++ b/src/core/hle/kernel/svc_wrap.h
@@ -43,6 +43,14 @@ void SvcWrap() {
    FuncReturn(func(static_cast<u32>(Param(0)), static_cast<u32>(Param(1))).raw);
 }
+template <ResultCode func(u32*)>
+void SvcWrap() {
+    u32 param = 0;
+    const u32 retval = func(&param).raw;
+    Core::CurrentArmInterface().SetReg(1, param);
+    FuncReturn(retval);
+}
 template <ResultCode func(u32*, u32)>
 void SvcWrap() {
    u32 param_1 = 0;
diff --git a/src/core/hle/service/acc/acc.cpp b/src/core/hle/service/acc/acc.cpp
index c629f9357..1f8ed265e 100644
--- a/src/core/hle/service/acc/acc.cpp
+++ b/src/core/hle/service/acc/acc.cpp
@@ -21,17 +21,6 @@
 namespace Service::Account {
-// TODO: RE this structure
-struct UserData {
-    INSERT_PADDING_WORDS(1);
-    u32 icon_id;
-    u8 bg_color_id;
-    INSERT_PADDING_BYTES(0x7);
-    INSERT_PADDING_BYTES(0x10);
-    INSERT_PADDING_BYTES(0x60);
-};
-static_assert(sizeof(UserData) == 0x80, "UserData structure has incorrect size");
 // Smallest JPEG https://github.com/mathiasbynens/small/blob/master/jpeg.jpg
 // used as a backup should the one on disk not exist
 constexpr u32 backup_jpeg_size = 107;
@@ -72,9 +61,11 @@ private:
    void Get(Kernel::HLERequestContext& ctx) {
        LOG_INFO(Service_ACC, "called user_id={}", user_id.Format());
        ProfileBase profile_base{};
-        std::array<u8, MAX_DATA> data{};
+        ProfileData data{};
        if (profile_manager.GetProfileBaseAndData(user_id, profile_base, data)) {
-            ctx.WriteBuffer(data);
+            std::array<u8, sizeof(ProfileData)> raw_data;
+            std::memcpy(raw_data.data(), &data, sizeof(ProfileData));
+            ctx.WriteBuffer(raw_data);
            IPC::ResponseBuilder rb{ctx, 16};
            rb.Push(RESULT_SUCCESS);
            rb.PushRaw(profile_base);
@@ -216,10 +207,11 @@ void Module::Interface::GetLastOpenedUser(Kernel::HLERequestContext& ctx) {
 void Module::Interface::GetProfile(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    UUID user_id = rp.PopRaw<UUID>();
+    LOG_DEBUG(Service_ACC, "called user_id={}", user_id.Format());
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IProfile>(user_id, *profile_manager);
-    LOG_DEBUG(Service_ACC, "called user_id={}", user_id.Format());
 }
 void Module::Interface::IsUserRegistrationRequestPermitted(Kernel::HLERequestContext& ctx) {
@@ -236,10 +228,10 @@ void Module::Interface::InitializeApplicationInfo(Kernel::HLERequestContext& ctx
 }
 void Module::Interface::GetBaasAccountManagerForApplication(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_ACC, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IManagerForApplication>();
-    LOG_DEBUG(Service_ACC, "called");
 }
 void Module::Interface::TrySelectUserWithoutInteraction(Kernel::HLERequestContext& ctx) {
diff --git a/src/core/hle/service/acc/profile_manager.cpp b/src/core/hle/service/acc/profile_manager.cpp
index 968263846..1316d0b07 100644
--- a/src/core/hle/service/acc/profile_manager.cpp
+++ b/src/core/hle/service/acc/profile_manager.cpp
@@ -18,7 +18,7 @@ struct UserRaw {
    UUID uuid2;
    u64 timestamp;
    ProfileUsername username;
-    INSERT_PADDING_BYTES(0x80);
+    ProfileData extra_data;
 };
 static_assert(sizeof(UserRaw) == 0xC8, "UserRaw has incorrect size.");
@@ -346,7 +346,7 @@ void ProfileManager::ParseUserSaveFile() {
            continue;
        }
-        AddUser({user.uuid, user.username, user.timestamp, {}, false});
+        AddUser({user.uuid, user.username, user.timestamp, user.extra_data, false});
    }
    std::stable_partition(profiles.begin(), profiles.end(),
@@ -361,6 +361,7 @@ void ProfileManager::WriteUserSaveFile() {
        raw.users[i].uuid2 = profiles[i].user_uuid;
        raw.users[i].uuid = profiles[i].user_uuid;
        raw.users[i].timestamp = profiles[i].creation_time;
+        raw.users[i].extra_data = profiles[i].data;
    }
    const auto raw_path =
diff --git a/src/core/hle/service/acc/profile_manager.h b/src/core/hle/service/acc/profile_manager.h
index d2d8e6c6b..c4ce2e0b3 100644
--- a/src/core/hle/service/acc/profile_manager.h
+++ b/src/core/hle/service/acc/profile_manager.h
@@ -13,7 +13,6 @@
 namespace Service::Account {
 constexpr std::size_t MAX_USERS = 8;
-constexpr std::size_t MAX_DATA = 128;
 constexpr u128 INVALID_UUID{{0, 0}};
 struct UUID {
@@ -50,9 +49,20 @@ static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");
 constexpr std::size_t profile_username_size = 32;
 using ProfileUsername = std::array<u8, profile_username_size>;
-using ProfileData = std::array<u8, MAX_DATA>;
 using UserIDArray = std::array<UUID, MAX_USERS>;
+/// Contains extra data related to a user.
+/// TODO: RE this structure
+struct ProfileData {
+    INSERT_PADDING_WORDS(1);
+    u32 icon_id;
+    u8 bg_color_id;
+    INSERT_PADDING_BYTES(0x7);
+    INSERT_PADDING_BYTES(0x10);
+    INSERT_PADDING_BYTES(0x60);
+};
+static_assert(sizeof(ProfileData) == 0x80, "ProfileData structure has incorrect size");
 /// This holds general information about a users profile. This is where we store all the information
 /// based on a specific user
 struct ProfileInfo {
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index 11181a0af..d595c37b0 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -6,8 +6,6 @@
 #include <cinttypes>
 #include <cstring>
 #include <stack>
-#include "applets/applets.h"
-#include "applets/software_keyboard.h"
 #include "audio_core/audio_renderer.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
@@ -18,6 +16,9 @@
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/am/applet_oe.h"
+#include "core/hle/service/am/applets/applets.h"
+#include "core/hle/service/am/applets/software_keyboard.h"
+#include "core/hle/service/am/applets/stub_applet.h"
 #include "core/hle/service/am/idle.h"
 #include "core/hle/service/am/omm.h"
 #include "core/hle/service/am/spsm.h"
@@ -216,6 +217,7 @@ ISelfController::~ISelfController() = default;
 void ISelfController::SetFocusHandlingMode(Kernel::HLERequestContext& ctx) {
    // Takes 3 input u8s with each field located immediately after the previous
    // u8, these are bool flags. No output.
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::RequestParser rp{ctx};
@@ -228,44 +230,40 @@ void ISelfController::SetFocusHandlingMode(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::SetRestartMessageEnabled(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::SetPerformanceModeChangedNotification(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    bool flag = rp.Pop<bool>();
+    LOG_WARNING(Service_AM, "(STUBBED) called flag={}", flag);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called flag={}", flag);
 }
 void ISelfController::SetScreenShotPermission(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::SetOperationModeChangedNotification(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    bool flag = rp.Pop<bool>();
+    LOG_WARNING(Service_AM, "(STUBBED) called flag={}", flag);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called flag={}", flag);
 }
 void ISelfController::SetOutOfFocusSuspendingEnabled(Kernel::HLERequestContext& ctx) {
@@ -274,45 +272,45 @@ void ISelfController::SetOutOfFocusSuspendingEnabled(Kernel::HLERequestContext&
    IPC::RequestParser rp{ctx};
    bool enabled = rp.Pop<bool>();
+    LOG_WARNING(Service_AM, "(STUBBED) called enabled={}", enabled);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called enabled={}", enabled);
 }
 void ISelfController::LockExit(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::UnlockExit(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    launchable_event->Signal();
    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushCopyObjects(launchable_event);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::SetScreenShotImageOrientation(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    // TODO(Subv): Find out how AM determines the display to use, for now just
    // create the layer in the Default display.
    u64 display_id = nvflinger->OpenDisplay("Default");
@@ -321,32 +319,31 @@ void ISelfController::CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx)
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(RESULT_SUCCESS);
    rb.Push(layer_id);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::SetHandlesRequestToDisplay(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::SetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    idle_time_detection_extension = rp.Pop<u32>();
+    LOG_WARNING(Service_AM, "(STUBBED) called idle_time_detection_extension={}",
+                idle_time_detection_extension);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::GetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(idle_time_detection_extension);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 AppletMessageQueue::AppletMessageQueue() {
@@ -437,59 +434,63 @@ ICommonStateGetter::ICommonStateGetter(std::shared_ptr<AppletMessageQueue> msg_q
 ICommonStateGetter::~ICommonStateGetter() = default;
 void ICommonStateGetter::GetBootMode(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u8>(static_cast<u8>(Service::PM::SystemBootMode::Normal)); // Normal boot mode
-    LOG_DEBUG(Service_AM, "called");
 }
 void ICommonStateGetter::GetEventHandle(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called");
    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushCopyObjects(msg_queue->GetMesssageRecieveEvent());
-    LOG_DEBUG(Service_AM, "called");
 }
 void ICommonStateGetter::ReceiveMessage(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.PushEnum<AppletMessageQueue::AppletMessage>(msg_queue->PopMessage());
-    LOG_DEBUG(Service_AM, "called");
 }
 void ICommonStateGetter::GetCurrentFocusState(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push(static_cast<u8>(FocusState::InFocus));
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ICommonStateGetter::GetDefaultDisplayResolutionChangeEvent(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called");
    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushCopyObjects(msg_queue->GetOperationModeChangedEvent());
-    LOG_DEBUG(Service_AM, "called");
 }
 void ICommonStateGetter::GetDefaultDisplayResolution(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called");
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(RESULT_SUCCESS);
    if (Settings::values.use_docked_mode) {
-        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth));
+        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth) *
-        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight));
+                static_cast<u32>(Settings::values.resolution_factor));
+        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight) *
+                static_cast<u32>(Settings::values.resolution_factor));
    } else {
-        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth));
+        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth) *
-        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight));
+                static_cast<u32>(Settings::values.resolution_factor));
+        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight) *
+                static_cast<u32>(Settings::values.resolution_factor));
    }
-    LOG_DEBUG(Service_AM, "called");
 }
 IStorage::IStorage(std::vector<u8> buffer)
@@ -512,21 +513,21 @@ const std::vector<u8>& IStorage::GetData() const {
 void ICommonStateGetter::GetOperationMode(Kernel::HLERequestContext& ctx) {
    const bool use_docked_mode{Settings::values.use_docked_mode};
+    LOG_DEBUG(Service_AM, "called, use_docked_mode={}", use_docked_mode);
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push(static_cast<u8>(use_docked_mode ? OperationMode::Docked : OperationMode::Handheld));
-    LOG_DEBUG(Service_AM, "called");
 }
 void ICommonStateGetter::GetPerformanceMode(Kernel::HLERequestContext& ctx) {
    const bool use_docked_mode{Settings::values.use_docked_mode};
+    LOG_DEBUG(Service_AM, "called, use_docked_mode={}", use_docked_mode);
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push(static_cast<u32>(use_docked_mode ? APM::PerformanceMode::Docked
                                             : APM::PerformanceMode::Handheld));
-    LOG_DEBUG(Service_AM, "called");
 }
 class ILibraryAppletAccessor final : public ServiceFramework<ILibraryAppletAccessor> {
@@ -561,32 +562,34 @@ public:
 private:
    void GetAppletStateChangedEvent(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        const auto event = applet->GetBroker().GetStateChangedEvent();
        event->Signal();
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(event);
-        LOG_DEBUG(Service_AM, "called");
    }
    void IsCompleted(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(applet->TransactionComplete());
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetResult(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(applet->GetStatus());
-        LOG_DEBUG(Service_AM, "called");
    }
    void Start(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        ASSERT(applet != nullptr);
        applet->Initialize();
@@ -594,36 +597,39 @@ private:
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_AM, "called");
    }
    void PushInData(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::RequestParser rp{ctx};
        applet->GetBroker().PushNormalDataFromGame(*rp.PopIpcInterface<IStorage>());
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_AM, "called");
    }
    void PopOutData(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        const auto storage = applet->GetBroker().PopNormalDataToGame();
        if (storage == nullptr) {
+            LOG_ERROR(Service_AM,
+                      "storage is a nullptr. There is no data in the current normal channel");
            rb.Push(ERR_NO_DATA_IN_CHANNEL);
            return;
        }
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IStorage>(std::move(*storage));
-        LOG_DEBUG(Service_AM, "called");
    }
    void PushInteractiveInData(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::RequestParser rp{ctx};
        applet->GetBroker().PushInteractiveDataFromGame(*rp.PopIpcInterface<IStorage>());
@@ -633,51 +639,52 @@ private:
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_AM, "called");
    }
    void PopInteractiveOutData(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        const auto storage = applet->GetBroker().PopInteractiveDataToGame();
        if (storage == nullptr) {
+            LOG_ERROR(Service_AM,
+                      "storage is a nullptr. There is no data in the current interactive channel");
            rb.Push(ERR_NO_DATA_IN_CHANNEL);
            return;
        }
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IStorage>(std::move(*storage));
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetPopOutDataEvent(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(applet->GetBroker().GetNormalDataEvent());
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetPopInteractiveOutDataEvent(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(applet->GetBroker().GetInteractiveDataEvent());
-        LOG_DEBUG(Service_AM, "called");
    }
    std::shared_ptr<Applets::Applet> applet;
 };
 void IStorage::Open(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IStorageAccessor>(*this);
-    LOG_DEBUG(Service_AM, "called");
 }
 IStorageAccessor::IStorageAccessor(IStorage& storage)
@@ -696,21 +703,27 @@ IStorageAccessor::IStorageAccessor(IStorage& storage)
 IStorageAccessor::~IStorageAccessor() = default;
 void IStorageAccessor::GetSize(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called");
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(RESULT_SUCCESS);
    rb.Push(static_cast<u64>(backing.buffer.size()));
-    LOG_DEBUG(Service_AM, "called");
 }
 void IStorageAccessor::Write(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const u64 offset{rp.Pop<u64>()};
+    LOG_DEBUG(Service_AM, "called, offset={}", offset);
    const std::vector<u8> data{ctx.ReadBuffer()};
    if (data.size() > backing.buffer.size() - offset) {
+        LOG_ERROR(Service_AM,
+                  "offset is out of bounds, backing_buffer_sz={}, data_size={}, offset={}",
+                  backing.buffer.size(), data.size(), offset);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(ERR_SIZE_OUT_OF_BOUNDS);
    }
@@ -719,17 +732,20 @@ void IStorageAccessor::Write(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_DEBUG(Service_AM, "called, offset={}", offset);
 }
 void IStorageAccessor::Read(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const u64 offset{rp.Pop<u64>()};
+    LOG_DEBUG(Service_AM, "called, offset={}", offset);
    const std::size_t size{ctx.GetWriteBufferSize()};
    if (size > backing.buffer.size() - offset) {
+        LOG_ERROR(Service_AM, "offset is out of bounds, backing_buffer_sz={}, size={}, offset={}",
+                  backing.buffer.size(), size, offset);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(ERR_SIZE_OUT_OF_BOUNDS);
    }
@@ -738,8 +754,6 @@ void IStorageAccessor::Read(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_DEBUG(Service_AM, "called, offset={}", offset);
 }
 ILibraryAppletCreator::ILibraryAppletCreator() : ServiceFramework("ILibraryAppletCreator") {
@@ -761,8 +775,9 @@ static std::shared_ptr<Applets::Applet> GetAppletFromId(AppletId id) {
    case AppletId::SoftwareKeyboard:
        return std::make_shared<Applets::SoftwareKeyboard>();
    default:
-        UNREACHABLE_MSG("Unimplemented AppletId [{:08X}]!", static_cast<u32>(id));
+        LOG_ERROR(Service_AM, "Unimplemented AppletId [{:08X}]! -- Falling back to stub!",
-        return nullptr;
+                  static_cast<u32>(id));
+        return std::make_shared<Applets::StubApplet>();
    }
 }
@@ -777,6 +792,8 @@ void ILibraryAppletCreator::CreateLibraryApplet(Kernel::HLERequestContext& ctx)
    const auto applet = GetAppletFromId(applet_id);
    if (applet == nullptr) {
+        LOG_ERROR(Service_AM, "Applet doesn't exist! applet_id={}", static_cast<u32>(applet_id));
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(ResultCode(-1));
        return;
@@ -786,23 +803,23 @@ void ILibraryAppletCreator::CreateLibraryApplet(Kernel::HLERequestContext& ctx)
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<AM::ILibraryAppletAccessor>(applet);
-    LOG_DEBUG(Service_AM, "called");
 }
 void ILibraryAppletCreator::CreateStorage(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const u64 size{rp.Pop<u64>()};
+    LOG_DEBUG(Service_AM, "called, size={}", size);
    std::vector<u8> buffer(size);
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<AM::IStorage>(std::move(buffer));
-    LOG_DEBUG(Service_AM, "called, size={}", size);
 }
 void ILibraryAppletCreator::CreateTransferMemoryStorage(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called");
    IPC::RequestParser rp{ctx};
    rp.SetCurrentOffset(3);
@@ -813,6 +830,7 @@ void ILibraryAppletCreator::CreateTransferMemoryStorage(Kernel::HLERequestContex
            handle);
    if (shared_mem == nullptr) {
+        LOG_ERROR(Service_AM, "shared_mem is a nullpr for handle={:08X}", handle);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(ResultCode(-1));
        return;
@@ -876,38 +894,45 @@ IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationF
 IApplicationFunctions::~IApplicationFunctions() = default;
 void IApplicationFunctions::EnableApplicationCrashReport(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void IApplicationFunctions::BeginBlockingHomeButtonShortAndLongPressed(
    Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void IApplicationFunctions::EndBlockingHomeButtonShortAndLongPressed(
    Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void IApplicationFunctions::BeginBlockingHomeButton(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void IApplicationFunctions::EndBlockingHomeButton(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called");
    LaunchParameters params{};
    params.magic = POP_LAUNCH_PARAMETER_MAGIC;
@@ -926,21 +951,19 @@ void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
    std::memcpy(buffer.data(), &params, buffer.size());
    rb.PushIpcInterface<AM::IStorage>(buffer);
-    LOG_DEBUG(Service_AM, "called");
 }
 void IApplicationFunctions::CreateApplicationAndRequestToStartForQuest(
    Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void IApplicationFunctions::EnsureSaveData(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    u128 uid = rp.PopRaw<u128>(); // What does this do?
    LOG_WARNING(Service, "(STUBBED) called uid = {:016X}{:016X}", uid[1], uid[0]);
    IPC::ResponseBuilder rb{ctx, 4};
@@ -955,60 +978,62 @@ void IApplicationFunctions::SetTerminateResult(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    u32 result = rp.Pop<u32>();
+    LOG_WARNING(Service_AM, "(STUBBED) called, result=0x{:08X}", result);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called, result=0x{:08X}", result);
 }
 void IApplicationFunctions::GetDisplayVersion(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 6};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u64>(1);
    rb.Push<u64>(0);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
    // TODO(bunnei): This should be configurable
+    LOG_DEBUG(Service_AM, "called");
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(RESULT_SUCCESS);
    rb.Push(
        static_cast<u64>(Service::Set::GetLanguageCodeFromIndex(Settings::values.language_index)));
-    LOG_DEBUG(Service_AM, "called");
 }
 void IApplicationFunctions::InitializeGamePlayRecording(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void IApplicationFunctions::SetGamePlayRecordingState(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void IApplicationFunctions::NotifyRunning(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u8>(0); // Unknown, seems to be ignored by official processes
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void IApplicationFunctions::GetPseudoDeviceId(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 6};
    rb.Push(RESULT_SUCCESS);
    // Returns a 128-bit UUID
    rb.Push<u64>(0);
    rb.Push<u64>(0);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void InstallInterfaces(SM::ServiceManager& service_manager,
@@ -1045,9 +1070,10 @@ IHomeMenuFunctions::IHomeMenuFunctions() : ServiceFramework("IHomeMenuFunctions"
 IHomeMenuFunctions::~IHomeMenuFunctions() = default;
 void IHomeMenuFunctions::RequestToGetForeground(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 IGlobalStateController::IGlobalStateController() : ServiceFramework("IGlobalStateController") {
diff --git a/src/core/hle/service/am/applet_ae.cpp b/src/core/hle/service/am/applet_ae.cpp
index ec93e3529..41a573a91 100644
--- a/src/core/hle/service/am/applet_ae.cpp
+++ b/src/core/hle/service/am/applet_ae.cpp
@@ -32,66 +32,75 @@ public:
 private:
    void GetCommonStateGetter(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ICommonStateGetter>(msg_queue);
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetSelfController(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ISelfController>(nvflinger);
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetWindowController(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IWindowController>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetAudioController(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IAudioController>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetDisplayController(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IDisplayController>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetProcessWindingController(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IProcessWindingController>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetDebugFunctions(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IDebugFunctions>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetLibraryAppletCreator(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ILibraryAppletCreator>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetApplicationFunctions(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IApplicationFunctions>();
-        LOG_DEBUG(Service_AM, "called");
    }
    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
@@ -122,97 +131,110 @@ public:
 private:
    void GetCommonStateGetter(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ICommonStateGetter>(msg_queue);
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetSelfController(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ISelfController>(nvflinger);
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetWindowController(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IWindowController>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetAudioController(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IAudioController>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetDisplayController(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IDisplayController>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetDebugFunctions(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IDebugFunctions>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetLibraryAppletCreator(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ILibraryAppletCreator>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetHomeMenuFunctions(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IHomeMenuFunctions>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetGlobalStateController(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IGlobalStateController>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetApplicationCreator(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IApplicationCreator>();
-        LOG_DEBUG(Service_AM, "called");
    }
    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
    std::shared_ptr<AppletMessageQueue> msg_queue;
 };
 void AppletAE::OpenSystemAppletProxy(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ISystemAppletProxy>(nvflinger, msg_queue);
-    LOG_DEBUG(Service_AM, "called");
 }
 void AppletAE::OpenLibraryAppletProxy(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger, msg_queue);
-    LOG_DEBUG(Service_AM, "called");
 }
 void AppletAE::OpenLibraryAppletProxyOld(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger, msg_queue);
-    LOG_DEBUG(Service_AM, "called");
 }
 AppletAE::AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
diff --git a/src/core/hle/service/am/applet_oe.cpp b/src/core/hle/service/am/applet_oe.cpp
index 20c8d5fff..d3a0a1568 100644
--- a/src/core/hle/service/am/applet_oe.cpp
+++ b/src/core/hle/service/am/applet_oe.cpp
@@ -35,59 +35,67 @@ public:
 private:
    void GetAudioController(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IAudioController>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetDisplayController(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IDisplayController>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetDebugFunctions(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IDebugFunctions>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetWindowController(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IWindowController>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetSelfController(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ISelfController>(nvflinger);
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetCommonStateGetter(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ICommonStateGetter>(msg_queue);
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetLibraryAppletCreator(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ILibraryAppletCreator>();
-        LOG_DEBUG(Service_AM, "called");
    }
    void GetApplicationFunctions(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IApplicationFunctions>();
-        LOG_DEBUG(Service_AM, "called");
    }
    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
@@ -95,10 +103,11 @@ private:
 };
 void AppletOE::OpenApplicationProxy(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IApplicationProxy>(nvflinger, msg_queue);
-    LOG_DEBUG(Service_AM, "called");
 }
 AppletOE::AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
diff --git a/src/core/hle/service/am/applets/stub_applet.cpp b/src/core/hle/service/am/applets/stub_applet.cpp
new file mode 100644
index 000000000..ed166b87d
--- /dev/null
+++ b/src/core/hle/service/am/applets/stub_applet.cpp
@@ -0,0 +1,70 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#include <string>
+#include "common/hex_util.h"
+#include "common/logging/log.h"
+#include "core/hle/result.h"
+#include "core/hle/service/am/am.h"
+#include "core/hle/service/am/applets/stub_applet.h"
+namespace Service::AM::Applets {
+static void LogCurrentStorage(AppletDataBroker& broker, std::string prefix) {
+    std::unique_ptr<IStorage> storage = broker.PopNormalDataToApplet();
+    for (; storage != nullptr; storage = broker.PopNormalDataToApplet()) {
+        const auto data = storage->GetData();
+        LOG_INFO(Service_AM,
+                 "called (STUBBED), during {} recieved normal data with size={:08X}, data={}",
+                 prefix, data.size(), Common::HexVectorToString(data));
+    }
+    storage = broker.PopInteractiveDataToApplet();
+    for (; storage != nullptr; storage = broker.PopInteractiveDataToApplet()) {
+        const auto data = storage->GetData();
+        LOG_INFO(Service_AM,
+                 "called (STUBBED), during {} recieved interactive data with size={:08X}, data={}",
+                 prefix, data.size(), Common::HexVectorToString(data));
+    }
+}
+StubApplet::StubApplet() = default;
+StubApplet::~StubApplet() = default;
+void StubApplet::Initialize() {
+    LOG_WARNING(Service_AM, "called (STUBBED)");
+    Applet::Initialize();
+    LogCurrentStorage(broker, "Initialize");
+}
+bool StubApplet::TransactionComplete() const {
+    LOG_WARNING(Service_AM, "called (STUBBED)");
+    return true;
+}
+ResultCode StubApplet::GetStatus() const {
+    LOG_WARNING(Service_AM, "called (STUBBED)");
+    return RESULT_SUCCESS;
+}
+void StubApplet::ExecuteInteractive() {
+    LOG_WARNING(Service_AM, "called (STUBBED)");
+    LogCurrentStorage(broker, "ExecuteInteractive");
+    broker.PushNormalDataFromApplet(IStorage{std::vector<u8>(0x1000)});
+    broker.PushInteractiveDataFromApplet(IStorage{std::vector<u8>(0x1000)});
+    broker.SignalStateChanged();
+}
+void StubApplet::Execute() {
+    LOG_WARNING(Service_AM, "called (STUBBED)");
+    LogCurrentStorage(broker, "Execute");
+    broker.PushNormalDataFromApplet(IStorage{std::vector<u8>(0x1000)});
+    broker.PushInteractiveDataFromApplet(IStorage{std::vector<u8>(0x1000)});
+    broker.SignalStateChanged();
+}
+} // namespace Service::AM::Applets
diff --git a/src/core/hle/service/am/applets/stub_applet.h b/src/core/hle/service/am/applets/stub_applet.h
new file mode 100644
index 000000000..7d8dc968d
--- /dev/null
+++ b/src/core/hle/service/am/applets/stub_applet.h
@@ -0,0 +1,24 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#pragma once
+#include "core/hle/service/am/applets/applets.h"
+namespace Service::AM::Applets {
+class StubApplet final : public Applet {
+public:
+    StubApplet();
+    ~StubApplet() override;
+    void Initialize() override;
+    bool TransactionComplete() const override;
+    ResultCode GetStatus() const override;
+    void ExecuteInteractive() override;
+    void Execute() override;
+};
+} // namespace Service::AM::Applets
diff --git a/src/core/hle/service/aoc/aoc_u.cpp b/src/core/hle/service/aoc/aoc_u.cpp
index 54305cf05..bacf19de2 100644
--- a/src/core/hle/service/aoc/aoc_u.cpp
+++ b/src/core/hle/service/aoc/aoc_u.cpp
@@ -68,6 +68,8 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs
 AOC_U::~AOC_U() = default;
 void AOC_U::CountAddOnContent(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AOC, "called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
@@ -82,6 +84,7 @@ void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
    const auto offset = rp.PopRaw<u32>();
    auto count = rp.PopRaw<u32>();
+    LOG_DEBUG(Service_AOC, "called with offset={}, count={}", offset, count);
    const auto current = Core::System::GetInstance().CurrentProcess()->GetTitleID();
@@ -110,6 +113,8 @@ void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
 }
 void AOC_U::GetAddOnContentBaseId(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AOC, "called");
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(RESULT_SUCCESS);
    const auto title_id = Core::System::GetInstance().CurrentProcess()->GetTitleID();
@@ -128,7 +133,6 @@ void AOC_U::PrepareAddOnContent(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto aoc_id = rp.PopRaw<u32>();
    LOG_WARNING(Service_AOC, "(STUBBED) called with aoc_id={:08X}", aoc_id);
    IPC::ResponseBuilder rb{ctx, 2};
diff --git a/src/core/hle/service/apm/interface.cpp b/src/core/hle/service/apm/interface.cpp
index c22bd3859..fcacbab72 100644
--- a/src/core/hle/service/apm/interface.cpp
+++ b/src/core/hle/service/apm/interface.cpp
@@ -40,24 +40,22 @@ private:
        auto mode = static_cast<PerformanceMode>(rp.Pop<u32>());
        u32 config = rp.Pop<u32>();
+        LOG_WARNING(Service_APM, "(STUBBED) called mode={} config={}", static_cast<u32>(mode),
+                    config);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_APM, "(STUBBED) called mode={} config={}", static_cast<u32>(mode),
-                    config);
    }
    void GetPerformanceConfiguration(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        auto mode = static_cast<PerformanceMode>(rp.Pop<u32>());
+        LOG_WARNING(Service_APM, "(STUBBED) called mode={}", static_cast<u32>(mode));
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(static_cast<u32>(PerformanceConfiguration::Config1));
-        LOG_WARNING(Service_APM, "(STUBBED) called mode={}", static_cast<u32>(mode));
    }
 };
@@ -73,11 +71,11 @@ APM::APM(std::shared_ptr<Module> apm, const char* name)
 APM::~APM() = default;
 void APM::OpenSession(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_APM, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ISession>();
-    LOG_DEBUG(Service_APM, "called");
 }
 APM_Sys::APM_Sys() : ServiceFramework{"apm:sys"} {
@@ -98,11 +96,11 @@ APM_Sys::APM_Sys() : ServiceFramework{"apm:sys"} {
 APM_Sys::~APM_Sys() = default;
 void APM_Sys::GetPerformanceEvent(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_APM, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ISession>();
-    LOG_DEBUG(Service_APM, "called");
 }
 } // namespace Service::APM
diff --git a/src/core/hle/service/arp/arp.cpp b/src/core/hle/service/arp/arp.cpp
index 358ef2576..e675b0188 100644
--- a/src/core/hle/service/arp/arp.cpp
+++ b/src/core/hle/service/arp/arp.cpp
@@ -59,11 +59,11 @@ public:
 private:
    void AcquireRegistrar(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_ARP, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IRegistrar>();
-        LOG_DEBUG(Service_ARP, "called");
    }
 };
diff --git a/src/core/hle/service/audio/audout_u.cpp b/src/core/hle/service/audio/audout_u.cpp
index ff1edefbb..2ee9bc273 100644
--- a/src/core/hle/service/audio/audout_u.cpp
+++ b/src/core/hle/service/audio/audout_u.cpp
@@ -44,8 +44,10 @@ enum class AudioState : u32 {
 class IAudioOut final : public ServiceFramework<IAudioOut> {
 public:
-    IAudioOut(AudoutParams audio_params, AudioCore::AudioOut& audio_core)
+    IAudioOut(AudoutParams audio_params, AudioCore::AudioOut& audio_core, std::string&& device_name,
-        : ServiceFramework("IAudioOut"), audio_core(audio_core), audio_params(audio_params) {
+              std::string&& unique_name)
+        : ServiceFramework("IAudioOut"), audio_core(audio_core), audio_params(audio_params),
+          device_name(std::move(device_name)) {
        static const FunctionInfo functions[] = {
            {0, &IAudioOut::GetAudioOutState, "GetAudioOutState"},
@@ -69,7 +71,7 @@ public:
            Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, "IAudioOutBufferReleased");
        stream = audio_core.OpenStream(audio_params.sample_rate, audio_params.channel_count,
-                                       "IAudioOut", [=]() { buffer_event->Signal(); });
+                                       std::move(unique_name), [=]() { buffer_event->Signal(); });
    }
 private:
@@ -84,6 +86,7 @@ private:
    void GetAudioOutState(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_Audio, "called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push(static_cast<u32>(stream->IsPlaying() ? AudioState::Started : AudioState::Stopped));
@@ -146,6 +149,7 @@ private:
    void GetReleasedAudioOutBufferImpl(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_Audio, "called {}", ctx.Description());
        IPC::RequestParser rp{ctx};
        const u64 max_count{ctx.GetWriteBufferSize() / sizeof(u64)};
        const auto released_buffers{audio_core.GetTagsAndReleaseBuffers(stream, max_count)};
@@ -161,6 +165,7 @@ private:
    void ContainsAudioOutBuffer(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_Audio, "called");
        IPC::RequestParser rp{ctx};
        const u64 tag{rp.Pop<u64>()};
        IPC::ResponseBuilder rb{ctx, 3};
@@ -170,6 +175,7 @@ private:
    void GetAudioOutBufferCount(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_Audio, "called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push(static_cast<u32>(stream->GetQueueSize()));
@@ -177,6 +183,7 @@ private:
    AudioCore::AudioOut& audio_core;
    AudioCore::StreamPtr stream;
+    std::string device_name;
    AudoutParams audio_params{};
@@ -186,6 +193,7 @@ private:
 void AudOutU::ListAudioOutsImpl(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_Audio, "called");
    IPC::RequestParser rp{ctx};
    ctx.WriteBuffer(DefaultDevice);
@@ -199,7 +207,15 @@ void AudOutU::ListAudioOutsImpl(Kernel::HLERequestContext& ctx) {
 void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_Audio, "called");
-    ctx.WriteBuffer(DefaultDevice);
+    const auto device_name_data{ctx.ReadBuffer()};
+    std::string device_name;
+    if (device_name_data[0] != '\0') {
+        device_name.assign(device_name_data.begin(), device_name_data.end());
+    } else {
+        device_name.assign(DefaultDevice.begin(), DefaultDevice.end());
+    }
+    ctx.WriteBuffer(device_name);
    IPC::RequestParser rp{ctx};
    auto params{rp.PopRaw<AudoutParams>()};
    if (params.channel_count <= 2) {
@@ -212,10 +228,9 @@ void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
        params.sample_rate = DefaultSampleRate;
    }
-    // TODO(bunnei): Support more than one IAudioOut interface. When we add this, ListAudioOutsImpl
+    std::string unique_name{fmt::format("{}-{}", device_name, audio_out_interfaces.size())};
-    // will likely need to be updated as well.
+    auto audio_out_interface = std::make_shared<IAudioOut>(
-    ASSERT_MSG(!audio_out_interface, "Unimplemented");
+        params, *audio_core, std::move(device_name), std::move(unique_name));
-    audio_out_interface = std::make_shared<IAudioOut>(params, *audio_core);
    IPC::ResponseBuilder rb{ctx, 6, 0, 1};
    rb.Push(RESULT_SUCCESS);
@@ -224,6 +239,8 @@ void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
    rb.Push<u32>(static_cast<u32>(AudioCore::Codec::PcmFormat::Int16));
    rb.Push<u32>(static_cast<u32>(AudioState::Stopped));
    rb.PushIpcInterface<Audio::IAudioOut>(audio_out_interface);
+    audio_out_interfaces.push_back(std::move(audio_out_interface));
 }
 AudOutU::AudOutU() : ServiceFramework("audout:u") {
diff --git a/src/core/hle/service/audio/audout_u.h b/src/core/hle/service/audio/audout_u.h
index dcaf64708..aed4c43b2 100644
--- a/src/core/hle/service/audio/audout_u.h
+++ b/src/core/hle/service/audio/audout_u.h
@@ -4,6 +4,7 @@
 #pragma once
+#include <vector>
 #include "core/hle/service/service.h"
 namespace AudioCore {
@@ -24,7 +25,7 @@ public:
    ~AudOutU() override;
 private:
-    std::shared_ptr<IAudioOut> audio_out_interface;
+    std::vector<std::shared_ptr<IAudioOut>> audio_out_interfaces;
    std::unique_ptr<AudioCore::AudioOut> audio_core;
    void ListAudioOutsImpl(Kernel::HLERequestContext& ctx);
diff --git a/src/core/hle/service/audio/audren_u.cpp b/src/core/hle/service/audio/audren_u.cpp
index d3ea57ea7..1c418a9bb 100644
--- a/src/core/hle/service/audio/audren_u.cpp
+++ b/src/core/hle/service/audio/audren_u.cpp
@@ -52,74 +52,79 @@ private:
    }
    void GetSampleRate(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_Audio, "called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(renderer->GetSampleRate());
-        LOG_DEBUG(Service_Audio, "called");
    }
    void GetSampleCount(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_Audio, "called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(renderer->GetSampleCount());
-        LOG_DEBUG(Service_Audio, "called");
    }
    void GetState(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_Audio, "called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(static_cast<u32>(renderer->GetStreamState()));
-        LOG_DEBUG(Service_Audio, "called");
    }
    void GetMixBufferCount(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_Audio, "called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(renderer->GetMixBufferCount());
-        LOG_DEBUG(Service_Audio, "called");
    }
    void RequestUpdateImpl(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
        ctx.WriteBuffer(renderer->UpdateAudioRenderer(ctx.ReadBuffer()));
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_Audio, "(STUBBED) called");
    }
    void Start(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_Audio, "(STUBBED) called");
    }
    void Stop(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_Audio, "(STUBBED) called");
    }
    void QuerySystemEvent(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(system_event);
-        LOG_WARNING(Service_Audio, "(STUBBED) called");
    }
    void SetRenderingTimeLimit(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        rendering_time_limit_percent = rp.Pop<u32>();
+        LOG_DEBUG(Service_Audio, "called. rendering_time_limit_percent={}",
+                  rendering_time_limit_percent);
        ASSERT(rendering_time_limit_percent >= 0 && rendering_time_limit_percent <= 100);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_Audio, "called. rendering_time_limit_percent={}",
-                  rendering_time_limit_percent);
    }
    void GetRenderingTimeLimit(Kernel::HLERequestContext& ctx) {
@@ -211,6 +216,7 @@ private:
    void GetActiveChannelCount(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_Audio, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(1);
@@ -235,19 +241,20 @@ AudRenU::AudRenU() : ServiceFramework("audren:u") {
 AudRenU::~AudRenU() = default;
 void AudRenU::OpenAudioRenderer(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Audio, "called");
    IPC::RequestParser rp{ctx};
    auto params = rp.PopRaw<AudioCore::AudioRendererParameter>();
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<Audio::IAudioRenderer>(std::move(params));
-    LOG_DEBUG(Service_Audio, "called");
 }
 void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    auto params = rp.PopRaw<AudioCore::AudioRendererParameter>();
+    LOG_DEBUG(Service_Audio, "called");
    u64 buffer_sz = Common::AlignUp(4 * params.mix_buffer_count, 0x40);
    buffer_sz += params.unknown_c * 1024;
@@ -301,26 +308,26 @@ void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.Push<u64>(output_sz);
-    LOG_DEBUG(Service_Audio, "called, buffer_size=0x{:X}", output_sz);
+    LOG_DEBUG(Service_Audio, "buffer_size=0x{:X}", output_sz);
 }
 void AudRenU::GetAudioDevice(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Audio, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<Audio::IAudioDevice>();
-    LOG_DEBUG(Service_Audio, "called");
 }
 void AudRenU::GetAudioDeviceServiceWithRevisionInfo(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_Audio, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<Audio::IAudioDevice>();
+    rb.PushIpcInterface<Audio::IAudioDevice>(); // TODO(ogniK): Figure out what is different
+                                                // based on the current revision
-    LOG_WARNING(Service_Audio, "(STUBBED) called"); // TODO(ogniK): Figure out what is different
-                                                    // based on the current revision
 }
 bool AudRenU::IsFeatureSupported(AudioFeatures feature, u32_le revision) const {
diff --git a/src/core/hle/service/audio/hwopus.cpp b/src/core/hle/service/audio/hwopus.cpp
index 763e619a4..a850cadc8 100644
--- a/src/core/hle/service/audio/hwopus.cpp
+++ b/src/core/hle/service/audio/hwopus.cpp
@@ -46,10 +46,13 @@ public:
 private:
    void DecodeInterleaved(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Audio, "called");
        u32 consumed = 0;
        u32 sample_count = 0;
        std::vector<opus_int16> samples(ctx.GetWriteBufferSize() / sizeof(opus_int16));
        if (!Decoder_DecodeInterleaved(consumed, sample_count, ctx.ReadBuffer(), samples)) {
+            LOG_ERROR(Audio, "Failed to decode opus data");
            IPC::ResponseBuilder rb{ctx, 2};
            // TODO(ogniK): Use correct error code
            rb.Push(ResultCode(-1));
@@ -63,12 +66,15 @@ private:
    }
    void DecodeInterleavedWithPerformance(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Audio, "called");
        u32 consumed = 0;
        u32 sample_count = 0;
        u64 performance = 0;
        std::vector<opus_int16> samples(ctx.GetWriteBufferSize() / sizeof(opus_int16));
        if (!Decoder_DecodeInterleaved(consumed, sample_count, ctx.ReadBuffer(), samples,
                                       performance)) {
+            LOG_ERROR(Audio, "Failed to decode opus data");
            IPC::ResponseBuilder rb{ctx, 2};
            // TODO(ogniK): Use correct error code
            rb.Push(ResultCode(-1));
@@ -88,24 +94,39 @@ private:
        std::optional<std::reference_wrapper<u64>> performance_time = std::nullopt) {
        const auto start_time = std::chrono::high_resolution_clock::now();
        std::size_t raw_output_sz = output.size() * sizeof(opus_int16);
-        if (sizeof(OpusHeader) > input.size())
+        if (sizeof(OpusHeader) > input.size()) {
+            LOG_ERROR(Audio, "Input is smaller than the header size, header_sz={}, input_sz={}",
+                      sizeof(OpusHeader), input.size());
            return false;
+        }
        OpusHeader hdr{};
        std::memcpy(&hdr, input.data(), sizeof(OpusHeader));
        if (sizeof(OpusHeader) + static_cast<u32>(hdr.sz) > input.size()) {
+            LOG_ERROR(Audio, "Input does not fit in the opus header size. data_sz={}, input_sz={}",
+                      sizeof(OpusHeader) + static_cast<u32>(hdr.sz), input.size());
            return false;
        }
        auto frame = input.data() + sizeof(OpusHeader);
        auto decoded_sample_count = opus_packet_get_nb_samples(
            frame, static_cast<opus_int32>(input.size() - sizeof(OpusHeader)),
            static_cast<opus_int32>(sample_rate));
-        if (decoded_sample_count * channel_count * sizeof(u16) > raw_output_sz)
+        if (decoded_sample_count * channel_count * sizeof(u16) > raw_output_sz) {
+            LOG_ERROR(
+                Audio,
+                "Decoded data does not fit into the output data, decoded_sz={}, raw_output_sz={}",
+                decoded_sample_count * channel_count * sizeof(u16), raw_output_sz);
            return false;
+        }
+        const int frame_size = (static_cast<int>(raw_output_sz / sizeof(s16) / channel_count));
        auto out_sample_count =
-            opus_decode(decoder.get(), frame, hdr.sz, output.data(),
+            opus_decode(decoder.get(), frame, hdr.sz, output.data(), frame_size, 0);
-                        (static_cast<int>(raw_output_sz / sizeof(s16) / channel_count)), 0);
+        if (out_sample_count < 0) {
-        if (out_sample_count < 0)
+            LOG_ERROR(Audio,
+                      "Incorrect sample count received from opus_decode, "
+                      "output_sample_count={}, frame_size={}, data_sz_from_hdr={}",
+                      out_sample_count, frame_size, static_cast<u32>(hdr.sz));
            return false;
+        }
        const auto end_time = std::chrono::high_resolution_clock::now() - start_time;
        sample_count = out_sample_count;
        consumed = static_cast<u32>(sizeof(OpusHeader) + hdr.sz);
@@ -134,14 +155,17 @@ static std::size_t WorkerBufferSize(u32 channel_count) {
 void HwOpus::GetWorkBufferSize(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
-    auto sample_rate = rp.Pop<u32>();
+    const auto sample_rate = rp.Pop<u32>();
-    auto channel_count = rp.Pop<u32>();
+    const auto channel_count = rp.Pop<u32>();
+    LOG_DEBUG(Audio, "called with sample_rate={}, channel_count={}", sample_rate, channel_count);
    ASSERT_MSG(sample_rate == 48000 || sample_rate == 24000 || sample_rate == 16000 ||
                   sample_rate == 12000 || sample_rate == 8000,
               "Invalid sample rate");
    ASSERT_MSG(channel_count == 1 || channel_count == 2, "Invalid channel count");
-    u32 worker_buffer_sz = static_cast<u32>(WorkerBufferSize(channel_count));
-    LOG_DEBUG(Audio, "called worker_buffer_sz={}", worker_buffer_sz);
+    const u32 worker_buffer_sz = static_cast<u32>(WorkerBufferSize(channel_count));
+    LOG_DEBUG(Audio, "worker_buffer_sz={}", worker_buffer_sz);
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
@@ -155,6 +179,7 @@ void HwOpus::OpenOpusDecoder(Kernel::HLERequestContext& ctx) {
    auto buffer_sz = rp.Pop<u32>();
    LOG_DEBUG(Audio, "called sample_rate={}, channel_count={}, buffer_size={}", sample_rate,
              channel_count, buffer_sz);
    ASSERT_MSG(sample_rate == 48000 || sample_rate == 24000 || sample_rate == 16000 ||
                   sample_rate == 12000 || sample_rate == 8000,
               "Invalid sample rate");
@@ -164,7 +189,8 @@ void HwOpus::OpenOpusDecoder(Kernel::HLERequestContext& ctx) {
    ASSERT_MSG(buffer_sz >= worker_sz, "Worker buffer too large");
    std::unique_ptr<OpusDecoder, OpusDeleter> decoder{
        static_cast<OpusDecoder*>(operator new(worker_sz))};
-    if (opus_decoder_init(decoder.get(), sample_rate, channel_count)) {
+    if (const int err = opus_decoder_init(decoder.get(), sample_rate, channel_count)) {
+        LOG_ERROR(Audio, "Failed to init opus decoder with error={}", err);
        IPC::ResponseBuilder rb{ctx, 2};
        // TODO(ogniK): Use correct error code
        rb.Push(ResultCode(-1));
diff --git a/src/core/hle/service/bcat/module.cpp b/src/core/hle/service/bcat/module.cpp
index 6e7b795fb..b7bd738fc 100644
--- a/src/core/hle/service/bcat/module.cpp
+++ b/src/core/hle/service/bcat/module.cpp
@@ -33,10 +33,11 @@ public:
 };
 void Module::Interface::CreateBcatService(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_BCAT, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IBcatService>();
-    LOG_DEBUG(Service_BCAT, "called");
 }
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
diff --git a/src/core/hle/service/btdrv/btdrv.cpp b/src/core/hle/service/btdrv/btdrv.cpp
index f3bde6d0d..2eadcdd05 100644
--- a/src/core/hle/service/btdrv/btdrv.cpp
+++ b/src/core/hle/service/btdrv/btdrv.cpp
@@ -34,13 +34,14 @@ public:
 private:
    void RegisterEvent(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
        auto& kernel = Core::System::GetInstance().Kernel();
        register_event =
            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "BT:RegisterEvent");
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(register_event);
-        LOG_WARNING(Service_BTM, "(STUBBED) called");
    }
    Kernel::SharedPtr<Kernel::Event> register_event;
 };
diff --git a/src/core/hle/service/btm/btm.cpp b/src/core/hle/service/btm/btm.cpp
index a02f6b53a..463a79351 100644
--- a/src/core/hle/service/btm/btm.cpp
+++ b/src/core/hle/service/btm/btm.cpp
@@ -57,40 +57,44 @@ public:
 private:
    void GetScanEvent(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
        auto& kernel = Core::System::GetInstance().Kernel();
        scan_event =
            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ScanEvent");
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(scan_event);
-        LOG_WARNING(Service_BTM, "(STUBBED) called");
    }
    void GetConnectionEvent(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
        auto& kernel = Core::System::GetInstance().Kernel();
        connection_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
                                                 "IBtmUserCore:ConnectionEvent");
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(connection_event);
-        LOG_WARNING(Service_BTM, "(STUBBED) called");
    }
    void GetDiscoveryEvent(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
        auto& kernel = Core::System::GetInstance().Kernel();
        service_discovery =
            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IBtmUserCore:Discovery");
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(service_discovery);
-        LOG_WARNING(Service_BTM, "(STUBBED) called");
    }
    void GetConfigEvent(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
        auto& kernel = Core::System::GetInstance().Kernel();
        config_event =
            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ConfigEvent");
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(config_event);
-        LOG_WARNING(Service_BTM, "(STUBBED) called");
    }
    Kernel::SharedPtr<Kernel::Event> scan_event;
    Kernel::SharedPtr<Kernel::Event> connection_event;
@@ -111,10 +115,11 @@ public:
 private:
    void GetCoreImpl(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_BTM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IBtmUserCore>();
-        LOG_DEBUG(Service_BTM, "called");
    }
 };
@@ -209,11 +214,11 @@ public:
 private:
    void GetCoreImpl(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_BTM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IBtmSystemCore>();
-        LOG_DEBUG(Service_BTM, "called");
    }
 };
diff --git a/src/core/hle/service/fgm/fgm.cpp b/src/core/hle/service/fgm/fgm.cpp
index 566fbf924..e461274c1 100644
--- a/src/core/hle/service/fgm/fgm.cpp
+++ b/src/core/hle/service/fgm/fgm.cpp
@@ -42,11 +42,11 @@ public:
 private:
    void Initialize(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_FGM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IRequest>();
-        LOG_DEBUG(Service_FGM, "called");
    }
 };
diff --git a/src/core/hle/service/filesystem/filesystem.cpp b/src/core/hle/service/filesystem/filesystem.cpp
index 5d6294016..2aa77f68d 100644
--- a/src/core/hle/service/filesystem/filesystem.cpp
+++ b/src/core/hle/service/filesystem/filesystem.cpp
@@ -341,6 +341,10 @@ std::shared_ptr<FileSys::RegisteredCacheUnion> GetUnionContents() {
    return registered_cache_union;
 }
+void ClearUnionContents() {
+    registered_cache_union = nullptr;
+}
 FileSys::RegisteredCache* GetSystemNANDContents() {
    LOG_TRACE(Service_FS, "Opening System NAND Contents");
@@ -391,6 +395,7 @@ void CreateFactories(FileSys::VfsFilesystem& vfs, bool overwrite) {
        bis_factory = nullptr;
        save_data_factory = nullptr;
        sdmc_factory = nullptr;
+        ClearUnionContents();
    }
    auto nand_directory = vfs.OpenDirectory(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir),
diff --git a/src/core/hle/service/filesystem/filesystem.h b/src/core/hle/service/filesystem/filesystem.h
index ff9182e84..0a6cb6635 100644
--- a/src/core/hle/service/filesystem/filesystem.h
+++ b/src/core/hle/service/filesystem/filesystem.h
@@ -49,6 +49,7 @@ ResultVal<FileSys::VirtualDir> OpenSaveDataSpace(FileSys::SaveDataSpaceId space)
 ResultVal<FileSys::VirtualDir> OpenSDMC();
 std::shared_ptr<FileSys::RegisteredCacheUnion> GetUnionContents();
+void ClearUnionContents();
 FileSys::RegisteredCache* GetSystemNANDContents();
 FileSys::RegisteredCache* GetUserNANDContents();
diff --git a/src/core/hle/service/filesystem/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp_srv.cpp
index 038dc80b1..99d9ebc39 100644
--- a/src/core/hle/service/filesystem/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp_srv.cpp
@@ -62,11 +62,13 @@ private:
        // Error checking
        if (length < 0) {
+            LOG_ERROR(Service_FS, "Length is less than 0, length={}", length);
            IPC::ResponseBuilder rb{ctx, 2};
            rb.Push(FileSys::ERROR_INVALID_SIZE);
            return;
        }
        if (offset < 0) {
+            LOG_ERROR(Service_FS, "Offset is less than 0, offset={}", offset);
            IPC::ResponseBuilder rb{ctx, 2};
            rb.Push(FileSys::ERROR_INVALID_OFFSET);
            return;
@@ -107,11 +109,13 @@ private:
        // Error checking
        if (length < 0) {
+            LOG_ERROR(Service_FS, "Length is less than 0, length={}", length);
            IPC::ResponseBuilder rb{ctx, 2};
            rb.Push(FileSys::ERROR_INVALID_SIZE);
            return;
        }
        if (offset < 0) {
+            LOG_ERROR(Service_FS, "Offset is less than 0, offset={}", offset);
            IPC::ResponseBuilder rb{ctx, 2};
            rb.Push(FileSys::ERROR_INVALID_OFFSET);
            return;
@@ -138,11 +142,13 @@ private:
        // Error checking
        if (length < 0) {
+            LOG_ERROR(Service_FS, "Length is less than 0, length={}", length);
            IPC::ResponseBuilder rb{ctx, 2};
            rb.Push(FileSys::ERROR_INVALID_SIZE);
            return;
        }
        if (offset < 0) {
+            LOG_ERROR(Service_FS, "Offset is less than 0, offset={}", offset);
            IPC::ResponseBuilder rb{ctx, 2};
            rb.Push(FileSys::ERROR_INVALID_OFFSET);
            return;
@@ -180,9 +186,10 @@ private:
    void SetSize(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const u64 size = rp.Pop<u64>();
-        backend->Resize(size);
        LOG_DEBUG(Service_FS, "called, size={}", size);
+        backend->Resize(size);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
@@ -465,6 +472,8 @@ public:
    }
    void ReadSaveDataInfo(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_FS, "called");
        // Calculate how many entries we can fit in the output buffer
        const u64 count_entries = ctx.GetWriteBufferSize() / sizeof(SaveDataInfo);
@@ -703,6 +712,8 @@ void FSP_SRV::OpenFileSystemWithPatch(Kernel::HLERequestContext& ctx) {
    const auto type = rp.PopRaw<FileSystemType>();
    const auto title_id = rp.PopRaw<u64>();
+    LOG_WARNING(Service_FS, "(STUBBED) called with type={}, title_id={:016X}",
+                static_cast<u8>(type), title_id);
    IPC::ResponseBuilder rb{ctx, 2, 0, 0};
    rb.Push(ResultCode(-1));
@@ -738,6 +749,7 @@ void FSP_SRV::MountSaveData(Kernel::HLERequestContext& ctx) {
    auto space_id = rp.PopRaw<FileSys::SaveDataSpaceId>();
    auto unk = rp.Pop<u32>();
    LOG_INFO(Service_FS, "called with unknown={:08X}", unk);
    auto save_struct = rp.PopRaw<FileSys::SaveDataDescriptor>();
    auto dir = OpenSaveData(space_id, save_struct);
@@ -763,6 +775,7 @@ void FSP_SRV::OpenReadOnlySaveDataFileSystem(Kernel::HLERequestContext& ctx) {
 void FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto space = rp.PopRaw<FileSys::SaveDataSpaceId>();
+    LOG_INFO(Service_FS, "called, space={}", static_cast<u8>(space));
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
diff --git a/src/core/hle/service/hid/controllers/debug_pad.cpp b/src/core/hle/service/hid/controllers/debug_pad.cpp
index e76c83aee..c22357d8c 100644
--- a/src/core/hle/service/hid/controllers/debug_pad.cpp
+++ b/src/core/hle/service/hid/controllers/debug_pad.cpp
@@ -71,8 +71,9 @@ void Controller_DebugPad::OnUpdate(u8* data, std::size_t size) {
 void Controller_DebugPad::OnLoadInputDevices() {
    std::transform(Settings::values.debug_pad_buttons.begin(),
-                   Settings::values.debug_pad_buttons.end(), buttons.begin(),
+                   Settings::values.debug_pad_buttons.begin() +
-                   Input::CreateDevice<Input::ButtonDevice>);
+                       Settings::NativeButton::NUM_BUTTONS_HID,
+                   buttons.begin(), Input::CreateDevice<Input::ButtonDevice>);
    std::transform(Settings::values.debug_pad_analogs.begin(),
                   Settings::values.debug_pad_analogs.end(), analogs.begin(),
                   Input::CreateDevice<Input::AnalogDevice>);
diff --git a/src/core/hle/service/hid/controllers/npad.cpp b/src/core/hle/service/hid/controllers/npad.cpp
index 46604887c..22e87a50a 100644
--- a/src/core/hle/service/hid/controllers/npad.cpp
+++ b/src/core/hle/service/hid/controllers/npad.cpp
@@ -524,6 +524,8 @@ void Controller_NPad::SetNpadMode(u32 npad_id, NPadAssignments assignment_mode)
 void Controller_NPad::VibrateController(const std::vector<u32>& controller_ids,
                                        const std::vector<Vibration>& vibrations) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
    if (!can_controllers_vibrate) {
        return;
    }
@@ -533,7 +535,6 @@ void Controller_NPad::VibrateController(const std::vector<u32>& controller_ids,
            // TODO(ogniK): Vibrate the physical controller
        }
    }
-    LOG_WARNING(Service_HID, "(STUBBED) called");
    last_processed_vibration = vibrations.back();
 }
@@ -575,8 +576,8 @@ void Controller_NPad::AddNewControllerAt(NPadControllerType controller, u32 npad
        return;
    }
-    connected_controllers[npad_id] = {controller, true};
+    connected_controllers[NPadIdToIndex(npad_id)] = {controller, true};
-    InitNewlyAddedControler(npad_id);
+    InitNewlyAddedControler(NPadIdToIndex(npad_id));
 }
 void Controller_NPad::ConnectNPad(u32 npad_id) {
diff --git a/src/core/hle/service/hid/controllers/npad.h b/src/core/hle/service/hid/controllers/npad.h
index ea8057b80..abff6544d 100644
--- a/src/core/hle/service/hid/controllers/npad.h
+++ b/src/core/hle/service/hid/controllers/npad.h
@@ -80,9 +80,9 @@ public:
    struct LedPattern {
        explicit LedPattern(u64 light1, u64 light2, u64 light3, u64 light4) {
            position1.Assign(light1);
-            position1.Assign(light2);
+            position2.Assign(light2);
-            position1.Assign(light3);
+            position3.Assign(light3);
-            position1.Assign(light4);
+            position4.Assign(light4);
        }
        union {
            u64 raw{};
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 7c0dac5dc..46496e9bb 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -124,10 +124,11 @@ public:
 private:
    void GetSharedMemoryHandle(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(shared_mem);
-        LOG_DEBUG(Service_HID, "called");
    }
    void UpdateControllers(u64 userdata, int cycles_late) {
@@ -163,9 +164,10 @@ public:
 private:
    void ActivateVibrationDevice(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_HID, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
 };
@@ -303,6 +305,8 @@ private:
    std::shared_ptr<IAppletResource> applet_resource;
    void CreateAppletResource(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        if (applet_resource == nullptr) {
            applet_resource = std::make_shared<IAppletResource>();
        }
@@ -310,206 +314,228 @@ private:
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IAppletResource>(applet_resource);
-        LOG_DEBUG(Service_HID, "called");
    }
    void ActivateXpad(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        applet_resource->ActivateController(HidController::XPad);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_HID, "called");
    }
    void ActivateDebugPad(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        applet_resource->ActivateController(HidController::DebugPad);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_HID, "called");
    }
    void ActivateTouchScreen(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        applet_resource->ActivateController(HidController::Touchscreen);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_HID, "called");
    }
    void ActivateMouse(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        applet_resource->ActivateController(HidController::Mouse);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_HID, "called");
    }
    void ActivateKeyboard(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        applet_resource->ActivateController(HidController::Keyboard);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_HID, "called");
    }
    void ActivateGesture(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        applet_resource->ActivateController(HidController::Gesture);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_HID, "called");
    }
    void ActivateNpadWithRevision(Kernel::HLERequestContext& ctx) {
        // Should have no effect with how our npad sets up the data
+        LOG_DEBUG(Service_HID, "called");
        applet_resource->ActivateController(HidController::NPad);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_HID, "called");
    }
    void StartSixAxisSensor(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        auto handle = rp.PopRaw<u32>();
+        LOG_WARNING(Service_HID, "(STUBBED) called with handle={}", handle);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void SetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_HID, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void IsSixAxisSensorAtRest(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_HID, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        // TODO (Hexagon12): Properly implement reading gyroscope values from controllers.
        rb.Push(true);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void SetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        auto supported_styleset = rp.PopRaw<u32>();
+        LOG_DEBUG(Service_HID, "called with supported_styleset={}", supported_styleset);
        applet_resource->GetController<Controller_NPad>(HidController::NPad)
            .SetSupportedStyleSet({supported_styleset});
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_HID, "called");
    }
    void GetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(controller.GetSupportedStyleSet().raw);
-        LOG_DEBUG(Service_HID, "called");
    }
    void SetSupportedNpadIdType(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        applet_resource->GetController<Controller_NPad>(HidController::NPad)
            .SetSupportedNPadIdTypes(ctx.ReadBuffer().data(), ctx.GetReadBufferSize());
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_HID, "called");
    }
    void ActivateNpad(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
        applet_resource->ActivateController(HidController::NPad);
-        LOG_DEBUG(Service_HID, "called");
    }
    void AcquireNpadStyleSetUpdateEventHandle(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        auto npad_id = rp.PopRaw<u32>();
+        LOG_DEBUG(Service_HID, "called with npad_id={}", npad_id);
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(applet_resource->GetController<Controller_NPad>(HidController::NPad)
                               .GetStyleSetChangedEvent());
-        LOG_DEBUG(Service_HID, "called");
    }
    void DisconnectNpad(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        auto npad_id = rp.PopRaw<u32>();
+        LOG_DEBUG(Service_HID, "called with npad_id={}", npad_id);
        applet_resource->GetController<Controller_NPad>(HidController::NPad)
            .DisconnectNPad(npad_id);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_HID, "called");
    }
    void GetPlayerLedPattern(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        auto npad_id = rp.PopRaw<u32>();
+        LOG_DEBUG(Service_HID, "called with npad_id={}", npad_id);
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(RESULT_SUCCESS);
        rb.PushRaw<u64>(applet_resource->GetController<Controller_NPad>(HidController::NPad)
                            .GetLedPattern(npad_id)
                            .raw);
-        LOG_DEBUG(Service_HID, "called");
    }
    void SetNpadJoyHoldType(Kernel::HLERequestContext& ctx) {
-        auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
        IPC::RequestParser rp{ctx};
        const auto hold_type = rp.PopRaw<u64>();
+        LOG_DEBUG(Service_HID, "called with hold_type={}", hold_type);
+        auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
        controller.SetHoldType(Controller_NPad::NpadHoldType{hold_type});
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_HID, "called");
    }
    void GetNpadJoyHoldType(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        const auto& controller =
            applet_resource->GetController<Controller_NPad>(HidController::NPad);
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u64>(static_cast<u64>(controller.GetHoldType()));
-        LOG_DEBUG(Service_HID, "called");
    }
    void SetNpadJoyAssignmentModeSingleByDefault(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        auto npad_id = rp.PopRaw<u32>();
+        LOG_WARNING(Service_HID, "(STUBBED) called with npad_id={}", npad_id);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void BeginPermitVibrationSession(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        applet_resource->GetController<Controller_NPad>(HidController::NPad)
            .SetVibrationEnabled(true);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_HID, "called");
    }
    void EndPermitVibrationSession(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        applet_resource->GetController<Controller_NPad>(HidController::NPad)
            .SetVibrationEnabled(false);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_HID, "called");
    }
    void SendVibrationValue(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const auto controller_id = rp.PopRaw<u32>();
        const auto vibration_values = rp.PopRaw<Controller_NPad::Vibration>();
+        LOG_DEBUG(Service_HID, "called with controller_id={}", controller_id);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
        applet_resource->GetController<Controller_NPad>(HidController::NPad)
            .VibrateController({controller_id}, {vibration_values});
-        LOG_DEBUG(Service_HID, "called");
    }
    void SendVibrationValues(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        const auto controllers = ctx.ReadBuffer(0);
        const auto vibrations = ctx.ReadBuffer(1);
@@ -527,86 +553,96 @@ private:
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_HID, "called");
    }
    void GetActualVibrationValue(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        IPC::ResponseBuilder rb{ctx, 6};
        rb.Push(RESULT_SUCCESS);
        rb.PushRaw<Controller_NPad::Vibration>(
            applet_resource->GetController<Controller_NPad>(HidController::NPad)
                .GetLastVibration());
-        LOG_DEBUG(Service_HID, "called");
    }
    void SetNpadJoyAssignmentModeDual(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const auto npad_id = rp.PopRaw<u32>();
+        LOG_DEBUG(Service_HID, "called with npad_id={}", npad_id);
        auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
        controller.SetNpadMode(npad_id, Controller_NPad::NPadAssignments::Dual);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_HID, "called");
    }
    void MergeSingleJoyAsDualJoy(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_HID, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void SetNpadHandheldActivationMode(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        auto mode = rp.PopRaw<u32>();
+        LOG_WARNING(Service_HID, "(STUBBED) called with mode={}", mode);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void GetVibrationDeviceInfo(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(1);
        rb.Push<u32>(0);
-        LOG_DEBUG(Service_HID, "called");
    }
    void CreateActiveVibrationDeviceList(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_HID, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IActiveVibrationDeviceList>();
-        LOG_DEBUG(Service_HID, "called");
    }
    void ActivateConsoleSixAxisSensor(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_HID, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void StartConsoleSixAxisSensor(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_HID, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void StopSixAxisSensor(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_HID, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void SetIsPalmaAllConnectable(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_HID, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void SetPalmaBoostMode(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_HID, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
 };
diff --git a/src/core/hle/service/hid/irs.cpp b/src/core/hle/service/hid/irs.cpp
index 872e3c344..3c7f8b1ee 100644
--- a/src/core/hle/service/hid/irs.cpp
+++ b/src/core/hle/service/hid/irs.cpp
@@ -44,115 +44,133 @@ IRS::IRS() : ServiceFramework{"irs"} {
 }
 void IRS::ActivateIrsensor(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 void IRS::DeactivateIrsensor(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 void IRS::GetIrsensorSharedMemoryHandle(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_IRS, "called");
    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushCopyObjects(shared_mem);
-    LOG_DEBUG(Service_IRS, "called");
 }
 void IRS::StopImageProcessor(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 void IRS::RunMomentProcessor(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 void IRS::RunClusteringProcessor(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 void IRS::RunImageTransferProcessor(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 void IRS::GetImageTransferProcessorState(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 5};
    rb.Push(RESULT_SUCCESS);
    rb.PushRaw<u64>(CoreTiming::GetTicks());
    rb.PushRaw<u32>(0);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 void IRS::RunTeraPluginProcessor(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 void IRS::GetNpadIrCameraHandle(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.PushRaw<u32>(device_handle);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 void IRS::RunPointingProcessor(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 void IRS::SuspendImageProcessor(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 void IRS::CheckFirmwareVersion(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 void IRS::SetFunctionLevel(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 void IRS::RunImageTransferExProcessor(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 void IRS::RunIrLedProcessor(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 void IRS::StopImageProcessorAsync(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 void IRS::ActivateIrsensorWithFunctionLevel(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 IRS::~IRS() = default;
diff --git a/src/core/hle/service/lbl/lbl.cpp b/src/core/hle/service/lbl/lbl.cpp
index 164c57e18..e8f9f2d29 100644
--- a/src/core/hle/service/lbl/lbl.cpp
+++ b/src/core/hle/service/lbl/lbl.cpp
@@ -55,29 +55,29 @@ public:
 private:
    void EnableVrMode(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LBL, "called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
        vr_mode_enabled = true;
-        LOG_DEBUG(Service_LBL, "called");
    }
    void DisableVrMode(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LBL, "called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
        vr_mode_enabled = false;
-        LOG_DEBUG(Service_LBL, "called");
    }
    void IsVrModeEnabled(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LBL, "called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push(vr_mode_enabled);
-        LOG_DEBUG(Service_LBL, "called");
    }
    bool vr_mode_enabled = false;
diff --git a/src/core/hle/service/ldn/ldn.cpp b/src/core/hle/service/ldn/ldn.cpp
index 167f2c66a..e250595e3 100644
--- a/src/core/hle/service/ldn/ldn.cpp
+++ b/src/core/hle/service/ldn/ldn.cpp
@@ -44,11 +44,11 @@ public:
    }
    void CreateMonitorService(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LDN, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IMonitorService>();
-        LOG_DEBUG(Service_LDN, "called");
    }
 };
@@ -104,11 +104,11 @@ public:
    }
    void CreateSystemLocalCommunicationService(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LDN, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ILocalCommunicationService>("ISystemLocalCommunicationService");
-        LOG_DEBUG(Service_LDN, "called");
    }
 };
@@ -125,11 +125,11 @@ public:
    }
    void CreateUserLocalCommunicationService(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LDN, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ILocalCommunicationService>("IUserLocalCommunicationService");
-        LOG_DEBUG(Service_LDN, "called");
    }
 };
diff --git a/src/core/hle/service/ldr/ldr.cpp b/src/core/hle/service/ldr/ldr.cpp
index 7a9d0d0dd..ca119dd3a 100644
--- a/src/core/hle/service/ldr/ldr.cpp
+++ b/src/core/hle/service/ldr/ldr.cpp
@@ -97,6 +97,8 @@ public:
        rp.Skip(2, false);
        const VAddr nrr_addr{rp.Pop<VAddr>()};
        const u64 nrr_size{rp.Pop<u64>()};
+        LOG_DEBUG(Service_LDR, "called with nrr_addr={:016X}, nrr_size={:016X}", nrr_addr,
+                  nrr_size);
        if (!initialized) {
            LOG_ERROR(Service_LDR, "LDR:RO not initialized before use!");
@@ -189,6 +191,7 @@ public:
        IPC::RequestParser rp{ctx};
        rp.Skip(2, false);
        const auto nrr_addr{rp.Pop<VAddr>()};
+        LOG_DEBUG(Service_LDR, "called with nrr_addr={:016X}", nrr_addr);
        if (!Common::Is4KBAligned(nrr_addr)) {
            LOG_ERROR(Service_LDR, "NRR Address has invalid alignment (actual {:016X})!", nrr_addr);
@@ -219,6 +222,10 @@ public:
        const u64 nro_size{rp.Pop<u64>()};
        const VAddr bss_addr{rp.Pop<VAddr>()};
        const u64 bss_size{rp.Pop<u64>()};
+        LOG_DEBUG(
+            Service_LDR,
+            "called with nro_addr={:016X}, nro_size={:016X}, bss_addr={:016X}, bss_size={:016X}",
+            nro_addr, nro_size, bss_addr, bss_size);
        if (!initialized) {
            LOG_ERROR(Service_LDR, "LDR:RO not initialized before use!");
@@ -345,6 +352,8 @@ public:
        rp.Skip(2, false);
        const VAddr mapped_addr{rp.PopRaw<VAddr>()};
        const VAddr heap_addr{rp.PopRaw<VAddr>()};
+        LOG_DEBUG(Service_LDR, "called with mapped_addr={:016X}, heap_addr={:016X}", mapped_addr,
+                  heap_addr);
        if (!initialized) {
            LOG_ERROR(Service_LDR, "LDR:RO not initialized before use!");
@@ -393,11 +402,12 @@ public:
    }
    void Initialize(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_LDR, "(STUBBED) called");
        initialized = true;
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_LDR, "(STUBBED) called");
    }
 private:
diff --git a/src/core/hle/service/lm/lm.cpp b/src/core/hle/service/lm/lm.cpp
index 4e5fdb16e..1f462e087 100644
--- a/src/core/hle/service/lm/lm.cpp
+++ b/src/core/hle/service/lm/lm.cpp
@@ -209,11 +209,11 @@ public:
     *      0: ResultCode
     */
    void OpenLogger(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ILogger>();
-        LOG_DEBUG(Service_LM, "called");
    }
 };
diff --git a/src/core/hle/service/mm/mm_u.cpp b/src/core/hle/service/mm/mm_u.cpp
index e1f17a926..def63dc8a 100644
--- a/src/core/hle/service/mm/mm_u.cpp
+++ b/src/core/hle/service/mm/mm_u.cpp
@@ -31,12 +31,14 @@ public:
 private:
    void Initialize(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_MM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
    void Finalize(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_MM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
@@ -45,15 +47,16 @@ private:
        IPC::RequestParser rp{ctx};
        min = rp.Pop<u32>();
        max = rp.Pop<u32>();
-        current = min;
        LOG_WARNING(Service_MM, "(STUBBED) called, min=0x{:X}, max=0x{:X}", min, max);
+        current = min;
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
    void Get(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_MM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push(current);
@@ -61,6 +64,7 @@ private:
    void InitializeWithId(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_MM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(id); // Any non zero value
@@ -68,6 +72,7 @@ private:
    void FinalizeWithId(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_MM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
@@ -77,16 +82,17 @@ private:
        u32 input_id = rp.Pop<u32>();
        min = rp.Pop<u32>();
        max = rp.Pop<u32>();
-        current = min;
        LOG_WARNING(Service_MM, "(STUBBED) called, input_id=0x{:X}, min=0x{:X}, max=0x{:X}",
                    input_id, min, max);
+        current = min;
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
    void GetWithId(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_MM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push(current);
diff --git a/src/core/hle/service/nfc/nfc.cpp b/src/core/hle/service/nfc/nfc.cpp
index 30e542542..5c62d42ba 100644
--- a/src/core/hle/service/nfc/nfc.cpp
+++ b/src/core/hle/service/nfc/nfc.cpp
@@ -43,11 +43,11 @@ public:
 private:
    void CreateAmInterface(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NFC, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IAm>();
-        LOG_DEBUG(Service_NFC, "called");
    }
 };
@@ -91,11 +91,11 @@ public:
 private:
    void CreateUserInterface(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NFC, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<MFIUser>();
-        LOG_DEBUG(Service_NFC, "called");
    }
 };
@@ -138,19 +138,19 @@ private:
    };
    void InitializeOld(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NFC, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0};
        rb.Push(RESULT_SUCCESS);
        // We don't deal with hardware initialization so we can just stub this.
-        LOG_DEBUG(Service_NFC, "called");
    }
    void IsNfcEnabledOld(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NFC, "IsNfcEnabledOld");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.PushRaw<u8>(Settings::values.enable_nfc);
-        LOG_DEBUG(Service_NFC, "IsNfcEnabledOld");
    }
    void GetStateOld(Kernel::HLERequestContext& ctx) {
@@ -183,11 +183,11 @@ public:
 private:
    void CreateUserInterface(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NFC, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IUser>();
-        LOG_DEBUG(Service_NFC, "called");
    }
 };
@@ -241,11 +241,11 @@ public:
 private:
    void CreateSystemInterface(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NFC, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ISystem>();
-        LOG_DEBUG(Service_NFC, "called");
    }
 };
diff --git a/src/core/hle/service/nfp/nfp.cpp b/src/core/hle/service/nfp/nfp.cpp
index 1d6e7756f..ff9170c24 100644
--- a/src/core/hle/service/nfp/nfp.cpp
+++ b/src/core/hle/service/nfp/nfp.cpp
@@ -108,30 +108,29 @@ private:
    static_assert(sizeof(CommonInfo) == 0x40, "CommonInfo is an invalid size");
    void Initialize(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NFC, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0};
        rb.Push(RESULT_SUCCESS);
        state = State::Initialized;
-        LOG_DEBUG(Service_NFC, "called");
    }
    void GetState(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NFC, "called");
        IPC::ResponseBuilder rb{ctx, 3, 0};
        rb.Push(RESULT_SUCCESS);
        rb.PushRaw<u32>(static_cast<u32>(state));
-        LOG_DEBUG(Service_NFC, "called");
    }
    void ListDevices(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const u32 array_size = rp.Pop<u32>();
+        LOG_DEBUG(Service_NFP, "called, array_size={}", array_size);
        ctx.WriteBuffer(&device_handle, sizeof(device_handle));
-        LOG_DEBUG(Service_NFP, "called, array_size={}", array_size);
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(1);
@@ -141,6 +140,7 @@ private:
        IPC::RequestParser rp{ctx};
        const u64 dev_handle = rp.Pop<u64>();
        LOG_DEBUG(Service_NFP, "called, dev_handle=0x{:X}", dev_handle);
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(npad_id);
@@ -150,6 +150,7 @@ private:
        IPC::RequestParser rp{ctx};
        const u64 dev_handle = rp.Pop<u64>();
        LOG_DEBUG(Service_NFP, "called, dev_handle=0x{:X}", dev_handle);
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(nfp_interface.GetNFCEvent());
@@ -168,6 +169,7 @@ private:
    void StopDetection(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_NFP, "called");
        switch (device_state) {
        case DeviceState::TagFound:
        case DeviceState::TagNearby:
@@ -185,6 +187,7 @@ private:
    void GetDeviceState(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_NFP, "called");
        auto nfc_event = nfp_interface.GetNFCEvent();
        if (!nfc_event->ShouldWait(Kernel::GetCurrentThread()) && !has_attached_handle) {
            device_state = DeviceState::TagFound;
@@ -323,6 +326,7 @@ private:
 void Module::Interface::CreateUserInterface(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_NFP, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IUser>(*this);
diff --git a/src/core/hle/service/nifm/nifm.cpp b/src/core/hle/service/nifm/nifm.cpp
index 75dcd94a3..dee391201 100644
--- a/src/core/hle/service/nifm/nifm.cpp
+++ b/src/core/hle/service/nifm/nifm.cpp
@@ -63,12 +63,14 @@ public:
 private:
    void Submit(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
    void GetRequestState(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(0);
@@ -76,12 +78,14 @@ private:
    void GetResult(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
    void GetSystemEventReadableHandles(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2, 2};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(event1, event2);
@@ -89,12 +93,14 @@ private:
    void Cancel(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
    void SetConnectionConfirmationOption(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
@@ -122,32 +128,36 @@ private:
    void GetClientId(Kernel::HLERequestContext& ctx) {
        static constexpr u32 client_id = 1;
        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u64>(client_id); // Client ID needs to be non zero otherwise it's considered invalid
    }
    void CreateScanRequest(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NIFM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IScanRequest>();
-        LOG_DEBUG(Service_NIFM, "called");
    }
    void CreateRequest(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NIFM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IRequest>();
-        LOG_DEBUG(Service_NIFM, "called");
    }
    void RemoveNetworkProfile(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
    void CreateTemporaryNetworkProfile(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NIFM, "called");
        ASSERT_MSG(ctx.GetReadBufferSize() == 0x17c, "NetworkProfileData is not the correct size");
        u128 uuid{};
        auto buffer = ctx.ReadBuffer();
@@ -158,23 +168,24 @@ private:
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<INetworkProfile>();
        rb.PushRaw<u128>(uuid);
-        LOG_DEBUG(Service_NIFM, "called");
    }
    void IsWirelessCommunicationEnabled(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u8>(0);
    }
    void IsEthernetCommunicationEnabled(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u8>(0);
    }
    void IsAnyInternetRequestAccepted(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u8>(0);
@@ -235,17 +246,19 @@ public:
    }
    void CreateGeneralServiceOld(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NIFM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IGeneralService>();
-        LOG_DEBUG(Service_NIFM, "called");
    }
    void CreateGeneralService(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NIFM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IGeneralService>();
-        LOG_DEBUG(Service_NIFM, "called");
    }
 };
diff --git a/src/core/hle/service/nim/nim.cpp b/src/core/hle/service/nim/nim.cpp
index 18091c9bb..1bbccd444 100644
--- a/src/core/hle/service/nim/nim.cpp
+++ b/src/core/hle/service/nim/nim.cpp
@@ -148,47 +148,53 @@ private:
    void StartTask(Kernel::HLERequestContext& ctx) {
        // No need to connect to the internet, just finish the task straight away.
+        LOG_DEBUG(Service_NIM, "called");
        finished_event->Signal();
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_NIM, "called");
    }
    void GetFinishNotificationEvent(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NIM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(finished_event);
-        LOG_DEBUG(Service_NIM, "called");
    }
    void GetResult(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NIM, "called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_NIM, "called");
    }
    void Cancel(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NIM, "called");
        finished_event->Clear();
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_NIM, "called");
    }
    void IsProcessing(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NIM, "called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.PushRaw<u32>(0); // We instantly process the request
-        LOG_DEBUG(Service_NIM, "called");
    }
    void GetServerTime(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NIM, "called");
        const s64 server_time{std::chrono::duration_cast<std::chrono::seconds>(
                                  std::chrono::system_clock::now().time_since_epoch())
                                  .count()};
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(RESULT_SUCCESS);
        rb.PushRaw<s64>(server_time);
-        LOG_DEBUG(Service_NIM, "called");
    }
 };
@@ -208,23 +214,26 @@ public:
 private:
    void OpenEnsureNetworkClockAvailabilityService(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NIM, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IEnsureNetworkClockAvailabilityService>();
-        LOG_DEBUG(Service_NIM, "called");
    }
    // TODO(ogniK): Do we need these?
    void SuspendAutonomicTimeCorrection(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_NIM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_NIM, "(STUBBED) called");
    }
    void ResumeAutonomicTimeCorrection(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_NIM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_NIM, "(STUBBED) called");
    }
 };
diff --git a/src/core/hle/service/ns/ns.cpp b/src/core/hle/service/ns/ns.cpp
index 1d2978f24..2663f56b1 100644
--- a/src/core/hle/service/ns/ns.cpp
+++ b/src/core/hle/service/ns/ns.cpp
@@ -433,11 +433,11 @@ public:
 private:
    template <typename T>
    void PushInterface(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NS, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<T>();
-        LOG_DEBUG(Service_NS, "called");
    }
 };
@@ -526,11 +526,11 @@ public:
 private:
    void OpenSystemUpdateControl(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NS, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ISystemUpdateControl>();
-        LOG_DEBUG(Service_NS, "called");
    }
 };
diff --git a/src/core/hle/service/ns/pl_u.cpp b/src/core/hle/service/ns/pl_u.cpp
index 1066bf505..ad176f89d 100644
--- a/src/core/hle/service/ns/pl_u.cpp
+++ b/src/core/hle/service/ns/pl_u.cpp
@@ -281,6 +281,7 @@ void PL_U::RequestLoad(Kernel::HLERequestContext& ctx) {
    const u32 shared_font_type{rp.Pop<u32>()};
    // Games don't call this so all fonts should be loaded
    LOG_DEBUG(Service_NS, "called, shared_font_type={}", shared_font_type);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }
@@ -288,8 +289,8 @@ void PL_U::RequestLoad(Kernel::HLERequestContext& ctx) {
 void PL_U::GetLoadState(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const u32 font_id{rp.Pop<u32>()};
    LOG_DEBUG(Service_NS, "called, font_id={}", font_id);
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(static_cast<u32>(LoadState::Done));
@@ -298,8 +299,8 @@ void PL_U::GetLoadState(Kernel::HLERequestContext& ctx) {
 void PL_U::GetSize(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const u32 font_id{rp.Pop<u32>()};
    LOG_DEBUG(Service_NS, "called, font_id={}", font_id);
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(impl->GetSharedFontRegion(font_id).size);
@@ -308,8 +309,8 @@ void PL_U::GetSize(Kernel::HLERequestContext& ctx) {
 void PL_U::GetSharedMemoryAddressOffset(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const u32 font_id{rp.Pop<u32>()};
    LOG_DEBUG(Service_NS, "called, font_id={}", font_id);
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(impl->GetSharedFontRegion(font_id).offset);
@@ -317,6 +318,7 @@ void PL_U::GetSharedMemoryAddressOffset(Kernel::HLERequestContext& ctx) {
 void PL_U::GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx) {
    // Map backing memory for the font data
+    LOG_DEBUG(Service_NS, "called");
    Core::CurrentProcess()->VMManager().MapMemoryBlock(SHARED_FONT_MEM_VADDR, impl->shared_font, 0,
                                                       SHARED_FONT_MEM_SIZE,
                                                       Kernel::MemoryState::Shared);
@@ -328,7 +330,6 @@ void PL_U::GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx) {
        Kernel::MemoryPermission::Read, SHARED_FONT_MEM_VADDR, Kernel::MemoryRegion::BASE,
        "PL_U:shared_font_mem");
-    LOG_DEBUG(Service_NS, "called");
    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushCopyObjects(impl->shared_font_mem);
@@ -338,6 +339,7 @@ void PL_U::GetSharedFontInOrderOfPriority(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const u64 language_code{rp.Pop<u64>()}; // TODO(ogniK): Find out what this is used for
    LOG_DEBUG(Service_NS, "called, language_code={:X}", language_code);
    IPC::ResponseBuilder rb{ctx, 4};
    std::vector<u32> font_codes;
    std::vector<u32> font_offsets;
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
index c41ef7058..466db7ccd 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
@@ -54,6 +54,7 @@ u32 nvhost_as_gpu::InitalizeEx(const std::vector<u8>& input, std::vector<u8>& ou
    IoctlInitalizeEx params{};
    std::memcpy(&params, input.data(), input.size());
    LOG_WARNING(Service_NVDRV, "(STUBBED) called, big_page_size=0x{:X}", params.big_page_size);
    return 0;
 }
@@ -191,6 +192,7 @@ u32 nvhost_as_gpu::BindChannel(const std::vector<u8>& input, std::vector<u8>& ou
    IoctlBindChannel params{};
    std::memcpy(&params, input.data(), input.size());
    LOG_DEBUG(Service_NVDRV, "called, fd={:X}", params.fd);
    channel = params.fd;
    return 0;
 }
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp b/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
index 7a88ae029..d57a54ee8 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
@@ -5,6 +5,8 @@
 #include <cstring>
 #include "common/assert.h"
 #include "common/logging/log.h"
+#include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h"
 namespace Service::Nvidia::Devices {
@@ -33,6 +35,8 @@ u32 nvhost_ctrl_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vec
        return ZBCQueryTable(input, output);
    case IoctlCommand::IocFlushL2:
        return FlushL2(input, output);
+    case IoctlCommand::IocGetGpuTime:
+        return GetGpuTime(input, output);
    }
    UNIMPLEMENTED_MSG("Unimplemented ioctl");
    return 0;
@@ -99,6 +103,7 @@ u32 nvhost_ctrl_gpu::GetTPCMasks(const std::vector<u8>& input, std::vector<u8>&
 u32 nvhost_ctrl_gpu::GetActiveSlotMask(const std::vector<u8>& input, std::vector<u8>& output) {
    LOG_DEBUG(Service_NVDRV, "called");
    IoctlActiveSlotMask params{};
    if (input.size() > 0) {
        std::memcpy(&params, input.data(), input.size());
@@ -111,6 +116,7 @@ u32 nvhost_ctrl_gpu::GetActiveSlotMask(const std::vector<u8>& input, std::vector
 u32 nvhost_ctrl_gpu::ZCullGetCtxSize(const std::vector<u8>& input, std::vector<u8>& output) {
    LOG_DEBUG(Service_NVDRV, "called");
    IoctlZcullGetCtxSize params{};
    if (input.size() > 0) {
        std::memcpy(&params, input.data(), input.size());
@@ -122,6 +128,7 @@ u32 nvhost_ctrl_gpu::ZCullGetCtxSize(const std::vector<u8>& input, std::vector<u
 u32 nvhost_ctrl_gpu::ZCullGetInfo(const std::vector<u8>& input, std::vector<u8>& output) {
    LOG_DEBUG(Service_NVDRV, "called");
    IoctlNvgpuGpuZcullGetInfoArgs params{};
    if (input.size() > 0) {
@@ -144,6 +151,7 @@ u32 nvhost_ctrl_gpu::ZCullGetInfo(const std::vector<u8>& input, std::vector<u8>&
 u32 nvhost_ctrl_gpu::ZBCSetTable(const std::vector<u8>& input, std::vector<u8>& output) {
    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
    IoctlZbcSetTable params{};
    std::memcpy(&params, input.data(), input.size());
    // TODO(ogniK): What does this even actually do?
@@ -153,6 +161,7 @@ u32 nvhost_ctrl_gpu::ZBCSetTable(const std::vector<u8>& input, std::vector<u8>&
 u32 nvhost_ctrl_gpu::ZBCQueryTable(const std::vector<u8>& input, std::vector<u8>& output) {
    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
    IoctlZbcQueryTable params{};
    std::memcpy(&params, input.data(), input.size());
    // TODO : To implement properly
@@ -162,6 +171,7 @@ u32 nvhost_ctrl_gpu::ZBCQueryTable(const std::vector<u8>& input, std::vector<u8>
 u32 nvhost_ctrl_gpu::FlushL2(const std::vector<u8>& input, std::vector<u8>& output) {
    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
    IoctlFlushL2 params{};
    std::memcpy(&params, input.data(), input.size());
    // TODO : To implement properly
@@ -169,4 +179,14 @@ u32 nvhost_ctrl_gpu::FlushL2(const std::vector<u8>& input, std::vector<u8>& outp
    return 0;
 }
+u32 nvhost_ctrl_gpu::GetGpuTime(const std::vector<u8>& input, std::vector<u8>& output) {
+    LOG_DEBUG(Service_NVDRV, "called");
+    IoctlGetGpuTime params{};
+    std::memcpy(&params, input.data(), input.size());
+    params.gpu_time = CoreTiming::cyclesToNs(CoreTiming::GetTicks());
+    std::memcpy(output.data(), &params, output.size());
+    return 0;
+}
 } // namespace Service::Nvidia::Devices
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h b/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h
index 3bbf028ad..240435eea 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h
+++ b/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h
@@ -156,6 +156,11 @@ private:
    };
    static_assert(sizeof(IoctlFlushL2) == 8, "IoctlFlushL2 is incorrect size");
+    struct IoctlGetGpuTime {
+        u64_le gpu_time;
+    };
+    static_assert(sizeof(IoctlGetGpuTime) == 8, "IoctlGetGpuTime is incorrect size");
    u32 GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output);
    u32 GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output);
    u32 GetActiveSlotMask(const std::vector<u8>& input, std::vector<u8>& output);
@@ -164,6 +169,7 @@ private:
    u32 ZBCSetTable(const std::vector<u8>& input, std::vector<u8>& output);
    u32 ZBCQueryTable(const std::vector<u8>& input, std::vector<u8>& output);
    u32 FlushL2(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 GetGpuTime(const std::vector<u8>& input, std::vector<u8>& output);
 };
 } // namespace Service::Nvidia::Devices
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp b/src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp
index 874d5e1c3..3bfce0110 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp
@@ -8,7 +8,6 @@
 #include "core/core.h"
 #include "core/hle/service/nvdrv/devices/nvhost_gpu.h"
 #include "core/memory.h"
-#include "video_core/command_processor.h"
 #include "video_core/gpu.h"
 #include "video_core/memory_manager.h"
@@ -61,12 +60,14 @@ u32 nvhost_gpu::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output
    IoctlSetNvmapFD params{};
    std::memcpy(&params, input.data(), input.size());
    LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
    nvmap_fd = params.nvmap_fd;
    return 0;
 }
 u32 nvhost_gpu::SetClientData(const std::vector<u8>& input, std::vector<u8>& output) {
    LOG_DEBUG(Service_NVDRV, "called");
    IoctlClientData params{};
    std::memcpy(&params, input.data(), input.size());
    user_data = params.data;
@@ -75,6 +76,7 @@ u32 nvhost_gpu::SetClientData(const std::vector<u8>& input, std::vector<u8>& out
 u32 nvhost_gpu::GetClientData(const std::vector<u8>& input, std::vector<u8>& output) {
    LOG_DEBUG(Service_NVDRV, "called");
    IoctlClientData params{};
    std::memcpy(&params, input.data(), input.size());
    params.data = user_data;
@@ -86,6 +88,7 @@ u32 nvhost_gpu::ZCullBind(const std::vector<u8>& input, std::vector<u8>& output)
    std::memcpy(&zcull_params, input.data(), input.size());
    LOG_DEBUG(Service_NVDRV, "called, gpu_va={:X}, mode={:X}", zcull_params.gpu_va,
              zcull_params.mode);
    std::memcpy(output.data(), &zcull_params, output.size());
    return 0;
 }
@@ -95,6 +98,7 @@ u32 nvhost_gpu::SetErrorNotifier(const std::vector<u8>& input, std::vector<u8>&
    std::memcpy(&params, input.data(), input.size());
    LOG_WARNING(Service_NVDRV, "(STUBBED) called, offset={:X}, size={:X}, mem={:X}", params.offset,
                params.size, params.mem);
    std::memcpy(output.data(), &params, output.size());
    return 0;
 }
@@ -102,6 +106,7 @@ u32 nvhost_gpu::SetErrorNotifier(const std::vector<u8>& input, std::vector<u8>&
 u32 nvhost_gpu::SetChannelPriority(const std::vector<u8>& input, std::vector<u8>& output) {
    std::memcpy(&channel_priority, input.data(), input.size());
    LOG_DEBUG(Service_NVDRV, "(STUBBED) called, priority={:X}", channel_priority);
    return 0;
 }
@@ -113,6 +118,7 @@ u32 nvhost_gpu::AllocGPFIFOEx2(const std::vector<u8>& input, std::vector<u8>& ou
                "unk1={:X}, unk2={:X}, unk3={:X}",
                params.num_entries, params.flags, params.unk0, params.unk1, params.unk2,
                params.unk3);
    params.fence_out.id = 0;
    params.fence_out.value = 0;
    std::memcpy(output.data(), &params, output.size());
@@ -124,11 +130,18 @@ u32 nvhost_gpu::AllocateObjectContext(const std::vector<u8>& input, std::vector<
    std::memcpy(&params, input.data(), input.size());
    LOG_WARNING(Service_NVDRV, "(STUBBED) called, class_num={:X}, flags={:X}", params.class_num,
                params.flags);
    params.obj_id = 0x0;
    std::memcpy(output.data(), &params, output.size());
    return 0;
 }
+static void PushGPUEntries(Tegra::CommandList&& entries) {
+    auto& dma_pusher{Core::System::GetInstance().GPU().DmaPusher()};
+    dma_pusher.Push(std::move(entries));
+    dma_pusher.DispatchCalls();
+}
 u32 nvhost_gpu::SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& output) {
    if (input.size() < sizeof(IoctlSubmitGpfifo)) {
        UNIMPLEMENTED();
@@ -142,11 +155,11 @@ u32 nvhost_gpu::SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& outp
                                   params.num_entries * sizeof(Tegra::CommandListHeader),
               "Incorrect input size");
-    std::vector<Tegra::CommandListHeader> entries(params.num_entries);
+    Tegra::CommandList entries(params.num_entries);
    std::memcpy(entries.data(), &input[sizeof(IoctlSubmitGpfifo)],
                params.num_entries * sizeof(Tegra::CommandListHeader));
-    Core::System::GetInstance().GPU().ProcessCommandLists(entries);
+    PushGPUEntries(std::move(entries));
    params.fence_out.id = 0;
    params.fence_out.value = 0;
@@ -163,11 +176,11 @@ u32 nvhost_gpu::KickoffPB(const std::vector<u8>& input, std::vector<u8>& output)
    LOG_WARNING(Service_NVDRV, "(STUBBED) called, gpfifo={:X}, num_entries={:X}, flags={:X}",
                params.address, params.num_entries, params.flags);
-    std::vector<Tegra::CommandListHeader> entries(params.num_entries);
+    Tegra::CommandList entries(params.num_entries);
    Memory::ReadBlock(params.address, entries.data(),
                      params.num_entries * sizeof(Tegra::CommandListHeader));
-    Core::System::GetInstance().GPU().ProcessCommandLists(entries);
+    PushGPUEntries(std::move(entries));
    params.fence_out.id = 0;
    params.fence_out.value = 0;
@@ -179,6 +192,7 @@ u32 nvhost_gpu::GetWaitbase(const std::vector<u8>& input, std::vector<u8>& outpu
    IoctlGetWaitbase params{};
    std::memcpy(&params, input.data(), sizeof(IoctlGetWaitbase));
    LOG_INFO(Service_NVDRV, "called, unknown=0x{:X}", params.unknown);
    params.value = 0; // Seems to be hard coded at 0
    std::memcpy(output.data(), &params, output.size());
    return 0;
@@ -188,6 +202,7 @@ u32 nvhost_gpu::ChannelSetTimeout(const std::vector<u8>& input, std::vector<u8>&
    IoctlChannelSetTimeout params{};
    std::memcpy(&params, input.data(), sizeof(IoctlChannelSetTimeout));
    LOG_INFO(Service_NVDRV, "called, timeout=0x{:X}", params.timeout);
    return 0;
 }
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp b/src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp
index 46dbbc37c..f5e8ea7c3 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp
@@ -30,6 +30,7 @@ u32 nvhost_nvdec::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& outp
    IoctlSetNvmapFD params{};
    std::memcpy(&params, input.data(), input.size());
    LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
    nvmap_fd = params.nvmap_fd;
    return 0;
 }
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_nvjpg.cpp b/src/core/hle/service/nvdrv/devices/nvhost_nvjpg.cpp
index c67f934f6..3e0951ab0 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_nvjpg.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_nvjpg.cpp
@@ -30,6 +30,7 @@ u32 nvhost_nvjpg::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& outp
    IoctlSetNvmapFD params{};
    std::memcpy(&params, input.data(), input.size());
    LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
    nvmap_fd = params.nvmap_fd;
    return 0;
 }
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_vic.cpp b/src/core/hle/service/nvdrv/devices/nvhost_vic.cpp
index 727b9fee4..d544f0f31 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_vic.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_vic.cpp
@@ -30,6 +30,7 @@ u32 nvhost_vic::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output
    IoctlSetNvmapFD params{};
    std::memcpy(&params, input.data(), input.size());
    LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
    nvmap_fd = params.nvmap_fd;
    return 0;
 }
diff --git a/src/core/hle/service/nvdrv/devices/nvmap.cpp b/src/core/hle/service/nvdrv/devices/nvmap.cpp
index 43651d8a6..1ec796fc6 100644
--- a/src/core/hle/service/nvdrv/devices/nvmap.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvmap.cpp
@@ -54,6 +54,7 @@ u32 nvmap::IocCreate(const std::vector<u8>& input, std::vector<u8>& output) {
    LOG_DEBUG(Service_NVDRV, "size=0x{:08X}", params.size);
    if (!params.size) {
+        LOG_ERROR(Service_NVDRV, "Size is 0");
        return static_cast<u32>(NvErrCodes::InvalidValue);
    }
    // Create a new nvmap object and obtain a handle to it.
@@ -78,10 +79,12 @@ u32 nvmap::IocAlloc(const std::vector<u8>& input, std::vector<u8>& output) {
    LOG_DEBUG(Service_NVDRV, "called, addr={:X}", params.addr);
    if (!params.handle) {
+        LOG_ERROR(Service_NVDRV, "Handle is 0");
        return static_cast<u32>(NvErrCodes::InvalidValue);
    }
    if ((params.align - 1) & params.align) {
+        LOG_ERROR(Service_NVDRV, "Incorrect alignment used, alignment={:08X}", params.align);
        return static_cast<u32>(NvErrCodes::InvalidValue);
    }
@@ -92,10 +95,12 @@ u32 nvmap::IocAlloc(const std::vector<u8>& input, std::vector<u8>& output) {
    auto object = GetObject(params.handle);
    if (!object) {
+        LOG_ERROR(Service_NVDRV, "Object does not exist, handle={:08X}", params.handle);
        return static_cast<u32>(NvErrCodes::InvalidValue);
    }
    if (object->status == Object::Status::Allocated) {
+        LOG_ERROR(Service_NVDRV, "Object is already allocated, handle={:08X}", params.handle);
        return static_cast<u32>(NvErrCodes::OperationNotPermitted);
    }
@@ -116,11 +121,13 @@ u32 nvmap::IocGetId(const std::vector<u8>& input, std::vector<u8>& output) {
    LOG_WARNING(Service_NVDRV, "called");
    if (!params.handle) {
+        LOG_ERROR(Service_NVDRV, "Handle is zero");
        return static_cast<u32>(NvErrCodes::InvalidValue);
    }
    auto object = GetObject(params.handle);
    if (!object) {
+        LOG_ERROR(Service_NVDRV, "Object does not exist, handle={:08X}", params.handle);
        return static_cast<u32>(NvErrCodes::OperationNotPermitted);
    }
@@ -139,11 +146,13 @@ u32 nvmap::IocFromId(const std::vector<u8>& input, std::vector<u8>& output) {
    auto itr = std::find_if(handles.begin(), handles.end(),
                            [&](const auto& entry) { return entry.second->id == params.id; });
    if (itr == handles.end()) {
+        LOG_ERROR(Service_NVDRV, "Object does not exist, handle={:08X}", params.handle);
        return static_cast<u32>(NvErrCodes::InvalidValue);
    }
    auto& object = itr->second;
    if (object->status != Object::Status::Allocated) {
+        LOG_ERROR(Service_NVDRV, "Object is not allocated, handle={:08X}", params.handle);
        return static_cast<u32>(NvErrCodes::InvalidValue);
    }
@@ -166,10 +175,12 @@ u32 nvmap::IocParam(const std::vector<u8>& input, std::vector<u8>& output) {
    auto object = GetObject(params.handle);
    if (!object) {
+        LOG_ERROR(Service_NVDRV, "Object does not exist, handle={:08X}", params.handle);
        return static_cast<u32>(NvErrCodes::InvalidValue);
    }
    if (object->status != Object::Status::Allocated) {
+        LOG_ERROR(Service_NVDRV, "Object is not allocated, handle={:08X}", params.handle);
        return static_cast<u32>(NvErrCodes::OperationNotPermitted);
    }
@@ -209,9 +220,14 @@ u32 nvmap::IocFree(const std::vector<u8>& input, std::vector<u8>& output) {
    auto itr = handles.find(params.handle);
    if (itr == handles.end()) {
+        LOG_ERROR(Service_NVDRV, "Object does not exist, handle={:08X}", params.handle);
        return static_cast<u32>(NvErrCodes::InvalidValue);
    }
    if (!itr->second->refcount) {
+        LOG_ERROR(
+            Service_NVDRV,
+            "There is no references to this object. The object is already freed. handle={:08X}",
+            params.handle);
        return static_cast<u32>(NvErrCodes::InvalidValue);
    }
diff --git a/src/core/hle/service/nvdrv/interface.cpp b/src/core/hle/service/nvdrv/interface.cpp
index ac3859353..ff76e0524 100644
--- a/src/core/hle/service/nvdrv/interface.cpp
+++ b/src/core/hle/service/nvdrv/interface.cpp
@@ -55,6 +55,7 @@ void NVDRV::Close(Kernel::HLERequestContext& ctx) {
 void NVDRV::Initialize(Kernel::HLERequestContext& ctx) {
    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(0);
@@ -75,8 +76,8 @@ void NVDRV::QueryEvent(Kernel::HLERequestContext& ctx) {
 void NVDRV::SetClientPID(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    pid = rp.Pop<u64>();
    LOG_WARNING(Service_NVDRV, "(STUBBED) called, pid=0x{:X}", pid);
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(0);
@@ -84,6 +85,23 @@ void NVDRV::SetClientPID(Kernel::HLERequestContext& ctx) {
 void NVDRV::FinishInitialize(Kernel::HLERequestContext& ctx) {
    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+void NVDRV::GetStatus(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+void NVDRV::DumpGraphicsMemoryInfo(Kernel::HLERequestContext& ctx) {
+    // According to SwitchBrew, this has no inputs and no outputs, so effectively does nothing on
+    // retail hardware.
+    LOG_DEBUG(Service_NVDRV, "called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }
@@ -97,10 +115,10 @@ NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
        {3, &NVDRV::Initialize, "Initialize"},
        {4, &NVDRV::QueryEvent, "QueryEvent"},
        {5, nullptr, "MapSharedMem"},
-        {6, nullptr, "GetStatus"},
+        {6, &NVDRV::GetStatus, "GetStatus"},
        {7, nullptr, "ForceSetClientPID"},
        {8, &NVDRV::SetClientPID, "SetClientPID"},
-        {9, nullptr, "DumpGraphicsMemoryInfo"},
+        {9, &NVDRV::DumpGraphicsMemoryInfo, "DumpGraphicsMemoryInfo"},
        {10, nullptr, "InitializeDevtools"},
        {11, &NVDRV::Ioctl, "Ioctl2"},
        {12, nullptr, "Ioctl3"},
diff --git a/src/core/hle/service/nvdrv/interface.h b/src/core/hle/service/nvdrv/interface.h
index d340893c2..5a1e4baa7 100644
--- a/src/core/hle/service/nvdrv/interface.h
+++ b/src/core/hle/service/nvdrv/interface.h
@@ -24,6 +24,8 @@ private:
    void QueryEvent(Kernel::HLERequestContext& ctx);
    void SetClientPID(Kernel::HLERequestContext& ctx);
    void FinishInitialize(Kernel::HLERequestContext& ctx);
+    void GetStatus(Kernel::HLERequestContext& ctx);
+    void DumpGraphicsMemoryInfo(Kernel::HLERequestContext& ctx);
    std::shared_ptr<Module> nvdrv;
diff --git a/src/core/hle/service/nvflinger/buffer_queue.cpp b/src/core/hle/service/nvflinger/buffer_queue.cpp
index 630ebbfc7..172a1a441 100644
--- a/src/core/hle/service/nvflinger/buffer_queue.cpp
+++ b/src/core/hle/service/nvflinger/buffer_queue.cpp
@@ -20,13 +20,13 @@ BufferQueue::BufferQueue(u32 id, u64 layer_id) : id(id), layer_id(layer_id) {
 BufferQueue::~BufferQueue() = default;
 void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer) {
+    LOG_WARNING(Service, "Adding graphics buffer {}", slot);
    Buffer buffer{};
    buffer.slot = slot;
    buffer.igbp_buffer = igbp_buffer;
    buffer.status = Buffer::Status::Free;
-    LOG_WARNING(Service, "Adding graphics buffer {}", slot);
    queue.emplace_back(buffer);
    buffer_wait_event->Signal();
 }
@@ -92,6 +92,7 @@ void BufferQueue::ReleaseBuffer(u32 slot) {
 u32 BufferQueue::Query(QueryType type) {
    LOG_WARNING(Service, "(STUBBED) called type={}", static_cast<u32>(type));
    switch (type) {
    case QueryType::NativeWindowFormat:
        // TODO(Subv): Use an enum for this
diff --git a/src/core/hle/service/pctl/module.cpp b/src/core/hle/service/pctl/module.cpp
index 4fd185f69..6081f41e1 100644
--- a/src/core/hle/service/pctl/module.cpp
+++ b/src/core/hle/service/pctl/module.cpp
@@ -114,29 +114,33 @@ public:
 private:
    void Initialize(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_PCTL, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 0};
        rb.Push(RESULT_SUCCESS);
    }
    void CheckFreeCommunicationPermission(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_PCTL, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
 };
 void Module::Interface::CreateService(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_PCTL, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IParentalControlService>();
-    LOG_DEBUG(Service_PCTL, "called");
 }
 void Module::Interface::CreateServiceWithoutInitialize(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_PCTL, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IParentalControlService>();
-    LOG_DEBUG(Service_PCTL, "called");
 }
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
diff --git a/src/core/hle/service/pm/pm.cpp b/src/core/hle/service/pm/pm.cpp
index 6ec35ca60..53e7da9c3 100644
--- a/src/core/hle/service/pm/pm.cpp
+++ b/src/core/hle/service/pm/pm.cpp
@@ -20,11 +20,11 @@ public:
 private:
    void GetBootMode(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_PM, "called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(static_cast<u32>(SystemBootMode::Normal)); // Normal boot mode
-        LOG_DEBUG(Service_PM, "called");
    }
 };
diff --git a/src/core/hle/service/psc/psc.cpp b/src/core/hle/service/psc/psc.cpp
index bbad870a2..0ba0a4076 100644
--- a/src/core/hle/service/psc/psc.cpp
+++ b/src/core/hle/service/psc/psc.cpp
@@ -61,11 +61,11 @@ public:
 private:
    void GetPmModule(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_PSC, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IPmModule>();
-        LOG_DEBUG(Service_PSC, "called");
    }
 };
diff --git a/src/core/hle/service/set/set.cpp b/src/core/hle/service/set/set.cpp
index 9e5af7839..40a9144f9 100644
--- a/src/core/hle/service/set/set.cpp
+++ b/src/core/hle/service/set/set.cpp
@@ -49,38 +49,39 @@ static std::array<LanguageCode, size> MakeLanguageCodeSubset() {
 static void PushResponseLanguageCode(Kernel::HLERequestContext& ctx, std::size_t max_size) {
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
-    if (available_language_codes.size() > max_size)
+    if (available_language_codes.size() > max_size) {
        rb.Push(static_cast<u32>(max_size));
-    else
+    } else {
        rb.Push(static_cast<u32>(available_language_codes.size()));
+    }
 }
 void SET::GetAvailableLanguageCodes(Kernel::HLERequestContext& ctx) {
-    if (available_language_codes.size() > pre4_0_0_max_entries)
+    LOG_DEBUG(Service_SET, "called");
+    if (available_language_codes.size() > pre4_0_0_max_entries) {
        ctx.WriteBuffer(MakeLanguageCodeSubset<pre4_0_0_max_entries>());
-    else
+    } else {
        ctx.WriteBuffer(available_language_codes);
+    }
    PushResponseLanguageCode(ctx, pre4_0_0_max_entries);
-    LOG_DEBUG(Service_SET, "called");
 }
 void SET::GetAvailableLanguageCodes2(Kernel::HLERequestContext& ctx) {
-    if (available_language_codes.size() > post4_0_0_max_entries)
+    LOG_DEBUG(Service_SET, "called");
+    if (available_language_codes.size() > post4_0_0_max_entries) {
        ctx.WriteBuffer(MakeLanguageCodeSubset<post4_0_0_max_entries>());
-    else
+    } else {
        ctx.WriteBuffer(available_language_codes);
+    }
    PushResponseLanguageCode(ctx, post4_0_0_max_entries);
-    LOG_DEBUG(Service_SET, "called");
 }
 void SET::GetAvailableLanguageCodeCount(Kernel::HLERequestContext& ctx) {
-    PushResponseLanguageCode(ctx, pre4_0_0_max_entries);
    LOG_DEBUG(Service_SET, "called");
+    PushResponseLanguageCode(ctx, pre4_0_0_max_entries);
 }
 void SET::GetAvailableLanguageCodeCount2(Kernel::HLERequestContext& ctx) {
@@ -90,11 +91,11 @@ void SET::GetAvailableLanguageCodeCount2(Kernel::HLERequestContext& ctx) {
 }
 void SET::GetLanguageCode(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called {}", Settings::values.language_index);
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(RESULT_SUCCESS);
    rb.Push(static_cast<u64>(available_language_codes[Settings::values.language_index]));
-    LOG_DEBUG(Service_SET, "called {}", Settings::values.language_index);
 }
 SET::SET() : ServiceFramework("set") {
diff --git a/src/core/hle/service/set/set_sys.cpp b/src/core/hle/service/set/set_sys.cpp
index 41efca31c..c9b4da5b0 100644
--- a/src/core/hle/service/set/set_sys.cpp
+++ b/src/core/hle/service/set/set_sys.cpp
@@ -10,22 +10,22 @@
 namespace Service::Set {
 void SET_SYS::GetColorSetId(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.PushEnum(color_set);
-    LOG_DEBUG(Service_SET, "called");
 }
 void SET_SYS::SetColorSetId(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called");
    IPC::RequestParser rp{ctx};
    color_set = rp.PopEnum<ColorSet>();
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_DEBUG(Service_SET, "called");
 }
 SET_SYS::SET_SYS() : ServiceFramework("set:sys") {
diff --git a/src/core/hle/service/sm/controller.cpp b/src/core/hle/service/sm/controller.cpp
index 98f6e4111..74da4d5e6 100644
--- a/src/core/hle/service/sm/controller.cpp
+++ b/src/core/hle/service/sm/controller.cpp
@@ -14,25 +14,26 @@ namespace Service::SM {
 void Controller::ConvertSessionToDomain(Kernel::HLERequestContext& ctx) {
    ASSERT_MSG(ctx.Session()->IsSession(), "Session is already a domain");
+    LOG_DEBUG(Service, "called, server_session={}", ctx.Session()->GetObjectId());
    ctx.Session()->ConvertToDomain();
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(1); // Converted sessions start with 1 request handler
-    LOG_DEBUG(Service, "called, server_session={}", ctx.Session()->GetObjectId());
 }
 void Controller::DuplicateSession(Kernel::HLERequestContext& ctx) {
    // TODO(bunnei): This is just creating a new handle to the same Session. I assume this is wrong
    // and that we probably want to actually make an entirely new Session, but we still need to
    // verify this on hardware.
+    LOG_DEBUG(Service, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
    rb.Push(RESULT_SUCCESS);
    Kernel::SharedPtr<Kernel::ClientSession> session{ctx.Session()->parent->client};
    rb.PushMoveObjects(session);
-    LOG_DEBUG(Service, "called, session={}", session->GetObjectId());
+    LOG_DEBUG(Service, "session={}", session->GetObjectId());
 }
 void Controller::DuplicateSessionEx(Kernel::HLERequestContext& ctx) {
@@ -42,11 +43,11 @@ void Controller::DuplicateSessionEx(Kernel::HLERequestContext& ctx) {
 }
 void Controller::QueryPointerBufferSize(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u16>(0x500);
-    LOG_WARNING(Service, "(STUBBED) called");
 }
 Controller::Controller() : ServiceFramework("IpcController") {
diff --git a/src/core/hle/service/sm/sm.cpp b/src/core/hle/service/sm/sm.cpp
index 464e79d01..0d0f63a78 100644
--- a/src/core/hle/service/sm/sm.cpp
+++ b/src/core/hle/service/sm/sm.cpp
@@ -63,6 +63,17 @@ ResultVal<Kernel::SharedPtr<Kernel::ServerPort>> ServiceManager::RegisterService
    return MakeResult<Kernel::SharedPtr<Kernel::ServerPort>>(std::move(server_port));
 }
+ResultCode ServiceManager::UnregisterService(const std::string& name) {
+    CASCADE_CODE(ValidateServiceName(name));
+    const auto iter = registered_services.find(name);
+    if (iter == registered_services.end())
+        return ERR_SERVICE_NOT_REGISTERED;
+    registered_services.erase(iter);
+    return RESULT_SUCCESS;
+}
 ResultVal<Kernel::SharedPtr<Kernel::ClientPort>> ServiceManager::GetServicePort(
    const std::string& name) {
@@ -92,9 +103,10 @@ SM::~SM() = default;
 *      0: ResultCode
 */
 void SM::Initialize(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SM, "called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_DEBUG(Service_SM, "called");
 }
 void SM::GetService(Kernel::HLERequestContext& ctx) {
@@ -127,13 +139,53 @@ void SM::GetService(Kernel::HLERequestContext& ctx) {
    }
 }
+void SM::RegisterService(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto name_buf = rp.PopRaw<std::array<char, 8>>();
+    const auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
+    const std::string name(name_buf.begin(), end);
+    const auto unk_bool = static_cast<bool>(rp.PopRaw<u32>());
+    const auto session_count = rp.PopRaw<u32>();
+    LOG_DEBUG(Service_SM, "called with unk_bool={}", unk_bool);
+    auto handle = service_manager->RegisterService(name, session_count);
+    if (handle.Failed()) {
+        LOG_ERROR(Service_SM, "failed to register service with error_code={:08X}",
+                  handle.Code().raw);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(handle.Code());
+        return;
+    }
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
+    rb.Push(handle.Code());
+    rb.PushMoveObjects(std::move(handle).Unwrap());
+}
+void SM::UnregisterService(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto name_buf = rp.PopRaw<std::array<char, 8>>();
+    const auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
+    const std::string name(name_buf.begin(), end);
+    LOG_DEBUG(Service_SM, "called with name={}", name);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(service_manager->UnregisterService(name));
+}
 SM::SM(std::shared_ptr<ServiceManager> service_manager)
    : ServiceFramework("sm:", 4), service_manager(std::move(service_manager)) {
    static const FunctionInfo functions[] = {
        {0x00000000, &SM::Initialize, "Initialize"},
        {0x00000001, &SM::GetService, "GetService"},
-        {0x00000002, nullptr, "RegisterService"},
+        {0x00000002, &SM::RegisterService, "RegisterService"},
-        {0x00000003, nullptr, "UnregisterService"},
+        {0x00000003, &SM::UnregisterService, "UnregisterService"},
    };
    RegisterHandlers(functions);
 }
diff --git a/src/core/hle/service/sm/sm.h b/src/core/hle/service/sm/sm.h
index 4f8145dda..bef25433e 100644
--- a/src/core/hle/service/sm/sm.h
+++ b/src/core/hle/service/sm/sm.h
@@ -35,6 +35,8 @@ public:
 private:
    void Initialize(Kernel::HLERequestContext& ctx);
    void GetService(Kernel::HLERequestContext& ctx);
+    void RegisterService(Kernel::HLERequestContext& ctx);
+    void UnregisterService(Kernel::HLERequestContext& ctx);
    std::shared_ptr<ServiceManager> service_manager;
 };
@@ -48,6 +50,7 @@ public:
    ResultVal<Kernel::SharedPtr<Kernel::ServerPort>> RegisterService(std::string name,
                                                                     unsigned int max_sessions);
+    ResultCode UnregisterService(const std::string& name);
    ResultVal<Kernel::SharedPtr<Kernel::ClientPort>> GetServicePort(const std::string& name);
    ResultVal<Kernel::SharedPtr<Kernel::ClientSession>> ConnectToService(const std::string& name);
diff --git a/src/core/hle/service/spl/module.cpp b/src/core/hle/service/spl/module.cpp
index b2de2a818..8db0c2f13 100644
--- a/src/core/hle/service/spl/module.cpp
+++ b/src/core/hle/service/spl/module.cpp
@@ -24,6 +24,8 @@ Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
 Module::Interface::~Interface() = default;
 void Module::Interface::GetRandomBytes(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SPL, "called");
    IPC::RequestParser rp{ctx};
    std::size_t size = ctx.GetWriteBufferSize();
@@ -36,7 +38,6 @@ void Module::Interface::GetRandomBytes(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    LOG_DEBUG(Service_SPL, "called");
 }
 void InstallInterfaces(SM::ServiceManager& service_manager) {
diff --git a/src/core/hle/service/ssl/ssl.cpp b/src/core/hle/service/ssl/ssl.cpp
index bc4f7a437..af40a1815 100644
--- a/src/core/hle/service/ssl/ssl.cpp
+++ b/src/core/hle/service/ssl/ssl.cpp
@@ -69,6 +69,7 @@ public:
 private:
    void SetOption(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_SSL, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        IPC::ResponseBuilder rb{ctx, 2};
@@ -114,6 +115,7 @@ private:
    void SetInterfaceVersion(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_SSL, "called");
        IPC::RequestParser rp{ctx};
        ssl_version = rp.Pop<u32>();
diff --git a/src/core/hle/service/time/time.cpp b/src/core/hle/service/time/time.cpp
index e561a0c52..60b201d06 100644
--- a/src/core/hle/service/time/time.cpp
+++ b/src/core/hle/service/time/time.cpp
@@ -72,6 +72,7 @@ private:
                                       std::chrono::system_clock::now().time_since_epoch())
                                       .count()};
        LOG_DEBUG(Service_Time, "called");
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u64>(time_since_epoch);
@@ -79,6 +80,7 @@ private:
    void GetSystemClockContext(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_Time, "(STUBBED) called");
        SystemClockContext system_clock_ontext{};
        IPC::ResponseBuilder rb{ctx, (sizeof(SystemClockContext) / 4) + 2};
        rb.Push(RESULT_SUCCESS);
@@ -98,6 +100,7 @@ public:
 private:
    void GetCurrentTimePoint(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_Time, "called");
        SteadyClockTimePoint steady_clock_time_point{
            CoreTiming::cyclesToMs(CoreTiming::GetTicks()) / 1000};
        IPC::ResponseBuilder rb{ctx, (sizeof(SteadyClockTimePoint) / 4) + 2};
@@ -130,6 +133,7 @@ private:
    void GetDeviceLocationName(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_Time, "called");
        IPC::ResponseBuilder rb{ctx, (sizeof(LocationName) / 4) + 2};
        rb.Push(RESULT_SUCCESS);
        rb.PushRaw(location_name);
@@ -137,6 +141,7 @@ private:
    void GetTotalLocationNameCount(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_Time, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(0);
@@ -154,7 +159,6 @@ private:
    void ToCalendarTime(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const u64 posix_time = rp.Pop<u64>();
        LOG_WARNING(Service_Time, "(STUBBED) called, posix_time=0x{:016X}", posix_time);
        TimeZoneRule time_zone_rule{};
@@ -175,7 +179,6 @@ private:
    void ToCalendarTimeWithMyRule(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const u64 posix_time = rp.Pop<u64>();
        LOG_WARNING(Service_Time, "(STUBBED) called, posix_time=0x{:016X}", posix_time);
        CalendarTime calendar_time{2018, 1, 1, 0, 0, 0};
@@ -192,6 +195,7 @@ private:
    void ToPosixTime(Kernel::HLERequestContext& ctx) {
        // TODO(ogniK): Figure out how to handle multiple times
        LOG_WARNING(Service_Time, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        auto calendar_time = rp.PopRaw<CalendarTime>();
        auto posix_time = CalendarToPosix(calendar_time, {});
@@ -204,6 +208,7 @@ private:
    void ToPosixTimeWithMyRule(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_Time, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        auto calendar_time = rp.PopRaw<CalendarTime>();
        auto posix_time = CalendarToPosix(calendar_time, {});
@@ -216,38 +221,43 @@ private:
 };
 void Module::Interface::GetStandardUserSystemClock(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ISystemClock>();
-    LOG_DEBUG(Service_Time, "called");
 }
 void Module::Interface::GetStandardNetworkSystemClock(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ISystemClock>();
-    LOG_DEBUG(Service_Time, "called");
 }
 void Module::Interface::GetStandardSteadyClock(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ISteadyClock>();
-    LOG_DEBUG(Service_Time, "called");
 }
 void Module::Interface::GetTimeZoneService(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ITimeZoneService>();
-    LOG_DEBUG(Service_Time, "called");
 }
 void Module::Interface::GetStandardLocalSystemClock(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ISystemClock>();
-    LOG_DEBUG(Service_Time, "called");
 }
 void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
@@ -265,6 +275,7 @@ void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
    const std::time_t time(time_since_epoch);
    const std::tm* tm = std::localtime(&time);
    if (tm == nullptr) {
+        LOG_ERROR(Service_Time, "tm is a nullptr");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(ResultCode(-1)); // TODO(ogniK): Find appropriate error code
        return;
diff --git a/src/core/hle/service/usb/usb.cpp b/src/core/hle/service/usb/usb.cpp
index f0a831d45..f082a63bc 100644
--- a/src/core/hle/service/usb/usb.cpp
+++ b/src/core/hle/service/usb/usb.cpp
@@ -159,11 +159,11 @@ public:
 private:
    void GetPdSession(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_USB, "called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IPdSession>();
-        LOG_DEBUG(Service_USB, "called");
    }
 };
diff --git a/src/core/hle/service/vi/vi.cpp b/src/core/hle/service/vi/vi.cpp
index d25fdb1fe..5120abfff 100644
--- a/src/core/hle/service/vi/vi.cpp
+++ b/src/core/hle/service/vi/vi.cpp
@@ -504,13 +504,17 @@ private:
        u32 id = rp.Pop<u32>();
        auto transaction = static_cast<TransactionId>(rp.Pop<u32>());
        u32 flags = rp.Pop<u32>();
-        auto buffer_queue = nv_flinger->GetBufferQueue(id);
        LOG_DEBUG(Service_VI, "called, transaction={:X}", static_cast<u32>(transaction));
+        auto buffer_queue = nv_flinger->GetBufferQueue(id);
        if (transaction == TransactionId::Connect) {
            IGBPConnectRequestParcel request{ctx.ReadBuffer()};
-            IGBPConnectResponseParcel response{1280, 720};
+            IGBPConnectResponseParcel response{
+                static_cast<u32>(static_cast<u32>(DisplayResolution::UndockedWidth) *
+                                 Settings::values.resolution_factor),
+                static_cast<u32>(static_cast<u32>(DisplayResolution::UndockedHeight) *
+                                 Settings::values.resolution_factor)};
            ctx.WriteBuffer(response.Serialize());
        } else if (transaction == TransactionId::SetPreallocatedBuffer) {
            IGBPSetPreallocatedBufferRequestParcel request{ctx.ReadBuffer()};
@@ -589,9 +593,9 @@ private:
        u32 id = rp.Pop<u32>();
        s32 addval = rp.PopRaw<s32>();
        u32 type = rp.Pop<u32>();
        LOG_WARNING(Service_VI, "(STUBBED) called id={}, addval={:08X}, type={:08X}", id, addval,
                    type);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
@@ -600,12 +604,11 @@ private:
        IPC::RequestParser rp{ctx};
        u32 id = rp.Pop<u32>();
        u32 unknown = rp.Pop<u32>();
+        LOG_WARNING(Service_VI, "(STUBBED) called id={}, unknown={:08X}", id, unknown);
        auto buffer_queue = nv_flinger->GetBufferQueue(id);
        // TODO(Subv): Find out what this actually is.
-        LOG_WARNING(Service_VI, "(STUBBED) called id={}, unknown={:08X}", id, unknown);
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(buffer_queue->GetBufferWaitEvent());
@@ -669,6 +672,7 @@ public:
 private:
    void SetLayerZ(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u64 layer_id = rp.Pop<u64>();
        u64 z_value = rp.Pop<u64>();
@@ -681,28 +685,33 @@ private:
        IPC::RequestParser rp{ctx};
        u64 layer_id = rp.Pop<u64>();
        bool visibility = rp.Pop<bool>();
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
        LOG_WARNING(Service_VI, "(STUBBED) called, layer_id=0x{:08X}, visibility={}", layer_id,
                    visibility);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
    }
    void GetDisplayMode(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 6};
        rb.Push(RESULT_SUCCESS);
        if (Settings::values.use_docked_mode) {
-            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth));
+            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth) *
-            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight));
+                    static_cast<u32>(Settings::values.resolution_factor));
+            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight) *
+                    static_cast<u32>(Settings::values.resolution_factor));
        } else {
-            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth));
+            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth) *
-            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight));
+                    static_cast<u32>(Settings::values.resolution_factor));
+            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight) *
+                    static_cast<u32>(Settings::values.resolution_factor));
        }
-        rb.PushRaw<float>(60.0f);
+        rb.PushRaw<float>(60.0f); // This wouldn't seem to be correct for 30 fps games.
        rb.Push<u32>(0);
-        LOG_DEBUG(Service_VI, "called");
    }
 };
@@ -785,6 +794,7 @@ public:
 private:
    void CloseDisplay(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u64 display = rp.Pop<u64>();
@@ -794,6 +804,7 @@ private:
    void CreateManagedLayer(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u32 unknown = rp.Pop<u32>();
        rp.Skip(1, false);
@@ -809,6 +820,7 @@ private:
    void AddToLayerStack(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u32 stack = rp.Pop<u32>();
        u64 layer_id = rp.Pop<u64>();
@@ -821,10 +833,11 @@ private:
        IPC::RequestParser rp{ctx};
        u64 layer_id = rp.Pop<u64>();
        bool visibility = rp.Pop<bool>();
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
        LOG_WARNING(Service_VI, "(STUBBED) called, layer_id=0x{:X}, visibility={}", layer_id,
                    visibility);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
    }
    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
@@ -870,6 +883,7 @@ private:
    void OpenDisplay(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        auto name_buf = rp.PopRaw<std::array<u8, 0x40>>();
        auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
@@ -885,6 +899,7 @@ private:
    void CloseDisplay(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u64 display_id = rp.Pop<u64>();
@@ -894,6 +909,7 @@ private:
    void GetDisplayResolution(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u64 display_id = rp.Pop<u64>();
@@ -901,16 +917,21 @@ private:
        rb.Push(RESULT_SUCCESS);
        if (Settings::values.use_docked_mode) {
-            rb.Push(static_cast<u64>(DisplayResolution::DockedWidth));
+            rb.Push(static_cast<u64>(DisplayResolution::DockedWidth) *
-            rb.Push(static_cast<u64>(DisplayResolution::DockedHeight));
+                    static_cast<u32>(Settings::values.resolution_factor));
+            rb.Push(static_cast<u64>(DisplayResolution::DockedHeight) *
+                    static_cast<u32>(Settings::values.resolution_factor));
        } else {
-            rb.Push(static_cast<u64>(DisplayResolution::UndockedWidth));
+            rb.Push(static_cast<u64>(DisplayResolution::UndockedWidth) *
-            rb.Push(static_cast<u64>(DisplayResolution::UndockedHeight));
+                    static_cast<u32>(Settings::values.resolution_factor));
+            rb.Push(static_cast<u64>(DisplayResolution::UndockedHeight) *
+                    static_cast<u32>(Settings::values.resolution_factor));
        }
    }
    void SetLayerScalingMode(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u32 scaling_mode = rp.Pop<u32>();
        u64 unknown = rp.Pop<u64>();
@@ -920,17 +941,21 @@ private:
    }
    void ListDisplays(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        DisplayInfo display_info;
+        display_info.width *= static_cast<u64>(Settings::values.resolution_factor);
+        display_info.height *= static_cast<u64>(Settings::values.resolution_factor);
        ctx.WriteBuffer(&display_info, sizeof(DisplayInfo));
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u64>(1);
-        LOG_WARNING(Service_VI, "(STUBBED) called");
    }
    void OpenLayer(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_VI, "called");
        IPC::RequestParser rp{ctx};
        auto name_buf = rp.PopRaw<std::array<u8, 0x40>>();
        auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
@@ -981,6 +1006,7 @@ private:
    void GetDisplayVsyncEvent(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u64 display_id = rp.Pop<u64>();
diff --git a/src/core/settings.h b/src/core/settings.h
index e63134f80..a0c5fd447 100644
--- a/src/core/settings.h
+++ b/src/core/settings.h
@@ -403,6 +403,7 @@ struct Values {
    bool use_gdbstub;
    u16 gdbstub_port;
    std::string program_args;
+    bool dump_exefs;
    bool dump_nso;
    // WebService
diff --git a/src/video_core/CMakeLists.txt b/src/video_core/CMakeLists.txt
index a780215c1..0406fbcd9 100644
--- a/src/video_core/CMakeLists.txt
+++ b/src/video_core/CMakeLists.txt
@@ -1,6 +1,6 @@
 add_library(video_core STATIC
-    command_processor.cpp
+    dma_pusher.cpp
-    command_processor.h
+    dma_pusher.h
    debug_utils/debug_utils.cpp
    debug_utils/debug_utils.h
    engines/fermi_2d.cpp
@@ -21,6 +21,8 @@ add_library(video_core STATIC
    macro_interpreter.h
    memory_manager.cpp
    memory_manager.h
+    morton.cpp
+    morton.h
    rasterizer_cache.cpp
    rasterizer_cache.h
    rasterizer_interface.h
@@ -62,7 +64,6 @@ add_library(video_core STATIC
    textures/decoders.cpp
    textures/decoders.h
    textures/texture.h
-    utils.h
    video_core.cpp
    video_core.h
 )
diff --git a/src/video_core/command_processor.cpp b/src/video_core/command_processor.cpp
index 28e8c13aa..8b9c548cc 100644
--- a/src/video_core/command_processor.cpp
+++ b/src/video_core/command_processor.cpp
@@ -34,6 +34,9 @@ MICROPROFILE_DEFINE(ProcessCommandLists, "GPU", "Execute command buffer", MP_RGB
 void GPU::ProcessCommandLists(const std::vector<CommandListHeader>& commands) {
    MICROPROFILE_SCOPE(ProcessCommandLists);
+    // On entering GPU code, assume all memory may be touched by the ARM core.
+    maxwell_3d->dirty_flags.OnMemoryWrite();
    auto WriteReg = [this](u32 method, u32 subchannel, u32 value, u32 remaining_params) {
        LOG_TRACE(HW_GPU,
                  "Processing method {:08X} on subchannel {} value "
diff --git a/src/video_core/command_processor.h b/src/video_core/command_processor.h
deleted file mode 100644
index bd766e77a..000000000
--- a/src/video_core/command_processor.h
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-#pragma once
-#include <type_traits>
-#include "common/bit_field.h"
-#include "common/common_types.h"
-#include "video_core/memory_manager.h"
-namespace Tegra {
-enum class SubmissionMode : u32 {
-    IncreasingOld = 0,
-    Increasing = 1,
-    NonIncreasingOld = 2,
-    NonIncreasing = 3,
-    Inline = 4,
-    IncreaseOnce = 5
-};
-struct CommandListHeader {
-    u32 entry0; // gpu_va_lo
-    union {
-        u32 entry1; // gpu_va_hi | (unk_0x02 << 0x08) | (size << 0x0A) | (unk_0x01 << 0x1F)
-        BitField<0, 8, u32> gpu_va_hi;
-        BitField<8, 2, u32> unk1;
-        BitField<10, 21, u32> sz;
-        BitField<31, 1, u32> unk2;
-    };
-    GPUVAddr Address() const {
-        return (static_cast<GPUVAddr>(gpu_va_hi) << 32) | entry0;
-    }
-};
-static_assert(sizeof(CommandListHeader) == 8, "CommandListHeader is incorrect size");
-union CommandHeader {
-    u32 hex;
-    BitField<0, 13, u32> method;
-    BitField<13, 3, u32> subchannel;
-    BitField<16, 13, u32> arg_count;
-    BitField<16, 13, u32> inline_data;
-    BitField<29, 3, SubmissionMode> mode;
-};
-static_assert(std::is_standard_layout_v<CommandHeader>, "CommandHeader is not standard layout");
-static_assert(sizeof(CommandHeader) == sizeof(u32), "CommandHeader has incorrect size!");
-} // namespace Tegra
diff --git a/src/video_core/dma_pusher.cpp b/src/video_core/dma_pusher.cpp
new file mode 100644
index 000000000..63a958f11
--- /dev/null
+++ b/src/video_core/dma_pusher.cpp
@@ -0,0 +1,123 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#include "common/microprofile.h"
+#include "core/core.h"
+#include "core/memory.h"
+#include "video_core/dma_pusher.h"
+#include "video_core/engines/maxwell_3d.h"
+#include "video_core/gpu.h"
+namespace Tegra {
+DmaPusher::DmaPusher(GPU& gpu) : gpu(gpu) {}
+DmaPusher::~DmaPusher() = default;
+MICROPROFILE_DEFINE(DispatchCalls, "GPU", "Execute command buffer", MP_RGB(128, 128, 192));
+void DmaPusher::DispatchCalls() {
+    MICROPROFILE_SCOPE(DispatchCalls);
+    // On entering GPU code, assume all memory may be touched by the ARM core.
+    gpu.Maxwell3D().dirty_flags.OnMemoryWrite();
+    dma_pushbuffer_subindex = 0;
+    while (Core::System::GetInstance().IsPoweredOn()) {
+        if (!Step()) {
+            break;
+        }
+    }
+}
+bool DmaPusher::Step() {
+    if (dma_get != dma_put) {
+        // Push buffer non-empty, read a word
+        const CommandHeader command_header{
+            Memory::Read32(*gpu.MemoryManager().GpuToCpuAddress(dma_get))};
+        dma_get += sizeof(u32);
+        if (!non_main) {
+            dma_mget = dma_get;
+        }
+        // now, see if we're in the middle of a command
+        if (dma_state.length_pending) {
+            // Second word of long non-inc methods command - method count
+            dma_state.length_pending = 0;
+            dma_state.method_count = command_header.method_count_;
+        } else if (dma_state.method_count) {
+            // Data word of methods command
+            CallMethod(command_header.argument);
+            if (!dma_state.non_incrementing) {
+                dma_state.method++;
+            }
+            if (dma_increment_once) {
+                dma_state.non_incrementing = true;
+            }
+            dma_state.method_count--;
+        } else {
+            // No command active - this is the first word of a new one
+            switch (command_header.mode) {
+            case SubmissionMode::Increasing:
+                SetState(command_header);
+                dma_state.non_incrementing = false;
+                dma_increment_once = false;
+                break;
+            case SubmissionMode::NonIncreasing:
+                SetState(command_header);
+                dma_state.non_incrementing = true;
+                dma_increment_once = false;
+                break;
+            case SubmissionMode::Inline:
+                dma_state.method = command_header.method;
+                dma_state.subchannel = command_header.subchannel;
+                CallMethod(command_header.arg_count);
+                dma_state.non_incrementing = true;
+                dma_increment_once = false;
+                break;
+            case SubmissionMode::IncreaseOnce:
+                SetState(command_header);
+                dma_state.non_incrementing = false;
+                dma_increment_once = true;
+                break;
+            }
+        }
+    } else if (ib_enable && !dma_pushbuffer.empty()) {
+        // Current pushbuffer empty, but we have more IB entries to read
+        const CommandList& command_list{dma_pushbuffer.front()};
+        const CommandListHeader& command_list_header{command_list[dma_pushbuffer_subindex++]};
+        dma_get = command_list_header.addr;
+        dma_put = dma_get + command_list_header.size * sizeof(u32);
+        non_main = command_list_header.is_non_main;
+        if (dma_pushbuffer_subindex >= command_list.size()) {
+            // We've gone through the current list, remove it from the queue
+            dma_pushbuffer.pop();
+            dma_pushbuffer_subindex = 0;
+        }
+    } else {
+        // Otherwise, pushbuffer empty and IB empty or nonexistent - nothing to do
+        return {};
+    }
+    return true;
+}
+void DmaPusher::SetState(const CommandHeader& command_header) {
+    dma_state.method = command_header.method;
+    dma_state.subchannel = command_header.subchannel;
+    dma_state.method_count = command_header.method_count;
+}
+void DmaPusher::CallMethod(u32 argument) const {
+    gpu.CallMethod({dma_state.method, argument, dma_state.subchannel, dma_state.method_count});
+}
+} // namespace Tegra
diff --git a/src/video_core/dma_pusher.h b/src/video_core/dma_pusher.h
new file mode 100644
index 000000000..16e0697c4
--- /dev/null
+++ b/src/video_core/dma_pusher.h
@@ -0,0 +1,99 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#pragma once
+#include <vector>
+#include <queue>
+#include "common/bit_field.h"
+#include "common/common_types.h"
+#include "video_core/memory_manager.h"
+namespace Tegra {
+enum class SubmissionMode : u32 {
+    IncreasingOld = 0,
+    Increasing = 1,
+    NonIncreasingOld = 2,
+    NonIncreasing = 3,
+    Inline = 4,
+    IncreaseOnce = 5
+};
+struct CommandListHeader {
+    union {
+        u64 raw;
+        BitField<0, 40, GPUVAddr> addr;
+        BitField<41, 1, u64> is_non_main;
+        BitField<42, 21, u64> size;
+    };
+};
+static_assert(sizeof(CommandListHeader) == sizeof(u64), "CommandListHeader is incorrect size");
+union CommandHeader {
+    u32 argument;
+    BitField<0, 13, u32> method;
+    BitField<0, 24, u32> method_count_;
+    BitField<13, 3, u32> subchannel;
+    BitField<16, 13, u32> arg_count;
+    BitField<16, 13, u32> method_count;
+    BitField<29, 3, SubmissionMode> mode;
+};
+static_assert(std::is_standard_layout_v<CommandHeader>, "CommandHeader is not standard layout");
+static_assert(sizeof(CommandHeader) == sizeof(u32), "CommandHeader has incorrect size!");
+class GPU;
+using CommandList = std::vector<Tegra::CommandListHeader>;
+/**
+ * The DmaPusher class implements DMA submission to FIFOs, providing an area of memory that the
+ * emulated app fills with commands and tells PFIFO to process. The pushbuffers are then assembled
+ * into a "command stream" consisting of 32-bit words that make up "commands".
+ * See https://envytools.readthedocs.io/en/latest/hw/fifo/dma-pusher.html#fifo-dma-pusher for
+ * details on this implementation.
+ */
+class DmaPusher {
+public:
+    explicit DmaPusher(GPU& gpu);
+    ~DmaPusher();
+    void Push(CommandList&& entries) {
+        dma_pushbuffer.push(std::move(entries));
+    }
+    void DispatchCalls();
+private:
+    bool Step();
+    void SetState(const CommandHeader& command_header);
+    void CallMethod(u32 argument) const;
+    GPU& gpu;
+    std::queue<CommandList> dma_pushbuffer; ///< Queue of command lists to be processed
+    std::size_t dma_pushbuffer_subindex{};  ///< Index within a command list within the pushbuffer
+    struct DmaState {
+        u32 method;            ///< Current method
+        u32 subchannel;        ///< Current subchannel
+        u32 method_count;      ///< Current method count
+        u32 length_pending;    ///< Large NI command length pending
+        bool non_incrementing; ///< Current command�s NI flag
+    };
+    DmaState dma_state{};
+    bool dma_increment_once{};
+    GPUVAddr dma_put{};   ///< pushbuffer current end address
+    GPUVAddr dma_get{};   ///< pushbuffer current read address
+    GPUVAddr dma_mget{};  ///< main pushbuffer last read address
+    bool ib_enable{true}; ///< IB mode enabled
+    bool non_main{};      ///< non-main pushbuffer active
+};
+} // namespace Tegra
diff --git a/src/video_core/engines/fermi_2d.cpp b/src/video_core/engines/fermi_2d.cpp
index 74e44c7fe..80f70e332 100644
--- a/src/video_core/engines/fermi_2d.cpp
+++ b/src/video_core/engines/fermi_2d.cpp
@@ -2,8 +2,10 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#include "core/core.h"
 #include "core/memory.h"
 #include "video_core/engines/fermi_2d.h"
+#include "video_core/engines/maxwell_3d.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/textures/decoders.h"
@@ -12,13 +14,13 @@ namespace Tegra::Engines {
 Fermi2D::Fermi2D(VideoCore::RasterizerInterface& rasterizer, MemoryManager& memory_manager)
    : memory_manager(memory_manager), rasterizer{rasterizer} {}
-void Fermi2D::WriteReg(u32 method, u32 value) {
+void Fermi2D::CallMethod(const GPU::MethodCall& method_call) {
-    ASSERT_MSG(method < Regs::NUM_REGS,
+    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
               "Invalid Fermi2D register, increase the size of the Regs structure");
-    regs.reg_array[method] = value;
+    regs.reg_array[method_call.method] = method_call.argument;
-    switch (method) {
+    switch (method_call.method) {
    case FERMI2D_REG_INDEX(trigger): {
        HandleSurfaceCopy();
        break;
@@ -47,6 +49,9 @@ void Fermi2D::HandleSurfaceCopy() {
    u32 dst_bytes_per_pixel = RenderTargetBytesPerPixel(regs.dst.format);
    if (!rasterizer.AccelerateSurfaceCopy(regs.src, regs.dst)) {
+        // All copies here update the main memory, so mark all rasterizer states as invalid.
+        Core::System::GetInstance().GPU().Maxwell3D().dirty_flags.OnMemoryWrite();
        rasterizer.FlushRegion(source_cpu, src_bytes_per_pixel * regs.src.width * regs.src.height);
        // We have to invalidate the destination region to evict any outdated surfaces from the
        // cache. We do this before actually writing the new data because the destination address
@@ -68,13 +73,13 @@ void Fermi2D::HandleSurfaceCopy() {
            Texture::CopySwizzledData(regs.src.width, regs.src.height, regs.src.depth,
                                      src_bytes_per_pixel, dst_bytes_per_pixel, src_buffer,
                                      dst_buffer, true, regs.src.BlockHeight(),
-                                      regs.src.BlockDepth());
+                                      regs.src.BlockDepth(), 0);
        } else {
            // If the input is linear and the output is tiled, swizzle the input and copy it over.
            Texture::CopySwizzledData(regs.src.width, regs.src.height, regs.src.depth,
                                      src_bytes_per_pixel, dst_bytes_per_pixel, dst_buffer,
                                      src_buffer, false, regs.dst.BlockHeight(),
-                                      regs.dst.BlockDepth());
+                                      regs.dst.BlockDepth(), 0);
        }
    }
 }
diff --git a/src/video_core/engines/fermi_2d.h b/src/video_core/engines/fermi_2d.h
index 2a6e8bbbb..50009bf75 100644
--- a/src/video_core/engines/fermi_2d.h
+++ b/src/video_core/engines/fermi_2d.h
@@ -27,7 +27,7 @@ public:
    ~Fermi2D() = default;
    /// Write the value to the register identified by method.
-    void WriteReg(u32 method, u32 value);
+    void CallMethod(const GPU::MethodCall& method_call);
    struct Regs {
        static constexpr std::size_t NUM_REGS = 0x258;
diff --git a/src/video_core/engines/kepler_memory.cpp b/src/video_core/engines/kepler_memory.cpp
index 585290d9f..4880191fc 100644
--- a/src/video_core/engines/kepler_memory.cpp
+++ b/src/video_core/engines/kepler_memory.cpp
@@ -3,8 +3,10 @@
 // Refer to the license.txt file included.
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/memory.h"
 #include "video_core/engines/kepler_memory.h"
+#include "video_core/engines/maxwell_3d.h"
 #include "video_core/rasterizer_interface.h"
 namespace Tegra::Engines {
@@ -15,19 +17,19 @@ KeplerMemory::KeplerMemory(VideoCore::RasterizerInterface& rasterizer,
 KeplerMemory::~KeplerMemory() = default;
-void KeplerMemory::WriteReg(u32 method, u32 value) {
+void KeplerMemory::CallMethod(const GPU::MethodCall& method_call) {
-    ASSERT_MSG(method < Regs::NUM_REGS,
+    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
               "Invalid KeplerMemory register, increase the size of the Regs structure");
-    regs.reg_array[method] = value;
+    regs.reg_array[method_call.method] = method_call.argument;
-    switch (method) {
+    switch (method_call.method) {
    case KEPLERMEMORY_REG_INDEX(exec): {
        state.write_offset = 0;
        break;
    }
    case KEPLERMEMORY_REG_INDEX(data): {
-        ProcessData(value);
+        ProcessData(method_call.argument);
        break;
    }
    }
@@ -47,6 +49,7 @@ void KeplerMemory::ProcessData(u32 data) {
    rasterizer.InvalidateRegion(dest_address, sizeof(u32));
    Memory::Write32(dest_address, data);
+    Core::System::GetInstance().GPU().Maxwell3D().dirty_flags.OnMemoryWrite();
    state.write_offset++;
 }
diff --git a/src/video_core/engines/kepler_memory.h b/src/video_core/engines/kepler_memory.h
index bf4a13cff..fe9ebc5b9 100644
--- a/src/video_core/engines/kepler_memory.h
+++ b/src/video_core/engines/kepler_memory.h
@@ -9,6 +9,7 @@
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "video_core/gpu.h"
 #include "video_core/memory_manager.h"
 namespace VideoCore {
@@ -26,7 +27,7 @@ public:
    ~KeplerMemory();
    /// Write the value to the register identified by method.
-    void WriteReg(u32 method, u32 value);
+    void CallMethod(const GPU::MethodCall& method_call);
    struct Regs {
        static constexpr size_t NUM_REGS = 0x7F;
diff --git a/src/video_core/engines/maxwell_3d.cpp b/src/video_core/engines/maxwell_3d.cpp
index 2bc534be3..b19b3a75a 100644
--- a/src/video_core/engines/maxwell_3d.cpp
+++ b/src/video_core/engines/maxwell_3d.cpp
@@ -97,57 +97,74 @@ void Maxwell3D::CallMacroMethod(u32 method, std::vector<u32> parameters) {
    macro_interpreter.Execute(search->second, std::move(parameters));
 }
-void Maxwell3D::WriteReg(u32 method, u32 value, u32 remaining_params) {
+void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
    auto debug_context = Core::System::GetInstance().GetGPUDebugContext();
    // It is an error to write to a register other than the current macro's ARG register before it
    // has finished execution.
    if (executing_macro != 0) {
-        ASSERT(method == executing_macro + 1);
+        ASSERT(method_call.method == executing_macro + 1);
    }
    // Methods after 0xE00 are special, they're actually triggers for some microcode that was
    // uploaded to the GPU during initialization.
-    if (method >= MacroRegistersStart) {
+    if (method_call.method >= MacroRegistersStart) {
        // We're trying to execute a macro
        if (executing_macro == 0) {
            // A macro call must begin by writing the macro method's register, not its argument.
-            ASSERT_MSG((method % 2) == 0,
+            ASSERT_MSG((method_call.method % 2) == 0,
                       "Can't start macro execution by writing to the ARGS register");
-            executing_macro = method;
+            executing_macro = method_call.method;
        }
-        macro_params.push_back(value);
+        macro_params.push_back(method_call.argument);
        // Call the macro when there are no more parameters in the command buffer
-        if (remaining_params == 0) {
+        if (method_call.IsLastCall()) {
            CallMacroMethod(executing_macro, std::move(macro_params));
        }
        return;
    }
-    ASSERT_MSG(method < Regs::NUM_REGS,
+    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
               "Invalid Maxwell3D register, increase the size of the Regs structure");
    if (debug_context) {
        debug_context->OnEvent(Tegra::DebugContext::Event::MaxwellCommandLoaded, nullptr);
    }
-    if (regs.reg_array[method] != value) {
+    if (regs.reg_array[method_call.method] != method_call.argument) {
-        regs.reg_array[method] = value;
+        regs.reg_array[method_call.method] = method_call.argument;
-        if (method >= MAXWELL3D_REG_INDEX(vertex_attrib_format) &&
+        // Vertex format
-            method < MAXWELL3D_REG_INDEX(vertex_attrib_format) + regs.vertex_attrib_format.size()) {
+        if (method_call.method >= MAXWELL3D_REG_INDEX(vertex_attrib_format) &&
+            method_call.method <
+                MAXWELL3D_REG_INDEX(vertex_attrib_format) + regs.vertex_attrib_format.size()) {
            dirty_flags.vertex_attrib_format = true;
        }
+        // Vertex buffer
+        if (method_call.method >= MAXWELL3D_REG_INDEX(vertex_array) &&
+            method_call.method < MAXWELL3D_REG_INDEX(vertex_array) + 4 * 32) {
+            dirty_flags.vertex_array |=
+                1u << ((method_call.method - MAXWELL3D_REG_INDEX(vertex_array)) >> 2);
+        } else if (method_call.method >= MAXWELL3D_REG_INDEX(vertex_array_limit) &&
+                   method_call.method < MAXWELL3D_REG_INDEX(vertex_array_limit) + 2 * 32) {
+            dirty_flags.vertex_array |=
+                1u << ((method_call.method - MAXWELL3D_REG_INDEX(vertex_array_limit)) >> 1);
+        } else if (method_call.method >= MAXWELL3D_REG_INDEX(instanced_arrays) &&
+                   method_call.method < MAXWELL3D_REG_INDEX(instanced_arrays) + 32) {
+            dirty_flags.vertex_array |=
+                1u << (method_call.method - MAXWELL3D_REG_INDEX(instanced_arrays));
+        }
    }
-    switch (method) {
+    switch (method_call.method) {
    case MAXWELL3D_REG_INDEX(macros.data): {
-        ProcessMacroUpload(value);
+        ProcessMacroUpload(method_call.argument);
        break;
    }
    case MAXWELL3D_REG_INDEX(macros.bind): {
-        ProcessMacroBind(value);
+        ProcessMacroBind(method_call.argument);
        break;
    }
    case MAXWELL3D_REG_INDEX(const_buffer.cb_data[0]):
@@ -166,7 +183,7 @@ void Maxwell3D::WriteReg(u32 method, u32 value, u32 remaining_params) {
    case MAXWELL3D_REG_INDEX(const_buffer.cb_data[13]):
    case MAXWELL3D_REG_INDEX(const_buffer.cb_data[14]):
    case MAXWELL3D_REG_INDEX(const_buffer.cb_data[15]): {
-        ProcessCBData(value);
+        ProcessCBData(method_call.argument);
        break;
    }
    case MAXWELL3D_REG_INDEX(cb_bind[0].raw_config): {
@@ -270,6 +287,7 @@ void Maxwell3D::ProcessQueryGet() {
            query_result.timestamp = CoreTiming::GetTicks();
            Memory::WriteBlock(*address, &query_result, sizeof(query_result));
        }
+        dirty_flags.OnMemoryWrite();
        break;
    }
    default:
@@ -346,6 +364,7 @@ void Maxwell3D::ProcessCBData(u32 value) {
        memory_manager.GpuToCpuAddress(buffer_address + regs.const_buffer.cb_pos);
    Memory::Write32(*address, value);
+    dirty_flags.OnMemoryWrite();
    // Increment the current buffer position.
    regs.const_buffer.cb_pos = regs.const_buffer.cb_pos + 4;
diff --git a/src/video_core/engines/maxwell_3d.h b/src/video_core/engines/maxwell_3d.h
index 9e480dc39..d3b3ed1f0 100644
--- a/src/video_core/engines/maxwell_3d.h
+++ b/src/video_core/engines/maxwell_3d.h
@@ -389,6 +389,13 @@ public:
                ReverseSubtract = 3,
                Min = 4,
                Max = 5,
+                // These values are used by Nouveau and some games.
+                AddGL = 0x8006,
+                SubtractGL = 0x8007,
+                ReverseSubtractGL = 0x8008,
+                MinGL = 0x800a,
+                MaxGL = 0x800b
            };
            enum class Factor : u32 {
@@ -583,10 +590,18 @@ public:
                float clear_color[4];
                float clear_depth;
                INSERT_PADDING_WORDS(0x3);
                s32 clear_stencil;
-                INSERT_PADDING_WORDS(0x17);
+                INSERT_PADDING_WORDS(0x7);
+                u32 polygon_offset_point_enable;
+                u32 polygon_offset_line_enable;
+                u32 polygon_offset_fill_enable;
+                INSERT_PADDING_WORDS(0xD);
                std::array<ScissorTest, NumViewports> scissor_test;
@@ -624,7 +639,16 @@ public:
                    }
                } zeta;
-                INSERT_PADDING_WORDS(0x5B);
+                INSERT_PADDING_WORDS(0x41);
+                union {
+                    BitField<0, 4, u32> stencil;
+                    BitField<4, 4, u32> unknown;
+                    BitField<8, 4, u32> scissor;
+                    BitField<12, 4, u32> viewport;
+                } clear_flags;
+                INSERT_PADDING_WORDS(0x19);
                std::array<VertexAttribute, NumVertexAttributes> vertex_attrib_format;
@@ -712,6 +736,7 @@ public:
                u32 frag_color_clamp;
                union {
+                    BitField<0, 1, u32> y_negate;
                    BitField<4, 1, u32> triangle_rast_flip;
                } screen_y_control;
@@ -719,7 +744,20 @@ public:
                u32 vb_element_base;
-                INSERT_PADDING_WORDS(0x38);
+                INSERT_PADDING_WORDS(0x36);
+                union {
+                    BitField<0, 1, u32> c0;
+                    BitField<1, 1, u32> c1;
+                    BitField<2, 1, u32> c2;
+                    BitField<3, 1, u32> c3;
+                    BitField<4, 1, u32> c4;
+                    BitField<5, 1, u32> c5;
+                    BitField<6, 1, u32> c6;
+                    BitField<7, 1, u32> c7;
+                } clip_distance_enabled;
+                INSERT_PADDING_WORDS(0x1);
                float point_size;
@@ -745,7 +783,11 @@ public:
                    }
                } tsc;
-                INSERT_PADDING_WORDS(0x3);
+                INSERT_PADDING_WORDS(0x1);
+                float polygon_offset_factor;
+                INSERT_PADDING_WORDS(0x1);
                struct {
                    u32 tic_address_high;
@@ -770,7 +812,9 @@ public:
                u32 framebuffer_srgb;
-                INSERT_PADDING_WORDS(0x12);
+                float polygon_offset_units;
+                INSERT_PADDING_WORDS(0x11);
                union {
                    BitField<2, 1, u32> coord_origin;
@@ -847,7 +891,9 @@ public:
                INSERT_PADDING_WORDS(0x7);
-                INSERT_PADDING_WORDS(0x20);
+                INSERT_PADDING_WORDS(0x1F);
+                float polygon_offset_clamp;
                struct {
                    u32 is_instanced[NumVertexArrays];
@@ -863,8 +909,21 @@ public:
                Cull cull;
-                INSERT_PADDING_WORDS(0x28);
+                u32 pixel_center_integer;
+                INSERT_PADDING_WORDS(0x1);
+                u32 viewport_transform_enabled;
+                INSERT_PADDING_WORDS(0x3);
+                union {
+                    BitField<0, 1, u32> depth_range_0_1;
+                    BitField<3, 1, u32> depth_clamp_near;
+                    BitField<4, 1, u32> depth_clamp_far;
+                } view_volume_clip_control;
+                INSERT_PADDING_WORDS(0x21);
                struct {
                    u32 enable;
                    LogicOperation operation;
@@ -1028,6 +1087,11 @@ public:
    struct DirtyFlags {
        bool vertex_attrib_format = true;
+        u32 vertex_array = 0xFFFFFFFF;
+        void OnMemoryWrite() {
+            vertex_array = 0xFFFFFFFF;
+        }
    };
    DirtyFlags dirty_flags;
@@ -1036,7 +1100,7 @@ public:
    u32 GetRegisterValue(u32 method) const;
    /// Write the value to the register identified by method.
-    void WriteReg(u32 method, u32 value, u32 remaining_params);
+    void CallMethod(const GPU::MethodCall& method_call);
    /// Returns a list of enabled textures for the specified shader stage.
    std::vector<Texture::FullTextureInfo> GetStageTextures(Regs::ShaderStage stage) const;
@@ -1120,6 +1184,9 @@ ASSERT_REG_POSITION(vertex_buffer, 0x35D);
 ASSERT_REG_POSITION(clear_color[0], 0x360);
 ASSERT_REG_POSITION(clear_depth, 0x364);
 ASSERT_REG_POSITION(clear_stencil, 0x368);
+ASSERT_REG_POSITION(polygon_offset_point_enable, 0x370);
+ASSERT_REG_POSITION(polygon_offset_line_enable, 0x371);
+ASSERT_REG_POSITION(polygon_offset_fill_enable, 0x372);
 ASSERT_REG_POSITION(scissor_test, 0x380);
 ASSERT_REG_POSITION(stencil_back_func_ref, 0x3D5);
 ASSERT_REG_POSITION(stencil_back_mask, 0x3D6);
@@ -1127,6 +1194,7 @@ ASSERT_REG_POSITION(stencil_back_func_mask, 0x3D7);
 ASSERT_REG_POSITION(color_mask_common, 0x3E4);
 ASSERT_REG_POSITION(rt_separate_frag_data, 0x3EB);
 ASSERT_REG_POSITION(zeta, 0x3F8);
+ASSERT_REG_POSITION(clear_flags, 0x43E);
 ASSERT_REG_POSITION(vertex_attrib_format, 0x458);
 ASSERT_REG_POSITION(rt_control, 0x487);
 ASSERT_REG_POSITION(zeta_width, 0x48a);
@@ -1153,10 +1221,12 @@ ASSERT_REG_POSITION(stencil_front_mask, 0x4E7);
 ASSERT_REG_POSITION(frag_color_clamp, 0x4EA);
 ASSERT_REG_POSITION(screen_y_control, 0x4EB);
 ASSERT_REG_POSITION(vb_element_base, 0x50D);
+ASSERT_REG_POSITION(clip_distance_enabled, 0x544);
 ASSERT_REG_POSITION(point_size, 0x546);
 ASSERT_REG_POSITION(zeta_enable, 0x54E);
 ASSERT_REG_POSITION(multisample_control, 0x54F);
 ASSERT_REG_POSITION(tsc, 0x557);
+ASSERT_REG_POSITION(polygon_offset_factor, 0x55b);
 ASSERT_REG_POSITION(tic, 0x55D);
 ASSERT_REG_POSITION(stencil_two_side_enable, 0x565);
 ASSERT_REG_POSITION(stencil_back_op_fail, 0x566);
@@ -1164,13 +1234,18 @@ ASSERT_REG_POSITION(stencil_back_op_zfail, 0x567);
 ASSERT_REG_POSITION(stencil_back_op_zpass, 0x568);
 ASSERT_REG_POSITION(stencil_back_func_func, 0x569);
 ASSERT_REG_POSITION(framebuffer_srgb, 0x56E);
+ASSERT_REG_POSITION(polygon_offset_units, 0x56F);
 ASSERT_REG_POSITION(point_coord_replace, 0x581);
 ASSERT_REG_POSITION(code_address, 0x582);
 ASSERT_REG_POSITION(draw, 0x585);
 ASSERT_REG_POSITION(primitive_restart, 0x591);
 ASSERT_REG_POSITION(index_array, 0x5F2);
+ASSERT_REG_POSITION(polygon_offset_clamp, 0x61F);
 ASSERT_REG_POSITION(instanced_arrays, 0x620);
 ASSERT_REG_POSITION(cull, 0x646);
+ASSERT_REG_POSITION(pixel_center_integer, 0x649);
+ASSERT_REG_POSITION(viewport_transform_enabled, 0x64B);
+ASSERT_REG_POSITION(view_volume_clip_control, 0x64F);
 ASSERT_REG_POSITION(logic_op, 0x671);
 ASSERT_REG_POSITION(clear_buffers, 0x674);
 ASSERT_REG_POSITION(color_mask, 0x680);
diff --git a/src/video_core/engines/maxwell_compute.cpp b/src/video_core/engines/maxwell_compute.cpp
index 8b5f08351..656db6a61 100644
--- a/src/video_core/engines/maxwell_compute.cpp
+++ b/src/video_core/engines/maxwell_compute.cpp
@@ -8,13 +8,13 @@
 namespace Tegra::Engines {
-void MaxwellCompute::WriteReg(u32 method, u32 value) {
+void MaxwellCompute::CallMethod(const GPU::MethodCall& method_call) {
-    ASSERT_MSG(method < Regs::NUM_REGS,
+    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
               "Invalid MaxwellCompute register, increase the size of the Regs structure");
-    regs.reg_array[method] = value;
+    regs.reg_array[method_call.method] = method_call.argument;
-    switch (method) {
+    switch (method_call.method) {
    case MAXWELL_COMPUTE_REG_INDEX(compute): {
        LOG_CRITICAL(HW_GPU, "Compute shaders are not implemented");
        UNREACHABLE();
diff --git a/src/video_core/engines/maxwell_compute.h b/src/video_core/engines/maxwell_compute.h
index 6ea934fb9..1d71f11bd 100644
--- a/src/video_core/engines/maxwell_compute.h
+++ b/src/video_core/engines/maxwell_compute.h
@@ -9,6 +9,7 @@
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "video_core/gpu.h"
 namespace Tegra::Engines {
@@ -42,7 +43,7 @@ public:
                  "MaxwellCompute Regs has wrong size");
    /// Write the value to the register identified by method.
-    void WriteReg(u32 method, u32 value);
+    void CallMethod(const GPU::MethodCall& method_call);
 };
 #define ASSERT_REG_POSITION(field_name, position)                                                  \
diff --git a/src/video_core/engines/maxwell_dma.cpp b/src/video_core/engines/maxwell_dma.cpp
index b8a78cf82..06462f570 100644
--- a/src/video_core/engines/maxwell_dma.cpp
+++ b/src/video_core/engines/maxwell_dma.cpp
@@ -2,7 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#include "core/core.h"
 #include "core/memory.h"
+#include "video_core/engines/maxwell_3d.h"
 #include "video_core/engines/maxwell_dma.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/textures/decoders.h"
@@ -12,16 +14,16 @@ namespace Tegra::Engines {
 MaxwellDMA::MaxwellDMA(VideoCore::RasterizerInterface& rasterizer, MemoryManager& memory_manager)
    : memory_manager(memory_manager), rasterizer{rasterizer} {}
-void MaxwellDMA::WriteReg(u32 method, u32 value) {
+void MaxwellDMA::CallMethod(const GPU::MethodCall& method_call) {
-    ASSERT_MSG(method < Regs::NUM_REGS,
+    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
               "Invalid MaxwellDMA register, increase the size of the Regs structure");
-    regs.reg_array[method] = value;
+    regs.reg_array[method_call.method] = method_call.argument;
 #define MAXWELLDMA_REG_INDEX(field_name)                                                           \
    (offsetof(Tegra::Engines::MaxwellDMA::Regs, field_name) / sizeof(u32))
-    switch (method) {
+    switch (method_call.method) {
    case MAXWELLDMA_REG_INDEX(exec): {
        HandleCopy();
        break;
@@ -54,6 +56,9 @@ void MaxwellDMA::HandleCopy() {
        return;
    }
+    // All copies here update the main memory, so mark all rasterizer states as invalid.
+    Core::System::GetInstance().GPU().Maxwell3D().dirty_flags.OnMemoryWrite();
    if (regs.exec.is_dst_linear && regs.exec.is_src_linear) {
        // When the enable_2d bit is disabled, the copy is performed as if we were copying a 1D
        // buffer of length `x_count`, otherwise we copy a 2D image of dimensions (x_count,
diff --git a/src/video_core/engines/maxwell_dma.h b/src/video_core/engines/maxwell_dma.h
index 5f3704f05..1f8cd65d2 100644
--- a/src/video_core/engines/maxwell_dma.h
+++ b/src/video_core/engines/maxwell_dma.h
@@ -24,7 +24,7 @@ public:
    ~MaxwellDMA() = default;
    /// Write the value to the register identified by method.
-    void WriteReg(u32 method, u32 value);
+    void CallMethod(const GPU::MethodCall& method_call);
    struct Regs {
        static constexpr std::size_t NUM_REGS = 0x1D6;
diff --git a/src/video_core/engines/shader_bytecode.h b/src/video_core/engines/shader_bytecode.h
index 83a6fd875..b9faaf8e0 100644
--- a/src/video_core/engines/shader_bytecode.h
+++ b/src/video_core/engines/shader_bytecode.h
@@ -82,6 +82,8 @@ union Attribute {
        Position = 7,
        Attribute_0 = 8,
        Attribute_31 = 39,
+        ClipDistances0123 = 44,
+        ClipDistances4567 = 45,
        PointCoord = 46,
        // This attribute contains a tuple of (~, ~, InstanceId, VertexId) when inside a vertex
        // shader, and a tuple of (TessCoord.x, TessCoord.y, TessCoord.z, ~) when inside a Tess Eval
@@ -153,6 +155,7 @@ enum class PredCondition : u64 {
    NotEqual = 5,
    GreaterEqual = 6,
    LessThanWithNan = 9,
+    LessEqualWithNan = 11,
    GreaterThanWithNan = 12,
    NotEqualWithNan = 13,
    GreaterEqualWithNan = 14,
@@ -261,7 +264,7 @@ enum class FlowCondition : u64 {
    Fcsm_Tr = 0x1C, // TODO(bunnei): What is this used for?
 };
-enum class ControlCode : u64 {
+enum class ConditionCode : u64 {
    F = 0,
    LT = 1,
    EQ = 2,
@@ -365,6 +368,11 @@ enum class HalfPrecision : u64 {
    FMZ = 2,
 };
+enum class R2pMode : u64 {
+    Pr = 0,
+    Cc = 1,
+};
 enum class IpaInterpMode : u64 {
    Linear = 0,
    Perspective = 1,
@@ -569,7 +577,6 @@ union Instruction {
        BitField<39, 2, u64> tab5cb8_2;
        BitField<41, 3, u64> tab5c68_1;
        BitField<44, 2, u64> tab5c68_0;
-        BitField<47, 1, u64> cc;
        BitField<48, 1, u64> negate_b;
    } fmul;
@@ -831,7 +838,7 @@ union Instruction {
    union {
        BitField<0, 3, u64> pred0;
        BitField<3, 3, u64> pred3;
-        BitField<8, 5, ControlCode> cc; // flag in cc
+        BitField<8, 5, ConditionCode> cc; // flag in cc
        BitField<39, 3, u64> pred39;
        BitField<42, 1, u64> neg_pred39;
        BitField<45, 4, PredOperation> op; // op with pred39
@@ -855,6 +862,12 @@ union Instruction {
    } hsetp2;
    union {
+        BitField<40, 1, R2pMode> mode;
+        BitField<41, 2, u64> byte;
+        BitField<20, 7, u64> immediate_mask;
+    } r2p;
+    union {
        BitField<39, 3, u64> pred39;
        BitField<42, 1, u64> neg_pred;
        BitField<43, 1, u64> neg_a;
@@ -1235,7 +1248,7 @@ union Instruction {
    BitField<60, 1, u64> is_b_gpr;
    BitField<59, 1, u64> is_c_gpr;
    BitField<20, 24, s64> smem_imm;
-    BitField<0, 5, ControlCode> flow_control_code;
+    BitField<0, 5, ConditionCode> flow_condition_code;
    Attribute attribute;
    Sampler sampler;
@@ -1256,6 +1269,7 @@ public:
        BFE_C,
        BFE_R,
        BFE_IMM,
+        BFI_IMM_R,
        BRA,
        PBK,
        LD_A,
@@ -1381,6 +1395,7 @@ public:
        PSETP,
        PSET,
        CSETP,
+        R2P_IMM,
        XMAD_IMM,
        XMAD_CR,
        XMAD_RC,
@@ -1396,6 +1411,7 @@ public:
        ArithmeticHalf,
        ArithmeticHalfImmediate,
        Bfe,
+        Bfi,
        Shift,
        Ffma,
        Hfma2,
@@ -1410,6 +1426,7 @@ public:
        HalfSetPredicate,
        PredicateSetPredicate,
        PredicateSetRegister,
+        RegisterSetPredicate,
        Conversion,
        Xmad,
        Unknown,
@@ -1613,6 +1630,7 @@ private:
            INST("0100110000000---", Id::BFE_C, Type::Bfe, "BFE_C"),
            INST("0101110000000---", Id::BFE_R, Type::Bfe, "BFE_R"),
            INST("0011100-00000---", Id::BFE_IMM, Type::Bfe, "BFE_IMM"),
+            INST("0011011-11110---", Id::BFI_IMM_R, Type::Bfi, "BFI_IMM_R"),
            INST("0100110001000---", Id::LOP_C, Type::ArithmeticInteger, "LOP_C"),
            INST("0101110001000---", Id::LOP_R, Type::ArithmeticInteger, "LOP_R"),
            INST("0011100001000---", Id::LOP_IMM, Type::ArithmeticInteger, "LOP_IMM"),
@@ -1647,6 +1665,7 @@ private:
            INST("0101000010001---", Id::PSET, Type::PredicateSetRegister, "PSET"),
            INST("0101000010010---", Id::PSETP, Type::PredicateSetPredicate, "PSETP"),
            INST("010100001010----", Id::CSETP, Type::PredicateSetPredicate, "CSETP"),
+            INST("0011100-11110---", Id::R2P_IMM, Type::RegisterSetPredicate, "R2P_IMM"),
            INST("0011011-00------", Id::XMAD_IMM, Type::Xmad, "XMAD_IMM"),
            INST("0100111---------", Id::XMAD_CR, Type::Xmad, "XMAD_CR"),
            INST("010100010-------", Id::XMAD_RC, Type::Xmad, "XMAD_RC"),
diff --git a/src/video_core/engines/shader_header.h b/src/video_core/engines/shader_header.h
index a0e015c4b..99c34649f 100644
--- a/src/video_core/engines/shader_header.h
+++ b/src/video_core/engines/shader_header.h
@@ -62,7 +62,16 @@ struct Header {
            INSERT_PADDING_BYTES(1);  // ImapSystemValuesB
            INSERT_PADDING_BYTES(16); // ImapGenericVector[32]
            INSERT_PADDING_BYTES(2);  // ImapColor
-            INSERT_PADDING_BYTES(2);  // ImapSystemValuesC
+            union {
+                BitField<0, 8, u16> clip_distances;
+                BitField<8, 1, u16> point_sprite_s;
+                BitField<9, 1, u16> point_sprite_t;
+                BitField<10, 1, u16> fog_coordinate;
+                BitField<12, 1, u16> tessellation_eval_point_u;
+                BitField<13, 1, u16> tessellation_eval_point_v;
+                BitField<14, 1, u16> instance_id;
+                BitField<15, 1, u16> vertex_id;
+            };
            INSERT_PADDING_BYTES(5);  // ImapFixedFncTexture[10]
            INSERT_PADDING_BYTES(1);  // ImapReserved
            INSERT_PADDING_BYTES(3);  // OmapSystemValuesA
diff --git a/src/video_core/gpu.cpp b/src/video_core/gpu.cpp
index 51b3904f6..6c81dee64 100644
--- a/src/video_core/gpu.cpp
+++ b/src/video_core/gpu.cpp
@@ -26,6 +26,7 @@ u32 FramebufferConfig::BytesPerPixel(PixelFormat format) {
 GPU::GPU(VideoCore::RasterizerInterface& rasterizer) {
    memory_manager = std::make_unique<Tegra::MemoryManager>();
+    dma_pusher = std::make_unique<Tegra::DmaPusher>(*this);
    maxwell_3d = std::make_unique<Engines::Maxwell3D>(rasterizer, *memory_manager);
    fermi_2d = std::make_unique<Engines::Fermi2D>(rasterizer, *memory_manager);
    maxwell_compute = std::make_unique<Engines::MaxwellCompute>();
@@ -51,6 +52,14 @@ const MemoryManager& GPU::MemoryManager() const {
    return *memory_manager;
 }
+DmaPusher& GPU::DmaPusher() {
+    return *dma_pusher;
+}
+const DmaPusher& GPU::DmaPusher() const {
+    return *dma_pusher;
+}
 u32 RenderTargetBytesPerPixel(RenderTargetFormat format) {
    ASSERT(format != RenderTargetFormat::NONE);
@@ -113,4 +122,48 @@ u32 DepthFormatBytesPerPixel(DepthFormat format) {
    }
 }
+enum class BufferMethods {
+    BindObject = 0,
+    CountBufferMethods = 0x40,
+};
+void GPU::CallMethod(const MethodCall& method_call) {
+    LOG_TRACE(HW_GPU,
+              "Processing method {:08X} on subchannel {} value "
+              "{:08X} remaining params {}",
+              MethCall.method, MethCall.subchannel, value, remaining_params);
+    ASSERT(method_call.subchannel < bound_engines.size());
+    if (method_call.method == static_cast<u32>(BufferMethods::BindObject)) {
+        // Bind the current subchannel to the desired engine id.
+        LOG_DEBUG(HW_GPU, "Binding subchannel {} to engine {}", method_call.subchannel,
+                  method_call.argument);
+        bound_engines[method_call.subchannel] = static_cast<EngineID>(method_call.argument);
+        return;
+    }
+    const EngineID engine = bound_engines[method_call.subchannel];
+    switch (engine) {
+    case EngineID::FERMI_TWOD_A:
+        fermi_2d->CallMethod(method_call);
+        break;
+    case EngineID::MAXWELL_B:
+        maxwell_3d->CallMethod(method_call);
+        break;
+    case EngineID::MAXWELL_COMPUTE_B:
+        maxwell_compute->CallMethod(method_call);
+        break;
+    case EngineID::MAXWELL_DMA_COPY_A:
+        maxwell_dma->CallMethod(method_call);
+        break;
+    case EngineID::KEPLER_INLINE_TO_MEMORY_B:
+        kepler_memory->CallMethod(method_call);
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Unimplemented engine");
+    }
+}
 } // namespace Tegra
diff --git a/src/video_core/gpu.h b/src/video_core/gpu.h
index 5cc1e19ca..af5ccd1e9 100644
--- a/src/video_core/gpu.h
+++ b/src/video_core/gpu.h
@@ -9,6 +9,7 @@
 #include <vector>
 #include "common/common_types.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"
+#include "video_core/dma_pusher.h"
 #include "video_core/memory_manager.h"
 namespace VideoCore {
@@ -119,8 +120,23 @@ public:
    explicit GPU(VideoCore::RasterizerInterface& rasterizer);
    ~GPU();
-    /// Processes a command list stored at the specified address in GPU memory.
+    struct MethodCall {
-    void ProcessCommandLists(const std::vector<CommandListHeader>& commands);
+        u32 method{};
+        u32 argument{};
+        u32 subchannel{};
+        u32 method_count{};
+        bool IsLastCall() const {
+            return method_count <= 1;
+        }
+        MethodCall(u32 method, u32 argument, u32 subchannel = 0, u32 method_count = 0)
+            : method(method), argument(argument), subchannel(subchannel),
+              method_count(method_count) {}
+    };
+    /// Calls a GPU method.
+    void CallMethod(const MethodCall& method_call);
    /// Returns a reference to the Maxwell3D GPU engine.
    Engines::Maxwell3D& Maxwell3D();
@@ -134,7 +150,14 @@ public:
    /// Returns a const reference to the GPU memory manager.
    const Tegra::MemoryManager& MemoryManager() const;
+    /// Returns a reference to the GPU DMA pusher.
+    Tegra::DmaPusher& DmaPusher();
+    /// Returns a const reference to the GPU DMA pusher.
+    const Tegra::DmaPusher& DmaPusher() const;
 private:
+    std::unique_ptr<Tegra::DmaPusher> dma_pusher;
    std::unique_ptr<Tegra::MemoryManager> memory_manager;
    /// Mapping of command subchannels to their bound engine ids.
diff --git a/src/video_core/macro_interpreter.cpp b/src/video_core/macro_interpreter.cpp
index 335a8d407..9c55e9f1e 100644
--- a/src/video_core/macro_interpreter.cpp
+++ b/src/video_core/macro_interpreter.cpp
@@ -35,6 +35,7 @@ void MacroInterpreter::Reset() {
    // The next parameter index starts at 1, because $r1 already has the value of the first
    // parameter.
    next_parameter_index = 1;
+    carry_flag = false;
 }
 bool MacroInterpreter::Step(u32 offset, bool is_delay_slot) {
@@ -135,14 +136,28 @@ MacroInterpreter::Opcode MacroInterpreter::GetOpcode(u32 offset) const {
    return {macro_memory[offset + pc / sizeof(u32)]};
 }
-u32 MacroInterpreter::GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) const {
+u32 MacroInterpreter::GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) {
    switch (operation) {
-    case ALUOperation::Add:
+    case ALUOperation::Add: {
-        return src_a + src_b;
+        const u64 result{static_cast<u64>(src_a) + src_b};
-    // TODO(Subv): Implement AddWithCarry
+        carry_flag = result > 0xffffffff;
-    case ALUOperation::Subtract:
+        return static_cast<u32>(result);
-        return src_a - src_b;
+    }
-    // TODO(Subv): Implement SubtractWithBorrow
+    case ALUOperation::AddWithCarry: {
+        const u64 result{static_cast<u64>(src_a) + src_b + (carry_flag ? 1ULL : 0ULL)};
+        carry_flag = result > 0xffffffff;
+        return static_cast<u32>(result);
+    }
+    case ALUOperation::Subtract: {
+        const u64 result{static_cast<u64>(src_a) - src_b};
+        carry_flag = result < 0x100000000;
+        return static_cast<u32>(result);
+    }
+    case ALUOperation::SubtractWithBorrow: {
+        const u64 result{static_cast<u64>(src_a) - src_b - (carry_flag ? 0ULL : 1ULL)};
+        carry_flag = result < 0x100000000;
+        return static_cast<u32>(result);
+    }
    case ALUOperation::Xor:
        return src_a ^ src_b;
    case ALUOperation::Or:
@@ -235,7 +250,7 @@ void MacroInterpreter::SetMethodAddress(u32 address) {
 }
 void MacroInterpreter::Send(u32 value) {
-    maxwell3d.WriteReg(method_address.address, value, 0);
+    maxwell3d.CallMethod({method_address.address, value});
    // Increment the method address by the method increment.
    method_address.address.Assign(method_address.address.Value() +
                                  method_address.increment.Value());
diff --git a/src/video_core/macro_interpreter.h b/src/video_core/macro_interpreter.h
index 62d1ce289..cde360288 100644
--- a/src/video_core/macro_interpreter.h
+++ b/src/video_core/macro_interpreter.h
@@ -117,7 +117,7 @@ private:
    bool Step(u32 offset, bool is_delay_slot);
    /// Calculates the result of an ALU operation. src_a OP src_b;
-    u32 GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) const;
+    u32 GetALUResult(ALUOperation operation, u32 src_a, u32 src_b);
    /// Performs the result operation on the input result and stores it in the specified register
    /// (if necessary).
@@ -165,5 +165,7 @@ private:
    std::vector<u32> parameters;
    /// Index of the next parameter that will be fetched by the 'parm' instruction.
    u32 next_parameter_index = 0;
+    bool carry_flag{};
 };
 } // namespace Tegra
diff --git a/src/video_core/memory_manager.cpp b/src/video_core/memory_manager.cpp
index 77a20bb84..47247f097 100644
--- a/src/video_core/memory_manager.cpp
+++ b/src/video_core/memory_manager.cpp
@@ -9,6 +9,13 @@
 namespace Tegra {
+MemoryManager::MemoryManager() {
+    // Mark the first page as reserved, so that 0 is not a valid GPUVAddr. Otherwise, games might
+    // try to use 0 as a valid address, which is also used to mean nullptr. This fixes a bug with
+    // Undertale using 0 for a render target.
+    PageSlot(0) = static_cast<u64>(PageStatus::Reserved);
+}
 GPUVAddr MemoryManager::AllocateSpace(u64 size, u64 align) {
    const std::optional<GPUVAddr> gpu_addr{FindFreeBlock(0, size, align, PageStatus::Unmapped)};
diff --git a/src/video_core/memory_manager.h b/src/video_core/memory_manager.h
index 4eb338aa2..fb03497ca 100644
--- a/src/video_core/memory_manager.h
+++ b/src/video_core/memory_manager.h
@@ -18,7 +18,7 @@ using GPUVAddr = u64;
 class MemoryManager final {
 public:
-    MemoryManager() = default;
+    MemoryManager();
    GPUVAddr AllocateSpace(u64 size, u64 align);
    GPUVAddr AllocateSpace(GPUVAddr gpu_addr, u64 size, u64 align);
@@ -37,6 +37,7 @@ private:
    enum class PageStatus : u64 {
        Unmapped = 0xFFFFFFFFFFFFFFFFULL,
        Allocated = 0xFFFFFFFFFFFFFFFEULL,
+        Reserved = 0xFFFFFFFFFFFFFFFDULL,
    };
    std::optional<GPUVAddr> FindFreeBlock(GPUVAddr region_start, u64 size, u64 align,
diff --git a/src/video_core/morton.cpp b/src/video_core/morton.cpp
new file mode 100644
index 000000000..a310491a8
--- /dev/null
+++ b/src/video_core/morton.cpp
@@ -0,0 +1,355 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#include <array>
+#include <cstring>
+#include "common/assert.h"
+#include "common/common_types.h"
+#include "core/memory.h"
+#include "video_core/morton.h"
+#include "video_core/surface.h"
+#include "video_core/textures/decoders.h"
+namespace VideoCore {
+using Surface::GetBytesPerPixel;
+using Surface::PixelFormat;
+using MortonCopyFn = void (*)(u32, u32, u32, u32, u32, u32, u8*, std::size_t, VAddr);
+using ConversionArray = std::array<MortonCopyFn, Surface::MaxPixelFormat>;
+template <bool morton_to_linear, PixelFormat format>
+static void MortonCopy(u32 stride, u32 block_height, u32 height, u32 block_depth, u32 depth,
+                       u32 tile_width_spacing, u8* buffer, std::size_t buffer_size, VAddr addr) {
+    constexpr u32 bytes_per_pixel = GetBytesPerPixel(format);
+    // With the BCn formats (DXT and DXN), each 4x4 tile is swizzled instead of just individual
+    // pixel values.
+    const u32 tile_size_x{GetDefaultBlockWidth(format)};
+    const u32 tile_size_y{GetDefaultBlockHeight(format)};
+    if constexpr (morton_to_linear) {
+        Tegra::Texture::UnswizzleTexture(buffer, addr, tile_size_x, tile_size_y, bytes_per_pixel,
+                                         stride, height, depth, block_height, block_depth,
+                                         tile_width_spacing);
+    } else {
+        Tegra::Texture::CopySwizzledData(
+            (stride + tile_size_x - 1) / tile_size_x, (height + tile_size_y - 1) / tile_size_y,
+            depth, bytes_per_pixel, bytes_per_pixel, Memory::GetPointer(addr), buffer, false,
+            block_height, block_depth, tile_width_spacing);
+    }
+}
+static constexpr ConversionArray morton_to_linear_fns = {
+    // clang-format off
+        MortonCopy<true, PixelFormat::ABGR8U>,
+        MortonCopy<true, PixelFormat::ABGR8S>,
+        MortonCopy<true, PixelFormat::ABGR8UI>,
+        MortonCopy<true, PixelFormat::B5G6R5U>,
+        MortonCopy<true, PixelFormat::A2B10G10R10U>,
+        MortonCopy<true, PixelFormat::A1B5G5R5U>,
+        MortonCopy<true, PixelFormat::R8U>,
+        MortonCopy<true, PixelFormat::R8UI>,
+        MortonCopy<true, PixelFormat::RGBA16F>,
+        MortonCopy<true, PixelFormat::RGBA16U>,
+        MortonCopy<true, PixelFormat::RGBA16UI>,
+        MortonCopy<true, PixelFormat::R11FG11FB10F>,
+        MortonCopy<true, PixelFormat::RGBA32UI>,
+        MortonCopy<true, PixelFormat::DXT1>,
+        MortonCopy<true, PixelFormat::DXT23>,
+        MortonCopy<true, PixelFormat::DXT45>,
+        MortonCopy<true, PixelFormat::DXN1>,
+        MortonCopy<true, PixelFormat::DXN2UNORM>,
+        MortonCopy<true, PixelFormat::DXN2SNORM>,
+        MortonCopy<true, PixelFormat::BC7U>,
+        MortonCopy<true, PixelFormat::BC6H_UF16>,
+        MortonCopy<true, PixelFormat::BC6H_SF16>,
+        MortonCopy<true, PixelFormat::ASTC_2D_4X4>,
+        MortonCopy<true, PixelFormat::G8R8U>,
+        MortonCopy<true, PixelFormat::G8R8S>,
+        MortonCopy<true, PixelFormat::BGRA8>,
+        MortonCopy<true, PixelFormat::RGBA32F>,
+        MortonCopy<true, PixelFormat::RG32F>,
+        MortonCopy<true, PixelFormat::R32F>,
+        MortonCopy<true, PixelFormat::R16F>,
+        MortonCopy<true, PixelFormat::R16U>,
+        MortonCopy<true, PixelFormat::R16S>,
+        MortonCopy<true, PixelFormat::R16UI>,
+        MortonCopy<true, PixelFormat::R16I>,
+        MortonCopy<true, PixelFormat::RG16>,
+        MortonCopy<true, PixelFormat::RG16F>,
+        MortonCopy<true, PixelFormat::RG16UI>,
+        MortonCopy<true, PixelFormat::RG16I>,
+        MortonCopy<true, PixelFormat::RG16S>,
+        MortonCopy<true, PixelFormat::RGB32F>,
+        MortonCopy<true, PixelFormat::RGBA8_SRGB>,
+        MortonCopy<true, PixelFormat::RG8U>,
+        MortonCopy<true, PixelFormat::RG8S>,
+        MortonCopy<true, PixelFormat::RG32UI>,
+        MortonCopy<true, PixelFormat::R32UI>,
+        MortonCopy<true, PixelFormat::ASTC_2D_8X8>,
+        MortonCopy<true, PixelFormat::ASTC_2D_8X5>,
+        MortonCopy<true, PixelFormat::ASTC_2D_5X4>,
+        MortonCopy<true, PixelFormat::BGRA8_SRGB>,
+        MortonCopy<true, PixelFormat::DXT1_SRGB>,
+        MortonCopy<true, PixelFormat::DXT23_SRGB>,
+        MortonCopy<true, PixelFormat::DXT45_SRGB>,
+        MortonCopy<true, PixelFormat::BC7U_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_4X4_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_8X8_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_8X5_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_5X4_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_5X5>,
+        MortonCopy<true, PixelFormat::ASTC_2D_5X5_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_10X8>,
+        MortonCopy<true, PixelFormat::ASTC_2D_10X8_SRGB>,
+        MortonCopy<true, PixelFormat::Z32F>,
+        MortonCopy<true, PixelFormat::Z16>,
+        MortonCopy<true, PixelFormat::Z24S8>,
+        MortonCopy<true, PixelFormat::S8Z24>,
+        MortonCopy<true, PixelFormat::Z32FS8>,
+    // clang-format on
+};
+static constexpr ConversionArray linear_to_morton_fns = {
+    // clang-format off
+        MortonCopy<false, PixelFormat::ABGR8U>,
+        MortonCopy<false, PixelFormat::ABGR8S>,
+        MortonCopy<false, PixelFormat::ABGR8UI>,
+        MortonCopy<false, PixelFormat::B5G6R5U>,
+        MortonCopy<false, PixelFormat::A2B10G10R10U>,
+        MortonCopy<false, PixelFormat::A1B5G5R5U>,
+        MortonCopy<false, PixelFormat::R8U>,
+        MortonCopy<false, PixelFormat::R8UI>,
+        MortonCopy<false, PixelFormat::RGBA16F>,
+        MortonCopy<false, PixelFormat::RGBA16U>,
+        MortonCopy<false, PixelFormat::RGBA16UI>,
+        MortonCopy<false, PixelFormat::R11FG11FB10F>,
+        MortonCopy<false, PixelFormat::RGBA32UI>,
+        MortonCopy<false, PixelFormat::DXT1>,
+        MortonCopy<false, PixelFormat::DXT23>,
+        MortonCopy<false, PixelFormat::DXT45>,
+        MortonCopy<false, PixelFormat::DXN1>,
+        MortonCopy<false, PixelFormat::DXN2UNORM>,
+        MortonCopy<false, PixelFormat::DXN2SNORM>,
+        MortonCopy<false, PixelFormat::BC7U>,
+        MortonCopy<false, PixelFormat::BC6H_UF16>,
+        MortonCopy<false, PixelFormat::BC6H_SF16>,
+        // TODO(Subv): Swizzling ASTC formats are not supported
+        nullptr,
+        MortonCopy<false, PixelFormat::G8R8U>,
+        MortonCopy<false, PixelFormat::G8R8S>,
+        MortonCopy<false, PixelFormat::BGRA8>,
+        MortonCopy<false, PixelFormat::RGBA32F>,
+        MortonCopy<false, PixelFormat::RG32F>,
+        MortonCopy<false, PixelFormat::R32F>,
+        MortonCopy<false, PixelFormat::R16F>,
+        MortonCopy<false, PixelFormat::R16U>,
+        MortonCopy<false, PixelFormat::R16S>,
+        MortonCopy<false, PixelFormat::R16UI>,
+        MortonCopy<false, PixelFormat::R16I>,
+        MortonCopy<false, PixelFormat::RG16>,
+        MortonCopy<false, PixelFormat::RG16F>,
+        MortonCopy<false, PixelFormat::RG16UI>,
+        MortonCopy<false, PixelFormat::RG16I>,
+        MortonCopy<false, PixelFormat::RG16S>,
+        MortonCopy<false, PixelFormat::RGB32F>,
+        MortonCopy<false, PixelFormat::RGBA8_SRGB>,
+        MortonCopy<false, PixelFormat::RG8U>,
+        MortonCopy<false, PixelFormat::RG8S>,
+        MortonCopy<false, PixelFormat::RG32UI>,
+        MortonCopy<false, PixelFormat::R32UI>,
+        nullptr,
+        nullptr,
+        nullptr,
+        MortonCopy<false, PixelFormat::BGRA8_SRGB>,
+        MortonCopy<false, PixelFormat::DXT1_SRGB>,
+        MortonCopy<false, PixelFormat::DXT23_SRGB>,
+        MortonCopy<false, PixelFormat::DXT45_SRGB>,
+        MortonCopy<false, PixelFormat::BC7U_SRGB>,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        MortonCopy<false, PixelFormat::Z32F>,
+        MortonCopy<false, PixelFormat::Z16>,
+        MortonCopy<false, PixelFormat::Z24S8>,
+        MortonCopy<false, PixelFormat::S8Z24>,
+        MortonCopy<false, PixelFormat::Z32FS8>,
+    // clang-format on
+};
+static MortonCopyFn GetSwizzleFunction(MortonSwizzleMode mode, Surface::PixelFormat format) {
+    switch (mode) {
+    case MortonSwizzleMode::MortonToLinear:
+        return morton_to_linear_fns[static_cast<std::size_t>(format)];
+    case MortonSwizzleMode::LinearToMorton:
+        return linear_to_morton_fns[static_cast<std::size_t>(format)];
+    }
+    UNREACHABLE();
+}
+/// 8x8 Z-Order coordinate from 2D coordinates
+static u32 MortonInterleave(u32 x, u32 y) {
+    static const u32 xlut[] = {0x00, 0x01, 0x04, 0x05, 0x10, 0x11, 0x14, 0x15};
+    static const u32 ylut[] = {0x00, 0x02, 0x08, 0x0a, 0x20, 0x22, 0x28, 0x2a};
+    return xlut[x % 8] + ylut[y % 8];
+}
+/// Calculates the offset of the position of the pixel in Morton order
+static u32 GetMortonOffset(u32 x, u32 y, u32 bytes_per_pixel) {
+    // Images are split into 8x8 tiles. Each tile is composed of four 4x4 subtiles each
+    // of which is composed of four 2x2 subtiles each of which is composed of four texels.
+    // Each structure is embedded into the next-bigger one in a diagonal pattern, e.g.
+    // texels are laid out in a 2x2 subtile like this:
+    // 2 3
+    // 0 1
+    //
+    // The full 8x8 tile has the texels arranged like this:
+    //
+    // 42 43 46 47 58 59 62 63
+    // 40 41 44 45 56 57 60 61
+    // 34 35 38 39 50 51 54 55
+    // 32 33 36 37 48 49 52 53
+    // 10 11 14 15 26 27 30 31
+    // 08 09 12 13 24 25 28 29
+    // 02 03 06 07 18 19 22 23
+    // 00 01 04 05 16 17 20 21
+    //
+    // This pattern is what's called Z-order curve, or Morton order.
+    const unsigned int block_height = 8;
+    const unsigned int coarse_x = x & ~7;
+    u32 i = MortonInterleave(x, y);
+    const unsigned int offset = coarse_x * block_height;
+    return (i + offset) * bytes_per_pixel;
+}
+static u32 MortonInterleave128(u32 x, u32 y) {
+    // 128x128 Z-Order coordinate from 2D coordinates
+    static constexpr u32 xlut[] = {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0008, 0x0009, 0x000a, 0x000b, 0x0040, 0x0041, 0x0042,
+        0x0043, 0x0048, 0x0049, 0x004a, 0x004b, 0x0800, 0x0801, 0x0802, 0x0803, 0x0808, 0x0809,
+        0x080a, 0x080b, 0x0840, 0x0841, 0x0842, 0x0843, 0x0848, 0x0849, 0x084a, 0x084b, 0x1000,
+        0x1001, 0x1002, 0x1003, 0x1008, 0x1009, 0x100a, 0x100b, 0x1040, 0x1041, 0x1042, 0x1043,
+        0x1048, 0x1049, 0x104a, 0x104b, 0x1800, 0x1801, 0x1802, 0x1803, 0x1808, 0x1809, 0x180a,
+        0x180b, 0x1840, 0x1841, 0x1842, 0x1843, 0x1848, 0x1849, 0x184a, 0x184b, 0x2000, 0x2001,
+        0x2002, 0x2003, 0x2008, 0x2009, 0x200a, 0x200b, 0x2040, 0x2041, 0x2042, 0x2043, 0x2048,
+        0x2049, 0x204a, 0x204b, 0x2800, 0x2801, 0x2802, 0x2803, 0x2808, 0x2809, 0x280a, 0x280b,
+        0x2840, 0x2841, 0x2842, 0x2843, 0x2848, 0x2849, 0x284a, 0x284b, 0x3000, 0x3001, 0x3002,
+        0x3003, 0x3008, 0x3009, 0x300a, 0x300b, 0x3040, 0x3041, 0x3042, 0x3043, 0x3048, 0x3049,
+        0x304a, 0x304b, 0x3800, 0x3801, 0x3802, 0x3803, 0x3808, 0x3809, 0x380a, 0x380b, 0x3840,
+        0x3841, 0x3842, 0x3843, 0x3848, 0x3849, 0x384a, 0x384b, 0x0000, 0x0001, 0x0002, 0x0003,
+        0x0008, 0x0009, 0x000a, 0x000b, 0x0040, 0x0041, 0x0042, 0x0043, 0x0048, 0x0049, 0x004a,
+        0x004b, 0x0800, 0x0801, 0x0802, 0x0803, 0x0808, 0x0809, 0x080a, 0x080b, 0x0840, 0x0841,
+        0x0842, 0x0843, 0x0848, 0x0849, 0x084a, 0x084b, 0x1000, 0x1001, 0x1002, 0x1003, 0x1008,
+        0x1009, 0x100a, 0x100b, 0x1040, 0x1041, 0x1042, 0x1043, 0x1048, 0x1049, 0x104a, 0x104b,
+        0x1800, 0x1801, 0x1802, 0x1803, 0x1808, 0x1809, 0x180a, 0x180b, 0x1840, 0x1841, 0x1842,
+        0x1843, 0x1848, 0x1849, 0x184a, 0x184b, 0x2000, 0x2001, 0x2002, 0x2003, 0x2008, 0x2009,
+        0x200a, 0x200b, 0x2040, 0x2041, 0x2042, 0x2043, 0x2048, 0x2049, 0x204a, 0x204b, 0x2800,
+        0x2801, 0x2802, 0x2803, 0x2808, 0x2809, 0x280a, 0x280b, 0x2840, 0x2841, 0x2842, 0x2843,
+        0x2848, 0x2849, 0x284a, 0x284b, 0x3000, 0x3001, 0x3002, 0x3003, 0x3008, 0x3009, 0x300a,
+        0x300b, 0x3040, 0x3041, 0x3042, 0x3043, 0x3048, 0x3049, 0x304a, 0x304b, 0x3800, 0x3801,
+        0x3802, 0x3803, 0x3808, 0x3809, 0x380a, 0x380b, 0x3840, 0x3841, 0x3842, 0x3843, 0x3848,
+        0x3849, 0x384a, 0x384b, 0x0000, 0x0001, 0x0002, 0x0003, 0x0008, 0x0009, 0x000a, 0x000b,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0048, 0x0049, 0x004a, 0x004b, 0x0800, 0x0801, 0x0802,
+        0x0803, 0x0808, 0x0809, 0x080a, 0x080b, 0x0840, 0x0841, 0x0842, 0x0843, 0x0848, 0x0849,
+        0x084a, 0x084b, 0x1000, 0x1001, 0x1002, 0x1003, 0x1008, 0x1009, 0x100a, 0x100b, 0x1040,
+        0x1041, 0x1042, 0x1043, 0x1048, 0x1049, 0x104a, 0x104b, 0x1800, 0x1801, 0x1802, 0x1803,
+        0x1808, 0x1809, 0x180a, 0x180b, 0x1840, 0x1841, 0x1842, 0x1843, 0x1848, 0x1849, 0x184a,
+        0x184b, 0x2000, 0x2001, 0x2002, 0x2003, 0x2008, 0x2009, 0x200a, 0x200b, 0x2040, 0x2041,
+        0x2042, 0x2043, 0x2048, 0x2049, 0x204a, 0x204b, 0x2800, 0x2801, 0x2802, 0x2803, 0x2808,
+        0x2809, 0x280a, 0x280b, 0x2840, 0x2841, 0x2842, 0x2843, 0x2848, 0x2849, 0x284a, 0x284b,
+        0x3000, 0x3001, 0x3002, 0x3003, 0x3008, 0x3009, 0x300a, 0x300b, 0x3040, 0x3041, 0x3042,
+        0x3043, 0x3048, 0x3049, 0x304a, 0x304b, 0x3800, 0x3801, 0x3802, 0x3803, 0x3808, 0x3809,
+        0x380a, 0x380b, 0x3840, 0x3841, 0x3842, 0x3843, 0x3848, 0x3849, 0x384a, 0x384b,
+    };
+    static constexpr u32 ylut[] = {
+        0x0000, 0x0004, 0x0010, 0x0014, 0x0020, 0x0024, 0x0030, 0x0034, 0x0080, 0x0084, 0x0090,
+        0x0094, 0x00a0, 0x00a4, 0x00b0, 0x00b4, 0x0100, 0x0104, 0x0110, 0x0114, 0x0120, 0x0124,
+        0x0130, 0x0134, 0x0180, 0x0184, 0x0190, 0x0194, 0x01a0, 0x01a4, 0x01b0, 0x01b4, 0x0200,
+        0x0204, 0x0210, 0x0214, 0x0220, 0x0224, 0x0230, 0x0234, 0x0280, 0x0284, 0x0290, 0x0294,
+        0x02a0, 0x02a4, 0x02b0, 0x02b4, 0x0300, 0x0304, 0x0310, 0x0314, 0x0320, 0x0324, 0x0330,
+        0x0334, 0x0380, 0x0384, 0x0390, 0x0394, 0x03a0, 0x03a4, 0x03b0, 0x03b4, 0x0400, 0x0404,
+        0x0410, 0x0414, 0x0420, 0x0424, 0x0430, 0x0434, 0x0480, 0x0484, 0x0490, 0x0494, 0x04a0,
+        0x04a4, 0x04b0, 0x04b4, 0x0500, 0x0504, 0x0510, 0x0514, 0x0520, 0x0524, 0x0530, 0x0534,
+        0x0580, 0x0584, 0x0590, 0x0594, 0x05a0, 0x05a4, 0x05b0, 0x05b4, 0x0600, 0x0604, 0x0610,
+        0x0614, 0x0620, 0x0624, 0x0630, 0x0634, 0x0680, 0x0684, 0x0690, 0x0694, 0x06a0, 0x06a4,
+        0x06b0, 0x06b4, 0x0700, 0x0704, 0x0710, 0x0714, 0x0720, 0x0724, 0x0730, 0x0734, 0x0780,
+        0x0784, 0x0790, 0x0794, 0x07a0, 0x07a4, 0x07b0, 0x07b4, 0x0000, 0x0004, 0x0010, 0x0014,
+        0x0020, 0x0024, 0x0030, 0x0034, 0x0080, 0x0084, 0x0090, 0x0094, 0x00a0, 0x00a4, 0x00b0,
+        0x00b4, 0x0100, 0x0104, 0x0110, 0x0114, 0x0120, 0x0124, 0x0130, 0x0134, 0x0180, 0x0184,
+        0x0190, 0x0194, 0x01a0, 0x01a4, 0x01b0, 0x01b4, 0x0200, 0x0204, 0x0210, 0x0214, 0x0220,
+        0x0224, 0x0230, 0x0234, 0x0280, 0x0284, 0x0290, 0x0294, 0x02a0, 0x02a4, 0x02b0, 0x02b4,
+        0x0300, 0x0304, 0x0310, 0x0314, 0x0320, 0x0324, 0x0330, 0x0334, 0x0380, 0x0384, 0x0390,
+        0x0394, 0x03a0, 0x03a4, 0x03b0, 0x03b4, 0x0400, 0x0404, 0x0410, 0x0414, 0x0420, 0x0424,
+        0x0430, 0x0434, 0x0480, 0x0484, 0x0490, 0x0494, 0x04a0, 0x04a4, 0x04b0, 0x04b4, 0x0500,
+        0x0504, 0x0510, 0x0514, 0x0520, 0x0524, 0x0530, 0x0534, 0x0580, 0x0584, 0x0590, 0x0594,
+        0x05a0, 0x05a4, 0x05b0, 0x05b4, 0x0600, 0x0604, 0x0610, 0x0614, 0x0620, 0x0624, 0x0630,
+        0x0634, 0x0680, 0x0684, 0x0690, 0x0694, 0x06a0, 0x06a4, 0x06b0, 0x06b4, 0x0700, 0x0704,
+        0x0710, 0x0714, 0x0720, 0x0724, 0x0730, 0x0734, 0x0780, 0x0784, 0x0790, 0x0794, 0x07a0,
+        0x07a4, 0x07b0, 0x07b4, 0x0000, 0x0004, 0x0010, 0x0014, 0x0020, 0x0024, 0x0030, 0x0034,
+        0x0080, 0x0084, 0x0090, 0x0094, 0x00a0, 0x00a4, 0x00b0, 0x00b4, 0x0100, 0x0104, 0x0110,
+        0x0114, 0x0120, 0x0124, 0x0130, 0x0134, 0x0180, 0x0184, 0x0190, 0x0194, 0x01a0, 0x01a4,
+        0x01b0, 0x01b4, 0x0200, 0x0204, 0x0210, 0x0214, 0x0220, 0x0224, 0x0230, 0x0234, 0x0280,
+        0x0284, 0x0290, 0x0294, 0x02a0, 0x02a4, 0x02b0, 0x02b4, 0x0300, 0x0304, 0x0310, 0x0314,
+        0x0320, 0x0324, 0x0330, 0x0334, 0x0380, 0x0384, 0x0390, 0x0394, 0x03a0, 0x03a4, 0x03b0,
+        0x03b4, 0x0400, 0x0404, 0x0410, 0x0414, 0x0420, 0x0424, 0x0430, 0x0434, 0x0480, 0x0484,
+        0x0490, 0x0494, 0x04a0, 0x04a4, 0x04b0, 0x04b4, 0x0500, 0x0504, 0x0510, 0x0514, 0x0520,
+        0x0524, 0x0530, 0x0534, 0x0580, 0x0584, 0x0590, 0x0594, 0x05a0, 0x05a4, 0x05b0, 0x05b4,
+        0x0600, 0x0604, 0x0610, 0x0614, 0x0620, 0x0624, 0x0630, 0x0634, 0x0680, 0x0684, 0x0690,
+        0x0694, 0x06a0, 0x06a4, 0x06b0, 0x06b4, 0x0700, 0x0704, 0x0710, 0x0714, 0x0720, 0x0724,
+        0x0730, 0x0734, 0x0780, 0x0784, 0x0790, 0x0794, 0x07a0, 0x07a4, 0x07b0, 0x07b4,
+    };
+    return xlut[x % 128] + ylut[y % 128];
+}
+static u32 GetMortonOffset128(u32 x, u32 y, u32 bytes_per_pixel) {
+    // Calculates the offset of the position of the pixel in Morton order
+    // Framebuffer images are split into 128x128 tiles.
+    constexpr u32 block_height = 128;
+    const u32 coarse_x = x & ~127;
+    const u32 i = MortonInterleave128(x, y);
+    const u32 offset = coarse_x * block_height;
+    return (i + offset) * bytes_per_pixel;
+}
+void MortonSwizzle(MortonSwizzleMode mode, Surface::PixelFormat format, u32 stride,
+                   u32 block_height, u32 height, u32 block_depth, u32 depth, u32 tile_width_spacing,
+                   u8* buffer, std::size_t buffer_size, VAddr addr) {
+    GetSwizzleFunction(mode, format)(stride, block_height, height, block_depth, depth,
+                                     tile_width_spacing, buffer, buffer_size, addr);
+}
+void MortonCopyPixels128(u32 width, u32 height, u32 bytes_per_pixel, u32 linear_bytes_per_pixel,
+                         u8* morton_data, u8* linear_data, bool morton_to_linear) {
+    u8* data_ptrs[2];
+    for (u32 y = 0; y < height; ++y) {
+        for (u32 x = 0; x < width; ++x) {
+            const u32 coarse_y = y & ~127;
+            const u32 morton_offset =
+                GetMortonOffset128(x, y, bytes_per_pixel) + coarse_y * width * bytes_per_pixel;
+            const u32 linear_pixel_index = (x + y * width) * linear_bytes_per_pixel;
+            data_ptrs[morton_to_linear ? 1 : 0] = morton_data + morton_offset;
+            data_ptrs[morton_to_linear ? 0 : 1] = &linear_data[linear_pixel_index];
+            std::memcpy(data_ptrs[0], data_ptrs[1], bytes_per_pixel);
+        }
+    }
+}
+} // namespace VideoCore
diff --git a/src/video_core/morton.h b/src/video_core/morton.h
new file mode 100644
index 000000000..065f59ce3
--- /dev/null
+++ b/src/video_core/morton.h
@@ -0,0 +1,21 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#pragma once
+#include "common/common_types.h"
+#include "video_core/surface.h"
+namespace VideoCore {
+enum class MortonSwizzleMode { MortonToLinear, LinearToMorton };
+void MortonSwizzle(MortonSwizzleMode mode, VideoCore::Surface::PixelFormat format, u32 stride,
+                   u32 block_height, u32 height, u32 block_depth, u32 depth, u32 tile_width_spacing,
+                   u8* buffer, std::size_t buffer_size, VAddr addr);
+void MortonCopyPixels128(u32 width, u32 height, u32 bytes_per_pixel, u32 linear_bytes_per_pixel,
+                         u8* morton_data, u8* linear_data, bool morton_to_linear);
+} // namespace VideoCore
diff --git a/src/video_core/renderer_opengl/gl_buffer_cache.cpp b/src/video_core/renderer_opengl/gl_buffer_cache.cpp
index 075192c3f..46a6c0308 100644
--- a/src/video_core/renderer_opengl/gl_buffer_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_buffer_cache.cpp
@@ -76,7 +76,7 @@ std::tuple<u8*, GLintptr> OGLBufferCache::ReserveMemory(std::size_t size, std::s
    return std::make_tuple(uploaded_ptr, uploaded_offset);
 }
-void OGLBufferCache::Map(std::size_t max_size) {
+bool OGLBufferCache::Map(std::size_t max_size) {
    bool invalidate;
    std::tie(buffer_ptr, buffer_offset_base, invalidate) =
        stream_buffer.Map(static_cast<GLsizeiptr>(max_size), 4);
@@ -85,6 +85,7 @@ void OGLBufferCache::Map(std::size_t max_size) {
    if (invalidate) {
        InvalidateAll();
    }
+    return invalidate;
 }
 void OGLBufferCache::Unmap() {
diff --git a/src/video_core/renderer_opengl/gl_buffer_cache.h b/src/video_core/renderer_opengl/gl_buffer_cache.h
index 91fca3f6c..c11acfb79 100644
--- a/src/video_core/renderer_opengl/gl_buffer_cache.h
+++ b/src/video_core/renderer_opengl/gl_buffer_cache.h
@@ -50,7 +50,7 @@ public:
    /// Reserves memory to be used by host's CPU. Returns mapped address and offset.
    std::tuple<u8*, GLintptr> ReserveMemory(std::size_t size, std::size_t alignment = 4);
-    void Map(std::size_t max_size);
+    bool Map(std::size_t max_size);
    void Unmap();
    GLuint GetHandle() const;
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.cpp b/src/video_core/renderer_opengl/gl_rasterizer.cpp
index ae6aaee4c..a44bbfae8 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer.cpp
@@ -98,14 +98,9 @@ RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& window, ScreenInfo
            has_ARB_direct_state_access = true;
        } else if (extension == "GL_ARB_multi_bind") {
            has_ARB_multi_bind = true;
-        } else if (extension == "GL_ARB_separate_shader_objects") {
-            has_ARB_separate_shader_objects = true;
-        } else if (extension == "GL_ARB_vertex_attrib_binding") {
-            has_ARB_vertex_attrib_binding = true;
        }
    }
-    ASSERT_MSG(has_ARB_separate_shader_objects, "has_ARB_separate_shader_objects is unsupported");
    OpenGLState::ApplyDefaultState();
    // Create render framebuffer
@@ -118,10 +113,24 @@ RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& window, ScreenInfo
    glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &uniform_buffer_alignment);
    LOG_CRITICAL(Render_OpenGL, "Sync fixed function OpenGL state here!");
+    CheckExtensions();
 }
 RasterizerOpenGL::~RasterizerOpenGL() {}
+void RasterizerOpenGL::CheckExtensions() {
+    if (!GLAD_GL_ARB_texture_filter_anisotropic && !GLAD_GL_EXT_texture_filter_anisotropic) {
+        LOG_WARNING(
+            Render_OpenGL,
+            "Anisotropic filter is not supported! This can cause graphical issues in some games.");
+    }
+    if (!GLAD_GL_ARB_buffer_storage) {
+        LOG_WARNING(
+            Render_OpenGL,
+            "Buffer storage control is not supported! This can cause performance degradation.");
+    }
+}
 void RasterizerOpenGL::SetupVertexFormat() {
    auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
    const auto& regs = gpu.regs;
@@ -181,15 +190,25 @@ void RasterizerOpenGL::SetupVertexFormat() {
    }
    state.draw.vertex_array = VAO.handle;
    state.ApplyVertexBufferState();
+    // Rebinding the VAO invalidates the vertex buffer bindings.
+    gpu.dirty_flags.vertex_array = 0xFFFFFFFF;
 }
 void RasterizerOpenGL::SetupVertexBuffer() {
-    MICROPROFILE_SCOPE(OpenGL_VB);
+    auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
-    const auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
    const auto& regs = gpu.regs;
+    if (!gpu.dirty_flags.vertex_array)
+        return;
+    MICROPROFILE_SCOPE(OpenGL_VB);
    // Upload all guest vertex arrays sequentially to our buffer
    for (u32 index = 0; index < Maxwell::NumVertexArrays; ++index) {
+        if (~gpu.dirty_flags.vertex_array & (1u << index))
+            continue;
        const auto& vertex_array = regs.vertex_array[index];
        if (!vertex_array.IsEnabled())
            continue;
@@ -216,6 +235,8 @@ void RasterizerOpenGL::SetupVertexBuffer() {
    // Implicit set by glBindVertexBuffer. Stupid glstate handling...
    state.draw.vertex_buffer = buffer_cache.GetHandle();
+    gpu.dirty_flags.vertex_array = 0;
 }
 DrawParameters RasterizerOpenGL::SetupDraw() {
@@ -542,6 +563,30 @@ void RasterizerOpenGL::Clear() {
        ASSERT_MSG(regs.zeta_enable != 0, "Tried to clear stencil but buffer is not enabled!");
        use_stencil = true;
        clear_state.stencil.test_enabled = true;
+        if (regs.clear_flags.stencil) {
+            // Stencil affects the clear so fill it with the used masks
+            clear_state.stencil.front.test_func = GL_ALWAYS;
+            clear_state.stencil.front.test_mask = regs.stencil_front_func_mask;
+            clear_state.stencil.front.action_stencil_fail = GL_KEEP;
+            clear_state.stencil.front.action_depth_fail = GL_KEEP;
+            clear_state.stencil.front.action_depth_pass = GL_KEEP;
+            clear_state.stencil.front.write_mask = regs.stencil_front_mask;
+            if (regs.stencil_two_side_enable) {
+                clear_state.stencil.back.test_func = GL_ALWAYS;
+                clear_state.stencil.back.test_mask = regs.stencil_back_func_mask;
+                clear_state.stencil.back.action_stencil_fail = GL_KEEP;
+                clear_state.stencil.back.action_depth_fail = GL_KEEP;
+                clear_state.stencil.back.action_depth_pass = GL_KEEP;
+                clear_state.stencil.back.write_mask = regs.stencil_back_mask;
+            } else {
+                clear_state.stencil.back.test_func = GL_ALWAYS;
+                clear_state.stencil.back.test_mask = 0xFFFFFFFF;
+                clear_state.stencil.back.write_mask = 0xFFFFFFFF;
+                clear_state.stencil.back.action_stencil_fail = GL_KEEP;
+                clear_state.stencil.back.action_depth_fail = GL_KEEP;
+                clear_state.stencil.back.action_depth_pass = GL_KEEP;
+            }
+        }
    }
    if (!use_color && !use_depth && !use_stencil) {
@@ -553,6 +598,14 @@ void RasterizerOpenGL::Clear() {
    ConfigureFramebuffers(clear_state, use_color, use_depth || use_stencil, false,
                          regs.clear_buffers.RT.Value());
+    if (regs.clear_flags.scissor) {
+        SyncScissorTest(clear_state);
+    }
+    if (regs.clear_flags.viewport) {
+        clear_state.EmulateViewportWithScissor();
+    }
    clear_state.Apply();
    if (use_color) {
@@ -573,7 +626,7 @@ void RasterizerOpenGL::DrawArrays() {
        return;
    MICROPROFILE_SCOPE(OpenGL_Drawing);
-    const auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
+    auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
    const auto& regs = gpu.regs;
    ScopeAcquireGLContext acquire_context{emu_window};
@@ -588,12 +641,13 @@ void RasterizerOpenGL::DrawArrays() {
    SyncLogicOpState();
    SyncCullMode();
    SyncPrimitiveRestart();
-    SyncScissorTest();
+    SyncScissorTest(state);
+    SyncClipEnabled();
    // Alpha Testing is synced on shaders.
    SyncTransformFeedback();
    SyncPointState();
    CheckAlphaTests();
+    SyncPolygonOffset();
    // TODO(bunnei): Sync framebuffer_scale uniform here
    // TODO(bunnei): Sync scissorbox uniform(s) here
@@ -626,7 +680,11 @@ void RasterizerOpenGL::DrawArrays() {
    // Add space for at least 18 constant buffers
    buffer_size += Maxwell::MaxConstBuffers * (MaxConstbufferSize + uniform_buffer_alignment);
-    buffer_cache.Map(buffer_size);
+    bool invalidate = buffer_cache.Map(buffer_size);
+    if (invalidate) {
+        // As all cached buffers are invalidated, we need to recheck their state.
+        gpu.dirty_flags.vertex_array = 0xFFFFFFFF;
+    }
    SetupVertexFormat();
    SetupVertexBuffer();
@@ -815,7 +873,7 @@ void RasterizerOpenGL::SamplerInfo::SyncWithConfig(const Tegra::Texture::TSCEntr
    }
    const u32 bias = config.mip_lod_bias.Value();
    // Sign extend the 13-bit value.
-    const u32 mask = 1U << (13 - 1);
+    constexpr u32 mask = 1U << (13 - 1);
    const float bias_lod = static_cast<s32>((bias ^ mask) - mask) / 256.f;
    if (lod_bias != bias_lod) {
        lod_bias = bias_lod;
@@ -942,20 +1000,35 @@ u32 RasterizerOpenGL::SetupTextures(Maxwell::ShaderStage stage, Shader& shader,
 void RasterizerOpenGL::SyncViewport(OpenGLState& current_state) {
    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
-    for (std::size_t i = 0; i < Tegra::Engines::Maxwell3D::Regs::NumViewports; i++) {
+    const bool geometry_shaders_enabled =
-        const MathUtil::Rectangle<s32> viewport_rect{regs.viewport_transform[i].GetRect()};
+        regs.IsShaderConfigEnabled(static_cast<size_t>(Maxwell::ShaderProgram::Geometry));
+    const std::size_t viewport_count =
+        geometry_shaders_enabled ? Tegra::Engines::Maxwell3D::Regs::NumViewports : 1;
+    for (std::size_t i = 0; i < viewport_count; i++) {
        auto& viewport = current_state.viewports[i];
+        const auto& src = regs.viewports[i];
+        const MathUtil::Rectangle<s32> viewport_rect{regs.viewport_transform[i].GetRect()};
        viewport.x = viewport_rect.left;
        viewport.y = viewport_rect.bottom;
-        viewport.width = static_cast<GLfloat>(viewport_rect.GetWidth());
+        viewport.width = viewport_rect.GetWidth();
-        viewport.height = static_cast<GLfloat>(viewport_rect.GetHeight());
+        viewport.height = viewport_rect.GetHeight();
        viewport.depth_range_far = regs.viewports[i].depth_range_far;
        viewport.depth_range_near = regs.viewports[i].depth_range_near;
    }
+    state.depth_clamp.far_plane = regs.view_volume_clip_control.depth_clamp_far != 0;
+    state.depth_clamp.near_plane = regs.view_volume_clip_control.depth_clamp_near != 0;
 }
 void RasterizerOpenGL::SyncClipEnabled() {
-    UNREACHABLE();
+    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
+    state.clip_distance[0] = regs.clip_distance_enabled.c0 != 0;
+    state.clip_distance[1] = regs.clip_distance_enabled.c1 != 0;
+    state.clip_distance[2] = regs.clip_distance_enabled.c2 != 0;
+    state.clip_distance[3] = regs.clip_distance_enabled.c3 != 0;
+    state.clip_distance[4] = regs.clip_distance_enabled.c4 != 0;
+    state.clip_distance[5] = regs.clip_distance_enabled.c5 != 0;
+    state.clip_distance[6] = regs.clip_distance_enabled.c6 != 0;
+    state.clip_distance[7] = regs.clip_distance_enabled.c7 != 0;
 }
 void RasterizerOpenGL::SyncClipCoef() {
@@ -1120,11 +1193,15 @@ void RasterizerOpenGL::SyncLogicOpState() {
    state.logic_op.operation = MaxwellToGL::LogicOp(regs.logic_op.operation);
 }
-void RasterizerOpenGL::SyncScissorTest() {
+void RasterizerOpenGL::SyncScissorTest(OpenGLState& current_state) {
    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
-    for (std::size_t i = 0; i < Tegra::Engines::Maxwell3D::Regs::NumViewports; i++) {
+    const bool geometry_shaders_enabled =
+        regs.IsShaderConfigEnabled(static_cast<size_t>(Maxwell::ShaderProgram::Geometry));
+    const std::size_t viewport_count =
+        geometry_shaders_enabled ? Tegra::Engines::Maxwell3D::Regs::NumViewports : 1;
+    for (std::size_t i = 0; i < viewport_count; i++) {
        const auto& src = regs.scissor_test[i];
-        auto& dst = state.viewports[i].scissor;
+        auto& dst = current_state.viewports[i].scissor;
        dst.enabled = (src.enable != 0);
        if (dst.enabled == 0) {
            return;
@@ -1152,6 +1229,16 @@ void RasterizerOpenGL::SyncPointState() {
    state.point.size = regs.point_size;
 }
+void RasterizerOpenGL::SyncPolygonOffset() {
+    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
+    state.polygon_offset.fill_enable = regs.polygon_offset_fill_enable != 0;
+    state.polygon_offset.line_enable = regs.polygon_offset_line_enable != 0;
+    state.polygon_offset.point_enable = regs.polygon_offset_point_enable != 0;
+    state.polygon_offset.units = regs.polygon_offset_units;
+    state.polygon_offset.factor = regs.polygon_offset_factor;
+    state.polygon_offset.clamp = regs.polygon_offset_clamp;
+}
 void RasterizerOpenGL::CheckAlphaTests() {
    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.h b/src/video_core/renderer_opengl/gl_rasterizer.h
index 6e78ab4cd..7ec9746b1 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.h
+++ b/src/video_core/renderer_opengl/gl_rasterizer.h
@@ -91,19 +91,20 @@ private:
        void SyncWithConfig(const Tegra::Texture::TSCEntry& info);
    private:
-        Tegra::Texture::TextureFilter mag_filter;
+        Tegra::Texture::TextureFilter mag_filter = Tegra::Texture::TextureFilter::Nearest;
-        Tegra::Texture::TextureFilter min_filter;
+        Tegra::Texture::TextureFilter min_filter = Tegra::Texture::TextureFilter::Nearest;
-        Tegra::Texture::TextureMipmapFilter mip_filter;
+        Tegra::Texture::TextureMipmapFilter mip_filter = Tegra::Texture::TextureMipmapFilter::None;
-        Tegra::Texture::WrapMode wrap_u;
+        Tegra::Texture::WrapMode wrap_u = Tegra::Texture::WrapMode::ClampToEdge;
-        Tegra::Texture::WrapMode wrap_v;
+        Tegra::Texture::WrapMode wrap_v = Tegra::Texture::WrapMode::ClampToEdge;
-        Tegra::Texture::WrapMode wrap_p;
+        Tegra::Texture::WrapMode wrap_p = Tegra::Texture::WrapMode::ClampToEdge;
-        bool uses_depth_compare;
+        bool uses_depth_compare = false;
-        Tegra::Texture::DepthCompareFunc depth_compare_func;
+        Tegra::Texture::DepthCompareFunc depth_compare_func =
-        GLvec4 border_color;
+            Tegra::Texture::DepthCompareFunc::Always;
-        float min_lod;
+        GLvec4 border_color = {};
-        float max_lod;
+        float min_lod = 0.0f;
-        float lod_bias;
+        float max_lod = 16.0f;
-        float max_anisotropic;
+        float lod_bias = 0.0f;
+        float max_anisotropic = 1.0f;
    };
    /**
@@ -171,7 +172,7 @@ private:
    void SyncMultiSampleState();
    /// Syncs the scissor test state to match the guest state
-    void SyncScissorTest();
+    void SyncScissorTest(OpenGLState& current_state);
    /// Syncs the transform feedback state to match the guest state
    void SyncTransformFeedback();
@@ -182,13 +183,18 @@ private:
    /// Syncs Color Mask
    void SyncColorMask();
+    /// Syncs the polygon offsets
+    void SyncPolygonOffset();
    /// Check asserts for alpha testing.
    void CheckAlphaTests();
+    /// Check for extension that are not strictly required
+    /// but are needed for correct emulation
+    void CheckExtensions();
    bool has_ARB_direct_state_access = false;
    bool has_ARB_multi_bind = false;
-    bool has_ARB_separate_shader_objects = false;
-    bool has_ARB_vertex_attrib_binding = false;
    OpenGLState state;
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
index 9ca82c06c..dde2f468d 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
@@ -15,6 +15,7 @@
 #include "core/memory.h"
 #include "core/settings.h"
 #include "video_core/engines/maxwell_3d.h"
+#include "video_core/morton.h"
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/gl_rasterizer_cache.h"
 #include "video_core/renderer_opengl/gl_state.h"
@@ -22,10 +23,11 @@
 #include "video_core/surface.h"
 #include "video_core/textures/astc.h"
 #include "video_core/textures/decoders.h"
-#include "video_core/utils.h"
 namespace OpenGL {
+using VideoCore::MortonSwizzle;
+using VideoCore::MortonSwizzleMode;
 using VideoCore::Surface::ComponentTypeFromDepthFormat;
 using VideoCore::Surface::ComponentTypeFromRenderTarget;
 using VideoCore::Surface::ComponentTypeFromTexture;
@@ -95,6 +97,7 @@ std::size_t SurfaceParams::InnerMemorySize(bool force_gl, bool layer_only,
    params.block_width = params.is_tiled ? config.tic.BlockWidth() : 0,
    params.block_height = params.is_tiled ? config.tic.BlockHeight() : 0,
    params.block_depth = params.is_tiled ? config.tic.BlockDepth() : 0,
+    params.tile_width_spacing = params.is_tiled ? (1 << config.tic.tile_width_spacing.Value()) : 1;
    params.srgb_conversion = config.tic.IsSrgbConversionEnabled();
    params.pixel_format = PixelFormatFromTextureFormat(config.tic.format, config.tic.r_type.Value(),
                                                       params.srgb_conversion);
@@ -160,6 +163,7 @@ std::size_t SurfaceParams::InnerMemorySize(bool force_gl, bool layer_only,
    params.block_width = 1 << config.memory_layout.block_width;
    params.block_height = 1 << config.memory_layout.block_height;
    params.block_depth = 1 << config.memory_layout.block_depth;
+    params.tile_width_spacing = 1;
    params.pixel_format = PixelFormatFromRenderTargetFormat(config.format);
    params.srgb_conversion = config.format == Tegra::RenderTargetFormat::BGRA8_SRGB ||
                             config.format == Tegra::RenderTargetFormat::RGBA8_SRGB;
@@ -195,6 +199,7 @@ std::size_t SurfaceParams::InnerMemorySize(bool force_gl, bool layer_only,
    params.block_width = 1 << std::min(block_width, 5U);
    params.block_height = 1 << std::min(block_height, 5U);
    params.block_depth = 1 << std::min(block_depth, 5U);
+    params.tile_width_spacing = 1;
    params.pixel_format = PixelFormatFromDepthFormat(format);
    params.component_type = ComponentTypeFromDepthFormat(format);
    params.type = GetFormatType(params.pixel_format);
@@ -221,6 +226,7 @@ std::size_t SurfaceParams::InnerMemorySize(bool force_gl, bool layer_only,
    params.block_width = params.is_tiled ? std::min(config.BlockWidth(), 32U) : 0,
    params.block_height = params.is_tiled ? std::min(config.BlockHeight(), 32U) : 0,
    params.block_depth = params.is_tiled ? std::min(config.BlockDepth(), 32U) : 0,
+    params.tile_width_spacing = 1;
    params.pixel_format = PixelFormatFromRenderTargetFormat(config.format);
    params.srgb_conversion = config.format == Tegra::RenderTargetFormat::BGRA8_SRGB ||
                             config.format == Tegra::RenderTargetFormat::RGBA8_SRGB;
@@ -265,11 +271,11 @@ static constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> tex
    {GL_COMPRESSED_RG_RGTC2, GL_RG, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
     true},                                                                     // DXN2UNORM
    {GL_COMPRESSED_SIGNED_RG_RGTC2, GL_RG, GL_INT, ComponentType::SNorm, true}, // DXN2SNORM
-    {GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
+    {GL_COMPRESSED_RGBA_BPTC_UNORM, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
     true}, // BC7U
-    {GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB, GL_RGB, GL_UNSIGNED_INT_8_8_8_8,
+    {GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::Float,
-     ComponentType::Float, true}, // BC6H_UF16
+     true}, // BC6H_UF16
-    {GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::Float,
+    {GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::Float,
     true},                                                                    // BC6H_SF16
    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_4X4
    {GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},            // G8R8U
@@ -306,8 +312,8 @@ static constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> tex
     true}, // DXT23_SRGB
    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
     true}, // DXT45_SRGB
-    {GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8,
+    {GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
-     ComponentType::UNorm, true},                                              // BC7U_SRGB
+     true},                                                                    // BC7U_SRGB
    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_4X4_SRGB
    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X8_SRGB
    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X5_SRGB
@@ -346,7 +352,7 @@ static GLenum SurfaceTargetToGL(SurfaceTarget target) {
    case SurfaceTarget::TextureCubemap:
        return GL_TEXTURE_CUBE_MAP;
    case SurfaceTarget::TextureCubeArray:
-        return GL_TEXTURE_CUBE_MAP_ARRAY_ARB;
+        return GL_TEXTURE_CUBE_MAP_ARRAY;
    }
    LOG_CRITICAL(Render_OpenGL, "Unimplemented texture target={}", static_cast<u32>(target));
    UNREACHABLE();
@@ -370,174 +376,7 @@ MathUtil::Rectangle<u32> SurfaceParams::GetRect(u32 mip_level) const {
    return {0, actual_height, MipWidth(mip_level), 0};
 }
-template <bool morton_to_gl, PixelFormat format>
+void SwizzleFunc(const MortonSwizzleMode& mode, const SurfaceParams& params,
-void MortonCopy(u32 stride, u32 block_height, u32 height, u32 block_depth, u32 depth, u8* gl_buffer,
-                std::size_t gl_buffer_size, VAddr addr) {
-    constexpr u32 bytes_per_pixel = GetBytesPerPixel(format);
-    // With the BCn formats (DXT and DXN), each 4x4 tile is swizzled instead of just individual
-    // pixel values.
-    const u32 tile_size_x{GetDefaultBlockWidth(format)};
-    const u32 tile_size_y{GetDefaultBlockHeight(format)};
-    if (morton_to_gl) {
-        Tegra::Texture::UnswizzleTexture(gl_buffer, addr, tile_size_x, tile_size_y, bytes_per_pixel,
-                                         stride, height, depth, block_height, block_depth);
-    } else {
-        Tegra::Texture::CopySwizzledData((stride + tile_size_x - 1) / tile_size_x,
-                                         (height + tile_size_y - 1) / tile_size_y, depth,
-                                         bytes_per_pixel, bytes_per_pixel, Memory::GetPointer(addr),
-                                         gl_buffer, false, block_height, block_depth);
-    }
-}
-using GLConversionArray = std::array<void (*)(u32, u32, u32, u32, u32, u8*, std::size_t, VAddr),
-                                     VideoCore::Surface::MaxPixelFormat>;
-static constexpr GLConversionArray morton_to_gl_fns = {
-    // clang-format off
-        MortonCopy<true, PixelFormat::ABGR8U>,
-        MortonCopy<true, PixelFormat::ABGR8S>,
-        MortonCopy<true, PixelFormat::ABGR8UI>,
-        MortonCopy<true, PixelFormat::B5G6R5U>,
-        MortonCopy<true, PixelFormat::A2B10G10R10U>,
-        MortonCopy<true, PixelFormat::A1B5G5R5U>,
-        MortonCopy<true, PixelFormat::R8U>,
-        MortonCopy<true, PixelFormat::R8UI>,
-        MortonCopy<true, PixelFormat::RGBA16F>,
-        MortonCopy<true, PixelFormat::RGBA16U>,
-        MortonCopy<true, PixelFormat::RGBA16UI>,
-        MortonCopy<true, PixelFormat::R11FG11FB10F>,
-        MortonCopy<true, PixelFormat::RGBA32UI>,
-        MortonCopy<true, PixelFormat::DXT1>,
-        MortonCopy<true, PixelFormat::DXT23>,
-        MortonCopy<true, PixelFormat::DXT45>,
-        MortonCopy<true, PixelFormat::DXN1>,
-        MortonCopy<true, PixelFormat::DXN2UNORM>,
-        MortonCopy<true, PixelFormat::DXN2SNORM>,
-        MortonCopy<true, PixelFormat::BC7U>,
-        MortonCopy<true, PixelFormat::BC6H_UF16>,
-        MortonCopy<true, PixelFormat::BC6H_SF16>,
-        MortonCopy<true, PixelFormat::ASTC_2D_4X4>,
-        MortonCopy<true, PixelFormat::G8R8U>,
-        MortonCopy<true, PixelFormat::G8R8S>,
-        MortonCopy<true, PixelFormat::BGRA8>,
-        MortonCopy<true, PixelFormat::RGBA32F>,
-        MortonCopy<true, PixelFormat::RG32F>,
-        MortonCopy<true, PixelFormat::R32F>,
-        MortonCopy<true, PixelFormat::R16F>,
-        MortonCopy<true, PixelFormat::R16U>,
-        MortonCopy<true, PixelFormat::R16S>,
-        MortonCopy<true, PixelFormat::R16UI>,
-        MortonCopy<true, PixelFormat::R16I>,
-        MortonCopy<true, PixelFormat::RG16>,
-        MortonCopy<true, PixelFormat::RG16F>,
-        MortonCopy<true, PixelFormat::RG16UI>,
-        MortonCopy<true, PixelFormat::RG16I>,
-        MortonCopy<true, PixelFormat::RG16S>,
-        MortonCopy<true, PixelFormat::RGB32F>,
-        MortonCopy<true, PixelFormat::RGBA8_SRGB>,
-        MortonCopy<true, PixelFormat::RG8U>,
-        MortonCopy<true, PixelFormat::RG8S>,
-        MortonCopy<true, PixelFormat::RG32UI>,
-        MortonCopy<true, PixelFormat::R32UI>,
-        MortonCopy<true, PixelFormat::ASTC_2D_8X8>,
-        MortonCopy<true, PixelFormat::ASTC_2D_8X5>,
-        MortonCopy<true, PixelFormat::ASTC_2D_5X4>,
-        MortonCopy<true, PixelFormat::BGRA8_SRGB>,
-        MortonCopy<true, PixelFormat::DXT1_SRGB>,
-        MortonCopy<true, PixelFormat::DXT23_SRGB>,
-        MortonCopy<true, PixelFormat::DXT45_SRGB>,
-        MortonCopy<true, PixelFormat::BC7U_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_4X4_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_8X8_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_8X5_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_5X4_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_5X5>,
-        MortonCopy<true, PixelFormat::ASTC_2D_5X5_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_10X8>,
-        MortonCopy<true, PixelFormat::ASTC_2D_10X8_SRGB>,
-        MortonCopy<true, PixelFormat::Z32F>,
-        MortonCopy<true, PixelFormat::Z16>,
-        MortonCopy<true, PixelFormat::Z24S8>,
-        MortonCopy<true, PixelFormat::S8Z24>,
-        MortonCopy<true, PixelFormat::Z32FS8>,
-    // clang-format on
-};
-static constexpr GLConversionArray gl_to_morton_fns = {
-    // clang-format off
-        MortonCopy<false, PixelFormat::ABGR8U>,
-        MortonCopy<false, PixelFormat::ABGR8S>,
-        MortonCopy<false, PixelFormat::ABGR8UI>,
-        MortonCopy<false, PixelFormat::B5G6R5U>,
-        MortonCopy<false, PixelFormat::A2B10G10R10U>,
-        MortonCopy<false, PixelFormat::A1B5G5R5U>,
-        MortonCopy<false, PixelFormat::R8U>,
-        MortonCopy<false, PixelFormat::R8UI>,
-        MortonCopy<false, PixelFormat::RGBA16F>,
-        MortonCopy<false, PixelFormat::RGBA16U>,
-        MortonCopy<false, PixelFormat::RGBA16UI>,
-        MortonCopy<false, PixelFormat::R11FG11FB10F>,
-        MortonCopy<false, PixelFormat::RGBA32UI>,
-        MortonCopy<false, PixelFormat::DXT1>,
-        MortonCopy<false, PixelFormat::DXT23>,
-        MortonCopy<false, PixelFormat::DXT45>,
-        MortonCopy<false, PixelFormat::DXN1>,
-        MortonCopy<false, PixelFormat::DXN2UNORM>,
-        MortonCopy<false, PixelFormat::DXN2SNORM>,
-        MortonCopy<false, PixelFormat::BC7U>,
-        MortonCopy<false, PixelFormat::BC6H_UF16>,
-        MortonCopy<false, PixelFormat::BC6H_SF16>,
-        // TODO(Subv): Swizzling ASTC formats are not supported
-        nullptr,
-        MortonCopy<false, PixelFormat::G8R8U>,
-        MortonCopy<false, PixelFormat::G8R8S>,
-        MortonCopy<false, PixelFormat::BGRA8>,
-        MortonCopy<false, PixelFormat::RGBA32F>,
-        MortonCopy<false, PixelFormat::RG32F>,
-        MortonCopy<false, PixelFormat::R32F>,
-        MortonCopy<false, PixelFormat::R16F>,
-        MortonCopy<false, PixelFormat::R16U>,
-        MortonCopy<false, PixelFormat::R16S>,
-        MortonCopy<false, PixelFormat::R16UI>,
-        MortonCopy<false, PixelFormat::R16I>,
-        MortonCopy<false, PixelFormat::RG16>,
-        MortonCopy<false, PixelFormat::RG16F>,
-        MortonCopy<false, PixelFormat::RG16UI>,
-        MortonCopy<false, PixelFormat::RG16I>,
-        MortonCopy<false, PixelFormat::RG16S>,
-        MortonCopy<false, PixelFormat::RGB32F>,
-        MortonCopy<false, PixelFormat::RGBA8_SRGB>,
-        MortonCopy<false, PixelFormat::RG8U>,
-        MortonCopy<false, PixelFormat::RG8S>,
-        MortonCopy<false, PixelFormat::RG32UI>,
-        MortonCopy<false, PixelFormat::R32UI>,
-        nullptr,
-        nullptr,
-        nullptr,
-        MortonCopy<false, PixelFormat::BGRA8_SRGB>,
-        MortonCopy<false, PixelFormat::DXT1_SRGB>,
-        MortonCopy<false, PixelFormat::DXT23_SRGB>,
-        MortonCopy<false, PixelFormat::DXT45_SRGB>,
-        MortonCopy<false, PixelFormat::BC7U_SRGB>,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        MortonCopy<false, PixelFormat::Z32F>,
-        MortonCopy<false, PixelFormat::Z16>,
-        MortonCopy<false, PixelFormat::Z24S8>,
-        MortonCopy<false, PixelFormat::S8Z24>,
-        MortonCopy<false, PixelFormat::Z32FS8>,
-    // clang-format on
-};
-void SwizzleFunc(const GLConversionArray& functions, const SurfaceParams& params,
                 std::vector<u8>& gl_buffer, u32 mip_level) {
    u32 depth = params.MipDepth(mip_level);
    if (params.target == SurfaceTarget::Texture2D) {
@@ -550,19 +389,19 @@ void SwizzleFunc(const GLConversionArray& functions, const SurfaceParams& params
        const u64 layer_size = params.LayerMemorySize();
        const u64 gl_size = params.LayerSizeGL(mip_level);
        for (u32 i = 0; i < params.depth; i++) {
-            functions[static_cast<std::size_t>(params.pixel_format)](
+            MortonSwizzle(mode, params.pixel_format, params.MipWidth(mip_level),
-                params.MipWidth(mip_level), params.MipBlockHeight(mip_level),
+                          params.MipBlockHeight(mip_level), params.MipHeight(mip_level),
-                params.MipHeight(mip_level), params.MipBlockDepth(mip_level), 1,
+                          params.MipBlockDepth(mip_level), params.tile_width_spacing, 1,
-                gl_buffer.data() + offset_gl, gl_size, params.addr + offset);
+                          gl_buffer.data() + offset_gl, gl_size, params.addr + offset);
            offset += layer_size;
            offset_gl += gl_size;
        }
    } else {
        const u64 offset = params.GetMipmapLevelOffset(mip_level);
-        functions[static_cast<std::size_t>(params.pixel_format)](
+        MortonSwizzle(mode, params.pixel_format, params.MipWidth(mip_level),
-            params.MipWidth(mip_level), params.MipBlockHeight(mip_level),
+                      params.MipBlockHeight(mip_level), params.MipHeight(mip_level),
-            params.MipHeight(mip_level), params.MipBlockDepth(mip_level), depth, gl_buffer.data(),
+                      params.MipBlockDepth(mip_level), depth, params.tile_width_spacing,
-            gl_buffer.size(), params.addr + offset);
+                      gl_buffer.data(), gl_buffer.size(), params.addr + offset);
    }
 }
@@ -726,7 +565,7 @@ static void CopySurface(const Surface& src_surface, const Surface& dst_surface,
    const std::size_t buffer_size = std::max(src_params.size_in_bytes, dst_params.size_in_bytes);
    glBindBuffer(GL_PIXEL_PACK_BUFFER, copy_pbo_handle);
-    glBufferData(GL_PIXEL_PACK_BUFFER, buffer_size, nullptr, GL_STREAM_DRAW_ARB);
+    glBufferData(GL_PIXEL_PACK_BUFFER, buffer_size, nullptr, GL_STREAM_DRAW);
    if (source_format.compressed) {
        glGetCompressedTextureImage(src_surface->Texture().handle, src_attachment,
                                    static_cast<GLsizei>(src_params.size_in_bytes), nullptr);
@@ -996,7 +835,7 @@ void CachedSurface::LoadGLBuffer() {
        ASSERT_MSG(params.block_width == 1, "Block width is defined as {} on texture type {}",
                   params.block_width, static_cast<u32>(params.target));
        for (u32 i = 0; i < params.max_mip_level; i++)
-            SwizzleFunc(morton_to_gl_fns, params, gl_buffer[i], i);
+            SwizzleFunc(MortonSwizzleMode::MortonToLinear, params, gl_buffer[i], i);
    } else {
        const auto texture_src_data{Memory::GetPointer(params.addr)};
        const auto texture_src_data_end{texture_src_data + params.size_in_bytes_gl};
@@ -1035,7 +874,7 @@ void CachedSurface::FlushGLBuffer() {
        ASSERT_MSG(params.block_width == 1, "Block width is defined as {} on texture type {}",
                   params.block_width, static_cast<u32>(params.target));
-        SwizzleFunc(gl_to_morton_fns, params, gl_buffer[0], 0);
+        SwizzleFunc(MortonSwizzleMode::LinearToMorton, params, gl_buffer[0], 0);
    } else {
        std::memcpy(Memory::GetPointer(GetAddr()), gl_buffer[0].data(), GetSizeInBytes());
    }
@@ -1275,6 +1114,31 @@ Surface RasterizerCacheOpenGL::GetUncachedSurface(const SurfaceParams& params) {
    return surface;
 }
+void RasterizerCacheOpenGL::FastLayeredCopySurface(const Surface& src_surface,
+                                                   const Surface& dst_surface) {
+    const auto& init_params{src_surface->GetSurfaceParams()};
+    const auto& dst_params{dst_surface->GetSurfaceParams()};
+    VAddr address = init_params.addr;
+    const std::size_t layer_size = dst_params.LayerMemorySize();
+    for (u32 layer = 0; layer < dst_params.depth; layer++) {
+        for (u32 mipmap = 0; mipmap < dst_params.max_mip_level; mipmap++) {
+            const VAddr sub_address = address + dst_params.GetMipmapLevelOffset(mipmap);
+            const Surface& copy = TryGet(sub_address);
+            if (!copy)
+                continue;
+            const auto& src_params{copy->GetSurfaceParams()};
+            const u32 width{std::min(src_params.width, dst_params.MipWidth(mipmap))};
+            const u32 height{std::min(src_params.height, dst_params.MipHeight(mipmap))};
+            glCopyImageSubData(copy->Texture().handle, SurfaceTargetToGL(src_params.target), 0, 0,
+                               0, 0, dst_surface->Texture().handle,
+                               SurfaceTargetToGL(dst_params.target), mipmap, 0, 0, layer, width,
+                               height, 1);
+        }
+        address += layer_size;
+    }
+}
 void RasterizerCacheOpenGL::FermiCopySurface(
    const Tegra::Engines::Fermi2D::Regs::Surface& src_config,
    const Tegra::Engines::Fermi2D::Regs::Surface& dst_config) {
@@ -1340,11 +1204,13 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
            CopySurface(old_surface, new_surface, copy_pbo.handle);
        }
        break;
-    case SurfaceTarget::TextureCubemap:
    case SurfaceTarget::Texture3D:
+        AccurateCopySurface(old_surface, new_surface);
+        break;
+    case SurfaceTarget::TextureCubemap:
    case SurfaceTarget::Texture2DArray:
    case SurfaceTarget::TextureCubeArray:
-        AccurateCopySurface(old_surface, new_surface);
+        FastLayeredCopySurface(old_surface, new_surface);
        break;
    default:
        LOG_CRITICAL(Render_OpenGL, "Unimplemented surface target={}",
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.h b/src/video_core/renderer_opengl/gl_rasterizer_cache.h
index 494f6b903..c710aa245 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.h
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.h
@@ -196,9 +196,15 @@ struct SurfaceParams {
    /// Checks if surfaces are compatible for caching
    bool IsCompatibleSurface(const SurfaceParams& other) const {
-        return std::tie(pixel_format, type, width, height, target, depth) ==
+        if (std::tie(pixel_format, type, width, height, target, depth, is_tiled) ==
-               std::tie(other.pixel_format, other.type, other.width, other.height, other.target,
+            std::tie(other.pixel_format, other.type, other.width, other.height, other.target,
-                        other.depth);
+                     other.depth, other.is_tiled)) {
+            if (!is_tiled)
+                return true;
+            return std::tie(block_height, block_depth, tile_width_spacing) ==
+                   std::tie(other.block_height, other.block_depth, other.tile_width_spacing);
+        }
+        return false;
    }
    /// Initializes parameters for caching, should be called after everything has been initialized
@@ -208,6 +214,7 @@ struct SurfaceParams {
    u32 block_width;
    u32 block_height;
    u32 block_depth;
+    u32 tile_width_spacing;
    PixelFormat pixel_format;
    ComponentType component_type;
    SurfaceType type;
@@ -350,6 +357,7 @@ private:
    /// Performs a slow but accurate surface copy, flushing to RAM and reinterpreting the data
    void AccurateCopySurface(const Surface& src_surface, const Surface& dst_surface);
+    void FastLayeredCopySurface(const Surface& src_surface, const Surface& dst_surface);
    /// The surface reserve is a "backup" cache, this is where we put unique surfaces that have
    /// previously been used. This is to prevent surfaces from being constantly created and
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.cpp b/src/video_core/renderer_opengl/gl_shader_cache.cpp
index a85a7c0c5..038b25c75 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_cache.cpp
@@ -84,6 +84,7 @@ CachedShader::CachedShader(VAddr addr, Maxwell::ShaderProgram program_type)
    }
    entries = program_result.second;
+    shader_length = entries.shader_length;
    if (program_type != Maxwell::ShaderProgram::Geometry) {
        OGLShader shader;
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.h b/src/video_core/renderer_opengl/gl_shader_cache.h
index ffbf21831..08f470de3 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.h
+++ b/src/video_core/renderer_opengl/gl_shader_cache.h
@@ -30,7 +30,7 @@ public:
    }
    std::size_t GetSizeInBytes() const override {
-        return GLShader::MAX_PROGRAM_CODE_LENGTH * sizeof(u64);
+        return shader_length;
    }
    // We do not have to flush this cache as things in it are never modified by us.
@@ -82,6 +82,7 @@ private:
                               u32 max_vertices, const std::string& debug_name);
    VAddr addr;
+    std::size_t shader_length;
    Maxwell::ShaderProgram program_type;
    GLShader::ShaderSetup setup;
    GLShader::ShaderEntries entries;
diff --git a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
index 90a88b91a..0c4524d5c 100644
--- a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
@@ -34,6 +34,17 @@ constexpr u32 PROGRAM_HEADER_SIZE = sizeof(Tegra::Shader::Header);
 constexpr u32 MAX_GEOMETRY_BUFFERS = 6;
 constexpr u32 MAX_ATTRIBUTES = 0x100; // Size in vec4s, this value is untested
+static const char* INTERNAL_FLAG_NAMES[] = {"zero_flag", "sign_flag", "carry_flag",
+                                            "overflow_flag"};
+enum class InternalFlag : u64 {
+    ZeroFlag = 0,
+    SignFlag = 1,
+    CarryFlag = 2,
+    OverflowFlag = 3,
+    Amount
+};
 class DecompileFail : public std::runtime_error {
 public:
    using std::runtime_error::runtime_error;
@@ -84,7 +95,8 @@ struct Subroutine {
 class ControlFlowAnalyzer {
 public:
    ControlFlowAnalyzer(const ProgramCode& program_code, u32 main_offset, const std::string& suffix)
-        : program_code(program_code) {
+        : program_code(program_code), shader_coverage_begin(main_offset),
+          shader_coverage_end(main_offset + 1) {
        // Recursively finds all subroutines.
        const Subroutine& program_main = AddSubroutine(main_offset, PROGRAM_END, suffix);
@@ -96,10 +108,16 @@ public:
        return std::move(subroutines);
    }
+    std::size_t GetShaderLength() const {
+        return shader_coverage_end * sizeof(u64);
+    }
 private:
    const ProgramCode& program_code;
    std::set<Subroutine> subroutines;
    std::map<std::pair<u32, u32>, ExitMethod> exit_method_map;
+    u32 shader_coverage_begin;
+    u32 shader_coverage_end;
    /// Adds and analyzes a new subroutine if it is not added yet.
    const Subroutine& AddSubroutine(u32 begin, u32 end, const std::string& suffix) {
@@ -141,6 +159,9 @@ private:
            return exit_method;
        for (u32 offset = begin; offset != end && offset != PROGRAM_END; ++offset) {
+            shader_coverage_begin = std::min(shader_coverage_begin, offset);
+            shader_coverage_end = std::max(shader_coverage_end, offset + 1);
            const Instruction instr = {program_code[offset]};
            if (const auto opcode = OpCode::Decode(instr)) {
                switch (opcode->get().GetId()) {
@@ -257,14 +278,6 @@ private:
    const std::string& suffix;
 };
-enum class InternalFlag : u64 {
-    ZeroFlag = 0,
-    CarryFlag = 1,
-    OverflowFlag = 2,
-    NaNFlag = 3,
-    Amount
-};
 /**
 * Used to manage shader registers that are emulated with GLSL. This class keeps track of the state
 * of all registers (e.g. whether they are currently being used as Floats or Integers), and
@@ -371,7 +384,7 @@ public:
        if (sets_cc) {
            const std::string zero_condition = "( " + ConvertIntegerSize(value, size) + " == 0 )";
            SetInternalFlag(InternalFlag::ZeroFlag, zero_condition);
-            LOG_WARNING(HW_GPU, "Control Codes Imcomplete.");
+            LOG_WARNING(HW_GPU, "Condition codes implementation is incomplete.");
        }
    }
@@ -454,23 +467,25 @@ public:
        shader.AddLine("lmem[" + index + "] = " + func + '(' + value + ");");
    }
-    std::string GetControlCode(const Tegra::Shader::ControlCode cc) const {
+    std::string GetConditionCode(const Tegra::Shader::ConditionCode cc) const {
        switch (cc) {
-        case Tegra::Shader::ControlCode::NEU:
+        case Tegra::Shader::ConditionCode::NEU:
            return "!(" + GetInternalFlag(InternalFlag::ZeroFlag) + ')';
        default:
-            UNIMPLEMENTED_MSG("Unimplemented Control Code: {}", static_cast<u32>(cc));
+            UNIMPLEMENTED_MSG("Unimplemented condition code: {}", static_cast<u32>(cc));
            return "false";
        }
    }
-    std::string GetInternalFlag(const InternalFlag ii) const {
+    std::string GetInternalFlag(const InternalFlag flag) const {
-        const u32 code = static_cast<u32>(ii);
+        const auto index = static_cast<u32>(flag);
-        return "internalFlag_" + std::to_string(code) + suffix;
+        ASSERT(index < static_cast<u32>(InternalFlag::Amount));
+        return std::string(INTERNAL_FLAG_NAMES[index]) + '_' + suffix;
    }
-    void SetInternalFlag(const InternalFlag ii, const std::string& value) const {
+    void SetInternalFlag(const InternalFlag flag, const std::string& value) const {
-        shader.AddLine(GetInternalFlag(ii) + " = " + value + ';');
+        shader.AddLine(GetInternalFlag(flag) + " = " + value + ';');
    }
    /**
@@ -485,27 +500,42 @@ public:
                                      const Register& buf_reg) {
        const std::string dest = GetOutputAttribute(attribute);
        const std::string src = GetRegisterAsFloat(val_reg);
+        if (dest.empty())
+            return;
-        if (!dest.empty()) {
+        // Can happen with unknown/unimplemented output attributes, in which case we ignore the
-            // Can happen with unknown/unimplemented output attributes, in which case we ignore the
+        // instruction for now.
-            // instruction for now.
+        if (stage == Maxwell3D::Regs::ShaderStage::Geometry) {
-            if (stage == Maxwell3D::Regs::ShaderStage::Geometry) {
+            // TODO(Rodrigo): nouveau sets some attributes after setting emitting a geometry
-                // TODO(Rodrigo): nouveau sets some attributes after setting emitting a geometry
+            // shader. These instructions use a dirty register as buffer index, to avoid some
-                // shader. These instructions use a dirty register as buffer index, to avoid some
+            // drivers from complaining about out of boundary writes, guard them.
-                // drivers from complaining about out of boundary writes, guard them.
+            const std::string buf_index{"((" + GetRegisterAsInteger(buf_reg) + ") % " +
-                const std::string buf_index{"((" + GetRegisterAsInteger(buf_reg) + ") % " +
+                                        std::to_string(MAX_GEOMETRY_BUFFERS) + ')'};
-                                            std::to_string(MAX_GEOMETRY_BUFFERS) + ')'};
+            shader.AddLine("amem[" + buf_index + "][" +
-                shader.AddLine("amem[" + buf_index + "][" +
+                           std::to_string(static_cast<u32>(attribute)) + ']' + GetSwizzle(elem) +
-                               std::to_string(static_cast<u32>(attribute)) + ']' +
+                           " = " + src + ';');
-                               GetSwizzle(elem) + " = " + src + ';');
+            return;
-            } else {
+        }
-                if (attribute == Attribute::Index::PointSize) {
-                    fixed_pipeline_output_attributes_used.insert(attribute);
+        switch (attribute) {
-                    shader.AddLine(dest + " = " + src + ';');
+        case Attribute::Index::ClipDistances0123:
-                } else {
+        case Attribute::Index::ClipDistances4567: {
-                    shader.AddLine(dest + GetSwizzle(elem) + " = " + src + ';');
+            const u64 index = (attribute == Attribute::Index::ClipDistances4567 ? 4 : 0) + elem;
-                }
+            UNIMPLEMENTED_IF_MSG(
-            }
+                ((header.vtg.clip_distances >> index) & 1) == 0,
+                "Shader is setting gl_ClipDistance{} without enabling it in the header", index);
+            fixed_pipeline_output_attributes_used.insert(attribute);
+            shader.AddLine(dest + '[' + std::to_string(index) + "] = " + src + ';');
+            break;
+        }
+        case Attribute::Index::PointSize:
+            fixed_pipeline_output_attributes_used.insert(attribute);
+            shader.AddLine(dest + " = " + src + ';');
+            break;
+        default:
+            shader.AddLine(dest + GetSwizzle(elem) + " = " + src + ';');
+            break;
        }
    }
@@ -621,8 +651,8 @@ private:
    /// Generates declarations for internal flags.
    void GenerateInternalFlags() {
-        for (u32 ii = 0; ii < static_cast<u64>(InternalFlag::Amount); ii++) {
+        for (u32 flag = 0; flag < static_cast<u32>(InternalFlag::Amount); flag++) {
-            const InternalFlag code = static_cast<InternalFlag>(ii);
+            const InternalFlag code = static_cast<InternalFlag>(flag);
            declarations.AddLine("bool " + GetInternalFlag(code) + " = false;");
        }
        declarations.AddNewLine();
@@ -725,12 +755,19 @@ private:
    void GenerateVertex() {
        if (stage != Maxwell3D::Regs::ShaderStage::Vertex)
            return;
+        bool clip_distances_declared = false;
        declarations.AddLine("out gl_PerVertex {");
        ++declarations.scope;
        declarations.AddLine("vec4 gl_Position;");
        for (auto& o : fixed_pipeline_output_attributes_used) {
            if (o == Attribute::Index::PointSize)
                declarations.AddLine("float gl_PointSize;");
+            if (!clip_distances_declared && (o == Attribute::Index::ClipDistances0123 ||
+                                             o == Attribute::Index::ClipDistances4567)) {
+                declarations.AddLine("float gl_ClipDistance[];");
+                clip_distances_declared = true;
+            }
        }
        --declarations.scope;
        declarations.AddLine("};");
@@ -830,7 +867,8 @@ private:
            // vertex shader, and what's the value of the fourth element when inside a Tess Eval
            // shader.
            ASSERT(stage == Maxwell3D::Regs::ShaderStage::Vertex);
-            return "vec4(0, 0, uintBitsToFloat(instance_id.x), uintBitsToFloat(gl_VertexID))";
+            // Config pack's first value is instance_id.
+            return "vec4(0, 0, uintBitsToFloat(config_pack[0]), uintBitsToFloat(gl_VertexID))";
        case Attribute::Index::FrontFacing:
            // TODO(Subv): Find out what the values are for the other elements.
            ASSERT(stage == Maxwell3D::Regs::ShaderStage::Fragment);
@@ -901,6 +939,10 @@ private:
            return "gl_PointSize";
        case Attribute::Index::Position:
            return "position";
+        case Attribute::Index::ClipDistances0123:
+        case Attribute::Index::ClipDistances4567: {
+            return "gl_ClipDistance";
+        }
        default:
            const u32 index{static_cast<u32>(attribute) -
                            static_cast<u32>(Attribute::Index::Attribute_0)};
@@ -939,9 +981,10 @@ private:
 class GLSLGenerator {
 public:
    GLSLGenerator(const std::set<Subroutine>& subroutines, const ProgramCode& program_code,
-                  u32 main_offset, Maxwell3D::Regs::ShaderStage stage, const std::string& suffix)
+                  u32 main_offset, Maxwell3D::Regs::ShaderStage stage, const std::string& suffix,
+                  std::size_t shader_length)
        : subroutines(subroutines), program_code(program_code), main_offset(main_offset),
-          stage(stage), suffix(suffix) {
+          stage(stage), suffix(suffix), shader_length(shader_length) {
        std::memcpy(&header, program_code.data(), sizeof(Tegra::Shader::Header));
        local_memory_size = header.GetLocalMemorySize();
        regs.SetLocalMemory(local_memory_size);
@@ -954,7 +997,7 @@ public:
    /// Returns entries in the shader that are useful for external functions
    ShaderEntries GetEntries() const {
-        return {regs.GetConstBuffersDeclarations(), regs.GetSamplers()};
+        return {regs.GetConstBuffersDeclarations(), regs.GetSamplers(), shader_length};
    }
 private:
@@ -1059,11 +1102,17 @@ private:
                                       const std::string& op_a, const std::string& op_b) const {
        using Tegra::Shader::PredCondition;
        static const std::unordered_map<PredCondition, const char*> PredicateComparisonStrings = {
-            {PredCondition::LessThan, "<"},           {PredCondition::Equal, "=="},
+            {PredCondition::LessThan, "<"},
-            {PredCondition::LessEqual, "<="},         {PredCondition::GreaterThan, ">"},
+            {PredCondition::Equal, "=="},
-            {PredCondition::NotEqual, "!="},          {PredCondition::GreaterEqual, ">="},
+            {PredCondition::LessEqual, "<="},
-            {PredCondition::LessThanWithNan, "<"},    {PredCondition::NotEqualWithNan, "!="},
+            {PredCondition::GreaterThan, ">"},
-            {PredCondition::GreaterThanWithNan, ">"}, {PredCondition::GreaterEqualWithNan, ">="}};
+            {PredCondition::NotEqual, "!="},
+            {PredCondition::GreaterEqual, ">="},
+            {PredCondition::LessThanWithNan, "<"},
+            {PredCondition::NotEqualWithNan, "!="},
+            {PredCondition::LessEqualWithNan, "<="},
+            {PredCondition::GreaterThanWithNan, ">"},
+            {PredCondition::GreaterEqualWithNan, ">="}};
        const auto& comparison{PredicateComparisonStrings.find(condition)};
        UNIMPLEMENTED_IF_MSG(comparison == PredicateComparisonStrings.end(),
@@ -1072,6 +1121,7 @@ private:
        std::string predicate{'(' + op_a + ") " + comparison->second + " (" + op_b + ')'};
        if (condition == PredCondition::LessThanWithNan ||
            condition == PredCondition::NotEqualWithNan ||
+            condition == PredCondition::LessEqualWithNan ||
            condition == PredCondition::GreaterThanWithNan ||
            condition == PredCondition::GreaterEqualWithNan) {
            predicate += " || isnan(" + op_a + ") || isnan(" + op_b + ')';
@@ -1250,6 +1300,7 @@ private:
        shader.AddLine('{');
        ++shader.scope;
        shader.AddLine(coord);
+        shader.AddLine("vec4 texture_tmp = " + texture + ';');
        // TEXS has two destination registers and a swizzle. The first two elements in the swizzle
        // go into gpr0+0 and gpr0+1, and the rest goes into gpr28+0 and gpr28+1
@@ -1262,18 +1313,17 @@ private:
            if (written_components < 2) {
                // Write the first two swizzle components to gpr0 and gpr0+1
-                regs.SetRegisterToFloat(instr.gpr0, component, texture, 1, 4, false,
+                regs.SetRegisterToFloat(instr.gpr0, component, "texture_tmp", 1, 4, false,
                                        written_components % 2);
            } else {
                ASSERT(instr.texs.HasTwoDestinations());
                // Write the rest of the swizzle components to gpr28 and gpr28+1
-                regs.SetRegisterToFloat(instr.gpr28, component, texture, 1, 4, false,
+                regs.SetRegisterToFloat(instr.gpr28, component, "texture_tmp", 1, 4, false,
                                        written_components % 2);
            }
            ++written_components;
        }
        --shader.scope;
        shader.AddLine('}');
    }
@@ -1508,9 +1558,8 @@ private:
                    instr.fmul.tab5c68_0 != 1, "FMUL tab5cb8_0({}) is not implemented",
                    instr.fmul.tab5c68_0
                        .Value()); // SMO typical sends 1 here which seems to be the default
-                UNIMPLEMENTED_IF_MSG(instr.fmul.cc != 0, "FMUL cc is not implemented");
                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
-                                     "FMUL Generates an unhandled Control Code");
+                                     "Condition codes generation in FMUL is not implemented");
                op_b = GetOperandAbsNeg(op_b, false, instr.fmul.negate_b);
@@ -1522,7 +1571,7 @@ private:
            case OpCode::Id::FADD_R:
            case OpCode::Id::FADD_IMM: {
                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
-                                     "FADD Generates an unhandled Control Code");
+                                     "Condition codes generation in FADD is not implemented");
                op_a = GetOperandAbsNeg(op_a, instr.alu.abs_a, instr.alu.negate_a);
                op_b = GetOperandAbsNeg(op_b, instr.alu.abs_b, instr.alu.negate_b);
@@ -1572,7 +1621,7 @@ private:
            case OpCode::Id::FMNMX_R:
            case OpCode::Id::FMNMX_IMM: {
                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
-                                     "FMNMX Generates an unhandled Control Code");
+                                     "Condition codes generation in FMNMX is not implemented");
                op_a = GetOperandAbsNeg(op_a, instr.alu.abs_a, instr.alu.negate_a);
                op_b = GetOperandAbsNeg(op_b, instr.alu.abs_b, instr.alu.negate_b);
@@ -1609,7 +1658,7 @@ private:
            }
            case OpCode::Id::FMUL32_IMM: {
                UNIMPLEMENTED_IF_MSG(instr.op_32.generates_cc,
-                                     "FMUL32 Generates an unhandled Control Code");
+                                     "Condition codes generation in FMUL32 is not implemented");
                regs.SetRegisterToFloat(instr.gpr0, 0,
                                        regs.GetRegisterAsFloat(instr.gpr8) + " * " +
@@ -1619,7 +1668,7 @@ private:
            }
            case OpCode::Id::FADD32I: {
                UNIMPLEMENTED_IF_MSG(instr.op_32.generates_cc,
-                                     "FADD32 Generates an unhandled Control Code");
+                                     "Condition codes generation in FADD32I is not implemented");
                std::string op_a = regs.GetRegisterAsFloat(instr.gpr8);
                std::string op_b = GetImmediate32(instr);
@@ -1654,7 +1703,8 @@ private:
            switch (opcode->get().GetId()) {
            case OpCode::Id::BFE_IMM: {
-                UNIMPLEMENTED_IF_MSG(instr.generates_cc, "BFE Generates an unhandled Control Code");
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in BFE is not implemented");
                std::string inner_shift =
                    '(' + op_a + " << " + std::to_string(instr.bfe.GetLeftShiftValue()) + ')';
@@ -1672,6 +1722,26 @@ private:
            break;
        }
+        case OpCode::Type::Bfi: {
+            UNIMPLEMENTED_IF(instr.generates_cc);
+            const auto [base, packed_shift] = [&]() -> std::tuple<std::string, std::string> {
+                switch (opcode->get().GetId()) {
+                case OpCode::Id::BFI_IMM_R:
+                    return {regs.GetRegisterAsInteger(instr.gpr39, 0, false),
+                            std::to_string(instr.alu.GetSignedImm20_20())};
+                default:
+                    UNREACHABLE();
+                }
+            }();
+            const std::string offset = '(' + packed_shift + " & 0xff)";
+            const std::string bits = "((" + packed_shift + " >> 8) & 0xff)";
+            const std::string insert = regs.GetRegisterAsInteger(instr.gpr8, 0, false);
+            regs.SetRegisterToInteger(
+                instr.gpr0, false, 0,
+                "bitfieldInsert(" + base + ", " + insert + ", " + offset + ", " + bits + ')', 1, 1);
+            break;
+        }
        case OpCode::Type::Shift: {
            std::string op_a = regs.GetRegisterAsInteger(instr.gpr8, 0, true);
            std::string op_b;
@@ -1691,7 +1761,8 @@ private:
            case OpCode::Id::SHR_C:
            case OpCode::Id::SHR_R:
            case OpCode::Id::SHR_IMM: {
-                UNIMPLEMENTED_IF_MSG(instr.generates_cc, "SHR Generates an unhandled Control Code");
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in SHR is not implemented");
                if (!instr.shift.is_signed) {
                    // Logical shift right
@@ -1706,8 +1777,8 @@ private:
            case OpCode::Id::SHL_C:
            case OpCode::Id::SHL_R:
            case OpCode::Id::SHL_IMM:
-                UNIMPLEMENTED_IF_MSG(instr.generates_cc, "SHL Generates an unhandled Control Code");
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in SHL is not implemented");
                regs.SetRegisterToInteger(instr.gpr0, true, 0, op_a + " << " + op_b, 1, 1);
                break;
            default: {
@@ -1723,7 +1794,7 @@ private:
            switch (opcode->get().GetId()) {
            case OpCode::Id::IADD32I:
                UNIMPLEMENTED_IF_MSG(instr.op_32.generates_cc,
-                                     "IADD32 Generates an unhandled Control Code");
+                                     "Condition codes generation in IADD32I is not implemented");
                if (instr.iadd32i.negate_a)
                    op_a = "-(" + op_a + ')';
@@ -1733,7 +1804,7 @@ private:
                break;
            case OpCode::Id::LOP32I: {
                UNIMPLEMENTED_IF_MSG(instr.op_32.generates_cc,
-                                     "LOP32I Generates an unhandled Control Code");
+                                     "Condition codes generation in LOP32I is not implemented");
                if (instr.alu.lop32i.invert_a)
                    op_a = "~(" + op_a + ')';
@@ -1772,7 +1843,7 @@ private:
            case OpCode::Id::IADD_R:
            case OpCode::Id::IADD_IMM: {
                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
-                                     "IADD Generates an unhandled Control Code");
+                                     "Condition codes generation in IADD is not implemented");
                if (instr.alu_integer.negate_a)
                    op_a = "-(" + op_a + ')';
@@ -1788,7 +1859,7 @@ private:
            case OpCode::Id::IADD3_R:
            case OpCode::Id::IADD3_IMM: {
                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
-                                     "IADD3 Generates an unhandled Control Code");
+                                     "Condition codes generation in IADD3 is not implemented");
                std::string op_c = regs.GetRegisterAsInteger(instr.gpr39);
@@ -1851,7 +1922,7 @@ private:
            case OpCode::Id::ISCADD_R:
            case OpCode::Id::ISCADD_IMM: {
                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
-                                     "ISCADD Generates an unhandled Control Code");
+                                     "Condition codes generation in ISCADD is not implemented");
                if (instr.alu_integer.negate_a)
                    op_a = "-(" + op_a + ')';
@@ -1886,7 +1957,8 @@ private:
            case OpCode::Id::LOP_C:
            case OpCode::Id::LOP_R:
            case OpCode::Id::LOP_IMM: {
-                UNIMPLEMENTED_IF_MSG(instr.generates_cc, "LOP Generates an unhandled Control Code");
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in LOP is not implemented");
                if (instr.alu.lop.invert_a)
                    op_a = "~(" + op_a + ')';
@@ -1902,7 +1974,7 @@ private:
            case OpCode::Id::LOP3_R:
            case OpCode::Id::LOP3_IMM: {
                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
-                                     "LOP3 Generates an unhandled Control Code");
+                                     "Condition codes generation in LOP3 is not implemented");
                const std::string op_c = regs.GetRegisterAsInteger(instr.gpr39);
                std::string lut;
@@ -1921,7 +1993,7 @@ private:
            case OpCode::Id::IMNMX_IMM: {
                UNIMPLEMENTED_IF(instr.imnmx.exchange != Tegra::Shader::IMinMaxExchange::None);
                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
-                                     "IMNMX Generates an unhandled Control Code");
+                                     "Condition codes generation in IMNMX is not implemented");
                const std::string condition =
                    GetPredicateCondition(instr.imnmx.pred, instr.imnmx.negate_pred != 0);
@@ -2094,7 +2166,8 @@ private:
                instr.ffma.tab5980_0.Value()); // Seems to be 1 by default based on SMO
            UNIMPLEMENTED_IF_MSG(instr.ffma.tab5980_1 != 0, "FFMA tab5980_1({}) not implemented",
                                 instr.ffma.tab5980_1.Value());
-            UNIMPLEMENTED_IF_MSG(instr.generates_cc, "FFMA Generates an unhandled Control Code");
+            UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                 "Condition codes generation in FFMA is not implemented");
            switch (opcode->get().GetId()) {
            case OpCode::Id::FFMA_CR: {
@@ -2204,7 +2277,8 @@ private:
            case OpCode::Id::I2F_C: {
                UNIMPLEMENTED_IF(instr.conversion.dest_size != Register::Size::Word);
                UNIMPLEMENTED_IF(instr.conversion.selector);
-                UNIMPLEMENTED_IF_MSG(instr.generates_cc, "I2F Generates an unhandled Control Code");
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in I2F is not implemented");
                std::string op_a{};
@@ -2234,7 +2308,8 @@ private:
            case OpCode::Id::F2F_R: {
                UNIMPLEMENTED_IF(instr.conversion.dest_size != Register::Size::Word);
                UNIMPLEMENTED_IF(instr.conversion.src_size != Register::Size::Word);
-                UNIMPLEMENTED_IF_MSG(instr.generates_cc, "F2F Generates an unhandled Control Code");
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in F2F is not implemented");
                std::string op_a = regs.GetRegisterAsFloat(instr.gpr20);
                if (instr.conversion.abs_a) {
@@ -2272,7 +2347,8 @@ private:
            case OpCode::Id::F2I_R:
            case OpCode::Id::F2I_C: {
                UNIMPLEMENTED_IF(instr.conversion.src_size != Register::Size::Word);
-                UNIMPLEMENTED_IF_MSG(instr.generates_cc, "F2I Generates an unhandled Control Code");
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in F2I is not implemented");
                std::string op_a{};
                if (instr.is_b_gpr) {
@@ -2491,61 +2567,83 @@ private:
                const bool depth_compare =
                    instr.tex.UsesMiscMode(Tegra::Shader::TextureMiscMode::DC);
                u32 num_coordinates = TextureCoordinates(texture_type);
-                if (depth_compare)
+                u32 start_index = 0;
-                    num_coordinates += 1;
+                std::string array_elem;
+                if (is_array) {
+                    array_elem = regs.GetRegisterAsInteger(instr.gpr8);
+                    start_index = 1;
+                }
+                const auto process_mode = instr.tex.GetTextureProcessMode();
+                u32 start_index_b = 0;
+                std::string lod_value;
+                if (process_mode != Tegra::Shader::TextureProcessMode::LZ &&
+                    process_mode != Tegra::Shader::TextureProcessMode::None) {
+                    start_index_b = 1;
+                    lod_value = regs.GetRegisterAsFloat(instr.gpr20);
+                }
+                std::string depth_value;
+                if (depth_compare) {
+                    depth_value = regs.GetRegisterAsFloat(instr.gpr20.Value() + start_index_b);
+                }
+                bool depth_compare_extra = false;
                switch (num_coordinates) {
                case 1: {
+                    const std::string x = regs.GetRegisterAsFloat(instr.gpr8.Value() + start_index);
                    if (is_array) {
-                        const std::string index = regs.GetRegisterAsInteger(instr.gpr8);
+                        if (depth_compare) {
-                        const std::string x = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                            coord = "vec3 coords = vec3(" + x + ", " + depth_value + ", " +
-                        coord = "vec2 coords = vec2(" + x + ", " + index + ");";
+                                    array_elem + ");";
+                        } else {
+                            coord = "vec2 coords = vec2(" + x + ", " + array_elem + ");";
+                        }
                    } else {
-                        const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
+                        if (depth_compare) {
-                        coord = "float coords = " + x + ';';
+                            coord = "vec2 coords = vec2(" + x + ", " + depth_value + ");";
+                        } else {
+                            coord = "float coords = " + x + ';';
+                        }
                    }
                    break;
                }
                case 2: {
+                    const std::string x = regs.GetRegisterAsFloat(instr.gpr8.Value() + start_index);
+                    const std::string y =
+                        regs.GetRegisterAsFloat(instr.gpr8.Value() + start_index + 1);
                    if (is_array) {
-                        const std::string index = regs.GetRegisterAsInteger(instr.gpr8);
+                        if (depth_compare) {
-                        const std::string x = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                            coord = "vec4 coords = vec4(" + x + ", " + y + ", " + depth_value +
-                        const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 2);
+                                    ", " + array_elem + ");";
-                        coord = "vec3 coords = vec3(" + x + ", " + y + ", " + index + ");";
+                        } else {
+                            coord = "vec3 coords = vec3(" + x + ", " + y + ", " + array_elem + ");";
+                        }
                    } else {
-                        const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
+                        if (depth_compare) {
-                        const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                            coord =
-                        coord = "vec2 coords = vec2(" + x + ", " + y + ");";
+                                "vec3 coords = vec3(" + x + ", " + y + ", " + depth_value + ");";
+                        } else {
+                            coord = "vec2 coords = vec2(" + x + ", " + y + ");";
+                        }
                    }
                    break;
                }
                case 3: {
-                    if (depth_compare) {
+                    const std::string x = regs.GetRegisterAsFloat(instr.gpr8.Value() + start_index);
-                        if (is_array) {
+                    const std::string y =
-                            const std::string index = regs.GetRegisterAsInteger(instr.gpr8);
+                        regs.GetRegisterAsFloat(instr.gpr8.Value() + start_index + 1);
-                            const std::string x = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                    const std::string z =
-                            const std::string y = regs.GetRegisterAsFloat(instr.gpr20);
+                        regs.GetRegisterAsFloat(instr.gpr8.Value() + start_index + 2);
-                            const std::string z = regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
+                    if (is_array) {
-                            coord = "vec4 coords = vec4(" + x + ", " + y + ", " + z + ", " + index +
+                        depth_compare_extra = depth_compare;
-                                    ");";
+                        coord = "vec4 coords = vec4(" + x + ", " + y + ", " + z + ", " +
-                        } else {
+                                array_elem + ");";
-                            const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
-                            const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
-                            const std::string z = regs.GetRegisterAsFloat(instr.gpr20);
-                            coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
-                        }
                    } else {
-                        if (is_array) {
+                        if (depth_compare) {
-                            const std::string index = regs.GetRegisterAsInteger(instr.gpr8);
+                            coord = "vec4 coords = vec4(" + x + ", " + y + ", " + z + ", " +
-                            const std::string x = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                                    depth_value + ");";
-                            const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 2);
-                            const std::string z = regs.GetRegisterAsFloat(instr.gpr8.Value() + 3);
-                            coord = "vec4 coords = vec4(" + x + ", " + y + ", " + z + ", " + index +
-                                    ");";
                        } else {
-                            const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
-                            const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
-                            const std::string z = regs.GetRegisterAsFloat(instr.gpr8.Value() + 2);
                            coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
                        }
                    }
@@ -2561,79 +2659,88 @@ private:
                    coord = "vec2 coords = vec2(" + x + ", " + y + ");";
                    texture_type = Tegra::Shader::TextureType::Texture2D;
                }
-                // TODO: make sure coordinates are always indexed to gpr8 and gpr20 is always bias
-                // or lod.
-                std::string op_c;
                const std::string sampler =
                    GetSampler(instr.sampler, texture_type, is_array, depth_compare);
                // Add an extra scope and declare the texture coords inside to prevent
                // overwriting them in case they are used as outputs of the texs instruction.
-                shader.AddLine("{");
+                shader.AddLine('{');
                ++shader.scope;
                shader.AddLine(coord);
                std::string texture;
                switch (instr.tex.GetTextureProcessMode()) {
                case Tegra::Shader::TextureProcessMode::None: {
-                    texture = "texture(" + sampler + ", coords)";
+                    if (!depth_compare_extra) {
+                        texture = "texture(" + sampler + ", coords)";
+                    } else {
+                        texture = "texture(" + sampler + ", coords, " + depth_value + ')';
+                    }
                    break;
                }
                case Tegra::Shader::TextureProcessMode::LZ: {
-                    texture = "textureLod(" + sampler + ", coords, 0.0)";
+                    if (!depth_compare_extra) {
+                        texture = "textureLod(" + sampler + ", coords, 0.0)";
+                    } else {
+                        texture = "texture(" + sampler + ", coords, " + depth_value + ')';
+                    }
                    break;
                }
                case Tegra::Shader::TextureProcessMode::LB:
                case Tegra::Shader::TextureProcessMode::LBA: {
-                    if (depth_compare) {
+                    // TODO: Figure if A suffix changes the equation at all.
-                        if (is_array)
+                    if (!depth_compare_extra) {
-                            op_c = regs.GetRegisterAsFloat(instr.gpr20.Value() + 2);
+                        texture = "texture(" + sampler + ", coords, " + lod_value + ')';
-                        else
-                            op_c = regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
                    } else {
-                        op_c = regs.GetRegisterAsFloat(instr.gpr20);
+                        texture = "texture(" + sampler + ", coords, " + depth_value + ')';
+                        LOG_WARNING(HW_GPU,
+                                    "OpenGL Limitation: can't set bias value along depth compare");
                    }
-                    // TODO: Figure if A suffix changes the equation at all.
-                    texture = "texture(" + sampler + ", coords, " + op_c + ')';
                    break;
                }
                case Tegra::Shader::TextureProcessMode::LL:
                case Tegra::Shader::TextureProcessMode::LLA: {
-                    if (num_coordinates <= 2) {
+                    // TODO: Figure if A suffix changes the equation at all.
-                        op_c = regs.GetRegisterAsFloat(instr.gpr20);
+                    if (!depth_compare_extra) {
+                        texture = "textureLod(" + sampler + ", coords, " + lod_value + ')';
                    } else {
-                        op_c = regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
+                        texture = "texture(" + sampler + ", coords, " + depth_value + ')';
+                        LOG_WARNING(HW_GPU,
+                                    "OpenGL Limitation: can't set lod value along depth compare");
                    }
-                    // TODO: Figure if A suffix changes the equation at all.
-                    texture = "textureLod(" + sampler + ", coords, " + op_c + ')';
                    break;
                }
                default: {
-                    texture = "texture(" + sampler + ", coords)";
+                    if (!depth_compare_extra) {
+                        texture = "texture(" + sampler + ", coords)";
+                    } else {
+                        texture = "texture(" + sampler + ", coords, " + depth_value + ')';
+                    }
                    UNIMPLEMENTED_MSG("Unhandled texture process mode {}",
                                      static_cast<u32>(instr.tex.GetTextureProcessMode()));
                }
                }
                if (!depth_compare) {
+                    shader.AddLine("vec4 texture_tmp = " + texture + ';');
                    std::size_t dest_elem{};
                    for (std::size_t elem = 0; elem < 4; ++elem) {
                        if (!instr.tex.IsComponentEnabled(elem)) {
                            // Skip disabled components
                            continue;
                        }
-                        regs.SetRegisterToFloat(instr.gpr0, elem, texture, 1, 4, false, dest_elem);
+                        regs.SetRegisterToFloat(instr.gpr0, elem, "texture_tmp", 1, 4, false,
+                                                dest_elem);
                        ++dest_elem;
                    }
                } else {
                    regs.SetRegisterToFloat(instr.gpr0, 0, texture, 1, 1, false);
                }
                --shader.scope;
-                shader.AddLine("}");
+                shader.AddLine('}');
                break;
            }
            case OpCode::Id::TEXS: {
-                std::string coord;
                Tegra::Shader::TextureType texture_type{instr.texs.GetTextureType()};
                bool is_array{instr.texs.IsArrayTexture()};
@@ -2643,37 +2750,76 @@ private:
                const bool depth_compare =
                    instr.texs.UsesMiscMode(Tegra::Shader::TextureMiscMode::DC);
                u32 num_coordinates = TextureCoordinates(texture_type);
-                if (depth_compare)
+                const auto process_mode = instr.texs.GetTextureProcessMode();
-                    num_coordinates += 1;
+                std::string lod_value;
+                std::string coord;
+                u32 lod_offset = 0;
+                if (process_mode == Tegra::Shader::TextureProcessMode::LL) {
+                    if (num_coordinates > 2) {
+                        lod_value = regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
+                        lod_offset = 2;
+                    } else {
+                        lod_value = regs.GetRegisterAsFloat(instr.gpr20);
+                        lod_offset = 1;
+                    }
+                }
                switch (num_coordinates) {
+                case 1: {
+                    coord = "float coords = " + regs.GetRegisterAsFloat(instr.gpr8) + ';';
+                    break;
+                }
                case 2: {
                    if (is_array) {
-                        const std::string index = regs.GetRegisterAsInteger(instr.gpr8);
+                        if (depth_compare) {
-                        const std::string x = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                            const std::string index = regs.GetRegisterAsInteger(instr.gpr8);
-                        const std::string y = regs.GetRegisterAsFloat(instr.gpr20);
+                            const std::string x = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
-                        coord = "vec3 coords = vec3(" + x + ", " + y + ", " + index + ");";
+                            const std::string y = regs.GetRegisterAsFloat(instr.gpr20);
+                            const std::string z = regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
+                            coord = "vec4 coords = vec4(" + x + ", " + y + ", " + z + ", " + index +
+                                    ");";
+                        } else {
+                            const std::string index = regs.GetRegisterAsInteger(instr.gpr8);
+                            const std::string x = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                            const std::string y = regs.GetRegisterAsFloat(instr.gpr20);
+                            coord = "vec3 coords = vec3(" + x + ", " + y + ", " + index + ");";
+                        }
                    } else {
-                        const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
+                        if (lod_offset != 0) {
-                        const std::string y = regs.GetRegisterAsFloat(instr.gpr20);
+                            if (depth_compare) {
-                        coord = "vec2 coords = vec2(" + x + ", " + y + ");";
+                                const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
+                                const std::string y =
+                                    regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                                const std::string z =
+                                    regs.GetRegisterAsFloat(instr.gpr20.Value() + lod_offset);
+                                coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
+                            } else {
+                                const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
+                                const std::string y =
+                                    regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                                coord = "vec2 coords = vec2(" + x + ", " + y + ");";
+                            }
+                        } else {
+                            if (depth_compare) {
+                                const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
+                                const std::string y =
+                                    regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                                const std::string z = regs.GetRegisterAsFloat(instr.gpr20);
+                                coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
+                            } else {
+                                const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
+                                const std::string y = regs.GetRegisterAsFloat(instr.gpr20);
+                                coord = "vec2 coords = vec2(" + x + ", " + y + ");";
+                            }
+                        }
                    }
                    break;
                }
                case 3: {
-                    if (is_array) {
+                    const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
-                        const std::string index = regs.GetRegisterAsInteger(instr.gpr8);
+                    const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
-                        const std::string x = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                    const std::string z = regs.GetRegisterAsFloat(instr.gpr20);
-                        const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 2);
+                    coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
-                        const std::string z = regs.GetRegisterAsFloat(instr.gpr20);
-                        coord =
-                            "vec4 coords = vec4(" + x + ", " + y + ", " + z + ", " + index + ");";
-                    } else {
-                        const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
-                        const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
-                        const std::string z = regs.GetRegisterAsFloat(instr.gpr20);
-                        coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
-                    }
                    break;
                }
                default:
@@ -2690,7 +2836,7 @@ private:
                const std::string sampler =
                    GetSampler(instr.sampler, texture_type, is_array, depth_compare);
                std::string texture;
-                switch (instr.texs.GetTextureProcessMode()) {
+                switch (process_mode) {
                case Tegra::Shader::TextureProcessMode::None: {
                    texture = "texture(" + sampler + ", coords)";
                    break;
@@ -2704,8 +2850,7 @@ private:
                    break;
                }
                case Tegra::Shader::TextureProcessMode::LL: {
-                    const std::string op_c = regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
+                    texture = "textureLod(" + sampler + ", coords, " + lod_value + ')';
-                    texture = "textureLod(" + sampler + ", coords, " + op_c + ')';
                    break;
                }
                default: {
@@ -2719,10 +2864,10 @@ private:
                } else {
                    WriteTexsInstruction(instr, coord, "vec4(" + texture + ')');
                }
                break;
            }
            case OpCode::Id::TLDS: {
-                std::string coord;
                const Tegra::Shader::TextureType texture_type{instr.tlds.GetTextureType()};
                const bool is_array{instr.tlds.IsArrayTexture()};
@@ -2736,12 +2881,17 @@ private:
                UNIMPLEMENTED_IF_MSG(instr.tlds.UsesMiscMode(Tegra::Shader::TextureMiscMode::MZ),
                                     "MZ is not implemented");
-                u32 op_c_offset = 0;
+                u32 extra_op_offset = 0;
+                // Scope to avoid variable name overlaps.
+                shader.AddLine('{');
+                ++shader.scope;
+                std::string coords;
                switch (texture_type) {
                case Tegra::Shader::TextureType::Texture1D: {
                    const std::string x = regs.GetRegisterAsInteger(instr.gpr8);
-                    coord = "int coords = " + x + ';';
+                    coords = "float coords = " + x + ';';
                    break;
                }
                case Tegra::Shader::TextureType::Texture2D: {
@@ -2749,8 +2899,9 @@ private:
                    const std::string x = regs.GetRegisterAsInteger(instr.gpr8);
                    const std::string y = regs.GetRegisterAsInteger(instr.gpr20);
-                    coord = "ivec2 coords = ivec2(" + x + ", " + y + ");";
+                    // shader.AddLine("ivec2 coords = ivec2(" + x + ", " + y + ");");
-                    op_c_offset = 1;
+                    coords = "ivec2 coords = ivec2(" + x + ", " + y + ");";
+                    extra_op_offset = 1;
                    break;
                }
                default:
@@ -2765,9 +2916,10 @@ private:
                    break;
                }
                case Tegra::Shader::TextureProcessMode::LL: {
-                    const std::string op_c =
+                    shader.AddLine(
-                        regs.GetRegisterAsInteger(instr.gpr20.Value() + op_c_offset);
+                        "float lod = " +
-                    texture = "texelFetch(" + sampler + ", coords, " + op_c + ')';
+                        regs.GetRegisterAsInteger(instr.gpr20.Value() + extra_op_offset) + ';');
+                    texture = "texelFetch(" + sampler + ", coords, lod)";
                    break;
                }
                default: {
@@ -2776,7 +2928,10 @@ private:
                                      static_cast<u32>(instr.tlds.GetTextureProcessMode()));
                }
                }
-                WriteTexsInstruction(instr, coord, texture);
+                WriteTexsInstruction(instr, coords, texture);
+                --shader.scope;
+                shader.AddLine('}');
                break;
            }
            case OpCode::Id::TLD4: {
@@ -2799,18 +2954,23 @@ private:
                if (depth_compare)
                    num_coordinates += 1;
+                // Add an extra scope and declare the texture coords inside to prevent
+                // overwriting them in case they are used as outputs of the texs instruction.
+                shader.AddLine('{');
+                ++shader.scope;
                switch (num_coordinates) {
                case 2: {
                    const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
                    const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
-                    coord = "vec2 coords = vec2(" + x + ", " + y + ");";
+                    shader.AddLine("vec2 coords = vec2(" + x + ", " + y + ");");
                    break;
                }
                case 3: {
                    const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
                    const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
                    const std::string z = regs.GetRegisterAsFloat(instr.gpr8.Value() + 2);
-                    coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
+                    shader.AddLine("vec3 coords = vec3(" + x + ", " + y + ", " + z + ");");
                    break;
                }
                default:
@@ -2818,34 +2978,33 @@ private:
                                      static_cast<u32>(num_coordinates));
                    const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
                    const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
-                    coord = "vec2 coords = vec2(" + x + ", " + y + ");";
+                    shader.AddLine("vec2 coords = vec2(" + x + ", " + y + ");");
                    texture_type = Tegra::Shader::TextureType::Texture2D;
                }
                const std::string sampler =
                    GetSampler(instr.sampler, texture_type, false, depth_compare);
-                // Add an extra scope and declare the texture coords inside to prevent
-                // overwriting them in case they are used as outputs of the texs instruction.
-                shader.AddLine("{");
-                ++shader.scope;
-                shader.AddLine(coord);
                const std::string texture = "textureGather(" + sampler + ", coords, " +
                                            std::to_string(instr.tld4.component) + ')';
                if (!depth_compare) {
+                    shader.AddLine("vec4 texture_tmp = " + texture + ';');
                    std::size_t dest_elem{};
                    for (std::size_t elem = 0; elem < 4; ++elem) {
                        if (!instr.tex.IsComponentEnabled(elem)) {
                            // Skip disabled components
                            continue;
                        }
-                        regs.SetRegisterToFloat(instr.gpr0, elem, texture, 1, 4, false, dest_elem);
+                        regs.SetRegisterToFloat(instr.gpr0, elem, "texture_tmp", 1, 4, false,
+                                                dest_elem);
                        ++dest_elem;
                    }
                } else {
                    regs.SetRegisterToFloat(instr.gpr0, 0, texture, 1, 1, false);
                }
                --shader.scope;
-                shader.AddLine("}");
+                shader.AddLine('}');
                break;
            }
            case OpCode::Id::TLD4S: {
@@ -2856,6 +3015,11 @@ private:
                    instr.tld4s.UsesMiscMode(Tegra::Shader::TextureMiscMode::AOFFI),
                    "AOFFI is not implemented");
+                // Scope to avoid variable name overlaps.
+                shader.AddLine('{');
+                ++shader.scope;
+                std::string coords;
                const bool depth_compare =
                    instr.tld4s.UsesMiscMode(Tegra::Shader::TextureMiscMode::DC);
                const std::string op_a = regs.GetRegisterAsFloat(instr.gpr8);
@@ -2863,28 +3027,32 @@ private:
                // TODO(Subv): Figure out how the sampler type is encoded in the TLD4S instruction.
                const std::string sampler = GetSampler(
                    instr.sampler, Tegra::Shader::TextureType::Texture2D, false, depth_compare);
-                std::string coord;
                if (!depth_compare) {
-                    coord = "vec2 coords = vec2(" + op_a + ", " + op_b + ");";
+                    coords = "vec2 coords = vec2(" + op_a + ", " + op_b + ");";
                } else {
                    // Note: TLD4S coordinate encoding works just like TEXS's
-                    const std::string op_c = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                    const std::string op_y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
-                    coord = "vec3 coords = vec3(" + op_a + ", " + op_c + ", " + op_b + ");";
+                    coords = "vec3 coords = vec3(" + op_a + ", " + op_y + ", " + op_b + ");";
                }
                const std::string texture = "textureGather(" + sampler + ", coords, " +
                                            std::to_string(instr.tld4s.component) + ')';
                if (!depth_compare) {
-                    WriteTexsInstruction(instr, coord, texture);
+                    WriteTexsInstruction(instr, coords, texture);
                } else {
-                    WriteTexsInstruction(instr, coord, "vec4(" + texture + ')');
+                    WriteTexsInstruction(instr, coords, "vec4(" + texture + ')');
                }
+                --shader.scope;
+                shader.AddLine('}');
                break;
            }
            case OpCode::Id::TXQ: {
                UNIMPLEMENTED_IF_MSG(instr.txq.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
                                     "NODEP is not implemented");
+                ++shader.scope;
+                shader.AddLine('{');
                // TODO: the new commits on the texture refactor, change the way samplers work.
                // Sadly, not all texture instructions specify the type of texture their sampler
                // uses. This must be fixed at a later instance.
@@ -2892,8 +3060,14 @@ private:
                    GetSampler(instr.sampler, Tegra::Shader::TextureType::Texture2D, false, false);
                switch (instr.txq.query_type) {
                case Tegra::Shader::TextureQueryType::Dimension: {
-                    const std::string texture = "textureQueryLevels(" + sampler + ')';
+                    const std::string texture = "textureSize(" + sampler + ", " +
-                    regs.SetRegisterToInteger(instr.gpr0, true, 0, texture, 1, 1);
+                                                regs.GetRegisterAsInteger(instr.gpr8) + ')';
+                    const std::string mip_level = "textureQueryLevels(" + sampler + ')';
+                    shader.AddLine("ivec2 sizes = " + texture + ';');
+                    regs.SetRegisterToInteger(instr.gpr0, true, 0, "sizes.x", 1, 1);
+                    regs.SetRegisterToInteger(instr.gpr0.Value() + 1, true, 0, "sizes.y", 1, 1);
+                    regs.SetRegisterToInteger(instr.gpr0.Value() + 2, true, 0, "0", 1, 1);
+                    regs.SetRegisterToInteger(instr.gpr0.Value() + 3, true, 0, mip_level, 1, 1);
                    break;
                }
                default: {
@@ -2901,6 +3075,8 @@ private:
                                      static_cast<u32>(instr.txq.query_type.Value()));
                }
                }
+                --shader.scope;
+                shader.AddLine('}');
                break;
            }
            case OpCode::Id::TMML: {
@@ -3083,7 +3259,8 @@ private:
            break;
        }
        case OpCode::Type::PredicateSetRegister: {
-            UNIMPLEMENTED_IF_MSG(instr.generates_cc, "PSET Generates an unhandled Control Code");
+            UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                 "Condition codes generation in PSET is not implemented");
            const std::string op_a =
                GetPredicateCondition(instr.pset.pred12, instr.pset.neg_pred12 != 0);
@@ -3142,14 +3319,14 @@ private:
                const std::string pred =
                    GetPredicateCondition(instr.csetp.pred39, instr.csetp.neg_pred39 != 0);
                const std::string combiner = GetPredicateCombiner(instr.csetp.op);
-                const std::string control_code = regs.GetControlCode(instr.csetp.cc);
+                const std::string condition_code = regs.GetConditionCode(instr.csetp.cc);
                if (instr.csetp.pred3 != static_cast<u64>(Pred::UnusedIndex)) {
                    SetPredicate(instr.csetp.pred3,
-                                 '(' + control_code + ") " + combiner + " (" + pred + ')');
+                                 '(' + condition_code + ") " + combiner + " (" + pred + ')');
                }
                if (instr.csetp.pred0 != static_cast<u64>(Pred::UnusedIndex)) {
                    SetPredicate(instr.csetp.pred0,
-                                 "!(" + control_code + ") " + combiner + " (" + pred + ')');
+                                 "!(" + condition_code + ") " + combiner + " (" + pred + ')');
                }
                break;
            }
@@ -3159,6 +3336,34 @@ private:
            }
            break;
        }
+        case OpCode::Type::RegisterSetPredicate: {
+            UNIMPLEMENTED_IF(instr.r2p.mode != Tegra::Shader::R2pMode::Pr);
+            const std::string apply_mask = [&]() {
+                switch (opcode->get().GetId()) {
+                case OpCode::Id::R2P_IMM:
+                    return std::to_string(instr.r2p.immediate_mask);
+                default:
+                    UNREACHABLE();
+                }
+            }();
+            const std::string mask = '(' + regs.GetRegisterAsInteger(instr.gpr8, 0, false) +
+                                     " >> " + std::to_string(instr.r2p.byte) + ')';
+            constexpr u64 programmable_preds = 7;
+            for (u64 pred = 0; pred < programmable_preds; ++pred) {
+                const auto shift = std::to_string(1 << pred);
+                shader.AddLine("if ((" + apply_mask + " & " + shift + ") != 0) {");
+                ++shader.scope;
+                SetPredicate(pred, '(' + mask + " & " + shift + ") != 0");
+                --shader.scope;
+                shader.AddLine('}');
+            }
+            break;
+        }
        case OpCode::Type::FloatSet: {
            const std::string op_a = GetOperandAbsNeg(regs.GetRegisterAsFloat(instr.gpr8),
                                                      instr.fset.abs_a != 0, instr.fset.neg_a != 0);
@@ -3196,6 +3401,10 @@ private:
                regs.SetRegisterToInteger(instr.gpr0, false, 0, predicate + " ? 0xFFFFFFFF : 0", 1,
                                          1);
            }
+            if (instr.generates_cc.Value() != 0) {
+                regs.SetInternalFlag(InternalFlag::ZeroFlag, predicate);
+                LOG_WARNING(HW_GPU, "FSET Condition Code is incomplete");
+            }
            break;
        }
        case OpCode::Type::IntegerSet: {
@@ -3280,7 +3489,8 @@ private:
        case OpCode::Type::Xmad: {
            UNIMPLEMENTED_IF(instr.xmad.sign_a);
            UNIMPLEMENTED_IF(instr.xmad.sign_b);
-            UNIMPLEMENTED_IF_MSG(instr.generates_cc, "XMAD Generates an unhandled Control Code");
+            UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                 "Condition codes generation in XMAD is not implemented");
            std::string op_a{regs.GetRegisterAsInteger(instr.gpr8, 0, instr.xmad.sign_a)};
            std::string op_b;
@@ -3372,9 +3582,9 @@ private:
        default: {
            switch (opcode->get().GetId()) {
            case OpCode::Id::EXIT: {
-                const Tegra::Shader::ControlCode cc = instr.flow_control_code;
+                const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
-                UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ControlCode::T,
+                UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T,
-                                     "EXIT Control Code used: {}", static_cast<u32>(cc));
+                                     "EXIT condition code used: {}", static_cast<u32>(cc));
                if (stage == Maxwell3D::Regs::ShaderStage::Fragment) {
                    EmitFragmentOutputsWrite();
@@ -3406,9 +3616,9 @@ private:
            case OpCode::Id::KIL: {
                UNIMPLEMENTED_IF(instr.flow.cond != Tegra::Shader::FlowCondition::Always);
-                const Tegra::Shader::ControlCode cc = instr.flow_control_code;
+                const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
-                UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ControlCode::T,
+                UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T,
-                                     "KIL Control Code used: {}", static_cast<u32>(cc));
+                                     "KIL condition code used: {}", static_cast<u32>(cc));
                // Enclose "discard" in a conditional, so that GLSL compilation does not complain
                // about unexecuted instructions that may follow this.
@@ -3448,6 +3658,11 @@ private:
                    regs.SetRegisterToInteger(instr.gpr0, false, 0, "0u", 1, 1);
                    break;
                }
+                case Tegra::Shader::SystemVariable::Ydirection: {
+                    // Config pack's third value is Y_NEGATE's state.
+                    regs.SetRegisterToFloat(instr.gpr0, 0, "uintBitsToFloat(config_pack[2])", 1, 1);
+                    break;
+                }
                default: {
                    UNIMPLEMENTED_MSG("Unhandled system move: {}",
                                      static_cast<u32>(instr.sys20.Value()));
@@ -3470,12 +3685,18 @@ private:
                UNIMPLEMENTED_IF_MSG(instr.bra.constant_buffer != 0,
                                     "BRA with constant buffers are not implemented");
-                const Tegra::Shader::ControlCode cc = instr.flow_control_code;
+                const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
-                UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ControlCode::T,
-                                     "BRA Control Code used: {}", static_cast<u32>(cc));
                const u32 target = offset + instr.bra.GetBranchTarget();
-                shader.AddLine("{ jmp_to = " + std::to_string(target) + "u; break; }");
+                if (cc != Tegra::Shader::ConditionCode::T) {
+                    const std::string condition_code = regs.GetConditionCode(cc);
+                    shader.AddLine("if (" + condition_code + "){");
+                    shader.scope++;
+                    shader.AddLine("{ jmp_to = " + std::to_string(target) + "u; break; }");
+                    shader.scope--;
+                    shader.AddLine('}');
+                } else {
+                    shader.AddLine("{ jmp_to = " + std::to_string(target) + "u; break; }");
+                }
                break;
            }
            case OpCode::Id::IPA: {
@@ -3515,9 +3736,9 @@ private:
                break;
            }
            case OpCode::Id::SYNC: {
-                const Tegra::Shader::ControlCode cc = instr.flow_control_code;
+                const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
-                UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ControlCode::T,
+                UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T,
-                                     "SYNC Control Code used: {}", static_cast<u32>(cc));
+                                     "SYNC condition code used: {}", static_cast<u32>(cc));
                // The SYNC opcode jumps to the address previously set by the SSY opcode
                EmitPopFromFlowStack();
@@ -3525,10 +3746,10 @@ private:
            }
            case OpCode::Id::BRK: {
                // The BRK opcode jumps to the address previously set by the PBK opcode
-                const Tegra::Shader::ControlCode cc = instr.flow_control_code;
+                const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
-                if (cc != Tegra::Shader::ControlCode::T) {
+                UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T,
-                    UNIMPLEMENTED_MSG("BRK Control Code used: {}", static_cast<u32>(cc));
+                                     "BRK condition code used: {}", static_cast<u32>(cc));
-                }
                EmitPopFromFlowStack();
                break;
            }
@@ -3539,6 +3760,9 @@ private:
                break;
            }
            case OpCode::Id::VMAD: {
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in VMAD is not implemented");
                const bool result_signed = instr.video.signed_a == 1 || instr.video.signed_b == 1;
                const std::string op_a = GetVideoOperandA(instr);
                const std::string op_b = GetVideoOperandB(instr);
@@ -3558,10 +3782,6 @@ private:
                regs.SetRegisterToInteger(instr.gpr0, result_signed, 1, result, 1, 1,
                                          instr.vmad.saturate == 1, 0, Register::Size::Word,
                                          instr.vmad.cc);
-                if (instr.generates_cc) {
-                    UNIMPLEMENTED_MSG("VMAD Generates an unhandled Control Code");
-                }
                break;
            }
            case OpCode::Id::VSETP: {
@@ -3713,6 +3933,7 @@ private:
    Maxwell3D::Regs::ShaderStage stage;
    const std::string& suffix;
    u64 local_memory_size;
+    std::size_t shader_length;
    ShaderWriter shader;
    ShaderWriter declarations;
@@ -3731,9 +3952,10 @@ std::optional<ProgramResult> DecompileProgram(const ProgramCode& program_code, u
                                              Maxwell3D::Regs::ShaderStage stage,
                                              const std::string& suffix) {
    try {
-        const auto subroutines =
+        ControlFlowAnalyzer analyzer(program_code, main_offset, suffix);
-            ControlFlowAnalyzer(program_code, main_offset, suffix).GetSubroutines();
+        const auto subroutines = analyzer.GetSubroutines();
-        GLSLGenerator generator(subroutines, program_code, main_offset, stage, suffix);
+        GLSLGenerator generator(subroutines, program_code, main_offset, stage, suffix,
+                                analyzer.GetShaderLength());
        return ProgramResult{generator.GetShaderCode(), generator.GetEntries()};
    } catch (const DecompileFail& exception) {
        LOG_ERROR(HW_GPU, "Shader decompilation failed: {}", exception.what());
diff --git a/src/video_core/renderer_opengl/gl_shader_gen.cpp b/src/video_core/renderer_opengl/gl_shader_gen.cpp
index eea090e52..23ed91e27 100644
--- a/src/video_core/renderer_opengl/gl_shader_gen.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_gen.cpp
@@ -24,8 +24,7 @@ layout (location = 0) out vec4 position;
 layout(std140) uniform vs_config {
    vec4 viewport_flip;
-    uvec4 instance_id;
+    uvec4 config_pack; // instance_id, flip_stage, y_direction, padding
-    uvec4 flip_stage;
    uvec4 alpha_test;
 };
 )";
@@ -63,7 +62,8 @@ void main() {
    out += R"(
    // Check if the flip stage is VertexB
-    if (flip_stage[0] == 1) {
+    // Config pack's second value is flip_stage
+    if (config_pack[1] == 1) {
        // Viewport can be flipped, which is unsupported by glViewport
        position.xy *= viewport_flip.xy;
    }
@@ -71,7 +71,7 @@ void main() {
    // TODO(bunnei): This is likely a hack, position.w should be interpolated as 1.0
    // For now, this is here to bring order in lieu of proper emulation
-    if (flip_stage[0] == 1) {
+    if (config_pack[1] == 1) {
        position.w = 1.0;
    }
 }
@@ -101,8 +101,7 @@ layout (location = 0) out vec4 position;
 layout (std140) uniform gs_config {
    vec4 viewport_flip;
-    uvec4 instance_id;
+    uvec4 config_pack; // instance_id, flip_stage, y_direction, padding
-    uvec4 flip_stage;
    uvec4 alpha_test;
 };
@@ -139,8 +138,7 @@ layout (location = 0) in vec4 position;
 layout (std140) uniform fs_config {
    vec4 viewport_flip;
-    uvec4 instance_id;
+    uvec4 config_pack; // instance_id, flip_stage, y_direction, padding
-    uvec4 flip_stage;
    uvec4 alpha_test;
 };
diff --git a/src/video_core/renderer_opengl/gl_shader_gen.h b/src/video_core/renderer_opengl/gl_shader_gen.h
index 520b9d4e3..b425d98ae 100644
--- a/src/video_core/renderer_opengl/gl_shader_gen.h
+++ b/src/video_core/renderer_opengl/gl_shader_gen.h
@@ -163,6 +163,7 @@ private:
 struct ShaderEntries {
    std::vector<ConstBufferEntry> const_buffer_entries;
    std::vector<SamplerEntry> texture_samplers;
+    std::size_t shader_length;
 };
 using ProgramResult = std::pair<std::string, ShaderEntries>;
diff --git a/src/video_core/renderer_opengl/gl_shader_manager.cpp b/src/video_core/renderer_opengl/gl_shader_manager.cpp
index 8b8869ecb..6a30c28d2 100644
--- a/src/video_core/renderer_opengl/gl_shader_manager.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_manager.cpp
@@ -27,16 +27,18 @@ void MaxwellUniformData::SetFromRegs(const Maxwell3D::State::ShaderStageInfo& sh
    alpha_test.func = func;
    alpha_test.ref = regs.alpha_test_ref;
-    // We only assign the instance to the first component of the vector, the rest is just padding.
+    instance_id = state.current_instance;
-    instance_id[0] = state.current_instance;
    // Assign in which stage the position has to be flipped
    // (the last stage before the fragment shader).
    if (gpu.regs.shader_config[static_cast<u32>(Maxwell3D::Regs::ShaderProgram::Geometry)].enable) {
-        flip_stage[0] = static_cast<u32>(Maxwell3D::Regs::ShaderProgram::Geometry);
+        flip_stage = static_cast<u32>(Maxwell3D::Regs::ShaderProgram::Geometry);
    } else {
-        flip_stage[0] = static_cast<u32>(Maxwell3D::Regs::ShaderProgram::VertexB);
+        flip_stage = static_cast<u32>(Maxwell3D::Regs::ShaderProgram::VertexB);
    }
+    // Y_NEGATE controls what value S2R returns for the Y_DIRECTION system value.
+    y_direction = regs.screen_y_control.y_negate == 0 ? 1.f : -1.f;
 }
 } // namespace OpenGL::GLShader
diff --git a/src/video_core/renderer_opengl/gl_shader_manager.h b/src/video_core/renderer_opengl/gl_shader_manager.h
index 9a5d7e289..b757f5f44 100644
--- a/src/video_core/renderer_opengl/gl_shader_manager.h
+++ b/src/video_core/renderer_opengl/gl_shader_manager.h
@@ -21,8 +21,11 @@ using Tegra::Engines::Maxwell3D;
 struct MaxwellUniformData {
    void SetFromRegs(const Maxwell3D::State::ShaderStageInfo& shader_stage);
    alignas(16) GLvec4 viewport_flip;
-    alignas(16) GLuvec4 instance_id;
+    struct alignas(16) {
-    alignas(16) GLuvec4 flip_stage;
+        GLuint instance_id;
+        GLuint flip_stage;
+        GLfloat y_direction;
+    };
    struct alignas(16) {
        GLuint enabled;
        GLuint func;
@@ -30,7 +33,7 @@ struct MaxwellUniformData {
        GLuint padding;
    } alpha_test;
 };
-static_assert(sizeof(MaxwellUniformData) == 64, "MaxwellUniformData structure size is incorrect");
+static_assert(sizeof(MaxwellUniformData) == 48, "MaxwellUniformData structure size is incorrect");
 static_assert(sizeof(MaxwellUniformData) < 16384,
              "MaxwellUniformData structure must be less than 16kb as per the OpenGL spec");
diff --git a/src/video_core/renderer_opengl/gl_state.cpp b/src/video_core/renderer_opengl/gl_state.cpp
index d9910c6e8..dc0a5ed5e 100644
--- a/src/video_core/renderer_opengl/gl_state.cpp
+++ b/src/video_core/renderer_opengl/gl_state.cpp
@@ -92,6 +92,14 @@ OpenGLState::OpenGLState() {
    point.size = 1;
    fragment_color_clamp.enabled = false;
+    depth_clamp.far_plane = false;
+    depth_clamp.near_plane = false;
+    polygon_offset.fill_enable = false;
+    polygon_offset.line_enable = false;
+    polygon_offset.point_enable = false;
+    polygon_offset.factor = 0.0f;
+    polygon_offset.units = 0.0f;
+    polygon_offset.clamp = 0.0f;
 }
 void OpenGLState::ApplyDefaultState() {
@@ -140,7 +148,7 @@ void OpenGLState::ApplyCulling() const {
 }
 void OpenGLState::ApplyColorMask() const {
-    if (GLAD_GL_ARB_viewport_array && independant_blend.enabled) {
+    if (independant_blend.enabled) {
        for (size_t i = 0; i < Tegra::Engines::Maxwell3D::Regs::NumRenderTargets; i++) {
            const auto& updated = color_mask[i];
            const auto& current = cur_state.color_mask[i];
@@ -233,16 +241,40 @@ void OpenGLState::ApplyStencilTest() const {
        config_stencil(GL_BACK, stencil.back, cur_state.stencil.back);
    }
 }
+// Viewport does not affects glClearBuffer so emulate viewport using scissor test
+void OpenGLState::EmulateViewportWithScissor() {
+    auto& current = viewports[0];
+    if (current.scissor.enabled) {
+        const GLint left = std::max(current.x, current.scissor.x);
+        const GLint right =
+            std::max(current.x + current.width, current.scissor.x + current.scissor.width);
+        const GLint bottom = std::max(current.y, current.scissor.y);
+        const GLint top =
+            std::max(current.y + current.height, current.scissor.y + current.scissor.height);
+        current.scissor.x = std::max(left, 0);
+        current.scissor.y = std::max(bottom, 0);
+        current.scissor.width = std::max(right - left, 0);
+        current.scissor.height = std::max(top - bottom, 0);
+    } else {
+        current.scissor.enabled = true;
+        current.scissor.x = current.x;
+        current.scissor.y = current.y;
+        current.scissor.width = current.width;
+        current.scissor.height = current.height;
+    }
+}
 void OpenGLState::ApplyViewport() const {
-    if (GLAD_GL_ARB_viewport_array && geometry_shaders.enabled) {
+    if (geometry_shaders.enabled) {
        for (GLuint i = 0; i < static_cast<GLuint>(Tegra::Engines::Maxwell3D::Regs::NumViewports);
             i++) {
            const auto& current = cur_state.viewports[i];
            const auto& updated = viewports[i];
            if (updated.x != current.x || updated.y != current.y ||
                updated.width != current.width || updated.height != current.height) {
-                glViewportIndexedf(i, updated.x, updated.y, updated.width, updated.height);
+                glViewportIndexedf(
+                    i, static_cast<GLfloat>(updated.x), static_cast<GLfloat>(updated.y),
+                    static_cast<GLfloat>(updated.width), static_cast<GLfloat>(updated.height));
            }
            if (updated.depth_range_near != current.depth_range_near ||
                updated.depth_range_far != current.depth_range_far) {
@@ -270,8 +302,7 @@ void OpenGLState::ApplyViewport() const {
        const auto& updated = viewports[0];
        if (updated.x != current.x || updated.y != current.y || updated.width != current.width ||
            updated.height != current.height) {
-            glViewport(static_cast<GLint>(updated.x), static_cast<GLint>(updated.y),
+            glViewport(updated.x, updated.y, updated.width, updated.height);
-                       static_cast<GLsizei>(updated.width), static_cast<GLsizei>(updated.height));
        }
        if (updated.depth_range_near != current.depth_range_near ||
            updated.depth_range_far != current.depth_range_far) {
@@ -339,14 +370,14 @@ void OpenGLState::ApplyTargetBlending(std::size_t target, bool force) const {
    if (blend_changed || updated.src_rgb_func != current.src_rgb_func ||
        updated.dst_rgb_func != current.dst_rgb_func || updated.src_a_func != current.src_a_func ||
        updated.dst_a_func != current.dst_a_func) {
-        glBlendFuncSeparateiARB(static_cast<GLuint>(target), updated.src_rgb_func,
+        glBlendFuncSeparatei(static_cast<GLuint>(target), updated.src_rgb_func,
-                                updated.dst_rgb_func, updated.src_a_func, updated.dst_a_func);
+                             updated.dst_rgb_func, updated.src_a_func, updated.dst_a_func);
    }
    if (blend_changed || updated.rgb_equation != current.rgb_equation ||
        updated.a_equation != current.a_equation) {
-        glBlendEquationSeparateiARB(static_cast<GLuint>(target), updated.rgb_equation,
+        glBlendEquationSeparatei(static_cast<GLuint>(target), updated.rgb_equation,
-                                    updated.a_equation);
+                                 updated.a_equation);
    }
 }
@@ -383,6 +414,55 @@ void OpenGLState::ApplyLogicOp() const {
    }
 }
+void OpenGLState::ApplyPolygonOffset() const {
+    const bool fill_enable_changed =
+        polygon_offset.fill_enable != cur_state.polygon_offset.fill_enable;
+    const bool line_enable_changed =
+        polygon_offset.line_enable != cur_state.polygon_offset.line_enable;
+    const bool point_enable_changed =
+        polygon_offset.point_enable != cur_state.polygon_offset.point_enable;
+    const bool factor_changed = polygon_offset.factor != cur_state.polygon_offset.factor;
+    const bool units_changed = polygon_offset.units != cur_state.polygon_offset.units;
+    const bool clamp_changed = polygon_offset.clamp != cur_state.polygon_offset.clamp;
+    if (fill_enable_changed) {
+        if (polygon_offset.fill_enable) {
+            glEnable(GL_POLYGON_OFFSET_FILL);
+        } else {
+            glDisable(GL_POLYGON_OFFSET_FILL);
+        }
+    }
+    if (line_enable_changed) {
+        if (polygon_offset.line_enable) {
+            glEnable(GL_POLYGON_OFFSET_LINE);
+        } else {
+            glDisable(GL_POLYGON_OFFSET_LINE);
+        }
+    }
+    if (point_enable_changed) {
+        if (polygon_offset.point_enable) {
+            glEnable(GL_POLYGON_OFFSET_POINT);
+        } else {
+            glDisable(GL_POLYGON_OFFSET_POINT);
+        }
+    }
+    if ((polygon_offset.fill_enable || polygon_offset.line_enable || polygon_offset.point_enable) &&
+        (factor_changed || units_changed || clamp_changed)) {
+        if (GLAD_GL_EXT_polygon_offset_clamp && polygon_offset.clamp != 0) {
+            glPolygonOffsetClamp(polygon_offset.factor, polygon_offset.units, polygon_offset.clamp);
+        } else {
+            glPolygonOffset(polygon_offset.factor, polygon_offset.units);
+            UNIMPLEMENTED_IF_MSG(polygon_offset.clamp != 0,
+                                 "Unimplemented Depth polygon offset clamp.");
+        }
+    }
+}
 void OpenGLState::ApplyTextures() const {
    for (std::size_t i = 0; i < std::size(texture_units); ++i) {
        const auto& texture_unit = texture_units[i];
@@ -446,6 +526,21 @@ void OpenGLState::ApplyVertexBufferState() const {
    }
 }
+void OpenGLState::ApplyDepthClamp() const {
+    if (depth_clamp.far_plane == cur_state.depth_clamp.far_plane &&
+        depth_clamp.near_plane == cur_state.depth_clamp.near_plane) {
+        return;
+    }
+    if (depth_clamp.far_plane != depth_clamp.near_plane) {
+        UNIMPLEMENTED_MSG("Unimplemented Depth Clamp Separation!");
+    }
+    if (depth_clamp.far_plane || depth_clamp.near_plane) {
+        glEnable(GL_DEPTH_CLAMP);
+    } else {
+        glDisable(GL_DEPTH_CLAMP);
+    }
+}
 void OpenGLState::Apply() const {
    ApplyFramebufferState();
    ApplyVertexBufferState();
@@ -477,11 +572,9 @@ void OpenGLState::Apply() const {
    if (point.size != cur_state.point.size) {
        glPointSize(point.size);
    }
-    if (GLAD_GL_ARB_color_buffer_float) {
+    if (fragment_color_clamp.enabled != cur_state.fragment_color_clamp.enabled) {
-        if (fragment_color_clamp.enabled != cur_state.fragment_color_clamp.enabled) {
+        glClampColor(GL_CLAMP_FRAGMENT_COLOR_ARB,
-            glClampColor(GL_CLAMP_FRAGMENT_COLOR_ARB,
+                     fragment_color_clamp.enabled ? GL_TRUE : GL_FALSE);
-                         fragment_color_clamp.enabled ? GL_TRUE : GL_FALSE);
-        }
    }
    if (multisample_control.alpha_to_coverage != cur_state.multisample_control.alpha_to_coverage) {
        if (multisample_control.alpha_to_coverage) {
@@ -497,7 +590,7 @@ void OpenGLState::Apply() const {
            glDisable(GL_SAMPLE_ALPHA_TO_ONE);
        }
    }
+    ApplyDepthClamp();
    ApplyColorMask();
    ApplyViewport();
    ApplyStencilTest();
@@ -509,6 +602,7 @@ void OpenGLState::Apply() const {
    ApplyLogicOp();
    ApplyTextures();
    ApplySamplers();
+    ApplyPolygonOffset();
    cur_state = *this;
 }
diff --git a/src/video_core/renderer_opengl/gl_state.h b/src/video_core/renderer_opengl/gl_state.h
index bdc743b0f..439bfbc98 100644
--- a/src/video_core/renderer_opengl/gl_state.h
+++ b/src/video_core/renderer_opengl/gl_state.h
@@ -49,6 +49,11 @@ public:
    } fragment_color_clamp;
    struct {
+        bool far_plane;
+        bool near_plane;
+    } depth_clamp; // GL_DEPTH_CLAMP
+    struct {
        bool enabled; // viewports arrays are only supported when geometry shaders are enabled.
    } geometry_shaders;
@@ -156,10 +161,10 @@ public:
    } draw;
    struct viewport {
-        GLfloat x;
+        GLint x;
-        GLfloat y;
+        GLint y;
-        GLfloat width;
+        GLint width;
-        GLfloat height;
+        GLint height;
        GLfloat depth_range_near; // GL_DEPTH_RANGE
        GLfloat depth_range_far;  // GL_DEPTH_RANGE
        struct {
@@ -176,7 +181,16 @@ public:
        float size; // GL_POINT_SIZE
    } point;
-    std::array<bool, 2> clip_distance; // GL_CLIP_DISTANCE
+    struct {
+        bool point_enable;
+        bool line_enable;
+        bool fill_enable;
+        GLfloat units;
+        GLfloat factor;
+        GLfloat clamp;
+    } polygon_offset;
+    std::array<bool, 8> clip_distance; // GL_CLIP_DISTANCE
    OpenGLState();
@@ -206,6 +220,7 @@ public:
    OpenGLState& ResetBuffer(GLuint handle);
    OpenGLState& ResetVertexArray(GLuint handle);
    OpenGLState& ResetFramebuffer(GLuint handle);
+    void EmulateViewportWithScissor();
 private:
    static OpenGLState cur_state;
@@ -225,6 +240,8 @@ private:
    void ApplyLogicOp() const;
    void ApplyTextures() const;
    void ApplySamplers() const;
+    void ApplyDepthClamp() const;
+    void ApplyPolygonOffset() const;
 };
 } // namespace OpenGL
diff --git a/src/video_core/renderer_opengl/maxwell_to_gl.h b/src/video_core/renderer_opengl/maxwell_to_gl.h
index 065b3929c..a8833c06e 100644
--- a/src/video_core/renderer_opengl/maxwell_to_gl.h
+++ b/src/video_core/renderer_opengl/maxwell_to_gl.h
@@ -218,14 +218,19 @@ inline GLenum DepthCompareFunc(Tegra::Texture::DepthCompareFunc func) {
 inline GLenum BlendEquation(Maxwell::Blend::Equation equation) {
    switch (equation) {
    case Maxwell::Blend::Equation::Add:
+    case Maxwell::Blend::Equation::AddGL:
        return GL_FUNC_ADD;
    case Maxwell::Blend::Equation::Subtract:
+    case Maxwell::Blend::Equation::SubtractGL:
        return GL_FUNC_SUBTRACT;
    case Maxwell::Blend::Equation::ReverseSubtract:
+    case Maxwell::Blend::Equation::ReverseSubtractGL:
        return GL_FUNC_REVERSE_SUBTRACT;
    case Maxwell::Blend::Equation::Min:
+    case Maxwell::Blend::Equation::MinGL:
        return GL_MIN;
    case Maxwell::Blend::Equation::Max:
+    case Maxwell::Blend::Equation::MaxGL:
        return GL_MAX;
    }
    LOG_ERROR(Render_OpenGL, "Unimplemented blend equation={}", static_cast<u32>(equation));
diff --git a/src/video_core/renderer_opengl/renderer_opengl.cpp b/src/video_core/renderer_opengl/renderer_opengl.cpp
index 27b5b8960..4fd0d66c5 100644
--- a/src/video_core/renderer_opengl/renderer_opengl.cpp
+++ b/src/video_core/renderer_opengl/renderer_opengl.cpp
@@ -19,9 +19,9 @@
 #include "core/settings.h"
 #include "core/telemetry_session.h"
 #include "core/tracer/recorder.h"
+#include "video_core/morton.h"
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/renderer_opengl.h"
-#include "video_core/utils.h"
 namespace OpenGL {
@@ -490,7 +490,7 @@ bool RendererOpenGL::Init() {
    Core::Telemetry().AddField(Telemetry::FieldType::UserSystem, "GPU_Model", gpu_model);
    Core::Telemetry().AddField(Telemetry::FieldType::UserSystem, "GPU_OpenGL_Version", gl_version);
-    if (!GLAD_GL_VERSION_3_3) {
+    if (!GLAD_GL_VERSION_4_3) {
        return false;
    }
diff --git a/src/video_core/textures/decoders.cpp b/src/video_core/textures/decoders.cpp
index 7eabd34f1..bbae9285f 100644
--- a/src/video_core/textures/decoders.cpp
+++ b/src/video_core/textures/decoders.cpp
@@ -127,7 +127,8 @@ void FastProcessBlock(u8* const swizzled_data, u8* const unswizzled_data, const
 template <bool fast>
 void SwizzledData(u8* const swizzled_data, u8* const unswizzled_data, const bool unswizzle,
                  const u32 width, const u32 height, const u32 depth, const u32 bytes_per_pixel,
-                  const u32 out_bytes_per_pixel, const u32 block_height, const u32 block_depth) {
+                  const u32 out_bytes_per_pixel, const u32 block_height, const u32 block_depth,
+                  const u32 width_spacing) {
    auto div_ceil = [](const u32 x, const u32 y) { return ((x + y - 1) / y); };
    const u32 stride_x = width * out_bytes_per_pixel;
    const u32 layer_z = height * stride_x;
@@ -137,7 +138,8 @@ void SwizzledData(u8* const swizzled_data, u8* const unswizzled_data, const bool
    const u32 block_x_elements = gob_elements_x;
    const u32 block_y_elements = gob_elements_y * block_height;
    const u32 block_z_elements = gob_elements_z * block_depth;
-    const u32 blocks_on_x = div_ceil(width, block_x_elements);
+    const u32 aligned_width = Common::AlignUp(width, gob_elements_x * width_spacing);
+    const u32 blocks_on_x = div_ceil(aligned_width, block_x_elements);
    const u32 blocks_on_y = div_ceil(height, block_y_elements);
    const u32 blocks_on_z = div_ceil(depth, block_z_elements);
    const u32 xy_block_size = gob_size * block_height;
@@ -169,13 +171,15 @@ void SwizzledData(u8* const swizzled_data, u8* const unswizzled_data, const bool
 void CopySwizzledData(u32 width, u32 height, u32 depth, u32 bytes_per_pixel,
                      u32 out_bytes_per_pixel, u8* const swizzled_data, u8* const unswizzled_data,
-                      bool unswizzle, u32 block_height, u32 block_depth) {
+                      bool unswizzle, u32 block_height, u32 block_depth, u32 width_spacing) {
    if (bytes_per_pixel % 3 != 0 && (width * bytes_per_pixel) % fast_swizzle_align == 0) {
        SwizzledData<true>(swizzled_data, unswizzled_data, unswizzle, width, height, depth,
-                           bytes_per_pixel, out_bytes_per_pixel, block_height, block_depth);
+                           bytes_per_pixel, out_bytes_per_pixel, block_height, block_depth,
+                           width_spacing);
    } else {
        SwizzledData<false>(swizzled_data, unswizzled_data, unswizzle, width, height, depth,
-                            bytes_per_pixel, out_bytes_per_pixel, block_height, block_depth);
+                            bytes_per_pixel, out_bytes_per_pixel, block_height, block_depth,
+                            width_spacing);
    }
 }
@@ -228,19 +232,19 @@ u32 BytesPerPixel(TextureFormat format) {
 void UnswizzleTexture(u8* const unswizzled_data, VAddr address, u32 tile_size_x, u32 tile_size_y,
                      u32 bytes_per_pixel, u32 width, u32 height, u32 depth, u32 block_height,
-                      u32 block_depth) {
+                      u32 block_depth, u32 width_spacing) {
    CopySwizzledData((width + tile_size_x - 1) / tile_size_x,
                     (height + tile_size_y - 1) / tile_size_y, depth, bytes_per_pixel,
                     bytes_per_pixel, Memory::GetPointer(address), unswizzled_data, true,
-                     block_height, block_depth);
+                     block_height, block_depth, width_spacing);
 }
 std::vector<u8> UnswizzleTexture(VAddr address, u32 tile_size_x, u32 tile_size_y,
                                 u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
-                                 u32 block_height, u32 block_depth) {
+                                 u32 block_height, u32 block_depth, u32 width_spacing) {
    std::vector<u8> unswizzled_data(width * height * depth * bytes_per_pixel);
    UnswizzleTexture(unswizzled_data.data(), address, tile_size_x, tile_size_y, bytes_per_pixel,
-                     width, height, depth, block_height, block_depth);
+                     width, height, depth, block_height, block_depth, width_spacing);
    return unswizzled_data;
 }
diff --git a/src/video_core/textures/decoders.h b/src/video_core/textures/decoders.h
index f4ef7c73e..85b7e9f7b 100644
--- a/src/video_core/textures/decoders.h
+++ b/src/video_core/textures/decoders.h
@@ -22,19 +22,20 @@ inline std::size_t GetGOBSize() {
 void UnswizzleTexture(u8* unswizzled_data, VAddr address, u32 tile_size_x, u32 tile_size_y,
                      u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
                      u32 block_height = TICEntry::DefaultBlockHeight,
-                      u32 block_depth = TICEntry::DefaultBlockHeight);
+                      u32 block_depth = TICEntry::DefaultBlockHeight, u32 width_spacing = 0);
 /**
 * Unswizzles a swizzled texture without changing its format.
 */
 std::vector<u8> UnswizzleTexture(VAddr address, u32 tile_size_x, u32 tile_size_y,
                                 u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
                                 u32 block_height = TICEntry::DefaultBlockHeight,
-                                 u32 block_depth = TICEntry::DefaultBlockHeight);
+                                 u32 block_depth = TICEntry::DefaultBlockHeight,
+                                 u32 width_spacing = 0);
 /// Copies texture data from a buffer and performs swizzling/unswizzling as necessary.
 void CopySwizzledData(u32 width, u32 height, u32 depth, u32 bytes_per_pixel,
                      u32 out_bytes_per_pixel, u8* swizzled_data, u8* unswizzled_data,
-                      bool unswizzle, u32 block_height, u32 block_depth);
+                      bool unswizzle, u32 block_height, u32 block_depth, u32 width_spacing);
 /**
 * Decodes an unswizzled texture into a A8R8G8B8 texture.
diff --git a/src/video_core/textures/texture.h b/src/video_core/textures/texture.h
index ffa08f5c1..e7c78bee2 100644
--- a/src/video_core/textures/texture.h
+++ b/src/video_core/textures/texture.h
@@ -166,6 +166,8 @@ struct TICEntry {
        BitField<3, 3, u32> block_height;
        BitField<6, 3, u32> block_depth;
+        BitField<10, 3, u32> tile_width_spacing;
        // High 16 bits of the pitch value
        BitField<0, 16, u32> pitch_high;
        BitField<26, 1, u32> use_header_opt_control;
diff --git a/src/video_core/utils.h b/src/video_core/utils.h
deleted file mode 100644
index e0a14d48f..000000000
--- a/src/video_core/utils.h
+++ /dev/null
@@ -1,164 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-#pragma once
-#include "common/common_types.h"
-namespace VideoCore {
-// 8x8 Z-Order coordinate from 2D coordinates
-static inline u32 MortonInterleave(u32 x, u32 y) {
-    static const u32 xlut[] = {0x00, 0x01, 0x04, 0x05, 0x10, 0x11, 0x14, 0x15};
-    static const u32 ylut[] = {0x00, 0x02, 0x08, 0x0a, 0x20, 0x22, 0x28, 0x2a};
-    return xlut[x % 8] + ylut[y % 8];
-}
-/**
- * Calculates the offset of the position of the pixel in Morton order
- */
-static inline u32 GetMortonOffset(u32 x, u32 y, u32 bytes_per_pixel) {
-    // Images are split into 8x8 tiles. Each tile is composed of four 4x4 subtiles each
-    // of which is composed of four 2x2 subtiles each of which is composed of four texels.
-    // Each structure is embedded into the next-bigger one in a diagonal pattern, e.g.
-    // texels are laid out in a 2x2 subtile like this:
-    // 2 3
-    // 0 1
-    //
-    // The full 8x8 tile has the texels arranged like this:
-    //
-    // 42 43 46 47 58 59 62 63
-    // 40 41 44 45 56 57 60 61
-    // 34 35 38 39 50 51 54 55
-    // 32 33 36 37 48 49 52 53
-    // 10 11 14 15 26 27 30 31
-    // 08 09 12 13 24 25 28 29
-    // 02 03 06 07 18 19 22 23
-    // 00 01 04 05 16 17 20 21
-    //
-    // This pattern is what's called Z-order curve, or Morton order.
-    const unsigned int block_height = 8;
-    const unsigned int coarse_x = x & ~7;
-    u32 i = VideoCore::MortonInterleave(x, y);
-    const unsigned int offset = coarse_x * block_height;
-    return (i + offset) * bytes_per_pixel;
-}
-static inline u32 MortonInterleave128(u32 x, u32 y) {
-    // 128x128 Z-Order coordinate from 2D coordinates
-    static constexpr u32 xlut[] = {
-        0x0000, 0x0001, 0x0002, 0x0003, 0x0008, 0x0009, 0x000a, 0x000b, 0x0040, 0x0041, 0x0042,
-        0x0043, 0x0048, 0x0049, 0x004a, 0x004b, 0x0800, 0x0801, 0x0802, 0x0803, 0x0808, 0x0809,
-        0x080a, 0x080b, 0x0840, 0x0841, 0x0842, 0x0843, 0x0848, 0x0849, 0x084a, 0x084b, 0x1000,
-        0x1001, 0x1002, 0x1003, 0x1008, 0x1009, 0x100a, 0x100b, 0x1040, 0x1041, 0x1042, 0x1043,
-        0x1048, 0x1049, 0x104a, 0x104b, 0x1800, 0x1801, 0x1802, 0x1803, 0x1808, 0x1809, 0x180a,
-        0x180b, 0x1840, 0x1841, 0x1842, 0x1843, 0x1848, 0x1849, 0x184a, 0x184b, 0x2000, 0x2001,
-        0x2002, 0x2003, 0x2008, 0x2009, 0x200a, 0x200b, 0x2040, 0x2041, 0x2042, 0x2043, 0x2048,
-        0x2049, 0x204a, 0x204b, 0x2800, 0x2801, 0x2802, 0x2803, 0x2808, 0x2809, 0x280a, 0x280b,
-        0x2840, 0x2841, 0x2842, 0x2843, 0x2848, 0x2849, 0x284a, 0x284b, 0x3000, 0x3001, 0x3002,
-        0x3003, 0x3008, 0x3009, 0x300a, 0x300b, 0x3040, 0x3041, 0x3042, 0x3043, 0x3048, 0x3049,
-        0x304a, 0x304b, 0x3800, 0x3801, 0x3802, 0x3803, 0x3808, 0x3809, 0x380a, 0x380b, 0x3840,
-        0x3841, 0x3842, 0x3843, 0x3848, 0x3849, 0x384a, 0x384b, 0x0000, 0x0001, 0x0002, 0x0003,
-        0x0008, 0x0009, 0x000a, 0x000b, 0x0040, 0x0041, 0x0042, 0x0043, 0x0048, 0x0049, 0x004a,
-        0x004b, 0x0800, 0x0801, 0x0802, 0x0803, 0x0808, 0x0809, 0x080a, 0x080b, 0x0840, 0x0841,
-        0x0842, 0x0843, 0x0848, 0x0849, 0x084a, 0x084b, 0x1000, 0x1001, 0x1002, 0x1003, 0x1008,
-        0x1009, 0x100a, 0x100b, 0x1040, 0x1041, 0x1042, 0x1043, 0x1048, 0x1049, 0x104a, 0x104b,
-        0x1800, 0x1801, 0x1802, 0x1803, 0x1808, 0x1809, 0x180a, 0x180b, 0x1840, 0x1841, 0x1842,
-        0x1843, 0x1848, 0x1849, 0x184a, 0x184b, 0x2000, 0x2001, 0x2002, 0x2003, 0x2008, 0x2009,
-        0x200a, 0x200b, 0x2040, 0x2041, 0x2042, 0x2043, 0x2048, 0x2049, 0x204a, 0x204b, 0x2800,
-        0x2801, 0x2802, 0x2803, 0x2808, 0x2809, 0x280a, 0x280b, 0x2840, 0x2841, 0x2842, 0x2843,
-        0x2848, 0x2849, 0x284a, 0x284b, 0x3000, 0x3001, 0x3002, 0x3003, 0x3008, 0x3009, 0x300a,
-        0x300b, 0x3040, 0x3041, 0x3042, 0x3043, 0x3048, 0x3049, 0x304a, 0x304b, 0x3800, 0x3801,
-        0x3802, 0x3803, 0x3808, 0x3809, 0x380a, 0x380b, 0x3840, 0x3841, 0x3842, 0x3843, 0x3848,
-        0x3849, 0x384a, 0x384b, 0x0000, 0x0001, 0x0002, 0x0003, 0x0008, 0x0009, 0x000a, 0x000b,
-        0x0040, 0x0041, 0x0042, 0x0043, 0x0048, 0x0049, 0x004a, 0x004b, 0x0800, 0x0801, 0x0802,
-        0x0803, 0x0808, 0x0809, 0x080a, 0x080b, 0x0840, 0x0841, 0x0842, 0x0843, 0x0848, 0x0849,
-        0x084a, 0x084b, 0x1000, 0x1001, 0x1002, 0x1003, 0x1008, 0x1009, 0x100a, 0x100b, 0x1040,
-        0x1041, 0x1042, 0x1043, 0x1048, 0x1049, 0x104a, 0x104b, 0x1800, 0x1801, 0x1802, 0x1803,
-        0x1808, 0x1809, 0x180a, 0x180b, 0x1840, 0x1841, 0x1842, 0x1843, 0x1848, 0x1849, 0x184a,
-        0x184b, 0x2000, 0x2001, 0x2002, 0x2003, 0x2008, 0x2009, 0x200a, 0x200b, 0x2040, 0x2041,
-        0x2042, 0x2043, 0x2048, 0x2049, 0x204a, 0x204b, 0x2800, 0x2801, 0x2802, 0x2803, 0x2808,
-        0x2809, 0x280a, 0x280b, 0x2840, 0x2841, 0x2842, 0x2843, 0x2848, 0x2849, 0x284a, 0x284b,
-        0x3000, 0x3001, 0x3002, 0x3003, 0x3008, 0x3009, 0x300a, 0x300b, 0x3040, 0x3041, 0x3042,
-        0x3043, 0x3048, 0x3049, 0x304a, 0x304b, 0x3800, 0x3801, 0x3802, 0x3803, 0x3808, 0x3809,
-        0x380a, 0x380b, 0x3840, 0x3841, 0x3842, 0x3843, 0x3848, 0x3849, 0x384a, 0x384b,
-    };
-    static constexpr u32 ylut[] = {
-        0x0000, 0x0004, 0x0010, 0x0014, 0x0020, 0x0024, 0x0030, 0x0034, 0x0080, 0x0084, 0x0090,
-        0x0094, 0x00a0, 0x00a4, 0x00b0, 0x00b4, 0x0100, 0x0104, 0x0110, 0x0114, 0x0120, 0x0124,
-        0x0130, 0x0134, 0x0180, 0x0184, 0x0190, 0x0194, 0x01a0, 0x01a4, 0x01b0, 0x01b4, 0x0200,
-        0x0204, 0x0210, 0x0214, 0x0220, 0x0224, 0x0230, 0x0234, 0x0280, 0x0284, 0x0290, 0x0294,
-        0x02a0, 0x02a4, 0x02b0, 0x02b4, 0x0300, 0x0304, 0x0310, 0x0314, 0x0320, 0x0324, 0x0330,
-        0x0334, 0x0380, 0x0384, 0x0390, 0x0394, 0x03a0, 0x03a4, 0x03b0, 0x03b4, 0x0400, 0x0404,
-        0x0410, 0x0414, 0x0420, 0x0424, 0x0430, 0x0434, 0x0480, 0x0484, 0x0490, 0x0494, 0x04a0,
-        0x04a4, 0x04b0, 0x04b4, 0x0500, 0x0504, 0x0510, 0x0514, 0x0520, 0x0524, 0x0530, 0x0534,
-        0x0580, 0x0584, 0x0590, 0x0594, 0x05a0, 0x05a4, 0x05b0, 0x05b4, 0x0600, 0x0604, 0x0610,
-        0x0614, 0x0620, 0x0624, 0x0630, 0x0634, 0x0680, 0x0684, 0x0690, 0x0694, 0x06a0, 0x06a4,
-        0x06b0, 0x06b4, 0x0700, 0x0704, 0x0710, 0x0714, 0x0720, 0x0724, 0x0730, 0x0734, 0x0780,
-        0x0784, 0x0790, 0x0794, 0x07a0, 0x07a4, 0x07b0, 0x07b4, 0x0000, 0x0004, 0x0010, 0x0014,
-        0x0020, 0x0024, 0x0030, 0x0034, 0x0080, 0x0084, 0x0090, 0x0094, 0x00a0, 0x00a4, 0x00b0,
-        0x00b4, 0x0100, 0x0104, 0x0110, 0x0114, 0x0120, 0x0124, 0x0130, 0x0134, 0x0180, 0x0184,
-        0x0190, 0x0194, 0x01a0, 0x01a4, 0x01b0, 0x01b4, 0x0200, 0x0204, 0x0210, 0x0214, 0x0220,
-        0x0224, 0x0230, 0x0234, 0x0280, 0x0284, 0x0290, 0x0294, 0x02a0, 0x02a4, 0x02b0, 0x02b4,
-        0x0300, 0x0304, 0x0310, 0x0314, 0x0320, 0x0324, 0x0330, 0x0334, 0x0380, 0x0384, 0x0390,
-        0x0394, 0x03a0, 0x03a4, 0x03b0, 0x03b4, 0x0400, 0x0404, 0x0410, 0x0414, 0x0420, 0x0424,
-        0x0430, 0x0434, 0x0480, 0x0484, 0x0490, 0x0494, 0x04a0, 0x04a4, 0x04b0, 0x04b4, 0x0500,
-        0x0504, 0x0510, 0x0514, 0x0520, 0x0524, 0x0530, 0x0534, 0x0580, 0x0584, 0x0590, 0x0594,
-        0x05a0, 0x05a4, 0x05b0, 0x05b4, 0x0600, 0x0604, 0x0610, 0x0614, 0x0620, 0x0624, 0x0630,
-        0x0634, 0x0680, 0x0684, 0x0690, 0x0694, 0x06a0, 0x06a4, 0x06b0, 0x06b4, 0x0700, 0x0704,
-        0x0710, 0x0714, 0x0720, 0x0724, 0x0730, 0x0734, 0x0780, 0x0784, 0x0790, 0x0794, 0x07a0,
-        0x07a4, 0x07b0, 0x07b4, 0x0000, 0x0004, 0x0010, 0x0014, 0x0020, 0x0024, 0x0030, 0x0034,
-        0x0080, 0x0084, 0x0090, 0x0094, 0x00a0, 0x00a4, 0x00b0, 0x00b4, 0x0100, 0x0104, 0x0110,
-        0x0114, 0x0120, 0x0124, 0x0130, 0x0134, 0x0180, 0x0184, 0x0190, 0x0194, 0x01a0, 0x01a4,
-        0x01b0, 0x01b4, 0x0200, 0x0204, 0x0210, 0x0214, 0x0220, 0x0224, 0x0230, 0x0234, 0x0280,
-        0x0284, 0x0290, 0x0294, 0x02a0, 0x02a4, 0x02b0, 0x02b4, 0x0300, 0x0304, 0x0310, 0x0314,
-        0x0320, 0x0324, 0x0330, 0x0334, 0x0380, 0x0384, 0x0390, 0x0394, 0x03a0, 0x03a4, 0x03b0,
-        0x03b4, 0x0400, 0x0404, 0x0410, 0x0414, 0x0420, 0x0424, 0x0430, 0x0434, 0x0480, 0x0484,
-        0x0490, 0x0494, 0x04a0, 0x04a4, 0x04b0, 0x04b4, 0x0500, 0x0504, 0x0510, 0x0514, 0x0520,
-        0x0524, 0x0530, 0x0534, 0x0580, 0x0584, 0x0590, 0x0594, 0x05a0, 0x05a4, 0x05b0, 0x05b4,
-        0x0600, 0x0604, 0x0610, 0x0614, 0x0620, 0x0624, 0x0630, 0x0634, 0x0680, 0x0684, 0x0690,
-        0x0694, 0x06a0, 0x06a4, 0x06b0, 0x06b4, 0x0700, 0x0704, 0x0710, 0x0714, 0x0720, 0x0724,
-        0x0730, 0x0734, 0x0780, 0x0784, 0x0790, 0x0794, 0x07a0, 0x07a4, 0x07b0, 0x07b4,
-    };
-    return xlut[x % 128] + ylut[y % 128];
-}
-static inline u32 GetMortonOffset128(u32 x, u32 y, u32 bytes_per_pixel) {
-    // Calculates the offset of the position of the pixel in Morton order
-    // Framebuffer images are split into 128x128 tiles.
-    const unsigned int block_height = 128;
-    const unsigned int coarse_x = x & ~127;
-    u32 i = MortonInterleave128(x, y);
-    const unsigned int offset = coarse_x * block_height;
-    return (i + offset) * bytes_per_pixel;
-}
-static inline void MortonCopyPixels128(u32 width, u32 height, u32 bytes_per_pixel,
-                                       u32 gl_bytes_per_pixel, u8* morton_data, u8* gl_data,
-                                       bool morton_to_gl) {
-    u8* data_ptrs[2];
-    for (unsigned y = 0; y < height; ++y) {
-        for (unsigned x = 0; x < width; ++x) {
-            const u32 coarse_y = y & ~127;
-            u32 morton_offset =
-                GetMortonOffset128(x, y, bytes_per_pixel) + coarse_y * width * bytes_per_pixel;
-            u32 gl_pixel_index = (x + y * width) * gl_bytes_per_pixel;
-            data_ptrs[morton_to_gl] = morton_data + morton_offset;
-            data_ptrs[!morton_to_gl] = &gl_data[gl_pixel_index];
-            memcpy(data_ptrs[0], data_ptrs[1], bytes_per_pixel);
-        }
-    }
-}
-} // namespace VideoCore
diff --git a/src/yuzu/applets/software_keyboard.cpp b/src/yuzu/applets/software_keyboard.cpp
index efefb1f99..8a26fdff1 100644
--- a/src/yuzu/applets/software_keyboard.cpp
+++ b/src/yuzu/applets/software_keyboard.cpp
@@ -82,8 +82,8 @@ QtSoftwareKeyboardDialog::QtSoftwareKeyboardDialog(
                           : QString::fromStdU16String(parameters.submit_text),
                       QDialogButtonBox::AcceptRole);
-    connect(buttons, &QDialogButtonBox::accepted, this, &QtSoftwareKeyboardDialog::Submit);
+    connect(buttons, &QDialogButtonBox::accepted, this, &QtSoftwareKeyboardDialog::accept);
-    connect(buttons, &QDialogButtonBox::rejected, this, &QtSoftwareKeyboardDialog::Reject);
+    connect(buttons, &QDialogButtonBox::rejected, this, &QtSoftwareKeyboardDialog::reject);
    layout->addWidget(header_label);
    layout->addWidget(sub_label);
    layout->addWidget(guide_label);
@@ -96,16 +96,16 @@ QtSoftwareKeyboardDialog::QtSoftwareKeyboardDialog(
 QtSoftwareKeyboardDialog::~QtSoftwareKeyboardDialog() = default;
-void QtSoftwareKeyboardDialog::Submit() {
+void QtSoftwareKeyboardDialog::accept() {
    ok = true;
    text = line_edit->text().toStdU16String();
-    accept();
+    QDialog::accept();
 }
-void QtSoftwareKeyboardDialog::Reject() {
+void QtSoftwareKeyboardDialog::reject() {
    ok = false;
    text.clear();
-    accept();
+    QDialog::reject();
 }
 std::u16string QtSoftwareKeyboardDialog::GetText() const {
@@ -129,13 +129,13 @@ QtSoftwareKeyboard::~QtSoftwareKeyboard() = default;
 void QtSoftwareKeyboard::RequestText(std::function<void(std::optional<std::u16string>)> out,
                                     Core::Frontend::SoftwareKeyboardParameters parameters) const {
-    text_output = out;
+    text_output = std::move(out);
    emit MainWindowGetText(parameters);
 }
 void QtSoftwareKeyboard::SendTextCheckDialog(std::u16string error_message,
                                             std::function<void()> finished_check) const {
-    this->finished_check = finished_check;
+    this->finished_check = std::move(finished_check);
    emit MainWindowTextCheckDialog(error_message);
 }
diff --git a/src/yuzu/applets/software_keyboard.h b/src/yuzu/applets/software_keyboard.h
index 73f56714f..c63720ba4 100644
--- a/src/yuzu/applets/software_keyboard.h
+++ b/src/yuzu/applets/software_keyboard.h
@@ -33,8 +33,8 @@ public:
                             Core::Frontend::SoftwareKeyboardParameters parameters);
    ~QtSoftwareKeyboardDialog() override;
-    void Submit();
+    void accept() override;
-    void Reject();
+    void reject() override;
    std::u16string GetText() const;
    bool GetStatus() const;
@@ -70,11 +70,10 @@ signals:
    void MainWindowGetText(Core::Frontend::SoftwareKeyboardParameters parameters) const;
    void MainWindowTextCheckDialog(std::u16string error_message) const;
-public slots:
+private:
    void MainWindowFinishedText(std::optional<std::u16string> text);
    void MainWindowFinishedCheckDialog();
-private:
    mutable std::function<void(std::optional<std::u16string>)> text_output;
    mutable std::function<void()> finished_check;
 };
diff --git a/src/yuzu/bootmanager.cpp b/src/yuzu/bootmanager.cpp
index 39eef8858..384e17921 100644
--- a/src/yuzu/bootmanager.cpp
+++ b/src/yuzu/bootmanager.cpp
@@ -310,7 +310,7 @@ void GRenderWindow::InitRenderTarget() {
    // TODO: One of these flags might be interesting: WA_OpaquePaintEvent, WA_NoBackground,
    // WA_DontShowOnScreen, WA_DeleteOnClose
    QGLFormat fmt;
-    fmt.setVersion(3, 3);
+    fmt.setVersion(4, 3);
    fmt.setProfile(QGLFormat::CoreProfile);
    fmt.setSwapInterval(false);
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index e24ed5f2b..83ebbd1fe 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -432,6 +432,7 @@ void Config::ReadValues() {
    Settings::values.use_gdbstub = qt_config->value("use_gdbstub", false).toBool();
    Settings::values.gdbstub_port = qt_config->value("gdbstub_port", 24689).toInt();
    Settings::values.program_args = qt_config->value("program_args", "").toString().toStdString();
+    Settings::values.dump_exefs = qt_config->value("dump_exefs", false).toBool();
    Settings::values.dump_nso = qt_config->value("dump_nso", false).toBool();
    qt_config->endGroup();
@@ -638,6 +639,7 @@ void Config::SaveValues() {
    qt_config->setValue("use_gdbstub", Settings::values.use_gdbstub);
    qt_config->setValue("gdbstub_port", Settings::values.gdbstub_port);
    qt_config->setValue("program_args", QString::fromStdString(Settings::values.program_args));
+    qt_config->setValue("dump_exefs", Settings::values.dump_exefs);
    qt_config->setValue("dump_nso", Settings::values.dump_nso);
    qt_config->endGroup();
diff --git a/src/yuzu/configuration/configure_debug.cpp b/src/yuzu/configuration/configure_debug.cpp
index fd5876b41..aa7de7b54 100644
--- a/src/yuzu/configuration/configure_debug.cpp
+++ b/src/yuzu/configuration/configure_debug.cpp
@@ -34,6 +34,7 @@ void ConfigureDebug::setConfiguration() {
    ui->toggle_console->setChecked(UISettings::values.show_console);
    ui->log_filter_edit->setText(QString::fromStdString(Settings::values.log_filter));
    ui->homebrew_args_edit->setText(QString::fromStdString(Settings::values.program_args));
+    ui->dump_exefs->setChecked(Settings::values.dump_exefs);
    ui->dump_decompressed_nso->setChecked(Settings::values.dump_nso);
 }
@@ -43,6 +44,7 @@ void ConfigureDebug::applyConfiguration() {
    UISettings::values.show_console = ui->toggle_console->isChecked();
    Settings::values.log_filter = ui->log_filter_edit->text().toStdString();
    Settings::values.program_args = ui->homebrew_args_edit->text().toStdString();
+    Settings::values.dump_exefs = ui->dump_exefs->isChecked();
    Settings::values.dump_nso = ui->dump_decompressed_nso->isChecked();
    Debugger::ToggleConsole();
    Log::Filter filter;
diff --git a/src/yuzu/configuration/configure_debug.ui b/src/yuzu/configuration/configure_debug.ui
index 9c5b702f8..758a92335 100644
--- a/src/yuzu/configuration/configure_debug.ui
+++ b/src/yuzu/configuration/configure_debug.ui
@@ -145,6 +145,16 @@
        </property>
       </widget>
      </item>
+      <item>
+       <widget class="QCheckBox" name="dump_exefs">
+        <property name="whatsThis">
+         <string>When checked, any game that yuzu loads will have its ExeFS dumped to the yuzu/dump directory.</string>
+        </property>
+        <property name="text">
+         <string>Dump ExeFS</string>
+        </property>
+       </widget>
+      </item>
     </layout>
    </widget>
   </item>
diff --git a/src/yuzu/configuration/configure_graphics.ui b/src/yuzu/configuration/configure_graphics.ui
index 91fcad994..e278cdd05 100644
--- a/src/yuzu/configuration/configure_graphics.ui
+++ b/src/yuzu/configuration/configure_graphics.ui
@@ -23,31 +23,31 @@
       </property>
       <layout class="QVBoxLayout" name="verticalLayout_2">
        <item>
-          <layout class="QHBoxLayout" name="horizontalLayout_2">
+         <layout class="QHBoxLayout" name="horizontalLayout_2">
-            <item>
+          <item>
-              <widget class="QCheckBox" name="toggle_frame_limit">
+           <widget class="QCheckBox" name="toggle_frame_limit">
-                <property name="text">
+            <property name="text">
-                  <string>Limit Speed Percent</string>
+             <string>Limit Speed Percent</string>
-                </property>
+            </property>
-              </widget>
+           </widget>
-            </item>
+          </item>
-            <item>
+          <item>
-              <widget class="QSpinBox" name="frame_limit">
+           <widget class="QSpinBox" name="frame_limit">
-                <property name="suffix">
+            <property name="suffix">
-                  <string>%</string>
+             <string>%</string>
-                </property>
+            </property>
-                <property name="minimum">
+            <property name="minimum">
-                  <number>1</number>
+             <number>1</number>
-                </property>
+            </property>
-                <property name="maximum">
+            <property name="maximum">
-                  <number>9999</number>
+             <number>9999</number>
-                </property>
+            </property>
-                <property name="value">
+            <property name="value">
-                  <number>100</number>
+             <number>100</number>
-                </property>
+            </property>
-              </widget>
+           </widget>
-            </item>
+          </item>
-          </layout>
+         </layout>
        </item>
        <item>
         <widget class="QCheckBox" name="use_accurate_gpu_emulation">
@@ -61,7 +61,7 @@
          <item>
           <widget class="QLabel" name="label">
            <property name="text">
-             <string>Internal Resolution:(Currently does nothing.)</string>
+             <string>Internal Resolution</string>
            </property>
           </widget>
          </item>
@@ -96,27 +96,27 @@
          </item>
         </layout>
        </item>
-         <item>
+        <item>
-           <layout class="QHBoxLayout" name="horizontalLayout_6">
+         <layout class="QHBoxLayout" name="horizontalLayout_6">
-             <item>
+          <item>
-               <widget class="QLabel" name="bg_label">
+           <widget class="QLabel" name="bg_label">
-                 <property name="text">
+            <property name="text">
-                   <string>Background Color:</string>
+             <string>Background Color:</string>
-                 </property>
+            </property>
-               </widget>
+           </widget>
-             </item>
+          </item>
-             <item>
+          <item>
-               <widget class="QPushButton" name="bg_button">
+           <widget class="QPushButton" name="bg_button">
-                 <property name="maximumSize">
+            <property name="maximumSize">
-                   <size>
+             <size>
-                     <width>40</width>
+              <width>40</width>
-                     <height>16777215</height>
+              <height>16777215</height>
-                   </size>
+             </size>
-                 </property>
+            </property>
-               </widget>
+           </widget>
-             </item>
+          </item>
-           </layout>
+         </layout>
-         </item>
+        </item>
       </layout>
      </widget>
     </item>
diff --git a/src/yuzu/configuration/configure_input.cpp b/src/yuzu/configuration/configure_input.cpp
index 07092f001..e25597b7f 100644
--- a/src/yuzu/configuration/configure_input.cpp
+++ b/src/yuzu/configuration/configure_input.cpp
@@ -4,11 +4,9 @@
 #include <algorithm>
 #include <memory>
-#include <utility>
-#include <QMenu>
-#include <QMessageBox>
 #include <QTimer>
-#include "common/param_package.h"
 #include "configuration/configure_touchscreen_advanced.h"
 #include "core/core.h"
 #include "core/hle/service/am/am.h"
@@ -16,16 +14,25 @@
 #include "core/hle/service/am/applet_oe.h"
 #include "core/hle/service/hid/controllers/npad.h"
 #include "core/hle/service/sm/sm.h"
-#include "input_common/main.h"
 #include "ui_configure_input.h"
 #include "ui_configure_input_player.h"
-#include "ui_configure_mouse_advanced.h"
-#include "ui_configure_touchscreen_advanced.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_input.h"
 #include "yuzu/configuration/configure_input_player.h"
 #include "yuzu/configuration/configure_mouse_advanced.h"
+namespace {
+template <typename Dialog, typename... Args>
+void CallConfigureDialog(ConfigureInput& parent, Args&&... args) {
+    parent.applyConfiguration();
+    Dialog dialog(&parent, std::forward<Args>(args)...);
+    const auto res = dialog.exec();
+    if (res == QDialog::Accepted) {
+        dialog.applyConfiguration();
+    }
+}
+} // Anonymous namespace
 ConfigureInput::ConfigureInput(QWidget* parent)
    : QWidget(parent), ui(std::make_unique<Ui::ConfigureInput>()) {
    ui->setupUi(this);
@@ -65,31 +72,20 @@ ConfigureInput::ConfigureInput(QWidget* parent)
    for (std::size_t i = 0; i < players_configure.size(); ++i) {
        connect(players_configure[i], &QPushButton::pressed, this,
-                [this, i]() { CallConfigureDialog<ConfigureInputPlayer>(i, false); });
+                [this, i] { CallConfigureDialog<ConfigureInputPlayer>(*this, i, false); });
    }
    connect(ui->handheld_configure, &QPushButton::pressed, this,
-            [this]() { CallConfigureDialog<ConfigureInputPlayer>(8, false); });
+            [this] { CallConfigureDialog<ConfigureInputPlayer>(*this, 8, false); });
    connect(ui->debug_configure, &QPushButton::pressed, this,
-            [this]() { CallConfigureDialog<ConfigureInputPlayer>(9, true); });
+            [this] { CallConfigureDialog<ConfigureInputPlayer>(*this, 9, true); });
    connect(ui->mouse_advanced, &QPushButton::pressed, this,
-            [this]() { CallConfigureDialog<ConfigureMouseAdvanced>(); });
+            [this] { CallConfigureDialog<ConfigureMouseAdvanced>(*this); });
    connect(ui->touchscreen_advanced, &QPushButton::pressed, this,
-            [this]() { CallConfigureDialog<ConfigureTouchscreenAdvanced>(); });
+            [this] { CallConfigureDialog<ConfigureTouchscreenAdvanced>(*this); });
-}
-template <typename Dialog, typename... Args>
-void ConfigureInput::CallConfigureDialog(Args&&... args) {
-    this->applyConfiguration();
-    Dialog dialog(this, std::forward<Args>(args)...);
-    const auto res = dialog.exec();
-    if (res == QDialog::Accepted) {
-        dialog.applyConfiguration();
-    }
 }
 void ConfigureInput::OnDockedModeChanged(bool last_state, bool new_state) {
diff --git a/src/yuzu/configuration/configure_input.h b/src/yuzu/configuration/configure_input.h
index 29a8a03f8..e8723dfcb 100644
--- a/src/yuzu/configuration/configure_input.h
+++ b/src/yuzu/configuration/configure_input.h
@@ -5,20 +5,12 @@
 #pragma once
 #include <array>
-#include <functional>
 #include <memory>
-#include <optional>
-#include <string>
-#include <unordered_map>
 #include <QKeyEvent>
 #include <QWidget>
-#include "common/param_package.h"
-#include "core/settings.h"
-#include "input_common/main.h"
 #include "ui_configure_input.h"
-#include "yuzu/configuration/config.h"
 class QPushButton;
 class QString;
@@ -40,9 +32,6 @@ public:
 private:
    void updateUIEnabled();
-    template <typename Dialog, typename... Args>
-    void CallConfigureDialog(Args&&... args);
    void OnDockedModeChanged(bool last_state, bool new_state);
    /// Load configuration settings.
diff --git a/src/yuzu/configuration/configure_input_player.cpp b/src/yuzu/configuration/configure_input_player.cpp
index ba6e09368..7dadd83c1 100644
--- a/src/yuzu/configuration/configure_input_player.cpp
+++ b/src/yuzu/configuration/configure_input_player.cpp
@@ -25,13 +25,6 @@ const std::array<std::string, ConfigureInputPlayer::ANALOG_SUB_BUTTONS_NUM>
        "modifier",
    }};
-static void MoveGridElement(QGridLayout* grid, int row_old, int column_old, int row_new,
-                            int column_new) {
-    const auto item = grid->itemAtPosition(row_old, column_old);
-    // grid->removeItem(item);
-    grid->addItem(item, row_new, column_new);
-}
 static void LayerGridElements(QGridLayout* grid, QWidget* item, QWidget* onTopOf) {
    const int index1 = grid->indexOf(item);
    const int index2 = grid->indexOf(onTopOf);
@@ -111,11 +104,10 @@ static QString AnalogToText(const Common::ParamPackage& param, const std::string
    }
 };
-ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, u8 player_index, bool debug)
+ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_index, bool debug)
-    : QDialog(parent), ui(std::make_unique<Ui::ConfigureInputPlayer>()),
+    : QDialog(parent), ui(std::make_unique<Ui::ConfigureInputPlayer>()), player_index(player_index),
-      timeout_timer(std::make_unique<QTimer>()), poll_timer(std::make_unique<QTimer>()),
+      debug(debug), timeout_timer(std::make_unique<QTimer>()),
-      player_index(player_index), debug(debug) {
+      poll_timer(std::make_unique<QTimer>()) {
    ui->setupUi(this);
    setFocusPolicy(Qt::ClickFocus);
@@ -315,7 +307,7 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, u8 player_index, boo
    for (std::size_t i = 0; i < controller_color_buttons.size(); ++i) {
        connect(controller_color_buttons[i], &QPushButton::clicked, this,
-                std::bind(&ConfigureInputPlayer::OnControllerButtonClick, this, i));
+                [this, i] { OnControllerButtonClick(static_cast<int>(i)); });
    }
    this->loadConfiguration();
diff --git a/src/yuzu/configuration/configure_input_player.h b/src/yuzu/configuration/configure_input_player.h
index b0e5550c5..7a53f6715 100644
--- a/src/yuzu/configuration/configure_input_player.h
+++ b/src/yuzu/configuration/configure_input_player.h
@@ -9,9 +9,10 @@
 #include <memory>
 #include <optional>
 #include <string>
-#include <unordered_map>
 #include <QDialog>
 #include <QKeyEvent>
 #include "common/param_package.h"
 #include "core/settings.h"
 #include "input_common/main.h"
@@ -29,16 +30,39 @@ class ConfigureInputPlayer : public QDialog {
    Q_OBJECT
 public:
-    explicit ConfigureInputPlayer(QWidget* parent, u8 player_index, bool debug = false);
+    explicit ConfigureInputPlayer(QWidget* parent, std::size_t player_index, bool debug = false);
    ~ConfigureInputPlayer() override;
    /// Save all button configurations to settings file
    void applyConfiguration();
 private:
+    void OnControllerButtonClick(int i);
+    /// Load configuration settings.
+    void loadConfiguration();
+    /// Restore all buttons to their default values.
+    void restoreDefaults();
+    /// Clear all input configuration
+    void ClearAll();
+    /// Update UI to reflect current configuration.
+    void updateButtonLabels();
+    /// Called when the button was pressed.
+    void handleClick(QPushButton* button,
+                     std::function<void(const Common::ParamPackage&)> new_input_setter,
+                     InputCommon::Polling::DeviceType type);
+    /// Finish polling and configure input using the input_setter
+    void setPollingResult(const Common::ParamPackage& params, bool abort);
+    /// Handle key press events.
+    void keyPressEvent(QKeyEvent* event) override;
    std::unique_ptr<Ui::ConfigureInputPlayer> ui;
-    u8 player_index;
+    std::size_t player_index;
    bool debug;
    std::unique_ptr<QTimer> timeout_timer;
@@ -77,27 +101,4 @@ private:
    std::array<QPushButton*, 4> controller_color_buttons;
    std::array<QColor, 4> controller_colors;
-    void OnControllerButtonClick(int i);
-    /// Load configuration settings.
-    void loadConfiguration();
-    /// Restore all buttons to their default values.
-    void restoreDefaults();
-    /// Clear all input configuration
-    void ClearAll();
-    /// Update UI to reflect current configuration.
-    void updateButtonLabels();
-    /// Called when the button was pressed.
-    void handleClick(QPushButton* button,
-                     std::function<void(const Common::ParamPackage&)> new_input_setter,
-                     InputCommon::Polling::DeviceType type);
-    /// Finish polling and configure input using the input_setter
-    void setPollingResult(const Common::ParamPackage& params, bool abort);
-    /// Handle key press events.
-    void keyPressEvent(QKeyEvent* event) override;
 };
diff --git a/src/yuzu/configuration/configure_mouse_advanced.cpp b/src/yuzu/configuration/configure_mouse_advanced.cpp
index dab58fbaa..ef857035e 100644
--- a/src/yuzu/configuration/configure_mouse_advanced.cpp
+++ b/src/yuzu/configuration/configure_mouse_advanced.cpp
@@ -4,11 +4,11 @@
 #include <algorithm>
 #include <memory>
-#include <utility>
 #include <QKeyEvent>
 #include <QMenu>
-#include <QMessageBox>
 #include <QTimer>
 #include "common/assert.h"
 #include "common/param_package.h"
 #include "input_common/main.h"
diff --git a/src/yuzu/configuration/configure_mouse_advanced.h b/src/yuzu/configuration/configure_mouse_advanced.h
index 218df2bda..e04da4bf2 100644
--- a/src/yuzu/configuration/configure_mouse_advanced.h
+++ b/src/yuzu/configuration/configure_mouse_advanced.h
@@ -7,7 +7,7 @@
 #include <memory>
 #include <optional>
 #include <QDialog>
-#include <QWidget>
 #include "core/settings.h"
 class QCheckBox;
@@ -28,23 +28,6 @@ public:
    void applyConfiguration();
 private:
-    std::unique_ptr<Ui::ConfigureMouseAdvanced> ui;
-    /// This will be the the setting function when an input is awaiting configuration.
-    std::optional<std::function<void(const Common::ParamPackage&)>> input_setter;
-    std::array<QPushButton*, Settings::NativeMouseButton::NumMouseButtons> button_map;
-    std::array<Common::ParamPackage, Settings::NativeMouseButton::NumMouseButtons> buttons_param;
-    std::vector<std::unique_ptr<InputCommon::Polling::DevicePoller>> device_pollers;
-    std::unique_ptr<QTimer> timeout_timer;
-    std::unique_ptr<QTimer> poll_timer;
-    /// A flag to indicate if keyboard keys are okay when configuring an input. If this is false,
-    /// keyboard events are ignored.
-    bool want_keyboard_keys = false;
    /// Load configuration settings.
    void loadConfiguration();
    /// Restore all buttons to their default values.
@@ -65,4 +48,21 @@ private:
    /// Handle key press events.
    void keyPressEvent(QKeyEvent* event) override;
+    std::unique_ptr<Ui::ConfigureMouseAdvanced> ui;
+    /// This will be the the setting function when an input is awaiting configuration.
+    std::optional<std::function<void(const Common::ParamPackage&)>> input_setter;
+    std::array<QPushButton*, Settings::NativeMouseButton::NumMouseButtons> button_map;
+    std::array<Common::ParamPackage, Settings::NativeMouseButton::NumMouseButtons> buttons_param;
+    std::vector<std::unique_ptr<InputCommon::Polling::DevicePoller>> device_pollers;
+    std::unique_ptr<QTimer> timeout_timer;
+    std::unique_ptr<QTimer> poll_timer;
+    /// A flag to indicate if keyboard keys are okay when configuring an input. If this is false,
+    /// keyboard events are ignored.
+    bool want_keyboard_keys = false;
 };
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index 9e13bbf7c..93bf117c8 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -518,32 +518,18 @@ void GMainWindow::OnDisplayTitleBars(bool show) {
 QStringList GMainWindow::GetUnsupportedGLExtensions() {
    QStringList unsupported_ext;
-    if (!GLAD_GL_ARB_program_interface_query)
-        unsupported_ext.append("ARB_program_interface_query");
-    if (!GLAD_GL_ARB_separate_shader_objects)
-        unsupported_ext.append("ARB_separate_shader_objects");
-    if (!GLAD_GL_ARB_vertex_attrib_binding)
-        unsupported_ext.append("ARB_vertex_attrib_binding");
    if (!GLAD_GL_ARB_vertex_type_10f_11f_11f_rev)
        unsupported_ext.append("ARB_vertex_type_10f_11f_11f_rev");
    if (!GLAD_GL_ARB_texture_mirror_clamp_to_edge)
        unsupported_ext.append("ARB_texture_mirror_clamp_to_edge");
-    if (!GLAD_GL_ARB_base_instance)
-        unsupported_ext.append("ARB_base_instance");
-    if (!GLAD_GL_ARB_texture_storage)
-        unsupported_ext.append("ARB_texture_storage");
    if (!GLAD_GL_ARB_multi_bind)
        unsupported_ext.append("ARB_multi_bind");
-    if (!GLAD_GL_ARB_copy_image)
-        unsupported_ext.append("ARB_copy_image");
    // Extensions required to support some texture formats.
    if (!GLAD_GL_EXT_texture_compression_s3tc)
        unsupported_ext.append("EXT_texture_compression_s3tc");
    if (!GLAD_GL_ARB_texture_compression_rgtc)
        unsupported_ext.append("ARB_texture_compression_rgtc");
-    if (!GLAD_GL_ARB_texture_compression_bptc)
-        unsupported_ext.append("ARB_texture_compression_bptc");
    if (!GLAD_GL_ARB_depth_buffer_float)
        unsupported_ext.append("ARB_depth_buffer_float");
@@ -562,8 +548,8 @@ bool GMainWindow::LoadROM(const QString& filename) {
    render_window->MakeCurrent();
    if (!gladLoadGL()) {
-        QMessageBox::critical(this, tr("Error while initializing OpenGL 3.3 Core!"),
+        QMessageBox::critical(this, tr("Error while initializing OpenGL 4.3 Core!"),
-                              tr("Your GPU may not support OpenGL 3.3, or you do not "
+                              tr("Your GPU may not support OpenGL 4.3, or you do not "
                                 "have the latest graphics driver."));
        return false;
    }
@@ -1119,14 +1105,14 @@ void GMainWindow::OnMenuInstallToNAND() {
            return;
        }
        const auto res =
-            Service::FileSystem::GetUserNANDContents()->InstallEntry(nsp, false, qt_raw_copy);
+            Service::FileSystem::GetUserNANDContents()->InstallEntry(*nsp, false, qt_raw_copy);
        if (res == FileSys::InstallResult::Success) {
            success();
        } else {
            if (res == FileSys::InstallResult::ErrorAlreadyExists) {
                if (overwrite()) {
                    const auto res2 = Service::FileSystem::GetUserNANDContents()->InstallEntry(
-                        nsp, true, qt_raw_copy);
+                        *nsp, true, qt_raw_copy);
                    if (res2 == FileSys::InstallResult::Success) {
                        success();
                    } else {
@@ -1181,10 +1167,10 @@ void GMainWindow::OnMenuInstallToNAND() {
        FileSys::InstallResult res;
        if (index >= static_cast<size_t>(FileSys::TitleType::Application)) {
            res = Service::FileSystem::GetUserNANDContents()->InstallEntry(
-                nca, static_cast<FileSys::TitleType>(index), false, qt_raw_copy);
+                *nca, static_cast<FileSys::TitleType>(index), false, qt_raw_copy);
        } else {
            res = Service::FileSystem::GetSystemNANDContents()->InstallEntry(
-                nca, static_cast<FileSys::TitleType>(index), false, qt_raw_copy);
+                *nca, static_cast<FileSys::TitleType>(index), false, qt_raw_copy);
        }
        if (res == FileSys::InstallResult::Success) {
@@ -1192,7 +1178,7 @@ void GMainWindow::OnMenuInstallToNAND() {
        } else if (res == FileSys::InstallResult::ErrorAlreadyExists) {
            if (overwrite()) {
                const auto res2 = Service::FileSystem::GetUserNANDContents()->InstallEntry(
-                    nca, static_cast<FileSys::TitleType>(index), true, qt_raw_copy);
+                    *nca, static_cast<FileSys::TitleType>(index), true, qt_raw_copy);
                if (res2 == FileSys::InstallResult::Success) {
                    success();
                } else {
diff --git a/src/yuzu_cmd/config.cpp b/src/yuzu_cmd/config.cpp
index c66353a65..097c1fbe3 100644
--- a/src/yuzu_cmd/config.cpp
+++ b/src/yuzu_cmd/config.cpp
@@ -366,6 +366,7 @@ void Config::ReadValues() {
    Settings::values.gdbstub_port =
        static_cast<u16>(sdl2_config->GetInteger("Debugging", "gdbstub_port", 24689));
    Settings::values.program_args = sdl2_config->Get("Debugging", "program_args", "");
+    Settings::values.dump_exefs = sdl2_config->GetBoolean("Debugging", "dump_exefs", false);
    Settings::values.dump_nso = sdl2_config->GetBoolean("Debugging", "dump_nso", false);
    // Web Service
diff --git a/src/yuzu_cmd/default_ini.h b/src/yuzu_cmd/default_ini.h
index ecf625e7b..d73669f36 100644
--- a/src/yuzu_cmd/default_ini.h
+++ b/src/yuzu_cmd/default_ini.h
@@ -206,6 +206,8 @@ log_filter = *:Trace
 # Port for listening to GDB connections.
 use_gdbstub=false
 gdbstub_port=24689
+# Determines whether or not yuzu will dump the ExeFS of all games it attempts to load while loading them
+dump_exefs=false
 # Determines whether or not yuzu will dump all NSOs it attempts to load while loading them
 dump_nso=false
diff --git a/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp b/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
index a9ad92a80..2d6f8cced 100644
--- a/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
+++ b/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
@@ -111,32 +111,18 @@ void EmuWindow_SDL2::Fullscreen() {
 bool EmuWindow_SDL2::SupportsRequiredGLExtensions() {
    std::vector<std::string> unsupported_ext;
-    if (!GLAD_GL_ARB_program_interface_query)
-        unsupported_ext.push_back("ARB_program_interface_query");
-    if (!GLAD_GL_ARB_separate_shader_objects)
-        unsupported_ext.push_back("ARB_separate_shader_objects");
-    if (!GLAD_GL_ARB_vertex_attrib_binding)
-        unsupported_ext.push_back("ARB_vertex_attrib_binding");
    if (!GLAD_GL_ARB_vertex_type_10f_11f_11f_rev)
        unsupported_ext.push_back("ARB_vertex_type_10f_11f_11f_rev");
    if (!GLAD_GL_ARB_texture_mirror_clamp_to_edge)
        unsupported_ext.push_back("ARB_texture_mirror_clamp_to_edge");
-    if (!GLAD_GL_ARB_base_instance)
-        unsupported_ext.push_back("ARB_base_instance");
-    if (!GLAD_GL_ARB_texture_storage)
-        unsupported_ext.push_back("ARB_texture_storage");
    if (!GLAD_GL_ARB_multi_bind)
        unsupported_ext.push_back("ARB_multi_bind");
-    if (!GLAD_GL_ARB_copy_image)
-        unsupported_ext.push_back("ARB_copy_image");
    // Extensions required to support some texture formats.
    if (!GLAD_GL_EXT_texture_compression_s3tc)
        unsupported_ext.push_back("EXT_texture_compression_s3tc");
    if (!GLAD_GL_ARB_texture_compression_rgtc)
        unsupported_ext.push_back("ARB_texture_compression_rgtc");
-    if (!GLAD_GL_ARB_texture_compression_bptc)
-        unsupported_ext.push_back("ARB_texture_compression_bptc");
    if (!GLAD_GL_ARB_depth_buffer_float)
        unsupported_ext.push_back("ARB_depth_buffer_float");
@@ -157,7 +143,7 @@ EmuWindow_SDL2::EmuWindow_SDL2(bool fullscreen) {
        exit(1);
    }
-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);