110 files changed, 4482 insertions, 1814 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6021a8054..918cf5372 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -23,21 +23,21 @@ option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
 
 option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)
 
-if(NOT EXISTS ${CMAKE_SOURCE_DIR}/.git/hooks/pre-commit)
+if(NOT EXISTS ${PROJECT_SOURCE_DIR}/.git/hooks/pre-commit)
     message(STATUS "Copying pre-commit hook")
     file(COPY hooks/pre-commit
-        DESTINATION ${CMAKE_SOURCE_DIR}/.git/hooks)
+        DESTINATION ${PROJECT_SOURCE_DIR}/.git/hooks)
 endif()
 
 # Sanity check : Check that all submodules are present
 # =======================================================================
 
 function(check_submodules_present)
-    file(READ "${CMAKE_SOURCE_DIR}/.gitmodules" gitmodules)
+    file(READ "${PROJECT_SOURCE_DIR}/.gitmodules" gitmodules)
     string(REGEX MATCHALL "path *= *[^ \t\r\n]*" gitmodules ${gitmodules})
     foreach(module ${gitmodules})
         string(REGEX REPLACE "path *= *" "" module ${module})
-        if (NOT EXISTS "${CMAKE_SOURCE_DIR}/${module}/.git")
+        if (NOT EXISTS "${PROJECT_SOURCE_DIR}/${module}/.git")
             message(FATAL_ERROR "Git submodule ${module} not found. "
                     "Please run: git submodule update --init --recursive")
         endif()
@@ -45,17 +45,17 @@ function(check_submodules_present)
 endfunction()
 check_submodules_present()
 
-configure_file(${CMAKE_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
-               ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
+configure_file(${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
+               ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
                COPYONLY)
-if (ENABLE_COMPATIBILITY_LIST_DOWNLOAD AND NOT EXISTS ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
+if (ENABLE_COMPATIBILITY_LIST_DOWNLOAD AND NOT EXISTS ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
     message(STATUS "Downloading compatibility list for yuzu...")
     file(DOWNLOAD
         https://api.yuzu-emu.org/gamedb/
-        "${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json" SHOW_PROGRESS)
+        "${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json" SHOW_PROGRESS)
 endif()
-if (NOT EXISTS ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
-    file(WRITE ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json "")
+if (NOT EXISTS ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
+    file(WRITE ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json "")
 endif()
 
 # Detect current compilation architecture and create standard definitions
@@ -170,7 +170,7 @@ endif()
 # On modern Unixes, this is typically already the case. The lone exception is
 # glibc, which may default to 32 bits. glibc allows this to be configured
 # by setting _FILE_OFFSET_BITS.
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR MINGW)
     add_definitions(-D_FILE_OFFSET_BITS=64)
 endif()
 
@@ -178,10 +178,6 @@ endif()
 set_property(DIRECTORY APPEND PROPERTY
     COMPILE_DEFINITIONS $<$<CONFIG:Debug>:_DEBUG> $<$<NOT:$<CONFIG:Debug>>:NDEBUG>)
 
-
-math(EXPR EMU_ARCH_BITS ${CMAKE_SIZEOF_VOID_P}*8)
-add_definitions(-DEMU_ARCH_BITS=${EMU_ARCH_BITS})
-
 # System imported libraries
 # ======================
 
@@ -189,13 +185,13 @@ find_package(Boost 1.63.0 QUIET)
 if (NOT Boost_FOUND)
     message(STATUS "Boost 1.63.0 or newer not found, falling back to externals")
 
-    set(BOOST_ROOT "${CMAKE_SOURCE_DIR}/externals/boost")
+    set(BOOST_ROOT "${PROJECT_SOURCE_DIR}/externals/boost")
     set(Boost_NO_SYSTEM_PATHS OFF)
     find_package(Boost QUIET REQUIRED)
 endif()
 
 # Output binaries to bin/
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 
 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
@@ -264,7 +260,7 @@ if (YUZU_USE_BUNDLED_UNICORN)
         endif()
 
         set(UNICORN_FOUND YES)
-        set(UNICORN_PREFIX ${CMAKE_SOURCE_DIR}/externals/unicorn)
+        set(UNICORN_PREFIX ${PROJECT_SOURCE_DIR}/externals/unicorn)
         set(LIBUNICORN_LIBRARY "${UNICORN_PREFIX}/${UNICORN_LIB_NAME}" CACHE PATH "Path to Unicorn library" FORCE)
         set(LIBUNICORN_INCLUDE_DIR "${UNICORN_PREFIX}/include" CACHE PATH "Path to Unicorn headers" FORCE)
         set(UNICORN_DLL_DIR "${UNICORN_PREFIX}/" CACHE PATH "Path to unicorn dynamic library" FORCE)
@@ -356,12 +352,12 @@ set(CLANG_FORMAT_POSTFIX "-6.0")
 find_program(CLANG_FORMAT
     NAMES clang-format${CLANG_FORMAT_POSTFIX}
           clang-format
-    PATHS ${CMAKE_BINARY_DIR}/externals)
+    PATHS ${PROJECT_BINARY_DIR}/externals)
 # if find_program doesn't find it, try to download from externals
 if (NOT CLANG_FORMAT)
     if (WIN32)
         message(STATUS "Clang format not found! Downloading...")
-        set(CLANG_FORMAT "${CMAKE_BINARY_DIR}/externals/clang-format${CLANG_FORMAT_POSTFIX}.exe")
+        set(CLANG_FORMAT "${PROJECT_BINARY_DIR}/externals/clang-format${CLANG_FORMAT_POSTFIX}.exe")
         file(DOWNLOAD
             https://github.com/yuzu-emu/ext-windows-bin/raw/master/clang-format${CLANG_FORMAT_POSTFIX}.exe
             "${CLANG_FORMAT}" SHOW_PROGRESS
@@ -377,7 +373,7 @@ if (NOT CLANG_FORMAT)
 endif()
 
 if (CLANG_FORMAT)
-    set(SRCS ${CMAKE_SOURCE_DIR}/src)
+    set(SRCS ${PROJECT_SOURCE_DIR}/src)
     set(CCOMMENT "Running clang format against all the .h and .cpp files in src/")
     if (WIN32)
         add_custom_target(clang-format
@@ -450,10 +446,10 @@ endif()
 # http://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html
 # http://standards.freedesktop.org/shared-mime-info-spec/shared-mime-info-spec-latest.html
 if(ENABLE_QT AND UNIX AND NOT APPLE)
-    install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.desktop"
+    install(FILES "${PROJECT_SOURCE_DIR}/dist/yuzu.desktop"
             DESTINATION "${CMAKE_INSTALL_PREFIX}/share/applications")
-    install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.svg"
+    install(FILES "${PROJECT_SOURCE_DIR}/dist/yuzu.svg"
             DESTINATION "${CMAKE_INSTALL_PREFIX}/share/icons/hicolor/scalable/apps")
-    install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.xml"
+    install(FILES "${PROJECT_SOURCE_DIR}/dist/yuzu.xml"
             DESTINATION "${CMAKE_INSTALL_PREFIX}/share/mime/packages")
 endif()
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index d0e506689..eccd8f64a 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -64,8 +64,6 @@ add_library(common STATIC
     logging/text_formatter.cpp
     logging/text_formatter.h
     math_util.h
-    memory_util.cpp
-    memory_util.h
     microprofile.cpp
     microprofile.h
     microprofileui.h
diff --git a/src/common/alignment.h b/src/common/alignment.h
index 225770fab..d94a2291f 100644
--- a/src/common/alignment.h
+++ b/src/common/alignment.h
@@ -19,4 +19,16 @@ constexpr T AlignDown(T value, std::size_t size) {
     return static_cast<T>(value - value % size);
 }
 
+template <typename T>
+constexpr bool Is4KBAligned(T value) {
+    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
+    return (value & 0xFFF) == 0;
+}
+
+template <typename T>
+constexpr bool IsWordAligned(T value) {
+    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
+    return (value & 0b11) == 0;
+}
+
 } // namespace Common
diff --git a/src/common/file_util.cpp b/src/common/file_util.cpp
index 548463787..b52492da6 100644
--- a/src/common/file_util.cpp
+++ b/src/common/file_util.cpp
@@ -15,21 +15,24 @@
 #ifdef _WIN32
 #include <windows.h>
 // windows.h needs to be included before other windows headers
-#include <commdlg.h> // for GetSaveFileName
-#include <direct.h>  // getcwd
+#include <direct.h> // getcwd
 #include <io.h>
 #include <shellapi.h>
 #include <shlobj.h> // for SHGetFolderPath
 #include <tchar.h>
 #include "common/string_util.h"
 
-// 64 bit offsets for windows
+#ifdef _MSC_VER
+// 64 bit offsets for MSVC
 #define fseeko _fseeki64
 #define ftello _ftelli64
-#define atoll _atoi64
+#define fileno _fileno
+#endif
+
+// 64 bit offsets for MSVC and MinGW. MinGW also needs this for using _wstat64
 #define stat _stat64
 #define fstat _fstat64
-#define fileno _fileno
+
 #else
 #ifdef __APPLE__
 #include <sys/param.h>
diff --git a/src/common/logging/log.h b/src/common/logging/log.h
index abbd056ee..c9161155a 100644
--- a/src/common/logging/log.h
+++ b/src/common/logging/log.h
@@ -91,6 +91,7 @@ enum class Class : ClassType {
     Service_PM,        ///< The PM service
     Service_PREPO,     ///< The PREPO (Play report) service
     Service_PSC,       ///< The PSC service
+    Service_PSM,       ///< The PSM service
     Service_SET,       ///< The SET (Settings) service
     Service_SM,        ///< The SM (Service manager) service
     Service_SPL,       ///< The SPL service
diff --git a/src/common/memory_util.cpp b/src/common/memory_util.cpp
deleted file mode 100644
index 9736fb12a..000000000
--- a/src/common/memory_util.cpp
+++ /dev/null
@@ -1,177 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "common/memory_util.h"
-
-#ifdef _WIN32
-#include <windows.h>
-// Windows.h needs to be included before psapi.h
-#include <psapi.h>
-#include "common/common_funcs.h"
-#include "common/string_util.h"
-#else
-#include <cstdlib>
-#include <sys/mman.h>
-#endif
-
-#if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
-#include <unistd.h>
-#define PAGE_MASK (getpagesize() - 1)
-#define round_page(x) ((((unsigned long)(x)) + PAGE_MASK) & ~(PAGE_MASK))
-#endif
-
-// This is purposely not a full wrapper for virtualalloc/mmap, but it
-// provides exactly the primitive operations that Dolphin needs.
-
-void* AllocateExecutableMemory(std::size_t size, bool low) {
-#if defined(_WIN32)
-    void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
-#else
-    static char* map_hint = nullptr;
-#if defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
-    // This OS has no flag to enforce allocation below the 4 GB boundary,
-    // but if we hint that we want a low address it is very likely we will
-    // get one.
-    // An older version of this code used MAP_FIXED, but that has the side
-    // effect of discarding already mapped pages that happen to be in the
-    // requested virtual memory range (such as the emulated RAM, sometimes).
-    if (low && (!map_hint))
-        map_hint = (char*)round_page(512 * 1024 * 1024); /* 0.5 GB rounded up to the next page */
-#endif
-    void* ptr = mmap(map_hint, size, PROT_READ | PROT_WRITE | PROT_EXEC,
-                     MAP_ANON | MAP_PRIVATE
-#if defined(ARCHITECTURE_x86_64) && defined(MAP_32BIT)
-                         | (low ? MAP_32BIT : 0)
-#endif
-                         ,
-                     -1, 0);
-#endif /* defined(_WIN32) */
-
-#ifdef _WIN32
-    if (ptr == nullptr) {
-#else
-    if (ptr == MAP_FAILED) {
-        ptr = nullptr;
-#endif
-        LOG_ERROR(Common_Memory, "Failed to allocate executable memory");
-    }
-#if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
-    else {
-        if (low) {
-            map_hint += size;
-            map_hint = (char*)round_page(map_hint); /* round up to the next page */
-        }
-    }
-#endif
-
-#if EMU_ARCH_BITS == 64
-    if ((u64)ptr >= 0x80000000 && low == true)
-        LOG_ERROR(Common_Memory, "Executable memory ended up above 2GB!");
-#endif
-
-    return ptr;
-}
-
-void* AllocateMemoryPages(std::size_t size) {
-#ifdef _WIN32
-    void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE);
-#else
-    void* ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
-
-    if (ptr == MAP_FAILED)
-        ptr = nullptr;
-#endif
-
-    if (ptr == nullptr)
-        LOG_ERROR(Common_Memory, "Failed to allocate raw memory");
-
-    return ptr;
-}
-
-void* AllocateAlignedMemory(std::size_t size, std::size_t alignment) {
-#ifdef _WIN32
-    void* ptr = _aligned_malloc(size, alignment);
-#else
-    void* ptr = nullptr;
-#ifdef ANDROID
-    ptr = memalign(alignment, size);
-#else
-    if (posix_memalign(&ptr, alignment, size) != 0)
-        LOG_ERROR(Common_Memory, "Failed to allocate aligned memory");
-#endif
-#endif
-
-    if (ptr == nullptr)
-        LOG_ERROR(Common_Memory, "Failed to allocate aligned memory");
-
-    return ptr;
-}
-
-void FreeMemoryPages(void* ptr, std::size_t size) {
-    if (ptr) {
-#ifdef _WIN32
-        if (!VirtualFree(ptr, 0, MEM_RELEASE))
-            LOG_ERROR(Common_Memory, "FreeMemoryPages failed!\n{}", GetLastErrorMsg());
-#else
-        munmap(ptr, size);
-#endif
-    }
-}
-
-void FreeAlignedMemory(void* ptr) {
-    if (ptr) {
-#ifdef _WIN32
-        _aligned_free(ptr);
-#else
-        free(ptr);
-#endif
-    }
-}
-
-void WriteProtectMemory(void* ptr, std::size_t size, bool allowExecute) {
-#ifdef _WIN32
-    DWORD oldValue;
-    if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READ : PAGE_READONLY, &oldValue))
-        LOG_ERROR(Common_Memory, "WriteProtectMemory failed!\n{}", GetLastErrorMsg());
-#else
-    mprotect(ptr, size, allowExecute ? (PROT_READ | PROT_EXEC) : PROT_READ);
-#endif
-}
-
-void UnWriteProtectMemory(void* ptr, std::size_t size, bool allowExecute) {
-#ifdef _WIN32
-    DWORD oldValue;
-    if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE,
-                        &oldValue))
-        LOG_ERROR(Common_Memory, "UnWriteProtectMemory failed!\n{}", GetLastErrorMsg());
-#else
-    mprotect(ptr, size,
-             allowExecute ? (PROT_READ | PROT_WRITE | PROT_EXEC) : PROT_WRITE | PROT_READ);
-#endif
-}
-
-std::string MemUsage() {
-#ifdef _WIN32
-#pragma comment(lib, "psapi")
-    DWORD processID = GetCurrentProcessId();
-    HANDLE hProcess;
-    PROCESS_MEMORY_COUNTERS pmc;
-    std::string Ret;
-
-    // Print information about the memory usage of the process.
-
-    hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID);
-    if (nullptr == hProcess)
-        return "MemUsage Error";
-
-    if (GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc)))
-        Ret = fmt::format("{} K", Common::ThousandSeparate(pmc.WorkingSetSize / 1024, 7));
-
-    CloseHandle(hProcess);
-    return Ret;
-#else
-    return "";
-#endif
-}
diff --git a/src/common/memory_util.h b/src/common/memory_util.h
deleted file mode 100644
index aad071979..000000000
--- a/src/common/memory_util.h
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstddef>
-#include <string>
-
-void* AllocateExecutableMemory(std::size_t size, bool low = true);
-void* AllocateMemoryPages(std::size_t size);
-void FreeMemoryPages(void* ptr, std::size_t size);
-void* AllocateAlignedMemory(std::size_t size, std::size_t alignment);
-void FreeAlignedMemory(void* ptr);
-void WriteProtectMemory(void* ptr, std::size_t size, bool executable = false);
-void UnWriteProtectMemory(void* ptr, std::size_t size, bool allowExecute = false);
-std::string MemUsage();
-
-inline int GetPageSize() {
-    return 4096;
-}
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 78986deb5..64fdf38cd 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -156,6 +156,8 @@ add_library(core STATIC
     hle/service/am/omm.h
     hle/service/am/spsm.cpp
     hle/service/am/spsm.h
+    hle/service/am/tcap.cpp
+    hle/service/am/tcap.h
     hle/service/aoc/aoc_u.cpp
     hle/service/aoc/aoc_u.h
     hle/service/apm/apm.cpp
@@ -236,6 +238,24 @@ add_library(core STATIC
     hle/service/hid/irs.h
     hle/service/hid/xcd.cpp
     hle/service/hid/xcd.h
+    hle/service/hid/controllers/controller_base.cpp
+    hle/service/hid/controllers/controller_base.h
+    hle/service/hid/controllers/debug_pad.cpp
+    hle/service/hid/controllers/debug_pad.h
+    hle/service/hid/controllers/gesture.cpp
+    hle/service/hid/controllers/gesture.h
+    hle/service/hid/controllers/keyboard.cpp
+    hle/service/hid/controllers/keyboard.h
+    hle/service/hid/controllers/mouse.cpp
+    hle/service/hid/controllers/mouse.h
+    hle/service/hid/controllers/npad.cpp
+    hle/service/hid/controllers/npad.h
+    hle/service/hid/controllers/stubbed.cpp
+    hle/service/hid/controllers/stubbed.h
+    hle/service/hid/controllers/touchscreen.cpp
+    hle/service/hid/controllers/touchscreen.h
+    hle/service/hid/controllers/xpad.cpp
+    hle/service/hid/controllers/xpad.h
     hle/service/lbl/lbl.cpp
     hle/service/lbl/lbl.h
     hle/service/ldn/ldn.cpp
@@ -262,6 +282,8 @@ add_library(core STATIC
     hle/service/nifm/nifm.h
     hle/service/nim/nim.cpp
     hle/service/nim/nim.h
+    hle/service/npns/npns.cpp
+    hle/service/npns/npns.h
     hle/service/ns/ns.cpp
     hle/service/ns/ns.h
     hle/service/ns/pl_u.cpp
@@ -309,6 +331,8 @@ add_library(core STATIC
     hle/service/prepo/prepo.h
     hle/service/psc/psc.cpp
     hle/service/psc/psc.h
+    hle/service/ptm/psm.cpp
+    hle/service/ptm/psm.h
     hle/service/service.cpp
     hle/service/service.h
     hle/service/set/set.cpp
diff --git a/src/core/core.cpp b/src/core/core.cpp
index 3c57a62ec..7cb86ed92 100644
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -375,8 +375,7 @@ const Kernel::Process* System::CurrentProcess() const {
 }
 
 ARM_Interface& System::ArmInterface(std::size_t core_index) {
-    ASSERT(core_index < NUM_CPU_CORES);
-    return impl->cpu_cores[core_index]->ArmInterface();
+    return CpuCore(core_index).ArmInterface();
 }
 
 Cpu& System::CpuCore(std::size_t core_index) {
diff --git a/src/core/crypto/partition_data_manager.cpp b/src/core/crypto/partition_data_manager.cpp
index 25cee1f3a..ed0775444 100644
--- a/src/core/crypto/partition_data_manager.cpp
+++ b/src/core/crypto/partition_data_manager.cpp
@@ -516,7 +516,8 @@ void PartitionDataManager::DecryptPackage2(const std::array<Key128, 0x20>& packa
         out.insert(out.end(), rodata.begin(), rodata.end());
         out.insert(out.end(), data.begin(), data.end());
 
-        offset += sizeof(KIPHeader) + out.size();
+        offset += sizeof(KIPHeader) + kip.sections[0].size_compressed +
+                  kip.sections[1].size_compressed + kip.sections[2].size_compressed;
 
         if (name == "FS")
             package2_fs[static_cast<size_t>(type)] = std::move(out);
diff --git a/src/core/file_sys/card_image.cpp b/src/core/file_sys/card_image.cpp
index 8f5142a07..ecdd7505b 100644
--- a/src/core/file_sys/card_image.cpp
+++ b/src/core/file_sys/card_image.cpp
@@ -122,14 +122,16 @@ u64 XCI::GetProgramTitleID() const {
     return secure_partition->GetProgramTitleID();
 }
 
-std::shared_ptr<NCA> XCI::GetProgramNCA() const {
-    return program;
+bool XCI::HasProgramNCA() const {
+    return program != nullptr;
 }
 
 VirtualFile XCI::GetProgramNCAFile() const {
-    if (GetProgramNCA() == nullptr)
+    if (!HasProgramNCA()) {
         return nullptr;
-    return GetProgramNCA()->GetBaseFile();
+    }
+
+    return program->GetBaseFile();
 }
 
 const std::vector<std::shared_ptr<NCA>>& XCI::GetNCAs() const {
diff --git a/src/core/file_sys/card_image.h b/src/core/file_sys/card_image.h
index ce514dfa0..48cbef666 100644
--- a/src/core/file_sys/card_image.h
+++ b/src/core/file_sys/card_image.h
@@ -80,7 +80,7 @@ public:
 
     u64 GetProgramTitleID() const;
 
-    std::shared_ptr<NCA> GetProgramNCA() const;
+    bool HasProgramNCA() const;
     VirtualFile GetProgramNCAFile() const;
     const std::vector<std::shared_ptr<NCA>>& GetNCAs() const;
     std::shared_ptr<NCA> GetNCAByType(NCAContentType type) const;
diff --git a/src/core/file_sys/content_archive.cpp b/src/core/file_sys/content_archive.cpp
index 6dcec7816..6c356d85d 100644
--- a/src/core/file_sys/content_archive.cpp
+++ b/src/core/file_sys/content_archive.cpp
@@ -97,11 +97,288 @@ union NCASectionHeader {
 };
 static_assert(sizeof(NCASectionHeader) == 0x200, "NCASectionHeader has incorrect size.");
 
-bool IsValidNCA(const NCAHeader& header) {
+static bool IsValidNCA(const NCAHeader& header) {
     // TODO(DarkLordZach): Add NCA2/NCA0 support.
     return header.magic == Common::MakeMagic('N', 'C', 'A', '3');
 }
 
+NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_offset)
+    : file(std::move(file_)), bktr_base_romfs(std::move(bktr_base_romfs_)) {
+    if (file == nullptr) {
+        status = Loader::ResultStatus::ErrorNullFile;
+        return;
+    }
+
+    if (sizeof(NCAHeader) != file->ReadObject(&header)) {
+        LOG_ERROR(Loader, "File reader errored out during header read.");
+        status = Loader::ResultStatus::ErrorBadNCAHeader;
+        return;
+    }
+
+    if (!HandlePotentialHeaderDecryption()) {
+        return;
+    }
+
+    has_rights_id = std::any_of(header.rights_id.begin(), header.rights_id.end(),
+                                [](char c) { return c != '\0'; });
+
+    const std::vector<NCASectionHeader> sections = ReadSectionHeaders();
+    is_update = std::any_of(sections.begin(), sections.end(), [](const NCASectionHeader& header) {
+        return header.raw.header.crypto_type == NCASectionCryptoType::BKTR;
+    });
+
+    if (!ReadSections(sections, bktr_base_ivfc_offset)) {
+        return;
+    }
+
+    status = Loader::ResultStatus::Success;
+}
+
+NCA::~NCA() = default;
+
+bool NCA::CheckSupportedNCA(const NCAHeader& nca_header) {
+    if (nca_header.magic == Common::MakeMagic('N', 'C', 'A', '2')) {
+        status = Loader::ResultStatus::ErrorNCA2;
+        return false;
+    }
+
+    if (nca_header.magic == Common::MakeMagic('N', 'C', 'A', '0')) {
+        status = Loader::ResultStatus::ErrorNCA0;
+        return false;
+    }
+
+    return true;
+}
+
+bool NCA::HandlePotentialHeaderDecryption() {
+    if (IsValidNCA(header)) {
+        return true;
+    }
+
+    if (!CheckSupportedNCA(header)) {
+        return false;
+    }
+
+    NCAHeader dec_header{};
+    Core::Crypto::AESCipher<Core::Crypto::Key256> cipher(
+        keys.GetKey(Core::Crypto::S256KeyType::Header), Core::Crypto::Mode::XTS);
+    cipher.XTSTranscode(&header, sizeof(NCAHeader), &dec_header, 0, 0x200,
+                        Core::Crypto::Op::Decrypt);
+    if (IsValidNCA(dec_header)) {
+        header = dec_header;
+        encrypted = true;
+    } else {
+        if (!CheckSupportedNCA(dec_header)) {
+            return false;
+        }
+
+        if (keys.HasKey(Core::Crypto::S256KeyType::Header)) {
+            status = Loader::ResultStatus::ErrorIncorrectHeaderKey;
+        } else {
+            status = Loader::ResultStatus::ErrorMissingHeaderKey;
+        }
+        return false;
+    }
+
+    return true;
+}
+
+std::vector<NCASectionHeader> NCA::ReadSectionHeaders() const {
+    const std::ptrdiff_t number_sections =
+        std::count_if(std::begin(header.section_tables), std::end(header.section_tables),
+                      [](NCASectionTableEntry entry) { return entry.media_offset > 0; });
+
+    std::vector<NCASectionHeader> sections(number_sections);
+    const auto length_sections = SECTION_HEADER_SIZE * number_sections;
+
+    if (encrypted) {
+        auto raw = file->ReadBytes(length_sections, SECTION_HEADER_OFFSET);
+        Core::Crypto::AESCipher<Core::Crypto::Key256> cipher(
+            keys.GetKey(Core::Crypto::S256KeyType::Header), Core::Crypto::Mode::XTS);
+        cipher.XTSTranscode(raw.data(), length_sections, sections.data(), 2, SECTION_HEADER_SIZE,
+                            Core::Crypto::Op::Decrypt);
+    } else {
+        file->ReadBytes(sections.data(), length_sections, SECTION_HEADER_OFFSET);
+    }
+
+    return sections;
+}
+
+bool NCA::ReadSections(const std::vector<NCASectionHeader>& sections, u64 bktr_base_ivfc_offset) {
+    for (std::size_t i = 0; i < sections.size(); ++i) {
+        const auto& section = sections[i];
+
+        if (section.raw.header.filesystem_type == NCASectionFilesystemType::ROMFS) {
+            if (!ReadRomFSSection(section, header.section_tables[i], bktr_base_ivfc_offset)) {
+                return false;
+            }
+        } else if (section.raw.header.filesystem_type == NCASectionFilesystemType::PFS0) {
+            if (!ReadPFS0Section(section, header.section_tables[i])) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+bool NCA::ReadRomFSSection(const NCASectionHeader& section, const NCASectionTableEntry& entry,
+                           u64 bktr_base_ivfc_offset) {
+    const std::size_t base_offset = entry.media_offset * MEDIA_OFFSET_MULTIPLIER;
+    ivfc_offset = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset;
+    const std::size_t romfs_offset = base_offset + ivfc_offset;
+    const std::size_t romfs_size = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].size;
+    auto raw = std::make_shared<OffsetVfsFile>(file, romfs_size, romfs_offset);
+    auto dec = Decrypt(section, raw, romfs_offset);
+
+    if (dec == nullptr) {
+        if (status != Loader::ResultStatus::Success)
+            return false;
+        if (has_rights_id)
+            status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
+        else
+            status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
+        return false;
+    }
+
+    if (section.raw.header.crypto_type == NCASectionCryptoType::BKTR) {
+        if (section.bktr.relocation.magic != Common::MakeMagic('B', 'K', 'T', 'R') ||
+            section.bktr.subsection.magic != Common::MakeMagic('B', 'K', 'T', 'R')) {
+            status = Loader::ResultStatus::ErrorBadBKTRHeader;
+            return false;
+        }
+
+        if (section.bktr.relocation.offset + section.bktr.relocation.size !=
+            section.bktr.subsection.offset) {
+            status = Loader::ResultStatus::ErrorBKTRSubsectionNotAfterRelocation;
+            return false;
+        }
+
+        const u64 size = MEDIA_OFFSET_MULTIPLIER * (entry.media_end_offset - entry.media_offset);
+        if (section.bktr.subsection.offset + section.bktr.subsection.size != size) {
+            status = Loader::ResultStatus::ErrorBKTRSubsectionNotAtEnd;
+            return false;
+        }
+
+        const u64 offset = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset;
+        RelocationBlock relocation_block{};
+        if (dec->ReadObject(&relocation_block, section.bktr.relocation.offset - offset) !=
+            sizeof(RelocationBlock)) {
+            status = Loader::ResultStatus::ErrorBadRelocationBlock;
+            return false;
+        }
+        SubsectionBlock subsection_block{};
+        if (dec->ReadObject(&subsection_block, section.bktr.subsection.offset - offset) !=
+            sizeof(RelocationBlock)) {
+            status = Loader::ResultStatus::ErrorBadSubsectionBlock;
+            return false;
+        }
+
+        std::vector<RelocationBucketRaw> relocation_buckets_raw(
+            (section.bktr.relocation.size - sizeof(RelocationBlock)) / sizeof(RelocationBucketRaw));
+        if (dec->ReadBytes(relocation_buckets_raw.data(),
+                           section.bktr.relocation.size - sizeof(RelocationBlock),
+                           section.bktr.relocation.offset + sizeof(RelocationBlock) - offset) !=
+            section.bktr.relocation.size - sizeof(RelocationBlock)) {
+            status = Loader::ResultStatus::ErrorBadRelocationBuckets;
+            return false;
+        }
+
+        std::vector<SubsectionBucketRaw> subsection_buckets_raw(
+            (section.bktr.subsection.size - sizeof(SubsectionBlock)) / sizeof(SubsectionBucketRaw));
+        if (dec->ReadBytes(subsection_buckets_raw.data(),
+                           section.bktr.subsection.size - sizeof(SubsectionBlock),
+                           section.bktr.subsection.offset + sizeof(SubsectionBlock) - offset) !=
+            section.bktr.subsection.size - sizeof(SubsectionBlock)) {
+            status = Loader::ResultStatus::ErrorBadSubsectionBuckets;
+            return false;
+        }
+
+        std::vector<RelocationBucket> relocation_buckets(relocation_buckets_raw.size());
+        std::transform(relocation_buckets_raw.begin(), relocation_buckets_raw.end(),
+                       relocation_buckets.begin(), &ConvertRelocationBucketRaw);
+        std::vector<SubsectionBucket> subsection_buckets(subsection_buckets_raw.size());
+        std::transform(subsection_buckets_raw.begin(), subsection_buckets_raw.end(),
+                       subsection_buckets.begin(), &ConvertSubsectionBucketRaw);
+
+        u32 ctr_low;
+        std::memcpy(&ctr_low, section.raw.section_ctr.data(), sizeof(ctr_low));
+        subsection_buckets.back().entries.push_back({section.bktr.relocation.offset, {0}, ctr_low});
+        subsection_buckets.back().entries.push_back({size, {0}, 0});
+
+        boost::optional<Core::Crypto::Key128> key = boost::none;
+        if (encrypted) {
+            if (has_rights_id) {
+                status = Loader::ResultStatus::Success;
+                key = GetTitlekey();
+                if (key == boost::none) {
+                    status = Loader::ResultStatus::ErrorMissingTitlekey;
+                    return false;
+                }
+            } else {
+                key = GetKeyAreaKey(NCASectionCryptoType::BKTR);
+                if (key == boost::none) {
+                    status = Loader::ResultStatus::ErrorMissingKeyAreaKey;
+                    return false;
+                }
+            }
+        }
+
+        if (bktr_base_romfs == nullptr) {
+            status = Loader::ResultStatus::ErrorMissingBKTRBaseRomFS;
+            return false;
+        }
+
+        auto bktr = std::make_shared<BKTR>(
+            bktr_base_romfs, std::make_shared<OffsetVfsFile>(file, romfs_size, base_offset),
+            relocation_block, relocation_buckets, subsection_block, subsection_buckets, encrypted,
+            encrypted ? key.get() : Core::Crypto::Key128{}, base_offset, bktr_base_ivfc_offset,
+            section.raw.section_ctr);
+
+        // BKTR applies to entire IVFC, so make an offset version to level 6
+        files.push_back(std::make_shared<OffsetVfsFile>(
+            bktr, romfs_size, section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset));
+    } else {
+        files.push_back(std::move(dec));
+    }
+
+    romfs = files.back();
+    return true;
+}
+
+bool NCA::ReadPFS0Section(const NCASectionHeader& section, const NCASectionTableEntry& entry) {
+    const u64 offset = (static_cast<u64>(entry.media_offset) * MEDIA_OFFSET_MULTIPLIER) +
+                       section.pfs0.pfs0_header_offset;
+    const u64 size = MEDIA_OFFSET_MULTIPLIER * (entry.media_end_offset - entry.media_offset);
+
+    auto dec = Decrypt(section, std::make_shared<OffsetVfsFile>(file, size, offset), offset);
+    if (dec != nullptr) {
+        auto npfs = std::make_shared<PartitionFilesystem>(std::move(dec));
+
+        if (npfs->GetStatus() == Loader::ResultStatus::Success) {
+            dirs.push_back(std::move(npfs));
+            if (IsDirectoryExeFS(dirs.back()))
+                exefs = dirs.back();
+        } else {
+            if (has_rights_id)
+                status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
+            else
+                status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
+            return false;
+        }
+    } else {
+        if (status != Loader::ResultStatus::Success)
+            return false;
+        if (has_rights_id)
+            status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
+        else
+            status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
+        return false;
+    }
+
+    return true;
+}
+
 u8 NCA::GetCryptoRevision() const {
     u8 master_key_id = header.crypto_type;
     if (header.crypto_type_2 > master_key_id)
@@ -167,7 +444,7 @@ boost::optional<Core::Crypto::Key128> NCA::GetTitlekey() {
     return titlekey;
 }
 
-VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting_offset) {
+VirtualFile NCA::Decrypt(const NCASectionHeader& s_header, VirtualFile in, u64 starting_offset) {
     if (!encrypted)
         return in;
 
@@ -215,256 +492,6 @@ VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting
     }
 }
 
-NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_offset)
-    : file(std::move(file_)),
-      bktr_base_romfs(bktr_base_romfs_ ? std::move(bktr_base_romfs_) : nullptr) {
-    status = Loader::ResultStatus::Success;
-
-    if (file == nullptr) {
-        status = Loader::ResultStatus::ErrorNullFile;
-        return;
-    }
-
-    if (sizeof(NCAHeader) != file->ReadObject(&header)) {
-        LOG_ERROR(Loader, "File reader errored out during header read.");
-        status = Loader::ResultStatus::ErrorBadNCAHeader;
-        return;
-    }
-
-    encrypted = false;
-
-    if (!IsValidNCA(header)) {
-        if (header.magic == Common::MakeMagic('N', 'C', 'A', '2')) {
-            status = Loader::ResultStatus::ErrorNCA2;
-            return;
-        }
-        if (header.magic == Common::MakeMagic('N', 'C', 'A', '0')) {
-            status = Loader::ResultStatus::ErrorNCA0;
-            return;
-        }
-
-        NCAHeader dec_header{};
-        Core::Crypto::AESCipher<Core::Crypto::Key256> cipher(
-            keys.GetKey(Core::Crypto::S256KeyType::Header), Core::Crypto::Mode::XTS);
-        cipher.XTSTranscode(&header, sizeof(NCAHeader), &dec_header, 0, 0x200,
-                            Core::Crypto::Op::Decrypt);
-        if (IsValidNCA(dec_header)) {
-            header = dec_header;
-            encrypted = true;
-        } else {
-            if (dec_header.magic == Common::MakeMagic('N', 'C', 'A', '2')) {
-                status = Loader::ResultStatus::ErrorNCA2;
-                return;
-            }
-            if (dec_header.magic == Common::MakeMagic('N', 'C', 'A', '0')) {
-                status = Loader::ResultStatus::ErrorNCA0;
-                return;
-            }
-
-            if (!keys.HasKey(Core::Crypto::S256KeyType::Header))
-                status = Loader::ResultStatus::ErrorMissingHeaderKey;
-            else
-                status = Loader::ResultStatus::ErrorIncorrectHeaderKey;
-            return;
-        }
-    }
-
-    has_rights_id = std::find_if_not(header.rights_id.begin(), header.rights_id.end(),
-                                     [](char c) { return c == '\0'; }) != header.rights_id.end();
-
-    const std::ptrdiff_t number_sections =
-        std::count_if(std::begin(header.section_tables), std::end(header.section_tables),
-                      [](NCASectionTableEntry entry) { return entry.media_offset > 0; });
-
-    std::vector<NCASectionHeader> sections(number_sections);
-    const auto length_sections = SECTION_HEADER_SIZE * number_sections;
-
-    if (encrypted) {
-        auto raw = file->ReadBytes(length_sections, SECTION_HEADER_OFFSET);
-        Core::Crypto::AESCipher<Core::Crypto::Key256> cipher(
-            keys.GetKey(Core::Crypto::S256KeyType::Header), Core::Crypto::Mode::XTS);
-        cipher.XTSTranscode(raw.data(), length_sections, sections.data(), 2, SECTION_HEADER_SIZE,
-                            Core::Crypto::Op::Decrypt);
-    } else {
-        file->ReadBytes(sections.data(), length_sections, SECTION_HEADER_OFFSET);
-    }
-
-    is_update = std::find_if(sections.begin(), sections.end(), [](const NCASectionHeader& header) {
-                    return header.raw.header.crypto_type == NCASectionCryptoType::BKTR;
-                }) != sections.end();
-    ivfc_offset = 0;
-
-    for (std::ptrdiff_t i = 0; i < number_sections; ++i) {
-        auto section = sections[i];
-
-        if (section.raw.header.filesystem_type == NCASectionFilesystemType::ROMFS) {
-            const std::size_t base_offset =
-                header.section_tables[i].media_offset * MEDIA_OFFSET_MULTIPLIER;
-            ivfc_offset = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset;
-            const std::size_t romfs_offset = base_offset + ivfc_offset;
-            const std::size_t romfs_size = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].size;
-            auto raw = std::make_shared<OffsetVfsFile>(file, romfs_size, romfs_offset);
-            auto dec = Decrypt(section, raw, romfs_offset);
-
-            if (dec == nullptr) {
-                if (status != Loader::ResultStatus::Success)
-                    return;
-                if (has_rights_id)
-                    status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
-                else
-                    status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
-                return;
-            }
-
-            if (section.raw.header.crypto_type == NCASectionCryptoType::BKTR) {
-                if (section.bktr.relocation.magic != Common::MakeMagic('B', 'K', 'T', 'R') ||
-                    section.bktr.subsection.magic != Common::MakeMagic('B', 'K', 'T', 'R')) {
-                    status = Loader::ResultStatus::ErrorBadBKTRHeader;
-                    return;
-                }
-
-                if (section.bktr.relocation.offset + section.bktr.relocation.size !=
-                    section.bktr.subsection.offset) {
-                    status = Loader::ResultStatus::ErrorBKTRSubsectionNotAfterRelocation;
-                    return;
-                }
-
-                const u64 size =
-                    MEDIA_OFFSET_MULTIPLIER * (header.section_tables[i].media_end_offset -
-                                               header.section_tables[i].media_offset);
-                if (section.bktr.subsection.offset + section.bktr.subsection.size != size) {
-                    status = Loader::ResultStatus::ErrorBKTRSubsectionNotAtEnd;
-                    return;
-                }
-
-                const u64 offset = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset;
-                RelocationBlock relocation_block{};
-                if (dec->ReadObject(&relocation_block, section.bktr.relocation.offset - offset) !=
-                    sizeof(RelocationBlock)) {
-                    status = Loader::ResultStatus::ErrorBadRelocationBlock;
-                    return;
-                }
-                SubsectionBlock subsection_block{};
-                if (dec->ReadObject(&subsection_block, section.bktr.subsection.offset - offset) !=
-                    sizeof(RelocationBlock)) {
-                    status = Loader::ResultStatus::ErrorBadSubsectionBlock;
-                    return;
-                }
-
-                std::vector<RelocationBucketRaw> relocation_buckets_raw(
-                    (section.bktr.relocation.size - sizeof(RelocationBlock)) /
-                    sizeof(RelocationBucketRaw));
-                if (dec->ReadBytes(relocation_buckets_raw.data(),
-                                   section.bktr.relocation.size - sizeof(RelocationBlock),
-                                   section.bktr.relocation.offset + sizeof(RelocationBlock) -
-                                       offset) !=
-                    section.bktr.relocation.size - sizeof(RelocationBlock)) {
-                    status = Loader::ResultStatus::ErrorBadRelocationBuckets;
-                    return;
-                }
-
-                std::vector<SubsectionBucketRaw> subsection_buckets_raw(
-                    (section.bktr.subsection.size - sizeof(SubsectionBlock)) /
-                    sizeof(SubsectionBucketRaw));
-                if (dec->ReadBytes(subsection_buckets_raw.data(),
-                                   section.bktr.subsection.size - sizeof(SubsectionBlock),
-                                   section.bktr.subsection.offset + sizeof(SubsectionBlock) -
-                                       offset) !=
-                    section.bktr.subsection.size - sizeof(SubsectionBlock)) {
-                    status = Loader::ResultStatus::ErrorBadSubsectionBuckets;
-                    return;
-                }
-
-                std::vector<RelocationBucket> relocation_buckets(relocation_buckets_raw.size());
-                std::transform(relocation_buckets_raw.begin(), relocation_buckets_raw.end(),
-                               relocation_buckets.begin(), &ConvertRelocationBucketRaw);
-                std::vector<SubsectionBucket> subsection_buckets(subsection_buckets_raw.size());
-                std::transform(subsection_buckets_raw.begin(), subsection_buckets_raw.end(),
-                               subsection_buckets.begin(), &ConvertSubsectionBucketRaw);
-
-                u32 ctr_low;
-                std::memcpy(&ctr_low, section.raw.section_ctr.data(), sizeof(ctr_low));
-                subsection_buckets.back().entries.push_back(
-                    {section.bktr.relocation.offset, {0}, ctr_low});
-                subsection_buckets.back().entries.push_back({size, {0}, 0});
-
-                boost::optional<Core::Crypto::Key128> key = boost::none;
-                if (encrypted) {
-                    if (has_rights_id) {
-                        status = Loader::ResultStatus::Success;
-                        key = GetTitlekey();
-                        if (key == boost::none) {
-                            status = Loader::ResultStatus::ErrorMissingTitlekey;
-                            return;
-                        }
-                    } else {
-                        key = GetKeyAreaKey(NCASectionCryptoType::BKTR);
-                        if (key == boost::none) {
-                            status = Loader::ResultStatus::ErrorMissingKeyAreaKey;
-                            return;
-                        }
-                    }
-                }
-
-                if (bktr_base_romfs == nullptr) {
-                    status = Loader::ResultStatus::ErrorMissingBKTRBaseRomFS;
-                    return;
-                }
-
-                auto bktr = std::make_shared<BKTR>(
-                    bktr_base_romfs, std::make_shared<OffsetVfsFile>(file, romfs_size, base_offset),
-                    relocation_block, relocation_buckets, subsection_block, subsection_buckets,
-                    encrypted, encrypted ? key.get() : Core::Crypto::Key128{}, base_offset,
-                    bktr_base_ivfc_offset, section.raw.section_ctr);
-
-                // BKTR applies to entire IVFC, so make an offset version to level 6
-
-                files.push_back(std::make_shared<OffsetVfsFile>(
-                    bktr, romfs_size, section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset));
-                romfs = files.back();
-            } else {
-                files.push_back(std::move(dec));
-                romfs = files.back();
-            }
-        } else if (section.raw.header.filesystem_type == NCASectionFilesystemType::PFS0) {
-            u64 offset = (static_cast<u64>(header.section_tables[i].media_offset) *
-                          MEDIA_OFFSET_MULTIPLIER) +
-                         section.pfs0.pfs0_header_offset;
-            u64 size = MEDIA_OFFSET_MULTIPLIER * (header.section_tables[i].media_end_offset -
-                                                  header.section_tables[i].media_offset);
-            auto dec =
-                Decrypt(section, std::make_shared<OffsetVfsFile>(file, size, offset), offset);
-            if (dec != nullptr) {
-                auto npfs = std::make_shared<PartitionFilesystem>(std::move(dec));
-
-                if (npfs->GetStatus() == Loader::ResultStatus::Success) {
-                    dirs.push_back(std::move(npfs));
-                    if (IsDirectoryExeFS(dirs.back()))
-                        exefs = dirs.back();
-                } else {
-                    if (has_rights_id)
-                        status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
-                    else
-                        status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
-                    return;
-                }
-            } else {
-                if (status != Loader::ResultStatus::Success)
-                    return;
-                if (has_rights_id)
-                    status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
-                else
-                    status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
-                return;
-            }
-        }
-    }
-
-    status = Loader::ResultStatus::Success;
-}
-
-NCA::~NCA() = default;
-
 Loader::ResultStatus NCA::GetStatus() const {
     return status;
 }
diff --git a/src/core/file_sys/content_archive.h b/src/core/file_sys/content_archive.h
index f9f66cae9..1c903cd3f 100644
--- a/src/core/file_sys/content_archive.h
+++ b/src/core/file_sys/content_archive.h
@@ -73,8 +73,6 @@ inline bool IsDirectoryExeFS(const std::shared_ptr<VfsDirectory>& pfs) {
     return pfs->GetFile("main") != nullptr && pfs->GetFile("main.npdm") != nullptr;
 }
 
-bool IsValidNCA(const NCAHeader& header);
-
 // An implementation of VfsDirectory that represents a Nintendo Content Archive (NCA) conatiner.
 // After construction, use GetStatus to determine if the file is valid and ready to be used.
 class NCA : public ReadOnlyVfsDirectory {
@@ -106,10 +104,19 @@ protected:
     bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
 
 private:
+    bool CheckSupportedNCA(const NCAHeader& header);
+    bool HandlePotentialHeaderDecryption();
+
+    std::vector<NCASectionHeader> ReadSectionHeaders() const;
+    bool ReadSections(const std::vector<NCASectionHeader>& sections, u64 bktr_base_ivfc_offset);
+    bool ReadRomFSSection(const NCASectionHeader& section, const NCASectionTableEntry& entry,
+                          u64 bktr_base_ivfc_offset);
+    bool ReadPFS0Section(const NCASectionHeader& section, const NCASectionTableEntry& entry);
+
     u8 GetCryptoRevision() const;
     boost::optional<Core::Crypto::Key128> GetKeyAreaKey(NCASectionCryptoType type) const;
     boost::optional<Core::Crypto::Key128> GetTitlekey();
-    VirtualFile Decrypt(NCASectionHeader header, VirtualFile in, u64 starting_offset);
+    VirtualFile Decrypt(const NCASectionHeader& header, VirtualFile in, u64 starting_offset);
 
     std::vector<VirtualDir> dirs;
     std::vector<VirtualFile> files;
@@ -118,15 +125,15 @@ private:
     VirtualDir exefs = nullptr;
     VirtualFile file;
     VirtualFile bktr_base_romfs;
-    u64 ivfc_offset;
+    u64 ivfc_offset = 0;
 
     NCAHeader header{};
     bool has_rights_id{};
 
     Loader::ResultStatus status{};
 
-    bool encrypted;
-    bool is_update;
+    bool encrypted = false;
+    bool is_update = false;
 
     Core::Crypto::KeyManager keys;
 };
diff --git a/src/core/file_sys/savedata_factory.cpp b/src/core/file_sys/savedata_factory.cpp
index 47f2ab9e0..ef1aaebbb 100644
--- a/src/core/file_sys/savedata_factory.cpp
+++ b/src/core/file_sys/savedata_factory.cpp
@@ -51,6 +51,13 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, SaveDataDescr
                     meta.title_id);
     }
 
+    if (meta.type == SaveDataType::DeviceSaveData && meta.user_id != u128{0, 0}) {
+        LOG_WARNING(Service_FS,
+                    "Possibly incorrect SaveDataDescriptor, type is DeviceSaveData but user_id is "
+                    "non-zero ({:016X}{:016X})",
+                    meta.user_id[1], meta.user_id[0]);
+    }
+
     std::string save_directory =
         GetFullPath(space, meta.type, meta.title_id, meta.user_id, meta.save_id);
 
@@ -92,6 +99,9 @@ std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType typ
     case SaveDataSpaceId::NandUser:
         out = "/user/";
         break;
+    case SaveDataSpaceId::TemporaryStorage:
+        out = "/temp/";
+        break;
     default:
         ASSERT_MSG(false, "Unrecognized SaveDataSpaceId: {:02X}", static_cast<u8>(space));
     }
@@ -100,10 +110,11 @@ std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType typ
     case SaveDataType::SystemSaveData:
         return fmt::format("{}save/{:016X}/{:016X}{:016X}", out, save_id, user_id[1], user_id[0]);
     case SaveDataType::SaveData:
+    case SaveDataType::DeviceSaveData:
         return fmt::format("{}save/{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
                            title_id);
     case SaveDataType::TemporaryStorage:
-        return fmt::format("{}temp/{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
+        return fmt::format("{}{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
                            title_id);
     default:
         ASSERT_MSG(false, "Unrecognized SaveDataType: {:02X}", static_cast<u8>(type));
diff --git a/src/core/hle/kernel/hle_ipc.cpp b/src/core/hle/kernel/hle_ipc.cpp
index edad5f1b1..68d5376cb 100644
--- a/src/core/hle/kernel/hle_ipc.cpp
+++ b/src/core/hle/kernel/hle_ipc.cpp
@@ -77,7 +77,8 @@ HLERequestContext::HLERequestContext(SharedPtr<Kernel::ServerSession> server_ses
 
 HLERequestContext::~HLERequestContext() = default;
 
-void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
+void HLERequestContext::ParseCommandBuffer(const HandleTable& handle_table, u32_le* src_cmdbuf,
+                                           bool incoming) {
     IPC::RequestParser rp(src_cmdbuf);
     command_header = std::make_shared<IPC::CommandHeader>(rp.PopRaw<IPC::CommandHeader>());
 
@@ -94,8 +95,6 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
             rp.Skip(2, false);
         }
         if (incoming) {
-            auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
-
             // Populate the object lists with the data in the IPC request.
             for (u32 handle = 0; handle < handle_descriptor_header->num_handles_to_copy; ++handle) {
                 copy_objects.push_back(handle_table.GetGeneric(rp.Pop<Handle>()));
@@ -189,10 +188,9 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
     rp.Skip(1, false); // The command is actually an u64, but we don't use the high part.
 }
 
-ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(u32_le* src_cmdbuf,
-                                                                Process& src_process,
-                                                                HandleTable& src_table) {
-    ParseCommandBuffer(src_cmdbuf, true);
+ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(const HandleTable& handle_table,
+                                                                u32_le* src_cmdbuf) {
+    ParseCommandBuffer(handle_table, src_cmdbuf, true);
     if (command_header->type == IPC::CommandType::Close) {
         // Close does not populate the rest of the IPC header
         return RESULT_SUCCESS;
@@ -207,14 +205,17 @@ ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(u32_le* src_cmdb
     return RESULT_SUCCESS;
 }
 
-ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(const Thread& thread) {
+ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {
+    auto& owner_process = *thread.GetOwnerProcess();
+    auto& handle_table = owner_process.GetHandleTable();
+
     std::array<u32, IPC::COMMAND_BUFFER_LENGTH> dst_cmdbuf;
-    Memory::ReadBlock(*thread.GetOwnerProcess(), thread.GetTLSAddress(), dst_cmdbuf.data(),
+    Memory::ReadBlock(owner_process, thread.GetTLSAddress(), dst_cmdbuf.data(),
                       dst_cmdbuf.size() * sizeof(u32));
 
     // The header was already built in the internal command buffer. Attempt to parse it to verify
     // the integrity and then copy it over to the target command buffer.
-    ParseCommandBuffer(cmd_buf.data(), false);
+    ParseCommandBuffer(handle_table, cmd_buf.data(), false);
 
     // The data_size already includes the payload header, the padding and the domain header.
     std::size_t size = data_payload_offset + command_header->data_size -
@@ -236,8 +237,6 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(const Thread& thread)
         ASSERT(copy_objects.size() == handle_descriptor_header->num_handles_to_copy);
         ASSERT(move_objects.size() == handle_descriptor_header->num_handles_to_move);
 
-        auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
-
         // We don't make a distinction between copy and move handles when translating since HLE
         // services don't deal with handles directly. However, the guest applications might check
         // for specific values in each of these descriptors.
@@ -268,7 +267,7 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(const Thread& thread)
     }
 
     // Copy the translated command buffer back into the thread's command buffer area.
-    Memory::WriteBlock(*thread.GetOwnerProcess(), thread.GetTLSAddress(), dst_cmdbuf.data(),
+    Memory::WriteBlock(owner_process, thread.GetTLSAddress(), dst_cmdbuf.data(),
                        dst_cmdbuf.size() * sizeof(u32));
 
     return RESULT_SUCCESS;
diff --git a/src/core/hle/kernel/hle_ipc.h b/src/core/hle/kernel/hle_ipc.h
index 894479ee0..f01491daa 100644
--- a/src/core/hle/kernel/hle_ipc.h
+++ b/src/core/hle/kernel/hle_ipc.h
@@ -24,10 +24,10 @@ class ServiceFrameworkBase;
 namespace Kernel {
 
 class Domain;
+class Event;
 class HandleTable;
 class HLERequestContext;
 class Process;
-class Event;
 
 /**
  * Interface implemented by HLE Session handlers.
@@ -126,13 +126,12 @@ public:
                                        u64 timeout, WakeupCallback&& callback,
                                        Kernel::SharedPtr<Kernel::Event> event = nullptr);
 
-    void ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming);
-
     /// Populates this context with data from the requesting process/thread.
-    ResultCode PopulateFromIncomingCommandBuffer(u32_le* src_cmdbuf, Process& src_process,
-                                                 HandleTable& src_table);
+    ResultCode PopulateFromIncomingCommandBuffer(const HandleTable& handle_table,
+                                                 u32_le* src_cmdbuf);
+
     /// Writes data from this context back to the requesting process/thread.
-    ResultCode WriteToOutgoingCommandBuffer(const Thread& thread);
+    ResultCode WriteToOutgoingCommandBuffer(Thread& thread);
 
     u32_le GetCommand() const {
         return command;
@@ -255,6 +254,8 @@ public:
     std::string Description() const;
 
 private:
+    void ParseCommandBuffer(const HandleTable& handle_table, u32_le* src_cmdbuf, bool incoming);
+
     std::array<u32, IPC::COMMAND_BUFFER_LENGTH> cmd_buf;
     SharedPtr<Kernel::ServerSession> server_session;
     // TODO(yuriks): Check common usage of this and optimize size accordingly
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index bd680adfe..4b6b32dd5 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -118,7 +118,6 @@ struct KernelCore::Impl {
         process_list.clear();
         current_process = nullptr;
 
-        handle_table.Clear();
         resource_limits.fill(nullptr);
 
         thread_wakeup_callback_handle_table.Clear();
@@ -209,7 +208,6 @@ struct KernelCore::Impl {
     std::vector<SharedPtr<Process>> process_list;
     Process* current_process = nullptr;
 
-    Kernel::HandleTable handle_table;
     std::array<SharedPtr<ResourceLimit>, 4> resource_limits;
 
     /// The event type of the generic timer callback event
@@ -241,14 +239,6 @@ void KernelCore::Shutdown() {
     impl->Shutdown();
 }
 
-Kernel::HandleTable& KernelCore::HandleTable() {
-    return impl->handle_table;
-}
-
-const Kernel::HandleTable& KernelCore::HandleTable() const {
-    return impl->handle_table;
-}
-
 SharedPtr<ResourceLimit> KernelCore::ResourceLimitForCategory(
     ResourceLimitCategory category) const {
     return impl->resource_limits.at(static_cast<std::size_t>(category));
diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h
index 41554821f..7f822d524 100644
--- a/src/core/hle/kernel/kernel.h
+++ b/src/core/hle/kernel/kernel.h
@@ -47,12 +47,6 @@ public:
     /// Clears all resources in use by the kernel instance.
     void Shutdown();
 
-    /// Provides a reference to the handle table.
-    Kernel::HandleTable& HandleTable();
-
-    /// Provides a const reference to the handle table.
-    const Kernel::HandleTable& HandleTable() const;
-
     /// Retrieves a shared pointer to a ResourceLimit identified by the given category.
     SharedPtr<ResourceLimit> ResourceLimitForCategory(ResourceLimitCategory category) const;
 
diff --git a/src/core/hle/kernel/process.h b/src/core/hle/kernel/process.h
index f2816943a..148478488 100644
--- a/src/core/hle/kernel/process.h
+++ b/src/core/hle/kernel/process.h
@@ -13,6 +13,7 @@
 #include <boost/container/static_vector.hpp>
 #include "common/bit_field.h"
 #include "common/common_types.h"
+#include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/vm_manager.h"
@@ -142,6 +143,16 @@ public:
         return vm_manager;
     }
 
+    /// Gets a reference to the process' handle table.
+    HandleTable& GetHandleTable() {
+        return handle_table;
+    }
+
+    /// Gets a const reference to the process' handle table.
+    const HandleTable& GetHandleTable() const {
+        return handle_table;
+    }
+
     /// Gets the current status of the process
     ProcessStatus GetStatus() const {
         return status;
@@ -294,6 +305,9 @@ private:
     /// specified by metadata provided to the process during loading.
     bool is_64bit_process = true;
 
+    /// Per-process handle table for storing created object handles in.
+    HandleTable handle_table;
+
     std::string name;
 };
 
diff --git a/src/core/hle/kernel/server_session.cpp b/src/core/hle/kernel/server_session.cpp
index 1ece691c7..5fc320403 100644
--- a/src/core/hle/kernel/server_session.cpp
+++ b/src/core/hle/kernel/server_session.cpp
@@ -107,8 +107,7 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
     // similar.
     Kernel::HLERequestContext context(this);
     u32* cmd_buf = (u32*)Memory::GetPointer(thread->GetTLSAddress());
-    context.PopulateFromIncomingCommandBuffer(cmd_buf, *Core::CurrentProcess(),
-                                              kernel.HandleTable());
+    context.PopulateFromIncomingCommandBuffer(kernel.CurrentProcess()->GetHandleTable(), cmd_buf);
 
     ResultCode result = RESULT_SUCCESS;
     // If the session has been converted to a domain, handle the domain request
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index 3e5f11f2b..67ea67666 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -8,6 +8,7 @@
 #include <mutex>
 #include <vector>
 
+#include "common/alignment.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/microprofile.h"
@@ -36,9 +37,6 @@
 
 namespace Kernel {
 namespace {
-constexpr bool Is4KBAligned(VAddr address) {
-    return (address & 0xFFF) == 0;
-}
 
 // Checks if address + size is greater than the given address
 // This can return false if the size causes an overflow of a 64-bit type
@@ -69,11 +67,11 @@ bool IsInsideNewMapRegion(const VMManager& vm, VAddr address, u64 size) {
 // in the same order.
 ResultCode MapUnmapMemorySanityChecks(const VMManager& vm_manager, VAddr dst_addr, VAddr src_addr,
                                       u64 size) {
-    if (!Is4KBAligned(dst_addr) || !Is4KBAligned(src_addr)) {
+    if (!Common::Is4KBAligned(dst_addr) || !Common::Is4KBAligned(src_addr)) {
         return ERR_INVALID_ADDRESS;
     }
 
-    if (size == 0 || !Is4KBAligned(size)) {
+    if (size == 0 || !Common::Is4KBAligned(size)) {
         return ERR_INVALID_SIZE;
     }
 
@@ -191,14 +189,15 @@ static ResultCode ConnectToNamedPort(Handle* out_handle, VAddr port_name_address
     CASCADE_RESULT(client_session, client_port->Connect());
 
     // Return the client session
-    CASCADE_RESULT(*out_handle, kernel.HandleTable().Create(client_session));
+    auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    CASCADE_RESULT(*out_handle, handle_table.Create(client_session));
     return RESULT_SUCCESS;
 }
 
 /// Makes a blocking IPC call to an OS service.
 static ResultCode SendSyncRequest(Handle handle) {
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<ClientSession> session = kernel.HandleTable().Get<ClientSession>(handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    SharedPtr<ClientSession> session = handle_table.Get<ClientSession>(handle);
     if (!session) {
         LOG_ERROR(Kernel_SVC, "called with invalid handle=0x{:08X}", handle);
         return ERR_INVALID_HANDLE;
@@ -217,8 +216,8 @@ static ResultCode SendSyncRequest(Handle handle) {
 static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
     LOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         return ERR_INVALID_HANDLE;
     }
@@ -231,8 +230,8 @@ static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
 static ResultCode GetProcessId(u32* process_id, Handle process_handle) {
     LOG_TRACE(Kernel_SVC, "called process=0x{:08X}", process_handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Process> process = kernel.HandleTable().Get<Process>(process_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    const SharedPtr<Process> process = handle_table.Get<Process>(process_handle);
     if (!process) {
         return ERR_INVALID_HANDLE;
     }
@@ -275,11 +274,11 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
 
     using ObjectPtr = Thread::ThreadWaitObjects::value_type;
     Thread::ThreadWaitObjects objects(handle_count);
-    auto& kernel = Core::System::GetInstance().Kernel();
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
 
     for (u64 i = 0; i < handle_count; ++i) {
         const Handle handle = Memory::Read32(handles_address + i * sizeof(Handle));
-        const auto object = kernel.HandleTable().Get<WaitObject>(handle);
+        const auto object = handle_table.Get<WaitObject>(handle);
 
         if (object == nullptr) {
             return ERR_INVALID_HANDLE;
@@ -327,8 +326,8 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
 static ResultCode CancelSynchronization(Handle thread_handle) {
     LOG_TRACE(Kernel_SVC, "called thread=0x{:X}", thread_handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         return ERR_INVALID_HANDLE;
     }
@@ -352,7 +351,11 @@ static ResultCode ArbitrateLock(Handle holding_thread_handle, VAddr mutex_addr,
         return ERR_INVALID_ADDRESS_STATE;
     }
 
-    auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
+    if (!Common::IsWordAligned(mutex_addr)) {
+        return ERR_INVALID_ADDRESS;
+    }
+
+    auto& handle_table = Core::CurrentProcess()->GetHandleTable();
     return Mutex::TryAcquire(handle_table, mutex_addr, holding_thread_handle,
                              requesting_thread_handle);
 }
@@ -365,6 +368,10 @@ static ResultCode ArbitrateUnlock(VAddr mutex_addr) {
         return ERR_INVALID_ADDRESS_STATE;
     }
 
+    if (!Common::IsWordAligned(mutex_addr)) {
+        return ERR_INVALID_ADDRESS;
+    }
+
     return Mutex::Release(mutex_addr);
 }
 
@@ -448,25 +455,12 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
     case GetInfoType::RandomEntropy:
         *result = 0;
         break;
-    case GetInfoType::AddressSpaceBaseAddr:
-        *result = vm_manager.GetCodeRegionBaseAddress();
+    case GetInfoType::ASLRRegionBaseAddr:
+        *result = vm_manager.GetASLRRegionBaseAddress();
         break;
-    case GetInfoType::AddressSpaceSize: {
-        const u64 width = vm_manager.GetAddressSpaceWidth();
-
-        switch (width) {
-        case 32:
-            *result = 0xFFE00000;
-            break;
-        case 36:
-            *result = 0xFF8000000;
-            break;
-        case 39:
-            *result = 0x7FF8000000;
-            break;
-        }
+    case GetInfoType::ASLRRegionSize:
+        *result = vm_manager.GetASLRRegionSize();
         break;
-    }
     case GetInfoType::NewMapRegionBaseAddr:
         *result = vm_manager.GetNewMapRegionBaseAddress();
         break;
@@ -506,13 +500,12 @@ static ResultCode SetThreadActivity(Handle handle, u32 unknown) {
 static ResultCode GetThreadContext(VAddr thread_context, Handle handle) {
     LOG_DEBUG(Kernel_SVC, "called, context=0x{:08X}, thread=0x{:X}", thread_context, handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(handle);
+    const auto* current_process = Core::CurrentProcess();
+    const SharedPtr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
     if (!thread) {
         return ERR_INVALID_HANDLE;
     }
 
-    const auto* current_process = Core::CurrentProcess();
     if (thread->GetOwnerProcess() != current_process) {
         return ERR_INVALID_HANDLE;
     }
@@ -538,10 +531,11 @@ static ResultCode GetThreadContext(VAddr thread_context, Handle handle) {
 
 /// Gets the priority for the specified thread
 static ResultCode GetThreadPriority(u32* priority, Handle handle) {
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(handle);
-    if (!thread)
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(handle);
+    if (!thread) {
         return ERR_INVALID_HANDLE;
+    }
 
     *priority = thread->GetPriority();
     return RESULT_SUCCESS;
@@ -553,14 +547,15 @@ static ResultCode SetThreadPriority(Handle handle, u32 priority) {
         return ERR_INVALID_THREAD_PRIORITY;
     }
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(handle);
-    if (!thread)
+    const auto* const current_process = Core::CurrentProcess();
+    SharedPtr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
+    if (!thread) {
         return ERR_INVALID_HANDLE;
+    }
 
     // Note: The kernel uses the current process's resource limit instead of
     // the one from the thread owner's resource limit.
-    const ResourceLimit& resource_limit = Core::CurrentProcess()->GetResourceLimit();
+    const ResourceLimit& resource_limit = current_process->GetResourceLimit();
     if (resource_limit.GetMaxResourceValue(ResourceType::Priority) > priority) {
         return ERR_NOT_AUTHORIZED;
     }
@@ -583,14 +578,18 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
               "called, shared_memory_handle=0x{:X}, addr=0x{:X}, size=0x{:X}, permissions=0x{:08X}",
               shared_memory_handle, addr, size, permissions);
 
-    if (!Is4KBAligned(addr)) {
+    if (!Common::Is4KBAligned(addr)) {
         return ERR_INVALID_ADDRESS;
     }
 
-    if (size == 0 || !Is4KBAligned(size)) {
+    if (size == 0 || !Common::Is4KBAligned(size)) {
         return ERR_INVALID_SIZE;
     }
 
+    if (!IsValidAddressRange(addr, size)) {
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+
     const auto permissions_type = static_cast<MemoryPermission>(permissions);
     if (permissions_type != MemoryPermission::Read &&
         permissions_type != MemoryPermission::ReadWrite) {
@@ -598,46 +597,61 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
         return ERR_INVALID_MEMORY_PERMISSIONS;
     }
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    auto shared_memory = kernel.HandleTable().Get<SharedMemory>(shared_memory_handle);
+    auto* const current_process = Core::CurrentProcess();
+    auto shared_memory = current_process->GetHandleTable().Get<SharedMemory>(shared_memory_handle);
     if (!shared_memory) {
         return ERR_INVALID_HANDLE;
     }
 
-    return shared_memory->Map(Core::CurrentProcess(), addr, permissions_type,
-                              MemoryPermission::DontCare);
+    const auto& vm_manager = current_process->VMManager();
+    if (!vm_manager.IsWithinASLRRegion(addr, size)) {
+        return ERR_INVALID_MEMORY_RANGE;
+    }
+
+    return shared_memory->Map(current_process, addr, permissions_type, MemoryPermission::DontCare);
 }
 
 static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 size) {
     LOG_WARNING(Kernel_SVC, "called, shared_memory_handle=0x{:08X}, addr=0x{:X}, size=0x{:X}",
                 shared_memory_handle, addr, size);
 
-    if (!Is4KBAligned(addr)) {
+    if (!Common::Is4KBAligned(addr)) {
         return ERR_INVALID_ADDRESS;
     }
 
-    if (size == 0 || !Is4KBAligned(size)) {
+    if (size == 0 || !Common::Is4KBAligned(size)) {
         return ERR_INVALID_SIZE;
     }
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    auto shared_memory = kernel.HandleTable().Get<SharedMemory>(shared_memory_handle);
+    if (!IsValidAddressRange(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) {
+        return ERR_INVALID_HANDLE;
+    }
+
+    const auto& vm_manager = current_process->VMManager();
+    if (!vm_manager.IsWithinASLRRegion(addr, size)) {
+        return ERR_INVALID_MEMORY_RANGE;
+    }
 
-    return shared_memory->Unmap(Core::CurrentProcess(), addr);
+    return shared_memory->Unmap(current_process, addr);
 }
 
 /// Query process memory
 static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_info*/,
                                      Handle process_handle, u64 addr) {
-
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<Process> process = kernel.HandleTable().Get<Process>(process_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    SharedPtr<Process> process = handle_table.Get<Process>(process_handle);
     if (!process) {
         return ERR_INVALID_HANDLE;
     }
     auto vma = process->VMManager().FindVMA(addr);
     memory_info->attributes = 0;
-    if (vma == Core::CurrentProcess()->VMManager().vma_map.end()) {
+    if (vma == process->VMManager().vma_map.end()) {
         memory_info->base_address = 0;
         memory_info->permission = static_cast<u32>(VMAPermission::None);
         memory_info->size = 0;
@@ -678,20 +692,19 @@ 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) {
-    std::string name = fmt::format("thread-{:X}", entry_point);
-
     if (priority > THREADPRIO_LOWEST) {
         return ERR_INVALID_THREAD_PRIORITY;
     }
 
-    const ResourceLimit& resource_limit = Core::CurrentProcess()->GetResourceLimit();
+    auto* const current_process = Core::CurrentProcess();
+    const ResourceLimit& resource_limit = current_process->GetResourceLimit();
     if (resource_limit.GetMaxResourceValue(ResourceType::Priority) > priority) {
         return ERR_NOT_AUTHORIZED;
     }
 
     if (processor_id == THREADPROCESSORID_DEFAULT) {
         // Set the target CPU to the one specified in the process' exheader.
-        processor_id = Core::CurrentProcess()->GetDefaultProcessorID();
+        processor_id = current_process->GetDefaultProcessorID();
         ASSERT(processor_id != THREADPROCESSORID_DEFAULT);
     }
 
@@ -706,11 +719,13 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
         return ERR_INVALID_PROCESSOR_ID;
     }
 
+    const std::string name = fmt::format("thread-{:X}", entry_point);
     auto& kernel = Core::System::GetInstance().Kernel();
     CASCADE_RESULT(SharedPtr<Thread> thread,
                    Thread::Create(kernel, name, entry_point, priority, arg, processor_id, stack_top,
-                                  *Core::CurrentProcess()));
-    const auto new_guest_handle = kernel.HandleTable().Create(thread);
+                                  *current_process));
+
+    const auto new_guest_handle = current_process->GetHandleTable().Create(thread);
     if (new_guest_handle.Failed()) {
         return new_guest_handle.Code();
     }
@@ -731,8 +746,8 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
 static ResultCode StartThread(Handle thread_handle) {
     LOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         return ERR_INVALID_HANDLE;
     }
@@ -779,8 +794,8 @@ static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_var
         "called mutex_addr={:X}, condition_variable_addr={:X}, thread_handle=0x{:08X}, timeout={}",
         mutex_addr, condition_variable_addr, thread_handle, nano_seconds);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
     ASSERT(thread);
 
     CASCADE_CODE(Mutex::Release(mutex_addr));
@@ -891,9 +906,9 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
                                                mutex_val | Mutex::MutexHasWaitersFlag));
 
             // The mutex is already owned by some other thread, make this thread wait on it.
-            auto& kernel = Core::System::GetInstance().Kernel();
-            Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
-            auto owner = kernel.HandleTable().Get<Thread>(owner_handle);
+            const Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
+            const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+            auto owner = handle_table.Get<Thread>(owner_handle);
             ASSERT(owner);
             ASSERT(thread->GetStatus() == ThreadStatus::WaitMutex);
             thread->InvalidateWakeupCallback();
@@ -972,16 +987,16 @@ static u64 GetSystemTick() {
 static ResultCode CloseHandle(Handle handle) {
     LOG_TRACE(Kernel_SVC, "Closing handle 0x{:08X}", handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    return kernel.HandleTable().Close(handle);
+    auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    return handle_table.Close(handle);
 }
 
 /// Reset an event
 static ResultCode ResetSignal(Handle handle) {
     LOG_WARNING(Kernel_SVC, "(STUBBED) called handle 0x{:08X}", handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    auto event = kernel.HandleTable().Get<Event>(handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    auto event = handle_table.Get<Event>(handle);
 
     ASSERT(event != nullptr);
 
@@ -1000,8 +1015,8 @@ static ResultCode CreateTransferMemory(Handle* handle, VAddr addr, u64 size, u32
 static ResultCode GetThreadCoreMask(Handle thread_handle, u32* core, u64* mask) {
     LOG_TRACE(Kernel_SVC, "called, handle=0x{:08X}", thread_handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         return ERR_INVALID_HANDLE;
     }
@@ -1016,8 +1031,8 @@ 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,
               mask, core);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         return ERR_INVALID_HANDLE;
     }
@@ -1078,7 +1093,7 @@ static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permiss
     }
 
     auto& kernel = Core::System::GetInstance().Kernel();
-    auto& handle_table = kernel.HandleTable();
+    auto& handle_table = Core::CurrentProcess()->GetHandleTable();
     auto shared_mem_handle =
         SharedMemory::Create(kernel, handle_table.Get<Process>(KernelHandle::CurrentProcess), size,
                              local_perms, remote_perms);
@@ -1090,10 +1105,12 @@ static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permiss
 static ResultCode ClearEvent(Handle handle) {
     LOG_TRACE(Kernel_SVC, "called, event=0x{:08X}", handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<Event> evt = kernel.HandleTable().Get<Event>(handle);
-    if (evt == nullptr)
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    SharedPtr<Event> evt = handle_table.Get<Event>(handle);
+    if (evt == nullptr) {
         return ERR_INVALID_HANDLE;
+    }
+
     evt->Clear();
     return RESULT_SUCCESS;
 }
@@ -1106,8 +1123,8 @@ static ResultCode GetProcessInfo(u64* out, Handle process_handle, u32 type) {
         Status,
     };
 
-    const auto& kernel = Core::System::GetInstance().Kernel();
-    const auto process = kernel.HandleTable().Get<Process>(process_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    const auto process = handle_table.Get<Process>(process_handle);
     if (!process) {
         return ERR_INVALID_HANDLE;
     }
diff --git a/src/core/hle/kernel/svc.h b/src/core/hle/kernel/svc.h
index 70148c4fe..554a5e328 100644
--- a/src/core/hle/kernel/svc.h
+++ b/src/core/hle/kernel/svc.h
@@ -41,8 +41,8 @@ enum class GetInfoType : u64 {
     RandomEntropy = 11,
     PerformanceCounter = 0xF0000002,
     // 2.0.0+
-    AddressSpaceBaseAddr = 12,
-    AddressSpaceSize = 13,
+    ASLRRegionBaseAddr = 12,
+    ASLRRegionSize = 13,
     NewMapRegionBaseAddr = 14,
     NewMapRegionSize = 15,
     // 3.0.0+
diff --git a/src/core/hle/kernel/thread.cpp b/src/core/hle/kernel/thread.cpp
index 35ec98c1a..59bc9e0af 100644
--- a/src/core/hle/kernel/thread.cpp
+++ b/src/core/hle/kernel/thread.cpp
@@ -266,7 +266,7 @@ SharedPtr<Thread> SetupMainThread(KernelCore& kernel, VAddr entry_point, u32 pri
     SharedPtr<Thread> thread = std::move(thread_res).Unwrap();
 
     // Register 1 must be a handle to the main thread
-    const Handle guest_handle = kernel.HandleTable().Create(thread).Unwrap();
+    const Handle guest_handle = owner_process.GetHandleTable().Create(thread).Unwrap();
     thread->SetGuestHandle(guest_handle);
     thread->GetContext().cpu_registers[1] = guest_handle;
 
diff --git a/src/core/hle/kernel/vm_manager.cpp b/src/core/hle/kernel/vm_manager.cpp
index e412309fd..e1a34eef1 100644
--- a/src/core/hle/kernel/vm_manager.cpp
+++ b/src/core/hle/kernel/vm_manager.cpp
@@ -393,30 +393,35 @@ void VMManager::InitializeMemoryRegionRanges(FileSys::ProgramAddressSpaceType ty
 
     switch (type) {
     case FileSys::ProgramAddressSpaceType::Is32Bit:
+    case FileSys::ProgramAddressSpaceType::Is32BitNoMap:
         address_space_width = 32;
         code_region_base = 0x200000;
         code_region_end = code_region_base + 0x3FE00000;
-        map_region_size = 0x40000000;
-        heap_region_size = 0x40000000;
+        aslr_region_base = 0x200000;
+        aslr_region_end = aslr_region_base + 0xFFE00000;
+        if (type == FileSys::ProgramAddressSpaceType::Is32Bit) {
+            map_region_size = 0x40000000;
+            heap_region_size = 0x40000000;
+        } else {
+            map_region_size = 0;
+            heap_region_size = 0x80000000;
+        }
         break;
     case FileSys::ProgramAddressSpaceType::Is36Bit:
         address_space_width = 36;
         code_region_base = 0x8000000;
         code_region_end = code_region_base + 0x78000000;
+        aslr_region_base = 0x8000000;
+        aslr_region_end = aslr_region_base + 0xFF8000000;
         map_region_size = 0x180000000;
         heap_region_size = 0x180000000;
         break;
-    case FileSys::ProgramAddressSpaceType::Is32BitNoMap:
-        address_space_width = 32;
-        code_region_base = 0x200000;
-        code_region_end = code_region_base + 0x3FE00000;
-        map_region_size = 0;
-        heap_region_size = 0x80000000;
-        break;
     case FileSys::ProgramAddressSpaceType::Is39Bit:
         address_space_width = 39;
         code_region_base = 0x8000000;
         code_region_end = code_region_base + 0x80000000;
+        aslr_region_base = 0x8000000;
+        aslr_region_end = aslr_region_base + 0x7FF8000000;
         map_region_size = 0x1000000000;
         heap_region_size = 0x180000000;
         new_map_region_size = 0x80000000;
@@ -490,6 +495,38 @@ u64 VMManager::GetAddressSpaceWidth() const {
     return address_space_width;
 }
 
+VAddr VMManager::GetASLRRegionBaseAddress() const {
+    return aslr_region_base;
+}
+
+VAddr VMManager::GetASLRRegionEndAddress() const {
+    return aslr_region_end;
+}
+
+u64 VMManager::GetASLRRegionSize() const {
+    return aslr_region_end - aslr_region_base;
+}
+
+bool VMManager::IsWithinASLRRegion(VAddr begin, u64 size) const {
+    const VAddr range_end = begin + size;
+    const VAddr aslr_start = GetASLRRegionBaseAddress();
+    const VAddr aslr_end = GetASLRRegionEndAddress();
+
+    if (aslr_start > begin || begin > range_end || range_end - 1 > aslr_end - 1) {
+        return false;
+    }
+
+    if (range_end > heap_region_base && heap_region_end > begin) {
+        return false;
+    }
+
+    if (range_end > map_region_base && map_region_end > begin) {
+        return false;
+    }
+
+    return true;
+}
+
 VAddr VMManager::GetCodeRegionBaseAddress() const {
     return code_region_base;
 }
diff --git a/src/core/hle/kernel/vm_manager.h b/src/core/hle/kernel/vm_manager.h
index 015559a64..84c890224 100644
--- a/src/core/hle/kernel/vm_manager.h
+++ b/src/core/hle/kernel/vm_manager.h
@@ -205,6 +205,18 @@ public:
     /// Gets the address space width in bits.
     u64 GetAddressSpaceWidth() const;
 
+    /// Gets the base address of the ASLR region.
+    VAddr GetASLRRegionBaseAddress() const;
+
+    /// Gets the end address of the ASLR region.
+    VAddr GetASLRRegionEndAddress() const;
+
+    /// Determines whether or not the specified address range is within the ASLR region.
+    bool IsWithinASLRRegion(VAddr address, u64 size) const;
+
+    /// Gets the size of the ASLR region
+    u64 GetASLRRegionSize() const;
+
     /// Gets the base address of the code region.
     VAddr GetCodeRegionBaseAddress() const;
 
@@ -306,6 +318,9 @@ private:
     VAddr address_space_base = 0;
     VAddr address_space_end = 0;
 
+    VAddr aslr_region_base = 0;
+    VAddr aslr_region_end = 0;
+
     VAddr code_region_base = 0;
     VAddr code_region_end = 0;
 
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index 69bfce1c1..ecf72ae24 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -15,6 +15,7 @@
 #include "core/hle/service/am/idle.h"
 #include "core/hle/service/am/omm.h"
 #include "core/hle/service/am/spsm.h"
+#include "core/hle/service/am/tcap.h"
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
@@ -26,13 +27,18 @@
 namespace Service::AM {
 
 IWindowController::IWindowController() : ServiceFramework("IWindowController") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "CreateWindow"},
         {1, &IWindowController::GetAppletResourceUserId, "GetAppletResourceUserId"},
         {10, &IWindowController::AcquireForegroundRights, "AcquireForegroundRights"},
         {11, nullptr, "ReleaseForegroundRights"},
         {12, nullptr, "RejectToChangeIntoBackground"},
+        {20, nullptr, "SetAppletWindowVisibility"},
+        {21, nullptr, "SetAppletGpuTimeSlice"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 
@@ -87,6 +93,7 @@ void IAudioController::GetLibraryAppletExpectedMasterVolume(Kernel::HLERequestCo
 }
 
 IDisplayController::IDisplayController() : ServiceFramework("IDisplayController") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "GetLastForegroundCaptureImage"},
         {1, nullptr, "UpdateLastForegroundCaptureImage"},
@@ -117,7 +124,11 @@ IDisplayController::IDisplayController() : ServiceFramework("IDisplayController"
         {25, nullptr, "ReleaseLastForegroundCaptureSharedBuffer"},
         {26, nullptr, "AcquireCallerAppletCaptureSharedBuffer"},
         {27, nullptr, "ReleaseCallerAppletCaptureSharedBuffer"},
+        // 6.0.0+
+        {28, nullptr, "TakeScreenShotOfOwnLayerEx"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 
@@ -128,6 +139,7 @@ IDebugFunctions::~IDebugFunctions() = default;
 
 ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
     : ServiceFramework("ISelfController"), nvflinger(std::move(nvflinger)) {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "Exit"},
         {1, &ISelfController::LockExit, "LockExit"},
@@ -136,10 +148,8 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {4, nullptr, "LeaveFatalSection"},
         {9, &ISelfController::GetLibraryAppletLaunchableEvent, "GetLibraryAppletLaunchableEvent"},
         {10, &ISelfController::SetScreenShotPermission, "SetScreenShotPermission"},
-        {11, &ISelfController::SetOperationModeChangedNotification,
-         "SetOperationModeChangedNotification"},
-        {12, &ISelfController::SetPerformanceModeChangedNotification,
-         "SetPerformanceModeChangedNotification"},
+        {11, &ISelfController::SetOperationModeChangedNotification, "SetOperationModeChangedNotification"},
+        {12, &ISelfController::SetPerformanceModeChangedNotification, "SetPerformanceModeChangedNotification"},
         {13, &ISelfController::SetFocusHandlingMode, "SetFocusHandlingMode"},
         {14, &ISelfController::SetRestartMessageEnabled, "SetRestartMessageEnabled"},
         {15, nullptr, "SetScreenShotAppletIdentityInfo"},
@@ -165,7 +175,12 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {69, nullptr, "IsAutoSleepDisabled"},
         {70, nullptr, "ReportMultimediaError"},
         {80, nullptr, "SetWirelessPriorityMode"},
+        {90, nullptr, "GetAccumulatedSuspendedTickValue"},
+        {91, nullptr, "GetAccumulatedSuspendedTickChangedEvent"},
+        {1000, nullptr, "GetDebugStorageChannel"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 
     auto& kernel = Core::System::GetInstance().Kernel();
@@ -312,6 +327,7 @@ void ISelfController::GetIdleTimeDetectionExtension(Kernel::HLERequestContext& c
 }
 
 ICommonStateGetter::ICommonStateGetter() : ServiceFramework("ICommonStateGetter") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ICommonStateGetter::GetEventHandle, "GetEventHandle"},
         {1, &ICommonStateGetter::ReceiveMessage, "ReceiveMessage"},
@@ -336,11 +352,12 @@ ICommonStateGetter::ICommonStateGetter() : ServiceFramework("ICommonStateGetter"
         {52, nullptr, "SwitchLcdBacklight"},
         {55, nullptr, "IsInControllerFirmwareUpdateSection"},
         {60, &ICommonStateGetter::GetDefaultDisplayResolution, "GetDefaultDisplayResolution"},
-        {61, &ICommonStateGetter::GetDefaultDisplayResolutionChangeEvent,
-         "GetDefaultDisplayResolutionChangeEvent"},
+        {61, &ICommonStateGetter::GetDefaultDisplayResolutionChangeEvent, "GetDefaultDisplayResolutionChangeEvent"},
         {62, nullptr, "GetHdcpAuthenticationState"},
         {63, nullptr, "GetHdcpAuthenticationStateChangeEvent"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 
     auto& kernel = Core::System::GetInstance().Kernel();
@@ -432,11 +449,14 @@ class IStorageAccessor final : public ServiceFramework<IStorageAccessor> {
 public:
     explicit IStorageAccessor(std::vector<u8> buffer)
         : ServiceFramework("IStorageAccessor"), buffer(std::move(buffer)) {
+        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IStorageAccessor::GetSize, "GetSize"},
             {10, &IStorageAccessor::Write, "Write"},
             {11, &IStorageAccessor::Read, "Read"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
     }
 
@@ -489,10 +509,13 @@ class IStorage final : public ServiceFramework<IStorage> {
 public:
     explicit IStorage(std::vector<u8> buffer)
         : ServiceFramework("IStorage"), buffer(std::move(buffer)) {
+        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IStorage::Open, "Open"},
             {1, nullptr, "OpenTransferStorage"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
     }
 
@@ -512,6 +535,7 @@ private:
 class ILibraryAppletAccessor final : public ServiceFramework<ILibraryAppletAccessor> {
 public:
     explicit ILibraryAppletAccessor() : ServiceFramework("ILibraryAppletAccessor") {
+        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &ILibraryAppletAccessor::GetAppletStateChangedEvent, "GetAppletStateChangedEvent"},
             {1, nullptr, "IsCompleted"},
@@ -532,6 +556,8 @@ public:
             {150, nullptr, "RequestForAppletToGetForeground"},
             {160, nullptr, "GetIndirectLayerConsumerHandle"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
@@ -624,13 +650,13 @@ void ILibraryAppletCreator::CreateStorage(Kernel::HLERequestContext& ctx) {
 }
 
 IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationFunctions") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {1, &IApplicationFunctions::PopLaunchParameter, "PopLaunchParameter"},
         {10, nullptr, "CreateApplicationAndPushAndRequestToStart"},
         {11, nullptr, "CreateApplicationAndPushAndRequestToStartForQuest"},
         {12, nullptr, "CreateApplicationAndRequestToStart"},
-        {13, &IApplicationFunctions::CreateApplicationAndRequestToStartForQuest,
-         "CreateApplicationAndRequestToStartForQuest"},
+        {13, &IApplicationFunctions::CreateApplicationAndRequestToStartForQuest, "CreateApplicationAndRequestToStartForQuest"},
         {20, &IApplicationFunctions::EnsureSaveData, "EnsureSaveData"},
         {21, &IApplicationFunctions::GetDesiredLanguage, "GetDesiredLanguage"},
         {22, &IApplicationFunctions::SetTerminateResult, "SetTerminateResult"},
@@ -638,10 +664,10 @@ IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationF
         {24, nullptr, "GetLaunchStorageInfoForDebug"},
         {25, nullptr, "ExtendSaveData"},
         {26, nullptr, "GetSaveDataSize"},
-        {30, nullptr, "BeginBlockingHomeButtonShortAndLongPressed"},
-        {31, nullptr, "EndBlockingHomeButtonShortAndLongPressed"},
-        {32, nullptr, "BeginBlockingHomeButton"},
-        {33, nullptr, "EndBlockingHomeButton"},
+        {30, &IApplicationFunctions::BeginBlockingHomeButtonShortAndLongPressed, "BeginBlockingHomeButtonShortAndLongPressed"},
+        {31, &IApplicationFunctions::EndBlockingHomeButtonShortAndLongPressed, "EndBlockingHomeButtonShortAndLongPressed"},
+        {32, &IApplicationFunctions::BeginBlockingHomeButton, "BeginBlockingHomeButton"},
+        {33, &IApplicationFunctions::EndBlockingHomeButton, "EndBlockingHomeButton"},
         {40, &IApplicationFunctions::NotifyRunning, "NotifyRunning"},
         {50, &IApplicationFunctions::GetPseudoDeviceId, "GetPseudoDeviceId"},
         {60, nullptr, "SetMediaPlaybackStateForApplication"},
@@ -664,11 +690,39 @@ IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationF
         {1000, nullptr, "CreateMovieMaker"},
         {1001, nullptr, "PrepareForJit"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 
 IApplicationFunctions::~IApplicationFunctions() = default;
 
+void IApplicationFunctions::BeginBlockingHomeButtonShortAndLongPressed(
+    Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+}
+
+void IApplicationFunctions::EndBlockingHomeButtonShortAndLongPressed(
+    Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+}
+
+void IApplicationFunctions::BeginBlockingHomeButton(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+}
+
+void IApplicationFunctions::EndBlockingHomeButton(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+}
+
 void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
     constexpr std::array<u8, 0x88> data{{
         0xca, 0x97, 0x94, 0xc7, // Magic
@@ -776,9 +830,11 @@ void InstallInterfaces(SM::ServiceManager& service_manager,
     std::make_shared<IdleSys>()->InstallAsService(service_manager);
     std::make_shared<OMM>()->InstallAsService(service_manager);
     std::make_shared<SPSM>()->InstallAsService(service_manager);
+    std::make_shared<TCAP>()->InstallAsService(service_manager);
 }
 
 IHomeMenuFunctions::IHomeMenuFunctions() : ServiceFramework("IHomeMenuFunctions") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {10, &IHomeMenuFunctions::RequestToGetForeground, "RequestToGetForeground"},
         {11, nullptr, "LockForeground"},
@@ -787,7 +843,10 @@ IHomeMenuFunctions::IHomeMenuFunctions() : ServiceFramework("IHomeMenuFunctions"
         {21, nullptr, "GetPopFromGeneralChannelEvent"},
         {30, nullptr, "GetHomeButtonWriterLockAccessor"},
         {31, nullptr, "GetWriterLockAccessorEx"},
+        {100, nullptr, "PopRequestLaunchApplicationForDebug"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 
@@ -800,6 +859,7 @@ void IHomeMenuFunctions::RequestToGetForeground(Kernel::HLERequestContext& ctx)
 }
 
 IGlobalStateController::IGlobalStateController() : ServiceFramework("IGlobalStateController") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "RequestToEnterSleep"},
         {1, nullptr, "EnterSleep"},
@@ -813,18 +873,23 @@ IGlobalStateController::IGlobalStateController() : ServiceFramework("IGlobalStat
         {14, nullptr, "ShouldSleepOnBoot"},
         {15, nullptr, "GetHdcpAuthenticationFailedEvent"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 
 IGlobalStateController::~IGlobalStateController() = default;
 
 IApplicationCreator::IApplicationCreator() : ServiceFramework("IApplicationCreator") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "CreateApplication"},
         {1, nullptr, "PopLaunchRequestedApplication"},
         {10, nullptr, "CreateSystemApplication"},
         {100, nullptr, "PopFloatingApplicationForDevelopment"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 
@@ -832,6 +897,7 @@ IApplicationCreator::~IApplicationCreator() = default;
 
 IProcessWindingController::IProcessWindingController()
     : ServiceFramework("IProcessWindingController") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "GetLaunchReason"},
         {11, nullptr, "OpenCallingLibraryApplet"},
@@ -842,6 +908,8 @@ IProcessWindingController::IProcessWindingController()
         {40, nullptr, "ReserveToStartAndWaitAndUnwindThis"},
         {41, nullptr, "ReserveToStartAndWait"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 
diff --git a/src/core/hle/service/am/am.h b/src/core/hle/service/am/am.h
index b39b0d838..095f94851 100644
--- a/src/core/hle/service/am/am.h
+++ b/src/core/hle/service/am/am.h
@@ -154,6 +154,10 @@ private:
     void SetGamePlayRecordingState(Kernel::HLERequestContext& ctx);
     void NotifyRunning(Kernel::HLERequestContext& ctx);
     void GetPseudoDeviceId(Kernel::HLERequestContext& ctx);
+    void BeginBlockingHomeButtonShortAndLongPressed(Kernel::HLERequestContext& ctx);
+    void EndBlockingHomeButtonShortAndLongPressed(Kernel::HLERequestContext& ctx);
+    void BeginBlockingHomeButton(Kernel::HLERequestContext& ctx);
+    void EndBlockingHomeButton(Kernel::HLERequestContext& ctx);
 };
 
 class IHomeMenuFunctions final : public ServiceFramework<IHomeMenuFunctions> {
diff --git a/src/core/hle/service/am/applet_ae.cpp b/src/core/hle/service/am/applet_ae.cpp
index 4296c255e..68ea778e8 100644
--- a/src/core/hle/service/am/applet_ae.cpp
+++ b/src/core/hle/service/am/applet_ae.cpp
@@ -211,6 +211,7 @@ void AppletAE::OpenLibraryAppletProxyOld(Kernel::HLERequestContext& ctx) {
 
 AppletAE::AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
     : ServiceFramework("appletAE"), nvflinger(std::move(nvflinger)) {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {100, &AppletAE::OpenSystemAppletProxy, "OpenSystemAppletProxy"},
         {200, &AppletAE::OpenLibraryAppletProxyOld, "OpenLibraryAppletProxyOld"},
@@ -218,7 +219,10 @@ AppletAE::AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
         {300, nullptr, "OpenOverlayAppletProxy"},
         {350, nullptr, "OpenSystemApplicationProxy"},
         {400, nullptr, "CreateSelfLibraryAppletCreatorForDevelop"},
+        {401, nullptr, "GetSystemAppletControllerForDebug"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 
diff --git a/src/core/hle/service/am/applet_oe.cpp b/src/core/hle/service/am/applet_oe.cpp
index e45cf6e20..60717afd9 100644
--- a/src/core/hle/service/am/applet_oe.cpp
+++ b/src/core/hle/service/am/applet_oe.cpp
@@ -14,6 +14,7 @@ class IApplicationProxy final : public ServiceFramework<IApplicationProxy> {
 public:
     explicit IApplicationProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
         : ServiceFramework("IApplicationProxy"), nvflinger(std::move(nvflinger)) {
+        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IApplicationProxy::GetCommonStateGetter, "GetCommonStateGetter"},
             {1, &IApplicationProxy::GetSelfController, "GetSelfController"},
@@ -25,6 +26,8 @@ public:
             {20, &IApplicationProxy::GetApplicationFunctions, "GetApplicationFunctions"},
             {1000, &IApplicationProxy::GetDebugFunctions, "GetDebugFunctions"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
     }
 
diff --git a/src/core/hle/service/am/idle.cpp b/src/core/hle/service/am/idle.cpp
index 0e3088bc8..f814fe2c0 100644
--- a/src/core/hle/service/am/idle.cpp
+++ b/src/core/hle/service/am/idle.cpp
@@ -12,9 +12,9 @@ IdleSys::IdleSys() : ServiceFramework{"idle:sys"} {
         {0, nullptr, "GetAutoPowerDownEvent"},
         {1, nullptr, "Unknown1"},
         {2, nullptr, "Unknown2"},
-        {3, nullptr, "Unknown3"},
-        {4, nullptr, "Unknown4"},
-        {5, nullptr, "Unknown5"},
+        {3, nullptr, "SetHandlingContext"},
+        {4, nullptr, "LoadAndApplySettings"},
+        {5, nullptr, "ReportUserIsActive"},
     };
     // clang-format on
 
diff --git a/src/core/hle/service/am/omm.cpp b/src/core/hle/service/am/omm.cpp
index 1c37f849f..6ab3fb906 100644
--- a/src/core/hle/service/am/omm.cpp
+++ b/src/core/hle/service/am/omm.cpp
@@ -17,22 +17,24 @@ OMM::OMM() : ServiceFramework{"omm"} {
         {5, nullptr, "GetCradleStatus"},
         {6, nullptr, "FadeInDisplay"},
         {7, nullptr, "FadeOutDisplay"},
-        {8, nullptr, "Unknown1"},
-        {9, nullptr, "Unknown2"},
-        {10, nullptr, "Unknown3"},
-        {11, nullptr, "Unknown4"},
-        {12, nullptr, "Unknown5"},
-        {13, nullptr, "Unknown6"},
-        {14, nullptr, "Unknown7"},
-        {15, nullptr, "Unknown8"},
-        {16, nullptr, "Unknown9"},
-        {17, nullptr, "Unknown10"},
-        {18, nullptr, "Unknown11"},
-        {19, nullptr, "Unknown12"},
-        {20, nullptr, "Unknown13"},
-        {21, nullptr, "Unknown14"},
-        {22, nullptr, "Unknown15"},
-        {23, nullptr, "Unknown16"},
+        {8, nullptr, "GetCradleFwVersion"},
+        {9, nullptr, "NotifyCecSettingsChanged"},
+        {10, nullptr, "SetOperationModePolicy"},
+        {11, nullptr, "GetDefaultDisplayResolution"},
+        {12, nullptr, "GetDefaultDisplayResolutionChangeEvent"},
+        {13, nullptr, "UpdateDefaultDisplayResolution"},
+        {14, nullptr, "ShouldSleepOnBoot"},
+        {15, nullptr, "NotifyHdcpApplicationExecutionStarted"},
+        {16, nullptr, "NotifyHdcpApplicationExecutionFinished"},
+        {17, nullptr, "NotifyHdcpApplicationDrawingStarted"},
+        {18, nullptr, "NotifyHdcpApplicationDrawingFinished"},
+        {19, nullptr, "GetHdcpAuthenticationFailedEvent"},
+        {20, nullptr, "GetHdcpAuthenticationFailedEmulationEnabled"},
+        {21, nullptr, "SetHdcpAuthenticationFailedEmulation"},
+        {22, nullptr, "GetHdcpStateChangeEvent"},
+        {23, nullptr, "GetHdcpState"},
+        {24, nullptr, "ShowCardUpdateProcessing"},
+        {25, nullptr, "SetApplicationCecSettingsAndNotifyChanged"},
     };
     // clang-format on
 
diff --git a/src/core/hle/service/am/tcap.cpp b/src/core/hle/service/am/tcap.cpp
new file mode 100644
index 000000000..a75cbdda8
--- /dev/null
+++ b/src/core/hle/service/am/tcap.cpp
@@ -0,0 +1,23 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/am/tcap.h"
+
+namespace Service::AM {
+
+TCAP::TCAP() : ServiceFramework{"tcap"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "GetContinuousHighSkinTemperatureEvent"},
+        {1, nullptr, "SetOperationMode"},
+        {2, nullptr, "LoadAndApplySettings"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+TCAP::~TCAP() = default;
+
+} // namespace Service::AM
diff --git a/src/core/hle/service/am/tcap.h b/src/core/hle/service/am/tcap.h
new file mode 100644
index 000000000..2021b55d1
--- /dev/null
+++ b/src/core/hle/service/am/tcap.h
@@ -0,0 +1,17 @@
+// 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/service.h"
+
+namespace Service::AM {
+
+class TCAP final : public ServiceFramework<TCAP> {
+public:
+    explicit TCAP();
+    ~TCAP() override;
+};
+
+} // namespace Service::AM
diff --git a/src/core/hle/service/aoc/aoc_u.cpp b/src/core/hle/service/aoc/aoc_u.cpp
index 518161bf7..428069df2 100644
--- a/src/core/hle/service/aoc/aoc_u.cpp
+++ b/src/core/hle/service/aoc/aoc_u.cpp
@@ -13,6 +13,7 @@
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/service/aoc/aoc_u.h"
 #include "core/hle/service/filesystem/filesystem.h"
@@ -55,9 +56,13 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs
         {5, &AOC_U::GetAddOnContentBaseId, "GetAddOnContentBaseId"},
         {6, nullptr, "PrepareAddOnContentByApplicationId"},
         {7, &AOC_U::PrepareAddOnContent, "PrepareAddOnContent"},
-        {8, nullptr, "GetAddOnContentListChangedEvent"},
+        {8, &AOC_U::GetAddOnContentListChangedEvent, "GetAddOnContentListChangedEvent"},
     };
     RegisterHandlers(functions);
+
+    auto& kernel = Core::System::GetInstance().Kernel();
+    aoc_change_event = Kernel::Event::Create(kernel, Kernel::ResetType::Sticky,
+                                             "GetAddOnContentListChanged:Event");
 }
 
 AOC_U::~AOC_U() = default;
@@ -130,6 +135,14 @@ void AOC_U::PrepareAddOnContent(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
 }
 
+void AOC_U::GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushCopyObjects(aoc_change_event);
+}
+
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<AOC_U>()->InstallAsService(service_manager);
 }
diff --git a/src/core/hle/service/aoc/aoc_u.h b/src/core/hle/service/aoc/aoc_u.h
index b3c7cab7a..68d94fdaa 100644
--- a/src/core/hle/service/aoc/aoc_u.h
+++ b/src/core/hle/service/aoc/aoc_u.h
@@ -18,8 +18,10 @@ private:
     void ListAddOnContent(Kernel::HLERequestContext& ctx);
     void GetAddOnContentBaseId(Kernel::HLERequestContext& ctx);
     void PrepareAddOnContent(Kernel::HLERequestContext& ctx);
+    void GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx);
 
     std::vector<u64> add_on_content;
+    Kernel::SharedPtr<Kernel::Event> aoc_change_event;
 };
 
 /// Registers all AOC services with the specified service manager.
diff --git a/src/core/hle/service/audio/audren_u.cpp b/src/core/hle/service/audio/audren_u.cpp
index 6073f4ecd..fac6785a5 100644
--- a/src/core/hle/service/audio/audren_u.cpp
+++ b/src/core/hle/service/audio/audren_u.cpp
@@ -22,20 +22,22 @@ class IAudioRenderer final : public ServiceFramework<IAudioRenderer> {
 public:
     explicit IAudioRenderer(AudioCore::AudioRendererParameter audren_params)
         : ServiceFramework("IAudioRenderer") {
+        // clang-format off
         static const FunctionInfo functions[] = {
-            {0, &IAudioRenderer::GetAudioRendererSampleRate, "GetAudioRendererSampleRate"},
-            {1, &IAudioRenderer::GetAudioRendererSampleCount, "GetAudioRendererSampleCount"},
-            {2, &IAudioRenderer::GetAudioRendererMixBufferCount, "GetAudioRendererMixBufferCount"},
-            {3, &IAudioRenderer::GetAudioRendererState, "GetAudioRendererState"},
-            {4, &IAudioRenderer::RequestUpdateAudioRenderer, "RequestUpdateAudioRenderer"},
-            {5, &IAudioRenderer::StartAudioRenderer, "StartAudioRenderer"},
-            {6, &IAudioRenderer::StopAudioRenderer, "StopAudioRenderer"},
+            {0, &IAudioRenderer::GetSampleRate, "GetSampleRate"},
+            {1, &IAudioRenderer::GetSampleCount, "GetSampleCount"},
+            {2, &IAudioRenderer::GetMixBufferCount, "GetMixBufferCount"},
+            {3, &IAudioRenderer::GetState, "GetState"},
+            {4, &IAudioRenderer::RequestUpdate, "RequestUpdate"},
+            {5, &IAudioRenderer::Start, "Start"},
+            {6, &IAudioRenderer::Stop, "Stop"},
             {7, &IAudioRenderer::QuerySystemEvent, "QuerySystemEvent"},
-            {8, nullptr, "SetAudioRendererRenderingTimeLimit"},
-            {9, nullptr, "GetAudioRendererRenderingTimeLimit"},
-            {10, nullptr, "RequestUpdateAudioRendererAuto"},
+            {8, nullptr, "SetRenderingTimeLimit"},
+            {9, nullptr, "GetRenderingTimeLimit"},
+            {10, nullptr, "RequestUpdateAuto"},
             {11, nullptr, "ExecuteAudioRendererRendering"},
         };
+        // clang-format on
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
@@ -49,42 +51,42 @@ private:
         system_event->Signal();
     }
 
-    void GetAudioRendererSampleRate(Kernel::HLERequestContext& ctx) {
+    void GetSampleRate(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(renderer->GetSampleRate());
         LOG_DEBUG(Service_Audio, "called");
     }
 
-    void GetAudioRendererSampleCount(Kernel::HLERequestContext& ctx) {
+    void GetSampleCount(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(renderer->GetSampleCount());
         LOG_DEBUG(Service_Audio, "called");
     }
 
-    void GetAudioRendererState(Kernel::HLERequestContext& ctx) {
+    void GetState(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(static_cast<u32>(renderer->GetStreamState()));
         LOG_DEBUG(Service_Audio, "called");
     }
 
-    void GetAudioRendererMixBufferCount(Kernel::HLERequestContext& ctx) {
+    void GetMixBufferCount(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(renderer->GetMixBufferCount());
         LOG_DEBUG(Service_Audio, "called");
     }
 
-    void RequestUpdateAudioRenderer(Kernel::HLERequestContext& ctx) {
+    void RequestUpdate(Kernel::HLERequestContext& ctx) {
         ctx.WriteBuffer(renderer->UpdateAudioRenderer(ctx.ReadBuffer()));
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
         LOG_WARNING(Service_Audio, "(STUBBED) called");
     }
 
-    void StartAudioRenderer(Kernel::HLERequestContext& ctx) {
+    void Start(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
 
         rb.Push(RESULT_SUCCESS);
@@ -92,7 +94,7 @@ private:
         LOG_WARNING(Service_Audio, "(STUBBED) called");
     }
 
-    void StopAudioRenderer(Kernel::HLERequestContext& ctx) {
+    void Stop(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
 
         rb.Push(RESULT_SUCCESS);
@@ -129,6 +131,7 @@ public:
             {10, &IAudioDevice::GetActiveAudioDeviceName, "GetActiveAudioDeviceNameAuto"},
             {11, nullptr, "QueryAudioDeviceInputEvent"},
             {12, nullptr, "QueryAudioDeviceOutputEvent"},
+            {13, nullptr, "GetAudioSystemMasterVolumeSetting"},
         };
         RegisterHandlers(functions);
 
diff --git a/src/core/hle/service/es/es.cpp b/src/core/hle/service/es/es.cpp
index d40f18565..6701cb913 100644
--- a/src/core/hle/service/es/es.cpp
+++ b/src/core/hle/service/es/es.cpp
@@ -9,6 +9,7 @@ namespace Service::ES {
 class ETicket final : public ServiceFramework<ETicket> {
 public:
     explicit ETicket() : ServiceFramework{"es"} {
+        // clang-format off
         static const FunctionInfo functions[] = {
             {1, nullptr, "ImportTicket"},
             {2, nullptr, "ImportTicketCertificateSet"},
@@ -37,15 +38,18 @@ public:
             {25, nullptr, "DeletePrepurchaseRecord"},
             {26, nullptr, "DeleteAllPrepurchaseRecord"},
             {27, nullptr, "CountPrepurchaseRecord"},
-            {28, nullptr, "ListPrepurchaseRecord"},
+            {28, nullptr, "ListPrepurchaseRecordRightsIds"},
             {29, nullptr, "ListPrepurchaseRecordInfo"},
-            {30, nullptr, "Unknown1"},
-            {31, nullptr, "Unknown2"},
-            {32, nullptr, "Unknown3"},
-            {33, nullptr, "Unknown4"},
-            {34, nullptr, "Unknown5"},
-            {35, nullptr, "Unknown6"},
+            {30, nullptr, "CountTicket"},
+            {31, nullptr, "ListTicketRightsIds"},
+            {32, nullptr, "CountPrepurchaseRecordEx"},
+            {33, nullptr, "ListPrepurchaseRecordRightsIdsEx"},
+            {34, nullptr, "GetEncryptedTicketSize"},
+            {35, nullptr, "GetEncryptedTicketData"},
+            {36, nullptr, "DeleteAllInactiveELicenseRequiredPersonalizedTicket"},
+            {503, nullptr, "GetTitleKey"},
         };
+        // clang-format on
         RegisterHandlers(functions);
     }
 };
diff --git a/src/core/hle/service/hid/controllers/controller_base.cpp b/src/core/hle/service/hid/controllers/controller_base.cpp
new file mode 100644
index 000000000..0993a7815
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/controller_base.cpp
@@ -0,0 +1,30 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/hid/controllers/controller_base.h"
+
+namespace Service::HID {
+
+ControllerBase::ControllerBase() = default;
+ControllerBase::~ControllerBase() = default;
+
+void ControllerBase::ActivateController() {
+    if (is_activated) {
+        OnRelease();
+    }
+    is_activated = true;
+    OnInit();
+}
+
+void ControllerBase::DeactivateController() {
+    if (is_activated) {
+        OnRelease();
+    }
+    is_activated = false;
+}
+
+bool ControllerBase::IsControllerActivated() const {
+    return is_activated;
+}
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/controller_base.h b/src/core/hle/service/hid/controllers/controller_base.h
new file mode 100644
index 000000000..f0e092b1b
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/controller_base.h
@@ -0,0 +1,45 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+#include "common/swap.h"
+
+namespace Service::HID {
+class ControllerBase {
+public:
+    ControllerBase();
+    virtual ~ControllerBase();
+
+    // Called when the controller is initialized
+    virtual void OnInit() = 0;
+
+    // When the controller is released
+    virtual void OnRelease() = 0;
+
+    // When the controller is requesting an update for the shared memory
+    virtual void OnUpdate(u8* data, std::size_t size) = 0;
+
+    // Called when input devices should be loaded
+    virtual void OnLoadInputDevices() = 0;
+
+    void ActivateController();
+
+    void DeactivateController();
+
+    bool IsControllerActivated() const;
+
+protected:
+    bool is_activated{false};
+
+    struct CommonHeader {
+        s64_le timestamp;
+        s64_le total_entry_count;
+        s64_le last_entry_index;
+        s64_le entry_count;
+    };
+    static_assert(sizeof(CommonHeader) == 0x20, "CommonHeader is an invalid size");
+};
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/debug_pad.cpp b/src/core/hle/service/hid/controllers/debug_pad.cpp
new file mode 100644
index 000000000..3d100763f
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/debug_pad.cpp
@@ -0,0 +1,42 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include "common/common_types.h"
+#include "core/core_timing.h"
+#include "core/hle/service/hid/controllers/debug_pad.h"
+
+namespace Service::HID {
+
+Controller_DebugPad::Controller_DebugPad() = default;
+Controller_DebugPad::~Controller_DebugPad() = default;
+
+void Controller_DebugPad::OnInit() {}
+
+void Controller_DebugPad::OnRelease() {}
+
+void Controller_DebugPad::OnUpdate(u8* data, std::size_t size) {
+    shared_memory.header.timestamp = CoreTiming::GetTicks();
+    shared_memory.header.total_entry_count = 17;
+
+    if (!IsControllerActivated()) {
+        shared_memory.header.entry_count = 0;
+        shared_memory.header.last_entry_index = 0;
+        return;
+    }
+    shared_memory.header.entry_count = 16;
+
+    const auto& last_entry = shared_memory.pad_states[shared_memory.header.last_entry_index];
+    shared_memory.header.last_entry_index = (shared_memory.header.last_entry_index + 1) % 17;
+    auto& cur_entry = shared_memory.pad_states[shared_memory.header.last_entry_index];
+
+    cur_entry.sampling_number = last_entry.sampling_number + 1;
+    cur_entry.sampling_number2 = cur_entry.sampling_number;
+    // TODO(ogniK): Update debug pad states
+
+    std::memcpy(data, &shared_memory, sizeof(SharedMemory));
+}
+
+void Controller_DebugPad::OnLoadInputDevices() {}
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/debug_pad.h b/src/core/hle/service/hid/controllers/debug_pad.h
new file mode 100644
index 000000000..62b4f2682
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/debug_pad.h
@@ -0,0 +1,56 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/hle/service/hid/controllers/controller_base.h"
+
+namespace Service::HID {
+class Controller_DebugPad final : public ControllerBase {
+public:
+    Controller_DebugPad();
+    ~Controller_DebugPad() override;
+
+    // Called when the controller is initialized
+    void OnInit() override;
+
+    // When the controller is released
+    void OnRelease() override;
+
+    // When the controller is requesting an update for the shared memory
+    void OnUpdate(u8* data, std::size_t size) override;
+
+    // Called when input devices should be loaded
+    void OnLoadInputDevices() override;
+
+private:
+    struct AnalogStick {
+        s32_le x;
+        s32_le y;
+    };
+    static_assert(sizeof(AnalogStick) == 0x8);
+
+    struct PadStates {
+        s64_le sampling_number;
+        s64_le sampling_number2;
+        u32_le attribute;
+        u32_le button_state;
+        AnalogStick r_stick;
+        AnalogStick l_stick;
+    };
+    static_assert(sizeof(PadStates) == 0x28, "PadStates is an invalid state");
+
+    struct SharedMemory {
+        CommonHeader header;
+        std::array<PadStates, 17> pad_states;
+        INSERT_PADDING_BYTES(0x138);
+    };
+    static_assert(sizeof(SharedMemory) == 0x400, "SharedMemory is an invalid size");
+    SharedMemory shared_memory{};
+};
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/gesture.cpp b/src/core/hle/service/hid/controllers/gesture.cpp
new file mode 100644
index 000000000..898572277
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/gesture.cpp
@@ -0,0 +1,43 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include "common/common_types.h"
+#include "core/core_timing.h"
+#include "core/hle/service/hid/controllers/gesture.h"
+
+namespace Service::HID {
+constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3BA00;
+
+Controller_Gesture::Controller_Gesture() = default;
+Controller_Gesture::~Controller_Gesture() = default;
+
+void Controller_Gesture::OnInit() {}
+
+void Controller_Gesture::OnRelease() {}
+
+void Controller_Gesture::OnUpdate(u8* data, std::size_t size) {
+    shared_memory.header.timestamp = CoreTiming::GetTicks();
+    shared_memory.header.total_entry_count = 17;
+
+    if (!IsControllerActivated()) {
+        shared_memory.header.entry_count = 0;
+        shared_memory.header.last_entry_index = 0;
+        return;
+    }
+    shared_memory.header.entry_count = 16;
+
+    const auto& last_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
+    shared_memory.header.last_entry_index = (shared_memory.header.last_entry_index + 1) % 17;
+    auto& cur_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
+
+    cur_entry.sampling_number = last_entry.sampling_number + 1;
+    cur_entry.sampling_number2 = cur_entry.sampling_number;
+    // TODO(ogniK): Update gesture states
+
+    std::memcpy(data + SHARED_MEMORY_OFFSET, &shared_memory, sizeof(SharedMemory));
+}
+
+void Controller_Gesture::OnLoadInputDevices() {}
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/gesture.h b/src/core/hle/service/hid/controllers/gesture.h
new file mode 100644
index 000000000..1056ffbcd
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/gesture.h
@@ -0,0 +1,63 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/hle/service/hid/controllers/controller_base.h"
+
+namespace Service::HID {
+class Controller_Gesture final : public ControllerBase {
+public:
+    Controller_Gesture();
+    ~Controller_Gesture() override;
+
+    // Called when the controller is initialized
+    void OnInit() override;
+
+    // When the controller is released
+    void OnRelease() override;
+
+    // When the controller is requesting an update for the shared memory
+    void OnUpdate(u8* data, size_t size) override;
+
+    // Called when input devices should be loaded
+    void OnLoadInputDevices() override;
+
+private:
+    struct Locations {
+        s32_le x;
+        s32_le y;
+    };
+
+    struct GestureState {
+        s64_le sampling_number;
+        s64_le sampling_number2;
+
+        s64_le detection_count;
+        s32_le type;
+        s32_le dir;
+        s32_le x;
+        s32_le y;
+        s32_le delta_x;
+        s32_le delta_y;
+        f32 vel_x;
+        f32 vel_y;
+        s32_le attributes;
+        f32 scale;
+        f32 rotation;
+        s32_le location_count;
+        std::array<Locations, 4> locations;
+    };
+    static_assert(sizeof(GestureState) == 0x68, "GestureState is an invalid size");
+
+    struct SharedMemory {
+        CommonHeader header;
+        std::array<GestureState, 17> gesture_states;
+    };
+    SharedMemory shared_memory{};
+};
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/keyboard.cpp b/src/core/hle/service/hid/controllers/keyboard.cpp
new file mode 100644
index 000000000..ccfbce9ac
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/keyboard.cpp
@@ -0,0 +1,43 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include "common/common_types.h"
+#include "core/core_timing.h"
+#include "core/hle/service/hid/controllers/keyboard.h"
+
+namespace Service::HID {
+constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3800;
+
+Controller_Keyboard::Controller_Keyboard() = default;
+Controller_Keyboard::~Controller_Keyboard() = default;
+
+void Controller_Keyboard::OnInit() {}
+
+void Controller_Keyboard::OnRelease() {}
+
+void Controller_Keyboard::OnUpdate(u8* data, std::size_t size) {
+    shared_memory.header.timestamp = CoreTiming::GetTicks();
+    shared_memory.header.total_entry_count = 17;
+
+    if (!IsControllerActivated()) {
+        shared_memory.header.entry_count = 0;
+        shared_memory.header.last_entry_index = 0;
+        return;
+    }
+    shared_memory.header.entry_count = 16;
+
+    const auto& last_entry = shared_memory.pad_states[shared_memory.header.last_entry_index];
+    shared_memory.header.last_entry_index = (shared_memory.header.last_entry_index + 1) % 17;
+    auto& cur_entry = shared_memory.pad_states[shared_memory.header.last_entry_index];
+
+    cur_entry.sampling_number = last_entry.sampling_number + 1;
+    cur_entry.sampling_number2 = cur_entry.sampling_number;
+    // TODO(ogniK): Update keyboard states
+
+    std::memcpy(data + SHARED_MEMORY_OFFSET, &shared_memory, sizeof(SharedMemory));
+}
+
+void Controller_Keyboard::OnLoadInputDevices() {}
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/keyboard.h b/src/core/hle/service/hid/controllers/keyboard.h
new file mode 100644
index 000000000..493e68fce
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/keyboard.h
@@ -0,0 +1,50 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/hle/service/hid/controllers/controller_base.h"
+
+namespace Service::HID {
+class Controller_Keyboard final : public ControllerBase {
+public:
+    Controller_Keyboard();
+    ~Controller_Keyboard() override;
+
+    // Called when the controller is initialized
+    void OnInit() override;
+
+    // When the controller is released
+    void OnRelease() override;
+
+    // When the controller is requesting an update for the shared memory
+    void OnUpdate(u8* data, std::size_t size) override;
+
+    // Called when input devices should be loaded
+    void OnLoadInputDevices() override;
+
+private:
+    struct KeyboardState {
+        s64_le sampling_number;
+        s64_le sampling_number2;
+
+        s32_le modifier;
+        s32_le attribute;
+        std::array<u8, 32> key;
+    };
+    static_assert(sizeof(KeyboardState) == 0x38, "KeyboardState is an invalid size");
+
+    struct SharedMemory {
+        CommonHeader header;
+        std::array<KeyboardState, 17> pad_states;
+        INSERT_PADDING_BYTES(0x28);
+    };
+    static_assert(sizeof(SharedMemory) == 0x400, "SharedMemory is an invalid size");
+    SharedMemory shared_memory{};
+};
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/mouse.cpp b/src/core/hle/service/hid/controllers/mouse.cpp
new file mode 100644
index 000000000..4e246a57d
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/mouse.cpp
@@ -0,0 +1,43 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include "common/common_types.h"
+#include "core/core_timing.h"
+#include "core/hle/service/hid/controllers/mouse.h"
+
+namespace Service::HID {
+constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3400;
+
+Controller_Mouse::Controller_Mouse() = default;
+Controller_Mouse::~Controller_Mouse() = default;
+
+void Controller_Mouse::OnInit() {}
+
+void Controller_Mouse::OnRelease() {}
+
+void Controller_Mouse::OnUpdate(u8* data, std::size_t size) {
+    shared_memory.header.timestamp = CoreTiming::GetTicks();
+    shared_memory.header.total_entry_count = 17;
+
+    if (!IsControllerActivated()) {
+        shared_memory.header.entry_count = 0;
+        shared_memory.header.last_entry_index = 0;
+        return;
+    }
+    shared_memory.header.entry_count = 16;
+
+    auto& last_entry = shared_memory.mouse_states[shared_memory.header.last_entry_index];
+    shared_memory.header.last_entry_index = (shared_memory.header.last_entry_index + 1) % 17;
+    auto& cur_entry = shared_memory.mouse_states[shared_memory.header.last_entry_index];
+
+    cur_entry.sampling_number = last_entry.sampling_number + 1;
+    cur_entry.sampling_number2 = cur_entry.sampling_number;
+    // TODO(ogniK): Update mouse states
+
+    std::memcpy(data + SHARED_MEMORY_OFFSET, &shared_memory, sizeof(SharedMemory));
+}
+
+void Controller_Mouse::OnLoadInputDevices() {}
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/mouse.h b/src/core/hle/service/hid/controllers/mouse.h
new file mode 100644
index 000000000..543b0b71f
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/mouse.h
@@ -0,0 +1,50 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/hle/service/hid/controllers/controller_base.h"
+
+namespace Service::HID {
+class Controller_Mouse final : public ControllerBase {
+public:
+    Controller_Mouse();
+    ~Controller_Mouse() override;
+
+    // Called when the controller is initialized
+    void OnInit() override;
+
+    // When the controller is released
+    void OnRelease() override;
+
+    // When the controller is requesting an update for the shared memory
+    void OnUpdate(u8* data, std::size_t size) override;
+
+    // Called when input devices should be loaded
+    void OnLoadInputDevices() override;
+
+private:
+    struct MouseState {
+        s64_le sampling_number;
+        s64_le sampling_number2;
+        s32_le x;
+        s32_le y;
+        s32_le delta_x;
+        s32_le delta_y;
+        s32_le mouse_wheel;
+        s32_le button;
+        s32_le attribute;
+    };
+    static_assert(sizeof(MouseState) == 0x30, "MouseState is an invalid size");
+
+    struct SharedMemory {
+        CommonHeader header;
+        std::array<MouseState, 17> mouse_states;
+    };
+    SharedMemory shared_memory{};
+};
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/npad.cpp b/src/core/hle/service/hid/controllers/npad.cpp
new file mode 100644
index 000000000..b06e65a77
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/npad.cpp
@@ -0,0 +1,619 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include "common/assert.h"
+#include "common/bit_field.h"
+#include "common/common_types.h"
+#include "common/logging/log.h"
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/frontend/input.h"
+#include "core/hle/kernel/event.h"
+#include "core/hle/service/hid/controllers/npad.h"
+#include "core/settings.h"
+
+namespace Service::HID {
+
+constexpr u32 JOYCON_BODY_NEON_RED = 0xFF3C28;
+constexpr u32 JOYCON_BUTTONS_NEON_RED = 0x1E0A0A;
+constexpr u32 JOYCON_BODY_NEON_BLUE = 0x0AB9E6;
+constexpr u32 JOYCON_BUTTONS_NEON_BLUE = 0x001E1E;
+constexpr s32 HID_JOYSTICK_MAX = 0x7fff;
+constexpr s32 HID_JOYSTICK_MIN = -0x7fff;
+constexpr std::size_t NPAD_OFFSET = 0x9A00;
+constexpr u32 BATTERY_FULL = 2;
+constexpr u32 NPAD_HANDHELD = 32;
+constexpr u32 NPAD_UNKNOWN = 16; // TODO(ogniK): What is this?
+constexpr u32 MAX_NPAD_ID = 7;
+constexpr Controller_NPad::NPadControllerType PREFERRED_CONTROLLER =
+    Controller_NPad::NPadControllerType::JoyDual;
+constexpr std::array<u32, 10> npad_id_list{
+    0, 1, 2, 3, 4, 5, 6, 7, 32, 16,
+};
+
+enum class JoystickId : std::size_t {
+    Joystick_Left,
+    Joystick_Right,
+};
+
+Controller_NPad::Controller_NPad() = default;
+Controller_NPad::~Controller_NPad() = default;
+
+void Controller_NPad::InitNewlyAddedControler(std::size_t controller_idx) {
+    const auto controller_type = connected_controllers[controller_idx].type;
+    auto& controller = shared_memory_entries[controller_idx];
+    if (controller_type == NPadControllerType::None) {
+        return;
+    }
+    controller.joy_styles.raw = 0; // Zero out
+    controller.device_type.raw = 0;
+    switch (controller_type) {
+    case NPadControllerType::Handheld:
+        controller.joy_styles.handheld.Assign(1);
+        controller.device_type.handheld.Assign(1);
+        controller.pad_assignment = NPadAssignments::Dual;
+        break;
+    case NPadControllerType::JoyDual:
+        controller.joy_styles.joycon_dual.Assign(1);
+        controller.device_type.joycon_left.Assign(1);
+        controller.device_type.joycon_right.Assign(1);
+        controller.pad_assignment = NPadAssignments::Dual;
+        break;
+    case NPadControllerType::JoyLeft:
+        controller.joy_styles.joycon_left.Assign(1);
+        controller.device_type.joycon_left.Assign(1);
+        controller.pad_assignment = NPadAssignments::Dual;
+        break;
+    case NPadControllerType::JoyRight:
+        controller.joy_styles.joycon_right.Assign(1);
+        controller.device_type.joycon_right.Assign(1);
+        controller.pad_assignment = NPadAssignments::Dual;
+        break;
+    case NPadControllerType::Pokeball:
+        controller.joy_styles.pokeball.Assign(1);
+        controller.device_type.pokeball.Assign(1);
+        controller.pad_assignment = NPadAssignments::Single;
+        break;
+    case NPadControllerType::ProController:
+        controller.joy_styles.pro_controller.Assign(1);
+        controller.device_type.pro_controller.Assign(1);
+        controller.pad_assignment = NPadAssignments::Single;
+        break;
+    }
+
+    controller.single_color_error = ColorReadError::ReadOk;
+    controller.single_color.body_color = 0;
+    controller.single_color.button_color = 0;
+
+    controller.dual_color_error = ColorReadError::ReadOk;
+    controller.left_color.body_color = JOYCON_BODY_NEON_BLUE;
+    controller.left_color.button_color = JOYCON_BUTTONS_NEON_BLUE;
+    controller.right_color.body_color = JOYCON_BODY_NEON_RED;
+    controller.right_color.button_color = JOYCON_BUTTONS_NEON_RED;
+
+    controller.properties.is_vertical.Assign(1); // TODO(ogniK): Swap joycons orientations
+    controller.properties.use_plus.Assign(1);
+    controller.properties.use_minus.Assign(1);
+    controller.battery_level[0] = BATTERY_FULL;
+    controller.battery_level[1] = BATTERY_FULL;
+    controller.battery_level[2] = BATTERY_FULL;
+}
+
+void Controller_NPad::OnInit() {
+    auto& kernel = Core::System::GetInstance().Kernel();
+    styleset_changed_event =
+        Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "npad:NpadStyleSetChanged");
+
+    if (!IsControllerActivated())
+        return;
+    std::size_t controller{};
+    if (style.raw == 0) {
+        // We want to support all controllers
+        style.handheld.Assign(1);
+        style.joycon_left.Assign(1);
+        style.joycon_right.Assign(1);
+        style.joycon_dual.Assign(1);
+        style.pro_controller.Assign(1);
+        style.pokeball.Assign(1);
+    }
+    if (std::none_of(connected_controllers.begin(), connected_controllers.end(),
+                     [](const ControllerHolder& controller) { return controller.is_connected; })) {
+        supported_npad_id_types.resize(npad_id_list.size());
+        std::memcpy(supported_npad_id_types.data(), npad_id_list.data(),
+                    npad_id_list.size() * sizeof(u32));
+        AddNewController(PREFERRED_CONTROLLER);
+    }
+}
+
+void Controller_NPad::OnLoadInputDevices() {
+    std::transform(Settings::values.buttons.begin() + Settings::NativeButton::BUTTON_HID_BEGIN,
+                   Settings::values.buttons.begin() + Settings::NativeButton::BUTTON_HID_END,
+                   buttons.begin(), Input::CreateDevice<Input::ButtonDevice>);
+    std::transform(Settings::values.analogs.begin() + Settings::NativeAnalog::STICK_HID_BEGIN,
+                   Settings::values.analogs.begin() + Settings::NativeAnalog::STICK_HID_END,
+                   sticks.begin(), Input::CreateDevice<Input::AnalogDevice>);
+}
+
+void Controller_NPad::OnRelease() {}
+
+void Controller_NPad::OnUpdate(u8* data, std::size_t data_len) {
+    if (!IsControllerActivated())
+        return;
+    for (std::size_t i = 0; i < shared_memory_entries.size(); i++) {
+        auto& npad = shared_memory_entries[i];
+        const std::array<NPadGeneric*, 7> controller_npads{&npad.main_controller_states,
+                                                           &npad.handheld_states,
+                                                           &npad.dual_states,
+                                                           &npad.left_joy_states,
+                                                           &npad.right_joy_states,
+                                                           &npad.pokeball_states,
+                                                           &npad.libnx};
+
+        for (auto* main_controller : controller_npads) {
+            main_controller->common.entry_count = 16;
+            main_controller->common.total_entry_count = 17;
+
+            const auto& last_entry =
+                main_controller->npad[main_controller->common.last_entry_index];
+
+            main_controller->common.timestamp = CoreTiming::GetTicks();
+            main_controller->common.last_entry_index =
+                (main_controller->common.last_entry_index + 1) % 17;
+
+            auto& cur_entry = main_controller->npad[main_controller->common.last_entry_index];
+
+            cur_entry.timestamp = last_entry.timestamp + 1;
+            cur_entry.timestamp2 = cur_entry.timestamp;
+        }
+
+        const auto& controller_type = connected_controllers[i].type;
+
+        if (controller_type == NPadControllerType::None || !connected_controllers[i].is_connected) {
+            continue;
+        }
+
+        // Pad states
+        ControllerPadState pad_state{};
+        using namespace Settings::NativeButton;
+        pad_state.a.Assign(buttons[A - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.b.Assign(buttons[B - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.x.Assign(buttons[X - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.y.Assign(buttons[Y - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.l_stick.Assign(buttons[LStick - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.r_stick.Assign(buttons[RStick - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.l.Assign(buttons[L - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.r.Assign(buttons[R - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.zl.Assign(buttons[ZL - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.zr.Assign(buttons[ZR - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.plus.Assign(buttons[Plus - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.minus.Assign(buttons[Minus - BUTTON_HID_BEGIN]->GetStatus());
+
+        pad_state.d_left.Assign(buttons[DLeft - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.d_up.Assign(buttons[DUp - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.d_right.Assign(buttons[DRight - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.d_down.Assign(buttons[DDown - BUTTON_HID_BEGIN]->GetStatus());
+
+        pad_state.l_stick_left.Assign(buttons[LStick_Left - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.l_stick_up.Assign(buttons[LStick_Up - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.l_stick_right.Assign(buttons[LStick_Right - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.l_stick_down.Assign(buttons[LStick_Down - BUTTON_HID_BEGIN]->GetStatus());
+
+        pad_state.r_stick_left.Assign(buttons[RStick_Left - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.r_stick_up.Assign(buttons[RStick_Up - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.r_stick_right.Assign(buttons[RStick_Right - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.r_stick_down.Assign(buttons[RStick_Down - BUTTON_HID_BEGIN]->GetStatus());
+
+        pad_state.sl.Assign(buttons[SL - BUTTON_HID_BEGIN]->GetStatus());
+        pad_state.sr.Assign(buttons[SR - BUTTON_HID_BEGIN]->GetStatus());
+
+        AnalogPosition lstick_entry{};
+        AnalogPosition rstick_entry{};
+
+        const auto [stick_l_x_f, stick_l_y_f] =
+            sticks[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetStatus();
+        const auto [stick_r_x_f, stick_r_y_f] =
+            sticks[static_cast<std::size_t>(JoystickId::Joystick_Right)]->GetStatus();
+        lstick_entry.x = static_cast<s32>(stick_l_x_f * HID_JOYSTICK_MAX);
+        lstick_entry.y = static_cast<s32>(stick_l_y_f * HID_JOYSTICK_MAX);
+        rstick_entry.x = static_cast<s32>(stick_r_x_f * HID_JOYSTICK_MAX);
+        rstick_entry.y = static_cast<s32>(stick_r_y_f * HID_JOYSTICK_MAX);
+
+        if (controller_type == NPadControllerType::JoyLeft ||
+            controller_type == NPadControllerType::JoyRight) {
+            if (npad.properties.is_horizontal) {
+                ControllerPadState state{};
+                AnalogPosition temp_lstick_entry{};
+                AnalogPosition temp_rstick_entry{};
+                if (controller_type == NPadControllerType::JoyLeft) {
+                    state.d_down.Assign(pad_state.d_left.Value());
+                    state.d_left.Assign(pad_state.d_up.Value());
+                    state.d_right.Assign(pad_state.d_down.Value());
+                    state.d_up.Assign(pad_state.d_right.Value());
+                    state.l.Assign(pad_state.l.Value() | pad_state.sl.Value());
+                    state.r.Assign(pad_state.r.Value() | pad_state.sr.Value());
+
+                    state.zl.Assign(pad_state.zl.Value());
+                    state.plus.Assign(pad_state.minus.Value());
+
+                    temp_lstick_entry = lstick_entry;
+                    temp_rstick_entry = rstick_entry;
+                    std::swap(temp_lstick_entry.x, temp_lstick_entry.y);
+                    std::swap(temp_rstick_entry.x, temp_rstick_entry.y);
+                    temp_lstick_entry.y *= -1;
+                } else if (controller_type == NPadControllerType::JoyRight) {
+                    state.x.Assign(pad_state.a.Value());
+                    state.a.Assign(pad_state.b.Value());
+                    state.b.Assign(pad_state.y.Value());
+                    state.y.Assign(pad_state.b.Value());
+
+                    state.l.Assign(pad_state.l.Value() | pad_state.sl.Value());
+                    state.r.Assign(pad_state.r.Value() | pad_state.sr.Value());
+                    state.zr.Assign(pad_state.zr.Value());
+                    state.plus.Assign(pad_state.plus.Value());
+
+                    temp_lstick_entry = lstick_entry;
+                    temp_rstick_entry = rstick_entry;
+                    std::swap(temp_lstick_entry.x, temp_lstick_entry.y);
+                    std::swap(temp_rstick_entry.x, temp_rstick_entry.y);
+                    temp_rstick_entry.x *= -1;
+                }
+                pad_state.raw = state.raw;
+                lstick_entry = temp_lstick_entry;
+                rstick_entry = temp_rstick_entry;
+            }
+        }
+
+        auto& main_controller =
+            npad.main_controller_states.npad[npad.main_controller_states.common.last_entry_index];
+        auto& handheld_entry =
+            npad.handheld_states.npad[npad.handheld_states.common.last_entry_index];
+        auto& dual_entry = npad.dual_states.npad[npad.dual_states.common.last_entry_index];
+        auto& left_entry = npad.left_joy_states.npad[npad.left_joy_states.common.last_entry_index];
+        auto& right_entry =
+            npad.right_joy_states.npad[npad.right_joy_states.common.last_entry_index];
+        auto& pokeball_entry =
+            npad.pokeball_states.npad[npad.pokeball_states.common.last_entry_index];
+        auto& libnx_entry = npad.libnx.npad[npad.libnx.common.last_entry_index];
+
+        if (hold_type == NpadHoldType::Horizontal) {
+            // TODO(ogniK): Remap buttons for different orientations
+        }
+        libnx_entry.connection_status.raw = 0;
+
+        switch (controller_type) {
+        case NPadControllerType::Handheld:
+            handheld_entry.connection_status.raw = 0;
+            handheld_entry.connection_status.IsConnected.Assign(1);
+            if (!Settings::values.use_docked_mode) {
+                handheld_entry.connection_status.IsWired.Assign(1);
+            }
+            handheld_entry.pad_states.raw = pad_state.raw;
+            handheld_entry.l_stick = lstick_entry;
+            handheld_entry.r_stick = rstick_entry;
+            break;
+        case NPadControllerType::JoyDual:
+            dual_entry.connection_status.raw = 0;
+
+            dual_entry.connection_status.IsLeftJoyConnected.Assign(1);
+            dual_entry.connection_status.IsRightJoyConnected.Assign(1);
+            dual_entry.connection_status.IsConnected.Assign(1);
+
+            libnx_entry.connection_status.IsLeftJoyConnected.Assign(1);
+            libnx_entry.connection_status.IsRightJoyConnected.Assign(1);
+            libnx_entry.connection_status.IsConnected.Assign(1);
+
+            dual_entry.pad_states.raw = pad_state.raw;
+            dual_entry.l_stick = lstick_entry;
+            dual_entry.r_stick = rstick_entry;
+        case NPadControllerType::JoyLeft:
+            left_entry.connection_status.raw = 0;
+
+            left_entry.connection_status.IsConnected.Assign(1);
+            left_entry.pad_states.raw = pad_state.raw;
+            left_entry.l_stick = lstick_entry;
+            left_entry.r_stick = rstick_entry;
+            break;
+        case NPadControllerType::JoyRight:
+            right_entry.connection_status.raw = 0;
+
+            right_entry.connection_status.IsConnected.Assign(1);
+            right_entry.pad_states.raw = pad_state.raw;
+            right_entry.l_stick = lstick_entry;
+            right_entry.r_stick = rstick_entry;
+            break;
+        case NPadControllerType::Pokeball:
+            pokeball_entry.connection_status.raw = 0;
+
+            pokeball_entry.connection_status.IsConnected.Assign(1);
+            pokeball_entry.connection_status.IsWired.Assign(1);
+
+            pokeball_entry.pad_states.raw = pad_state.raw;
+            pokeball_entry.l_stick = lstick_entry;
+            pokeball_entry.r_stick = rstick_entry;
+            break;
+        case NPadControllerType::ProController:
+            main_controller.connection_status.raw = 0;
+
+            main_controller.connection_status.IsConnected.Assign(1);
+            main_controller.connection_status.IsWired.Assign(1);
+            main_controller.pad_states.raw = pad_state.raw;
+            main_controller.l_stick = lstick_entry;
+            main_controller.r_stick = rstick_entry;
+            break;
+        }
+
+        // LibNX exclusively uses this section, so we always update it since LibNX doesn't activate
+        // any controllers.
+        libnx_entry.pad_states.raw = pad_state.raw;
+        libnx_entry.l_stick = lstick_entry;
+        libnx_entry.r_stick = rstick_entry;
+    }
+    std::memcpy(data + NPAD_OFFSET, shared_memory_entries.data(),
+                shared_memory_entries.size() * sizeof(NPadEntry));
+} // namespace Service::HID
+
+void Controller_NPad::SetSupportedStyleSet(NPadType style_set) {
+    style.raw = style_set.raw;
+}
+
+Controller_NPad::NPadType Controller_NPad::GetSupportedStyleSet() const {
+    return style;
+}
+
+void Controller_NPad::SetSupportedNPadIdTypes(u8* data, std::size_t length) {
+    ASSERT(length > 0 && (length % sizeof(u32)) == 0);
+    supported_npad_id_types.clear();
+    supported_npad_id_types.resize(length / sizeof(u32));
+    std::memcpy(supported_npad_id_types.data(), data, length);
+    for (std::size_t i = 0; i < connected_controllers.size(); i++) {
+        auto& controller = connected_controllers[i];
+        if (!controller.is_connected) {
+            continue;
+        }
+        if (!IsControllerSupported(PREFERRED_CONTROLLER)) {
+            controller.type = DecideBestController(PREFERRED_CONTROLLER);
+            InitNewlyAddedControler(i);
+        }
+    }
+}
+
+void Controller_NPad::GetSupportedNpadIdTypes(u32* data, std::size_t max_length) {
+    ASSERT(max_length < supported_npad_id_types.size());
+    std::memcpy(data, supported_npad_id_types.data(), supported_npad_id_types.size());
+}
+
+std::size_t Controller_NPad::GetSupportedNPadIdTypesSize() const {
+    return supported_npad_id_types.size();
+}
+
+void Controller_NPad::SetHoldType(NpadHoldType joy_hold_type) {
+    hold_type = joy_hold_type;
+}
+Controller_NPad::NpadHoldType Controller_NPad::GetHoldType() const {
+    return hold_type;
+}
+
+void Controller_NPad::SetNpadMode(u32 npad_id, NPadAssignments assignment_mode) {
+    ASSERT(npad_id < shared_memory_entries.size());
+    shared_memory_entries[npad_id].pad_assignment = assignment_mode;
+}
+
+void Controller_NPad::VibrateController(const std::vector<u32>& controller_ids,
+                                        const std::vector<Vibration>& vibrations) {
+    if (!can_controllers_vibrate) {
+        return;
+    }
+    for (std::size_t i = 0; i < controller_ids.size(); i++) {
+        std::size_t controller_pos = i;
+        // Handheld controller conversion
+        if (controller_pos == NPAD_HANDHELD) {
+            controller_pos = 8;
+        }
+        // Unknown controller conversion
+        if (controller_pos == NPAD_UNKNOWN) {
+            controller_pos = 9;
+        }
+        if (connected_controllers[controller_pos].is_connected) {
+            // TODO(ogniK): Vibrate the physical controller
+        }
+    }
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+    last_processed_vibration = vibrations.back();
+}
+
+Kernel::SharedPtr<Kernel::Event> Controller_NPad::GetStyleSetChangedEvent() const {
+    return styleset_changed_event;
+}
+
+Controller_NPad::Vibration Controller_NPad::GetLastVibration() const {
+    return last_processed_vibration;
+}
+void Controller_NPad::AddNewController(NPadControllerType controller) {
+    if (controller == NPadControllerType::Handheld) {
+        connected_controllers[8] = {controller, true};
+        InitNewlyAddedControler(8);
+        return;
+    }
+    const auto pos =
+        std::find_if(connected_controllers.begin(), connected_controllers.end() - 2,
+                     [](const ControllerHolder& holder) { return !holder.is_connected; });
+    if (pos == connected_controllers.end() - 2) {
+        LOG_ERROR(Service_HID, "Cannot connect any more controllers!");
+        return;
+    }
+    const auto controller_id = std::distance(connected_controllers.begin(), pos);
+    connected_controllers[controller_id] = {controller, true};
+    InitNewlyAddedControler(controller_id);
+}
+
+void Controller_NPad::ConnectNPad(u32 npad_id) {
+    if (npad_id >= connected_controllers.size())
+        return;
+    connected_controllers[npad_id].is_connected = true;
+}
+
+void Controller_NPad::DisconnectNPad(u32 npad_id) {
+    if (npad_id >= connected_controllers.size())
+        return;
+    connected_controllers[npad_id].is_connected = false;
+}
+
+Controller_NPad::LedPattern Controller_NPad::GetLedPattern(u32 npad_id) {
+    if (npad_id == npad_id_list.back() || npad_id == npad_id_list[npad_id_list.size() - 2]) {
+        // These are controllers without led patterns
+        return LedPattern{0, 0, 0, 0};
+    }
+    switch (npad_id) {
+    case 0:
+        return LedPattern{1, 0, 0, 0};
+    case 1:
+        return LedPattern{0, 1, 0, 0};
+    case 2:
+        return LedPattern{0, 0, 1, 0};
+    case 3:
+        return LedPattern{0, 0, 0, 1};
+    case 4:
+        return LedPattern{1, 0, 0, 1};
+    case 5:
+        return LedPattern{1, 0, 1, 0};
+    case 6:
+        return LedPattern{1, 0, 1, 1};
+    case 7:
+        return LedPattern{0, 1, 1, 0};
+    default:
+        UNIMPLEMENTED_MSG("Unhandled npad_id {}", npad_id);
+        return LedPattern{0, 0, 0, 0};
+    };
+}
+void Controller_NPad::SetVibrationEnabled(bool can_vibrate) {
+    can_controllers_vibrate = can_vibrate;
+}
+
+bool Controller_NPad::IsControllerSupported(NPadControllerType controller) const {
+    const bool support_handheld =
+        std::find(supported_npad_id_types.begin(), supported_npad_id_types.end(), NPAD_HANDHELD) !=
+        supported_npad_id_types.end();
+    if (controller == NPadControllerType::Handheld) {
+        // Handheld is not even a supported type, lets stop here
+        if (!support_handheld) {
+            return false;
+        }
+        // Handheld should not be supported in docked mode
+        if (Settings::values.use_docked_mode) {
+            return false;
+        }
+
+        return true;
+    }
+    if (std::any_of(supported_npad_id_types.begin(), supported_npad_id_types.end(),
+                    [](u32 npad_id) { return npad_id <= MAX_NPAD_ID; })) {
+        switch (controller) {
+        case NPadControllerType::ProController:
+            return style.pro_controller;
+        case NPadControllerType::JoyDual:
+            return style.joycon_dual;
+        case NPadControllerType::JoyLeft:
+            return style.joycon_left;
+        case NPadControllerType::JoyRight:
+            return style.joycon_right;
+        case NPadControllerType::Pokeball:
+            return style.pokeball;
+        default:
+            return false;
+        }
+    }
+    return false;
+}
+
+Controller_NPad::NPadControllerType Controller_NPad::DecideBestController(
+    NPadControllerType priority) const {
+    if (IsControllerSupported(priority)) {
+        return priority;
+    }
+    const auto is_docked = Settings::values.use_docked_mode;
+    if (is_docked && priority == NPadControllerType::Handheld) {
+        priority = NPadControllerType::JoyDual;
+        if (IsControllerSupported(priority)) {
+            return priority;
+        }
+    }
+    std::vector<NPadControllerType> priority_list;
+    switch (priority) {
+    case NPadControllerType::ProController:
+        priority_list.push_back(NPadControllerType::JoyDual);
+        if (!is_docked) {
+            priority_list.push_back(NPadControllerType::Handheld);
+        }
+        priority_list.push_back(NPadControllerType::JoyLeft);
+        priority_list.push_back(NPadControllerType::JoyRight);
+        priority_list.push_back(NPadControllerType::Pokeball);
+        break;
+    case NPadControllerType::Handheld:
+        priority_list.push_back(NPadControllerType::JoyDual);
+        priority_list.push_back(NPadControllerType::ProController);
+        priority_list.push_back(NPadControllerType::JoyLeft);
+        priority_list.push_back(NPadControllerType::JoyRight);
+        priority_list.push_back(NPadControllerType::Pokeball);
+        break;
+    case NPadControllerType::JoyDual:
+        if (!is_docked) {
+            priority_list.push_back(NPadControllerType::Handheld);
+        }
+        priority_list.push_back(NPadControllerType::ProController);
+        priority_list.push_back(NPadControllerType::JoyLeft);
+        priority_list.push_back(NPadControllerType::JoyRight);
+        priority_list.push_back(NPadControllerType::Pokeball);
+        break;
+    case NPadControllerType::JoyLeft:
+        priority_list.push_back(NPadControllerType::JoyRight);
+        priority_list.push_back(NPadControllerType::JoyDual);
+        if (!is_docked) {
+            priority_list.push_back(NPadControllerType::Handheld);
+        }
+        priority_list.push_back(NPadControllerType::ProController);
+        priority_list.push_back(NPadControllerType::Pokeball);
+        break;
+    case NPadControllerType::JoyRight:
+        priority_list.push_back(NPadControllerType::JoyLeft);
+        priority_list.push_back(NPadControllerType::JoyDual);
+        if (!is_docked) {
+            priority_list.push_back(NPadControllerType::Handheld);
+        }
+        priority_list.push_back(NPadControllerType::ProController);
+        priority_list.push_back(NPadControllerType::Pokeball);
+        break;
+    case NPadControllerType::Pokeball:
+        priority_list.push_back(NPadControllerType::JoyLeft);
+        priority_list.push_back(NPadControllerType::JoyRight);
+        priority_list.push_back(NPadControllerType::JoyDual);
+        if (!is_docked) {
+            priority_list.push_back(NPadControllerType::Handheld);
+        }
+        priority_list.push_back(NPadControllerType::ProController);
+        break;
+    default:
+        priority_list.push_back(NPadControllerType::JoyDual);
+        if (!is_docked) {
+            priority_list.push_back(NPadControllerType::Handheld);
+        }
+        priority_list.push_back(NPadControllerType::ProController);
+        priority_list.push_back(NPadControllerType::JoyLeft);
+        priority_list.push_back(NPadControllerType::JoyRight);
+        priority_list.push_back(NPadControllerType::JoyDual);
+    }
+
+    const auto iter = std::find_if(priority_list.begin(), priority_list.end(),
+                                   [this](auto type) { return IsControllerSupported(type); });
+    if (iter == priority_list.end()) {
+        UNIMPLEMENTED_MSG("Could not find supported controller!");
+        return priority;
+    }
+
+    return *iter;
+}
+
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/npad.h b/src/core/hle/service/hid/controllers/npad.h
new file mode 100644
index 000000000..ac86985ff
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/npad.h
@@ -0,0 +1,289 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include "common/common_types.h"
+#include "core/frontend/input.h"
+#include "core/hle/service/hid/controllers/controller_base.h"
+#include "core/settings.h"
+
+namespace Service::HID {
+
+class Controller_NPad final : public ControllerBase {
+public:
+    Controller_NPad();
+    ~Controller_NPad() override;
+
+    // Called when the controller is initialized
+    void OnInit() override;
+
+    // When the controller is released
+    void OnRelease() override;
+
+    // When the controller is requesting an update for the shared memory
+    void OnUpdate(u8* data, std::size_t size) override;
+
+    // Called when input devices should be loaded
+    void OnLoadInputDevices() override;
+
+    struct NPadType {
+        union {
+            u32_le raw{};
+
+            BitField<0, 1, u32_le> pro_controller;
+            BitField<1, 1, u32_le> handheld;
+            BitField<2, 1, u32_le> joycon_dual;
+            BitField<3, 1, u32_le> joycon_left;
+            BitField<4, 1, u32_le> joycon_right;
+
+            BitField<6, 1, u32_le> pokeball; // TODO(ogniK): Confirm when possible
+        };
+    };
+    static_assert(sizeof(NPadType) == 4, "NPadType is an invalid size");
+
+    struct Vibration {
+        f32 amp_low;
+        f32 freq_low;
+        f32 amp_high;
+        f32 freq_high;
+    };
+    static_assert(sizeof(Vibration) == 0x10, "Vibration is an invalid size");
+
+    enum class NpadHoldType : u64 {
+        Vertical = 0,
+        Horizontal = 1,
+    };
+
+    enum class NPadAssignments : u32_le {
+        Dual = 0,
+        Single = 1,
+    };
+
+    enum class NPadControllerType {
+        None,
+        ProController,
+        Handheld,
+        JoyDual,
+        JoyLeft,
+        JoyRight,
+        Pokeball,
+    };
+
+    struct LedPattern {
+        explicit LedPattern(u64 light1, u64 light2, u64 light3, u64 light4) {
+            position1.Assign(light1);
+            position1.Assign(light2);
+            position1.Assign(light3);
+            position1.Assign(light4);
+        }
+        union {
+            u64 raw{};
+            BitField<0, 1, u64> position1;
+            BitField<1, 1, u64> position2;
+            BitField<2, 1, u64> position3;
+            BitField<3, 1, u64> position4;
+        };
+    };
+
+    void SetSupportedStyleSet(NPadType style_set);
+    NPadType GetSupportedStyleSet() const;
+
+    void SetSupportedNPadIdTypes(u8* data, std::size_t length);
+    void GetSupportedNpadIdTypes(u32* data, std::size_t max_length);
+    std::size_t GetSupportedNPadIdTypesSize() const;
+
+    void SetHoldType(NpadHoldType joy_hold_type);
+    NpadHoldType GetHoldType() const;
+
+    void SetNpadMode(u32 npad_id, NPadAssignments assignment_mode);
+
+    void VibrateController(const std::vector<u32>& controller_ids,
+                           const std::vector<Vibration>& vibrations);
+
+    Kernel::SharedPtr<Kernel::Event> GetStyleSetChangedEvent() const;
+    Vibration GetLastVibration() const;
+
+    void AddNewController(NPadControllerType controller);
+
+    void ConnectNPad(u32 npad_id);
+    void DisconnectNPad(u32 npad_id);
+    LedPattern GetLedPattern(u32 npad_id);
+    void SetVibrationEnabled(bool can_vibrate);
+
+private:
+    struct CommonHeader {
+        s64_le timestamp;
+        s64_le total_entry_count;
+        s64_le last_entry_index;
+        s64_le entry_count;
+    };
+    static_assert(sizeof(CommonHeader) == 0x20, "CommonHeader is an invalid size");
+
+    struct ControllerColor {
+        u32_le body_color;
+        u32_le button_color;
+    };
+    static_assert(sizeof(ControllerColor) == 8, "ControllerColor is an invalid size");
+
+    struct ControllerPadState {
+        union {
+            u64_le raw{};
+            // Button states
+            BitField<0, 1, u64_le> a;
+            BitField<1, 1, u64_le> b;
+            BitField<2, 1, u64_le> x;
+            BitField<3, 1, u64_le> y;
+            BitField<4, 1, u64_le> l_stick;
+            BitField<5, 1, u64_le> r_stick;
+            BitField<6, 1, u64_le> l;
+            BitField<7, 1, u64_le> r;
+            BitField<8, 1, u64_le> zl;
+            BitField<9, 1, u64_le> zr;
+            BitField<10, 1, u64_le> plus;
+            BitField<11, 1, u64_le> minus;
+
+            // D-Pad
+            BitField<12, 1, u64_le> d_left;
+            BitField<13, 1, u64_le> d_up;
+            BitField<14, 1, u64_le> d_right;
+            BitField<15, 1, u64_le> d_down;
+
+            // Left JoyStick
+            BitField<16, 1, u64_le> l_stick_left;
+            BitField<17, 1, u64_le> l_stick_up;
+            BitField<18, 1, u64_le> l_stick_right;
+            BitField<19, 1, u64_le> l_stick_down;
+
+            // Right JoyStick
+            BitField<20, 1, u64_le> r_stick_left;
+            BitField<21, 1, u64_le> r_stick_up;
+            BitField<22, 1, u64_le> r_stick_right;
+            BitField<23, 1, u64_le> r_stick_down;
+
+            // Not always active?
+            BitField<24, 1, u64_le> sl;
+            BitField<25, 1, u64_le> sr;
+        };
+    };
+    static_assert(sizeof(ControllerPadState) == 8, "ControllerPadState is an invalid size");
+
+    struct AnalogPosition {
+        s32_le x;
+        s32_le y;
+    };
+    static_assert(sizeof(AnalogPosition) == 8, "AnalogPosition is an invalid size");
+
+    struct ConnectionState {
+        union {
+            u32_le raw{};
+            BitField<0, 1, u32_le> IsConnected;
+            BitField<1, 1, u32_le> IsWired;
+            BitField<2, 1, u32_le> IsLeftJoyConnected;
+            BitField<3, 1, u32_le> IsLeftJoyWired;
+            BitField<4, 1, u32_le> IsRightJoyConnected;
+            BitField<5, 1, u32_le> IsRightJoyWired;
+        };
+    };
+    static_assert(sizeof(ConnectionState) == 4, "ConnectionState is an invalid size");
+
+    struct GenericStates {
+        s64_le timestamp;
+        s64_le timestamp2;
+        ControllerPadState pad_states;
+        AnalogPosition l_stick;
+        AnalogPosition r_stick;
+        ConnectionState connection_status;
+    };
+    static_assert(sizeof(GenericStates) == 0x30, "NPadGenericStates is an invalid size");
+
+    struct NPadGeneric {
+        CommonHeader common;
+        std::array<GenericStates, 17> npad;
+    };
+    static_assert(sizeof(NPadGeneric) == 0x350, "NPadGeneric is an invalid size");
+
+    enum class ColorReadError : u32_le {
+        ReadOk = 0,
+        ColorDoesntExist = 1,
+        NoController = 2,
+    };
+
+    struct NPadProperties {
+        union {
+            s64_le raw{};
+            BitField<11, 1, s64_le> is_vertical;
+            BitField<12, 1, s64_le> is_horizontal;
+            BitField<13, 1, s64_le> use_plus;
+            BitField<14, 1, s64_le> use_minus;
+        };
+    };
+
+    struct NPadDevice {
+        union {
+            u32_le raw{};
+            BitField<0, 1, s32_le> pro_controller;
+            BitField<1, 1, s32_le> handheld;
+            BitField<2, 1, s32_le> handheld_left;
+            BitField<3, 1, s32_le> handheld_right;
+            BitField<4, 1, s32_le> joycon_left;
+            BitField<5, 1, s32_le> joycon_right;
+            BitField<6, 1, s32_le> pokeball;
+        };
+    };
+
+    struct NPadEntry {
+        NPadType joy_styles;
+        NPadAssignments pad_assignment;
+
+        ColorReadError single_color_error;
+        ControllerColor single_color;
+
+        ColorReadError dual_color_error;
+        ControllerColor left_color;
+        ControllerColor right_color;
+
+        NPadGeneric main_controller_states;
+        NPadGeneric handheld_states;
+        NPadGeneric dual_states;
+        NPadGeneric left_joy_states;
+        NPadGeneric right_joy_states;
+        NPadGeneric pokeball_states;
+        NPadGeneric libnx; // TODO(ogniK): Find out what this actually is, libnx seems to only be
+                           // relying on this for the time being
+        INSERT_PADDING_BYTES(
+            0x708 *
+            6); // TODO(ogniK): SixAxis states, require more information before implementation
+        NPadDevice device_type;
+        NPadProperties properties;
+        INSERT_PADDING_WORDS(1);
+        std::array<u32, 3> battery_level;
+        INSERT_PADDING_BYTES(0x5c);
+        INSERT_PADDING_BYTES(0xdf8);
+    };
+    static_assert(sizeof(NPadEntry) == 0x5000, "NPadEntry is an invalid size");
+
+    struct ControllerHolder {
+        Controller_NPad::NPadControllerType type;
+        bool is_connected;
+    };
+
+    NPadType style{};
+    std::array<NPadEntry, 10> shared_memory_entries{};
+    std::array<std::unique_ptr<Input::ButtonDevice>, Settings::NativeButton::NUM_BUTTONS_HID>
+        buttons;
+    std::array<std::unique_ptr<Input::AnalogDevice>, Settings::NativeAnalog::NUM_STICKS_HID> sticks;
+    std::vector<u32> supported_npad_id_types{};
+    NpadHoldType hold_type{NpadHoldType::Vertical};
+    Kernel::SharedPtr<Kernel::Event> styleset_changed_event;
+    Vibration last_processed_vibration{};
+    std::array<ControllerHolder, 10> connected_controllers{};
+    bool can_controllers_vibrate{true};
+
+    void InitNewlyAddedControler(std::size_t controller_idx);
+    bool IsControllerSupported(NPadControllerType controller) const;
+    NPadControllerType DecideBestController(NPadControllerType priority) const;
+};
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/stubbed.cpp b/src/core/hle/service/hid/controllers/stubbed.cpp
new file mode 100644
index 000000000..02fcfadd9
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/stubbed.cpp
@@ -0,0 +1,39 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include "common/common_types.h"
+#include "core/core_timing.h"
+#include "core/hle/service/hid/controllers/stubbed.h"
+
+namespace Service::HID {
+
+Controller_Stubbed::Controller_Stubbed() = default;
+Controller_Stubbed::~Controller_Stubbed() = default;
+
+void Controller_Stubbed::OnInit() {}
+
+void Controller_Stubbed::OnRelease() {}
+
+void Controller_Stubbed::OnUpdate(u8* data, std::size_t size) {
+    if (!smart_update) {
+        return;
+    }
+
+    CommonHeader header{};
+    header.timestamp = CoreTiming::GetTicks();
+    header.total_entry_count = 17;
+    header.entry_count = 0;
+    header.last_entry_index = 0;
+
+    std::memcpy(data + common_offset, &header, sizeof(CommonHeader));
+}
+
+void Controller_Stubbed::OnLoadInputDevices() {}
+
+void Controller_Stubbed::SetCommonHeaderOffset(std::size_t off) {
+    common_offset = off;
+    smart_update = true;
+}
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/stubbed.h b/src/core/hle/service/hid/controllers/stubbed.h
new file mode 100644
index 000000000..4a21c643e
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/stubbed.h
@@ -0,0 +1,34 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+#include "core/hle/service/hid/controllers/controller_base.h"
+
+namespace Service::HID {
+class Controller_Stubbed final : public ControllerBase {
+public:
+    Controller_Stubbed();
+    ~Controller_Stubbed() override;
+
+    // Called when the controller is initialized
+    void OnInit() override;
+
+    // When the controller is released
+    void OnRelease() override;
+
+    // When the controller is requesting an update for the shared memory
+    void OnUpdate(u8* data, std::size_t size) override;
+
+    // Called when input devices should be loaded
+    void OnLoadInputDevices() override;
+
+    void SetCommonHeaderOffset(std::size_t off);
+
+private:
+    bool smart_update{};
+    std::size_t common_offset{};
+};
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/touchscreen.cpp b/src/core/hle/service/hid/controllers/touchscreen.cpp
new file mode 100644
index 000000000..43efef803
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/touchscreen.cpp
@@ -0,0 +1,65 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include "common/common_types.h"
+#include "core/core_timing.h"
+#include "core/frontend/emu_window.h"
+#include "core/frontend/input.h"
+#include "core/hle/service/hid/controllers/touchscreen.h"
+#include "core/settings.h"
+
+namespace Service::HID {
+constexpr std::size_t SHARED_MEMORY_OFFSET = 0x400;
+
+Controller_Touchscreen::Controller_Touchscreen() = default;
+Controller_Touchscreen::~Controller_Touchscreen() = default;
+
+void Controller_Touchscreen::OnInit() {}
+
+void Controller_Touchscreen::OnRelease() {}
+
+void Controller_Touchscreen::OnUpdate(u8* data, std::size_t size) {
+    shared_memory.header.timestamp = CoreTiming::GetTicks();
+    shared_memory.header.total_entry_count = 17;
+
+    if (!IsControllerActivated()) {
+        shared_memory.header.entry_count = 0;
+        shared_memory.header.last_entry_index = 0;
+        return;
+    }
+    shared_memory.header.entry_count = 16;
+
+    const auto& last_entry =
+        shared_memory.shared_memory_entries[shared_memory.header.last_entry_index];
+    shared_memory.header.last_entry_index = (shared_memory.header.last_entry_index + 1) % 17;
+    auto& cur_entry = shared_memory.shared_memory_entries[shared_memory.header.last_entry_index];
+
+    cur_entry.sampling_number = last_entry.sampling_number + 1;
+    cur_entry.sampling_number2 = cur_entry.sampling_number;
+
+    const auto [x, y, pressed] = touch_device->GetStatus();
+    auto& touch_entry = cur_entry.states[0];
+    if (pressed) {
+        touch_entry.x = static_cast<u16>(x * Layout::ScreenUndocked::Width);
+        touch_entry.y = static_cast<u16>(y * Layout::ScreenUndocked::Height);
+        touch_entry.diameter_x = 15;
+        touch_entry.diameter_y = 15;
+        touch_entry.rotation_angle = 0;
+        const u64 tick = CoreTiming::GetTicks();
+        touch_entry.delta_time = tick - last_touch;
+        last_touch = tick;
+        touch_entry.finger = 0;
+        cur_entry.entry_count = 1;
+    } else {
+        cur_entry.entry_count = 0;
+    }
+
+    std::memcpy(data + SHARED_MEMORY_OFFSET, &shared_memory, sizeof(TouchScreenSharedMemory));
+}
+
+void Controller_Touchscreen::OnLoadInputDevices() {
+    touch_device = Input::CreateDevice<Input::TouchDevice>(Settings::values.touch_device);
+}
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/touchscreen.h b/src/core/hle/service/hid/controllers/touchscreen.h
new file mode 100644
index 000000000..e5db6e6ba
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/touchscreen.h
@@ -0,0 +1,63 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/frontend/input.h"
+#include "core/hle/service/hid/controllers/controller_base.h"
+
+namespace Service::HID {
+class Controller_Touchscreen final : public ControllerBase {
+public:
+    Controller_Touchscreen();
+    ~Controller_Touchscreen() override;
+
+    // Called when the controller is initialized
+    void OnInit() override;
+
+    // When the controller is released
+    void OnRelease() override;
+
+    // When the controller is requesting an update for the shared memory
+    void OnUpdate(u8* data, std::size_t size) override;
+
+    // Called when input devices should be loaded
+    void OnLoadInputDevices() override;
+
+private:
+    struct TouchState {
+        u64_le delta_time;
+        u32_le attribute;
+        u32_le finger;
+        u32_le x;
+        u32_le y;
+        u32_le diameter_x;
+        u32_le diameter_y;
+        u32_le rotation_angle;
+    };
+    static_assert(sizeof(TouchState) == 0x28, "Touchstate is an invalid size");
+
+    struct TouchScreenEntry {
+        s64_le sampling_number;
+        s64_le sampling_number2;
+        s32_le entry_count;
+        std::array<TouchState, 16> states;
+    };
+    static_assert(sizeof(TouchScreenEntry) == 0x298, "TouchScreenEntry is an invalid size");
+
+    struct TouchScreenSharedMemory {
+        CommonHeader header;
+        std::array<TouchScreenEntry, 17> shared_memory_entries{};
+        INSERT_PADDING_BYTES(0x3c8);
+    };
+    static_assert(sizeof(TouchScreenSharedMemory) == 0x3000,
+                  "TouchScreenSharedMemory is an invalid size");
+    TouchScreenSharedMemory shared_memory{};
+    std::unique_ptr<Input::TouchDevice> touch_device;
+    s64_le last_touch{};
+};
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/xpad.cpp b/src/core/hle/service/hid/controllers/xpad.cpp
new file mode 100644
index 000000000..cd397c70b
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/xpad.cpp
@@ -0,0 +1,45 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include "common/common_types.h"
+#include "core/core_timing.h"
+#include "core/hle/service/hid/controllers/xpad.h"
+
+namespace Service::HID {
+constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3C00;
+
+Controller_XPad::Controller_XPad() = default;
+Controller_XPad::~Controller_XPad() = default;
+
+void Controller_XPad::OnInit() {}
+
+void Controller_XPad::OnRelease() {}
+
+void Controller_XPad::OnUpdate(u8* data, std::size_t size) {
+    for (auto& xpad_entry : shared_memory.shared_memory_entries) {
+        xpad_entry.header.timestamp = CoreTiming::GetTicks();
+        xpad_entry.header.total_entry_count = 17;
+
+        if (!IsControllerActivated()) {
+            xpad_entry.header.entry_count = 0;
+            xpad_entry.header.last_entry_index = 0;
+            return;
+        }
+        xpad_entry.header.entry_count = 16;
+
+        const auto& last_entry = xpad_entry.pad_states[xpad_entry.header.last_entry_index];
+        xpad_entry.header.last_entry_index = (xpad_entry.header.last_entry_index + 1) % 17;
+        auto& cur_entry = xpad_entry.pad_states[xpad_entry.header.last_entry_index];
+
+        cur_entry.sampling_number = last_entry.sampling_number + 1;
+        cur_entry.sampling_number2 = cur_entry.sampling_number;
+    }
+    // TODO(ogniK): Update xpad states
+
+    std::memcpy(data + SHARED_MEMORY_OFFSET, &shared_memory, sizeof(SharedMemory));
+}
+
+void Controller_XPad::OnLoadInputDevices() {}
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/xpad.h b/src/core/hle/service/hid/controllers/xpad.h
new file mode 100644
index 000000000..ff836989f
--- /dev/null
+++ b/src/core/hle/service/hid/controllers/xpad.h
@@ -0,0 +1,60 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/hle/service/hid/controllers/controller_base.h"
+
+namespace Service::HID {
+class Controller_XPad final : public ControllerBase {
+public:
+    Controller_XPad();
+    ~Controller_XPad() override;
+
+    // Called when the controller is initialized
+    void OnInit() override;
+
+    // When the controller is released
+    void OnRelease() override;
+
+    // When the controller is requesting an update for the shared memory
+    void OnUpdate(u8* data, std::size_t size) override;
+
+    // Called when input devices should be loaded
+    void OnLoadInputDevices() override;
+
+private:
+    struct AnalogStick {
+        s32_le x;
+        s32_le y;
+    };
+    static_assert(sizeof(AnalogStick) == 0x8, "AnalogStick is an invalid size");
+
+    struct XPadState {
+        s64_le sampling_number;
+        s64_le sampling_number2;
+        s32_le attributes;
+        u32_le pad_states;
+        AnalogStick x_stick;
+        AnalogStick y_stick;
+    };
+    static_assert(sizeof(XPadState) == 0x28, "XPadState is an invalid size");
+
+    struct XPadEntry {
+        CommonHeader header;
+        std::array<XPadState, 17> pad_states{};
+        INSERT_PADDING_BYTES(0x138);
+    };
+    static_assert(sizeof(XPadEntry) == 0x400, "XPadEntry is an invalid size");
+
+    struct SharedMemory {
+        std::array<XPadEntry, 4> shared_memory_entries{};
+    };
+    static_assert(sizeof(SharedMemory) == 0x1000, "SharedMemory is an invalid size");
+    SharedMemory shared_memory{};
+};
+} // namespace Service::HID
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 7c6b0a4e6..a9aa9ec78 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <array>
+#include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/core_timing.h"
@@ -19,6 +21,16 @@
 #include "core/hle/service/service.h"
 #include "core/settings.h"
 
+#include "core/hle/service/hid/controllers/controller_base.h"
+#include "core/hle/service/hid/controllers/debug_pad.h"
+#include "core/hle/service/hid/controllers/gesture.h"
+#include "core/hle/service/hid/controllers/keyboard.h"
+#include "core/hle/service/hid/controllers/mouse.h"
+#include "core/hle/service/hid/controllers/npad.h"
+#include "core/hle/service/hid/controllers/stubbed.h"
+#include "core/hle/service/hid/controllers/touchscreen.h"
+#include "core/hle/service/hid/controllers/xpad.h"
+
 namespace Service::HID {
 
 // Updating period for each HID device.
@@ -26,6 +38,22 @@ namespace Service::HID {
 constexpr u64 pad_update_ticks = CoreTiming::BASE_CLOCK_RATE / 100;
 constexpr u64 accelerometer_update_ticks = CoreTiming::BASE_CLOCK_RATE / 100;
 constexpr u64 gyroscope_update_ticks = CoreTiming::BASE_CLOCK_RATE / 100;
+constexpr std::size_t SHARED_MEMORY_SIZE = 0x40000;
+enum class HidController : std::size_t {
+    DebugPad,
+    Touchscreen,
+    Mouse,
+    Keyboard,
+    XPad,
+    Unknown1,
+    Unknown2,
+    Unknown3,
+    SixAxisSensor,
+    NPad,
+    Gesture,
+
+    MaxControllers,
+};
 
 class IAppletResource final : public ServiceFramework<IAppletResource> {
 public:
@@ -37,19 +65,57 @@ public:
 
         auto& kernel = Core::System::GetInstance().Kernel();
         shared_mem = Kernel::SharedMemory::Create(
-            kernel, nullptr, 0x40000, Kernel::MemoryPermission::ReadWrite,
+            kernel, nullptr, SHARED_MEMORY_SIZE, Kernel::MemoryPermission::ReadWrite,
             Kernel::MemoryPermission::Read, 0, Kernel::MemoryRegion::BASE, "HID:SharedMemory");
 
+        MakeController<Controller_DebugPad>(HidController::DebugPad);
+        MakeController<Controller_Touchscreen>(HidController::Touchscreen);
+        MakeController<Controller_Mouse>(HidController::Mouse);
+        MakeController<Controller_Keyboard>(HidController::Keyboard);
+        MakeController<Controller_XPad>(HidController::XPad);
+        MakeController<Controller_Stubbed>(HidController::Unknown1);
+        MakeController<Controller_Stubbed>(HidController::Unknown2);
+        MakeController<Controller_Stubbed>(HidController::Unknown3);
+        MakeController<Controller_Stubbed>(HidController::SixAxisSensor);
+        MakeController<Controller_NPad>(HidController::NPad);
+        MakeController<Controller_Gesture>(HidController::Gesture);
+
+        // Homebrew doesn't try to activate some controllers, so we activate them by default
+        GetController<Controller_NPad>(HidController::NPad).ActivateController();
+        GetController<Controller_Touchscreen>(HidController::Touchscreen).ActivateController();
+
+        GetController<Controller_Stubbed>(HidController::Unknown1).SetCommonHeaderOffset(0x4c00);
+        GetController<Controller_Stubbed>(HidController::Unknown2).SetCommonHeaderOffset(0x4e00);
+        GetController<Controller_Stubbed>(HidController::Unknown3).SetCommonHeaderOffset(0x5000);
+
         // Register update callbacks
         pad_update_event = CoreTiming::RegisterEvent(
             "HID::UpdatePadCallback",
-            [this](u64 userdata, int cycles_late) { UpdatePadCallback(userdata, cycles_late); });
+            [this](u64 userdata, int cycles_late) { UpdateControllers(userdata, cycles_late); });
 
         // TODO(shinyquagsire23): Other update callbacks? (accel, gyro?)
 
         CoreTiming::ScheduleEvent(pad_update_ticks, pad_update_event);
     }
 
+    void ActivateController(HidController controller) {
+        controllers[static_cast<size_t>(controller)]->ActivateController();
+    }
+
+    void DeactivateController(HidController controller) {
+        controllers[static_cast<size_t>(controller)]->DeactivateController();
+    }
+
+    template <typename T>
+    void MakeController(HidController controller) {
+        controllers[static_cast<std::size_t>(controller)] = std::make_unique<T>();
+    }
+
+    template <typename T>
+    T& GetController(HidController controller) {
+        return static_cast<T&>(*controllers[static_cast<size_t>(controller)]);
+    }
+
     ~IAppletResource() {
         CoreTiming::UnscheduleEvent(pad_update_event, 0);
     }
@@ -62,200 +128,15 @@ private:
         LOG_DEBUG(Service_HID, "called");
     }
 
-    void LoadInputDevices() {
-        std::transform(Settings::values.buttons.begin() + Settings::NativeButton::BUTTON_HID_BEGIN,
-                       Settings::values.buttons.begin() + Settings::NativeButton::BUTTON_HID_END,
-                       buttons.begin(), Input::CreateDevice<Input::ButtonDevice>);
-        std::transform(Settings::values.analogs.begin() + Settings::NativeAnalog::STICK_HID_BEGIN,
-                       Settings::values.analogs.begin() + Settings::NativeAnalog::STICK_HID_END,
-                       sticks.begin(), Input::CreateDevice<Input::AnalogDevice>);
-        touch_device = Input::CreateDevice<Input::TouchDevice>(Settings::values.touch_device);
-        // TODO(shinyquagsire23): gyro, mouse, keyboard
-    }
-
-    void UpdatePadCallback(u64 userdata, int cycles_late) {
-        SharedMemory mem{};
-        std::memcpy(&mem, shared_mem->GetPointer(), sizeof(SharedMemory));
-
-        if (Settings::values.is_device_reload_pending.exchange(false))
-            LoadInputDevices();
-
-        // Set up controllers as neon red+blue Joy-Con attached to console
-        ControllerHeader& controller_header = mem.controllers[Controller_Handheld].header;
-        controller_header.type = ControllerType_Handheld;
-        controller_header.single_colors_descriptor = ColorDesc_ColorsNonexistent;
-        controller_header.right_color_body = JOYCON_BODY_NEON_RED;
-        controller_header.right_color_buttons = JOYCON_BUTTONS_NEON_RED;
-        controller_header.left_color_body = JOYCON_BODY_NEON_BLUE;
-        controller_header.left_color_buttons = JOYCON_BUTTONS_NEON_BLUE;
-
-        for (std::size_t controller = 0; controller < mem.controllers.size(); controller++) {
-            for (auto& layout : mem.controllers[controller].layouts) {
-                layout.header.num_entries = HID_NUM_ENTRIES;
-                layout.header.max_entry_index = HID_NUM_ENTRIES - 1;
-
-                // HID shared memory stores the state of the past 17 samples in a circlular buffer,
-                // each with a timestamp in number of samples since boot.
-                const ControllerInputEntry& last_entry = layout.entries[layout.header.latest_entry];
-
-                layout.header.timestamp_ticks = CoreTiming::GetTicks();
-                layout.header.latest_entry = (layout.header.latest_entry + 1) % HID_NUM_ENTRIES;
-
-                ControllerInputEntry& entry = layout.entries[layout.header.latest_entry];
-                entry.timestamp = last_entry.timestamp + 1;
-                // TODO(shinyquagsire23): Is this always identical to timestamp?
-                entry.timestamp_2 = entry.timestamp;
-
-                // TODO(shinyquagsire23): More than just handheld input
-                if (controller != Controller_Handheld)
-                    continue;
-
-                entry.connection_state = ConnectionState_Connected | ConnectionState_Wired;
-
-                // TODO(shinyquagsire23): Set up some LUTs for each layout mapping in the future?
-                // For now everything is just the default handheld layout, but split Joy-Con will
-                // rotate the face buttons and directions for certain layouts.
-                ControllerPadState& state = entry.buttons;
-                using namespace Settings::NativeButton;
-                state.a.Assign(buttons[A - BUTTON_HID_BEGIN]->GetStatus());
-                state.b.Assign(buttons[B - BUTTON_HID_BEGIN]->GetStatus());
-                state.x.Assign(buttons[X - BUTTON_HID_BEGIN]->GetStatus());
-                state.y.Assign(buttons[Y - BUTTON_HID_BEGIN]->GetStatus());
-                state.lstick.Assign(buttons[LStick - BUTTON_HID_BEGIN]->GetStatus());
-                state.rstick.Assign(buttons[RStick - BUTTON_HID_BEGIN]->GetStatus());
-                state.l.Assign(buttons[L - BUTTON_HID_BEGIN]->GetStatus());
-                state.r.Assign(buttons[R - BUTTON_HID_BEGIN]->GetStatus());
-                state.zl.Assign(buttons[ZL - BUTTON_HID_BEGIN]->GetStatus());
-                state.zr.Assign(buttons[ZR - BUTTON_HID_BEGIN]->GetStatus());
-                state.plus.Assign(buttons[Plus - BUTTON_HID_BEGIN]->GetStatus());
-                state.minus.Assign(buttons[Minus - BUTTON_HID_BEGIN]->GetStatus());
-
-                state.dleft.Assign(buttons[DLeft - BUTTON_HID_BEGIN]->GetStatus());
-                state.dup.Assign(buttons[DUp - BUTTON_HID_BEGIN]->GetStatus());
-                state.dright.Assign(buttons[DRight - BUTTON_HID_BEGIN]->GetStatus());
-                state.ddown.Assign(buttons[DDown - BUTTON_HID_BEGIN]->GetStatus());
-
-                state.lstick_left.Assign(buttons[LStick_Left - BUTTON_HID_BEGIN]->GetStatus());
-                state.lstick_up.Assign(buttons[LStick_Up - BUTTON_HID_BEGIN]->GetStatus());
-                state.lstick_right.Assign(buttons[LStick_Right - BUTTON_HID_BEGIN]->GetStatus());
-                state.lstick_down.Assign(buttons[LStick_Down - BUTTON_HID_BEGIN]->GetStatus());
-
-                state.rstick_left.Assign(buttons[RStick_Left - BUTTON_HID_BEGIN]->GetStatus());
-                state.rstick_up.Assign(buttons[RStick_Up - BUTTON_HID_BEGIN]->GetStatus());
-                state.rstick_right.Assign(buttons[RStick_Right - BUTTON_HID_BEGIN]->GetStatus());
-                state.rstick_down.Assign(buttons[RStick_Down - BUTTON_HID_BEGIN]->GetStatus());
-
-                state.sl.Assign(buttons[SL - BUTTON_HID_BEGIN]->GetStatus());
-                state.sr.Assign(buttons[SR - BUTTON_HID_BEGIN]->GetStatus());
-
-                const auto [stick_l_x_f, stick_l_y_f] = sticks[Joystick_Left]->GetStatus();
-                const auto [stick_r_x_f, stick_r_y_f] = sticks[Joystick_Right]->GetStatus();
-                entry.joystick_left_x = static_cast<s32>(stick_l_x_f * HID_JOYSTICK_MAX);
-                entry.joystick_left_y = static_cast<s32>(stick_l_y_f * HID_JOYSTICK_MAX);
-                entry.joystick_right_x = static_cast<s32>(stick_r_x_f * HID_JOYSTICK_MAX);
-                entry.joystick_right_y = static_cast<s32>(stick_r_y_f * HID_JOYSTICK_MAX);
+    void UpdateControllers(u64 userdata, int cycles_late) {
+        const bool should_reload = Settings::values.is_device_reload_pending.exchange(false);
+        for (const auto& controller : controllers) {
+            if (should_reload) {
+                controller->OnLoadInputDevices();
             }
+            controller->OnUpdate(shared_mem->GetPointer(), SHARED_MEMORY_SIZE);
         }
 
-        TouchScreen& touchscreen = mem.touchscreen;
-        const u64 last_entry = touchscreen.header.latest_entry;
-        const u64 curr_entry = (last_entry + 1) % touchscreen.entries.size();
-        const u64 timestamp = CoreTiming::GetTicks();
-        const u64 sample_counter = touchscreen.entries[last_entry].header.timestamp + 1;
-        touchscreen.header.timestamp_ticks = timestamp;
-        touchscreen.header.num_entries = touchscreen.entries.size();
-        touchscreen.header.latest_entry = curr_entry;
-        touchscreen.header.max_entry_index = touchscreen.entries.size();
-        touchscreen.header.timestamp = timestamp;
-        touchscreen.entries[curr_entry].header.timestamp = sample_counter;
-
-        TouchScreenEntryTouch touch_entry{};
-        auto [x, y, pressed] = touch_device->GetStatus();
-        touch_entry.timestamp = timestamp;
-        touch_entry.x = static_cast<u16>(x * Layout::ScreenUndocked::Width);
-        touch_entry.y = static_cast<u16>(y * Layout::ScreenUndocked::Height);
-        touch_entry.touch_index = 0;
-
-        // TODO(DarkLordZach): Maybe try to derive these from EmuWindow?
-        touch_entry.diameter_x = 15;
-        touch_entry.diameter_y = 15;
-        touch_entry.angle = 0;
-
-        // TODO(DarkLordZach): Implement multi-touch support
-        if (pressed) {
-            touchscreen.entries[curr_entry].header.num_touches = 1;
-            touchscreen.entries[curr_entry].touches[0] = touch_entry;
-        } else {
-            touchscreen.entries[curr_entry].header.num_touches = 0;
-        }
-
-        // TODO(shinyquagsire23): Properly implement mouse
-        Mouse& mouse = mem.mouse;
-        const u64 last_mouse_entry = mouse.header.latest_entry;
-        const u64 curr_mouse_entry = (mouse.header.latest_entry + 1) % mouse.entries.size();
-        const u64 mouse_sample_counter = mouse.entries[last_mouse_entry].timestamp + 1;
-        mouse.header.timestamp_ticks = timestamp;
-        mouse.header.num_entries = mouse.entries.size();
-        mouse.header.max_entry_index = mouse.entries.size();
-        mouse.header.latest_entry = curr_mouse_entry;
-
-        mouse.entries[curr_mouse_entry].timestamp = mouse_sample_counter;
-        mouse.entries[curr_mouse_entry].timestamp_2 = mouse_sample_counter;
-
-        // TODO(shinyquagsire23): Properly implement keyboard
-        Keyboard& keyboard = mem.keyboard;
-        const u64 last_keyboard_entry = keyboard.header.latest_entry;
-        const u64 curr_keyboard_entry =
-            (keyboard.header.latest_entry + 1) % keyboard.entries.size();
-        const u64 keyboard_sample_counter = keyboard.entries[last_keyboard_entry].timestamp + 1;
-        keyboard.header.timestamp_ticks = timestamp;
-        keyboard.header.num_entries = keyboard.entries.size();
-        keyboard.header.latest_entry = last_keyboard_entry;
-        keyboard.header.max_entry_index = keyboard.entries.size();
-
-        keyboard.entries[curr_keyboard_entry].timestamp = keyboard_sample_counter;
-        keyboard.entries[curr_keyboard_entry].timestamp_2 = keyboard_sample_counter;
-
-        // TODO(shinyquagsire23): Figure out what any of these are
-        for (auto& input : mem.unk_input_1) {
-            const u64 last_input_entry = input.header.latest_entry;
-            const u64 curr_input_entry = (input.header.latest_entry + 1) % input.entries.size();
-            const u64 input_sample_counter = input.entries[last_input_entry].timestamp + 1;
-
-            input.header.timestamp_ticks = timestamp;
-            input.header.num_entries = input.entries.size();
-            input.header.latest_entry = last_input_entry;
-            input.header.max_entry_index = input.entries.size();
-
-            input.entries[curr_input_entry].timestamp = input_sample_counter;
-            input.entries[curr_input_entry].timestamp_2 = input_sample_counter;
-        }
-
-        for (auto& input : mem.unk_input_2) {
-            input.header.timestamp_ticks = timestamp;
-            input.header.num_entries = 17;
-            input.header.latest_entry = 0;
-            input.header.max_entry_index = 0;
-        }
-
-        UnkInput3& input = mem.unk_input_3;
-        const u64 last_input_entry = input.header.latest_entry;
-        const u64 curr_input_entry = (input.header.latest_entry + 1) % input.entries.size();
-        const u64 input_sample_counter = input.entries[last_input_entry].timestamp + 1;
-
-        input.header.timestamp_ticks = timestamp;
-        input.header.num_entries = input.entries.size();
-        input.header.latest_entry = last_input_entry;
-        input.header.max_entry_index = input.entries.size();
-
-        input.entries[curr_input_entry].timestamp = input_sample_counter;
-        input.entries[curr_input_entry].timestamp_2 = input_sample_counter;
-
-        // TODO(shinyquagsire23): Signal events
-
-        std::memcpy(shared_mem->GetPointer(), &mem, sizeof(SharedMemory));
-
-        // Reschedule recurrent event
         CoreTiming::ScheduleEvent(pad_update_ticks - cycles_late, pad_update_event);
     }
 
@@ -265,11 +146,8 @@ private:
     // CoreTiming update events
     CoreTiming::EventType* pad_update_event;
 
-    // Stored input state info
-    std::array<std::unique_ptr<Input::ButtonDevice>, Settings::NativeButton::NUM_BUTTONS_HID>
-        buttons;
-    std::array<std::unique_ptr<Input::AnalogDevice>, Settings::NativeAnalog::NUM_STICKS_HID> sticks;
-    std::unique_ptr<Input::TouchDevice> touch_device;
+    std::array<std::unique_ptr<ControllerBase>, static_cast<size_t>(HidController::MaxControllers)>
+        controllers{};
 };
 
 class IActiveVibrationDeviceList final : public ServiceFramework<IActiveVibrationDeviceList> {
@@ -299,9 +177,10 @@ public:
             {11, &Hid::ActivateTouchScreen, "ActivateTouchScreen"},
             {21, &Hid::ActivateMouse, "ActivateMouse"},
             {31, &Hid::ActivateKeyboard, "ActivateKeyboard"},
+            {32, nullptr, "SendKeyboardLockKeyEvent"},
             {40, nullptr, "AcquireXpadIdEventHandle"},
             {41, nullptr, "ReleaseXpadIdEventHandle"},
-            {51, nullptr, "ActivateXpad"},
+            {51, &Hid::ActivateXpad, "ActivateXpad"},
             {55, nullptr, "GetXpadIds"},
             {56, nullptr, "ActivateJoyXpad"},
             {58, nullptr, "GetJoyXpadLifoHandle"},
@@ -329,6 +208,7 @@ public:
             {80, nullptr, "GetGyroscopeZeroDriftMode"},
             {81, nullptr, "ResetGyroscopeZeroDriftMode"},
             {82, &Hid::IsSixAxisSensorAtRest, "IsSixAxisSensorAtRest"},
+            {83, nullptr, "IsFirmwareUpdateAvailableForSixAxisSensor"},
             {91, &Hid::ActivateGesture, "ActivateGesture"},
             {100, &Hid::SetSupportedNpadStyleSet, "SetSupportedNpadStyleSet"},
             {101, &Hid::GetSupportedNpadStyleSet, "GetSupportedNpadStyleSet"},
@@ -362,8 +242,8 @@ public:
             {206, &Hid::SendVibrationValues, "SendVibrationValues"},
             {207, nullptr, "SendVibrationGcErmCommand"},
             {208, nullptr, "GetActualVibrationGcErmCommand"},
-            {209, nullptr, "BeginPermitVibrationSession"},
-            {210, nullptr, "EndPermitVibrationSession"},
+            {209, &Hid::BeginPermitVibrationSession, "BeginPermitVibrationSession"},
+            {210, &Hid::EndPermitVibrationSession, "EndPermitVibrationSession"},
             {300, &Hid::ActivateConsoleSixAxisSensor, "ActivateConsoleSixAxisSensor"},
             {301, &Hid::StartConsoleSixAxisSensor, "StartConsoleSixAxisSensor"},
             {302, nullptr, "StopConsoleSixAxisSensor"},
@@ -374,6 +254,7 @@ public:
             {307, nullptr, "FinalizeSevenSixAxisSensor"},
             {308, nullptr, "SetSevenSixAxisSensorFusionStrength"},
             {309, nullptr, "GetSevenSixAxisSensorFusionStrength"},
+            {310, nullptr, "ResetSevenSixAxisSensorTimestamp"},
             {400, nullptr, "IsUsbFullKeyControllerEnabled"},
             {401, nullptr, "EnableUsbFullKeyController"},
             {402, nullptr, "IsUsbFullKeyControllerConnected"},
@@ -389,28 +270,35 @@ public:
             {505, nullptr, "SetPalmaFrModeType"},
             {506, nullptr, "ReadPalmaStep"},
             {507, nullptr, "EnablePalmaStep"},
-            {508, nullptr, "SuspendPalmaStep"},
-            {509, nullptr, "ResetPalmaStep"},
-            {510, nullptr, "ReadPalmaApplicationSection"},
-            {511, nullptr, "WritePalmaApplicationSection"},
-            {512, nullptr, "ReadPalmaUniqueCode"},
-            {513, nullptr, "SetPalmaUniqueCodeInvalid"},
+            {508, nullptr, "ResetPalmaStep"},
+            {509, nullptr, "ReadPalmaApplicationSection"},
+            {510, nullptr, "WritePalmaApplicationSection"},
+            {511, nullptr, "ReadPalmaUniqueCode"},
+            {512, nullptr, "SetPalmaUniqueCodeInvalid"},
+            {513, nullptr, "WritePalmaActivityEntry"},
+            {514, nullptr, "WritePalmaRgbLedPatternEntry"},
+            {515, nullptr, "WritePalmaWaveEntry"},
+            {516, nullptr, "SetPalmaDataBaseIdentificationVersion"},
+            {517, nullptr, "GetPalmaDataBaseIdentificationVersion"},
+            {518, nullptr, "SuspendPalmaFeature"},
+            {519, nullptr, "GetPalmaOperationResult"},
+            {520, nullptr, "ReadPalmaPlayLog"},
+            {521, nullptr, "ResetPalmaPlayLog"},
+            {522, nullptr, "SetIsPalmaAllConnectable"},
+            {523, nullptr, "SetIsPalmaPairedConnectable"},
+            {524, nullptr, "PairPalma"},
+            {525, nullptr, "SetPalmaBoostMode"},
             {1000, nullptr, "SetNpadCommunicationMode"},
             {1001, nullptr, "GetNpadCommunicationMode"},
         };
         // clang-format on
 
         RegisterHandlers(functions);
-
-        auto& kernel = Core::System::GetInstance().Kernel();
-        event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "hid:EventHandle");
     }
     ~Hid() = default;
 
 private:
     std::shared_ptr<IAppletResource> applet_resource;
-    u32 joy_hold_type{0};
-    Kernel::SharedPtr<Kernel::Event> event;
 
     void CreateAppletResource(Kernel::HLERequestContext& ctx) {
         if (applet_resource == nullptr) {
@@ -423,31 +311,59 @@ private:
         LOG_DEBUG(Service_HID, "called");
     }
 
+    void ActivateXpad(Kernel::HLERequestContext& ctx) {
+        applet_resource->ActivateController(HidController::XPad);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        LOG_DEBUG(Service_HID, "called");
+    }
+
     void ActivateDebugPad(Kernel::HLERequestContext& ctx) {
+        applet_resource->ActivateController(HidController::DebugPad);
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_DEBUG(Service_HID, "called");
     }
 
     void ActivateTouchScreen(Kernel::HLERequestContext& ctx) {
+        applet_resource->ActivateController(HidController::Touchscreen);
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_DEBUG(Service_HID, "called");
     }
 
     void ActivateMouse(Kernel::HLERequestContext& ctx) {
+        applet_resource->ActivateController(HidController::Mouse);
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_DEBUG(Service_HID, "called");
     }
 
     void ActivateKeyboard(Kernel::HLERequestContext& ctx) {
+        applet_resource->ActivateController(HidController::Keyboard);
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_DEBUG(Service_HID, "called");
+    }
+
+    void ActivateGesture(Kernel::HLERequestContext& ctx) {
+        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
+        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>();
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
         LOG_WARNING(Service_HID, "(STUBBED) called");
@@ -468,84 +384,168 @@ private:
     }
 
     void SetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        auto supported_styleset = rp.PopRaw<u32>();
+        applet_resource->GetController<Controller_NPad>(HidController::NPad)
+            .SetSupportedStyleSet({supported_styleset});
+
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
+
+        LOG_DEBUG(Service_HID, "called");
     }
 
     void GetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx) {
+        auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
+
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(0);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
+        rb.Push<u32>(controller.GetSupportedStyleSet().raw);
+        LOG_DEBUG(Service_HID, "called");
     }
 
     void SetSupportedNpadIdType(Kernel::HLERequestContext& ctx) {
+        applet_resource->GetController<Controller_NPad>(HidController::NPad)
+            .SetSupportedNPadIdTypes(ctx.ReadBuffer().data(), ctx.GetReadBufferSize());
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_DEBUG(Service_HID, "called");
     }
 
     void ActivateNpad(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
+        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>();
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(event);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
+        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>();
+        applet_resource->GetController<Controller_NPad>(HidController::NPad)
+            .DisconnectNPad(npad_id);
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_DEBUG(Service_HID, "called");
     }
 
     void GetPlayerLedPattern(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
+        IPC::RequestParser rp{ctx};
+        auto npad_id = rp.PopRaw<u32>();
+        IPC::ResponseBuilder rb{ctx, 4};
         rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
+        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>();
+        controller.SetHoldType(Controller_NPad::NpadHoldType{hold_type});
+
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_DEBUG(Service_HID, "called");
     }
 
     void GetNpadJoyHoldType(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 3};
+        const auto& controller =
+            applet_resource->GetController<Controller_NPad>(HidController::NPad);
+        IPC::ResponseBuilder rb{ctx, 4};
         rb.Push(RESULT_SUCCESS);
-        rb.Push(joy_hold_type);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
+        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>();
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
 
+    void BeginPermitVibrationSession(Kernel::HLERequestContext& ctx) {
+        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) {
+        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>();
+
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
+
+        applet_resource->GetController<Controller_NPad>(HidController::NPad)
+            .VibrateController({controller_id}, {vibration_values});
+        LOG_DEBUG(Service_HID, "called");
     }
 
-    void GetActualVibrationValue(Kernel::HLERequestContext& ctx) {
+    void SendVibrationValues(Kernel::HLERequestContext& ctx) {
+        const auto controllers = ctx.ReadBuffer(0);
+        const auto vibrations = ctx.ReadBuffer(1);
+
+        std::vector<u32> controller_list(controllers.size() / sizeof(u32));
+        std::vector<Controller_NPad::Vibration> vibration_list(vibrations.size() /
+                                                               sizeof(Controller_NPad::Vibration));
+
+        std::memcpy(controller_list.data(), controllers.data(), controllers.size());
+        std::memcpy(vibration_list.data(), vibrations.data(), vibrations.size());
+        std::transform(controller_list.begin(), controller_list.end(), controller_list.begin(),
+                       [](u32 controller_id) { return controller_id - 3; });
+
+        applet_resource->GetController<Controller_NPad>(HidController::NPad)
+            .VibrateController(controller_list, vibration_list);
+
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_DEBUG(Service_HID, "called");
+    }
+
+    void GetActualVibrationValue(Kernel::HLERequestContext& ctx) {
+        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>();
+        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_WARNING(Service_HID, "(STUBBED) called");
+        LOG_DEBUG(Service_HID, "called");
     }
 
     void MergeSingleJoyAsDualJoy(Kernel::HLERequestContext& ctx) {
@@ -555,6 +555,8 @@ private:
     }
 
     void SetNpadHandheldActivationMode(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        auto mode = rp.PopRaw<u32>();
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
         LOG_WARNING(Service_HID, "(STUBBED) called");
@@ -563,8 +565,9 @@ private:
     void GetVibrationDeviceInfo(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 4};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(0);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
+        rb.Push<u32>(1);
+        rb.Push<u32>(0);
+        LOG_DEBUG(Service_HID, "called");
     }
 
     void CreateActiveVibrationDeviceList(Kernel::HLERequestContext& ctx) {
@@ -574,12 +577,6 @@ private:
         LOG_DEBUG(Service_HID, "called");
     }
 
-    void SendVibrationValues(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
     void ActivateConsoleSixAxisSensor(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -597,18 +594,6 @@ private:
         rb.Push(RESULT_SUCCESS);
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
-
-    void ActivateGesture(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
-    void ActivateNpadWithRevision(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
 };
 
 class HidDbg final : public ServiceFramework<HidDbg> {
@@ -650,6 +635,7 @@ public:
             {140, nullptr, "DeactivateConsoleSixAxisSensor"},
             {141, nullptr, "GetConsoleSixAxisSensorSamplingFrequency"},
             {142, nullptr, "DeactivateSevenSixAxisSensor"},
+            {143, nullptr, "GetConsoleSixAxisSensorCountStates"},
             {201, nullptr, "ActivateFirmwareUpdate"},
             {202, nullptr, "DeactivateFirmwareUpdate"},
             {203, nullptr, "StartFirmwareUpdate"},
@@ -660,12 +646,23 @@ public:
             {208, nullptr, "StartFirmwareUpdateForRevert"},
             {209, nullptr, "GetAvailableFirmwareVersionForRevert"},
             {210, nullptr, "IsFirmwareUpdatingDevice"},
+            {211, nullptr, "StartFirmwareUpdateIndividual"},
+            {215, nullptr, "SetUsbFirmwareForceUpdateEnabled"},
+            {216, nullptr, "SetAllKuinaDevicesToFirmwareUpdateMode"},
             {221, nullptr, "UpdateControllerColor"},
             {222, nullptr, "ConnectUsbPadsAsync"},
             {223, nullptr, "DisconnectUsbPadsAsync"},
             {224, nullptr, "UpdateDesignInfo"},
             {225, nullptr, "GetUniquePadDriverState"},
             {226, nullptr, "GetSixAxisSensorDriverStates"},
+            {227, nullptr, "GetRxPacketHistory"},
+            {228, nullptr, "AcquireOperationEventHandle"},
+            {229, nullptr, "ReadSerialFlash"},
+            {230, nullptr, "WriteSerialFlash"},
+            {231, nullptr, "GetOperationResult"},
+            {232, nullptr, "EnableShipmentMode"},
+            {233, nullptr, "ClearPairingInfo"},
+            {234, nullptr, "GetUniquePadDeviceTypeSetInternal"},
             {301, nullptr, "GetAbstractedPadHandles"},
             {302, nullptr, "GetAbstractedPadState"},
             {303, nullptr, "GetAbstractedPadsState"},
@@ -673,6 +670,8 @@ public:
             {322, nullptr, "UnsetAutoPilotVirtualPadState"},
             {323, nullptr, "UnsetAllAutoPilotVirtualPadState"},
             {350, nullptr, "AddRegisteredDevice"},
+            {400, nullptr, "DisableExternalMcuOnNxDevice"},
+            {401, nullptr, "DisableRailDeviceFiltering"},
         };
         // clang-format on
 
@@ -708,7 +707,9 @@ public:
             {307, nullptr, "GetNpadSystemExtStyle"},
             {308, nullptr, "ApplyNpadSystemCommonPolicyFull"},
             {309, nullptr, "GetNpadFullKeyGripColor"},
+            {310, nullptr, "GetMaskedSupportedNpadStyleSet"},
             {311, nullptr, "SetNpadPlayerLedBlinkingDevice"},
+            {312, nullptr, "SetSupportedNpadStyleSetAll"},
             {321, nullptr, "GetUniquePadsFromNpad"},
             {322, nullptr, "GetIrSensorState"},
             {323, nullptr, "GetXcdHandleForNpadWithIrSensor"},
@@ -733,6 +734,7 @@ public:
             {546, nullptr, "AcquireDeviceRegisteredEventForControllerSupport"},
             {547, nullptr, "GetAllowedBluetoothLinksCount"},
             {548, nullptr, "GetRegisteredDevices"},
+            {549, nullptr, "GetConnectableRegisteredDevices"},
             {700, nullptr, "ActivateUniquePad"},
             {702, nullptr, "AcquireUniquePadConnectionEventHandle"},
             {703, nullptr, "GetUniquePadIds"},
@@ -761,6 +763,7 @@ public:
             {850, nullptr, "IsUsbFullKeyControllerEnabled"},
             {851, nullptr, "EnableUsbFullKeyController"},
             {852, nullptr, "IsUsbConnected"},
+            {870, nullptr, "IsHandheldButtonPressedOnConsoleMode"},
             {900, nullptr, "ActivateInputDetector"},
             {901, nullptr, "NotifyInputDetector"},
             {1000, nullptr, "InitializeFirmwareUpdate"},
@@ -780,6 +783,12 @@ public:
             {1052, nullptr, "CancelSixAxisSensorAccurateUserCalibration"},
             {1053, nullptr, "GetSixAxisSensorAccurateUserCalibrationState"},
             {1100, nullptr, "GetHidbusSystemServiceObject"},
+            {1120, nullptr, "SetFirmwareHotfixUpdateSkipEnabled"},
+            {1130, nullptr, "InitializeUsbFirmwareUpdate"},
+            {1131, nullptr, "FinalizeUsbFirmwareUpdate"},
+            {1132, nullptr, "CheckUsbFirmwareUpdateRequired"},
+            {1133, nullptr, "StartUsbFirmwareUpdate"},
+            {1134, nullptr, "GetUsbFirmwareUpdateState"},
         };
         // clang-format on
 
@@ -818,6 +827,7 @@ public:
             {11, nullptr, "EnableJoyPollingReceiveMode"},
             {12, nullptr, "DisableJoyPollingReceiveMode"},
             {13, nullptr, "GetPollingData"},
+            {14, nullptr, "SetStatusManagerType"},
         };
         // clang-format on
 
diff --git a/src/core/hle/service/hid/hid.h b/src/core/hle/service/hid/hid.h
index 88d926808..773035460 100644
--- a/src/core/hle/service/hid/hid.h
+++ b/src/core/hle/service/hid/hid.h
@@ -4,408 +4,12 @@
 
 #pragma once
 
-#include <array>
-#include "common/bit_field.h"
-#include "common/common_types.h"
-#include "core/hle/service/service.h"
+namespace SM {
+class ServiceManager;
+}
 
 namespace Service::HID {
 
-// Begin enums and output structs
-
-constexpr u32 HID_NUM_ENTRIES = 17;
-constexpr u32 HID_NUM_LAYOUTS = 7;
-constexpr s32 HID_JOYSTICK_MAX = 0x8000;
-constexpr s32 HID_JOYSTICK_MIN = -0x8000;
-
-constexpr u32 JOYCON_BODY_NEON_RED = 0xFF3C28;
-constexpr u32 JOYCON_BUTTONS_NEON_RED = 0x1E0A0A;
-constexpr u32 JOYCON_BODY_NEON_BLUE = 0x0AB9E6;
-constexpr u32 JOYCON_BUTTONS_NEON_BLUE = 0x001E1E;
-
-enum ControllerType : u32 {
-    ControllerType_ProController = 1 << 0,
-    ControllerType_Handheld = 1 << 1,
-    ControllerType_JoyconPair = 1 << 2,
-    ControllerType_JoyconLeft = 1 << 3,
-    ControllerType_JoyconRight = 1 << 4,
-};
-
-enum ControllerLayoutType : u32 {
-    Layout_ProController = 0, // Pro Controller or HID gamepad
-    Layout_Handheld = 1,      // Two Joy-Con docked to rails
-    Layout_Single = 2, // Horizontal single Joy-Con or pair of Joy-Con, adjusted for orientation
-    Layout_Left = 3,   // Only raw left Joy-Con state, no orientation adjustment
-    Layout_Right = 4,  // Only raw right Joy-Con state, no orientation adjustment
-    Layout_DefaultDigital = 5, // Same as next, but sticks have 8-direction values only
-    Layout_Default = 6, // Safe default, single Joy-Con have buttons/sticks rotated for orientation
-};
-
-enum ControllerColorDescription {
-    ColorDesc_ColorsNonexistent = 1 << 1,
-};
-
-enum ControllerConnectionState {
-    ConnectionState_Connected = 1 << 0,
-    ConnectionState_Wired = 1 << 1,
-};
-
-enum ControllerJoystick {
-    Joystick_Left = 0,
-    Joystick_Right = 1,
-};
-
-enum ControllerID {
-    Controller_Player1 = 0,
-    Controller_Player2 = 1,
-    Controller_Player3 = 2,
-    Controller_Player4 = 3,
-    Controller_Player5 = 4,
-    Controller_Player6 = 5,
-    Controller_Player7 = 6,
-    Controller_Player8 = 7,
-    Controller_Handheld = 8,
-    Controller_Unknown = 9,
-};
-
-// End enums and output structs
-
-// Begin UnkInput3
-
-struct UnkInput3Header {
-    u64 timestamp_ticks;
-    u64 num_entries;
-    u64 latest_entry;
-    u64 max_entry_index;
-};
-static_assert(sizeof(UnkInput3Header) == 0x20, "HID UnkInput3 header structure has incorrect size");
-
-struct UnkInput3Entry {
-    u64 timestamp;
-    u64 timestamp_2;
-    u64 unk_8;
-    u64 unk_10;
-    u64 unk_18;
-};
-static_assert(sizeof(UnkInput3Entry) == 0x28, "HID UnkInput3 entry structure has incorrect size");
-
-struct UnkInput3 {
-    UnkInput3Header header;
-    std::array<UnkInput3Entry, 17> entries;
-    std::array<u8, 0x138> padding;
-};
-static_assert(sizeof(UnkInput3) == 0x400, "HID UnkInput3 structure has incorrect size");
-
-// End UnkInput3
-
-// Begin TouchScreen
-
-struct TouchScreenHeader {
-    u64 timestamp_ticks;
-    u64 num_entries;
-    u64 latest_entry;
-    u64 max_entry_index;
-    u64 timestamp;
-};
-static_assert(sizeof(TouchScreenHeader) == 0x28,
-              "HID touch screen header structure has incorrect size");
-
-struct TouchScreenEntryHeader {
-    u64 timestamp;
-    u64 num_touches;
-};
-static_assert(sizeof(TouchScreenEntryHeader) == 0x10,
-              "HID touch screen entry header structure has incorrect size");
-
-struct TouchScreenEntryTouch {
-    u64 timestamp;
-    u32 padding;
-    u32 touch_index;
-    u32 x;
-    u32 y;
-    u32 diameter_x;
-    u32 diameter_y;
-    u32 angle;
-    u32 padding_2;
-};
-static_assert(sizeof(TouchScreenEntryTouch) == 0x28,
-              "HID touch screen touch structure has incorrect size");
-
-struct TouchScreenEntry {
-    TouchScreenEntryHeader header;
-    std::array<TouchScreenEntryTouch, 16> touches;
-    u64 unk;
-};
-static_assert(sizeof(TouchScreenEntry) == 0x298,
-              "HID touch screen entry structure has incorrect size");
-
-struct TouchScreen {
-    TouchScreenHeader header;
-    std::array<TouchScreenEntry, 17> entries;
-    std::array<u8, 0x3c0> padding;
-};
-static_assert(sizeof(TouchScreen) == 0x3000, "HID touch screen structure has incorrect size");
-
-// End TouchScreen
-
-// Begin Mouse
-
-struct MouseHeader {
-    u64 timestamp_ticks;
-    u64 num_entries;
-    u64 latest_entry;
-    u64 max_entry_index;
-};
-static_assert(sizeof(MouseHeader) == 0x20, "HID mouse header structure has incorrect size");
-
-struct MouseButtonState {
-    union {
-        u64 hex{};
-
-        // Buttons
-        BitField<0, 1, u64> left;
-        BitField<1, 1, u64> right;
-        BitField<2, 1, u64> middle;
-        BitField<3, 1, u64> forward;
-        BitField<4, 1, u64> back;
-    };
-};
-
-struct MouseEntry {
-    u64 timestamp;
-    u64 timestamp_2;
-    u32 x;
-    u32 y;
-    u32 velocity_x;
-    u32 velocity_y;
-    u32 scroll_velocity_x;
-    u32 scroll_velocity_y;
-    MouseButtonState buttons;
-};
-static_assert(sizeof(MouseEntry) == 0x30, "HID mouse entry structure has incorrect size");
-
-struct Mouse {
-    MouseHeader header;
-    std::array<MouseEntry, 17> entries;
-    std::array<u8, 0xB0> padding;
-};
-static_assert(sizeof(Mouse) == 0x400, "HID mouse structure has incorrect size");
-
-// End Mouse
-
-// Begin Keyboard
-
-struct KeyboardHeader {
-    u64 timestamp_ticks;
-    u64 num_entries;
-    u64 latest_entry;
-    u64 max_entry_index;
-};
-static_assert(sizeof(KeyboardHeader) == 0x20, "HID keyboard header structure has incorrect size");
-
-struct KeyboardModifierKeyState {
-    union {
-        u64 hex{};
-
-        // Buttons
-        BitField<0, 1, u64> lctrl;
-        BitField<1, 1, u64> lshift;
-        BitField<2, 1, u64> lalt;
-        BitField<3, 1, u64> lmeta;
-        BitField<4, 1, u64> rctrl;
-        BitField<5, 1, u64> rshift;
-        BitField<6, 1, u64> ralt;
-        BitField<7, 1, u64> rmeta;
-        BitField<8, 1, u64> capslock;
-        BitField<9, 1, u64> scrolllock;
-        BitField<10, 1, u64> numlock;
-    };
-};
-
-struct KeyboardEntry {
-    u64 timestamp;
-    u64 timestamp_2;
-    KeyboardModifierKeyState modifier;
-    u32 keys[8];
-};
-static_assert(sizeof(KeyboardEntry) == 0x38, "HID keyboard entry structure has incorrect size");
-
-struct Keyboard {
-    KeyboardHeader header;
-    std::array<KeyboardEntry, 17> entries;
-    std::array<u8, 0x28> padding;
-};
-static_assert(sizeof(Keyboard) == 0x400, "HID keyboard structure has incorrect size");
-
-// End Keyboard
-
-// Begin UnkInput1
-
-struct UnkInput1Header {
-    u64 timestamp_ticks;
-    u64 num_entries;
-    u64 latest_entry;
-    u64 max_entry_index;
-};
-static_assert(sizeof(UnkInput1Header) == 0x20, "HID UnkInput1 header structure has incorrect size");
-
-struct UnkInput1Entry {
-    u64 timestamp;
-    u64 timestamp_2;
-    u64 unk_8;
-    u64 unk_10;
-    u64 unk_18;
-};
-static_assert(sizeof(UnkInput1Entry) == 0x28, "HID UnkInput1 entry structure has incorrect size");
-
-struct UnkInput1 {
-    UnkInput1Header header;
-    std::array<UnkInput1Entry, 17> entries;
-    std::array<u8, 0x138> padding;
-};
-static_assert(sizeof(UnkInput1) == 0x400, "HID UnkInput1 structure has incorrect size");
-
-// End UnkInput1
-
-// Begin UnkInput2
-
-struct UnkInput2Header {
-    u64 timestamp_ticks;
-    u64 num_entries;
-    u64 latest_entry;
-    u64 max_entry_index;
-};
-static_assert(sizeof(UnkInput2Header) == 0x20, "HID UnkInput2 header structure has incorrect size");
-
-struct UnkInput2 {
-    UnkInput2Header header;
-    std::array<u8, 0x1E0> padding;
-};
-static_assert(sizeof(UnkInput2) == 0x200, "HID UnkInput2 structure has incorrect size");
-
-// End UnkInput2
-
-// Begin Controller
-
-struct ControllerMAC {
-    u64 timestamp;
-    std::array<u8, 0x8> mac;
-    u64 unk;
-    u64 timestamp_2;
-};
-static_assert(sizeof(ControllerMAC) == 0x20, "HID controller MAC structure has incorrect size");
-
-struct ControllerHeader {
-    u32 type;
-    u32 is_half;
-    u32 single_colors_descriptor;
-    u32 single_color_body;
-    u32 single_color_buttons;
-    u32 split_colors_descriptor;
-    u32 left_color_body;
-    u32 left_color_buttons;
-    u32 right_color_body;
-    u32 right_color_buttons;
-};
-static_assert(sizeof(ControllerHeader) == 0x28,
-              "HID controller header structure has incorrect size");
-
-struct ControllerLayoutHeader {
-    u64 timestamp_ticks;
-    u64 num_entries;
-    u64 latest_entry;
-    u64 max_entry_index;
-};
-static_assert(sizeof(ControllerLayoutHeader) == 0x20,
-              "HID controller layout header structure has incorrect size");
-
-struct ControllerPadState {
-    union {
-        u64 hex{};
-
-        // Buttons
-        BitField<0, 1, u64> a;
-        BitField<1, 1, u64> b;
-        BitField<2, 1, u64> x;
-        BitField<3, 1, u64> y;
-        BitField<4, 1, u64> lstick;
-        BitField<5, 1, u64> rstick;
-        BitField<6, 1, u64> l;
-        BitField<7, 1, u64> r;
-        BitField<8, 1, u64> zl;
-        BitField<9, 1, u64> zr;
-        BitField<10, 1, u64> plus;
-        BitField<11, 1, u64> minus;
-
-        // D-pad buttons
-        BitField<12, 1, u64> dleft;
-        BitField<13, 1, u64> dup;
-        BitField<14, 1, u64> dright;
-        BitField<15, 1, u64> ddown;
-
-        // Left stick directions
-        BitField<16, 1, u64> lstick_left;
-        BitField<17, 1, u64> lstick_up;
-        BitField<18, 1, u64> lstick_right;
-        BitField<19, 1, u64> lstick_down;
-
-        // Right stick directions
-        BitField<20, 1, u64> rstick_left;
-        BitField<21, 1, u64> rstick_up;
-        BitField<22, 1, u64> rstick_right;
-        BitField<23, 1, u64> rstick_down;
-
-        BitField<24, 1, u64> sl;
-        BitField<25, 1, u64> sr;
-    };
-};
-
-struct ControllerInputEntry {
-    u64 timestamp;
-    u64 timestamp_2;
-    ControllerPadState buttons;
-    s32 joystick_left_x;
-    s32 joystick_left_y;
-    s32 joystick_right_x;
-    s32 joystick_right_y;
-    u64 connection_state;
-};
-static_assert(sizeof(ControllerInputEntry) == 0x30,
-              "HID controller input entry structure has incorrect size");
-
-struct ControllerLayout {
-    ControllerLayoutHeader header;
-    std::array<ControllerInputEntry, 17> entries;
-};
-static_assert(sizeof(ControllerLayout) == 0x350,
-              "HID controller layout structure has incorrect size");
-
-struct Controller {
-    ControllerHeader header;
-    std::array<ControllerLayout, HID_NUM_LAYOUTS> layouts;
-    std::array<u8, 0x2a70> unk_1;
-    ControllerMAC mac_left;
-    ControllerMAC mac_right;
-    std::array<u8, 0xdf8> unk_2;
-};
-static_assert(sizeof(Controller) == 0x5000, "HID controller structure has incorrect size");
-
-// End Controller
-
-struct SharedMemory {
-    UnkInput3 unk_input_3;
-    TouchScreen touchscreen;
-    Mouse mouse;
-    Keyboard keyboard;
-    std::array<UnkInput1, 4> unk_input_1;
-    std::array<UnkInput2, 3> unk_input_2;
-    std::array<u8, 0x800> unk_section_8;
-    std::array<u8, 0x4000> controller_serials;
-    std::array<Controller, 10> controllers;
-    std::array<u8, 0x4600> unk_section_9;
-};
-static_assert(sizeof(SharedMemory) == 0x40000, "HID Shared Memory structure has incorrect size");
-
 /// Reload input devices. Used when input configuration changed
 void ReloadInputDevices();
 
diff --git a/src/core/hle/service/lbl/lbl.cpp b/src/core/hle/service/lbl/lbl.cpp
index 7321584e1..164c57e18 100644
--- a/src/core/hle/service/lbl/lbl.cpp
+++ b/src/core/hle/service/lbl/lbl.cpp
@@ -18,35 +18,35 @@ public:
     explicit LBL() : ServiceFramework{"lbl"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown1"},
-            {1, nullptr, "Unknown2"},
-            {2, nullptr, "Unknown3"},
-            {3, nullptr, "GetCurrentBacklightLevel"},
-            {4, nullptr, "Unknown4"},
-            {5, nullptr, "GetAlsComputedBacklightLevel"},
-            {6, nullptr, "TurnOffBacklight"},
-            {7, nullptr, "TurnOnBacklight"},
-            {8, nullptr, "GetBacklightStatus"},
-            {9, nullptr, "Unknown5"},
-            {10, nullptr, "Unknown6"},
-            {11, nullptr, "Unknown7"},
-            {12, nullptr, "Unknown8"},
-            {13, nullptr, "Unknown9"},
-            {14, nullptr, "Unknown10"},
-            {15, nullptr, "GetAutoBrightnessSetting"},
-            {16, nullptr, "ReadRawLightSensor"},
-            {17, nullptr, "Unknown11"},
-            {18, nullptr, "Unknown12"},
-            {19, nullptr, "Unknown13"},
-            {20, nullptr, "Unknown14"},
-            {21, nullptr, "Unknown15"},
-            {22, nullptr, "Unknown16"},
-            {23, nullptr, "Unknown17"},
-            {24, nullptr, "Unknown18"},
-            {25, nullptr, "Unknown19"},
+            {0, nullptr, "SaveCurrentSetting"},
+            {1, nullptr, "LoadCurrentSetting"},
+            {2, nullptr, "SetCurrentBrightnessSetting"},
+            {3, nullptr, "GetCurrentBrightnessSetting"},
+            {4, nullptr, "ApplyCurrentBrightnessSettingToBacklight"},
+            {5, nullptr, "GetBrightnessSettingAppliedToBacklight"},
+            {6, nullptr, "SwitchBacklightOn"},
+            {7, nullptr, "SwitchBacklightOff"},
+            {8, nullptr, "GetBacklightSwitchStatus"},
+            {9, nullptr, "EnableDimming"},
+            {10, nullptr, "DisableDimming"},
+            {11, nullptr, "IsDimmingEnabled"},
+            {12, nullptr, "EnableAutoBrightnessControl"},
+            {13, nullptr, "DisableAutoBrightnessControl"},
+            {14, nullptr, "IsAutoBrightnessControlEnabled"},
+            {15, nullptr, "SetAmbientLightSensorValue"},
+            {16, nullptr, "GetAmbientLightSensorValue"},
+            {17, nullptr, "SetBrightnessReflectionDelayLevel"},
+            {18, nullptr, "GetBrightnessReflectionDelayLevel"},
+            {19, nullptr, "SetCurrentBrightnessMapping"},
+            {20, nullptr, "GetCurrentBrightnessMapping"},
+            {21, nullptr, "SetCurrentAmbientLightSensorMapping"},
+            {22, nullptr, "GetCurrentAmbientLightSensorMapping"},
+            {23, nullptr, "IsAmbientLightSensorAvailable"},
+            {24, nullptr, "SetCurrentBrightnessSettingForVrMode"},
+            {25, nullptr, "GetCurrentBrightnessSettingForVrMode"},
             {26, &LBL::EnableVrMode, "EnableVrMode"},
             {27, &LBL::DisableVrMode, "DisableVrMode"},
-            {28, &LBL::GetVrMode, "GetVrMode"},
+            {28, &LBL::IsVrModeEnabled, "IsVrModeEnabled"},
         };
         // clang-format on
 
@@ -72,7 +72,7 @@ private:
         LOG_DEBUG(Service_LBL, "called");
     }
 
-    void GetVrMode(Kernel::HLERequestContext& ctx) {
+    void IsVrModeEnabled(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push(vr_mode_enabled);
diff --git a/src/core/hle/service/mm/mm_u.cpp b/src/core/hle/service/mm/mm_u.cpp
index 7b91bb258..e1f17a926 100644
--- a/src/core/hle/service/mm/mm_u.cpp
+++ b/src/core/hle/service/mm/mm_u.cpp
@@ -14,14 +14,14 @@ public:
     explicit MM_U() : ServiceFramework{"mm:u"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, &MM_U::Initialize, "InitializeOld"},
-            {1, &MM_U::Finalize, "FinalizeOld"},
-            {2, &MM_U::SetAndWait, "SetAndWaitOld"},
-            {3, &MM_U::Get, "GetOld"},
-            {4, &MM_U::Initialize, "Initialize"},
-            {5, &MM_U::Finalize, "Finalize"},
-            {6, &MM_U::SetAndWait, "SetAndWait"},
-            {7, &MM_U::Get, "Get"},
+            {0, &MM_U::Initialize, "Initialize"},
+            {1, &MM_U::Finalize, "Finalize"},
+            {2, &MM_U::SetAndWait, "SetAndWait"},
+            {3, &MM_U::Get, "Get"},
+            {4, &MM_U::InitializeWithId, "InitializeWithId"},
+            {5, &MM_U::FinalizeWithId, "FinalizeWithId"},
+            {6, &MM_U::SetAndWaitWithId, "SetAndWaitWithId"},
+            {7, &MM_U::GetWithId, "GetWithId"},
         };
         // clang-format on
 
@@ -59,9 +59,43 @@ private:
         rb.Push(current);
     }
 
+    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
+    }
+
+    void FinalizeWithId(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_MM, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void SetAndWaitWithId(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        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);
+        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);
+    }
+
     u32 min{0};
     u32 max{0};
     u32 current{0};
+    u32 id{1};
 };
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
diff --git a/src/core/hle/service/nfp/nfp.cpp b/src/core/hle/service/nfp/nfp.cpp
index 8c07a05c2..39c0c1e63 100644
--- a/src/core/hle/service/nfp/nfp.cpp
+++ b/src/core/hle/service/nfp/nfp.cpp
@@ -144,7 +144,7 @@ private:
     }
 
     const u64 device_handle{0xDEAD};
-    const HID::ControllerID npad_id{HID::Controller_Player1};
+    const u32 npad_id{0}; // This is the first player controller id
     State state{State::NonInitialized};
     DeviceState device_state{DeviceState::Initialized};
     Kernel::SharedPtr<Kernel::Event> activate_event;
diff --git a/src/core/hle/service/nifm/nifm.cpp b/src/core/hle/service/nifm/nifm.cpp
index 10611ed6a..75dcd94a3 100644
--- a/src/core/hle/service/nifm/nifm.cpp
+++ b/src/core/hle/service/nifm/nifm.cpp
@@ -219,6 +219,7 @@ IGeneralService::IGeneralService() : ServiceFramework("IGeneralService") {
         {35, nullptr, "GetScanData"},
         {36, nullptr, "GetCurrentAccessPoint"},
         {37, nullptr, "Shutdown"},
+        {38, nullptr, "GetAllowedChannels"},
     };
     RegisterHandlers(functions);
 }
diff --git a/src/core/hle/service/nim/nim.cpp b/src/core/hle/service/nim/nim.cpp
index 261ad539c..18091c9bb 100644
--- a/src/core/hle/service/nim/nim.cpp
+++ b/src/core/hle/service/nim/nim.cpp
@@ -71,6 +71,22 @@ public:
     }
 };
 
+class NIM_ECA final : public ServiceFramework<NIM_ECA> {
+public:
+    explicit NIM_ECA() : ServiceFramework{"nim:eca"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "CreateServerInterface"},
+            {1, nullptr, "RefreshDebugAvailability"},
+            {2, nullptr, "ClearDebugResponse"},
+            {3, nullptr, "RegisterDebugResponse"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
 class NIM_SHP final : public ServiceFramework<NIM_SHP> {
 public:
     explicit NIM_SHP() : ServiceFramework{"nim:shp"} {
@@ -214,6 +230,7 @@ private:
 
 void InstallInterfaces(SM::ServiceManager& sm) {
     std::make_shared<NIM>()->InstallAsService(sm);
+    std::make_shared<NIM_ECA>()->InstallAsService(sm);
     std::make_shared<NIM_SHP>()->InstallAsService(sm);
     std::make_shared<NTC>()->InstallAsService(sm);
 }
diff --git a/src/core/hle/service/npns/npns.cpp b/src/core/hle/service/npns/npns.cpp
new file mode 100644
index 000000000..ccb6f9da9
--- /dev/null
+++ b/src/core/hle/service/npns/npns.cpp
@@ -0,0 +1,88 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "core/hle/service/npns/npns.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::NPNS {
+
+class NPNS_S final : public ServiceFramework<NPNS_S> {
+public:
+    explicit NPNS_S() : ServiceFramework{"npns:s"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "ListenAll"},
+            {2, nullptr, "ListenTo"},
+            {3, nullptr, "Receive"},
+            {4, nullptr, "ReceiveRaw"},
+            {5, nullptr, "GetReceiveEvent"},
+            {6, nullptr, "ListenUndelivered"},
+            {7, nullptr, "GetStateChangeEVent"},
+            {11, nullptr, "SubscribeTopic"},
+            {12, nullptr, "UnsubscribeTopic"},
+            {13, nullptr, "QueryIsTopicExist"},
+            {21, nullptr, "CreateToken"},
+            {22, nullptr, "CreateTokenWithApplicationId"},
+            {23, nullptr, "DestroyToken"},
+            {24, nullptr, "DestroyTokenWithApplicationId"},
+            {25, nullptr, "QueryIsTokenValid"},
+            {31, nullptr, "UploadTokenToBaaS"},
+            {32, nullptr, "DestroyTokenForBaaS"},
+            {33, nullptr, "CreateTokenForBaaS"},
+            {34, nullptr, "SetBaaSDeviceAccountIdList"},
+            {101, nullptr, "Suspend"},
+            {102, nullptr, "Resume"},
+            {103, nullptr, "GetState"},
+            {104, nullptr, "GetStatistics"},
+            {105, nullptr, "GetPlayReportRequestEvent"},
+            {111, nullptr, "GetJid"},
+            {112, nullptr, "CreateJid"},
+            {113, nullptr, "DestroyJid"},
+            {114, nullptr, "AttachJid"},
+            {115, nullptr, "DetachJid"},
+            {201, nullptr, "RequestChangeStateForceTimed"},
+            {102, nullptr, "RequestChangeStateForceAsync"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class NPNS_U final : public ServiceFramework<NPNS_U> {
+public:
+    explicit NPNS_U() : ServiceFramework{"npns:u"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "ListenAll"},
+            {2, nullptr, "ListenTo"},
+            {3, nullptr, "Receive"},
+            {4, nullptr, "ReceiveRaw"},
+            {5, nullptr, "GetReceiveEvent"},
+            {7, nullptr, "GetStateChangeEVent"},
+            {21, nullptr, "CreateToken"},
+            {23, nullptr, "DestroyToken"},
+            {25, nullptr, "QueryIsTokenValid"},
+            {26, nullptr, "ListenToMyApplicationId"},
+            {101, nullptr, "Suspend"},
+            {102, nullptr, "Resume"},
+            {103, nullptr, "GetState"},
+            {104, nullptr, "GetStatistics"},
+            {111, nullptr, "GetJid"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<NPNS_S>()->InstallAsService(sm);
+    std::make_shared<NPNS_U>()->InstallAsService(sm);
+}
+
+} // namespace Service::NPNS
diff --git a/src/core/hle/service/npns/npns.h b/src/core/hle/service/npns/npns.h
new file mode 100644
index 000000000..861cd3e48
--- /dev/null
+++ b/src/core/hle/service/npns/npns.h
@@ -0,0 +1,15 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Service::SM {
+class ServiceManager;
+}
+
+namespace Service::NPNS {
+
+void InstallInterfaces(SM::ServiceManager& sm);
+
+} // namespace Service::NPNS
diff --git a/src/core/hle/service/ns/ns.cpp b/src/core/hle/service/ns/ns.cpp
index 98017267c..07c1381fe 100644
--- a/src/core/hle/service/ns/ns.cpp
+++ b/src/core/hle/service/ns/ns.cpp
@@ -93,13 +93,23 @@ public:
             {86, nullptr, "EnableApplicationCrashReport"},
             {87, nullptr, "IsApplicationCrashReportEnabled"},
             {90, nullptr, "BoostSystemMemoryResourceLimit"},
+            {91, nullptr, "Unknown1"},
+            {92, nullptr, "Unknown2"},
+            {93, nullptr, "GetMainApplicationProgramIndex"},
+            {94, nullptr, "LaunchApplication2"},
+            {95, nullptr, "GetApplicationLaunchInfo"},
+            {96, nullptr, "AcquireApplicationLaunchInfo"},
+            {97, nullptr, "GetMainApplicationProgramIndex2"},
+            {98, nullptr, "EnableApplicationAllThreadDumpOnCrash"},
             {100, nullptr, "ResetToFactorySettings"},
             {101, nullptr, "ResetToFactorySettingsWithoutUserSaveData"},
             {102, nullptr, "ResetToFactorySettingsForRefurbishment"},
             {200, nullptr, "CalculateUserSaveDataStatistics"},
             {201, nullptr, "DeleteUserSaveDataAll"},
             {210, nullptr, "DeleteUserSystemSaveData"},
+            {211, nullptr, "DeleteSaveData"},
             {220, nullptr, "UnregisterNetworkServiceAccount"},
+            {221, nullptr, "UnregisterNetworkServiceAccountWithUserSaveDataDeletion"},
             {300, nullptr, "GetApplicationShellEvent"},
             {301, nullptr, "PopApplicationShellEventInfo"},
             {302, nullptr, "LaunchLibraryApplet"},
@@ -114,6 +124,7 @@ public:
             {403, nullptr, "GetMaxApplicationControlCacheCount"},
             {404, nullptr, "InvalidateApplicationControlCache"},
             {405, nullptr, "ListApplicationControlCacheEntryInfo"},
+            {406, nullptr, "GetApplicationControlProperty"},
             {502, nullptr, "RequestCheckGameCardRegistration"},
             {503, nullptr, "RequestGameCardRegistrationGoldPoint"},
             {504, nullptr, "RequestRegisterGameCard"},
@@ -129,6 +140,7 @@ public:
             {604, nullptr, "RegisterContentsExternalKey"},
             {605, nullptr, "ListApplicationContentMetaStatusWithRightsCheck"},
             {606, nullptr, "GetContentMetaStorage"},
+            {607, nullptr, "ListAvailableAddOnContent"},
             {700, nullptr, "PushDownloadTaskList"},
             {701, nullptr, "ClearTaskStatusList"},
             {702, nullptr, "RequestDownloadTaskList"},
@@ -148,6 +160,9 @@ public:
             {907, nullptr, "WithdrawApplicationUpdateRequest"},
             {908, nullptr, "ListApplicationRecordInstalledContentMeta"},
             {909, nullptr, "WithdrawCleanupAddOnContentsWithNoRightsRecommendation"},
+            {910, nullptr, "Unknown3"},
+            {911, nullptr, "SetPreInstalledApplication"},
+            {912, nullptr, "ClearPreInstalledApplicationFlag"},
             {1000, nullptr, "RequestVerifyApplicationDeprecated"},
             {1001, nullptr, "CorruptApplicationForDebug"},
             {1002, nullptr, "RequestVerifyAddOnContentsRights"},
@@ -162,6 +177,8 @@ public:
             {1305, nullptr, "TryDeleteRunningApplicationEntity"},
             {1306, nullptr, "TryDeleteRunningApplicationCompletely"},
             {1307, nullptr, "TryDeleteRunningApplicationContentEntities"},
+            {1308, nullptr, "DeleteApplicationCompletelyForDebug"},
+            {1309, nullptr, "CleanupUnavailableAddOnContents"},
             {1400, nullptr, "PrepareShutdown"},
             {1500, nullptr, "FormatSdCard"},
             {1501, nullptr, "NeedsSystemUpdateToFormatSdCard"},
@@ -199,6 +216,28 @@ public:
             {2015, nullptr, "CompareSystemDeliveryInfo"},
             {2016, nullptr, "ListNotCommittedContentMeta"},
             {2017, nullptr, "CreateDownloadTask"},
+            {2018, nullptr, "Unknown4"},
+            {2050, nullptr, "Unknown5"},
+            {2100, nullptr, "Unknown6"},
+            {2101, nullptr, "Unknown7"},
+            {2150, nullptr, "CreateRightsEnvironment"},
+            {2151, nullptr, "DestroyRightsEnvironment"},
+            {2152, nullptr, "ActivateRightsEnvironment"},
+            {2153, nullptr, "DeactivateRightsEnvironment"},
+            {2154, nullptr, "ForceActivateRightsContextForExit"},
+            {2160, nullptr, "AddTargetApplicationToRightsEnvironment"},
+            {2161, nullptr, "SetUsersToRightsEnvironment"},
+            {2170, nullptr, "GetRightsEnvironmentStatus"},
+            {2171, nullptr, "GetRightsEnvironmentStatusChangedEvent"},
+            {2180, nullptr, "RequestExtendRightsInRightsEnvironment"},
+            {2181, nullptr, "GetLastResultOfExtendRightsInRightsEnvironment"},
+            {2182, nullptr, "SetActiveRightsContextUsingStateToRightsEnvironment"},
+            {2190, nullptr, "GetRightsEnvironmentHandleForApplication"},
+            {2199, nullptr, "GetRightsEnvironmentCountForDebug"},
+            {2200, nullptr, "Unknown8"},
+            {2201, nullptr, "Unknown9"},
+            {2250, nullptr, "Unknown10"},
+            {2300, nullptr, "Unknown11"},
         };
         // clang-format on
 
@@ -348,12 +387,15 @@ public:
             {0, nullptr, "LaunchProgram"},
             {1, nullptr, "TerminateProcess"},
             {2, nullptr, "TerminateProgram"},
-            {3, nullptr, "GetShellEventHandle"},
-            {4, nullptr, "GetShellEventInfo"},
-            {5, nullptr, "TerminateApplication"},
-            {6, nullptr, "PrepareLaunchProgramFromHost"},
-            {7, nullptr, "LaunchApplication"},
-            {8, nullptr, "LaunchApplicationWithStorageId"},
+            {4, nullptr, "GetShellEventHandle"},
+            {5, nullptr, "GetShellEventInfo"},
+            {6, nullptr, "TerminateApplication"},
+            {7, nullptr, "PrepareLaunchProgramFromHost"},
+            {8, nullptr, "LaunchApplication"},
+            {9, nullptr, "LaunchApplicationWithStorageId"},
+            {10, nullptr, "TerminateApplication2"},
+            {11, nullptr, "GetRunningApplicationProcessId"},
+            {12, nullptr, "SetCurrentApplicationRightsEnvironmentCanBeActive"},
         };
         // clang-format on
 
@@ -388,6 +430,7 @@ public:
             {19, nullptr, "GetReceivedEulaDataSize"},
             {20, nullptr, "GetReceivedEulaData"},
             {21, nullptr, "SetupToReceiveSystemUpdate"},
+            {22, nullptr, "RequestCheckLatestUpdateIncludesRebootlessUpdate"},
         };
         // clang-format on
 
diff --git a/src/core/hle/service/prepo/prepo.cpp b/src/core/hle/service/prepo/prepo.cpp
index 6a9eccfb5..e4fcee9f8 100644
--- a/src/core/hle/service/prepo/prepo.cpp
+++ b/src/core/hle/service/prepo/prepo.cpp
@@ -14,20 +14,24 @@ public:
     explicit PlayReport(const char* name) : ServiceFramework{name} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {10100, nullptr, "SaveReport"},
-            {10101, &PlayReport::SaveReportWithUser, "SaveReportWithUser"},
+            {10100, nullptr, "SaveReportOld"},
+            {10101, &PlayReport::SaveReportWithUserOld, "SaveReportWithUserOld"},
+            {10102, nullptr, "SaveReport"},
+            {10103, nullptr, "SaveReportWithUser"},
             {10200, nullptr, "RequestImmediateTransmission"},
             {10300, nullptr, "GetTransmissionStatus"},
             {20100, nullptr, "SaveSystemReport"},
-            {20200, nullptr, "SetOperationMode"},
             {20101, nullptr, "SaveSystemReportWithUser"},
+            {20200, nullptr, "SetOperationMode"},
             {30100, nullptr, "ClearStorage"},
+            {30200, nullptr, "ClearStatistics"},
+            {30300, nullptr, "GetStorageUsage"},
+            {30400, nullptr, "GetStatistics"},
+            {30401, nullptr, "GetThroughputHistory"},
+            {30500, nullptr, "GetLastUploadError"},
             {40100, nullptr, "IsUserAgreementCheckEnabled"},
             {40101, nullptr, "SetUserAgreementCheckEnabled"},
-            {90100, nullptr, "GetStorageUsage"},
-            {90200, nullptr, "GetStatistics"},
-            {90201, nullptr, "GetThroughputHistory"},
-            {90300, nullptr, "GetLastUploadError"},
+            {90100, nullptr, "ReadAllReportFiles"},
         };
         // clang-format on
 
@@ -35,7 +39,7 @@ public:
     }
 
 private:
-    void SaveReportWithUser(Kernel::HLERequestContext& ctx) {
+    void SaveReportWithUserOld(Kernel::HLERequestContext& ctx) {
         // TODO(ogniK): Do we want to add play report?
         LOG_WARNING(Service_PREPO, "(STUBBED) called");
 
@@ -46,6 +50,7 @@ private:
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<PlayReport>("prepo:a")->InstallAsService(service_manager);
+    std::make_shared<PlayReport>("prepo:a2")->InstallAsService(service_manager);
     std::make_shared<PlayReport>("prepo:m")->InstallAsService(service_manager);
     std::make_shared<PlayReport>("prepo:s")->InstallAsService(service_manager);
     std::make_shared<PlayReport>("prepo:u")->InstallAsService(service_manager);
diff --git a/src/core/hle/service/ptm/psm.cpp b/src/core/hle/service/ptm/psm.cpp
new file mode 100644
index 000000000..c2d5fda94
--- /dev/null
+++ b/src/core/hle/service/ptm/psm.cpp
@@ -0,0 +1,71 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/service/ptm/psm.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::PSM {
+
+constexpr u32 BATTERY_FULLY_CHARGED = 100;    // 100% Full
+constexpr u32 BATTERY_CURRENTLY_CHARGING = 1; // Plugged into an official dock
+
+class PSM final : public ServiceFramework<PSM> {
+public:
+    explicit PSM() : ServiceFramework{"psm"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &PSM::GetBatteryChargePercentage, "GetBatteryChargePercentage"},
+            {1, &PSM::GetChargerType, "GetChargerType"},
+            {2, nullptr, "EnableBatteryCharging"},
+            {3, nullptr, "DisableBatteryCharging"},
+            {4, nullptr, "IsBatteryChargingEnabled"},
+            {5, nullptr, "AcquireControllerPowerSupply"},
+            {6, nullptr, "ReleaseControllerPowerSupply"},
+            {7, nullptr, "OpenSession"},
+            {8, nullptr, "EnableEnoughPowerChargeEmulation"},
+            {9, nullptr, "DisableEnoughPowerChargeEmulation"},
+            {10, nullptr, "EnableFastBatteryCharging"},
+            {11, nullptr, "DisableFastBatteryCharging"},
+            {12, nullptr, "GetBatteryVoltageState"},
+            {13, nullptr, "GetRawBatteryChargePercentage"},
+            {14, nullptr, "IsEnoughPowerSupplied"},
+            {15, nullptr, "GetBatteryAgePercentage"},
+            {16, nullptr, "GetBatteryChargeInfoEvent"},
+            {17, nullptr, "GetBatteryChargeInfoFields"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+    ~PSM() override = default;
+
+private:
+    void GetBatteryChargePercentage(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_PSM, "(STUBBED) called");
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push<u32>(BATTERY_FULLY_CHARGED);
+    }
+
+    void GetChargerType(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_PSM, "(STUBBED) called");
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push<u32>(BATTERY_CURRENTLY_CHARGING);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<PSM>()->InstallAsService(sm);
+}
+
+} // namespace Service::PSM
diff --git a/src/core/hle/service/ptm/psm.h b/src/core/hle/service/ptm/psm.h
new file mode 100644
index 000000000..a286793ae
--- /dev/null
+++ b/src/core/hle/service/ptm/psm.h
@@ -0,0 +1,15 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Service::SM {
+class ServiceManager;
+}
+
+namespace Service::PSM {
+
+void InstallInterfaces(SM::ServiceManager& sm);
+
+} // namespace Service::PSM
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index a225cb4cb..a4cf45267 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -22,7 +22,7 @@
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/arp/arp.h"
 #include "core/hle/service/audio/audio.h"
-#include "core/hle/service/bcat/bcat.h"
+#include "core/hle/service/bcat/module.h"
 #include "core/hle/service/bpc/bpc.h"
 #include "core/hle/service/btdrv/btdrv.h"
 #include "core/hle/service/btm/btm.h"
@@ -48,15 +48,17 @@
 #include "core/hle/service/nfp/nfp.h"
 #include "core/hle/service/nifm/nifm.h"
 #include "core/hle/service/nim/nim.h"
+#include "core/hle/service/npns/npns.h"
 #include "core/hle/service/ns/ns.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
 #include "core/hle/service/pcie/pcie.h"
-#include "core/hle/service/pctl/pctl.h"
+#include "core/hle/service/pctl/module.h"
 #include "core/hle/service/pcv/pcv.h"
 #include "core/hle/service/pm/pm.h"
 #include "core/hle/service/prepo/prepo.h"
 #include "core/hle/service/psc/psc.h"
+#include "core/hle/service/ptm/psm.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/set/settings.h"
 #include "core/hle/service/sm/sm.h"
@@ -236,6 +238,7 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm, FileSys::VfsFilesystem& vfs)
     NFP::InstallInterfaces(*sm);
     NIFM::InstallInterfaces(*sm);
     NIM::InstallInterfaces(*sm);
+    NPNS::InstallInterfaces(*sm);
     NS::InstallInterfaces(*sm);
     Nvidia::InstallInterfaces(*sm, *nv_flinger);
     PCIe::InstallInterfaces(*sm);
@@ -244,6 +247,7 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm, FileSys::VfsFilesystem& vfs)
     PlayReport::InstallInterfaces(*sm);
     PM::InstallInterfaces(*sm);
     PSC::InstallInterfaces(*sm);
+    PSM::InstallInterfaces(*sm);
     Set::InstallInterfaces(*sm);
     Sockets::InstallInterfaces(*sm);
     SPL::InstallInterfaces(*sm);
diff --git a/src/core/hle/service/set/set_cal.cpp b/src/core/hle/service/set/set_cal.cpp
index 5af356d10..34654bb07 100644
--- a/src/core/hle/service/set/set_cal.cpp
+++ b/src/core/hle/service/set/set_cal.cpp
@@ -39,7 +39,8 @@ SET_CAL::SET_CAL() : ServiceFramework("set:cal") {
         {29, nullptr, "GetAmiiboEcqvBlsKey"},
         {30, nullptr, "GetAmiiboEcqvBlsCertificate"},
         {31, nullptr, "GetAmiiboEcqvBlsRootCertificate"},
-        {32, nullptr, "GetUnknownId"},
+        {32, nullptr, "GetUsbTypeCPowerSourceCircuitVersion"},
+        {33, nullptr, "GetBatteryVersion"},
     };
     RegisterHandlers(functions);
 }
diff --git a/src/core/loader/xci.cpp b/src/core/loader/xci.cpp
index 7a619acb4..461607c95 100644
--- a/src/core/loader/xci.cpp
+++ b/src/core/loader/xci.cpp
@@ -59,8 +59,7 @@ ResultStatus AppLoader_XCI::Load(Kernel::Process& process) {
     if (xci->GetProgramNCAStatus() != ResultStatus::Success)
         return xci->GetProgramNCAStatus();
 
-    const auto nca = xci->GetProgramNCA();
-    if (nca == nullptr && !Core::Crypto::KeyManager::KeyFileExists(false))
+    if (!xci->HasProgramNCA() && !Core::Crypto::KeyManager::KeyFileExists(false))
         return ResultStatus::ErrorMissingProductionKeyFile;
 
     const auto result = nca_loader->Load(process);
diff --git a/src/core/settings.h b/src/core/settings.h
index 83b9a04c8..8f2da01c8 100644
--- a/src/core/settings.h
+++ b/src/core/settings.h
@@ -136,7 +136,7 @@ struct Values {
     float resolution_factor;
     bool use_frame_limit;
     u16 frame_limit;
-    bool use_accurate_framebuffers;
+    bool use_accurate_gpu_emulation;
 
     float bg_red;
     float bg_green;
diff --git a/src/core/telemetry_session.cpp b/src/core/telemetry_session.cpp
index 7b04792b5..0de13edd3 100644
--- a/src/core/telemetry_session.cpp
+++ b/src/core/telemetry_session.cpp
@@ -163,8 +163,8 @@ TelemetrySession::TelemetrySession() {
     AddField(Telemetry::FieldType::UserConfig, "Renderer_UseFrameLimit",
              Settings::values.use_frame_limit);
     AddField(Telemetry::FieldType::UserConfig, "Renderer_FrameLimit", Settings::values.frame_limit);
-    AddField(Telemetry::FieldType::UserConfig, "Renderer_UseAccurateFramebuffers",
-             Settings::values.use_accurate_framebuffers);
+    AddField(Telemetry::FieldType::UserConfig, "Renderer_UseAccurateGpuEmulation",
+             Settings::values.use_accurate_gpu_emulation);
     AddField(Telemetry::FieldType::UserConfig, "System_UseDockedMode",
              Settings::values.use_docked_mode);
 }
diff --git a/src/video_core/engines/fermi_2d.cpp b/src/video_core/engines/fermi_2d.cpp
index 597b279b9..74e44c7fe 100644
--- a/src/video_core/engines/fermi_2d.cpp
+++ b/src/video_core/engines/fermi_2d.cpp
@@ -47,9 +47,12 @@ void Fermi2D::HandleSurfaceCopy() {
     u32 dst_bytes_per_pixel = RenderTargetBytesPerPixel(regs.dst.format);
 
     if (!rasterizer.AccelerateSurfaceCopy(regs.src, regs.dst)) {
-        // TODO(bunnei): The below implementation currently will not get hit, as
-        // AccelerateSurfaceCopy tries to always copy and will always return success. This should be
-        // changed once we properly support flushing.
+        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
+        // might contain a dirty surface that will have to be written back to memory.
+        rasterizer.InvalidateRegion(dest_cpu,
+                                    dst_bytes_per_pixel * regs.dst.width * regs.dst.height);
 
         if (regs.src.linear == regs.dst.linear) {
             // If the input layout and the output layout are the same, just perform a raw copy.
diff --git a/src/video_core/engines/kepler_memory.cpp b/src/video_core/engines/kepler_memory.cpp
index 66ae6332d..585290d9f 100644
--- a/src/video_core/engines/kepler_memory.cpp
+++ b/src/video_core/engines/kepler_memory.cpp
@@ -5,10 +5,14 @@
 #include "common/logging/log.h"
 #include "core/memory.h"
 #include "video_core/engines/kepler_memory.h"
+#include "video_core/rasterizer_interface.h"
 
 namespace Tegra::Engines {
 
-KeplerMemory::KeplerMemory(MemoryManager& memory_manager) : memory_manager(memory_manager) {}
+KeplerMemory::KeplerMemory(VideoCore::RasterizerInterface& rasterizer,
+                           MemoryManager& memory_manager)
+    : memory_manager(memory_manager), rasterizer{rasterizer} {}
+
 KeplerMemory::~KeplerMemory() = default;
 
 void KeplerMemory::WriteReg(u32 method, u32 value) {
@@ -37,6 +41,11 @@ void KeplerMemory::ProcessData(u32 data) {
     VAddr dest_address =
         *memory_manager.GpuToCpuAddress(address + state.write_offset * sizeof(u32));
 
+    // 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 might contain
+    // a dirty surface that will have to be written back to memory.
+    rasterizer.InvalidateRegion(dest_address, sizeof(u32));
+
     Memory::Write32(dest_address, data);
 
     state.write_offset++;
diff --git a/src/video_core/engines/kepler_memory.h b/src/video_core/engines/kepler_memory.h
index b0d0078cf..bf4a13cff 100644
--- a/src/video_core/engines/kepler_memory.h
+++ b/src/video_core/engines/kepler_memory.h
@@ -11,6 +11,10 @@
 #include "common/common_types.h"
 #include "video_core/memory_manager.h"
 
+namespace VideoCore {
+class RasterizerInterface;
+}
+
 namespace Tegra::Engines {
 
 #define KEPLERMEMORY_REG_INDEX(field_name)                                                         \
@@ -18,7 +22,7 @@ namespace Tegra::Engines {
 
 class KeplerMemory final {
 public:
-    KeplerMemory(MemoryManager& memory_manager);
+    KeplerMemory(VideoCore::RasterizerInterface& rasterizer, MemoryManager& memory_manager);
     ~KeplerMemory();
 
     /// Write the value to the register identified by method.
@@ -72,6 +76,7 @@ public:
 
 private:
     MemoryManager& memory_manager;
+    VideoCore::RasterizerInterface& rasterizer;
 
     void ProcessData(u32 data);
 };
diff --git a/src/video_core/engines/maxwell_3d.cpp b/src/video_core/engines/maxwell_3d.cpp
index 8afd26fe9..bca014a4a 100644
--- a/src/video_core/engines/maxwell_3d.cpp
+++ b/src/video_core/engines/maxwell_3d.cpp
@@ -13,8 +13,7 @@
 #include "video_core/renderer_base.h"
 #include "video_core/textures/texture.h"
 
-namespace Tegra {
-namespace Engines {
+namespace Tegra::Engines {
 
 /// First register id that is actually a Macro call.
 constexpr u32 MacroRegistersStart = 0xE00;
@@ -408,5 +407,4 @@ void Maxwell3D::ProcessClearBuffers() {
     rasterizer.Clear();
 }
 
-} // namespace Engines
-} // namespace Tegra
+} // namespace Tegra::Engines
diff --git a/src/video_core/engines/maxwell_3d.h b/src/video_core/engines/maxwell_3d.h
index c8d1b6478..0e09a7ee5 100644
--- a/src/video_core/engines/maxwell_3d.h
+++ b/src/video_core/engines/maxwell_3d.h
@@ -448,7 +448,10 @@ public:
                 BitField<8, 3, u32> block_depth;
                 BitField<12, 1, InvMemoryLayout> type;
             } memory_layout;
-            u32 array_mode;
+            union {
+                BitField<0, 16, u32> array_mode;
+                BitField<16, 1, u32> volume;
+            };
             u32 layer_stride;
             u32 base_layer;
             INSERT_PADDING_WORDS(7);
@@ -640,8 +643,10 @@ public:
                 u32 d3d_cull_mode;
 
                 ComparisonOp depth_test_func;
+                float alpha_test_ref;
+                ComparisonOp alpha_test_func;
 
-                INSERT_PADDING_WORDS(0xB);
+                INSERT_PADDING_WORDS(0x9);
 
                 struct {
                     u32 separate_alpha;
diff --git a/src/video_core/engines/maxwell_compute.cpp b/src/video_core/engines/maxwell_compute.cpp
index 59e28b22d..8b5f08351 100644
--- a/src/video_core/engines/maxwell_compute.cpp
+++ b/src/video_core/engines/maxwell_compute.cpp
@@ -6,8 +6,7 @@
 #include "core/core.h"
 #include "video_core/engines/maxwell_compute.h"
 
-namespace Tegra {
-namespace Engines {
+namespace Tegra::Engines {
 
 void MaxwellCompute::WriteReg(u32 method, u32 value) {
     ASSERT_MSG(method < Regs::NUM_REGS,
@@ -26,5 +25,4 @@ void MaxwellCompute::WriteReg(u32 method, u32 value) {
     }
 }
 
-} // namespace Engines
-} // namespace Tegra
+} // namespace Tegra::Engines
diff --git a/src/video_core/engines/maxwell_dma.cpp b/src/video_core/engines/maxwell_dma.cpp
index bf2a21bb6..b8a78cf82 100644
--- a/src/video_core/engines/maxwell_dma.cpp
+++ b/src/video_core/engines/maxwell_dma.cpp
@@ -4,12 +4,13 @@
 
 #include "core/memory.h"
 #include "video_core/engines/maxwell_dma.h"
+#include "video_core/rasterizer_interface.h"
 #include "video_core/textures/decoders.h"
 
-namespace Tegra {
-namespace Engines {
+namespace Tegra::Engines {
 
-MaxwellDMA::MaxwellDMA(MemoryManager& memory_manager) : memory_manager(memory_manager) {}
+MaxwellDMA::MaxwellDMA(VideoCore::RasterizerInterface& rasterizer, MemoryManager& memory_manager)
+    : memory_manager(memory_manager), rasterizer{rasterizer} {}
 
 void MaxwellDMA::WriteReg(u32 method, u32 value) {
     ASSERT_MSG(method < Regs::NUM_REGS,
@@ -44,40 +45,77 @@ void MaxwellDMA::HandleCopy() {
     ASSERT(regs.exec.query_mode == Regs::QueryMode::None);
     ASSERT(regs.exec.query_intr == Regs::QueryIntr::None);
     ASSERT(regs.exec.copy_mode == Regs::CopyMode::Unk2);
-    ASSERT(regs.src_params.pos_x == 0);
-    ASSERT(regs.src_params.pos_y == 0);
     ASSERT(regs.dst_params.pos_x == 0);
     ASSERT(regs.dst_params.pos_y == 0);
 
-    if (regs.exec.is_dst_linear == regs.exec.is_src_linear) {
-        std::size_t copy_size = regs.x_count;
+    if (!regs.exec.is_dst_linear && !regs.exec.is_src_linear) {
+        // If both the source and the destination are in block layout, assert.
+        UNREACHABLE_MSG("Tiled->Tiled DMA transfers are not yet implemented");
+        return;
+    }
 
+    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 buffer of size (x_count, y_count).
-        if (regs.exec.enable_2d) {
-            copy_size = copy_size * regs.y_count;
+        // buffer of length `x_count`, otherwise we copy a 2D image of dimensions (x_count,
+        // y_count).
+        if (!regs.exec.enable_2d) {
+            Memory::CopyBlock(dest_cpu, source_cpu, regs.x_count);
+            return;
         }
 
-        Memory::CopyBlock(dest_cpu, source_cpu, copy_size);
+        // If both the source and the destination are in linear layout, perform a line-by-line
+        // copy. We're going to take a subrect of size (x_count, y_count) from the source
+        // rectangle. There is no need to manually flush/invalidate the regions because
+        // CopyBlock does that for us.
+        for (u32 line = 0; line < regs.y_count; ++line) {
+            const VAddr source_line = source_cpu + line * regs.src_pitch;
+            const VAddr dest_line = dest_cpu + line * regs.dst_pitch;
+            Memory::CopyBlock(dest_line, source_line, regs.x_count);
+        }
         return;
     }
 
     ASSERT(regs.exec.enable_2d == 1);
-    u8* src_buffer = Memory::GetPointer(source_cpu);
-    u8* dst_buffer = Memory::GetPointer(dest_cpu);
+
+    const std::size_t copy_size = regs.x_count * regs.y_count;
+
+    const auto FlushAndInvalidate = [&](u32 src_size, u64 dst_size) {
+        // TODO(Subv): For now, manually flush the regions until we implement GPU-accelerated
+        // copying.
+        rasterizer.FlushRegion(source_cpu, src_size);
+
+        // 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
+        // might contain a dirty surface that will have to be written back to memory.
+        rasterizer.InvalidateRegion(dest_cpu, dst_size);
+    };
 
     if (regs.exec.is_dst_linear && !regs.exec.is_src_linear) {
+        ASSERT(regs.src_params.size_z == 1);
         // If the input is tiled and the output is linear, deswizzle the input and copy it over.
-        Texture::CopySwizzledData(regs.src_params.size_x, regs.src_params.size_y,
-                                  regs.src_params.size_z, 1, 1, src_buffer, dst_buffer, true,
-                                  regs.src_params.BlockHeight(), regs.src_params.BlockDepth());
+
+        const u32 src_bytes_per_pixel = regs.src_pitch / regs.src_params.size_x;
+
+        FlushAndInvalidate(regs.src_pitch * regs.src_params.size_y,
+                           copy_size * src_bytes_per_pixel);
+
+        Texture::UnswizzleSubrect(regs.x_count, regs.y_count, regs.dst_pitch,
+                                  regs.src_params.size_x, src_bytes_per_pixel, source_cpu, dest_cpu,
+                                  regs.src_params.BlockHeight(), regs.src_params.pos_x,
+                                  regs.src_params.pos_y);
     } else {
+        ASSERT(regs.dst_params.size_z == 1);
+        ASSERT(regs.src_pitch == regs.x_count);
+
+        const u32 src_bpp = regs.src_pitch / regs.x_count;
+
+        FlushAndInvalidate(regs.src_pitch * regs.y_count,
+                           regs.dst_params.size_x * regs.dst_params.size_y * src_bpp);
+
         // If the input is linear and the output is tiled, swizzle the input and copy it over.
-        Texture::CopySwizzledData(regs.dst_params.size_x, regs.dst_params.size_y,
-                                  regs.dst_params.size_z, 1, 1, dst_buffer, src_buffer, false,
-                                  regs.dst_params.BlockHeight(), regs.dst_params.BlockDepth());
+        Texture::SwizzleSubrect(regs.x_count, regs.y_count, regs.src_pitch, regs.dst_params.size_x,
+                                src_bpp, dest_cpu, source_cpu, regs.dst_params.BlockHeight());
     }
 }
 
-} // namespace Engines
-} // namespace Tegra
+} // namespace Tegra::Engines
diff --git a/src/video_core/engines/maxwell_dma.h b/src/video_core/engines/maxwell_dma.h
index df19e02e2..5f3704f05 100644
--- a/src/video_core/engines/maxwell_dma.h
+++ b/src/video_core/engines/maxwell_dma.h
@@ -12,11 +12,15 @@
 #include "video_core/gpu.h"
 #include "video_core/memory_manager.h"
 
+namespace VideoCore {
+class RasterizerInterface;
+}
+
 namespace Tegra::Engines {
 
 class MaxwellDMA final {
 public:
-    explicit MaxwellDMA(MemoryManager& memory_manager);
+    explicit MaxwellDMA(VideoCore::RasterizerInterface& rasterizer, MemoryManager& memory_manager);
     ~MaxwellDMA() = default;
 
     /// Write the value to the register identified by method.
@@ -133,6 +137,8 @@ public:
     MemoryManager& memory_manager;
 
 private:
+    VideoCore::RasterizerInterface& rasterizer;
+
     /// Performs the copy from the source buffer to the destination buffer as configured in the
     /// registers.
     void HandleCopy();
diff --git a/src/video_core/engines/shader_bytecode.h b/src/video_core/engines/shader_bytecode.h
index f356f9a03..6cd08d28b 100644
--- a/src/video_core/engines/shader_bytecode.h
+++ b/src/video_core/engines/shader_bytecode.h
@@ -214,7 +214,7 @@ enum class IMinMaxExchange : u64 {
     XHi = 3,
 };
 
-enum class VmadType : u64 {
+enum class VideoType : u64 {
     Size16_Low = 0,
     Size16_High = 1,
     Size32 = 2,
@@ -335,6 +335,26 @@ enum class IsberdMode : u64 {
 
 enum class IsberdShift : u64 { None = 0, U16 = 1, B32 = 2 };
 
+enum class HalfType : u64 {
+    H0_H1 = 0,
+    F32 = 1,
+    H0_H0 = 2,
+    H1_H1 = 3,
+};
+
+enum class HalfMerge : u64 {
+    H0_H1 = 0,
+    F32 = 1,
+    Mrg_H0 = 2,
+    Mrg_H1 = 3,
+};
+
+enum class HalfPrecision : u64 {
+    None = 0,
+    FTZ = 1,
+    FMZ = 2,
+};
+
 enum class IpaInterpMode : u64 {
     Linear = 0,
     Perspective = 1,
@@ -544,6 +564,10 @@ union Instruction {
     } fmul;
 
     union {
+        BitField<55, 1, u64> saturate;
+    } fmul32;
+
+    union {
         BitField<48, 1, u64> is_signed;
     } shift;
 
@@ -554,6 +578,70 @@ union Instruction {
     } alu_integer;
 
     union {
+        BitField<39, 1, u64> ftz;
+        BitField<32, 1, u64> saturate;
+        BitField<49, 2, HalfMerge> merge;
+
+        BitField<43, 1, u64> negate_a;
+        BitField<44, 1, u64> abs_a;
+        BitField<47, 2, HalfType> type_a;
+
+        BitField<31, 1, u64> negate_b;
+        BitField<30, 1, u64> abs_b;
+        BitField<47, 2, HalfType> type_b;
+
+        BitField<35, 2, HalfType> type_c;
+    } alu_half;
+
+    union {
+        BitField<39, 2, HalfPrecision> precision;
+        BitField<39, 1, u64> ftz;
+        BitField<52, 1, u64> saturate;
+        BitField<49, 2, HalfMerge> merge;
+
+        BitField<43, 1, u64> negate_a;
+        BitField<44, 1, u64> abs_a;
+        BitField<47, 2, HalfType> type_a;
+    } alu_half_imm;
+
+    union {
+        BitField<29, 1, u64> first_negate;
+        BitField<20, 9, u64> first;
+
+        BitField<56, 1, u64> second_negate;
+        BitField<30, 9, u64> second;
+
+        u32 PackImmediates() const {
+            // Immediates are half floats shifted.
+            constexpr u32 imm_shift = 6;
+            return static_cast<u32>((first << imm_shift) | (second << (16 + imm_shift)));
+        }
+    } half_imm;
+
+    union {
+        union {
+            BitField<37, 2, HalfPrecision> precision;
+            BitField<32, 1, u64> saturate;
+
+            BitField<30, 1, u64> negate_c;
+            BitField<35, 2, HalfType> type_c;
+        } rr;
+
+        BitField<57, 2, HalfPrecision> precision;
+        BitField<52, 1, u64> saturate;
+
+        BitField<49, 2, HalfMerge> merge;
+
+        BitField<47, 2, HalfType> type_a;
+
+        BitField<56, 1, u64> negate_b;
+        BitField<28, 2, HalfType> type_b;
+
+        BitField<51, 1, u64> negate_c;
+        BitField<53, 2, HalfType> type_reg39;
+    } hfma2;
+
+    union {
         BitField<40, 1, u64> invert;
     } popc;
 
@@ -669,7 +757,6 @@ union Instruction {
         BitField<45, 2, PredOperation> op;
         BitField<47, 1, u64> ftz;
         BitField<48, 4, PredCondition> cond;
-        BitField<56, 1, u64> neg_b;
     } fsetp;
 
     union {
@@ -696,6 +783,14 @@ union Instruction {
     } psetp;
 
     union {
+        BitField<43, 4, PredCondition> cond;
+        BitField<45, 2, PredOperation> op;
+        BitField<3, 3, u64> pred3;
+        BitField<0, 3, u64> pred0;
+        BitField<39, 3, u64> pred39;
+    } vsetp;
+
+    union {
         BitField<12, 3, u64> pred12;
         BitField<15, 1, u64> neg_pred12;
         BitField<24, 2, PredOperation> cond;
@@ -717,6 +812,23 @@ union Instruction {
     } csetp;
 
     union {
+        BitField<35, 4, PredCondition> cond;
+        BitField<49, 1, u64> h_and;
+        BitField<6, 1, u64> ftz;
+        BitField<45, 2, PredOperation> op;
+        BitField<3, 3, u64> pred3;
+        BitField<0, 3, u64> pred0;
+        BitField<43, 1, u64> negate_a;
+        BitField<44, 1, u64> abs_a;
+        BitField<47, 2, HalfType> type_a;
+        BitField<31, 1, u64> negate_b;
+        BitField<30, 1, u64> abs_b;
+        BitField<28, 2, HalfType> type_b;
+        BitField<42, 1, u64> neg_pred;
+        BitField<39, 3, u64> pred39;
+    } hsetp2;
+
+    union {
         BitField<39, 3, u64> pred39;
         BitField<42, 1, u64> neg_pred;
         BitField<43, 1, u64> neg_a;
@@ -727,10 +839,24 @@ union Instruction {
         BitField<53, 1, u64> neg_b;
         BitField<54, 1, u64> abs_a;
         BitField<55, 1, u64> ftz;
-        BitField<56, 1, u64> neg_imm;
     } fset;
 
     union {
+        BitField<49, 1, u64> bf;
+        BitField<35, 3, PredCondition> cond;
+        BitField<50, 1, u64> ftz;
+        BitField<45, 2, PredOperation> op;
+        BitField<43, 1, u64> negate_a;
+        BitField<44, 1, u64> abs_a;
+        BitField<47, 2, HalfType> type_a;
+        BitField<31, 1, u64> negate_b;
+        BitField<30, 1, u64> abs_b;
+        BitField<28, 2, HalfType> type_b;
+        BitField<42, 1, u64> neg_pred;
+        BitField<39, 3, u64> pred39;
+    } hset2;
+
+    union {
         BitField<39, 3, u64> pred39;
         BitField<42, 1, u64> neg_pred;
         BitField<44, 1, u64> bf;
@@ -1036,15 +1162,17 @@ union Instruction {
     union {
         BitField<48, 1, u64> signed_a;
         BitField<38, 1, u64> is_byte_chunk_a;
-        BitField<36, 2, VmadType> type_a;
+        BitField<36, 2, VideoType> type_a;
         BitField<36, 2, u64> byte_height_a;
 
         BitField<49, 1, u64> signed_b;
         BitField<50, 1, u64> use_register_b;
         BitField<30, 1, u64> is_byte_chunk_b;
-        BitField<28, 2, VmadType> type_b;
+        BitField<28, 2, VideoType> type_b;
         BitField<28, 2, u64> byte_height_b;
+    } video;
 
+    union {
         BitField<51, 2, VmadShr> shr;
         BitField<55, 1, u64> saturate; // Saturates the result (a * b + c)
         BitField<47, 1, u64> cc;
@@ -1095,11 +1223,13 @@ public:
         KIL,
         SSY,
         SYNC,
+        BRK,
         DEPBAR,
         BFE_C,
         BFE_R,
         BFE_IMM,
         BRA,
+        PBK,
         LD_A,
         LD_C,
         ST_A,
@@ -1118,6 +1248,7 @@ public:
         OUT_R, // Emit vertex/primitive
         ISBERD,
         VMAD,
+        VSETP,
         FFMA_IMM, // Fused Multiply and Add
         FFMA_CR,
         FFMA_RC,
@@ -1145,6 +1276,18 @@ public:
         LEA_RZ,
         LEA_IMM,
         LEA_HI,
+        HADD2_C,
+        HADD2_R,
+        HADD2_IMM,
+        HMUL2_C,
+        HMUL2_R,
+        HMUL2_IMM,
+        HFMA2_CR,
+        HFMA2_RC,
+        HFMA2_RR,
+        HFMA2_IMM_R,
+        HSETP2_R,
+        HSET2_R,
         POPC_C,
         POPC_R,
         POPC_IMM,
@@ -1218,9 +1361,12 @@ public:
         ArithmeticImmediate,
         ArithmeticInteger,
         ArithmeticIntegerImmediate,
+        ArithmeticHalf,
+        ArithmeticHalfImmediate,
         Bfe,
         Shift,
         Ffma,
+        Hfma2,
         Flow,
         Synch,
         Memory,
@@ -1228,6 +1374,8 @@ public:
         FloatSetPredicate,
         IntegerSet,
         IntegerSetPredicate,
+        HalfSet,
+        HalfSetPredicate,
         PredicateSetPredicate,
         PredicateSetRegister,
         Conversion,
@@ -1239,7 +1387,7 @@ public:
     /// conditionally executed).
     static bool IsPredicatedInstruction(Id opcode) {
         // TODO(Subv): Add the rest of unpredicated instructions.
-        return opcode != Id::SSY;
+        return opcode != Id::SSY && opcode != Id::PBK;
     }
 
     class Matcher {
@@ -1335,9 +1483,11 @@ private:
 #define INST(bitstring, op, type, name) Detail::GetMatcher(bitstring, op, type, name)
             INST("111000110011----", Id::KIL, Type::Flow, "KIL"),
             INST("111000101001----", Id::SSY, Type::Flow, "SSY"),
+            INST("111000101010----", Id::PBK, Type::Flow, "PBK"),
             INST("111000100100----", Id::BRA, Type::Flow, "BRA"),
+            INST("1111000011111---", Id::SYNC, Type::Flow, "SYNC"),
+            INST("111000110100---", Id::BRK, Type::Flow, "BRK"),
             INST("1111000011110---", Id::DEPBAR, Type::Synch, "DEPBAR"),
-            INST("1111000011111---", Id::SYNC, Type::Synch, "SYNC"),
             INST("1110111111011---", Id::LD_A, Type::Memory, "LD_A"),
             INST("1110111110010---", Id::LD_C, Type::Memory, "LD_C"),
             INST("1110111111110---", Id::ST_A, Type::Memory, "ST_A"),
@@ -1356,6 +1506,7 @@ private:
             INST("1111101111100---", Id::OUT_R, Type::Trivial, "OUT_R"),
             INST("1110111111010---", Id::ISBERD, Type::Trivial, "ISBERD"),
             INST("01011111--------", Id::VMAD, Type::Trivial, "VMAD"),
+            INST("0101000011110---", Id::VSETP, Type::Trivial, "VSETP"),
             INST("0011001-1-------", Id::FFMA_IMM, Type::Ffma, "FFMA_IMM"),
             INST("010010011-------", Id::FFMA_CR, Type::Ffma, "FFMA_CR"),
             INST("010100011-------", Id::FFMA_RC, Type::Ffma, "FFMA_RC"),
@@ -1389,6 +1540,18 @@ private:
             INST("001101101101----", Id::LEA_IMM, Type::ArithmeticInteger, "LEA_IMM"),
             INST("010010111101----", Id::LEA_RZ, Type::ArithmeticInteger, "LEA_RZ"),
             INST("00011000--------", Id::LEA_HI, Type::ArithmeticInteger, "LEA_HI"),
+            INST("0111101-1-------", Id::HADD2_C, Type::ArithmeticHalf, "HADD2_C"),
+            INST("0101110100010---", Id::HADD2_R, Type::ArithmeticHalf, "HADD2_R"),
+            INST("0111101-0-------", Id::HADD2_IMM, Type::ArithmeticHalfImmediate, "HADD2_IMM"),
+            INST("0111100-1-------", Id::HMUL2_C, Type::ArithmeticHalf, "HMUL2_C"),
+            INST("0101110100001---", Id::HMUL2_R, Type::ArithmeticHalf, "HMUL2_R"),
+            INST("0111100-0-------", Id::HMUL2_IMM, Type::ArithmeticHalfImmediate, "HMUL2_IMM"),
+            INST("01110---1-------", Id::HFMA2_CR, Type::Hfma2, "HFMA2_CR"),
+            INST("01100---1-------", Id::HFMA2_RC, Type::Hfma2, "HFMA2_RC"),
+            INST("0101110100000---", Id::HFMA2_RR, Type::Hfma2, "HFMA2_RR"),
+            INST("01110---0-------", Id::HFMA2_IMM_R, Type::Hfma2, "HFMA2_R_IMM"),
+            INST("0101110100100---", Id::HSETP2_R, Type::HalfSetPredicate, "HSETP_R"),
+            INST("0101110100011---", Id::HSET2_R, Type::HalfSet, "HSET2_R"),
             INST("0101000010000---", Id::MUFU, Type::Arithmetic, "MUFU"),
             INST("0100110010010---", Id::RRO_C, Type::Arithmetic, "RRO_C"),
             INST("0101110010010---", Id::RRO_R, Type::Arithmetic, "RRO_R"),
@@ -1463,4 +1626,4 @@ private:
     }
 };
 
-} // namespace Tegra::Shader
+} // namespace Tegra::Shader
\ No newline at end of file
diff --git a/src/video_core/gpu.cpp b/src/video_core/gpu.cpp
index 9ba7e3533..83c7e5b0b 100644
--- a/src/video_core/gpu.cpp
+++ b/src/video_core/gpu.cpp
@@ -27,8 +27,8 @@ GPU::GPU(VideoCore::RasterizerInterface& rasterizer) {
     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>();
-    maxwell_dma = std::make_unique<Engines::MaxwellDMA>(*memory_manager);
-    kepler_memory = std::make_unique<Engines::KeplerMemory>(*memory_manager);
+    maxwell_dma = std::make_unique<Engines::MaxwellDMA>(rasterizer, *memory_manager);
+    kepler_memory = std::make_unique<Engines::KeplerMemory>(rasterizer, *memory_manager);
 }
 
 GPU::~GPU() = default;
diff --git a/src/video_core/memory_manager.cpp b/src/video_core/memory_manager.cpp
index ca923d17d..022d4ab74 100644
--- a/src/video_core/memory_manager.cpp
+++ b/src/video_core/memory_manager.cpp
@@ -87,6 +87,16 @@ GPUVAddr MemoryManager::UnmapBuffer(GPUVAddr gpu_addr, u64 size) {
     return gpu_addr;
 }
 
+GPUVAddr MemoryManager::GetRegionEnd(GPUVAddr region_start) const {
+    for (const auto& region : mapped_regions) {
+        const GPUVAddr region_end{region.gpu_addr + region.size};
+        if (region_start >= region.gpu_addr && region_start < region_end) {
+            return region_end;
+        }
+    }
+    return {};
+}
+
 boost::optional<GPUVAddr> MemoryManager::FindFreeBlock(u64 size, u64 align) {
     GPUVAddr gpu_addr = 0;
     u64 free_space = 0;
diff --git a/src/video_core/memory_manager.h b/src/video_core/memory_manager.h
index 86765e72a..caf80093f 100644
--- a/src/video_core/memory_manager.h
+++ b/src/video_core/memory_manager.h
@@ -26,6 +26,7 @@ public:
     GPUVAddr MapBufferEx(VAddr cpu_addr, u64 size);
     GPUVAddr MapBufferEx(VAddr cpu_addr, GPUVAddr gpu_addr, u64 size);
     GPUVAddr UnmapBuffer(GPUVAddr gpu_addr, u64 size);
+    GPUVAddr GetRegionEnd(GPUVAddr region_start) const;
     boost::optional<VAddr> GpuToCpuAddress(GPUVAddr gpu_addr);
     std::vector<GPUVAddr> CpuToGpuAddress(VAddr cpu_addr) const;
 
diff --git a/src/video_core/rasterizer_cache.h b/src/video_core/rasterizer_cache.h
index 083b283b0..0a3b3951e 100644
--- a/src/video_core/rasterizer_cache.h
+++ b/src/video_core/rasterizer_cache.h
@@ -11,32 +11,77 @@
 
 #include "common/common_types.h"
 #include "core/core.h"
+#include "core/settings.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_base.h"
 
+class RasterizerCacheObject {
+public:
+    /// Gets the address of the shader in guest memory, required for cache management
+    virtual VAddr GetAddr() const = 0;
+
+    /// Gets the size of the shader in guest memory, required for cache management
+    virtual std::size_t GetSizeInBytes() const = 0;
+
+    /// Wriets any cached resources back to memory
+    virtual void Flush() = 0;
+
+    /// Sets whether the cached object should be considered registered
+    void SetIsRegistered(bool registered) {
+        is_registered = registered;
+    }
+
+    /// Returns true if the cached object is registered
+    bool IsRegistered() const {
+        return is_registered;
+    }
+
+    /// Returns true if the cached object is dirty
+    bool IsDirty() const {
+        return is_dirty;
+    }
+
+    /// Returns ticks from when this cached object was last modified
+    u64 GetLastModifiedTicks() const {
+        return last_modified_ticks;
+    }
+
+    /// Marks an object as recently modified, used to specify whether it is clean or dirty
+    template <class T>
+    void MarkAsModified(bool dirty, T& cache) {
+        is_dirty = dirty;
+        last_modified_ticks = cache.GetModifiedTicks();
+    }
+
+private:
+    bool is_registered{};      ///< Whether the object is currently registered with the cache
+    bool is_dirty{};           ///< Whether the object is dirty (out of sync with guest memory)
+    u64 last_modified_ticks{}; ///< When the object was last modified, used for in-order flushing
+};
+
 template <class T>
 class RasterizerCache : NonCopyable {
+    friend class RasterizerCacheObject;
+
 public:
+    /// Write any cached resources overlapping the specified region back to memory
+    void FlushRegion(Tegra::GPUVAddr addr, size_t size) {
+        const auto& objects{GetSortedObjectsFromRegion(addr, size)};
+        for (auto& object : objects) {
+            FlushObject(object);
+        }
+    }
+
     /// Mark the specified region as being invalidated
     void InvalidateRegion(VAddr addr, u64 size) {
-        if (size == 0)
-            return;
-
-        const ObjectInterval interval{addr, addr + size};
-        for (auto& pair : boost::make_iterator_range(object_cache.equal_range(interval))) {
-            for (auto& cached_object : pair.second) {
-                if (!cached_object)
-                    continue;
-
-                remove_objects.emplace(cached_object);
+        const auto& objects{GetSortedObjectsFromRegion(addr, size)};
+        for (auto& object : objects) {
+            if (!object->IsRegistered()) {
+                // Skip duplicates
+                continue;
             }
+            Unregister(object);
         }
-
-        for (auto& remove_object : remove_objects) {
-            Unregister(remove_object);
-        }
-
-        remove_objects.clear();
     }
 
     /// Invalidates everything in the cache
@@ -62,6 +107,7 @@ protected:
 
     /// Register an object into the cache
     void Register(const T& object) {
+        object->SetIsRegistered(true);
         object_cache.add({GetInterval(object), ObjectSet{object}});
         auto& rasterizer = Core::System::GetInstance().Renderer().Rasterizer();
         rasterizer.UpdatePagesCachedCount(object->GetAddr(), object->GetSizeInBytes(), 1);
@@ -69,12 +115,57 @@ protected:
 
     /// Unregisters an object from the cache
     void Unregister(const T& object) {
+        object->SetIsRegistered(false);
         auto& rasterizer = Core::System::GetInstance().Renderer().Rasterizer();
         rasterizer.UpdatePagesCachedCount(object->GetAddr(), object->GetSizeInBytes(), -1);
+
+        // Only flush if use_accurate_gpu_emulation is enabled, as it incurs a performance hit
+        if (Settings::values.use_accurate_gpu_emulation) {
+            FlushObject(object);
+        }
+
         object_cache.subtract({GetInterval(object), ObjectSet{object}});
     }
 
+    /// Returns a ticks counter used for tracking when cached objects were last modified
+    u64 GetModifiedTicks() {
+        return ++modified_ticks;
+    }
+
 private:
+    /// Returns a list of cached objects from the specified memory region, ordered by access time
+    std::vector<T> GetSortedObjectsFromRegion(VAddr addr, u64 size) {
+        if (size == 0) {
+            return {};
+        }
+
+        std::vector<T> objects;
+        const ObjectInterval interval{addr, addr + size};
+        for (auto& pair : boost::make_iterator_range(object_cache.equal_range(interval))) {
+            for (auto& cached_object : pair.second) {
+                if (!cached_object) {
+                    continue;
+                }
+                objects.push_back(cached_object);
+            }
+        }
+
+        std::sort(objects.begin(), objects.end(), [](const T& a, const T& b) -> bool {
+            return a->GetLastModifiedTicks() < b->GetLastModifiedTicks();
+        });
+
+        return objects;
+    }
+
+    /// Flushes the specified object, updating appropriate cache state as needed
+    void FlushObject(const T& object) {
+        if (!object->IsDirty()) {
+            return;
+        }
+        object->Flush();
+        object->MarkAsModified(false, *this);
+    }
+
     using ObjectSet = std::set<T>;
     using ObjectCache = boost::icl::interval_map<VAddr, ObjectSet>;
     using ObjectInterval = typename ObjectCache::interval_type;
@@ -84,6 +175,6 @@ private:
                                           object->GetAddr() + object->GetSizeInBytes());
     }
 
-    ObjectCache object_cache;
-    ObjectSet remove_objects;
+    ObjectCache object_cache; ///< Cache of objects
+    u64 modified_ticks{};     ///< Counter of cache state ticks, used for in-order flushing
 };
diff --git a/src/video_core/renderer_opengl/gl_buffer_cache.h b/src/video_core/renderer_opengl/gl_buffer_cache.h
index 965976334..be29dc8be 100644
--- a/src/video_core/renderer_opengl/gl_buffer_cache.h
+++ b/src/video_core/renderer_opengl/gl_buffer_cache.h
@@ -15,15 +15,18 @@
 
 namespace OpenGL {
 
-struct CachedBufferEntry final {
-    VAddr GetAddr() const {
+struct CachedBufferEntry final : public RasterizerCacheObject {
+    VAddr GetAddr() const override {
         return addr;
     }
 
-    std::size_t GetSizeInBytes() const {
+    std::size_t GetSizeInBytes() const override {
         return size;
     }
 
+    // We do not have to flush this cache as things in it are never modified by us.
+    void Flush() override {}
+
     VAddr addr;
     std::size_t size;
     GLintptr offset;
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.cpp b/src/video_core/renderer_opengl/gl_rasterizer.cpp
index 8d5f277e2..be51c5215 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer.cpp
@@ -424,6 +424,13 @@ void RasterizerOpenGL::ConfigureFramebuffers(bool using_color_fb, bool using_dep
             // Used when just a single color attachment is enabled, e.g. for clearing a color buffer
             Surface color_surface =
                 res_cache.GetColorBufferSurface(*single_color_target, preserve_contents);
+
+            if (color_surface) {
+                // Assume that a surface will be written to if it is used as a framebuffer, even if
+                // the shader doesn't actually write to it.
+                color_surface->MarkAsModified(true, res_cache);
+            }
+
             glFramebufferTexture2D(
                 GL_DRAW_FRAMEBUFFER,
                 GL_COLOR_ATTACHMENT0 + static_cast<GLenum>(*single_color_target), GL_TEXTURE_2D,
@@ -434,6 +441,13 @@ void RasterizerOpenGL::ConfigureFramebuffers(bool using_color_fb, bool using_dep
             std::array<GLenum, Maxwell::NumRenderTargets> buffers;
             for (std::size_t index = 0; index < Maxwell::NumRenderTargets; ++index) {
                 Surface color_surface = res_cache.GetColorBufferSurface(index, preserve_contents);
+
+                if (color_surface) {
+                    // Assume that a surface will be written to if it is used as a framebuffer, even
+                    // if the shader doesn't actually write to it.
+                    color_surface->MarkAsModified(true, res_cache);
+                }
+
                 buffers[index] = GL_COLOR_ATTACHMENT0 + regs.rt_control.GetMap(index);
                 glFramebufferTexture2D(
                     GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + static_cast<GLenum>(index),
@@ -453,6 +467,10 @@ void RasterizerOpenGL::ConfigureFramebuffers(bool using_color_fb, bool using_dep
     }
 
     if (depth_surface) {
+        // Assume that a surface will be written to if it is used as a framebuffer, even if
+        // the shader doesn't actually write to it.
+        depth_surface->MarkAsModified(true, res_cache);
+
         if (regs.stencil_enable) {
             // Attach both depth and stencil
             glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
@@ -552,10 +570,11 @@ void RasterizerOpenGL::DrawArrays() {
     SyncBlendState();
     SyncLogicOpState();
     SyncCullMode();
-    SyncAlphaTest();
     SyncScissorTest();
+    // Alpha Testing is synced on shaders.
     SyncTransformFeedback();
     SyncPointState();
+    CheckAlphaTests();
 
     // TODO(bunnei): Sync framebuffer_scale uniform here
     // TODO(bunnei): Sync scissorbox uniform(s) here
@@ -617,7 +636,14 @@ void RasterizerOpenGL::DrawArrays() {
 
 void RasterizerOpenGL::FlushAll() {}
 
-void RasterizerOpenGL::FlushRegion(VAddr addr, u64 size) {}
+void RasterizerOpenGL::FlushRegion(VAddr addr, u64 size) {
+    MICROPROFILE_SCOPE(OpenGL_CacheManagement);
+
+    if (Settings::values.use_accurate_gpu_emulation) {
+        // Only flush if use_accurate_gpu_emulation is enabled, as it incurs a performance hit
+        res_cache.FlushRegion(addr, size);
+    }
+}
 
 void RasterizerOpenGL::InvalidateRegion(VAddr addr, u64 size) {
     MICROPROFILE_SCOPE(OpenGL_CacheManagement);
@@ -627,12 +653,19 @@ void RasterizerOpenGL::InvalidateRegion(VAddr addr, u64 size) {
 }
 
 void RasterizerOpenGL::FlushAndInvalidateRegion(VAddr addr, u64 size) {
+    FlushRegion(addr, size);
     InvalidateRegion(addr, size);
 }
 
 bool RasterizerOpenGL::AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
                                              const Tegra::Engines::Fermi2D::Regs::Surface& dst) {
     MICROPROFILE_SCOPE(OpenGL_Blits);
+
+    if (Settings::values.use_accurate_gpu_emulation) {
+        // Skip the accelerated copy and perform a slow but more accurate copy
+        return false;
+    }
+
     res_cache.FermiCopySurface(src, dst);
     return true;
 }
@@ -975,17 +1008,6 @@ void RasterizerOpenGL::SyncLogicOpState() {
     state.logic_op.operation = MaxwellToGL::LogicOp(regs.logic_op.operation);
 }
 
-void RasterizerOpenGL::SyncAlphaTest() {
-    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
-
-    // TODO(Rodrigo): Alpha testing is a legacy OpenGL feature, but it can be
-    // implemented with a test+discard in fragment shaders.
-    if (regs.alpha_test_enabled != 0) {
-        LOG_CRITICAL(Render_OpenGL, "Alpha testing is not implemented");
-        UNREACHABLE();
-    }
-}
-
 void RasterizerOpenGL::SyncScissorTest() {
     const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
 
@@ -1020,4 +1042,15 @@ void RasterizerOpenGL::SyncPointState() {
     state.point.size = regs.point_size == 0 ? 1 : regs.point_size;
 }
 
+void RasterizerOpenGL::CheckAlphaTests() {
+    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
+
+    if (regs.alpha_test_enabled != 0 && regs.rt_control.count > 1) {
+        LOG_CRITICAL(
+            Render_OpenGL,
+            "Alpha Testing is enabled with Multiple Render Targets, this behavior is undefined.");
+        UNREACHABLE();
+    }
+}
+
 } // namespace OpenGL
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.h b/src/video_core/renderer_opengl/gl_rasterizer.h
index b1f7ccc7e..0e90a31f5 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.h
+++ b/src/video_core/renderer_opengl/gl_rasterizer.h
@@ -162,9 +162,6 @@ private:
     /// Syncs the LogicOp state to match the guest state
     void SyncLogicOpState();
 
-    /// Syncs the alpha test state to match the guest state
-    void SyncAlphaTest();
-
     /// Syncs the scissor test state to match the guest state
     void SyncScissorTest();
 
@@ -174,6 +171,9 @@ private:
     /// Syncs the point state to match the guest state
     void SyncPointState();
 
+    /// Check asserts for alpha testing.
+    void CheckAlphaTests();
+
     bool has_ARB_direct_state_access = false;
     bool has_ARB_multi_bind = false;
     bool has_ARB_separate_shader_objects = false;
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
index 801d45144..9c8925383 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
@@ -34,16 +34,53 @@ struct FormatTuple {
     bool compressed;
 };
 
-static VAddr TryGetCpuAddr(Tegra::GPUVAddr gpu_addr) {
-    auto& gpu{Core::System::GetInstance().GPU()};
-    const auto cpu_addr{gpu.MemoryManager().GpuToCpuAddress(gpu_addr)};
-    return cpu_addr ? *cpu_addr : 0;
+static bool IsPixelFormatASTC(PixelFormat format) {
+    switch (format) {
+    case PixelFormat::ASTC_2D_4X4:
+    case PixelFormat::ASTC_2D_5X4:
+    case PixelFormat::ASTC_2D_8X8:
+    case PixelFormat::ASTC_2D_8X5:
+        return true;
+    default:
+        return false;
+    }
+}
+
+static std::pair<u32, u32> GetASTCBlockSize(PixelFormat format) {
+    switch (format) {
+    case PixelFormat::ASTC_2D_4X4:
+        return {4, 4};
+    case PixelFormat::ASTC_2D_5X4:
+        return {5, 4};
+    case PixelFormat::ASTC_2D_8X8:
+        return {8, 8};
+    case PixelFormat::ASTC_2D_8X5:
+        return {8, 5};
+    default:
+        LOG_CRITICAL(HW_GPU, "Unhandled format: {}", static_cast<u32>(format));
+        UNREACHABLE();
+    }
+}
+
+void SurfaceParams::InitCacheParameters(Tegra::GPUVAddr gpu_addr_) {
+    auto& memory_manager{Core::System::GetInstance().GPU().MemoryManager()};
+    const auto cpu_addr{memory_manager.GpuToCpuAddress(gpu_addr_)};
+
+    addr = cpu_addr ? *cpu_addr : 0;
+    gpu_addr = gpu_addr_;
+    size_in_bytes = SizeInBytesRaw();
+
+    if (IsPixelFormatASTC(pixel_format)) {
+        // ASTC is uncompressed in software, in emulated as RGBA8
+        size_in_bytes_gl = width * height * depth * 4;
+    } else {
+        size_in_bytes_gl = SizeInBytesGL();
+    }
 }
 
 /*static*/ SurfaceParams SurfaceParams::CreateForTexture(
     const Tegra::Texture::FullTextureInfo& config, const GLShader::SamplerEntry& entry) {
     SurfaceParams params{};
-    params.addr = TryGetCpuAddr(config.tic.Address());
     params.is_tiled = config.tic.IsTiled();
     params.block_width = params.is_tiled ? config.tic.BlockWidth() : 0,
     params.block_height = params.is_tiled ? config.tic.BlockHeight() : 0,
@@ -87,18 +124,18 @@ static VAddr TryGetCpuAddr(Tegra::GPUVAddr gpu_addr) {
         break;
     }
 
-    params.size_in_bytes_total = params.SizeInBytesTotal();
-    params.size_in_bytes_2d = params.SizeInBytes2D();
     params.max_mip_level = config.tic.max_mip_level + 1;
     params.rt = {};
 
+    params.InitCacheParameters(config.tic.Address());
+
     return params;
 }
 
 /*static*/ SurfaceParams SurfaceParams::CreateForFramebuffer(std::size_t index) {
     const auto& config{Core::System::GetInstance().GPU().Maxwell3D().regs.rt[index]};
     SurfaceParams params{};
-    params.addr = TryGetCpuAddr(config.Address());
+
     params.is_tiled =
         config.memory_layout.type == Tegra::Engines::Maxwell3D::Regs::InvMemoryLayout::BlockLinear;
     params.block_width = 1 << config.memory_layout.block_width;
@@ -112,16 +149,17 @@ static VAddr TryGetCpuAddr(Tegra::GPUVAddr gpu_addr) {
     params.unaligned_height = config.height;
     params.target = SurfaceTarget::Texture2D;
     params.depth = 1;
-    params.size_in_bytes_total = params.SizeInBytesTotal();
-    params.size_in_bytes_2d = params.SizeInBytes2D();
     params.max_mip_level = 0;
 
     // Render target specific parameters, not used for caching
     params.rt.index = static_cast<u32>(index);
     params.rt.array_mode = config.array_mode;
     params.rt.layer_stride = config.layer_stride;
+    params.rt.volume = config.volume;
     params.rt.base_layer = config.base_layer;
 
+    params.InitCacheParameters(config.Address());
+
     return params;
 }
 
@@ -130,7 +168,7 @@ static VAddr TryGetCpuAddr(Tegra::GPUVAddr gpu_addr) {
     u32 block_width, u32 block_height, u32 block_depth,
     Tegra::Engines::Maxwell3D::Regs::InvMemoryLayout type) {
     SurfaceParams params{};
-    params.addr = TryGetCpuAddr(zeta_address);
+
     params.is_tiled = type == Tegra::Engines::Maxwell3D::Regs::InvMemoryLayout::BlockLinear;
     params.block_width = 1 << std::min(block_width, 5U);
     params.block_height = 1 << std::min(block_height, 5U);
@@ -143,18 +181,18 @@ static VAddr TryGetCpuAddr(Tegra::GPUVAddr gpu_addr) {
     params.unaligned_height = zeta_height;
     params.target = SurfaceTarget::Texture2D;
     params.depth = 1;
-    params.size_in_bytes_total = params.SizeInBytesTotal();
-    params.size_in_bytes_2d = params.SizeInBytes2D();
     params.max_mip_level = 0;
     params.rt = {};
 
+    params.InitCacheParameters(zeta_address);
+
     return params;
 }
 
 /*static*/ SurfaceParams SurfaceParams::CreateForFermiCopySurface(
     const Tegra::Engines::Fermi2D::Regs::Surface& config) {
     SurfaceParams params{};
-    params.addr = TryGetCpuAddr(config.Address());
+
     params.is_tiled = !config.linear;
     params.block_width = params.is_tiled ? std::min(config.BlockWidth(), 32U) : 0,
     params.block_height = params.is_tiled ? std::min(config.BlockHeight(), 32U) : 0,
@@ -167,11 +205,11 @@ static VAddr TryGetCpuAddr(Tegra::GPUVAddr gpu_addr) {
     params.unaligned_height = config.height;
     params.target = SurfaceTarget::Texture2D;
     params.depth = 1;
-    params.size_in_bytes_total = params.SizeInBytesTotal();
-    params.size_in_bytes_2d = params.SizeInBytes2D();
     params.max_mip_level = 0;
     params.rt = {};
 
+    params.InitCacheParameters(config.Address());
+
     return params;
 }
 
@@ -276,34 +314,6 @@ static const FormatTuple& GetFormatTuple(PixelFormat pixel_format, ComponentType
     return format;
 }
 
-static bool IsPixelFormatASTC(PixelFormat format) {
-    switch (format) {
-    case PixelFormat::ASTC_2D_4X4:
-    case PixelFormat::ASTC_2D_5X4:
-    case PixelFormat::ASTC_2D_8X8:
-    case PixelFormat::ASTC_2D_8X5:
-        return true;
-    default:
-        return false;
-    }
-}
-
-static std::pair<u32, u32> GetASTCBlockSize(PixelFormat format) {
-    switch (format) {
-    case PixelFormat::ASTC_2D_4X4:
-        return {4, 4};
-    case PixelFormat::ASTC_2D_5X4:
-        return {5, 4};
-    case PixelFormat::ASTC_2D_8X8:
-        return {8, 8};
-    case PixelFormat::ASTC_2D_8X5:
-        return {8, 5};
-    default:
-        LOG_CRITICAL(HW_GPU, "Unhandled format: {}", static_cast<u32>(format));
-        UNREACHABLE();
-    }
-}
-
 MathUtil::Rectangle<u32> SurfaceParams::GetRect() const {
     u32 actual_height{unaligned_height};
     if (IsPixelFormatASTC(pixel_format)) {
@@ -333,23 +343,21 @@ static bool IsFormatBCn(PixelFormat format) {
 template <bool morton_to_gl, PixelFormat format>
 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 = SurfaceParams::GetFormatBpp(format) / CHAR_BIT;
-    constexpr u32 gl_bytes_per_pixel = CachedSurface::GetGLBytesPerPixel(format);
+    constexpr u32 bytes_per_pixel = SurfaceParams::GetBytesPerPixel(format);
+
+    // With the BCn formats (DXT and DXN), each 4x4 tile is swizzled instead of just individual
+    // pixel values.
+    const u32 tile_size{IsFormatBCn(format) ? 4U : 1U};
 
     if (morton_to_gl) {
-        // With the BCn formats (DXT and DXN), each 4x4 tile is swizzled instead of just individual
-        // pixel values.
-        const u32 tile_size{IsFormatBCn(format) ? 4U : 1U};
         const std::vector<u8> data = Tegra::Texture::UnswizzleTexture(
             addr, tile_size, bytes_per_pixel, stride, height, depth, block_height, block_depth);
         const std::size_t size_to_copy{std::min(gl_buffer_size, data.size())};
         memcpy(gl_buffer, data.data(), size_to_copy);
     } else {
-        // TODO(bunnei): Assumes the default rendering GOB size of 16 (128 lines). We should
-        // check the configuration for this and perform more generic un/swizzle
-        LOG_WARNING(Render_OpenGL, "need to use correct swizzle/GOB parameters!");
-        VideoCore::MortonCopyPixels128(stride, height, bytes_per_pixel, gl_bytes_per_pixel,
-                                       Memory::GetPointer(addr), gl_buffer, morton_to_gl);
+        Tegra::Texture::CopySwizzledData(stride / tile_size, height / tile_size, depth,
+                                         bytes_per_pixel, bytes_per_pixel, Memory::GetPointer(addr),
+                                         gl_buffer, false, block_height, block_depth);
     }
 }
 
@@ -430,17 +438,16 @@ static constexpr std::array<void (*)(u32, u32, u32, u32, u32, u8*, std::size_t,
         MortonCopy<false, PixelFormat::RGBA16UI>,
         MortonCopy<false, PixelFormat::R11FG11FB10F>,
         MortonCopy<false, PixelFormat::RGBA32UI>,
-        // TODO(Subv): Swizzling DXT1/DXT23/DXT45/DXN1/DXN2/BC7U/BC6H_UF16/BC6H_SF16/ASTC_2D_4X4
-        // formats are not supported
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
+        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>,
@@ -626,22 +633,21 @@ static void CopySurface(const Surface& src_surface, const Surface& dst_surface,
     auto source_format = GetFormatTuple(src_params.pixel_format, src_params.component_type);
     auto dest_format = GetFormatTuple(dst_params.pixel_format, dst_params.component_type);
 
-    std::size_t buffer_size =
-        std::max(src_params.size_in_bytes_total, dst_params.size_in_bytes_total);
+    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);
     if (source_format.compressed) {
         glGetCompressedTextureImage(src_surface->Texture().handle, src_attachment,
-                                    static_cast<GLsizei>(src_params.size_in_bytes_total), nullptr);
+                                    static_cast<GLsizei>(src_params.size_in_bytes), nullptr);
     } else {
         glGetTextureImage(src_surface->Texture().handle, src_attachment, source_format.format,
-                          source_format.type, static_cast<GLsizei>(src_params.size_in_bytes_total),
+                          source_format.type, static_cast<GLsizei>(src_params.size_in_bytes),
                           nullptr);
     }
     // If the new texture is bigger than the previous one, we need to fill in the rest with data
     // from the CPU.
-    if (src_params.size_in_bytes_total < dst_params.size_in_bytes_total) {
+    if (src_params.size_in_bytes < dst_params.size_in_bytes) {
         // Upload the rest of the memory.
         if (dst_params.is_tiled) {
             // TODO(Subv): We might have to de-tile the subtexture and re-tile it with the rest
@@ -651,12 +657,12 @@ static void CopySurface(const Surface& src_surface, const Surface& dst_surface,
             LOG_DEBUG(HW_GPU, "Trying to upload extra texture data from the CPU during "
                               "reinterpretation but the texture is tiled.");
         }
-        std::size_t remaining_size =
-            dst_params.size_in_bytes_total - src_params.size_in_bytes_total;
+        std::size_t remaining_size = dst_params.size_in_bytes - src_params.size_in_bytes;
         std::vector<u8> data(remaining_size);
-        Memory::ReadBlock(dst_params.addr + src_params.size_in_bytes_total, data.data(),
-                          data.size());
-        glBufferSubData(GL_PIXEL_PACK_BUFFER, src_params.size_in_bytes_total, remaining_size,
+        std::memcpy(data.data(), Memory::GetPointer(dst_params.addr + src_params.size_in_bytes),
+                    data.size());
+
+        glBufferSubData(GL_PIXEL_PACK_BUFFER, src_params.size_in_bytes, remaining_size,
                         data.data());
     }
 
@@ -702,7 +708,8 @@ static void CopySurface(const Surface& src_surface, const Surface& dst_surface,
 }
 
 CachedSurface::CachedSurface(const SurfaceParams& params)
-    : params(params), gl_target(SurfaceTargetToGL(params.target)) {
+    : params(params), gl_target(SurfaceTargetToGL(params.target)),
+      cached_size_in_bytes(params.size_in_bytes) {
     texture.Create();
     const auto& rect{params.GetRect()};
 
@@ -752,9 +759,21 @@ CachedSurface::CachedSurface(const SurfaceParams& params)
 
     VideoCore::LabelGLObject(GL_TEXTURE, texture.handle, params.addr,
                              SurfaceParams::SurfaceTargetName(params.target));
+
+    // Clamp size to mapped GPU memory region
+    // TODO(bunnei): Super Mario Odyssey maps a 0x40000 byte region and then uses it for a 0x80000
+    // R32F render buffer. We do not yet know if this is a game bug or something else, but this
+    // check is necessary to prevent flushing from overwriting unmapped memory.
+
+    auto& memory_manager{Core::System::GetInstance().GPU().MemoryManager()};
+    const u64 max_size{memory_manager.GetRegionEnd(params.gpu_addr) - params.gpu_addr};
+    if (cached_size_in_bytes > max_size) {
+        LOG_ERROR(HW_GPU, "Surface size {} exceeds region size {}", params.size_in_bytes, max_size);
+        cached_size_in_bytes = max_size;
+    }
 }
 
-static void ConvertS8Z24ToZ24S8(std::vector<u8>& data, u32 width, u32 height) {
+static void ConvertS8Z24ToZ24S8(std::vector<u8>& data, u32 width, u32 height, bool reverse) {
     union S8Z24 {
         BitField<0, 24, u32> z24;
         BitField<24, 8, u32> s8;
@@ -767,22 +786,29 @@ static void ConvertS8Z24ToZ24S8(std::vector<u8>& data, u32 width, u32 height) {
     };
     static_assert(sizeof(Z24S8) == 4, "Z24S8 is incorrect size");
 
-    S8Z24 input_pixel{};
-    Z24S8 output_pixel{};
-    constexpr auto bpp{CachedSurface::GetGLBytesPerPixel(PixelFormat::S8Z24)};
+    S8Z24 s8z24_pixel{};
+    Z24S8 z24s8_pixel{};
+    constexpr auto bpp{SurfaceParams::GetBytesPerPixel(PixelFormat::S8Z24)};
     for (std::size_t y = 0; y < height; ++y) {
         for (std::size_t x = 0; x < width; ++x) {
             const std::size_t offset{bpp * (y * width + x)};
-            std::memcpy(&input_pixel, &data[offset], sizeof(S8Z24));
-            output_pixel.s8.Assign(input_pixel.s8);
-            output_pixel.z24.Assign(input_pixel.z24);
-            std::memcpy(&data[offset], &output_pixel, sizeof(Z24S8));
+            if (reverse) {
+                std::memcpy(&z24s8_pixel, &data[offset], sizeof(Z24S8));
+                s8z24_pixel.s8.Assign(z24s8_pixel.s8);
+                s8z24_pixel.z24.Assign(z24s8_pixel.z24);
+                std::memcpy(&data[offset], &s8z24_pixel, sizeof(S8Z24));
+            } else {
+                std::memcpy(&s8z24_pixel, &data[offset], sizeof(S8Z24));
+                z24s8_pixel.s8.Assign(s8z24_pixel.s8);
+                z24s8_pixel.z24.Assign(s8z24_pixel.z24);
+                std::memcpy(&data[offset], &z24s8_pixel, sizeof(Z24S8));
+            }
         }
     }
 }
 
 static void ConvertG8R8ToR8G8(std::vector<u8>& data, u32 width, u32 height) {
-    constexpr auto bpp{CachedSurface::GetGLBytesPerPixel(PixelFormat::G8R8U)};
+    constexpr auto bpp{SurfaceParams::GetBytesPerPixel(PixelFormat::G8R8U)};
     for (std::size_t y = 0; y < height; ++y) {
         for (std::size_t x = 0; x < width; ++x) {
             const std::size_t offset{bpp * (y * width + x)};
@@ -814,7 +840,7 @@ static void ConvertFormatAsNeeded_LoadGLBuffer(std::vector<u8>& data, PixelForma
     }
     case PixelFormat::S8Z24:
         // Convert the S8Z24 depth format to Z24S8, as OpenGL does not support S8Z24.
-        ConvertS8Z24ToZ24S8(data, width, height);
+        ConvertS8Z24ToZ24S8(data, width, height, false);
         break;
 
     case PixelFormat::G8R8U:
@@ -825,22 +851,36 @@ static void ConvertFormatAsNeeded_LoadGLBuffer(std::vector<u8>& data, PixelForma
     }
 }
 
+/**
+ * Helper function to perform software conversion (as needed) when flushing a buffer from OpenGL to
+ * Switch memory. This is for Maxwell pixel formats that cannot be represented as-is in OpenGL or
+ * with typical desktop GPUs.
+ */
+static void ConvertFormatAsNeeded_FlushGLBuffer(std::vector<u8>& data, PixelFormat pixel_format,
+                                                u32 width, u32 height) {
+    switch (pixel_format) {
+    case PixelFormat::G8R8U:
+    case PixelFormat::G8R8S:
+    case PixelFormat::ASTC_2D_4X4:
+    case PixelFormat::ASTC_2D_8X8: {
+        LOG_CRITICAL(HW_GPU, "Conversion of format {} after texture flushing is not implemented",
+                     static_cast<u32>(pixel_format));
+        UNREACHABLE();
+        break;
+    }
+    case PixelFormat::S8Z24:
+        // Convert the Z24S8 depth format to S8Z24, as OpenGL does not support S8Z24.
+        ConvertS8Z24ToZ24S8(data, width, height, true);
+        break;
+    }
+}
+
 MICROPROFILE_DEFINE(OpenGL_SurfaceLoad, "OpenGL", "Surface Load", MP_RGB(128, 64, 192));
 void CachedSurface::LoadGLBuffer() {
-    ASSERT(params.type != SurfaceType::Fill);
-
-    const u8* const texture_src_data = Memory::GetPointer(params.addr);
-
-    ASSERT(texture_src_data);
-
-    const u32 bytes_per_pixel = GetGLBytesPerPixel(params.pixel_format);
-    const u32 copy_size = params.width * params.height * bytes_per_pixel;
-    const std::size_t total_size = copy_size * params.depth;
-
     MICROPROFILE_SCOPE(OpenGL_SurfaceLoad);
 
+    gl_buffer.resize(params.size_in_bytes_gl);
     if (params.is_tiled) {
-        gl_buffer.resize(total_size);
         u32 depth = params.depth;
         u32 block_depth = params.block_depth;
 
@@ -853,13 +893,12 @@ void CachedSurface::LoadGLBuffer() {
             block_depth = 1U;
         }
 
-        const std::size_t size = copy_size * depth;
-
         morton_to_gl_fns[static_cast<std::size_t>(params.pixel_format)](
             params.width, params.block_height, params.height, block_depth, depth, gl_buffer.data(),
-            size, params.addr);
+            gl_buffer.size(), params.addr);
     } else {
-        const u8* const texture_src_data_end{texture_src_data + total_size};
+        const auto texture_src_data{Memory::GetPointer(params.addr)};
+        const auto texture_src_data_end{texture_src_data + params.size_in_bytes_gl};
         gl_buffer.assign(texture_src_data, texture_src_data_end);
     }
 
@@ -868,7 +907,44 @@ void CachedSurface::LoadGLBuffer() {
 
 MICROPROFILE_DEFINE(OpenGL_SurfaceFlush, "OpenGL", "Surface Flush", MP_RGB(128, 192, 64));
 void CachedSurface::FlushGLBuffer() {
-    ASSERT_MSG(false, "Unimplemented");
+    MICROPROFILE_SCOPE(OpenGL_SurfaceFlush);
+
+    ASSERT_MSG(!IsPixelFormatASTC(params.pixel_format), "Unimplemented");
+
+    // OpenGL temporary buffer needs to be big enough to store raw texture size
+    gl_buffer.resize(GetSizeInBytes());
+
+    const FormatTuple& tuple = GetFormatTuple(params.pixel_format, params.component_type);
+    // Ensure no bad interactions with GL_UNPACK_ALIGNMENT
+    ASSERT(params.width * SurfaceParams::GetBytesPerPixel(params.pixel_format) % 4 == 0);
+    glPixelStorei(GL_PACK_ROW_LENGTH, static_cast<GLint>(params.width));
+    ASSERT(!tuple.compressed);
+    glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+    glGetTextureImage(texture.handle, 0, tuple.format, tuple.type, gl_buffer.size(),
+                      gl_buffer.data());
+    glPixelStorei(GL_PACK_ROW_LENGTH, 0);
+    ConvertFormatAsNeeded_FlushGLBuffer(gl_buffer, params.pixel_format, params.width,
+                                        params.height);
+    ASSERT(params.type != SurfaceType::Fill);
+    const u8* const texture_src_data = Memory::GetPointer(params.addr);
+    ASSERT(texture_src_data);
+    if (params.is_tiled) {
+        u32 depth = params.depth;
+        u32 block_depth = params.block_depth;
+
+        ASSERT_MSG(params.block_width == 1, "Block width is defined as {} on texture type {}",
+                   params.block_width, static_cast<u32>(params.target));
+
+        if (params.target == SurfaceParams::SurfaceTarget::Texture2D) {
+            // TODO(Blinkhawk): Eliminate this condition once all texture types are implemented.
+            depth = 1U;
+        }
+        gl_to_morton_fns[static_cast<size_t>(params.pixel_format)](
+            params.width, params.block_height, params.height, block_depth, depth, gl_buffer.data(),
+            gl_buffer.size(), GetAddr());
+    } else {
+        std::memcpy(Memory::GetPointer(GetAddr()), gl_buffer.data(), GetSizeInBytes());
+    }
 }
 
 MICROPROFILE_DEFINE(OpenGL_TextureUL, "OpenGL", "Texture Upload", MP_RGB(128, 64, 192));
@@ -878,9 +954,6 @@ void CachedSurface::UploadGLTexture(GLuint read_fb_handle, GLuint draw_fb_handle
 
     MICROPROFILE_SCOPE(OpenGL_TextureUL);
 
-    ASSERT(gl_buffer.size() == static_cast<std::size_t>(params.width) * params.height *
-                                   GetGLBytesPerPixel(params.pixel_format) * params.depth);
-
     const auto& rect{params.GetRect()};
 
     // Load data from memory to the surface
@@ -889,7 +962,7 @@ void CachedSurface::UploadGLTexture(GLuint read_fb_handle, GLuint draw_fb_handle
     std::size_t buffer_offset =
         static_cast<std::size_t>(static_cast<std::size_t>(y0) * params.width +
                                  static_cast<std::size_t>(x0)) *
-        GetGLBytesPerPixel(params.pixel_format);
+        SurfaceParams::GetBytesPerPixel(params.pixel_format);
 
     const FormatTuple& tuple = GetFormatTuple(params.pixel_format, params.component_type);
     const GLuint target_tex = texture.handle;
@@ -905,7 +978,7 @@ void CachedSurface::UploadGLTexture(GLuint read_fb_handle, GLuint draw_fb_handle
     cur_state.Apply();
 
     // Ensure no bad interactions with GL_UNPACK_ALIGNMENT
-    ASSERT(params.width * GetGLBytesPerPixel(params.pixel_format) % 4 == 0);
+    ASSERT(params.width * SurfaceParams::GetBytesPerPixel(params.pixel_format) % 4 == 0);
     glPixelStorei(GL_UNPACK_ROW_LENGTH, static_cast<GLint>(params.width));
 
     glActiveTexture(GL_TEXTURE0);
@@ -915,7 +988,7 @@ void CachedSurface::UploadGLTexture(GLuint read_fb_handle, GLuint draw_fb_handle
             glCompressedTexImage2D(
                 SurfaceTargetToGL(params.target), 0, tuple.internal_format,
                 static_cast<GLsizei>(params.width), static_cast<GLsizei>(params.height), 0,
-                static_cast<GLsizei>(params.size_in_bytes_2d), &gl_buffer[buffer_offset]);
+                static_cast<GLsizei>(params.size_in_bytes_gl), &gl_buffer[buffer_offset]);
             break;
         case SurfaceParams::SurfaceTarget::Texture3D:
         case SurfaceParams::SurfaceTarget::Texture2DArray:
@@ -923,16 +996,16 @@ void CachedSurface::UploadGLTexture(GLuint read_fb_handle, GLuint draw_fb_handle
                 SurfaceTargetToGL(params.target), 0, tuple.internal_format,
                 static_cast<GLsizei>(params.width), static_cast<GLsizei>(params.height),
                 static_cast<GLsizei>(params.depth), 0,
-                static_cast<GLsizei>(params.size_in_bytes_total), &gl_buffer[buffer_offset]);
+                static_cast<GLsizei>(params.size_in_bytes_gl), &gl_buffer[buffer_offset]);
             break;
         case SurfaceParams::SurfaceTarget::TextureCubemap:
             for (std::size_t face = 0; face < params.depth; ++face) {
                 glCompressedTexImage2D(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face),
                                        0, tuple.internal_format, static_cast<GLsizei>(params.width),
                                        static_cast<GLsizei>(params.height), 0,
-                                       static_cast<GLsizei>(params.size_in_bytes_2d),
+                                       static_cast<GLsizei>(params.SizeInBytesCubeFaceGL()),
                                        &gl_buffer[buffer_offset]);
-                buffer_offset += params.size_in_bytes_2d;
+                buffer_offset += params.SizeInBytesCubeFace();
             }
             break;
         default:
@@ -942,7 +1015,7 @@ void CachedSurface::UploadGLTexture(GLuint read_fb_handle, GLuint draw_fb_handle
             glCompressedTexImage2D(
                 GL_TEXTURE_2D, 0, tuple.internal_format, static_cast<GLsizei>(params.width),
                 static_cast<GLsizei>(params.height), 0,
-                static_cast<GLsizei>(params.size_in_bytes_2d), &gl_buffer[buffer_offset]);
+                static_cast<GLsizei>(params.size_in_bytes_gl), &gl_buffer[buffer_offset]);
         }
     } else {
 
@@ -971,7 +1044,7 @@ void CachedSurface::UploadGLTexture(GLuint read_fb_handle, GLuint draw_fb_handle
                                 y0, static_cast<GLsizei>(rect.GetWidth()),
                                 static_cast<GLsizei>(rect.GetHeight()), tuple.format, tuple.type,
                                 &gl_buffer[buffer_offset]);
-                buffer_offset += params.size_in_bytes_2d;
+                buffer_offset += params.SizeInBytesCubeFace();
             }
             break;
         default:
@@ -1033,10 +1106,7 @@ Surface RasterizerCacheOpenGL::GetColorBufferSurface(std::size_t index, bool pre
 void RasterizerCacheOpenGL::LoadSurface(const Surface& surface) {
     surface->LoadGLBuffer();
     surface->UploadGLTexture(read_framebuffer.handle, draw_framebuffer.handle);
-}
-
-void RasterizerCacheOpenGL::FlushSurface(const Surface& surface) {
-    surface->FlushGLBuffer();
+    surface->MarkAsModified(false, *this);
 }
 
 Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params, bool preserve_contents) {
@@ -1053,8 +1123,8 @@ Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params, bool pres
         } else if (preserve_contents) {
             // If surface parameters changed and we care about keeping the previous data, recreate
             // the surface from the old one
-            Unregister(surface);
             Surface new_surface{RecreateSurface(surface, params)};
+            Unregister(surface);
             Register(new_surface);
             return new_surface;
         } else {
@@ -1105,6 +1175,14 @@ void RasterizerCacheOpenGL::FermiCopySurface(
     FastCopySurface(GetSurface(src_params, true), GetSurface(dst_params, false));
 }
 
+void RasterizerCacheOpenGL::AccurateCopySurface(const Surface& src_surface,
+                                                const Surface& dst_surface) {
+    const auto& src_params{src_surface->GetSurfaceParams()};
+    const auto& dst_params{dst_surface->GetSurfaceParams()};
+    FlushRegion(src_params.addr, dst_params.size_in_bytes);
+    LoadSurface(dst_surface);
+}
+
 Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
                                                const SurfaceParams& new_params) {
     // Verify surface is compatible for blitting
@@ -1113,6 +1191,12 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
     // Get a new surface with the new parameters, and blit the previous surface to it
     Surface new_surface{GetUncachedSurface(new_params)};
 
+    // With use_accurate_gpu_emulation enabled, do an accurate surface copy
+    if (Settings::values.use_accurate_gpu_emulation) {
+        AccurateCopySurface(old_surface, new_surface);
+        return new_surface;
+    }
+
     // For compatible surfaces, we can just do fast glCopyImageSubData based copy
     if (old_params.target == new_params.target && old_params.type == new_params.type &&
         old_params.depth == new_params.depth && old_params.depth == 1 &&
@@ -1124,11 +1208,10 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
 
     // If the format is the same, just do a framebuffer blit. This is significantly faster than
     // using PBOs. The is also likely less accurate, as textures will be converted rather than
-    // reinterpreted. When use_accurate_framebuffers setting is enabled, perform a more accurate
+    // reinterpreted. When use_accurate_gpu_emulation setting is enabled, perform a more accurate
     // surface copy, where pixels are reinterpreted as a new format (without conversion). This
     // code path uses OpenGL PBOs and is quite slow.
-    const bool is_blit{old_params.pixel_format == new_params.pixel_format ||
-                       !Settings::values.use_accurate_framebuffers};
+    const bool is_blit{old_params.pixel_format == new_params.pixel_format};
 
     switch (new_params.target) {
     case SurfaceParams::SurfaceTarget::Texture2D:
@@ -1138,6 +1221,9 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
             CopySurface(old_surface, new_surface, copy_pbo.handle);
         }
         break;
+    case SurfaceParams::SurfaceTarget::Texture3D:
+        AccurateCopySurface(old_surface, new_surface);
+        break;
     case SurfaceParams::SurfaceTarget::TextureCubemap: {
         if (old_params.rt.array_mode != 1) {
             // TODO(bunnei): This is used by Breath of the Wild, I'm not sure how to implement this
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.h b/src/video_core/renderer_opengl/gl_rasterizer_cache.h
index 0b8ae3eb4..0dd0d90a3 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.h
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.h
@@ -18,6 +18,7 @@
 #include "video_core/rasterizer_cache.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/gl_shader_gen.h"
+#include "video_core/textures/decoders.h"
 #include "video_core/textures/texture.h"
 
 namespace OpenGL {
@@ -131,6 +132,8 @@ struct SurfaceParams {
         case Tegra::Texture::TextureType::Texture2D:
         case Tegra::Texture::TextureType::Texture2DNoMipmap:
             return SurfaceTarget::Texture2D;
+        case Tegra::Texture::TextureType::Texture3D:
+            return SurfaceTarget::Texture3D;
         case Tegra::Texture::TextureType::TextureCubemap:
             return SurfaceTarget::TextureCubemap;
         case Tegra::Texture::TextureType::Texture1DArray:
@@ -701,21 +704,42 @@ struct SurfaceParams {
         return SurfaceType::Invalid;
     }
 
+    /// Returns the sizer in bytes of the specified pixel format
+    static constexpr u32 GetBytesPerPixel(PixelFormat pixel_format) {
+        if (pixel_format == SurfaceParams::PixelFormat::Invalid) {
+            return 0;
+        }
+        return GetFormatBpp(pixel_format) / CHAR_BIT;
+    }
+
     /// Returns the rectangle corresponding to this surface
     MathUtil::Rectangle<u32> GetRect() const;
 
-    /// Returns the size of this surface as a 2D texture in bytes, adjusted for compression
-    std::size_t SizeInBytes2D() const {
+    /// Returns the total size of this surface in bytes, adjusted for compression
+    std::size_t SizeInBytesRaw(bool ignore_tiled = false) const {
         const u32 compression_factor{GetCompressionFactor(pixel_format)};
-        ASSERT(width % compression_factor == 0);
-        ASSERT(height % compression_factor == 0);
-        return (width / compression_factor) * (height / compression_factor) *
-               GetFormatBpp(pixel_format) / CHAR_BIT;
+        const u32 bytes_per_pixel{GetBytesPerPixel(pixel_format)};
+        const size_t uncompressed_size{
+            Tegra::Texture::CalculateSize((ignore_tiled ? false : is_tiled), bytes_per_pixel, width,
+                                          height, depth, block_height, block_depth)};
+
+        // Divide by compression_factor^2, as height and width are factored by this
+        return uncompressed_size / (compression_factor * compression_factor);
     }
 
-    /// Returns the total size of this surface in bytes, adjusted for compression
-    std::size_t SizeInBytesTotal() const {
-        return SizeInBytes2D() * depth;
+    /// Returns the size of this surface as an OpenGL texture in bytes
+    std::size_t SizeInBytesGL() const {
+        return SizeInBytesRaw(true);
+    }
+
+    /// Returns the size of this surface as a cube face in bytes
+    std::size_t SizeInBytesCubeFace() const {
+        return size_in_bytes / 6;
+    }
+
+    /// Returns the size of this surface as an OpenGL cube face in bytes
+    std::size_t SizeInBytesCubeFaceGL() const {
+        return size_in_bytes_gl / 6;
     }
 
     /// Creates SurfaceParams from a texture configuration
@@ -742,7 +766,9 @@ struct SurfaceParams {
                         other.depth);
     }
 
-    VAddr addr;
+    /// Initializes parameters for caching, should be called after everything has been initialized
+    void InitCacheParameters(Tegra::GPUVAddr gpu_addr);
+
     bool is_tiled;
     u32 block_width;
     u32 block_height;
@@ -754,15 +780,20 @@ struct SurfaceParams {
     u32 height;
     u32 depth;
     u32 unaligned_height;
-    std::size_t size_in_bytes_total;
-    std::size_t size_in_bytes_2d;
     SurfaceTarget target;
     u32 max_mip_level;
 
+    // Parameters used for caching
+    VAddr addr;
+    Tegra::GPUVAddr gpu_addr;
+    std::size_t size_in_bytes;
+    std::size_t size_in_bytes_gl;
+
     // Render target specific parameters, not used in caching
     struct {
         u32 index;
         u32 array_mode;
+        u32 volume;
         u32 layer_stride;
         u32 base_layer;
     } rt;
@@ -775,7 +806,8 @@ struct SurfaceReserveKey : Common::HashableStruct<OpenGL::SurfaceParams> {
     static SurfaceReserveKey Create(const OpenGL::SurfaceParams& params) {
         SurfaceReserveKey res;
         res.state = params;
-        res.state.rt = {}; // Ignore rt config in caching
+        res.state.gpu_addr = {}; // Ignore GPU vaddr in caching
+        res.state.rt = {};       // Ignore rt config in caching
         return res;
     }
 };
@@ -790,16 +822,20 @@ struct hash<SurfaceReserveKey> {
 
 namespace OpenGL {
 
-class CachedSurface final {
+class CachedSurface final : public RasterizerCacheObject {
 public:
     CachedSurface(const SurfaceParams& params);
 
-    VAddr GetAddr() const {
+    VAddr GetAddr() const override {
         return params.addr;
     }
 
-    std::size_t GetSizeInBytes() const {
-        return params.size_in_bytes_total;
+    std::size_t GetSizeInBytes() const override {
+        return cached_size_in_bytes;
+    }
+
+    void Flush() override {
+        FlushGLBuffer();
     }
 
     const OGLTexture& Texture() const {
@@ -810,13 +846,6 @@ public:
         return gl_target;
     }
 
-    static constexpr unsigned int GetGLBytesPerPixel(SurfaceParams::PixelFormat format) {
-        if (format == SurfaceParams::PixelFormat::Invalid)
-            return 0;
-
-        return SurfaceParams::GetFormatBpp(format) / CHAR_BIT;
-    }
-
     const SurfaceParams& GetSurfaceParams() const {
         return params;
     }
@@ -833,6 +862,7 @@ private:
     std::vector<u8> gl_buffer;
     SurfaceParams params;
     GLenum gl_target;
+    std::size_t cached_size_in_bytes;
 };
 
 class RasterizerCacheOpenGL final : public RasterizerCache<Surface> {
@@ -849,9 +879,6 @@ public:
     /// Get the color surface based on the framebuffer configuration and the specified render target
     Surface GetColorBufferSurface(std::size_t index, bool preserve_contents);
 
-    /// Flushes the surface to Switch memory
-    void FlushSurface(const Surface& surface);
-
     /// Tries to find a framebuffer using on the provided CPU address
     Surface TryFindFramebufferSurface(VAddr addr) const;
 
@@ -875,6 +902,9 @@ private:
     /// Tries to get a reserved surface for the specified parameters
     Surface TryGetReservedSurface(const SurfaceParams& params);
 
+    /// Performs a slow but accurate surface copy, flushing to RAM and reinterpreting the data
+    void AccurateCopySurface(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
     /// destroyed when used with different surface parameters.
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.h b/src/video_core/renderer_opengl/gl_shader_cache.h
index 7bb287f56..a210f1731 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.h
+++ b/src/video_core/renderer_opengl/gl_shader_cache.h
@@ -19,20 +19,21 @@ class CachedShader;
 using Shader = std::shared_ptr<CachedShader>;
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 
-class CachedShader final {
+class CachedShader final : public RasterizerCacheObject {
 public:
     CachedShader(VAddr addr, Maxwell::ShaderProgram program_type);
 
-    /// Gets the address of the shader in guest memory, required for cache management
-    VAddr GetAddr() const {
+    VAddr GetAddr() const override {
         return addr;
     }
 
-    /// Gets the size of the shader in guest memory, required for cache management
-    std::size_t GetSizeInBytes() const {
+    std::size_t GetSizeInBytes() const override {
         return GLShader::MAX_PROGRAM_CODE_LENGTH * sizeof(u64);
     }
 
+    // We do not have to flush this cache as things in it are never modified by us.
+    void Flush() override {}
+
     /// Gets the shader entries for the shader
     const GLShader::ShaderEntries& GetShaderEntries() const {
         return entries;
diff --git a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
index ca063d90d..fe4d1bd83 100644
--- a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
@@ -30,8 +30,6 @@ using Tegra::Shader::SubOp;
 constexpr u32 PROGRAM_END = MAX_PROGRAM_CODE_LENGTH;
 constexpr u32 PROGRAM_HEADER_SIZE = sizeof(Tegra::Shader::Header);
 
-enum : u32 { POSITION_VARYING_LOCATION = 0, GENERIC_VARYING_START_LOCATION = 1 };
-
 constexpr u32 MAX_GEOMETRY_BUFFERS = 6;
 constexpr u32 MAX_ATTRIBUTES = 0x100; // Size in vec4s, this value is untested
 
@@ -165,10 +163,11 @@ private:
                     const ExitMethod jmp = Scan(target, end, labels);
                     return exit_method = ParallelExit(no_jmp, jmp);
                 }
-                case OpCode::Id::SSY: {
-                    // The SSY instruction uses a similar encoding as the BRA instruction.
+                case OpCode::Id::SSY:
+                case OpCode::Id::PBK: {
+                    // The SSY and PBK use a similar encoding as the BRA instruction.
                     ASSERT_MSG(instr.bra.constant_buffer == 0,
-                               "Constant buffer SSY is not supported");
+                               "Constant buffer branching is not supported");
                     const u32 target = offset + instr.bra.GetBranchTarget();
                     labels.insert(target);
                     // Continue scanning for an exit method.
@@ -376,11 +375,55 @@ public:
     }
 
     /**
+     * Writes code that does a register assignment to a half float value operation.
+     * @param reg The destination register to use.
+     * @param elem The element to use for the operation.
+     * @param value The code representing the value to assign. Type has to be half float.
+     * @param merge Half float kind of assignment.
+     * @param dest_num_components Number of components in the destination.
+     * @param value_num_components Number of components in the value.
+     * @param is_saturated Optional, when True, saturates the provided value.
+     * @param dest_elem Optional, the destination element to use for the operation.
+     */
+    void SetRegisterToHalfFloat(const Register& reg, u64 elem, const std::string& value,
+                                Tegra::Shader::HalfMerge merge, u64 dest_num_components,
+                                u64 value_num_components, bool is_saturated = false,
+                                u64 dest_elem = 0) {
+        ASSERT_MSG(!is_saturated, "Unimplemented");
+
+        const std::string result = [&]() {
+            switch (merge) {
+            case Tegra::Shader::HalfMerge::H0_H1:
+                return "uintBitsToFloat(packHalf2x16(" + value + "))";
+            case Tegra::Shader::HalfMerge::F32:
+                // Half float instructions take the first component when doing a float cast.
+                return "float(" + value + ".x)";
+            case Tegra::Shader::HalfMerge::Mrg_H0:
+                // TODO(Rodrigo): I guess Mrg_H0 and Mrg_H1 take their respective component from the
+                // pack. I couldn't test this on hardware but it shouldn't really matter since most
+                // of the time when a Mrg_* flag is used both components will be mirrored. That
+                // being said, it deserves a test.
+                return "((" + GetRegisterAsInteger(reg, 0, false) +
+                       " & 0xffff0000) | (packHalf2x16(" + value + ") & 0x0000ffff))";
+            case Tegra::Shader::HalfMerge::Mrg_H1:
+                return "((" + GetRegisterAsInteger(reg, 0, false) +
+                       " & 0x0000ffff) | (packHalf2x16(" + value + ") & 0xffff0000))";
+            default:
+                UNREACHABLE();
+                return std::string("0");
+            }
+        }();
+
+        SetRegister(reg, elem, result, dest_num_components, value_num_components, dest_elem);
+    }
+
+    /**
      * Writes code that does a register assignment to input attribute operation. Input attributes
      * are stored as floats, so this may require conversion.
      * @param reg The destination register to use.
      * @param elem The element to use for the operation.
      * @param attribute The input attribute to use as the source value.
+     * @param input_mode The input mode.
      * @param vertex The register that decides which vertex to read from (used in GS).
      */
     void SetRegisterToInputAttibute(const Register& reg, u64 elem, Attribute::Index attribute,
@@ -548,13 +591,6 @@ private:
 
     /// Generates declarations for input attributes.
     void GenerateInputAttrs() {
-        if (stage != Maxwell3D::Regs::ShaderStage::Vertex) {
-            const std::string attr =
-                stage == Maxwell3D::Regs::ShaderStage::Geometry ? "gs_position[]" : "position";
-            declarations.AddLine("layout (location = " + std::to_string(POSITION_VARYING_LOCATION) +
-                                 ") in vec4 " + attr + ';');
-        }
-
         for (const auto element : declr_input_attribute) {
             // TODO(bunnei): Use proper number of elements for these
             u32 idx =
@@ -577,10 +613,6 @@ private:
 
     /// Generates declarations for output attributes.
     void GenerateOutputAttrs() {
-        if (stage != Maxwell3D::Regs::ShaderStage::Fragment) {
-            declarations.AddLine("layout (location = " + std::to_string(POSITION_VARYING_LOCATION) +
-                                 ") out vec4 position;");
-        }
         for (const auto& index : declr_output_attribute) {
             // TODO(bunnei): Use proper number of elements for these
             const u32 idx = static_cast<u32>(index) -
@@ -877,6 +909,19 @@ private:
         return fmt::format("uintBitsToFloat({})", instr.alu.GetImm20_32());
     }
 
+    /// Generates code representing a vec2 pair unpacked from a half float immediate
+    static std::string UnpackHalfImmediate(const Instruction& instr, bool negate) {
+        const std::string immediate = GetHalfFloat(std::to_string(instr.half_imm.PackImmediates()));
+        if (!negate) {
+            return immediate;
+        }
+        const std::string negate_first = instr.half_imm.first_negate != 0 ? "-" : "";
+        const std::string negate_second = instr.half_imm.second_negate != 0 ? "-" : "";
+        const std::string negate_vec = "vec2(" + negate_first + "1, " + negate_second + "1)";
+
+        return '(' + immediate + " * " + negate_vec + ')';
+    }
+
     /// Generates code representing a texture sampler.
     std::string GetSampler(const Sampler& sampler, Tegra::Shader::TextureType type, bool is_array,
                            bool is_shadow) {
@@ -908,7 +953,7 @@ private:
         // Can't assign to the constant predicate.
         ASSERT(pred != static_cast<u64>(Pred::UnusedIndex));
 
-        const std::string variable = 'p' + std::to_string(pred) + '_' + suffix;
+        std::string variable = 'p' + std::to_string(pred) + '_' + suffix;
         shader.AddLine(variable + " = " + value + ';');
         declr_predicates.insert(std::move(variable));
     }
@@ -1013,6 +1058,41 @@ private:
     }
 
     /*
+     * Transforms the input string GLSL operand into an unpacked half float pair.
+     * @note This function returns a float type pair instead of a half float pair. This is because
+     * real half floats are not standardized in GLSL but unpackHalf2x16 (which returns a vec2) is.
+     * @param operand Input operand. It has to be an unsigned integer.
+     * @param type How to unpack the unsigned integer to a half float pair.
+     * @param abs Get the absolute value of unpacked half floats.
+     * @param neg Get the negative value of unpacked half floats.
+     * @returns String corresponding to a half float pair.
+     */
+    static std::string GetHalfFloat(const std::string& operand,
+                                    Tegra::Shader::HalfType type = Tegra::Shader::HalfType::H0_H1,
+                                    bool abs = false, bool neg = false) {
+        // "vec2" calls emitted in this function are intended to alias components.
+        const std::string value = [&]() {
+            switch (type) {
+            case Tegra::Shader::HalfType::H0_H1:
+                return "unpackHalf2x16(" + operand + ')';
+            case Tegra::Shader::HalfType::F32:
+                return "vec2(uintBitsToFloat(" + operand + "))";
+            case Tegra::Shader::HalfType::H0_H0:
+            case Tegra::Shader::HalfType::H1_H1: {
+                const bool high = type == Tegra::Shader::HalfType::H1_H1;
+                const char unpack_index = "xy"[high ? 1 : 0];
+                return "vec2(unpackHalf2x16(" + operand + ")." + unpack_index + ')';
+            }
+            default:
+                UNREACHABLE();
+                return std::string("vec2(0)");
+            }
+        }();
+
+        return GetOperandAbsNeg(value, abs, neg);
+    }
+
+    /*
      * Returns whether the instruction at the specified offset is a 'sched' instruction.
      * Sched instructions always appear before a sequence of 3 instructions.
      */
@@ -1142,6 +1222,7 @@ private:
         case Tegra::Shader::TextureType::Texture2D: {
             return 2;
         }
+        case Tegra::Shader::TextureType::Texture3D:
         case Tegra::Shader::TextureType::TextureCube: {
             return 3;
         }
@@ -1153,27 +1234,27 @@ private:
     }
 
     /*
-     * Emits code to push the input target address to the SSY address stack, incrementing the stack
+     * Emits code to push the input target address to the flow address stack, incrementing the stack
      * top.
      */
-    void EmitPushToSSYStack(u32 target) {
+    void EmitPushToFlowStack(u32 target) {
         shader.AddLine('{');
         ++shader.scope;
-        shader.AddLine("ssy_stack[ssy_stack_top] = " + std::to_string(target) + "u;");
-        shader.AddLine("ssy_stack_top++;");
+        shader.AddLine("flow_stack[flow_stack_top] = " + std::to_string(target) + "u;");
+        shader.AddLine("flow_stack_top++;");
         --shader.scope;
         shader.AddLine('}');
     }
 
     /*
-     * Emits code to pop an address from the SSY address stack, setting the jump address to the
+     * Emits code to pop an address from the flow address stack, setting the jump address to the
      * popped address and decrementing the stack top.
      */
-    void EmitPopFromSSYStack() {
+    void EmitPopFromFlowStack() {
         shader.AddLine('{');
         ++shader.scope;
-        shader.AddLine("ssy_stack_top--;");
-        shader.AddLine("jmp_to = ssy_stack[ssy_stack_top];");
+        shader.AddLine("flow_stack_top--;");
+        shader.AddLine("jmp_to = flow_stack[flow_stack_top];");
         shader.AddLine("break;");
         --shader.scope;
         shader.AddLine('}');
@@ -1185,9 +1266,29 @@ private:
 
         ASSERT_MSG(header.ps.omap.sample_mask == 0, "Samplemask write is unimplemented");
 
+        shader.AddLine("if (alpha_test[0] != 0) {");
+        ++shader.scope;
+        // We start on the register containing the alpha value in the first RT.
+        u32 current_reg = 3;
+        for (u32 render_target = 0; render_target < Maxwell3D::Regs::NumRenderTargets;
+             ++render_target) {
+            // TODO(Blinkhawk): verify the behavior of alpha testing on hardware when
+            // multiple render targets are used.
+            if (header.ps.IsColorComponentOutputEnabled(render_target, 0) ||
+                header.ps.IsColorComponentOutputEnabled(render_target, 1) ||
+                header.ps.IsColorComponentOutputEnabled(render_target, 2) ||
+                header.ps.IsColorComponentOutputEnabled(render_target, 3)) {
+                shader.AddLine(fmt::format("if (!AlphaFunc({})) discard;",
+                                           regs.GetRegisterAsFloat(current_reg)));
+                current_reg += 4;
+            }
+        }
+        --shader.scope;
+        shader.AddLine('}');
+
         // Write the color outputs using the data in the shader registers, disabled
         // rendertargets/components are skipped in the register assignment.
-        u32 current_reg = 0;
+        current_reg = 0;
         for (u32 render_target = 0; render_target < Maxwell3D::Regs::NumRenderTargets;
              ++render_target) {
             // TODO(Subv): Figure out how dual-source blending is configured in the Switch.
@@ -1211,6 +1312,63 @@ private:
         }
     }
 
+    /// Unpacks a video instruction operand (e.g. VMAD).
+    std::string GetVideoOperand(const std::string& op, bool is_chunk, bool is_signed,
+                                Tegra::Shader::VideoType type, u64 byte_height) {
+        const std::string value = [&]() {
+            if (!is_chunk) {
+                const auto offset = static_cast<u32>(byte_height * 8);
+                return "((" + op + " >> " + std::to_string(offset) + ") & 0xff)";
+            }
+            const std::string zero = "0";
+
+            switch (type) {
+            case Tegra::Shader::VideoType::Size16_Low:
+                return '(' + op + " & 0xffff)";
+            case Tegra::Shader::VideoType::Size16_High:
+                return '(' + op + " >> 16)";
+            case Tegra::Shader::VideoType::Size32:
+                // TODO(Rodrigo): From my hardware tests it becomes a bit "mad" when
+                // this type is used (1 * 1 + 0 == 0x5b800000). Until a better
+                // explanation is found: assert.
+                UNIMPLEMENTED();
+                return zero;
+            case Tegra::Shader::VideoType::Invalid:
+                UNREACHABLE_MSG("Invalid instruction encoding");
+                return zero;
+            default:
+                UNREACHABLE();
+                return zero;
+            }
+        }();
+
+        if (is_signed) {
+            return "int(" + value + ')';
+        }
+        return value;
+    };
+
+    /// Gets the A operand for a video instruction.
+    std::string GetVideoOperandA(Instruction instr) {
+        return GetVideoOperand(regs.GetRegisterAsInteger(instr.gpr8, 0, false),
+                               instr.video.is_byte_chunk_a != 0, instr.video.signed_a,
+                               instr.video.type_a, instr.video.byte_height_a);
+    }
+
+    /// Gets the B operand for a video instruction.
+    std::string GetVideoOperandB(Instruction instr) {
+        if (instr.video.use_register_b) {
+            return GetVideoOperand(regs.GetRegisterAsInteger(instr.gpr20, 0, false),
+                                   instr.video.is_byte_chunk_b != 0, instr.video.signed_b,
+                                   instr.video.type_b, instr.video.byte_height_b);
+        } else {
+            return '(' +
+                   std::to_string(instr.video.signed_b ? static_cast<s16>(instr.alu.GetImm20_16())
+                                                       : instr.alu.GetImm20_16()) +
+                   ')';
+        }
+    }
+
     /**
      * Compiles a single instruction from Tegra to GLSL.
      * @param offset the offset of the Tegra shader instruction.
@@ -1380,9 +1538,10 @@ private:
                 break;
             }
             case OpCode::Id::FMUL32_IMM: {
-                regs.SetRegisterToFloat(
-                    instr.gpr0, 0,
-                    regs.GetRegisterAsFloat(instr.gpr8) + " * " + GetImmediate32(instr), 1, 1);
+                regs.SetRegisterToFloat(instr.gpr0, 0,
+                                        regs.GetRegisterAsFloat(instr.gpr8) + " * " +
+                                            GetImmediate32(instr),
+                                        1, 1, instr.fmul32.saturate);
                 break;
             }
             case OpCode::Id::FADD32I: {
@@ -1747,6 +1906,86 @@ private:
 
             break;
         }
+        case OpCode::Type::ArithmeticHalf: {
+            if (opcode->GetId() == OpCode::Id::HADD2_C || opcode->GetId() == OpCode::Id::HADD2_R) {
+                ASSERT_MSG(instr.alu_half.ftz == 0, "Unimplemented");
+            }
+            const bool negate_a =
+                opcode->GetId() != OpCode::Id::HMUL2_R && instr.alu_half.negate_a != 0;
+            const bool negate_b =
+                opcode->GetId() != OpCode::Id::HMUL2_C && instr.alu_half.negate_b != 0;
+
+            const std::string op_a =
+                GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr8, 0, false), instr.alu_half.type_a,
+                             instr.alu_half.abs_a != 0, negate_a);
+
+            std::string op_b;
+            switch (opcode->GetId()) {
+            case OpCode::Id::HADD2_C:
+            case OpCode::Id::HMUL2_C:
+                op_b = regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
+                                       GLSLRegister::Type::UnsignedInteger);
+                break;
+            case OpCode::Id::HADD2_R:
+            case OpCode::Id::HMUL2_R:
+                op_b = regs.GetRegisterAsInteger(instr.gpr20, 0, false);
+                break;
+            default:
+                UNREACHABLE();
+                op_b = "0";
+                break;
+            }
+            op_b = GetHalfFloat(op_b, instr.alu_half.type_b, instr.alu_half.abs_b != 0, negate_b);
+
+            const std::string result = [&]() {
+                switch (opcode->GetId()) {
+                case OpCode::Id::HADD2_C:
+                case OpCode::Id::HADD2_R:
+                    return '(' + op_a + " + " + op_b + ')';
+                case OpCode::Id::HMUL2_C:
+                case OpCode::Id::HMUL2_R:
+                    return '(' + op_a + " * " + op_b + ')';
+                default:
+                    LOG_CRITICAL(HW_GPU, "Unhandled half float instruction: {}", opcode->GetName());
+                    UNREACHABLE();
+                    return std::string("0");
+                }
+            }();
+
+            regs.SetRegisterToHalfFloat(instr.gpr0, 0, result, instr.alu_half.merge, 1, 1,
+                                        instr.alu_half.saturate != 0);
+            break;
+        }
+        case OpCode::Type::ArithmeticHalfImmediate: {
+            if (opcode->GetId() == OpCode::Id::HADD2_IMM) {
+                ASSERT_MSG(instr.alu_half_imm.ftz == 0, "Unimplemented");
+            } else {
+                ASSERT_MSG(instr.alu_half_imm.precision == Tegra::Shader::HalfPrecision::None,
+                           "Unimplemented");
+            }
+
+            const std::string op_a = GetHalfFloat(
+                regs.GetRegisterAsInteger(instr.gpr8, 0, false), instr.alu_half_imm.type_a,
+                instr.alu_half_imm.abs_a != 0, instr.alu_half_imm.negate_a != 0);
+
+            const std::string op_b = UnpackHalfImmediate(instr, true);
+
+            const std::string result = [&]() {
+                switch (opcode->GetId()) {
+                case OpCode::Id::HADD2_IMM:
+                    return op_a + " + " + op_b;
+                case OpCode::Id::HMUL2_IMM:
+                    return op_a + " * " + op_b;
+                default:
+                    UNREACHABLE();
+                    return std::string("0");
+                }
+            }();
+
+            regs.SetRegisterToHalfFloat(instr.gpr0, 0, result, instr.alu_half_imm.merge, 1, 1,
+                                        instr.alu_half_imm.saturate != 0);
+            break;
+        }
         case OpCode::Type::Ffma: {
             const std::string op_a = regs.GetRegisterAsFloat(instr.gpr8);
             std::string op_b = instr.ffma.negate_b ? "-" : "";
@@ -1791,6 +2030,59 @@ private:
                                     instr.alu.saturate_d);
             break;
         }
+        case OpCode::Type::Hfma2: {
+            if (opcode->GetId() == OpCode::Id::HFMA2_RR) {
+                ASSERT_MSG(instr.hfma2.rr.precision == Tegra::Shader::HalfPrecision::None,
+                           "Unimplemented");
+            } else {
+                ASSERT_MSG(instr.hfma2.precision == Tegra::Shader::HalfPrecision::None,
+                           "Unimplemented");
+            }
+            const bool saturate = opcode->GetId() == OpCode::Id::HFMA2_RR
+                                      ? instr.hfma2.rr.saturate != 0
+                                      : instr.hfma2.saturate != 0;
+
+            const std::string op_a =
+                GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr8, 0, false), instr.hfma2.type_a);
+            std::string op_b, op_c;
+
+            switch (opcode->GetId()) {
+            case OpCode::Id::HFMA2_CR:
+                op_b = GetHalfFloat(regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
+                                                    GLSLRegister::Type::UnsignedInteger),
+                                    instr.hfma2.type_b, false, instr.hfma2.negate_b);
+                op_c = GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr39, 0, false),
+                                    instr.hfma2.type_reg39, false, instr.hfma2.negate_c);
+                break;
+            case OpCode::Id::HFMA2_RC:
+                op_b = GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr39, 0, false),
+                                    instr.hfma2.type_reg39, false, instr.hfma2.negate_b);
+                op_c = GetHalfFloat(regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
+                                                    GLSLRegister::Type::UnsignedInteger),
+                                    instr.hfma2.type_b, false, instr.hfma2.negate_c);
+                break;
+            case OpCode::Id::HFMA2_RR:
+                op_b = GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr20, 0, false),
+                                    instr.hfma2.type_b, false, instr.hfma2.negate_b);
+                op_c = GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr39, 0, false),
+                                    instr.hfma2.rr.type_c, false, instr.hfma2.rr.negate_c);
+                break;
+            case OpCode::Id::HFMA2_IMM_R:
+                op_b = UnpackHalfImmediate(instr, true);
+                op_c = GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr39, 0, false),
+                                    instr.hfma2.type_reg39, false, instr.hfma2.negate_c);
+                break;
+            default:
+                UNREACHABLE();
+                op_c = op_b = "vec2(0)";
+                break;
+            }
+
+            const std::string result = '(' + op_a + " * " + op_b + " + " + op_c + ')';
+
+            regs.SetRegisterToHalfFloat(instr.gpr0, 0, result, instr.hfma2.merge, 1, 1, saturate);
+            break;
+        }
         case OpCode::Type::Conversion: {
             switch (opcode->GetId()) {
             case OpCode::Id::I2I_R: {
@@ -2036,9 +2328,9 @@ private:
                 break;
             }
             case OpCode::Id::TEX: {
-                ASSERT_MSG(instr.tex.array == 0, "TEX arrays unimplemented");
                 Tegra::Shader::TextureType texture_type{instr.tex.texture_type};
                 std::string coord;
+                const bool is_array = instr.tex.array != 0;
 
                 ASSERT_MSG(!instr.tex.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
                            "NODEP is not implemented");
@@ -2053,21 +2345,59 @@ private:
 
                 switch (num_coordinates) {
                 case 1: {
-                    const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
-                    coord = "float coords = " + x + ';';
+                    if (is_array) {
+                        const std::string index = regs.GetRegisterAsInteger(instr.gpr8);
+                        const std::string x = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                        coord = "vec2 coords = vec2(" + x + ", " + index + ");";
+                    } else {
+                        const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
+                        coord = "float coords = " + x + ';';
+                    }
                     break;
                 }
                 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 + ");";
+                    if (is_array) {
+                        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.gpr8.Value() + 2);
+                        coord = "vec3 coords = vec3(" + x + ", " + y + ", " + index + ");";
+                    } 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 + ");";
+                    }
                     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.gpr20);
-                    coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
+                    if (depth_compare) {
+                        if (is_array) {
+                            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);
+                            const std::string z = regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
+                            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 + ");";
+                        }
+                    } else {
+                        if (is_array) {
+                            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.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 + ");";
+                        }
+                    }
                     break;
                 }
                 default:
@@ -2086,7 +2416,7 @@ private:
                 std::string op_c;
 
                 const std::string sampler =
-                    GetSampler(instr.sampler, texture_type, false, depth_compare);
+                    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.
 
@@ -2106,10 +2436,13 @@ private:
                 }
                 case Tegra::Shader::TextureProcessMode::LB:
                 case Tegra::Shader::TextureProcessMode::LBA: {
-                    if (num_coordinates <= 2) {
-                        op_c = regs.GetRegisterAsFloat(instr.gpr20);
+                    if (depth_compare) {
+                        if (is_array)
+                            op_c = regs.GetRegisterAsFloat(instr.gpr20.Value() + 2);
+                        else
+                            op_c = regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
                     } else {
-                        op_c = regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
+                        op_c = regs.GetRegisterAsFloat(instr.gpr20);
                     }
                     // TODO: Figure if A suffix changes the equation at all.
                     texture = "texture(" + sampler + ", coords, " + op_c + ')';
@@ -2252,6 +2585,8 @@ private:
                 ASSERT_MSG(!instr.tlds.UsesMiscMode(Tegra::Shader::TextureMiscMode::MZ),
                            "MZ is not implemented");
 
+                u32 op_c_offset = 0;
+
                 switch (texture_type) {
                 case Tegra::Shader::TextureType::Texture1D: {
                     const std::string x = regs.GetRegisterAsInteger(instr.gpr8);
@@ -2266,6 +2601,7 @@ private:
                         const std::string x = regs.GetRegisterAsInteger(instr.gpr8);
                         const std::string y = regs.GetRegisterAsInteger(instr.gpr20);
                         coord = "ivec2 coords = ivec2(" + x + ", " + y + ");";
+                        op_c_offset = 1;
                     }
                     break;
                 }
@@ -2277,13 +2613,14 @@ private:
                 const std::string sampler =
                     GetSampler(instr.sampler, texture_type, is_array, false);
                 std::string texture = "texelFetch(" + sampler + ", coords, 0)";
-                const std::string op_c = regs.GetRegisterAsInteger(instr.gpr20.Value() + 1);
                 switch (instr.tlds.GetTextureProcessMode()) {
                 case Tegra::Shader::TextureProcessMode::LZ: {
                     texture = "texelFetch(" + sampler + ", coords, 0)";
                     break;
                 }
                 case Tegra::Shader::TextureProcessMode::LL: {
+                    const std::string op_c =
+                        regs.GetRegisterAsInteger(instr.gpr20.Value() + op_c_offset);
                     texture = "texelFetch(" + sampler + ", coords, " + op_c + ')';
                     break;
                 }
@@ -2479,20 +2816,13 @@ private:
             break;
         }
         case OpCode::Type::FloatSetPredicate: {
-            std::string op_a = instr.fsetp.neg_a ? "-" : "";
-            op_a += regs.GetRegisterAsFloat(instr.gpr8);
-
-            if (instr.fsetp.abs_a) {
-                op_a = "abs(" + op_a + ')';
-            }
+            const std::string op_a =
+                GetOperandAbsNeg(regs.GetRegisterAsFloat(instr.gpr8), instr.fsetp.abs_a != 0,
+                                 instr.fsetp.neg_a != 0);
 
-            std::string op_b{};
+            std::string op_b;
 
             if (instr.is_b_imm) {
-                if (instr.fsetp.neg_b) {
-                    // Only the immediate version of fsetp has a neg_b bit.
-                    op_b += '-';
-                }
                 op_b += '(' + GetImmediate19(instr) + ')';
             } else {
                 if (instr.is_b_gpr) {
@@ -2565,6 +2895,51 @@ private:
             }
             break;
         }
+        case OpCode::Type::HalfSetPredicate: {
+            ASSERT_MSG(instr.hsetp2.ftz == 0, "Unimplemented");
+
+            const std::string op_a =
+                GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr8, 0, false), instr.hsetp2.type_a,
+                             instr.hsetp2.abs_a, instr.hsetp2.negate_a);
+
+            const std::string op_b = [&]() {
+                switch (opcode->GetId()) {
+                case OpCode::Id::HSETP2_R:
+                    return GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr20, 0, false),
+                                        instr.hsetp2.type_b, instr.hsetp2.abs_a,
+                                        instr.hsetp2.negate_b);
+                default:
+                    UNREACHABLE();
+                    return std::string("vec2(0)");
+                }
+            }();
+
+            // We can't use the constant predicate as destination.
+            ASSERT(instr.hsetp2.pred3 != static_cast<u64>(Pred::UnusedIndex));
+
+            const std::string second_pred =
+                GetPredicateCondition(instr.hsetp2.pred39, instr.hsetp2.neg_pred != 0);
+
+            const std::string combiner = GetPredicateCombiner(instr.hsetp2.op);
+
+            const std::string component_combiner = instr.hsetp2.h_and ? "&&" : "||";
+            const std::string predicate =
+                '(' + GetPredicateComparison(instr.hsetp2.cond, op_a + ".x", op_b + ".x") + ' ' +
+                component_combiner + ' ' +
+                GetPredicateComparison(instr.hsetp2.cond, op_a + ".y", op_b + ".y") + ')';
+
+            // Set the primary predicate to the result of Predicate OP SecondPredicate
+            SetPredicate(instr.hsetp2.pred3,
+                         '(' + predicate + ") " + combiner + " (" + second_pred + ')');
+
+            if (instr.hsetp2.pred0 != static_cast<u64>(Pred::UnusedIndex)) {
+                // Set the secondary predicate to the result of !Predicate OP SecondPredicate,
+                // if enabled
+                SetPredicate(instr.hsetp2.pred0,
+                             "!(" + predicate + ") " + combiner + " (" + second_pred + ')');
+            }
+            break;
+        }
         case OpCode::Type::PredicateSetRegister: {
             const std::string op_a =
                 GetPredicateCondition(instr.pset.pred12, instr.pset.neg_pred12 != 0);
@@ -2643,33 +3018,24 @@ private:
             break;
         }
         case OpCode::Type::FloatSet: {
-            std::string op_a = instr.fset.neg_a ? "-" : "";
-            op_a += regs.GetRegisterAsFloat(instr.gpr8);
+            const std::string op_a = GetOperandAbsNeg(regs.GetRegisterAsFloat(instr.gpr8),
+                                                      instr.fset.abs_a != 0, instr.fset.neg_a != 0);
 
-            if (instr.fset.abs_a) {
-                op_a = "abs(" + op_a + ')';
-            }
-
-            std::string op_b = instr.fset.neg_b ? "-" : "";
+            std::string op_b;
 
             if (instr.is_b_imm) {
                 const std::string imm = GetImmediate19(instr);
-                if (instr.fset.neg_imm)
-                    op_b += "(-" + imm + ')';
-                else
-                    op_b += imm;
+                op_b = imm;
             } else {
                 if (instr.is_b_gpr) {
-                    op_b += regs.GetRegisterAsFloat(instr.gpr20);
+                    op_b = regs.GetRegisterAsFloat(instr.gpr20);
                 } else {
-                    op_b += regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
-                                            GLSLRegister::Type::Float);
+                    op_b = regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
+                                           GLSLRegister::Type::Float);
                 }
             }
 
-            if (instr.fset.abs_b) {
-                op_b = "abs(" + op_b + ')';
-            }
+            op_b = GetOperandAbsNeg(op_b, instr.fset.abs_b != 0, instr.fset.neg_b != 0);
 
             // The fset instruction sets a register to 1.0 or -1 (depending on the bf bit) if the
             // condition is true, and to 0 otherwise.
@@ -2725,6 +3091,50 @@ private:
             }
             break;
         }
+        case OpCode::Type::HalfSet: {
+            ASSERT_MSG(instr.hset2.ftz == 0, "Unimplemented");
+
+            const std::string op_a =
+                GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr8, 0, false), instr.hset2.type_a,
+                             instr.hset2.abs_a != 0, instr.hset2.negate_a != 0);
+
+            const std::string op_b = [&]() {
+                switch (opcode->GetId()) {
+                case OpCode::Id::HSET2_R:
+                    return GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr20, 0, false),
+                                        instr.hset2.type_b, instr.hset2.abs_b != 0,
+                                        instr.hset2.negate_b != 0);
+                default:
+                    UNREACHABLE();
+                    return std::string("vec2(0)");
+                }
+            }();
+
+            const std::string second_pred =
+                GetPredicateCondition(instr.hset2.pred39, instr.hset2.neg_pred != 0);
+
+            const std::string combiner = GetPredicateCombiner(instr.hset2.op);
+
+            // HSET2 operates on each half float in the pack.
+            std::string result;
+            for (int i = 0; i < 2; ++i) {
+                const std::string float_value = i == 0 ? "0x00003c00" : "0x3c000000";
+                const std::string integer_value = i == 0 ? "0x0000ffff" : "0xffff0000";
+                const std::string value = instr.hset2.bf == 1 ? float_value : integer_value;
+
+                const std::string comp = std::string(".") + "xy"[i];
+                const std::string predicate =
+                    "((" + GetPredicateComparison(instr.hset2.cond, op_a + comp, op_b + comp) +
+                    ") " + combiner + " (" + second_pred + "))";
+
+                result += '(' + predicate + " ? " + value + " : 0)";
+                if (i == 0) {
+                    result += " | ";
+                }
+            }
+            regs.SetRegisterToInteger(instr.gpr0, false, 0, '(' + result + ')', 1, 1);
+            break;
+        }
         case OpCode::Type::Xmad: {
             ASSERT_MSG(!instr.xmad.sign_a, "Unimplemented");
             ASSERT_MSG(!instr.xmad.sign_b, "Unimplemented");
@@ -2933,16 +3343,32 @@ private:
                 // The SSY opcode tells the GPU where to re-converge divergent execution paths, it
                 // sets the target of the jump that the SYNC instruction will make. The SSY opcode
                 // has a similar structure to the BRA opcode.
-                ASSERT_MSG(instr.bra.constant_buffer == 0, "Constant buffer SSY is not supported");
+                ASSERT_MSG(instr.bra.constant_buffer == 0, "Constant buffer flow is not supported");
+
+                const u32 target = offset + instr.bra.GetBranchTarget();
+                EmitPushToFlowStack(target);
+                break;
+            }
+            case OpCode::Id::PBK: {
+                // PBK pushes to a stack the address where BRK will jump to. This shares stack with
+                // SSY but using SYNC on a PBK address will kill the shader execution. We don't
+                // emulate this because it's very unlikely a driver will emit such invalid shader.
+                ASSERT_MSG(instr.bra.constant_buffer == 0, "Constant buffer PBK is not supported");
 
                 const u32 target = offset + instr.bra.GetBranchTarget();
-                EmitPushToSSYStack(target);
+                EmitPushToFlowStack(target);
                 break;
             }
             case OpCode::Id::SYNC: {
                 // The SYNC opcode jumps to the address previously set by the SSY opcode
                 ASSERT(instr.flow.cond == Tegra::Shader::FlowCondition::Always);
-                EmitPopFromSSYStack();
+                EmitPopFromFlowStack();
+                break;
+            }
+            case OpCode::Id::BRK: {
+                // The BRK opcode jumps to the address previously set by the PBK opcode
+                ASSERT(instr.flow.cond == Tegra::Shader::FlowCondition::Always);
+                EmitPopFromFlowStack();
                 break;
             }
             case OpCode::Id::DEPBAR: {
@@ -2952,87 +3378,51 @@ private:
                 break;
             }
             case OpCode::Id::VMAD: {
-                const bool signed_a = instr.vmad.signed_a == 1;
-                const bool signed_b = instr.vmad.signed_b == 1;
-                const bool result_signed = signed_a || signed_b;
-                boost::optional<std::string> forced_result;
-
-                auto Unpack = [&](const std::string& op, bool is_chunk, bool is_signed,
-                                  Tegra::Shader::VmadType type, u64 byte_height) {
-                    const std::string value = [&]() {
-                        if (!is_chunk) {
-                            const auto offset = static_cast<u32>(byte_height * 8);
-                            return "((" + op + " >> " + std::to_string(offset) + ") & 0xff)";
-                        }
-                        const std::string zero = "0";
-
-                        switch (type) {
-                        case Tegra::Shader::VmadType::Size16_Low:
-                            return '(' + op + " & 0xffff)";
-                        case Tegra::Shader::VmadType::Size16_High:
-                            return '(' + op + " >> 16)";
-                        case Tegra::Shader::VmadType::Size32:
-                            // TODO(Rodrigo): From my hardware tests it becomes a bit "mad" when
-                            // this type is used (1 * 1 + 0 == 0x5b800000). Until a better
-                            // explanation is found: assert.
-                            UNREACHABLE_MSG("Unimplemented");
-                            return zero;
-                        case Tegra::Shader::VmadType::Invalid:
-                            // Note(Rodrigo): This flag is invalid according to nvdisasm. From my
-                            // testing (even though it's invalid) this makes the whole instruction
-                            // assign zero to target register.
-                            forced_result = boost::make_optional(zero);
-                            return zero;
-                        default:
-                            UNREACHABLE();
-                            return zero;
-                        }
-                    }();
-
-                    if (is_signed) {
-                        return "int(" + value + ')';
-                    }
-                    return value;
-                };
-
-                const std::string op_a = Unpack(regs.GetRegisterAsInteger(instr.gpr8, 0, false),
-                                                instr.vmad.is_byte_chunk_a != 0, signed_a,
-                                                instr.vmad.type_a, instr.vmad.byte_height_a);
-
-                std::string op_b;
-                if (instr.vmad.use_register_b) {
-                    op_b = Unpack(regs.GetRegisterAsInteger(instr.gpr20, 0, false),
-                                  instr.vmad.is_byte_chunk_b != 0, signed_b, instr.vmad.type_b,
-                                  instr.vmad.byte_height_b);
-                } else {
-                    op_b = '(' +
-                           std::to_string(signed_b ? static_cast<s16>(instr.alu.GetImm20_16())
-                                                   : instr.alu.GetImm20_16()) +
-                           ')';
-                }
-
+                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);
                 const std::string op_c = regs.GetRegisterAsInteger(instr.gpr39, 0, result_signed);
 
-                std::string result;
-                if (forced_result) {
-                    result = *forced_result;
-                } else {
-                    result = '(' + op_a + " * " + op_b + " + " + op_c + ')';
+                std::string result = '(' + op_a + " * " + op_b + " + " + op_c + ')';
 
-                    switch (instr.vmad.shr) {
-                    case Tegra::Shader::VmadShr::Shr7:
-                        result = '(' + result + " >> 7)";
-                        break;
-                    case Tegra::Shader::VmadShr::Shr15:
-                        result = '(' + result + " >> 15)";
-                        break;
-                    }
+                switch (instr.vmad.shr) {
+                case Tegra::Shader::VmadShr::Shr7:
+                    result = '(' + result + " >> 7)";
+                    break;
+                case Tegra::Shader::VmadShr::Shr15:
+                    result = '(' + result + " >> 15)";
+                    break;
                 }
+
                 regs.SetRegisterToInteger(instr.gpr0, result_signed, 1, result, 1, 1,
                                           instr.vmad.saturate == 1, 0, Register::Size::Word,
                                           instr.vmad.cc);
                 break;
             }
+            case OpCode::Id::VSETP: {
+                const std::string op_a = GetVideoOperandA(instr);
+                const std::string op_b = GetVideoOperandB(instr);
+
+                // We can't use the constant predicate as destination.
+                ASSERT(instr.vsetp.pred3 != static_cast<u64>(Pred::UnusedIndex));
+
+                const std::string second_pred = GetPredicateCondition(instr.vsetp.pred39, false);
+
+                const std::string combiner = GetPredicateCombiner(instr.vsetp.op);
+
+                const std::string predicate = GetPredicateComparison(instr.vsetp.cond, op_a, op_b);
+                // Set the primary predicate to the result of Predicate OP SecondPredicate
+                SetPredicate(instr.vsetp.pred3,
+                             '(' + predicate + ") " + combiner + " (" + second_pred + ')');
+
+                if (instr.vsetp.pred0 != static_cast<u64>(Pred::UnusedIndex)) {
+                    // Set the secondary predicate to the result of !Predicate OP SecondPredicate,
+                    // if enabled
+                    SetPredicate(instr.vsetp.pred0,
+                                 "!(" + predicate + ") " + combiner + " (" + second_pred + ')');
+                }
+                break;
+            }
             default: {
                 LOG_CRITICAL(HW_GPU, "Unhandled instruction: {}", opcode->GetName());
                 UNREACHABLE();
@@ -3096,11 +3486,11 @@ private:
                 labels.insert(subroutine.begin);
                 shader.AddLine("uint jmp_to = " + std::to_string(subroutine.begin) + "u;");
 
-                // TODO(Subv): Figure out the actual depth of the SSY stack, for now it seems
-                // unlikely that shaders will use 20 nested SSYs.
-                constexpr u32 SSY_STACK_SIZE = 20;
-                shader.AddLine("uint ssy_stack[" + std::to_string(SSY_STACK_SIZE) + "];");
-                shader.AddLine("uint ssy_stack_top = 0u;");
+                // TODO(Subv): Figure out the actual depth of the flow stack, for now it seems
+                // unlikely that shaders will use 20 nested SSYs and PBKs.
+                constexpr u32 FLOW_STACK_SIZE = 20;
+                shader.AddLine("uint flow_stack[" + std::to_string(FLOW_STACK_SIZE) + "];");
+                shader.AddLine("uint flow_stack_top = 0u;");
 
                 shader.AddLine("while (true) {");
                 ++shader.scope;
@@ -3167,7 +3557,7 @@ private:
 
     // Declarations
     std::set<std::string> declr_predicates;
-}; // namespace Decompiler
+}; // namespace OpenGL::GLShader::Decompiler
 
 std::string GetCommonDeclarations() {
     return fmt::format("#define MAX_CONSTBUFFER_ELEMENTS {}\n",
diff --git a/src/video_core/renderer_opengl/gl_shader_gen.cpp b/src/video_core/renderer_opengl/gl_shader_gen.cpp
index 1e5eb32df..e883ffb1d 100644
--- a/src/video_core/renderer_opengl/gl_shader_gen.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_gen.cpp
@@ -23,10 +23,13 @@ out gl_PerVertex {
     vec4 gl_Position;
 };
 
+layout (location = 0) out vec4 position;
+
 layout(std140) uniform vs_config {
     vec4 viewport_flip;
     uvec4 instance_id;
     uvec4 flip_stage;
+    uvec4 alpha_test;
 };
 )";
 
@@ -96,10 +99,14 @@ out gl_PerVertex {
     vec4 gl_Position;
 };
 
+layout (location = 0) in vec4 gs_position[];
+layout (location = 0) out vec4 position;
+
 layout (std140) uniform gs_config {
     vec4 viewport_flip;
     uvec4 instance_id;
     uvec4 flip_stage;
+    uvec4 alpha_test;
 };
 
 void main() {
@@ -131,12 +138,39 @@ layout(location = 5) out vec4 FragColor5;
 layout(location = 6) out vec4 FragColor6;
 layout(location = 7) out vec4 FragColor7;
 
+layout (location = 0) in vec4 position;
+
 layout (std140) uniform fs_config {
     vec4 viewport_flip;
     uvec4 instance_id;
     uvec4 flip_stage;
+    uvec4 alpha_test;
 };
 
+bool AlphaFunc(in float value) {
+    float ref = uintBitsToFloat(alpha_test[2]);
+    switch (alpha_test[1]) {
+        case 1:
+            return false;
+        case 2:
+            return value < ref;
+        case 3:
+            return value == ref;
+        case 4:
+            return value <= ref;
+        case 5:
+            return value > ref;
+        case 6:
+            return value != ref;
+        case 7:
+            return value >= ref;
+        case 8:
+            return true;
+        default:
+            return false;
+    }
+}
+
 void main() {
     exec_fragment();
 }
@@ -145,4 +179,4 @@ void main() {
     out += program.first;
     return {out, program.second};
 }
-} // namespace OpenGL::GLShader
\ No newline at end of file
+} // namespace OpenGL::GLShader
diff --git a/src/video_core/renderer_opengl/gl_shader_gen.h b/src/video_core/renderer_opengl/gl_shader_gen.h
index 79596087a..520b9d4e3 100644
--- a/src/video_core/renderer_opengl/gl_shader_gen.h
+++ b/src/video_core/renderer_opengl/gl_shader_gen.h
@@ -16,6 +16,8 @@ namespace OpenGL::GLShader {
 constexpr std::size_t MAX_PROGRAM_CODE_LENGTH{0x1000};
 using ProgramCode = std::vector<u64>;
 
+enum : u32 { POSITION_VARYING_LOCATION = 0, GENERIC_VARYING_START_LOCATION = 1 };
+
 class ConstBufferEntry {
     using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 
diff --git a/src/video_core/renderer_opengl/gl_shader_manager.cpp b/src/video_core/renderer_opengl/gl_shader_manager.cpp
index 010857ec6..8b8869ecb 100644
--- a/src/video_core/renderer_opengl/gl_shader_manager.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_manager.cpp
@@ -16,6 +16,17 @@ void MaxwellUniformData::SetFromRegs(const Maxwell3D::State::ShaderStageInfo& sh
     viewport_flip[0] = regs.viewport_transform[0].scale_x < 0.0 ? -1.0f : 1.0f;
     viewport_flip[1] = regs.viewport_transform[0].scale_y < 0.0 ? -1.0f : 1.0f;
 
+    u32 func = static_cast<u32>(regs.alpha_test_func);
+    // Normalize the gl variants of opCompare to be the same as the normal variants
+    u32 op_gl_variant_base = static_cast<u32>(Tegra::Engines::Maxwell3D::Regs::ComparisonOp::Never);
+    if (func >= op_gl_variant_base) {
+        func = func - op_gl_variant_base + 1U;
+    }
+
+    alpha_test.enabled = regs.alpha_test_enabled;
+    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[0] = state.current_instance;
 
diff --git a/src/video_core/renderer_opengl/gl_shader_manager.h b/src/video_core/renderer_opengl/gl_shader_manager.h
index b3a191cf2..36fe1f04c 100644
--- a/src/video_core/renderer_opengl/gl_shader_manager.h
+++ b/src/video_core/renderer_opengl/gl_shader_manager.h
@@ -22,8 +22,14 @@ struct MaxwellUniformData {
     alignas(16) GLvec4 viewport_flip;
     alignas(16) GLuvec4 instance_id;
     alignas(16) GLuvec4 flip_stage;
+    struct alignas(16) {
+        GLuint enabled;
+        GLuint func;
+        GLfloat ref;
+        GLuint padding;
+    } alpha_test;
 };
-static_assert(sizeof(MaxwellUniformData) == 48, "MaxwellUniformData structure size is incorrect");
+static_assert(sizeof(MaxwellUniformData) == 64, "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/maxwell_to_gl.h b/src/video_core/renderer_opengl/maxwell_to_gl.h
index 3c3bcaae4..0f6dcab2b 100644
--- a/src/video_core/renderer_opengl/maxwell_to_gl.h
+++ b/src/video_core/renderer_opengl/maxwell_to_gl.h
@@ -82,8 +82,20 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
         return {};
     }
 
-    case Maxwell::VertexAttribute::Type::Float:
-        return GL_FLOAT;
+    case Maxwell::VertexAttribute::Type::Float: {
+        switch (attrib.size) {
+        case Maxwell::VertexAttribute::Size::Size_16:
+        case Maxwell::VertexAttribute::Size::Size_16_16:
+        case Maxwell::VertexAttribute::Size::Size_16_16_16:
+        case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
+            return GL_HALF_FLOAT;
+        case Maxwell::VertexAttribute::Size::Size_32:
+        case Maxwell::VertexAttribute::Size::Size_32_32:
+        case Maxwell::VertexAttribute::Size::Size_32_32_32:
+        case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
+            return GL_FLOAT;
+        }
+    }
     }
 
     LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex type={}", attrib.TypeString());
diff --git a/src/video_core/textures/decoders.cpp b/src/video_core/textures/decoders.cpp
index 18ab723f7..f1b40e7f5 100644
--- a/src/video_core/textures/decoders.cpp
+++ b/src/video_core/textures/decoders.cpp
@@ -237,6 +237,46 @@ std::vector<u8> UnswizzleTexture(VAddr address, u32 tile_size, u32 bytes_per_pix
     return unswizzled_data;
 }
 
+void SwizzleSubrect(u32 subrect_width, u32 subrect_height, u32 source_pitch, u32 swizzled_width,
+                    u32 bytes_per_pixel, VAddr swizzled_data, VAddr unswizzled_data,
+                    u32 block_height) {
+    const u32 image_width_in_gobs{(swizzled_width * bytes_per_pixel + 63) / 64};
+    for (u32 line = 0; line < subrect_height; ++line) {
+        const u32 gob_address_y =
+            (line / (8 * block_height)) * 512 * block_height * image_width_in_gobs +
+            (line % (8 * block_height) / 8) * 512;
+        const auto& table = legacy_swizzle_table[line % 8];
+        for (u32 x = 0; x < subrect_width; ++x) {
+            const u32 gob_address = gob_address_y + (x * bytes_per_pixel / 64) * 512 * block_height;
+            const u32 swizzled_offset = gob_address + table[(x * bytes_per_pixel) % 64];
+            const VAddr source_line = unswizzled_data + line * source_pitch + x * bytes_per_pixel;
+            const VAddr dest_addr = swizzled_data + swizzled_offset;
+
+            Memory::CopyBlock(dest_addr, source_line, bytes_per_pixel);
+        }
+    }
+}
+
+void UnswizzleSubrect(u32 subrect_width, u32 subrect_height, u32 dest_pitch, u32 swizzled_width,
+                      u32 bytes_per_pixel, VAddr swizzled_data, VAddr unswizzled_data,
+                      u32 block_height, u32 offset_x, u32 offset_y) {
+    for (u32 line = 0; line < subrect_height; ++line) {
+        const u32 y2 = line + offset_y;
+        const u32 gob_address_y =
+            (y2 / (8 * block_height)) * 512 * block_height + (y2 % (8 * block_height) / 8) * 512;
+        const auto& table = legacy_swizzle_table[y2 % 8];
+        for (u32 x = 0; x < subrect_width; ++x) {
+            const u32 x2 = (x + offset_x) * bytes_per_pixel;
+            const u32 gob_address = gob_address_y + (x2 / 64) * 512 * block_height;
+            const u32 swizzled_offset = gob_address + table[x2 % 64];
+            const VAddr dest_line = unswizzled_data + line * dest_pitch + x * bytes_per_pixel;
+            const VAddr source_addr = swizzled_data + swizzled_offset;
+
+            Memory::CopyBlock(dest_line, source_addr, bytes_per_pixel);
+        }
+    }
+}
+
 std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat format, u32 width,
                               u32 height) {
     std::vector<u8> rgba_data;
diff --git a/src/video_core/textures/decoders.h b/src/video_core/textures/decoders.h
index aaf316947..4726f54a5 100644
--- a/src/video_core/textures/decoders.h
+++ b/src/video_core/textures/decoders.h
@@ -35,4 +35,13 @@ std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat
 std::size_t CalculateSize(bool tiled, u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
                           u32 block_height, u32 block_depth);
 
+/// Copies an untiled subrectangle into a tiled surface.
+void SwizzleSubrect(u32 subrect_width, u32 subrect_height, u32 source_pitch, u32 swizzled_width,
+                    u32 bytes_per_pixel, VAddr swizzled_data, VAddr unswizzled_data,
+                    u32 block_height);
+/// Copies a tiled subrectangle into a linear surface.
+void UnswizzleSubrect(u32 subrect_width, u32 subrect_height, u32 dest_pitch, u32 swizzled_width,
+                      u32 bytes_per_pixel, VAddr swizzled_data, VAddr unswizzled_data,
+                      u32 block_height, u32 offset_x, u32 offset_y);
+
 } // namespace Tegra::Texture
diff --git a/src/web_service/CMakeLists.txt b/src/web_service/CMakeLists.txt
index 1c83e9c34..01f2d129d 100644
--- a/src/web_service/CMakeLists.txt
+++ b/src/web_service/CMakeLists.txt
@@ -10,7 +10,7 @@ add_library(web_service STATIC
 create_target_directory_groups(web_service)
 
 get_directory_property(OPENSSL_LIBS
-        DIRECTORY ${CMAKE_SOURCE_DIR}/externals/libressl
+        DIRECTORY ${PROJECT_SOURCE_DIR}/externals/libressl
         DEFINITION OPENSSL_LIBS)
-target_compile_definitions(web_service PUBLIC -DCPPHTTPLIB_OPENSSL_SUPPORT)
+target_compile_definitions(web_service PRIVATE -DCPPHTTPLIB_OPENSSL_SUPPORT)
 target_link_libraries(web_service PRIVATE common json-headers ${OPENSSL_LIBS} httplib lurlparser)
diff --git a/src/yuzu/CMakeLists.txt b/src/yuzu/CMakeLists.txt
index 04464ad5e..9379d9110 100644
--- a/src/yuzu/CMakeLists.txt
+++ b/src/yuzu/CMakeLists.txt
@@ -82,10 +82,10 @@ set(UIS
 )
 
 file(GLOB COMPAT_LIST
-     ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
-     ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
-file(GLOB_RECURSE ICONS ${CMAKE_SOURCE_DIR}/dist/icons/*)
-file(GLOB_RECURSE THEMES ${CMAKE_SOURCE_DIR}/dist/qt_themes/*)
+     ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
+     ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
+file(GLOB_RECURSE ICONS ${PROJECT_SOURCE_DIR}/dist/icons/*)
+file(GLOB_RECURSE THEMES ${PROJECT_SOURCE_DIR}/dist/qt_themes/*)
 
 qt5_wrap_ui(UI_HDRS ${UIS})
 
@@ -121,7 +121,7 @@ target_link_libraries(yuzu PRIVATE Boost::boost glad Qt5::OpenGL Qt5::Widgets)
 target_link_libraries(yuzu PRIVATE ${PLATFORM_LIBRARIES} Threads::Threads)
 
 if (YUZU_ENABLE_COMPATIBILITY_REPORTING)
-    add_definitions(-DYUZU_ENABLE_COMPATIBILITY_REPORTING)
+    target_compile_definitions(yuzu PRIVATE -DYUZU_ENABLE_COMPATIBILITY_REPORTING)
 endif()
 
 if (USE_DISCORD_PRESENCE)
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index 7fec15991..71c6ebb41 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -85,8 +85,8 @@ void Config::ReadValues() {
     Settings::values.resolution_factor = qt_config->value("resolution_factor", 1.0).toFloat();
     Settings::values.use_frame_limit = qt_config->value("use_frame_limit", true).toBool();
     Settings::values.frame_limit = qt_config->value("frame_limit", 100).toInt();
-    Settings::values.use_accurate_framebuffers =
-        qt_config->value("use_accurate_framebuffers", false).toBool();
+    Settings::values.use_accurate_gpu_emulation =
+        qt_config->value("use_accurate_gpu_emulation", false).toBool();
 
     Settings::values.bg_red = qt_config->value("bg_red", 0.0).toFloat();
     Settings::values.bg_green = qt_config->value("bg_green", 0.0).toFloat();
@@ -233,7 +233,7 @@ void Config::SaveValues() {
     qt_config->setValue("resolution_factor", (double)Settings::values.resolution_factor);
     qt_config->setValue("use_frame_limit", Settings::values.use_frame_limit);
     qt_config->setValue("frame_limit", Settings::values.frame_limit);
-    qt_config->setValue("use_accurate_framebuffers", Settings::values.use_accurate_framebuffers);
+    qt_config->setValue("use_accurate_gpu_emulation", Settings::values.use_accurate_gpu_emulation);
 
     // Cast to double because Qt's written float values are not human-readable
     qt_config->setValue("bg_red", (double)Settings::values.bg_red);
diff --git a/src/yuzu/configuration/configure_graphics.cpp b/src/yuzu/configuration/configure_graphics.cpp
index cd1549462..8290b4384 100644
--- a/src/yuzu/configuration/configure_graphics.cpp
+++ b/src/yuzu/configuration/configure_graphics.cpp
@@ -75,7 +75,7 @@ void ConfigureGraphics::setConfiguration() {
         static_cast<int>(FromResolutionFactor(Settings::values.resolution_factor)));
     ui->toggle_frame_limit->setChecked(Settings::values.use_frame_limit);
     ui->frame_limit->setValue(Settings::values.frame_limit);
-    ui->use_accurate_framebuffers->setChecked(Settings::values.use_accurate_framebuffers);
+    ui->use_accurate_gpu_emulation->setChecked(Settings::values.use_accurate_gpu_emulation);
     bg_color = QColor::fromRgbF(Settings::values.bg_red, Settings::values.bg_green,
                                 Settings::values.bg_blue);
     ui->bg_button->setStyleSheet(
@@ -87,7 +87,7 @@ void ConfigureGraphics::applyConfiguration() {
         ToResolutionFactor(static_cast<Resolution>(ui->resolution_factor_combobox->currentIndex()));
     Settings::values.use_frame_limit = ui->toggle_frame_limit->isChecked();
     Settings::values.frame_limit = ui->frame_limit->value();
-    Settings::values.use_accurate_framebuffers = ui->use_accurate_framebuffers->isChecked();
+    Settings::values.use_accurate_gpu_emulation = ui->use_accurate_gpu_emulation->isChecked();
     Settings::values.bg_red = static_cast<float>(bg_color.redF());
     Settings::values.bg_green = static_cast<float>(bg_color.greenF());
     Settings::values.bg_blue = static_cast<float>(bg_color.blueF());
diff --git a/src/yuzu/configuration/configure_graphics.ui b/src/yuzu/configuration/configure_graphics.ui
index 8fc00af1b..91fcad994 100644
--- a/src/yuzu/configuration/configure_graphics.ui
+++ b/src/yuzu/configuration/configure_graphics.ui
@@ -50,9 +50,9 @@
           </layout>
         </item>
         <item>
-         <widget class="QCheckBox" name="use_accurate_framebuffers">
+         <widget class="QCheckBox" name="use_accurate_gpu_emulation">
           <property name="text">
-           <string>Use accurate framebuffers (slow)</string>
+           <string>Use accurate GPU emulation (slow)</string>
           </property>
          </widget>
         </item>
diff --git a/src/yuzu/debugger/wait_tree.cpp b/src/yuzu/debugger/wait_tree.cpp
index 7403e9ccd..0c831c9f4 100644
--- a/src/yuzu/debugger/wait_tree.cpp
+++ b/src/yuzu/debugger/wait_tree.cpp
@@ -9,8 +9,8 @@
 #include "core/core.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/handle_table.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/mutex.h"
+#include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/timer.h"
@@ -83,7 +83,7 @@ QString WaitTreeText::GetText() const {
 }
 
 WaitTreeMutexInfo::WaitTreeMutexInfo(VAddr mutex_address) : mutex_address(mutex_address) {
-    auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
 
     mutex_value = Memory::Read32(mutex_address);
     owner_handle = static_cast<Kernel::Handle>(mutex_value & Kernel::Mutex::MutexOwnerMask);
diff --git a/src/yuzu/main.ui b/src/yuzu/main.ui
index 9851f507d..dffd9c788 100644
--- a/src/yuzu/main.ui
+++ b/src/yuzu/main.ui
@@ -97,18 +97,24 @@
     <addaction name="action_Show_Status_Bar"/>
     <addaction name="menu_View_Debugging"/>
    </widget>
+   <widget class ="QMenu" name="menu_Tools">
+    <property name="title">
+     <string>Tools</string>
+    </property>
+    <addaction name="action_Rederive" />
+   </widget>
    <widget class="QMenu" name="menu_Help">
     <property name="title">
      <string>&amp;Help</string>
     </property>
     <addaction name="action_Report_Compatibility"/>
     <addaction name="separator"/>
-     <addaction name="action_Rederive"/>
     <addaction name="action_About"/>
    </widget>
    <addaction name="menu_File"/>
    <addaction name="menu_Emulation"/>
    <addaction name="menu_View"/>
+   <addaction name="menu_Tools" />
    <addaction name="menu_Help"/>
   </widget>
    <action name="action_Install_File_NAND">
diff --git a/src/yuzu_cmd/config.cpp b/src/yuzu_cmd/config.cpp
index 2470f4640..5e42e48b2 100644
--- a/src/yuzu_cmd/config.cpp
+++ b/src/yuzu_cmd/config.cpp
@@ -99,8 +99,8 @@ void Config::ReadValues() {
     Settings::values.use_frame_limit = sdl2_config->GetBoolean("Renderer", "use_frame_limit", true);
     Settings::values.frame_limit =
         static_cast<u16>(sdl2_config->GetInteger("Renderer", "frame_limit", 100));
-    Settings::values.use_accurate_framebuffers =
-        sdl2_config->GetBoolean("Renderer", "use_accurate_framebuffers", false);
+    Settings::values.use_accurate_gpu_emulation =
+        sdl2_config->GetBoolean("Renderer", "use_accurate_gpu_emulation", false);
 
     Settings::values.bg_red = (float)sdl2_config->GetReal("Renderer", "bg_red", 0.0);
     Settings::values.bg_green = (float)sdl2_config->GetReal("Renderer", "bg_green", 0.0);
diff --git a/src/yuzu_cmd/default_ini.h b/src/yuzu_cmd/default_ini.h
index 762396e3b..a97b75f7b 100644
--- a/src/yuzu_cmd/default_ini.h
+++ b/src/yuzu_cmd/default_ini.h
@@ -110,9 +110,9 @@ use_frame_limit =
 # 1 - 9999: Speed limit as a percentage of target game speed. 100 (default)
 frame_limit =
 
-# Whether to use accurate framebuffers
+# Whether to use accurate GPU emulation
 # 0 (default): Off (fast), 1 : On (slow)
-use_accurate_framebuffers =
+use_accurate_gpu_emulation =
 
 # The clear color for the renderer. What shows up on the sides of the bottom screen.
 # Must be in range of 0.0-1.0. Defaults to 1.0 for all.