145 files changed, 2670 insertions, 2594 deletions
diff --git a/.gitignore b/.gitignore
index 7999a40e1..5ec0d110b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,6 +11,7 @@ src/common/scm_rev.cpp
 .idea/
 .vs/
 .vscode/
+CMakeLists.txt.user
 # *nix related
 # Common convention for backup or temporary files
diff --git a/CMakeModules/CopyYuzuQt5Deps.cmake b/CMakeModules/CopyYuzuQt5Deps.cmake
index ed24c742c..e4a9796c8 100644
--- a/CMakeModules/CopyYuzuQt5Deps.cmake
+++ b/CMakeModules/CopyYuzuQt5Deps.cmake
@@ -3,7 +3,9 @@ function(copy_yuzu_Qt5_deps target_dir)
    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
    set(Qt5_DLL_DIR "${Qt5_DIR}/../../../bin")
    set(Qt5_PLATFORMS_DIR "${Qt5_DIR}/../../../plugins/platforms/")
+    set(Qt5_STYLES_DIR "${Qt5_DIR}/../../../plugins/styles/")
    set(PLATFORMS ${DLL_DEST}platforms/)
+    set(STYLES ${DLL_DEST}styles/)
    windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
        icudt*.dll
        icuin*.dll
@@ -14,4 +16,5 @@ function(copy_yuzu_Qt5_deps target_dir)
        Qt5Widgets$<$<CONFIG:Debug>:d>.*
    )
    windows_copy_files(yuzu ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*)
+    windows_copy_files(yuzu ${Qt5_STYLES_DIR} ${STYLES} qwindowsvistastyle$<$<CONFIG:Debug>:d>.*)
 endfunction(copy_yuzu_Qt5_deps)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index ce0608db2..008dc5b50 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,6 +1,6 @@
 # Reporting Issues
-**The issue tracker is not a support forum.** Unless you can provide precise *technical information* regarding an issue, you *should not post in it*. If you need support, first read the [FAQ](https://github.com/yuzu-emu/yuzu/wiki/FAQ) and then either visit our Discord server, [our forum](https://community.citra-emu.org) or ask in a general emulation forum such as [/r/emulation](https://www.reddit.com/r/emulation/). If you post support questions, generic messages to the developers or vague reports without technical details, they will be closed and locked.
+**The issue tracker is not a support forum.** Unless you can provide precise *technical information* regarding an issue, you *should not post in it*. If you need support, first read the [FAQ](https://github.com/yuzu-emu/yuzu/wiki/FAQ) and then either visit our [Discord server](https://discordapp.com/invite/u77vRWY), [our forum](https://community.citra-emu.org) or ask in a general emulation forum such as [/r/emulation](https://www.reddit.com/r/emulation/). If you post support questions, generic messages to the developers or vague reports without technical details, they will be closed and locked.
 If you believe you have a valid issue report, please post text or a screenshot from the log (the console window that opens alongside yuzu) and build version (hex string visible in the titlebar and zip filename), as well as your hardware and software information if applicable.
diff --git a/appveyor.yml b/appveyor.yml
index 72cda26a7..17d1b5fee 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -116,6 +116,7 @@ after_build:
          mkdir $RELEASE_DIST
          mkdir $RELEASE_DIST/platforms
+          mkdir $RELEASE_DIST/styles
          # copy the compiled binaries and other release files to the release folder
          Get-ChildItem "$CMAKE_BINARY_DIR" -Filter "yuzu*.exe" | Copy-Item -destination $RELEASE_DIST
@@ -136,6 +137,9 @@ after_build:
          # copy the qt windows plugin dll to platforms
          Copy-Item -path "C:/msys64/mingw64/share/qt5/plugins/platforms/qwindows.dll" -force -destination "$RELEASE_DIST/platforms"
+          # copy the qt windows vista style dll to platforms
+          Copy-Item -path "C:/msys64/mingw64/share/qt5/plugins/styles/qwindowsvistastyle.dll" -force -destination "$RELEASE_DIST/styles"
          7z a -tzip $MINGW_BUILD_ZIP $RELEASE_DIST\*
          7z a $MINGW_SEVENZIP $RELEASE_DIST
        }
diff --git a/externals/dynarmic b/externals/dynarmic
-Subproject 990a569b7a5f2518fe08682f5ebf8536e5388d6
+Subproject f7d11baa1cba82f7926058bebdeb6b1c23cff8e
diff --git a/src/common/assert.h b/src/common/assert.h
index 3ee07f6a2..0d4eddc19 100644
--- a/src/common/assert.h
+++ b/src/common/assert.h
@@ -30,15 +30,14 @@ __declspec(noinline, noreturn)
 #define ASSERT(_a_)                                                                                \
    do                                                                                             \
        if (!(_a_)) {                                                                              \
-            assert_noinline_call([] { NGLOG_CRITICAL(Debug, "Assertion Failed!"); });              \
+            assert_noinline_call([] { LOG_CRITICAL(Debug, "Assertion Failed!"); });                \
        }                                                                                          \
    while (0)
 #define ASSERT_MSG(_a_, ...)                                                                       \
    do                                                                                             \
        if (!(_a_)) {                                                                              \
-            assert_noinline_call(                                                                  \
+            assert_noinline_call([&] { LOG_CRITICAL(Debug, "Assertion Failed!\n" __VA_ARGS__); }); \
-                [&] { NGLOG_CRITICAL(Debug, "Assertion Failed!\n" __VA_ARGS__); });                \
        }                                                                                          \
    while (0)
@@ -53,5 +52,5 @@ __declspec(noinline, noreturn)
 #define DEBUG_ASSERT_MSG(_a_, _desc_, ...)
 #endif
-#define UNIMPLEMENTED() DEBUG_ASSERT_MSG(false, "Unimplemented code!")
+#define UNIMPLEMENTED() LOG_CRITICAL(Debug, "Unimplemented code!")
 #define UNIMPLEMENTED_MSG(...) ASSERT_MSG(false, __VA_ARGS__)
diff --git a/src/common/common_funcs.h b/src/common/common_funcs.h
index 7cf7b7997..995938d0b 100644
--- a/src/common/common_funcs.h
+++ b/src/common/common_funcs.h
@@ -4,7 +4,7 @@
 #pragma once
-#if !defined(ARCHITECTURE_x86_64) && !defined(_M_ARM)
+#if !defined(ARCHITECTURE_x86_64) && !defined(ARCHITECTURE_ARM)
 #include <cstdlib> // for exit
 #endif
 #include "common/common_types.h"
@@ -30,7 +30,7 @@
 #ifdef ARCHITECTURE_x86_64
 #define Crash() __asm__ __volatile__("int $3")
-#elif defined(_M_ARM)
+#elif defined(ARCHITECTURE_ARM)
 #define Crash() __asm__ __volatile__("trap")
 #else
 #define Crash() exit(1)
diff --git a/src/common/common_paths.h b/src/common/common_paths.h
index 0a6132dab..9bf3efaf2 100644
--- a/src/common/common_paths.h
+++ b/src/common/common_paths.h
@@ -32,12 +32,15 @@
 #define SDMC_DIR "sdmc"
 #define NAND_DIR "nand"
 #define SYSDATA_DIR "sysdata"
+#define LOG_DIR "log"
 // Filenames
 // Files in the directory returned by GetUserPath(D_CONFIG_IDX)
 #define EMU_CONFIG "emu.ini"
 #define DEBUGGER_CONFIG "debugger.ini"
 #define LOGGER_CONFIG "logger.ini"
+// Files in the directory returned by GetUserPath(D_LOGS_IDX)
+#define LOG_FILE "yuzu_log.txt"
 // Sys files
 #define SHARED_FONT "shared_font.bin"
diff --git a/src/common/file_util.cpp b/src/common/file_util.cpp
index 2d0b81c6e..7213abe18 100644
--- a/src/common/file_util.cpp
+++ b/src/common/file_util.cpp
@@ -118,7 +118,7 @@ bool IsDirectory(const std::string& filename) {
 #endif
    if (result < 0) {
-        NGLOG_DEBUG(Common_Filesystem, "stat failed on {}: {}", filename, GetLastErrorMsg());
+        LOG_DEBUG(Common_Filesystem, "stat failed on {}: {}", filename, GetLastErrorMsg());
        return false;
    }
@@ -128,29 +128,29 @@ bool IsDirectory(const std::string& filename) {
 // Deletes a given filename, return true on success
 // Doesn't supports deleting a directory
 bool Delete(const std::string& filename) {
-    NGLOG_TRACE(Common_Filesystem, "file {}", filename);
+    LOG_TRACE(Common_Filesystem, "file {}", filename);
    // Return true because we care about the file no
    // being there, not the actual delete.
    if (!Exists(filename)) {
-        NGLOG_DEBUG(Common_Filesystem, "{} does not exist", filename);
+        LOG_DEBUG(Common_Filesystem, "{} does not exist", filename);
        return true;
    }
    // We can't delete a directory
    if (IsDirectory(filename)) {
-        NGLOG_ERROR(Common_Filesystem, "Failed: {} is a directory", filename);
+        LOG_ERROR(Common_Filesystem, "Failed: {} is a directory", filename);
        return false;
    }
 #ifdef _WIN32
    if (!DeleteFileW(Common::UTF8ToUTF16W(filename).c_str())) {
-        NGLOG_ERROR(Common_Filesystem, "DeleteFile failed on {}: {}", filename, GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "DeleteFile failed on {}: {}", filename, GetLastErrorMsg());
        return false;
    }
 #else
    if (unlink(filename.c_str()) == -1) {
-        NGLOG_ERROR(Common_Filesystem, "unlink failed on {}: {}", filename, GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "unlink failed on {}: {}", filename, GetLastErrorMsg());
        return false;
    }
 #endif
@@ -160,16 +160,16 @@ bool Delete(const std::string& filename) {
 // Returns true if successful, or path already exists.
 bool CreateDir(const std::string& path) {
-    NGLOG_TRACE(Common_Filesystem, "directory {}", path);
+    LOG_TRACE(Common_Filesystem, "directory {}", path);
 #ifdef _WIN32
    if (::CreateDirectoryW(Common::UTF8ToUTF16W(path).c_str(), nullptr))
        return true;
    DWORD error = GetLastError();
    if (error == ERROR_ALREADY_EXISTS) {
-        NGLOG_DEBUG(Common_Filesystem, "CreateDirectory failed on {}: already exists", path);
+        LOG_DEBUG(Common_Filesystem, "CreateDirectory failed on {}: already exists", path);
        return true;
    }
-    NGLOG_ERROR(Common_Filesystem, "CreateDirectory failed on {}: {}", path, error);
+    LOG_ERROR(Common_Filesystem, "CreateDirectory failed on {}: {}", path, error);
    return false;
 #else
    if (mkdir(path.c_str(), 0755) == 0)
@@ -178,11 +178,11 @@ bool CreateDir(const std::string& path) {
    int err = errno;
    if (err == EEXIST) {
-        NGLOG_DEBUG(Common_Filesystem, "mkdir failed on {}: already exists", path);
+        LOG_DEBUG(Common_Filesystem, "mkdir failed on {}: already exists", path);
        return true;
    }
-    NGLOG_ERROR(Common_Filesystem, "mkdir failed on {}: {}", path, strerror(err));
+    LOG_ERROR(Common_Filesystem, "mkdir failed on {}: {}", path, strerror(err));
    return false;
 #endif
 }
@@ -190,10 +190,10 @@ bool CreateDir(const std::string& path) {
 // Creates the full path of fullPath returns true on success
 bool CreateFullPath(const std::string& fullPath) {
    int panicCounter = 100;
-    NGLOG_TRACE(Common_Filesystem, "path {}", fullPath);
+    LOG_TRACE(Common_Filesystem, "path {}", fullPath);
    if (FileUtil::Exists(fullPath)) {
-        NGLOG_DEBUG(Common_Filesystem, "path exists {}", fullPath);
+        LOG_DEBUG(Common_Filesystem, "path exists {}", fullPath);
        return true;
    }
@@ -209,14 +209,14 @@ bool CreateFullPath(const std::string& fullPath) {
        // Include the '/' so the first call is CreateDir("/") rather than CreateDir("")
        std::string const subPath(fullPath.substr(0, position + 1));
        if (!FileUtil::IsDirectory(subPath) && !FileUtil::CreateDir(subPath)) {
-            NGLOG_ERROR(Common, "CreateFullPath: directory creation failed");
+            LOG_ERROR(Common, "CreateFullPath: directory creation failed");
            return false;
        }
        // A safety check
        panicCounter--;
        if (panicCounter <= 0) {
-            NGLOG_ERROR(Common, "CreateFullPath: directory structure is too deep");
+            LOG_ERROR(Common, "CreateFullPath: directory structure is too deep");
            return false;
        }
        position++;
@@ -225,11 +225,11 @@ bool CreateFullPath(const std::string& fullPath) {
 // Deletes a directory filename, returns true on success
 bool DeleteDir(const std::string& filename) {
-    NGLOG_TRACE(Common_Filesystem, "directory {}", filename);
+    LOG_TRACE(Common_Filesystem, "directory {}", filename);
    // check if a directory
    if (!FileUtil::IsDirectory(filename)) {
-        NGLOG_ERROR(Common_Filesystem, "Not a directory {}", filename);
+        LOG_ERROR(Common_Filesystem, "Not a directory {}", filename);
        return false;
    }
@@ -240,14 +240,14 @@ bool DeleteDir(const std::string& filename) {
    if (rmdir(filename.c_str()) == 0)
        return true;
 #endif
-    NGLOG_ERROR(Common_Filesystem, "failed {}: {}", filename, GetLastErrorMsg());
+    LOG_ERROR(Common_Filesystem, "failed {}: {}", filename, GetLastErrorMsg());
    return false;
 }
 // renames file srcFilename to destFilename, returns true on success
 bool Rename(const std::string& srcFilename, const std::string& destFilename) {
-    NGLOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
+    LOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
 #ifdef _WIN32
    if (_wrename(Common::UTF8ToUTF16W(srcFilename).c_str(),
                 Common::UTF8ToUTF16W(destFilename).c_str()) == 0)
@@ -256,21 +256,21 @@ bool Rename(const std::string& srcFilename, const std::string& destFilename) {
    if (rename(srcFilename.c_str(), destFilename.c_str()) == 0)
        return true;
 #endif
-    NGLOG_ERROR(Common_Filesystem, "failed {} --> {}: {}", srcFilename, destFilename,
+    LOG_ERROR(Common_Filesystem, "failed {} --> {}: {}", srcFilename, destFilename,
-                GetLastErrorMsg());
+              GetLastErrorMsg());
    return false;
 }
 // copies file srcFilename to destFilename, returns true on success
 bool Copy(const std::string& srcFilename, const std::string& destFilename) {
-    NGLOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
+    LOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
 #ifdef _WIN32
    if (CopyFileW(Common::UTF8ToUTF16W(srcFilename).c_str(),
                  Common::UTF8ToUTF16W(destFilename).c_str(), FALSE))
        return true;
-    NGLOG_ERROR(Common_Filesystem, "failed {} --> {}: {}", srcFilename, destFilename,
+    LOG_ERROR(Common_Filesystem, "failed {} --> {}: {}", srcFilename, destFilename,
-                GetLastErrorMsg());
+              GetLastErrorMsg());
    return false;
 #else
@@ -282,8 +282,8 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
    // Open input file
    FILE* input = fopen(srcFilename.c_str(), "rb");
    if (!input) {
-        NGLOG_ERROR(Common_Filesystem, "opening input failed {} --> {}: {}", srcFilename,
+        LOG_ERROR(Common_Filesystem, "opening input failed {} --> {}: {}", srcFilename,
-                    destFilename, GetLastErrorMsg());
+                  destFilename, GetLastErrorMsg());
        return false;
    }
@@ -291,8 +291,8 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
    FILE* output = fopen(destFilename.c_str(), "wb");
    if (!output) {
        fclose(input);
-        NGLOG_ERROR(Common_Filesystem, "opening output failed {} --> {}: {}", srcFilename,
+        LOG_ERROR(Common_Filesystem, "opening output failed {} --> {}: {}", srcFilename,
-                    destFilename, GetLastErrorMsg());
+                  destFilename, GetLastErrorMsg());
        return false;
    }
@@ -302,8 +302,8 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
        size_t rnum = fread(buffer, sizeof(char), BSIZE, input);
        if (rnum != BSIZE) {
            if (ferror(input) != 0) {
-                NGLOG_ERROR(Common_Filesystem, "failed reading from source, {} --> {}: {}",
+                LOG_ERROR(Common_Filesystem, "failed reading from source, {} --> {}: {}",
-                            srcFilename, destFilename, GetLastErrorMsg());
+                          srcFilename, destFilename, GetLastErrorMsg());
                goto bail;
            }
        }
@@ -311,8 +311,8 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
        // write output
        size_t wnum = fwrite(buffer, sizeof(char), rnum, output);
        if (wnum != rnum) {
-            NGLOG_ERROR(Common_Filesystem, "failed writing to output, {} --> {}: {}", srcFilename,
+            LOG_ERROR(Common_Filesystem, "failed writing to output, {} --> {}: {}", srcFilename,
-                        destFilename, GetLastErrorMsg());
+                      destFilename, GetLastErrorMsg());
            goto bail;
        }
    }
@@ -332,12 +332,12 @@ bail:
 // Returns the size of filename (64bit)
 u64 GetSize(const std::string& filename) {
    if (!Exists(filename)) {
-        NGLOG_ERROR(Common_Filesystem, "failed {}: No such file", filename);
+        LOG_ERROR(Common_Filesystem, "failed {}: No such file", filename);
        return 0;
    }
    if (IsDirectory(filename)) {
-        NGLOG_ERROR(Common_Filesystem, "failed {}: is a directory", filename);
+        LOG_ERROR(Common_Filesystem, "failed {}: is a directory", filename);
        return 0;
    }
@@ -348,11 +348,11 @@ u64 GetSize(const std::string& filename) {
    if (stat(filename.c_str(), &buf) == 0)
 #endif
    {
-        NGLOG_TRACE(Common_Filesystem, "{}: {}", filename, buf.st_size);
+        LOG_TRACE(Common_Filesystem, "{}: {}", filename, buf.st_size);
        return buf.st_size;
    }
-    NGLOG_ERROR(Common_Filesystem, "Stat failed {}: {}", filename, GetLastErrorMsg());
+    LOG_ERROR(Common_Filesystem, "Stat failed {}: {}", filename, GetLastErrorMsg());
    return 0;
 }
@@ -360,7 +360,7 @@ u64 GetSize(const std::string& filename) {
 u64 GetSize(const int fd) {
    struct stat buf;
    if (fstat(fd, &buf) != 0) {
-        NGLOG_ERROR(Common_Filesystem, "GetSize: stat failed {}: {}", fd, GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "GetSize: stat failed {}: {}", fd, GetLastErrorMsg());
        return 0;
    }
    return buf.st_size;
@@ -371,14 +371,12 @@ u64 GetSize(FILE* f) {
    // can't use off_t here because it can be 32-bit
    u64 pos = ftello(f);
    if (fseeko(f, 0, SEEK_END) != 0) {
-        NGLOG_ERROR(Common_Filesystem, "GetSize: seek failed {}: {}", fmt::ptr(f),
+        LOG_ERROR(Common_Filesystem, "GetSize: seek failed {}: {}", fmt::ptr(f), GetLastErrorMsg());
-                    GetLastErrorMsg());
        return 0;
    }
    u64 size = ftello(f);
    if ((size != pos) && (fseeko(f, pos, SEEK_SET) != 0)) {
-        NGLOG_ERROR(Common_Filesystem, "GetSize: seek failed {}: {}", fmt::ptr(f),
+        LOG_ERROR(Common_Filesystem, "GetSize: seek failed {}: {}", fmt::ptr(f), GetLastErrorMsg());
-                    GetLastErrorMsg());
        return 0;
    }
    return size;
@@ -386,10 +384,10 @@ u64 GetSize(FILE* f) {
 // creates an empty file filename, returns true on success
 bool CreateEmptyFile(const std::string& filename) {
-    NGLOG_TRACE(Common_Filesystem, "{}", filename);
+    LOG_TRACE(Common_Filesystem, "{}", filename);
    if (!FileUtil::IOFile(filename, "wb")) {
-        NGLOG_ERROR(Common_Filesystem, "failed {}: {}", filename, GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "failed {}: {}", filename, GetLastErrorMsg());
        return false;
    }
@@ -398,7 +396,7 @@ bool CreateEmptyFile(const std::string& filename) {
 bool ForeachDirectoryEntry(unsigned* num_entries_out, const std::string& directory,
                           DirectoryEntryCallable callback) {
-    NGLOG_TRACE(Common_Filesystem, "directory {}", directory);
+    LOG_TRACE(Common_Filesystem, "directory {}", directory);
    // How many files + directories we found
    unsigned found_entries = 0;
@@ -556,7 +554,7 @@ std::string GetCurrentDir() {
    char* dir;
    if (!(dir = getcwd(nullptr, 0))) {
 #endif
-        NGLOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: {}", GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: {}", GetLastErrorMsg());
        return nullptr;
    }
 #ifdef _WIN32
@@ -676,11 +674,11 @@ std::string GetSysDirectory() {
 #endif
    sysDir += DIR_SEP;
-    NGLOG_DEBUG(Common_Filesystem, "Setting to {}:", sysDir);
+    LOG_DEBUG(Common_Filesystem, "Setting to {}:", sysDir);
    return sysDir;
 }
-// Returns a string with a Citra data dir or file in the user's home
+// Returns a string with a yuzu data dir or file in the user's home
 // directory. To be used in "multi-user" mode (that is, installed).
 const std::string& GetUserPath(const unsigned int DirIDX, const std::string& newPath) {
    static std::string paths[NUM_PATH_INDICES];
@@ -692,7 +690,7 @@ const std::string& GetUserPath(const unsigned int DirIDX, const std::string& new
        if (!FileUtil::IsDirectory(paths[D_USER_IDX])) {
            paths[D_USER_IDX] = AppDataRoamingDirectory() + DIR_SEP EMU_DATA_DIR DIR_SEP;
        } else {
-            NGLOG_INFO(Common_Filesystem, "Using the local user directory");
+            LOG_INFO(Common_Filesystem, "Using the local user directory");
        }
        paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
@@ -715,11 +713,13 @@ const std::string& GetUserPath(const unsigned int DirIDX, const std::string& new
        paths[D_SDMC_IDX] = paths[D_USER_IDX] + SDMC_DIR DIR_SEP;
        paths[D_NAND_IDX] = paths[D_USER_IDX] + NAND_DIR DIR_SEP;
        paths[D_SYSDATA_IDX] = paths[D_USER_IDX] + SYSDATA_DIR DIR_SEP;
+        // TODO: Put the logs in a better location for each OS
+        paths[D_LOGS_IDX] = paths[D_USER_IDX] + LOG_DIR DIR_SEP;
    }
    if (!newPath.empty()) {
        if (!FileUtil::IsDirectory(newPath)) {
-            NGLOG_ERROR(Common_Filesystem, "Invalid path specified {}", newPath);
+            LOG_ERROR(Common_Filesystem, "Invalid path specified {}", newPath);
            return paths[DirIDX];
        } else {
            paths[DirIDX] = newPath;
@@ -801,8 +801,8 @@ void SplitFilename83(const std::string& filename, std::array<char, 9>& short_nam
 IOFile::IOFile() {}
-IOFile::IOFile(const std::string& filename, const char openmode[]) {
+IOFile::IOFile(const std::string& filename, const char openmode[], int flags) {
-    Open(filename, openmode);
+    Open(filename, openmode, flags);
 }
 IOFile::~IOFile() {
@@ -823,11 +823,16 @@ void IOFile::Swap(IOFile& other) noexcept {
    std::swap(m_good, other.m_good);
 }
-bool IOFile::Open(const std::string& filename, const char openmode[]) {
+bool IOFile::Open(const std::string& filename, const char openmode[], int flags) {
    Close();
 #ifdef _WIN32
-    _wfopen_s(&m_file, Common::UTF8ToUTF16W(filename).c_str(),
+    if (flags != 0) {
-              Common::UTF8ToUTF16W(openmode).c_str());
+        m_file = _wfsopen(Common::UTF8ToUTF16W(filename).c_str(),
+                          Common::UTF8ToUTF16W(openmode).c_str(), flags);
+    } else {
+        _wfopen_s(&m_file, Common::UTF8ToUTF16W(filename).c_str(),
+                  Common::UTF8ToUTF16W(openmode).c_str());
+    }
 #else
    m_file = fopen(filename.c_str(), openmode);
 #endif
diff --git a/src/common/file_util.h b/src/common/file_util.h
index fc6b3ea46..5bc7fbf7c 100644
--- a/src/common/file_util.h
+++ b/src/common/file_util.h
@@ -156,7 +156,10 @@ void SplitFilename83(const std::string& filename, std::array<char, 9>& short_nam
 class IOFile : public NonCopyable {
 public:
    IOFile();
-    IOFile(const std::string& filename, const char openmode[]);
+    // flags is used for windows specific file open mode flags, which
+    // allows yuzu to open the logs in shared write mode, so that the file
+    // isn't considered "locked" while yuzu is open and people can open the log file and view it
+    IOFile(const std::string& filename, const char openmode[], int flags = 0);
    ~IOFile();
@@ -165,7 +168,7 @@ public:
    void Swap(IOFile& other) noexcept;
-    bool Open(const std::string& filename, const char openmode[]);
+    bool Open(const std::string& filename, const char openmode[], int flags = 0);
    bool Close();
    template <typename T>
@@ -220,6 +223,10 @@ public:
        return WriteArray(&object, 1);
    }
+    size_t WriteString(const std::string& str) {
+        return WriteArray(str.c_str(), str.length());
+    }
    bool IsOpen() const {
        return nullptr != m_file;
    }
diff --git a/src/common/logging/backend.cpp b/src/common/logging/backend.cpp
index c26b20062..242914c6a 100644
--- a/src/common/logging/backend.cpp
+++ b/src/common/logging/backend.cpp
@@ -2,16 +2,145 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
-#include <utility>
+#include <algorithm>
+#include <array>
+#include <chrono>
+#include <condition_variable>
+#include <memory>
+#include <thread>
+#ifdef _WIN32
+#include <share.h> // For _SH_DENYWR
+#else
+#define _SH_DENYWR 0
+#endif
 #include "common/assert.h"
+#include "common/common_funcs.h" // snprintf compatibility define
 #include "common/logging/backend.h"
-#include "common/logging/filter.h"
 #include "common/logging/log.h"
 #include "common/logging/text_formatter.h"
 #include "common/string_util.h"
+#include "common/threadsafe_queue.h"
 namespace Log {
+/**
+ * Static state as a singleton.
+ */
+class Impl {
+public:
+    static Impl& Instance() {
+        static Impl backend;
+        return backend;
+    }
+    Impl(Impl const&) = delete;
+    const Impl& operator=(Impl const&) = delete;
+    void PushEntry(Entry e) {
+        std::lock_guard<std::mutex> lock(message_mutex);
+        message_queue.Push(std::move(e));
+        message_cv.notify_one();
+    }
+    void AddBackend(std::unique_ptr<Backend> backend) {
+        std::lock_guard<std::mutex> lock(writing_mutex);
+        backends.push_back(std::move(backend));
+    }
+    void RemoveBackend(const std::string& backend_name) {
+        std::lock_guard<std::mutex> lock(writing_mutex);
+        auto it = std::remove_if(backends.begin(), backends.end(), [&backend_name](const auto& i) {
+            return !strcmp(i->GetName(), backend_name.c_str());
+        });
+        backends.erase(it, backends.end());
+    }
+    const Filter& GetGlobalFilter() const {
+        return filter;
+    }
+    void SetGlobalFilter(const Filter& f) {
+        filter = f;
+    }
+    Backend* GetBackend(const std::string& backend_name) {
+        auto it = std::find_if(backends.begin(), backends.end(), [&backend_name](const auto& i) {
+            return !strcmp(i->GetName(), backend_name.c_str());
+        });
+        if (it == backends.end())
+            return nullptr;
+        return it->get();
+    }
+private:
+    Impl() {
+        backend_thread = std::thread([&] {
+            Entry entry;
+            auto write_logs = [&](Entry& e) {
+                std::lock_guard<std::mutex> lock(writing_mutex);
+                for (const auto& backend : backends) {
+                    backend->Write(e);
+                }
+            };
+            while (true) {
+                std::unique_lock<std::mutex> lock(message_mutex);
+                message_cv.wait(lock, [&] { return !running || message_queue.Pop(entry); });
+                if (!running) {
+                    break;
+                }
+                write_logs(entry);
+            }
+            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a case
+            // where a system is repeatedly spamming logs even on close.
+            constexpr int MAX_LOGS_TO_WRITE = 100;
+            int logs_written = 0;
+            while (logs_written++ < MAX_LOGS_TO_WRITE && message_queue.Pop(entry)) {
+                write_logs(entry);
+            }
+        });
+    }
+    ~Impl() {
+        running = false;
+        message_cv.notify_one();
+        backend_thread.join();
+    }
+    std::atomic_bool running{true};
+    std::mutex message_mutex, writing_mutex;
+    std::condition_variable message_cv;
+    std::thread backend_thread;
+    std::vector<std::unique_ptr<Backend>> backends;
+    Common::MPSCQueue<Log::Entry> message_queue;
+    Filter filter;
+};
+void ConsoleBackend::Write(const Entry& entry) {
+    PrintMessage(entry);
+}
+void ColorConsoleBackend::Write(const Entry& entry) {
+    PrintColoredMessage(entry);
+}
+// _SH_DENYWR allows read only access to the file for other programs.
+// It is #defined to 0 on other platforms
+FileBackend::FileBackend(const std::string& filename)
+    : file(filename, "w", _SH_DENYWR), bytes_written(0) {}
+void FileBackend::Write(const Entry& entry) {
+    // prevent logs from going over the maximum size (in case its spamming and the user doesn't
+    // know)
+    constexpr size_t MAX_BYTES_WRITTEN = 50 * 1024L * 1024L;
+    if (!file.IsOpen() || bytes_written > MAX_BYTES_WRITTEN) {
+        return;
+    }
+    bytes_written += file.WriteString(FormatLogMessage(entry) + '\n');
+    if (entry.log_level >= Level::Error) {
+        file.Flush();
+    }
+}
 /// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
 #define ALL_LOG_CLASSES()                                                                          \
    CLS(Log)                                                                                       \
@@ -125,20 +254,32 @@ Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsign
    return entry;
 }
-static Filter* filter = nullptr;
+void SetGlobalFilter(const Filter& filter) {
+    Impl::Instance().SetGlobalFilter(filter);
+}
+void AddBackend(std::unique_ptr<Backend> backend) {
+    Impl::Instance().AddBackend(std::move(backend));
+}
-void SetFilter(Filter* new_filter) {
+void RemoveBackend(const std::string& backend_name) {
-    filter = new_filter;
+    Impl::Instance().RemoveBackend(backend_name);
+}
+Backend* GetBackend(const std::string& backend_name) {
+    return Impl::Instance().GetBackend(backend_name);
 }
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
                       unsigned int line_num, const char* function, const char* format,
                       const fmt::format_args& args) {
-    if (filter && !filter->CheckMessage(log_class, log_level))
+    auto filter = Impl::Instance().GetGlobalFilter();
+    if (!filter.CheckMessage(log_class, log_level))
        return;
    Entry entry =
        CreateEntry(log_class, log_level, filename, line_num, function, fmt::vformat(format, args));
-    PrintColoredMessage(entry);
+    Impl::Instance().PushEntry(std::move(entry));
 }
-} // namespace Log
+} // namespace Log
+\ No newline at end of file
diff --git a/src/common/logging/backend.h b/src/common/logging/backend.h
index 7e81efb23..57cdf6b2d 100644
--- a/src/common/logging/backend.h
+++ b/src/common/logging/backend.h
@@ -1,13 +1,15 @@
 // Copyright 2014 Citra Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 #pragma once
 #include <chrono>
 #include <cstdarg>
+#include <memory>
 #include <string>
 #include <utility>
+#include "common/file_util.h"
+#include "common/logging/filter.h"
 #include "common/logging/log.h"
 namespace Log {
@@ -35,6 +37,80 @@ struct Entry {
 };
 /**
+ * Interface for logging backends. As loggers can be created and removed at runtime, this can be
+ * used by a frontend for adding a custom logging backend as needed
+ */
+class Backend {
+public:
+    virtual ~Backend() = default;
+    virtual void SetFilter(const Filter& new_filter) {
+        filter = new_filter;
+    }
+    virtual const char* GetName() const = 0;
+    virtual void Write(const Entry& entry) = 0;
+private:
+    Filter filter;
+};
+/**
+ * Backend that writes to stderr without any color commands
+ */
+class ConsoleBackend : public Backend {
+public:
+    static const char* Name() {
+        return "console";
+    }
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+};
+/**
+ * Backend that writes to stderr and with color
+ */
+class ColorConsoleBackend : public Backend {
+public:
+    static const char* Name() {
+        return "color_console";
+    }
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+};
+/**
+ * Backend that writes to a file passed into the constructor
+ */
+class FileBackend : public Backend {
+public:
+    explicit FileBackend(const std::string& filename);
+    static const char* Name() {
+        return "file";
+    }
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+private:
+    FileUtil::IOFile file;
+    size_t bytes_written;
+};
+void AddBackend(std::unique_ptr<Backend> backend);
+void RemoveBackend(const std::string& backend_name);
+Backend* GetBackend(const std::string& backend_name);
+/**
 * Returns the name of the passed log class as a C-string. Subclasses are separated by periods
 * instead of underscores as in the enumeration.
 */
@@ -49,5 +125,10 @@ const char* GetLevelName(Level log_level);
 Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
                  const char* function, std::string message);
-void SetFilter(Filter* filter);
+/**
-} // namespace Log
+ * The global filter will prevent any messages from even being processed if they are filtered. Each
+ * backend can have a filter, but if the level is lower than the global filter, the backend will
+ * never get the message
+ */
+void SetGlobalFilter(const Filter& filter);
+} // namespace Log
+\ No newline at end of file
diff --git a/src/common/logging/filter.cpp b/src/common/logging/filter.cpp
index 428723dce..4e783a577 100644
--- a/src/common/logging/filter.cpp
+++ b/src/common/logging/filter.cpp
@@ -65,14 +65,14 @@ bool Filter::ParseFilterRule(const std::string::const_iterator begin,
                             const std::string::const_iterator end) {
    auto level_separator = std::find(begin, end, ':');
    if (level_separator == end) {
-        NGLOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: %s",
+        LOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: {}",
-                    std::string(begin, end).c_str());
+                  std::string(begin, end));
        return false;
    }
    const Level level = GetLevelByName(level_separator + 1, end);
    if (level == Level::Count) {
-        NGLOG_ERROR(Log, "Unknown log level in filter: %s", std::string(begin, end).c_str());
+        LOG_ERROR(Log, "Unknown log level in filter: {}", std::string(begin, end));
        return false;
    }
@@ -83,7 +83,7 @@ bool Filter::ParseFilterRule(const std::string::const_iterator begin,
    const Class log_class = GetClassByName(begin, level_separator);
    if (log_class == Class::Count) {
-        NGLOG_ERROR(Log, "Unknown log class in filter: %s", std::string(begin, end).c_str());
+        LOG_ERROR(Log, "Unknown log class in filter: {}", std::string(begin, end));
        return false;
    }
diff --git a/src/common/logging/log.h b/src/common/logging/log.h
index c5015531c..e96c90e16 100644
--- a/src/common/logging/log.h
+++ b/src/common/logging/log.h
@@ -109,25 +109,25 @@ void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsig
 } // namespace Log
 #ifdef _DEBUG
-#define NGLOG_TRACE(log_class, ...)                                                                \
+#define LOG_TRACE(log_class, ...)                                                                  \
    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Trace, __FILE__, __LINE__,         \
                         __func__, __VA_ARGS__)
 #else
-#define NGLOG_TRACE(log_class, fmt, ...) (void(0))
+#define LOG_TRACE(log_class, fmt, ...) (void(0))
 #endif
-#define NGLOG_DEBUG(log_class, ...)                                                                \
+#define LOG_DEBUG(log_class, ...)                                                                  \
    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Debug, __FILE__, __LINE__,         \
                         __func__, __VA_ARGS__)
-#define NGLOG_INFO(log_class, ...)                                                                 \
+#define LOG_INFO(log_class, ...)                                                                   \
    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Info, __FILE__, __LINE__,          \
                         __func__, __VA_ARGS__)
-#define NGLOG_WARNING(log_class, ...)                                                              \
+#define LOG_WARNING(log_class, ...)                                                                \
    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Warning, __FILE__, __LINE__,       \
                         __func__, __VA_ARGS__)
-#define NGLOG_ERROR(log_class, ...)                                                                \
+#define LOG_ERROR(log_class, ...)                                                                  \
    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Error, __FILE__, __LINE__,         \
                         __func__, __VA_ARGS__)
-#define NGLOG_CRITICAL(log_class, ...)                                                             \
+#define LOG_CRITICAL(log_class, ...)                                                               \
    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Critical, __FILE__, __LINE__,      \
                         __func__, __VA_ARGS__)
diff --git a/src/common/memory_util.cpp b/src/common/memory_util.cpp
index 4d1ec8fb9..09462ccee 100644
--- a/src/common/memory_util.cpp
+++ b/src/common/memory_util.cpp
@@ -16,7 +16,7 @@
 #include <sys/mman.h>
 #endif
-#if !defined(_WIN32) && defined(ARCHITECTURE_X64) && !defined(MAP_32BIT)
+#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))
@@ -30,7 +30,7 @@ void* AllocateExecutableMemory(size_t size, bool low) {
    void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
 #else
    static char* map_hint = nullptr;
-#if defined(ARCHITECTURE_X64) && !defined(MAP_32BIT)
+#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.
@@ -42,7 +42,7 @@ void* AllocateExecutableMemory(size_t size, bool low) {
 #endif
    void* ptr = mmap(map_hint, size, PROT_READ | PROT_WRITE | PROT_EXEC,
                     MAP_ANON | MAP_PRIVATE
-#if defined(ARCHITECTURE_X64) && defined(MAP_32BIT)
+#if defined(ARCHITECTURE_x86_64) && defined(MAP_32BIT)
                         | (low ? MAP_32BIT : 0)
 #endif
                         ,
@@ -55,9 +55,9 @@ void* AllocateExecutableMemory(size_t size, bool low) {
    if (ptr == MAP_FAILED) {
        ptr = nullptr;
 #endif
-        NGLOG_ERROR(Common_Memory, "Failed to allocate executable memory");
+        LOG_ERROR(Common_Memory, "Failed to allocate executable memory");
    }
-#if !defined(_WIN32) && defined(ARCHITECTURE_X64) && !defined(MAP_32BIT)
+#if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
    else {
        if (low) {
            map_hint += size;
@@ -68,7 +68,7 @@ void* AllocateExecutableMemory(size_t size, bool low) {
 #if EMU_ARCH_BITS == 64
    if ((u64)ptr >= 0x80000000 && low == true)
-        NGLOG_ERROR(Common_Memory, "Executable memory ended up above 2GB!");
+        LOG_ERROR(Common_Memory, "Executable memory ended up above 2GB!");
 #endif
    return ptr;
@@ -85,7 +85,7 @@ void* AllocateMemoryPages(size_t size) {
 #endif
    if (ptr == nullptr)
-        NGLOG_ERROR(Common_Memory, "Failed to allocate raw memory");
+        LOG_ERROR(Common_Memory, "Failed to allocate raw memory");
    return ptr;
 }
@@ -99,12 +99,12 @@ void* AllocateAlignedMemory(size_t size, size_t alignment) {
    ptr = memalign(alignment, size);
 #else
    if (posix_memalign(&ptr, alignment, size) != 0)
-        NGLOG_ERROR(Common_Memory, "Failed to allocate aligned memory");
+        LOG_ERROR(Common_Memory, "Failed to allocate aligned memory");
 #endif
 #endif
    if (ptr == nullptr)
-        NGLOG_ERROR(Common_Memory, "Failed to allocate aligned memory");
+        LOG_ERROR(Common_Memory, "Failed to allocate aligned memory");
    return ptr;
 }
@@ -113,7 +113,7 @@ void FreeMemoryPages(void* ptr, size_t size) {
    if (ptr) {
 #ifdef _WIN32
        if (!VirtualFree(ptr, 0, MEM_RELEASE))
-            NGLOG_ERROR(Common_Memory, "FreeMemoryPages failed!\n{}", GetLastErrorMsg());
+            LOG_ERROR(Common_Memory, "FreeMemoryPages failed!\n{}", GetLastErrorMsg());
 #else
        munmap(ptr, size);
 #endif
@@ -134,7 +134,7 @@ void WriteProtectMemory(void* ptr, size_t size, bool allowExecute) {
 #ifdef _WIN32
    DWORD oldValue;
    if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READ : PAGE_READONLY, &oldValue))
-        NGLOG_ERROR(Common_Memory, "WriteProtectMemory failed!\n{}", GetLastErrorMsg());
+        LOG_ERROR(Common_Memory, "WriteProtectMemory failed!\n{}", GetLastErrorMsg());
 #else
    mprotect(ptr, size, allowExecute ? (PROT_READ | PROT_EXEC) : PROT_READ);
 #endif
@@ -145,7 +145,7 @@ void UnWriteProtectMemory(void* ptr, size_t size, bool allowExecute) {
    DWORD oldValue;
    if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE,
                        &oldValue))
-        NGLOG_ERROR(Common_Memory, "UnWriteProtectMemory failed!\n{}", GetLastErrorMsg());
+        LOG_ERROR(Common_Memory, "UnWriteProtectMemory failed!\n{}", GetLastErrorMsg());
 #else
    mprotect(ptr, size,
             allowExecute ? (PROT_READ | PROT_WRITE | PROT_EXEC) : PROT_WRITE | PROT_READ);
diff --git a/src/common/param_package.cpp b/src/common/param_package.cpp
index ab0154133..e0df430ab 100644
--- a/src/common/param_package.cpp
+++ b/src/common/param_package.cpp
@@ -25,7 +25,7 @@ ParamPackage::ParamPackage(const std::string& serialized) {
        std::vector<std::string> key_value;
        Common::SplitString(pair, KEY_VALUE_SEPARATOR, key_value);
        if (key_value.size() != 2) {
-            NGLOG_ERROR(Common, "invalid key pair {}", pair);
+            LOG_ERROR(Common, "invalid key pair {}", pair);
            continue;
        }
@@ -64,7 +64,7 @@ std::string ParamPackage::Serialize() const {
 std::string ParamPackage::Get(const std::string& key, const std::string& default_value) const {
    auto pair = data.find(key);
    if (pair == data.end()) {
-        NGLOG_DEBUG(Common, "key '{}' not found", key);
+        LOG_DEBUG(Common, "key '{}' not found", key);
        return default_value;
    }
@@ -74,14 +74,14 @@ std::string ParamPackage::Get(const std::string& key, const std::string& default
 int ParamPackage::Get(const std::string& key, int default_value) const {
    auto pair = data.find(key);
    if (pair == data.end()) {
-        NGLOG_DEBUG(Common, "key '{}' not found", key);
+        LOG_DEBUG(Common, "key '{}' not found", key);
        return default_value;
    }
    try {
        return std::stoi(pair->second);
    } catch (const std::logic_error&) {
-        NGLOG_ERROR(Common, "failed to convert {} to int", pair->second);
+        LOG_ERROR(Common, "failed to convert {} to int", pair->second);
        return default_value;
    }
 }
@@ -89,14 +89,14 @@ int ParamPackage::Get(const std::string& key, int default_value) const {
 float ParamPackage::Get(const std::string& key, float default_value) const {
    auto pair = data.find(key);
    if (pair == data.end()) {
-        NGLOG_DEBUG(Common, "key {} not found", key);
+        LOG_DEBUG(Common, "key {} not found", key);
        return default_value;
    }
    try {
        return std::stof(pair->second);
    } catch (const std::logic_error&) {
-        NGLOG_ERROR(Common, "failed to convert {} to float", pair->second);
+        LOG_ERROR(Common, "failed to convert {} to float", pair->second);
        return default_value;
    }
 }
diff --git a/src/common/string_util.cpp b/src/common/string_util.cpp
index 646400db0..ea9d8f77c 100644
--- a/src/common/string_util.cpp
+++ b/src/common/string_util.cpp
@@ -281,7 +281,7 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
    iconv_t const conv_desc = iconv_open("UTF-8", fromcode);
    if ((iconv_t)(-1) == conv_desc) {
-        NGLOG_ERROR(Common, "Iconv initialization failure [{}]: {}", fromcode, strerror(errno));
+        LOG_ERROR(Common, "Iconv initialization failure [{}]: {}", fromcode, strerror(errno));
        iconv_close(conv_desc);
        return {};
    }
@@ -310,7 +310,7 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
                    ++src_buffer;
                }
            } else {
-                NGLOG_ERROR(Common, "iconv failure [{}]: {}", fromcode, strerror(errno));
+                LOG_ERROR(Common, "iconv failure [{}]: {}", fromcode, strerror(errno));
                break;
            }
        }
@@ -329,7 +329,7 @@ std::u16string UTF8ToUTF16(const std::string& input) {
    iconv_t const conv_desc = iconv_open("UTF-16LE", "UTF-8");
    if ((iconv_t)(-1) == conv_desc) {
-        NGLOG_ERROR(Common, "Iconv initialization failure [UTF-8]: {}", strerror(errno));
+        LOG_ERROR(Common, "Iconv initialization failure [UTF-8]: {}", strerror(errno));
        iconv_close(conv_desc);
        return {};
    }
@@ -358,7 +358,7 @@ std::u16string UTF8ToUTF16(const std::string& input) {
                    ++src_buffer;
                }
            } else {
-                NGLOG_ERROR(Common, "iconv failure [UTF-8]: {}", strerror(errno));
+                LOG_ERROR(Common, "iconv failure [UTF-8]: {}", strerror(errno));
                break;
            }
        }
diff --git a/src/common/swap.h b/src/common/swap.h
index 4a4012d1a..f025f7450 100644
--- a/src/common/swap.h
+++ b/src/common/swap.h
@@ -69,7 +69,7 @@ inline u32 swap32(u32 _data) {
 inline u64 swap64(u64 _data) {
    return _byteswap_uint64(_data);
 }
-#elif _M_ARM
+#elif ARCHITECTURE_ARM
 inline u16 swap16(u16 _data) {
    u32 data = _data;
    __asm__("rev16 %0, %1\n" : "=l"(data) : "l"(data));
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 51e4088d2..3dff068df 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -126,6 +126,8 @@ add_library(core STATIC
    hle/service/audio/audren_u.h
    hle/service/audio/codecctl.cpp
    hle/service/audio/codecctl.h
+    hle/service/audio/hwopus.cpp
+    hle/service/audio/hwopus.h
    hle/service/bcat/module.cpp
    hle/service/bcat/module.h
    hle/service/bcat/bcat.cpp
diff --git a/src/core/arm/dynarmic/arm_dynarmic.cpp b/src/core/arm/dynarmic/arm_dynarmic.cpp
index b5db47667..42605374b 100644
--- a/src/core/arm/dynarmic/arm_dynarmic.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic.cpp
@@ -55,8 +55,8 @@ public:
    }
    void InterpreterFallback(u64 pc, size_t num_instructions) override {
-        NGLOG_INFO(Core_ARM, "Unicorn fallback @ 0x{:X} for {} instructions (instr = {:08X})", pc,
+        LOG_INFO(Core_ARM, "Unicorn fallback @ 0x{:X} for {} instructions (instr = {:08X})", pc,
-                   num_instructions, MemoryReadCode(pc));
+                 num_instructions, MemoryReadCode(pc));
        ARM_Interface::ThreadContext ctx;
        parent.SaveContext(ctx);
diff --git a/src/core/core.cpp b/src/core/core.cpp
index 84ab876cc..8335d502e 100644
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -87,15 +87,15 @@ System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& file
    app_loader = Loader::GetLoader(filepath);
    if (!app_loader) {
-        NGLOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
+        LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
        return ResultStatus::ErrorGetLoader;
    }
    std::pair<boost::optional<u32>, Loader::ResultStatus> system_mode =
        app_loader->LoadKernelSystemMode();
    if (system_mode.second != Loader::ResultStatus::Success) {
-        NGLOG_CRITICAL(Core, "Failed to determine system mode (Error {})!",
+        LOG_CRITICAL(Core, "Failed to determine system mode (Error {})!",
-                       static_cast<int>(system_mode.second));
+                     static_cast<int>(system_mode.second));
        switch (system_mode.second) {
        case Loader::ResultStatus::ErrorEncrypted:
@@ -111,15 +111,15 @@ System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& file
    ResultStatus init_result{Init(emu_window, system_mode.first.get())};
    if (init_result != ResultStatus::Success) {
-        NGLOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
+        LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
-                       static_cast<int>(init_result));
+                     static_cast<int>(init_result));
        System::Shutdown();
        return init_result;
    }
    const Loader::ResultStatus load_result{app_loader->Load(current_process)};
    if (Loader::ResultStatus::Success != load_result) {
-        NGLOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
+        LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
        System::Shutdown();
        switch (load_result) {
@@ -161,7 +161,7 @@ Cpu& System::CpuCore(size_t core_index) {
 }
 System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
-    NGLOG_DEBUG(HW_Memory, "initialized OK");
+    LOG_DEBUG(HW_Memory, "initialized OK");
    CoreTiming::Init();
@@ -196,7 +196,7 @@ System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
        }
    }
-    NGLOG_DEBUG(Core, "Initialized OK");
+    LOG_DEBUG(Core, "Initialized OK");
    // Reset counters and set time origin to current frame
    GetAndResetPerfStats();
@@ -245,7 +245,7 @@ void System::Shutdown() {
    // Close app loader
    app_loader.reset();
-    NGLOG_DEBUG(Core, "Shutdown OK");
+    LOG_DEBUG(Core, "Shutdown OK");
 }
 Service::SM::ServiceManager& System::ServiceManager() {
diff --git a/src/core/core_cpu.cpp b/src/core/core_cpu.cpp
index 099f2bb1a..f22d6a9d0 100644
--- a/src/core/core_cpu.cpp
+++ b/src/core/core_cpu.cpp
@@ -56,7 +56,7 @@ Cpu::Cpu(std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index)
        arm_interface = std::make_shared<ARM_Dynarmic>();
 #else
        cpu_core = std::make_shared<ARM_Unicorn>();
-        NGLOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
+        LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
    } else {
        arm_interface = std::make_shared<ARM_Unicorn>();
@@ -75,7 +75,7 @@ void Cpu::RunLoop(bool tight_loop) {
    // If we don't have a currently active thread then don't execute instructions,
    // instead advance to the next event and try to yield to the next thread
    if (Kernel::GetCurrentThread() == nullptr) {
-        NGLOG_TRACE(Core, "Core-{} idling", core_index);
+        LOG_TRACE(Core, "Core-{} idling", core_index);
        if (IsMainCore()) {
            CoreTiming::Idle();
diff --git a/src/core/core_timing.cpp b/src/core/core_timing.cpp
index dc1d8668f..50d1e3fc9 100644
--- a/src/core/core_timing.cpp
+++ b/src/core/core_timing.cpp
@@ -74,11 +74,11 @@ static void EmptyTimedCallback(u64 userdata, s64 cyclesLate) {}
 s64 usToCycles(s64 us) {
    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
-        NGLOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
        return std::numeric_limits<s64>::max();
    }
    if (us > MAX_VALUE_TO_MULTIPLY) {
-        NGLOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
        return BASE_CLOCK_RATE * (us / 1000000);
    }
    return (BASE_CLOCK_RATE * us) / 1000000;
@@ -86,11 +86,11 @@ s64 usToCycles(s64 us) {
 s64 usToCycles(u64 us) {
    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
-        NGLOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
        return std::numeric_limits<s64>::max();
    }
    if (us > MAX_VALUE_TO_MULTIPLY) {
-        NGLOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
        return BASE_CLOCK_RATE * static_cast<s64>(us / 1000000);
    }
    return (BASE_CLOCK_RATE * static_cast<s64>(us)) / 1000000;
@@ -98,11 +98,11 @@ s64 usToCycles(u64 us) {
 s64 nsToCycles(s64 ns) {
    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
-        NGLOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
        return std::numeric_limits<s64>::max();
    }
    if (ns > MAX_VALUE_TO_MULTIPLY) {
-        NGLOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
        return BASE_CLOCK_RATE * (ns / 1000000000);
    }
    return (BASE_CLOCK_RATE * ns) / 1000000000;
@@ -110,11 +110,11 @@ s64 nsToCycles(s64 ns) {
 s64 nsToCycles(u64 ns) {
    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
-        NGLOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
        return std::numeric_limits<s64>::max();
    }
    if (ns > MAX_VALUE_TO_MULTIPLY) {
-        NGLOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
        return BASE_CLOCK_RATE * (static_cast<s64>(ns) / 1000000000);
    }
    return (BASE_CLOCK_RATE * static_cast<s64>(ns)) / 1000000000;
diff --git a/src/core/file_sys/disk_filesystem.cpp b/src/core/file_sys/disk_filesystem.cpp
index 8aa0e0aa4..8c6f15bb5 100644
--- a/src/core/file_sys/disk_filesystem.cpp
+++ b/src/core/file_sys/disk_filesystem.cpp
@@ -80,19 +80,19 @@ ResultCode Disk_FileSystem::RenameFile(const std::string& src_path,
 }
 ResultCode Disk_FileSystem::DeleteDirectory(const Path& path) const {
-    NGLOG_WARNING(Service_FS, "(STUBBED) called");
+    LOG_WARNING(Service_FS, "(STUBBED) called");
    // TODO(wwylele): Use correct error code
    return ResultCode(-1);
 }
 ResultCode Disk_FileSystem::DeleteDirectoryRecursively(const Path& path) const {
-    NGLOG_WARNING(Service_FS, "(STUBBED) called");
+    LOG_WARNING(Service_FS, "(STUBBED) called");
    // TODO(wwylele): Use correct error code
    return ResultCode(-1);
 }
 ResultCode Disk_FileSystem::CreateFile(const std::string& path, u64 size) const {
-    NGLOG_WARNING(Service_FS, "(STUBBED) called");
+    LOG_WARNING(Service_FS, "(STUBBED) called");
    std::string full_path = base_directory + path;
    if (size == 0) {
@@ -107,7 +107,7 @@ ResultCode Disk_FileSystem::CreateFile(const std::string& path, u64 size) const
        return RESULT_SUCCESS;
    }
-    NGLOG_ERROR(Service_FS, "Too large file");
+    LOG_ERROR(Service_FS, "Too large file");
    // TODO(Subv): Find out the correct error code
    return ResultCode(-1);
 }
@@ -120,13 +120,13 @@ ResultCode Disk_FileSystem::CreateDirectory(const std::string& path) const {
        return RESULT_SUCCESS;
    }
-    NGLOG_CRITICAL(Service_FS, "(unreachable) Unknown error creating {}", full_path);
+    LOG_CRITICAL(Service_FS, "(unreachable) Unknown error creating {}", full_path);
    // TODO(wwylele): Use correct error code
    return ResultCode(-1);
 }
 ResultCode Disk_FileSystem::RenameDirectory(const Path& src_path, const Path& dest_path) const {
-    NGLOG_WARNING(Service_FS, "(STUBBED) called");
+    LOG_WARNING(Service_FS, "(STUBBED) called");
    // TODO(wwylele): Use correct error code
    return ResultCode(-1);
 }
@@ -146,7 +146,7 @@ ResultVal<std::unique_ptr<DirectoryBackend>> Disk_FileSystem::OpenDirectory(
 }
 u64 Disk_FileSystem::GetFreeSpaceSize() const {
-    NGLOG_WARNING(Service_FS, "(STUBBED) called");
+    LOG_WARNING(Service_FS, "(STUBBED) called");
    return 0;
 }
@@ -163,14 +163,14 @@ ResultVal<FileSys::EntryType> Disk_FileSystem::GetEntryType(const std::string& p
 }
 ResultVal<size_t> Disk_Storage::Read(const u64 offset, const size_t length, u8* buffer) const {
-    NGLOG_TRACE(Service_FS, "called offset={}, length={}", offset, length);
+    LOG_TRACE(Service_FS, "called offset={}, length={}", offset, length);
    file->Seek(offset, SEEK_SET);
    return MakeResult<size_t>(file->ReadBytes(buffer, length));
 }
 ResultVal<size_t> Disk_Storage::Write(const u64 offset, const size_t length, const bool flush,
                                      const u8* buffer) const {
-    NGLOG_WARNING(Service_FS, "(STUBBED) called");
+    LOG_WARNING(Service_FS, "(STUBBED) called");
    file->Seek(offset, SEEK_SET);
    size_t written = file->WriteBytes(buffer, length);
    if (flush) {
@@ -204,7 +204,7 @@ u64 Disk_Directory::Read(const u64 count, Entry* entries) {
        const std::string& filename = file.virtualName;
        Entry& entry = entries[entries_read];
-        NGLOG_TRACE(Service_FS, "File {}: size={} dir={}", filename, file.size, file.isDirectory);
+        LOG_TRACE(Service_FS, "File {}: size={} dir={}", filename, file.size, file.isDirectory);
        // TODO(Link Mauve): use a proper conversion to UTF-16.
        for (size_t j = 0; j < FILENAME_LENGTH; ++j) {
diff --git a/src/core/file_sys/filesystem.cpp b/src/core/file_sys/filesystem.cpp
index 87083878b..82fdb3c46 100644
--- a/src/core/file_sys/filesystem.cpp
+++ b/src/core/file_sys/filesystem.cpp
@@ -71,7 +71,7 @@ std::string Path::AsString() const {
    case Binary:
    default:
        // TODO(yuriks): Add assert
-        NGLOG_ERROR(Service_FS, "LowPathType cannot be converted to string!");
+        LOG_ERROR(Service_FS, "LowPathType cannot be converted to string!");
        return {};
    }
 }
@@ -87,7 +87,7 @@ std::u16string Path::AsU16Str() const {
    case Invalid:
    case Binary:
        // TODO(yuriks): Add assert
-        NGLOG_ERROR(Service_FS, "LowPathType cannot be converted to u16string!");
+        LOG_ERROR(Service_FS, "LowPathType cannot be converted to u16string!");
        return {};
    }
@@ -115,7 +115,7 @@ std::vector<u8> Path::AsBinary() const {
    case Invalid:
    default:
        // TODO(yuriks): Add assert
-        NGLOG_ERROR(Service_FS, "LowPathType cannot be converted to binary!");
+        LOG_ERROR(Service_FS, "LowPathType cannot be converted to binary!");
        return {};
    }
 }
diff --git a/src/core/file_sys/partition_filesystem.cpp b/src/core/file_sys/partition_filesystem.cpp
index 874b9e23b..46d438aca 100644
--- a/src/core/file_sys/partition_filesystem.cpp
+++ b/src/core/file_sys/partition_filesystem.cpp
@@ -46,7 +46,7 @@ Loader::ResultStatus PartitionFilesystem::Load(const std::string& file_path, siz
    Loader::ResultStatus result = Load(file_data);
    if (result != Loader::ResultStatus::Success)
-        NGLOG_ERROR(Service_FS, "Failed to load PFS from file {}!", file_path);
+        LOG_ERROR(Service_FS, "Failed to load PFS from file {}!", file_path);
    return result;
 }
@@ -125,12 +125,12 @@ u64 PartitionFilesystem::GetFileSize(const std::string& name) const {
 }
 void PartitionFilesystem::Print() const {
-    NGLOG_DEBUG(Service_FS, "Magic:                  {}", pfs_header.magic);
+    LOG_DEBUG(Service_FS, "Magic:                  {}", pfs_header.magic);
-    NGLOG_DEBUG(Service_FS, "Files:                  {}", pfs_header.num_entries);
+    LOG_DEBUG(Service_FS, "Files:                  {}", pfs_header.num_entries);
    for (u32 i = 0; i < pfs_header.num_entries; i++) {
-        NGLOG_DEBUG(Service_FS, " > File {}:              {} (0x{:X} bytes, at 0x{:X})", i,
+        LOG_DEBUG(Service_FS, " > File {}:              {} (0x{:X} bytes, at 0x{:X})", i,
-                    pfs_entries[i].name.c_str(), pfs_entries[i].fs_entry.size,
+                  pfs_entries[i].name.c_str(), pfs_entries[i].fs_entry.size,
-                    GetFileOffset(pfs_entries[i].name));
+                  GetFileOffset(pfs_entries[i].name));
    }
 }
 } // namespace FileSys
diff --git a/src/core/file_sys/program_metadata.cpp b/src/core/file_sys/program_metadata.cpp
index 25a822891..226811115 100644
--- a/src/core/file_sys/program_metadata.cpp
+++ b/src/core/file_sys/program_metadata.cpp
@@ -21,7 +21,7 @@ Loader::ResultStatus ProgramMetadata::Load(const std::string& file_path) {
    Loader::ResultStatus result = Load(file_data);
    if (result != Loader::ResultStatus::Success)
-        NGLOG_ERROR(Service_FS, "Failed to load NPDM from file {}!", file_path);
+        LOG_ERROR(Service_FS, "Failed to load NPDM from file {}!", file_path);
    return result;
 }
@@ -76,14 +76,14 @@ u64 ProgramMetadata::GetFilesystemPermissions() const {
 }
 void ProgramMetadata::Print() const {
-    NGLOG_DEBUG(Service_FS, "Magic:                  {:.4}", npdm_header.magic.data());
+    LOG_DEBUG(Service_FS, "Magic:                  {:.4}", npdm_header.magic.data());
-    NGLOG_DEBUG(Service_FS, "Main thread priority:   0x{:02X}", npdm_header.main_thread_priority);
+    LOG_DEBUG(Service_FS, "Main thread priority:   0x{:02X}", npdm_header.main_thread_priority);
-    NGLOG_DEBUG(Service_FS, "Main thread core:       {}", npdm_header.main_thread_cpu);
+    LOG_DEBUG(Service_FS, "Main thread core:       {}", npdm_header.main_thread_cpu);
-    NGLOG_DEBUG(Service_FS, "Main thread stack size: 0x{:X} bytes", npdm_header.main_stack_size);
+    LOG_DEBUG(Service_FS, "Main thread stack size: 0x{:X} bytes", npdm_header.main_stack_size);
-    NGLOG_DEBUG(Service_FS, "Process category:       {}", npdm_header.process_category);
+    LOG_DEBUG(Service_FS, "Process category:       {}", npdm_header.process_category);
-    NGLOG_DEBUG(Service_FS, "Flags:                  0x{:02X}", npdm_header.flags);
+    LOG_DEBUG(Service_FS, "Flags:                  0x{:02X}", npdm_header.flags);
-    NGLOG_DEBUG(Service_FS, " > 64-bit instructions: {}",
+    LOG_DEBUG(Service_FS, " > 64-bit instructions: {}",
-                npdm_header.has_64_bit_instructions ? "YES" : "NO");
+              npdm_header.has_64_bit_instructions ? "YES" : "NO");
    auto address_space = "Unknown";
    switch (npdm_header.address_space_type) {
@@ -95,19 +95,19 @@ void ProgramMetadata::Print() const {
        break;
    }
-    NGLOG_DEBUG(Service_FS, " > Address space:       {}\n", address_space);
+    LOG_DEBUG(Service_FS, " > Address space:       {}\n", address_space);
    // Begin ACID printing (potential perms, signed)
-    NGLOG_DEBUG(Service_FS, "Magic:                  {:.4}", acid_header.magic.data());
+    LOG_DEBUG(Service_FS, "Magic:                  {:.4}", acid_header.magic.data());
-    NGLOG_DEBUG(Service_FS, "Flags:                  0x{:02X}", acid_header.flags);
+    LOG_DEBUG(Service_FS, "Flags:                  0x{:02X}", acid_header.flags);
-    NGLOG_DEBUG(Service_FS, " > Is Retail:           {}", acid_header.is_retail ? "YES" : "NO");
+    LOG_DEBUG(Service_FS, " > Is Retail:           {}", acid_header.is_retail ? "YES" : "NO");
-    NGLOG_DEBUG(Service_FS, "Title ID Min:           0x{:016X}", acid_header.title_id_min);
+    LOG_DEBUG(Service_FS, "Title ID Min:           0x{:016X}", acid_header.title_id_min);
-    NGLOG_DEBUG(Service_FS, "Title ID Max:           0x{:016X}", acid_header.title_id_max);
+    LOG_DEBUG(Service_FS, "Title ID Max:           0x{:016X}", acid_header.title_id_max);
-    NGLOG_DEBUG(Service_FS, "Filesystem Access:      0x{:016X}\n", acid_file_access.permissions);
+    LOG_DEBUG(Service_FS, "Filesystem Access:      0x{:016X}\n", acid_file_access.permissions);
    // Begin ACI0 printing (actual perms, unsigned)
-    NGLOG_DEBUG(Service_FS, "Magic:                  {:.4}", aci_header.magic.data());
+    LOG_DEBUG(Service_FS, "Magic:                  {:.4}", aci_header.magic.data());
-    NGLOG_DEBUG(Service_FS, "Title ID:               0x{:016X}", aci_header.title_id);
+    LOG_DEBUG(Service_FS, "Title ID:               0x{:016X}", aci_header.title_id);
-    NGLOG_DEBUG(Service_FS, "Filesystem Access:      0x{:016X}\n", aci_file_access.permissions);
+    LOG_DEBUG(Service_FS, "Filesystem Access:      0x{:016X}\n", aci_file_access.permissions);
 }
 } // namespace FileSys
diff --git a/src/core/file_sys/romfs_factory.cpp b/src/core/file_sys/romfs_factory.cpp
index dc7591aca..84ae0d99b 100644
--- a/src/core/file_sys/romfs_factory.cpp
+++ b/src/core/file_sys/romfs_factory.cpp
@@ -14,7 +14,7 @@ namespace FileSys {
 RomFS_Factory::RomFS_Factory(Loader::AppLoader& app_loader) {
    // Load the RomFS from the app
    if (Loader::ResultStatus::Success != app_loader.ReadRomFS(romfs_file, data_offset, data_size)) {
-        NGLOG_ERROR(Service_FS, "Unable to read RomFS!");
+        LOG_ERROR(Service_FS, "Unable to read RomFS!");
    }
 }
@@ -24,13 +24,13 @@ ResultVal<std::unique_ptr<FileSystemBackend>> RomFS_Factory::Open(const Path& pa
 }
 ResultCode RomFS_Factory::Format(const Path& path) {
-    NGLOG_ERROR(Service_FS, "Unimplemented Format archive {}", GetName());
+    LOG_ERROR(Service_FS, "Unimplemented Format archive {}", GetName());
    // TODO(bunnei): Find the right error code for this
    return ResultCode(-1);
 }
 ResultVal<ArchiveFormatInfo> RomFS_Factory::GetFormatInfo(const Path& path) const {
-    NGLOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive {}", GetName());
+    LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive {}", GetName());
    // TODO(bunnei): Find the right error code for this
    return ResultCode(-1);
 }
diff --git a/src/core/file_sys/romfs_filesystem.cpp b/src/core/file_sys/romfs_filesystem.cpp
index 8e2bce687..83162622b 100644
--- a/src/core/file_sys/romfs_filesystem.cpp
+++ b/src/core/file_sys/romfs_filesystem.cpp
@@ -21,72 +21,70 @@ ResultVal<std::unique_ptr<StorageBackend>> RomFS_FileSystem::OpenFile(const std:
 }
 ResultCode RomFS_FileSystem::DeleteFile(const std::string& path) const {
-    NGLOG_CRITICAL(Service_FS, "Attempted to delete a file from an ROMFS archive ({}).", GetName());
+    LOG_CRITICAL(Service_FS, "Attempted to delete a file from an ROMFS archive ({}).", GetName());
    // TODO(bunnei): Use correct error code
    return ResultCode(-1);
 }
 ResultCode RomFS_FileSystem::RenameFile(const std::string& src_path,
                                        const std::string& dest_path) const {
-    NGLOG_CRITICAL(Service_FS, "Attempted to rename a file within an ROMFS archive ({}).",
+    LOG_CRITICAL(Service_FS, "Attempted to rename a file within an ROMFS archive ({}).", GetName());
-                   GetName());
    // TODO(wwylele): Use correct error code
    return ResultCode(-1);
 }
 ResultCode RomFS_FileSystem::DeleteDirectory(const Path& path) const {
-    NGLOG_CRITICAL(Service_FS, "Attempted to delete a directory from an ROMFS archive ({}).",
+    LOG_CRITICAL(Service_FS, "Attempted to delete a directory from an ROMFS archive ({}).",
-                   GetName());
+                 GetName());
    // TODO(wwylele): Use correct error code
    return ResultCode(-1);
 }
 ResultCode RomFS_FileSystem::DeleteDirectoryRecursively(const Path& path) const {
-    NGLOG_CRITICAL(Service_FS, "Attempted to delete a directory from an ROMFS archive ({}).",
+    LOG_CRITICAL(Service_FS, "Attempted to delete a directory from an ROMFS archive ({}).",
-                   GetName());
+                 GetName());
    // TODO(wwylele): Use correct error code
    return ResultCode(-1);
 }
 ResultCode RomFS_FileSystem::CreateFile(const std::string& path, u64 size) const {
-    NGLOG_CRITICAL(Service_FS, "Attempted to create a file in an ROMFS archive ({}).", GetName());
+    LOG_CRITICAL(Service_FS, "Attempted to create a file in an ROMFS archive ({}).", GetName());
    // TODO(bunnei): Use correct error code
    return ResultCode(-1);
 }
 ResultCode RomFS_FileSystem::CreateDirectory(const std::string& path) const {
-    NGLOG_CRITICAL(Service_FS, "Attempted to create a directory in an ROMFS archive ({}).",
+    LOG_CRITICAL(Service_FS, "Attempted to create a directory in an ROMFS archive ({}).",
-                   GetName());
+                 GetName());
    // TODO(wwylele): Use correct error code
    return ResultCode(-1);
 }
 ResultCode RomFS_FileSystem::RenameDirectory(const Path& src_path, const Path& dest_path) const {
-    NGLOG_CRITICAL(Service_FS, "Attempted to rename a file within an ROMFS archive ({}).",
+    LOG_CRITICAL(Service_FS, "Attempted to rename a file within an ROMFS archive ({}).", GetName());
-                   GetName());
    // TODO(wwylele): Use correct error code
    return ResultCode(-1);
 }
 ResultVal<std::unique_ptr<DirectoryBackend>> RomFS_FileSystem::OpenDirectory(
    const std::string& path) const {
-    NGLOG_WARNING(Service_FS, "Opening Directory in a ROMFS archive");
+    LOG_WARNING(Service_FS, "Opening Directory in a ROMFS archive");
    return MakeResult<std::unique_ptr<DirectoryBackend>>(std::make_unique<ROMFSDirectory>());
 }
 u64 RomFS_FileSystem::GetFreeSpaceSize() const {
-    NGLOG_WARNING(Service_FS, "Attempted to get the free space in an ROMFS archive");
+    LOG_WARNING(Service_FS, "Attempted to get the free space in an ROMFS archive");
    return 0;
 }
 ResultVal<FileSys::EntryType> RomFS_FileSystem::GetEntryType(const std::string& path) const {
-    NGLOG_CRITICAL(Service_FS, "Called within an ROMFS archive (path {}).", path);
+    LOG_CRITICAL(Service_FS, "Called within an ROMFS archive (path {}).", path);
    // TODO(wwylele): Use correct error code
    return ResultCode(-1);
 }
 ResultVal<size_t> RomFS_Storage::Read(const u64 offset, const size_t length, u8* buffer) const {
-    NGLOG_TRACE(Service_FS, "called offset={}, length={}", offset, length);
+    LOG_TRACE(Service_FS, "called offset={}, length={}", offset, length);
    romfs_file->Seek(data_offset + offset, SEEK_SET);
    size_t read_length = (size_t)std::min((u64)length, data_size - offset);
@@ -95,7 +93,7 @@ ResultVal<size_t> RomFS_Storage::Read(const u64 offset, const size_t length, u8*
 ResultVal<size_t> RomFS_Storage::Write(const u64 offset, const size_t length, const bool flush,
                                       const u8* buffer) const {
-    NGLOG_ERROR(Service_FS, "Attempted to write to ROMFS file");
+    LOG_ERROR(Service_FS, "Attempted to write to ROMFS file");
    // TODO(Subv): Find error code
    return MakeResult<size_t>(0);
 }
@@ -105,7 +103,7 @@ u64 RomFS_Storage::GetSize() const {
 }
 bool RomFS_Storage::SetSize(const u64 size) const {
-    NGLOG_ERROR(Service_FS, "Attempted to set the size of an ROMFS file");
+    LOG_ERROR(Service_FS, "Attempted to set the size of an ROMFS file");
    return false;
 }
diff --git a/src/core/file_sys/savedata_factory.cpp b/src/core/file_sys/savedata_factory.cpp
index c1be8fee4..f3aa213af 100644
--- a/src/core/file_sys/savedata_factory.cpp
+++ b/src/core/file_sys/savedata_factory.cpp
@@ -17,6 +17,15 @@ SaveData_Factory::SaveData_Factory(std::string nand_directory)
 ResultVal<std::unique_ptr<FileSystemBackend>> SaveData_Factory::Open(const Path& path) {
    std::string save_directory = GetFullPath();
+    if (!FileUtil::Exists(save_directory)) {
+        // TODO(bunnei): This is a work-around to always create a save data directory if it does not
+        // already exist. This is a hack, as we do not understand yet how this works on hardware.
+        // Without a save data directory, many games will assert on boot. This should not have any
+        // bad side-effects.
+        FileUtil::CreateFullPath(save_directory);
+    }
    // Return an error if the save data doesn't actually exist.
    if (!FileUtil::IsDirectory(save_directory)) {
        // TODO(Subv): Find out correct error code.
@@ -28,7 +37,7 @@ ResultVal<std::unique_ptr<FileSystemBackend>> SaveData_Factory::Open(const Path&
 }
 ResultCode SaveData_Factory::Format(const Path& path) {
-    NGLOG_WARNING(Service_FS, "Format archive {}", GetName());
+    LOG_WARNING(Service_FS, "Format archive {}", GetName());
    // Create the save data directory.
    if (!FileUtil::CreateFullPath(GetFullPath())) {
        // TODO(Subv): Find the correct error code.
@@ -39,7 +48,7 @@ ResultCode SaveData_Factory::Format(const Path& path) {
 }
 ResultVal<ArchiveFormatInfo> SaveData_Factory::GetFormatInfo(const Path& path) const {
-    NGLOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive {}", GetName());
+    LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive {}", GetName());
    // TODO(bunnei): Find the right error code for this
    return ResultCode(-1);
 }
diff --git a/src/core/file_sys/sdmc_factory.cpp b/src/core/file_sys/sdmc_factory.cpp
index 59ac3e0be..2e5ffb764 100644
--- a/src/core/file_sys/sdmc_factory.cpp
+++ b/src/core/file_sys/sdmc_factory.cpp
@@ -25,13 +25,13 @@ ResultVal<std::unique_ptr<FileSystemBackend>> SDMC_Factory::Open(const Path& pat
 }
 ResultCode SDMC_Factory::Format(const Path& path) {
-    NGLOG_ERROR(Service_FS, "Unimplemented Format archive {}", GetName());
+    LOG_ERROR(Service_FS, "Unimplemented Format archive {}", GetName());
    // TODO(Subv): Find the right error code for this
    return ResultCode(-1);
 }
 ResultVal<ArchiveFormatInfo> SDMC_Factory::GetFormatInfo(const Path& path) const {
-    NGLOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive {}", GetName());
+    LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive {}", GetName());
    // TODO(bunnei): Find the right error code for this
    return ResultCode(-1);
 }
diff --git a/src/core/frontend/input.h b/src/core/frontend/input.h
index 79e52488f..39bdf4e21 100644
--- a/src/core/frontend/input.h
+++ b/src/core/frontend/input.h
@@ -59,7 +59,7 @@ template <typename InputDeviceType>
 void RegisterFactory(const std::string& name, std::shared_ptr<Factory<InputDeviceType>> factory) {
    auto pair = std::make_pair(name, std::move(factory));
    if (!Impl::FactoryList<InputDeviceType>::list.insert(std::move(pair)).second) {
-        NGLOG_ERROR(Input, "Factory '{}' already registered", name);
+        LOG_ERROR(Input, "Factory '{}' already registered", name);
    }
 }
@@ -71,7 +71,7 @@ void RegisterFactory(const std::string& name, std::shared_ptr<Factory<InputDevic
 template <typename InputDeviceType>
 void UnregisterFactory(const std::string& name) {
    if (Impl::FactoryList<InputDeviceType>::list.erase(name) == 0) {
-        NGLOG_ERROR(Input, "Factory '{}' not registered", name);
+        LOG_ERROR(Input, "Factory '{}' not registered", name);
    }
 }
@@ -88,7 +88,7 @@ std::unique_ptr<InputDeviceType> CreateDevice(const std::string& params) {
    const auto pair = factory_list.find(engine);
    if (pair == factory_list.end()) {
        if (engine != "null") {
-            NGLOG_ERROR(Input, "Unknown engine name: {}", engine);
+            LOG_ERROR(Input, "Unknown engine name: {}", engine);
        }
        return std::make_unique<InputDeviceType>();
    }
diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp
index 2603192fe..938852a1a 100644
--- a/src/core/gdbstub/gdbstub.cpp
+++ b/src/core/gdbstub/gdbstub.cpp
@@ -232,7 +232,7 @@ static u8 HexCharToValue(u8 hex) {
        return hex - 'A' + 0xA;
    }
-    NGLOG_ERROR(Debug_GDBStub, "Invalid nibble: {} ({:02X})", hex, hex);
+    LOG_ERROR(Debug_GDBStub, "Invalid nibble: {} ({:02X})", hex, hex);
    return 0;
 }
@@ -372,7 +372,7 @@ static u8 ReadByte() {
    u8 c;
    size_t received_size = recv(gdbserver_socket, reinterpret_cast<char*>(&c), 1, MSG_WAITALL);
    if (received_size != 1) {
-        NGLOG_ERROR(Debug_GDBStub, "recv failed: {}", received_size);
+        LOG_ERROR(Debug_GDBStub, "recv failed: {}", received_size);
        Shutdown();
    }
@@ -413,8 +413,8 @@ static void RemoveBreakpoint(BreakpointType type, PAddr addr) {
    auto bp = p.find(static_cast<u64>(addr));
    if (bp != p.end()) {
-        NGLOG_DEBUG(Debug_GDBStub, "gdb: removed a breakpoint: {:016X} bytes at {:016X} of type {}",
+        LOG_DEBUG(Debug_GDBStub, "gdb: removed a breakpoint: {:016X} bytes at {:016X} of type {}",
-                    bp->second.len, bp->second.addr, static_cast<int>(type));
+                  bp->second.len, bp->second.addr, static_cast<int>(type));
        p.erase(static_cast<u64>(addr));
    }
 }
@@ -459,10 +459,10 @@ bool CheckBreakpoint(PAddr addr, BreakpointType type) {
        }
        if (bp->second.active && (addr >= bp->second.addr && addr < bp->second.addr + len)) {
-            NGLOG_DEBUG(Debug_GDBStub,
+            LOG_DEBUG(Debug_GDBStub,
-                        "Found breakpoint type {} @ {:016X}, range: {:016X}"
+                      "Found breakpoint type {} @ {:016X}, range: {:016X}"
-                        " - {:016X} ({:X} bytes)",
+                      " - {:016X} ({:X} bytes)",
-                        static_cast<int>(type), addr, bp->second.addr, bp->second.addr + len, len);
+                      static_cast<int>(type), addr, bp->second.addr, bp->second.addr + len, len);
            return true;
        }
    }
@@ -478,7 +478,7 @@ bool CheckBreakpoint(PAddr addr, BreakpointType type) {
 static void SendPacket(const char packet) {
    size_t sent_size = send(gdbserver_socket, &packet, 1, 0);
    if (sent_size != 1) {
-        NGLOG_ERROR(Debug_GDBStub, "send failed");
+        LOG_ERROR(Debug_GDBStub, "send failed");
    }
 }
@@ -492,13 +492,13 @@ static void SendReply(const char* reply) {
        return;
    }
-    NGLOG_DEBUG(Debug_GDBStub, "Reply: {}", reply);
+    LOG_DEBUG(Debug_GDBStub, "Reply: {}", reply);
    memset(command_buffer, 0, sizeof(command_buffer));
    command_length = static_cast<u32>(strlen(reply));
    if (command_length + 4 > sizeof(command_buffer)) {
-        NGLOG_ERROR(Debug_GDBStub, "command_buffer overflow in SendReply");
+        LOG_ERROR(Debug_GDBStub, "command_buffer overflow in SendReply");
        return;
    }
@@ -515,7 +515,7 @@ static void SendReply(const char* reply) {
    while (left > 0) {
        int sent_size = send(gdbserver_socket, reinterpret_cast<char*>(ptr), left, 0);
        if (sent_size < 0) {
-            NGLOG_ERROR(Debug_GDBStub, "gdb: send failed");
+            LOG_ERROR(Debug_GDBStub, "gdb: send failed");
            return Shutdown();
        }
@@ -526,7 +526,7 @@ static void SendReply(const char* reply) {
 /// Handle query command from gdb client.
 static void HandleQuery() {
-    NGLOG_DEBUG(Debug_GDBStub, "gdb: query '{}'", command_buffer + 1);
+    LOG_DEBUG(Debug_GDBStub, "gdb: query '{}'", command_buffer + 1);
    const char* query = reinterpret_cast<const char*>(command_buffer + 1);
@@ -634,18 +634,18 @@ static void ReadCommand() {
        // ignore ack
        return;
    } else if (c == 0x03) {
-        NGLOG_INFO(Debug_GDBStub, "gdb: found break command");
+        LOG_INFO(Debug_GDBStub, "gdb: found break command");
        halt_loop = true;
        SendSignal(current_thread, SIGTRAP);
        return;
    } else if (c != GDB_STUB_START) {
-        NGLOG_DEBUG(Debug_GDBStub, "gdb: read invalid byte {:02X}", c);
+        LOG_DEBUG(Debug_GDBStub, "gdb: read invalid byte {:02X}", c);
        return;
    }
    while ((c = ReadByte()) != GDB_STUB_END) {
        if (command_length >= sizeof(command_buffer)) {
-            NGLOG_ERROR(Debug_GDBStub, "gdb: command_buffer overflow");
+            LOG_ERROR(Debug_GDBStub, "gdb: command_buffer overflow");
            SendPacket(GDB_STUB_NACK);
            return;
        }
@@ -658,10 +658,9 @@ static void ReadCommand() {
    u8 checksum_calculated = CalculateChecksum(command_buffer, command_length);
    if (checksum_received != checksum_calculated) {
-        NGLOG_ERROR(
+        LOG_ERROR(Debug_GDBStub,
-            Debug_GDBStub,
+                  "gdb: invalid checksum: calculated {:02X} and read {:02X} for ${}# (length: {})",
-            "gdb: invalid checksum: calculated {:02X} and read {:02X} for ${}# (length: {})",
+                  checksum_calculated, checksum_received, command_buffer, command_length);
-            checksum_calculated, checksum_received, command_buffer, command_length);
        command_length = 0;
@@ -688,7 +687,7 @@ static bool IsDataAvailable() {
    t.tv_usec = 0;
    if (select(gdbserver_socket + 1, &fd_socket, nullptr, nullptr, &t) < 0) {
-        NGLOG_ERROR(Debug_GDBStub, "select failed");
+        LOG_ERROR(Debug_GDBStub, "select failed");
        return false;
    }
@@ -801,7 +800,7 @@ static void ReadMemory() {
    u64 len =
        HexToLong(start_offset, static_cast<u64>((command_buffer + command_length) - start_offset));
-    NGLOG_DEBUG(Debug_GDBStub, "gdb: addr: {:016X} len: {:016X}", addr, len);
+    LOG_DEBUG(Debug_GDBStub, "gdb: addr: {:016X} len: {:016X}", addr, len);
    if (len * 2 > sizeof(reply)) {
        SendReply("E01");
@@ -888,8 +887,8 @@ static bool CommitBreakpoint(BreakpointType type, PAddr addr, u64 len) {
    breakpoint.len = len;
    p.insert({addr, breakpoint});
-    NGLOG_DEBUG(Debug_GDBStub, "gdb: added {} breakpoint: {:016X} bytes at {:016X}",
+    LOG_DEBUG(Debug_GDBStub, "gdb: added {} breakpoint: {:016X} bytes at {:016X}",
-                static_cast<int>(type), breakpoint.len, breakpoint.addr);
+              static_cast<int>(type), breakpoint.len, breakpoint.addr);
    return true;
 }
@@ -996,7 +995,7 @@ void HandlePacket() {
        return;
    }
-    NGLOG_DEBUG(Debug_GDBStub, "Packet: {}", command_buffer);
+    LOG_DEBUG(Debug_GDBStub, "Packet: {}", command_buffer);
    switch (command_buffer[0]) {
    case 'q':
@@ -1010,7 +1009,7 @@ void HandlePacket() {
        break;
    case 'k':
        Shutdown();
-        NGLOG_INFO(Debug_GDBStub, "killed by gdb");
+        LOG_INFO(Debug_GDBStub, "killed by gdb");
        return;
    case 'g':
        ReadRegisters();
@@ -1092,7 +1091,7 @@ static void Init(u16 port) {
    breakpoints_write.clear();
    // Start gdb server
-    NGLOG_INFO(Debug_GDBStub, "Starting GDB server on port {}...", port);
+    LOG_INFO(Debug_GDBStub, "Starting GDB server on port {}...", port);
    sockaddr_in saddr_server = {};
    saddr_server.sin_family = AF_INET;
@@ -1105,28 +1104,28 @@ static void Init(u16 port) {
    int tmpsock = static_cast<int>(socket(PF_INET, SOCK_STREAM, 0));
    if (tmpsock == -1) {
-        NGLOG_ERROR(Debug_GDBStub, "Failed to create gdb socket");
+        LOG_ERROR(Debug_GDBStub, "Failed to create gdb socket");
    }
    // Set socket to SO_REUSEADDR so it can always bind on the same port
    int reuse_enabled = 1;
    if (setsockopt(tmpsock, SOL_SOCKET, SO_REUSEADDR, (const char*)&reuse_enabled,
                   sizeof(reuse_enabled)) < 0) {
-        NGLOG_ERROR(Debug_GDBStub, "Failed to set gdb socket option");
+        LOG_ERROR(Debug_GDBStub, "Failed to set gdb socket option");
    }
    const sockaddr* server_addr = reinterpret_cast<const sockaddr*>(&saddr_server);
    socklen_t server_addrlen = sizeof(saddr_server);
    if (bind(tmpsock, server_addr, server_addrlen) < 0) {
-        NGLOG_ERROR(Debug_GDBStub, "Failed to bind gdb socket");
+        LOG_ERROR(Debug_GDBStub, "Failed to bind gdb socket");
    }
    if (listen(tmpsock, 1) < 0) {
-        NGLOG_ERROR(Debug_GDBStub, "Failed to listen to gdb socket");
+        LOG_ERROR(Debug_GDBStub, "Failed to listen to gdb socket");
    }
    // Wait for gdb to connect
-    NGLOG_INFO(Debug_GDBStub, "Waiting for gdb to connect...");
+    LOG_INFO(Debug_GDBStub, "Waiting for gdb to connect...");
    sockaddr_in saddr_client;
    sockaddr* client_addr = reinterpret_cast<sockaddr*>(&saddr_client);
    socklen_t client_addrlen = sizeof(saddr_client);
@@ -1137,9 +1136,9 @@ static void Init(u16 port) {
        halt_loop = false;
        step_loop = false;
-        NGLOG_ERROR(Debug_GDBStub, "Failed to accept gdb client");
+        LOG_ERROR(Debug_GDBStub, "Failed to accept gdb client");
    } else {
-        NGLOG_INFO(Debug_GDBStub, "Client connected.");
+        LOG_INFO(Debug_GDBStub, "Client connected.");
        saddr_client.sin_addr.s_addr = ntohl(saddr_client.sin_addr.s_addr);
    }
@@ -1158,7 +1157,7 @@ void Shutdown() {
        return;
    }
-    NGLOG_INFO(Debug_GDBStub, "Stopping GDB ...");
+    LOG_INFO(Debug_GDBStub, "Stopping GDB ...");
    if (gdbserver_socket != -1) {
        shutdown(gdbserver_socket, SHUT_RDWR);
        gdbserver_socket = -1;
@@ -1168,7 +1167,7 @@ void Shutdown() {
    WSACleanup();
 #endif
-    NGLOG_INFO(Debug_GDBStub, "GDB stopped.");
+    LOG_INFO(Debug_GDBStub, "GDB stopped.");
 }
 bool IsServerEnabled() {
diff --git a/src/core/hle/kernel/handle_table.cpp b/src/core/hle/kernel/handle_table.cpp
index f7a9920d8..7dd67f80f 100644
--- a/src/core/hle/kernel/handle_table.cpp
+++ b/src/core/hle/kernel/handle_table.cpp
@@ -26,7 +26,7 @@ ResultVal<Handle> HandleTable::Create(SharedPtr<Object> obj) {
    u16 slot = next_free_slot;
    if (slot >= generations.size()) {
-        NGLOG_ERROR(Kernel, "Unable to allocate Handle, too many slots in use.");
+        LOG_ERROR(Kernel, "Unable to allocate Handle, too many slots in use.");
        return ERR_OUT_OF_HANDLES;
    }
    next_free_slot = generations[slot];
@@ -48,7 +48,7 @@ ResultVal<Handle> HandleTable::Create(SharedPtr<Object> obj) {
 ResultVal<Handle> HandleTable::Duplicate(Handle handle) {
    SharedPtr<Object> object = GetGeneric(handle);
    if (object == nullptr) {
-        NGLOG_ERROR(Kernel, "Tried to duplicate invalid handle: {:08X}", handle);
+        LOG_ERROR(Kernel, "Tried to duplicate invalid handle: {:08X}", handle);
        return ERR_INVALID_HANDLE;
    }
    return Create(std::move(object));
diff --git a/src/core/hle/kernel/hle_ipc.cpp b/src/core/hle/kernel/hle_ipc.cpp
index b0d83f401..609cdbff2 100644
--- a/src/core/hle/kernel/hle_ipc.cpp
+++ b/src/core/hle/kernel/hle_ipc.cpp
@@ -120,7 +120,7 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
                std::make_shared<IPC::DomainMessageHeader>(rp.PopRaw<IPC::DomainMessageHeader>());
        } else {
            if (Session()->IsDomain())
-                NGLOG_WARNING(IPC, "Domain request has no DomainMessageHeader!");
+                LOG_WARNING(IPC, "Domain request has no DomainMessageHeader!");
        }
    }
@@ -272,15 +272,15 @@ std::vector<u8> HLERequestContext::ReadBuffer(int buffer_index) const {
 size_t HLERequestContext::WriteBuffer(const void* buffer, size_t size, int buffer_index) const {
    if (size == 0) {
-        NGLOG_WARNING(Core, "skip empty buffer write");
+        LOG_WARNING(Core, "skip empty buffer write");
        return 0;
    }
    const bool is_buffer_b{BufferDescriptorB().size() && BufferDescriptorB()[buffer_index].Size()};
    const size_t buffer_size{GetWriteBufferSize(buffer_index)};
    if (size > buffer_size) {
-        NGLOG_CRITICAL(Core, "size ({:016X}) is greater than buffer_size ({:016X})", size,
+        LOG_CRITICAL(Core, "size ({:016X}) is greater than buffer_size ({:016X})", size,
-                       buffer_size);
+                     buffer_size);
        size = buffer_size; // TODO(bunnei): This needs to be HW tested
    }
diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp
index 651d932d3..0c0506085 100644
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -54,7 +54,7 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
            continue;
        } else if ((type & 0xF00) == 0xE00) { // 0x0FFF
            // Allowed interrupts list
-            NGLOG_WARNING(Loader, "ExHeader allowed interrupts list ignored");
+            LOG_WARNING(Loader, "ExHeader allowed interrupts list ignored");
        } else if ((type & 0xF80) == 0xF00) { // 0x07FF
            // Allowed syscalls mask
            unsigned int index = ((descriptor >> 24) & 7) * 24;
@@ -74,7 +74,7 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
        } else if ((type & 0xFFE) == 0xFF8) { // 0x001F
            // Mapped memory range
            if (i + 1 >= len || ((kernel_caps[i + 1] >> 20) & 0xFFE) != 0xFF8) {
-                NGLOG_WARNING(Loader, "Incomplete exheader memory range descriptor ignored.");
+                LOG_WARNING(Loader, "Incomplete exheader memory range descriptor ignored.");
                continue;
            }
            u32 end_desc = kernel_caps[i + 1];
@@ -109,9 +109,9 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
            int minor = kernel_version & 0xFF;
            int major = (kernel_version >> 8) & 0xFF;
-            NGLOG_INFO(Loader, "ExHeader kernel version: {}.{}", major, minor);
+            LOG_INFO(Loader, "ExHeader kernel version: {}.{}", major, minor);
        } else {
-            NGLOG_ERROR(Loader, "Unhandled kernel caps descriptor: 0x{:08X}", descriptor);
+            LOG_ERROR(Loader, "Unhandled kernel caps descriptor: 0x{:08X}", descriptor);
        }
    }
 }
diff --git a/src/core/hle/kernel/resource_limit.cpp b/src/core/hle/kernel/resource_limit.cpp
index 0ef5fc57d..17a3e8a74 100644
--- a/src/core/hle/kernel/resource_limit.cpp
+++ b/src/core/hle/kernel/resource_limit.cpp
@@ -29,7 +29,7 @@ SharedPtr<ResourceLimit> ResourceLimit::GetForCategory(ResourceLimitCategory cat
    case ResourceLimitCategory::OTHER:
        return resource_limits[static_cast<u8>(category)];
    default:
-        NGLOG_CRITICAL(Kernel, "Unknown resource limit category");
+        LOG_CRITICAL(Kernel, "Unknown resource limit category");
        UNREACHABLE();
    }
 }
@@ -55,7 +55,7 @@ s32 ResourceLimit::GetCurrentResourceValue(ResourceType resource) const {
    case ResourceType::CPUTime:
        return current_cpu_time;
    default:
-        NGLOG_ERROR(Kernel, "Unknown resource type={:08X}", static_cast<u32>(resource));
+        LOG_ERROR(Kernel, "Unknown resource type={:08X}", static_cast<u32>(resource));
        UNIMPLEMENTED();
        return 0;
    }
@@ -84,7 +84,7 @@ u32 ResourceLimit::GetMaxResourceValue(ResourceType resource) const {
    case ResourceType::CPUTime:
        return max_cpu_time;
    default:
-        NGLOG_ERROR(Kernel, "Unknown resource type={:08X}", static_cast<u32>(resource));
+        LOG_ERROR(Kernel, "Unknown resource type={:08X}", static_cast<u32>(resource));
        UNIMPLEMENTED();
        return 0;
    }
diff --git a/src/core/hle/kernel/scheduler.cpp b/src/core/hle/kernel/scheduler.cpp
index 9cb9e0e5c..11c2cb69e 100644
--- a/src/core/hle/kernel/scheduler.cpp
+++ b/src/core/hle/kernel/scheduler.cpp
@@ -99,11 +99,11 @@ void Scheduler::Reschedule() {
    Thread* next = PopNextReadyThread();
    if (cur && next) {
-        NGLOG_TRACE(Kernel, "context switch {} -> {}", cur->GetObjectId(), next->GetObjectId());
+        LOG_TRACE(Kernel, "context switch {} -> {}", cur->GetObjectId(), next->GetObjectId());
    } else if (cur) {
-        NGLOG_TRACE(Kernel, "context switch {} -> idle", cur->GetObjectId());
+        LOG_TRACE(Kernel, "context switch {} -> idle", cur->GetObjectId());
    } else if (next) {
-        NGLOG_TRACE(Kernel, "context switch idle -> {}", next->GetObjectId());
+        LOG_TRACE(Kernel, "context switch idle -> {}", next->GetObjectId());
    }
    SwitchContext(next);
diff --git a/src/core/hle/kernel/server_session.cpp b/src/core/hle/kernel/server_session.cpp
index bf812c543..0d5cba1d9 100644
--- a/src/core/hle/kernel/server_session.cpp
+++ b/src/core/hle/kernel/server_session.cpp
@@ -71,7 +71,7 @@ ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& con
            return domain_request_handlers[object_id - 1]->HandleSyncRequest(context);
        case IPC::DomainMessageHeader::CommandType::CloseVirtualHandle: {
-            NGLOG_DEBUG(IPC, "CloseVirtualHandle, object_id=0x{:08X}", object_id);
+            LOG_DEBUG(IPC, "CloseVirtualHandle, object_id=0x{:08X}", object_id);
            domain_request_handlers[object_id - 1] = nullptr;
@@ -81,8 +81,8 @@ ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& con
        }
        }
-        NGLOG_CRITICAL(IPC, "Unknown domain command={}",
+        LOG_CRITICAL(IPC, "Unknown domain command={}",
-                       static_cast<int>(domain_message_header->command.Value()));
+                     static_cast<int>(domain_message_header->command.Value()));
        ASSERT(false);
    }
diff --git a/src/core/hle/kernel/shared_memory.cpp b/src/core/hle/kernel/shared_memory.cpp
index ac4921298..93f7f2772 100644
--- a/src/core/hle/kernel/shared_memory.cpp
+++ b/src/core/hle/kernel/shared_memory.cpp
@@ -107,16 +107,16 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
    // Error out if the requested permissions don't match what the creator process allows.
    if (static_cast<u32>(permissions) & ~static_cast<u32>(own_other_permissions)) {
-        NGLOG_ERROR(Kernel, "cannot map id={}, address=0x{:X} name={}, permissions don't match",
+        LOG_ERROR(Kernel, "cannot map id={}, address=0x{:X} name={}, permissions don't match",
-                    GetObjectId(), address, name);
+                  GetObjectId(), address, name);
        return ERR_INVALID_COMBINATION;
    }
    // Error out if the provided permissions are not compatible with what the creator process needs.
    if (other_permissions != MemoryPermission::DontCare &&
        static_cast<u32>(this->permissions) & ~static_cast<u32>(other_permissions)) {
-        NGLOG_ERROR(Kernel, "cannot map id={}, address=0x{:X} name={}, permissions don't match",
+        LOG_ERROR(Kernel, "cannot map id={}, address=0x{:X} name={}, permissions don't match",
-                    GetObjectId(), address, name);
+                  GetObjectId(), address, name);
        return ERR_WRONG_PERMISSION;
    }
@@ -131,7 +131,7 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
    auto result = target_process->vm_manager.MapMemoryBlock(
        target_address, backing_block, backing_block_offset, size, MemoryState::Shared);
    if (result.Failed()) {
-        NGLOG_ERROR(
+        LOG_ERROR(
            Kernel,
            "cannot map id={}, target_address=0x{:X} name={}, error mapping to virtual memory",
            GetObjectId(), target_address, name);
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index 1a36e0d02..5ad923fe7 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -32,7 +32,7 @@ namespace Kernel {
 /// Set the process heap to a given Size. It can both extend and shrink the heap.
 static ResultCode SetHeapSize(VAddr* heap_addr, u64 heap_size) {
-    NGLOG_TRACE(Kernel_SVC, "called, heap_size=0x{:X}", heap_size);
+    LOG_TRACE(Kernel_SVC, "called, heap_size=0x{:X}", heap_size);
    auto& process = *Core::CurrentProcess();
    CASCADE_RESULT(*heap_addr,
                   process.HeapAllocate(Memory::HEAP_VADDR, heap_size, VMAPermission::ReadWrite));
@@ -40,21 +40,21 @@ static ResultCode SetHeapSize(VAddr* heap_addr, u64 heap_size) {
 }
 static ResultCode SetMemoryAttribute(VAddr addr, u64 size, u32 state0, u32 state1) {
-    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, addr=0x{:X}", addr);
+    LOG_WARNING(Kernel_SVC, "(STUBBED) called, addr=0x{:X}", addr);
    return RESULT_SUCCESS;
 }
 /// Maps a memory range into a different range.
 static ResultCode MapMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
-    NGLOG_TRACE(Kernel_SVC, "called, dst_addr=0x{:X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
+    LOG_TRACE(Kernel_SVC, "called, dst_addr=0x{:X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
-                src_addr, size);
+              src_addr, size);
    return Core::CurrentProcess()->MirrorMemory(dst_addr, src_addr, size);
 }
 /// Unmaps a region that was previously mapped with svcMapMemory
 static ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
-    NGLOG_TRACE(Kernel_SVC, "called, dst_addr=0x{:X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
+    LOG_TRACE(Kernel_SVC, "called, dst_addr=0x{:X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
-                src_addr, size);
+              src_addr, size);
    return Core::CurrentProcess()->UnmapMemory(dst_addr, src_addr, size);
 }
@@ -69,11 +69,11 @@ static ResultCode ConnectToNamedPort(Handle* out_handle, VAddr port_name_address
    if (port_name.size() > PortNameMaxLength)
        return ERR_PORT_NAME_TOO_LONG;
-    NGLOG_TRACE(Kernel_SVC, "called port_name={}", port_name);
+    LOG_TRACE(Kernel_SVC, "called port_name={}", port_name);
    auto it = Service::g_kernel_named_ports.find(port_name);
    if (it == Service::g_kernel_named_ports.end()) {
-        NGLOG_WARNING(Kernel_SVC, "tried to connect to unknown port: {}", port_name);
+        LOG_WARNING(Kernel_SVC, "tried to connect to unknown port: {}", port_name);
        return ERR_NOT_FOUND;
    }
@@ -91,11 +91,11 @@ static ResultCode ConnectToNamedPort(Handle* out_handle, VAddr port_name_address
 static ResultCode SendSyncRequest(Handle handle) {
    SharedPtr<ClientSession> session = g_handle_table.Get<ClientSession>(handle);
    if (!session) {
-        NGLOG_ERROR(Kernel_SVC, "called with invalid handle=0x{:08X}", handle);
+        LOG_ERROR(Kernel_SVC, "called with invalid handle=0x{:08X}", handle);
        return ERR_INVALID_HANDLE;
    }
-    NGLOG_TRACE(Kernel_SVC, "called handle=0x{:08X}({})", handle, session->GetName());
+    LOG_TRACE(Kernel_SVC, "called handle=0x{:08X}({})", handle, session->GetName());
    Core::System::GetInstance().PrepareReschedule();
@@ -106,7 +106,7 @@ static ResultCode SendSyncRequest(Handle handle) {
 /// Get the ID for the specified thread.
 static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
-    NGLOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
+    LOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
    if (!thread) {
@@ -119,7 +119,7 @@ static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
 /// Get the ID of the specified process
 static ResultCode GetProcessId(u32* process_id, Handle process_handle) {
-    NGLOG_TRACE(Kernel_SVC, "called process=0x{:08X}", process_handle);
+    LOG_TRACE(Kernel_SVC, "called process=0x{:08X}", process_handle);
    const SharedPtr<Process> process = g_handle_table.Get<Process>(process_handle);
    if (!process) {
@@ -149,8 +149,8 @@ static bool DefaultThreadWakeupCallback(ThreadWakeupReason reason, SharedPtr<Thr
 /// Wait for the given handles to synchronize, timeout after the specified nanoseconds
 static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64 handle_count,
                                      s64 nano_seconds) {
-    NGLOG_TRACE(Kernel_SVC, "called handles_address=0x{:X}, handle_count={}, nano_seconds={}",
+    LOG_TRACE(Kernel_SVC, "called handles_address=0x{:X}, handle_count={}, nano_seconds={}",
-                handles_address, handle_count, nano_seconds);
+              handles_address, handle_count, nano_seconds);
    if (!Memory::IsValidVirtualAddress(handles_address))
        return ERR_INVALID_POINTER;
@@ -210,7 +210,7 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
 /// Resumes a thread waiting on WaitSynchronization
 static ResultCode CancelSynchronization(Handle thread_handle) {
-    NGLOG_TRACE(Kernel_SVC, "called thread=0x{:X}", thread_handle);
+    LOG_TRACE(Kernel_SVC, "called thread=0x{:X}", thread_handle);
    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
    if (!thread) {
@@ -227,24 +227,24 @@ static ResultCode CancelSynchronization(Handle thread_handle) {
 /// Attempts to locks a mutex, creating it if it does not already exist
 static ResultCode ArbitrateLock(Handle holding_thread_handle, VAddr mutex_addr,
                                Handle requesting_thread_handle) {
-    NGLOG_TRACE(Kernel_SVC,
+    LOG_TRACE(Kernel_SVC,
-                "called holding_thread_handle=0x{:08X}, mutex_addr=0x{:X}, "
+              "called holding_thread_handle=0x{:08X}, mutex_addr=0x{:X}, "
-                "requesting_current_thread_handle=0x{:08X}",
+              "requesting_current_thread_handle=0x{:08X}",
-                holding_thread_handle, mutex_addr, requesting_thread_handle);
+              holding_thread_handle, mutex_addr, requesting_thread_handle);
    return Mutex::TryAcquire(mutex_addr, holding_thread_handle, requesting_thread_handle);
 }
 /// Unlock a mutex
 static ResultCode ArbitrateUnlock(VAddr mutex_addr) {
-    NGLOG_TRACE(Kernel_SVC, "called mutex_addr=0x{:X}", mutex_addr);
+    LOG_TRACE(Kernel_SVC, "called mutex_addr=0x{:X}", mutex_addr);
    return Mutex::Release(mutex_addr);
 }
 /// Break program execution
 static void Break(u64 unk_0, u64 unk_1, u64 unk_2) {
-    NGLOG_CRITICAL(Debug_Emulated, "Emulated program broke execution!");
+    LOG_CRITICAL(Debug_Emulated, "Emulated program broke execution!");
    ASSERT(false);
 }
@@ -252,13 +252,13 @@ static void Break(u64 unk_0, u64 unk_1, u64 unk_2) {
 static void OutputDebugString(VAddr address, s32 len) {
    std::string str(len, '\0');
    Memory::ReadBlock(address, str.data(), str.size());
-    NGLOG_DEBUG(Debug_Emulated, "{}", str);
+    LOG_DEBUG(Debug_Emulated, "{}", str);
 }
 /// Gets system/memory information for the current process
 static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id) {
-    NGLOG_TRACE(Kernel_SVC, "called info_id=0x{:X}, info_sub_id=0x{:X}, handle=0x{:08X}", info_id,
+    LOG_TRACE(Kernel_SVC, "called info_id=0x{:X}, info_sub_id=0x{:X}, handle=0x{:08X}", info_id,
-                info_sub_id, handle);
+              info_sub_id, handle);
    auto& vm_manager = Core::CurrentProcess()->vm_manager;
@@ -309,17 +309,17 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
        *result = Core::CurrentProcess()->is_virtual_address_memory_enabled;
        break;
    case GetInfoType::TitleId:
-        NGLOG_WARNING(Kernel_SVC, "(STUBBED) Attempted to query titleid, returned 0");
+        LOG_WARNING(Kernel_SVC, "(STUBBED) Attempted to query titleid, returned 0");
        *result = 0;
        break;
    case GetInfoType::PrivilegedProcessId:
-        NGLOG_WARNING(Kernel_SVC,
+        LOG_WARNING(Kernel_SVC,
-                      "(STUBBED) Attempted to query privileged process id bounds, returned 0");
+                    "(STUBBED) Attempted to query privileged process id bounds, returned 0");
        *result = 0;
        break;
    case GetInfoType::UserExceptionContextAddr:
-        NGLOG_WARNING(Kernel_SVC,
+        LOG_WARNING(Kernel_SVC,
-                      "(STUBBED) Attempted to query user exception context address, returned 0");
+                    "(STUBBED) Attempted to query user exception context address, returned 0");
        *result = 0;
        break;
    default:
@@ -331,14 +331,13 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
 /// Sets the thread activity
 static ResultCode SetThreadActivity(Handle handle, u32 unknown) {
-    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x{:08X}, unknown=0x{:08X}", handle,
+    LOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x{:08X}, unknown=0x{:08X}", handle, unknown);
-                  unknown);
    return RESULT_SUCCESS;
 }
 /// Gets the thread context
 static ResultCode GetThreadContext(Handle handle, VAddr addr) {
-    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x{:08X}, addr=0x{:X}", handle, addr);
+    LOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x{:08X}, addr=0x{:X}", handle, addr);
    return RESULT_SUCCESS;
 }
@@ -377,16 +376,15 @@ static ResultCode SetThreadPriority(Handle handle, u32 priority) {
 /// Get which CPU core is executing the current thread
 static u32 GetCurrentProcessorNumber() {
-    NGLOG_TRACE(Kernel_SVC, "called");
+    LOG_TRACE(Kernel_SVC, "called");
    return GetCurrentThread()->processor_id;
 }
 static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 size,
                                  u32 permissions) {
-    NGLOG_TRACE(
+    LOG_TRACE(Kernel_SVC,
-        Kernel_SVC,
+              "called, shared_memory_handle=0x{:X}, addr=0x{:X}, size=0x{:X}, permissions=0x{:08X}",
-        "called, shared_memory_handle=0x{:X}, addr=0x{:X}, size=0x{:X}, permissions=0x{:08X}",
+              shared_memory_handle, addr, size, permissions);
-        shared_memory_handle, addr, size, permissions);
    SharedPtr<SharedMemory> shared_memory = g_handle_table.Get<SharedMemory>(shared_memory_handle);
    if (!shared_memory) {
@@ -406,15 +404,15 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
        return shared_memory->Map(Core::CurrentProcess().get(), addr, permissions_type,
                                  MemoryPermission::DontCare);
    default:
-        NGLOG_ERROR(Kernel_SVC, "unknown permissions=0x{:08X}", permissions);
+        LOG_ERROR(Kernel_SVC, "unknown permissions=0x{:08X}", permissions);
    }
    return RESULT_SUCCESS;
 }
 static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 size) {
-    NGLOG_WARNING(Kernel_SVC, "called, shared_memory_handle=0x{:08X}, addr=0x{:X}, size=0x{:X}",
+    LOG_WARNING(Kernel_SVC, "called, shared_memory_handle=0x{:08X}, addr=0x{:X}, size=0x{:X}",
-                  shared_memory_handle, addr, size);
+                shared_memory_handle, addr, size);
    SharedPtr<SharedMemory> shared_memory = g_handle_table.Get<SharedMemory>(shared_memory_handle);
@@ -442,19 +440,19 @@ static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_i
        memory_info->type = static_cast<u32>(vma->second.meminfo_state);
    }
-    NGLOG_TRACE(Kernel_SVC, "called process=0x{:08X} addr={:X}", process_handle, addr);
+    LOG_TRACE(Kernel_SVC, "called process=0x{:08X} addr={:X}", process_handle, addr);
    return RESULT_SUCCESS;
 }
 /// Query memory
 static ResultCode QueryMemory(MemoryInfo* memory_info, PageInfo* page_info, VAddr addr) {
-    NGLOG_TRACE(Kernel_SVC, "called, addr={:X}", addr);
+    LOG_TRACE(Kernel_SVC, "called, addr={:X}", addr);
    return QueryProcessMemory(memory_info, page_info, CurrentProcess, addr);
 }
 /// Exits the current process
 static void ExitProcess() {
-    NGLOG_INFO(Kernel_SVC, "Process {} exiting", Core::CurrentProcess()->process_id);
+    LOG_INFO(Kernel_SVC, "Process {} exiting", Core::CurrentProcess()->process_id);
    ASSERT_MSG(Core::CurrentProcess()->status == ProcessStatus::Running,
               "Process has already exited");
@@ -530,17 +528,17 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
    Core::System::GetInstance().PrepareReschedule();
    Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
-    NGLOG_TRACE(Kernel_SVC,
+    LOG_TRACE(Kernel_SVC,
-                "called entrypoint=0x{:08X} ({}), arg=0x{:08X}, stacktop=0x{:08X}, "
+              "called entrypoint=0x{:08X} ({}), arg=0x{:08X}, stacktop=0x{:08X}, "
-                "threadpriority=0x{:08X}, processorid=0x{:08X} : created handle=0x{:08X}",
+              "threadpriority=0x{:08X}, processorid=0x{:08X} : created handle=0x{:08X}",
-                entry_point, name, arg, stack_top, priority, processor_id, *out_handle);
+              entry_point, name, arg, stack_top, priority, processor_id, *out_handle);
    return RESULT_SUCCESS;
 }
 /// Starts the thread for the provided handle
 static ResultCode StartThread(Handle thread_handle) {
-    NGLOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
+    LOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
    if (!thread) {
@@ -557,7 +555,7 @@ static ResultCode StartThread(Handle thread_handle) {
 /// Called when a thread exits
 static void ExitThread() {
-    NGLOG_TRACE(Kernel_SVC, "called, pc=0x{:08X}", Core::CurrentArmInterface().GetPC());
+    LOG_TRACE(Kernel_SVC, "called, pc=0x{:08X}", Core::CurrentArmInterface().GetPC());
    ExitCurrentThread();
    Core::System::GetInstance().PrepareReschedule();
@@ -565,7 +563,7 @@ static void ExitThread() {
 /// Sleep the current thread
 static void SleepThread(s64 nanoseconds) {
-    NGLOG_TRACE(Kernel_SVC, "called nanoseconds={}", nanoseconds);
+    LOG_TRACE(Kernel_SVC, "called nanoseconds={}", nanoseconds);
    // Don't attempt to yield execution if there are no available threads to run,
    // this way we avoid a useless reschedule to the idle thread.
@@ -584,7 +582,7 @@ static void SleepThread(s64 nanoseconds) {
 /// Wait process wide key atomic
 static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_variable_addr,
                                           Handle thread_handle, s64 nano_seconds) {
-    NGLOG_TRACE(
+    LOG_TRACE(
        Kernel_SVC,
        "called mutex_addr={:X}, condition_variable_addr={:X}, thread_handle=0x{:08X}, timeout={}",
        mutex_addr, condition_variable_addr, thread_handle, nano_seconds);
@@ -611,8 +609,8 @@ static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_var
 /// Signal process wide key
 static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target) {
-    NGLOG_TRACE(Kernel_SVC, "called, condition_variable_addr=0x{:X}, target=0x{:08X}",
+    LOG_TRACE(Kernel_SVC, "called, condition_variable_addr=0x{:X}, target=0x{:08X}",
-                condition_variable_addr, target);
+              condition_variable_addr, target);
    auto RetrieveWaitingThreads =
        [](size_t core_index, std::vector<SharedPtr<Thread>>& waiting_threads, VAddr condvar_addr) {
@@ -692,8 +690,8 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
 // Wait for an address (via Address Arbiter)
 static ResultCode WaitForAddress(VAddr address, u32 type, s32 value, s64 timeout) {
-    NGLOG_WARNING(Kernel_SVC, "called, address=0x{:X}, type=0x{:X}, value=0x{:X}, timeout={}",
+    LOG_WARNING(Kernel_SVC, "called, address=0x{:X}, type=0x{:X}, value=0x{:X}, timeout={}",
-                  address, type, value, timeout);
+                address, type, value, timeout);
    // If the passed address is a kernel virtual address, return invalid memory state.
    if (Memory::IsKernelVirtualAddress(address)) {
        return ERR_INVALID_ADDRESS_STATE;
@@ -717,9 +715,8 @@ static ResultCode WaitForAddress(VAddr address, u32 type, s32 value, s64 timeout
 // Signals to an address (via Address Arbiter)
 static ResultCode SignalToAddress(VAddr address, u32 type, s32 value, s32 num_to_wake) {
-    NGLOG_WARNING(Kernel_SVC,
+    LOG_WARNING(Kernel_SVC, "called, address=0x{:X}, type=0x{:X}, value=0x{:X}, num_to_wake=0x{:X}",
-                  "called, address=0x{:X}, type=0x{:X}, value=0x{:X}, num_to_wake=0x{:X}", address,
+                address, type, value, num_to_wake);
-                  type, value, num_to_wake);
    // If the passed address is a kernel virtual address, return invalid memory state.
    if (Memory::IsKernelVirtualAddress(address)) {
        return ERR_INVALID_ADDRESS_STATE;
@@ -754,13 +751,13 @@ static u64 GetSystemTick() {
 /// Close a handle
 static ResultCode CloseHandle(Handle handle) {
-    NGLOG_TRACE(Kernel_SVC, "Closing handle 0x{:08X}", handle);
+    LOG_TRACE(Kernel_SVC, "Closing handle 0x{:08X}", handle);
    return g_handle_table.Close(handle);
 }
 /// Reset an event
 static ResultCode ResetSignal(Handle handle) {
-    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called handle 0x{:08X}", handle);
+    LOG_WARNING(Kernel_SVC, "(STUBBED) called handle 0x{:08X}", handle);
    auto event = g_handle_table.Get<Event>(handle);
    ASSERT(event != nullptr);
    event->Clear();
@@ -769,14 +766,14 @@ static ResultCode ResetSignal(Handle handle) {
 /// Creates a TransferMemory object
 static ResultCode CreateTransferMemory(Handle* handle, VAddr addr, u64 size, u32 permissions) {
-    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called addr=0x{:X}, size=0x{:X}, perms=0x{:08X}", addr,
+    LOG_WARNING(Kernel_SVC, "(STUBBED) called addr=0x{:X}, size=0x{:X}, perms=0x{:08X}", addr, size,
-                  size, permissions);
+                permissions);
    *handle = 0;
    return RESULT_SUCCESS;
 }
 static ResultCode GetThreadCoreMask(Handle thread_handle, u32* core, u64* mask) {
-    NGLOG_TRACE(Kernel_SVC, "called, handle=0x{:08X}", thread_handle);
+    LOG_TRACE(Kernel_SVC, "called, handle=0x{:08X}", thread_handle);
    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
    if (!thread) {
@@ -790,8 +787,8 @@ static ResultCode GetThreadCoreMask(Handle thread_handle, u32* core, u64* mask)
 }
 static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
-    NGLOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, mask=0x{:16X}, core=0x{:X}", thread_handle,
+    LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, mask=0x{:16X}, core=0x{:X}", thread_handle,
-                mask, core);
+              mask, core);
    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
    if (!thread) {
@@ -830,8 +827,8 @@ static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
 static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permissions,
                                     u32 remote_permissions) {
-    NGLOG_TRACE(Kernel_SVC, "called, size=0x{:X}, localPerms=0x{:08X}, remotePerms=0x{:08X}", size,
+    LOG_TRACE(Kernel_SVC, "called, size=0x{:X}, localPerms=0x{:08X}, remotePerms=0x{:08X}", size,
-                local_permissions, remote_permissions);
+              local_permissions, remote_permissions);
    auto sharedMemHandle =
        SharedMemory::Create(g_handle_table.Get<Process>(KernelHandle::CurrentProcess), size,
                             static_cast<MemoryPermission>(local_permissions),
@@ -842,7 +839,7 @@ static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permiss
 }
 static ResultCode ClearEvent(Handle handle) {
-    NGLOG_TRACE(Kernel_SVC, "called, event=0x{:08X}", handle);
+    LOG_TRACE(Kernel_SVC, "called, event=0x{:08X}", handle);
    SharedPtr<Event> evt = g_handle_table.Get<Event>(handle);
    if (evt == nullptr)
@@ -994,7 +991,7 @@ static const FunctionDef SVC_Table[] = {
 static const FunctionDef* GetSVCInfo(u32 func_num) {
    if (func_num >= std::size(SVC_Table)) {
-        NGLOG_ERROR(Kernel_SVC, "Unknown svc=0x{:02X}", func_num);
+        LOG_ERROR(Kernel_SVC, "Unknown svc=0x{:02X}", func_num);
        return nullptr;
    }
    return &SVC_Table[func_num];
@@ -1013,10 +1010,10 @@ void CallSVC(u32 immediate) {
        if (info->func) {
            info->func();
        } else {
-            NGLOG_CRITICAL(Kernel_SVC, "Unimplemented SVC function {}(..)", info->name);
+            LOG_CRITICAL(Kernel_SVC, "Unimplemented SVC function {}(..)", info->name);
        }
    } else {
-        NGLOG_CRITICAL(Kernel_SVC, "Unknown SVC function 0x{:X}", immediate);
+        LOG_CRITICAL(Kernel_SVC, "Unknown SVC function 0x{:X}", immediate);
    }
 }
diff --git a/src/core/hle/kernel/thread.cpp b/src/core/hle/kernel/thread.cpp
index 2f333ec34..9a9746585 100644
--- a/src/core/hle/kernel/thread.cpp
+++ b/src/core/hle/kernel/thread.cpp
@@ -104,7 +104,7 @@ static void ThreadWakeupCallback(u64 thread_handle, int cycles_late) {
    const auto proper_handle = static_cast<Handle>(thread_handle);
    SharedPtr<Thread> thread = wakeup_callback_handle_table.Get<Thread>(proper_handle);
    if (thread == nullptr) {
-        NGLOG_CRITICAL(Kernel, "Callback fired for invalid thread {:08X}", proper_handle);
+        LOG_CRITICAL(Kernel, "Callback fired for invalid thread {:08X}", proper_handle);
        return;
    }
@@ -290,19 +290,19 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
                                            SharedPtr<Process> owner_process) {
    // Check if priority is in ranged. Lowest priority -> highest priority id.
    if (priority > THREADPRIO_LOWEST) {
-        NGLOG_ERROR(Kernel_SVC, "Invalid thread priority: {}", priority);
+        LOG_ERROR(Kernel_SVC, "Invalid thread priority: {}", priority);
        return ERR_OUT_OF_RANGE;
    }
    if (processor_id > THREADPROCESSORID_MAX) {
-        NGLOG_ERROR(Kernel_SVC, "Invalid processor id: {}", processor_id);
+        LOG_ERROR(Kernel_SVC, "Invalid processor id: {}", processor_id);
        return ERR_OUT_OF_RANGE_KERNEL;
    }
    // TODO(yuriks): Other checks, returning 0xD9001BEA
    if (!Memory::IsValidVirtualAddress(*owner_process, entry_point)) {
-        NGLOG_ERROR(Kernel_SVC, "(name={}): invalid entry {:016X}", name, entry_point);
+        LOG_ERROR(Kernel_SVC, "(name={}): invalid entry {:016X}", name, entry_point);
        // TODO (bunnei): Find the correct error code to use here
        return ResultCode(-1);
    }
@@ -343,8 +343,8 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
        auto& linheap_memory = memory_region->linear_heap_memory;
        if (linheap_memory->size() + Memory::PAGE_SIZE > memory_region->size) {
-            NGLOG_ERROR(Kernel_SVC,
+            LOG_ERROR(Kernel_SVC,
-                        "Not enough space in region to allocate a new TLS page for thread");
+                      "Not enough space in region to allocate a new TLS page for thread");
            return ERR_OUT_OF_MEMORY;
        }
diff --git a/src/core/hle/kernel/timer.cpp b/src/core/hle/kernel/timer.cpp
index 661356a97..0141125e4 100644
--- a/src/core/hle/kernel/timer.cpp
+++ b/src/core/hle/kernel/timer.cpp
@@ -78,7 +78,7 @@ void Timer::WakeupAllWaitingThreads() {
 }
 void Timer::Signal(int cycles_late) {
-    NGLOG_TRACE(Kernel, "Timer {} fired", GetObjectId());
+    LOG_TRACE(Kernel, "Timer {} fired", GetObjectId());
    signaled = true;
@@ -98,7 +98,7 @@ static void TimerCallback(u64 timer_handle, int cycles_late) {
        timer_callback_handle_table.Get<Timer>(static_cast<Handle>(timer_handle));
    if (timer == nullptr) {
-        NGLOG_CRITICAL(Kernel, "Callback fired for invalid timer {:016X}", timer_handle);
+        LOG_CRITICAL(Kernel, "Callback fired for invalid timer {:016X}", timer_handle);
        return;
    }
diff --git a/src/core/hle/kernel/vm_manager.cpp b/src/core/hle/kernel/vm_manager.cpp
index 676e5b282..034dd490e 100644
--- a/src/core/hle/kernel/vm_manager.cpp
+++ b/src/core/hle/kernel/vm_manager.cpp
@@ -242,12 +242,12 @@ void VMManager::RefreshMemoryBlockMappings(const std::vector<u8>* block) {
 void VMManager::LogLayout() const {
    for (const auto& p : vma_map) {
        const VirtualMemoryArea& vma = p.second;
-        NGLOG_DEBUG(Kernel, "{:016X} - {:016X} size: {:016X} {}{}{} {}", vma.base,
+        LOG_DEBUG(Kernel, "{:016X} - {:016X} size: {:016X} {}{}{} {}", vma.base,
-                    vma.base + vma.size, vma.size,
+                  vma.base + vma.size, vma.size,
-                    (u8)vma.permissions & (u8)VMAPermission::Read ? 'R' : '-',
+                  (u8)vma.permissions & (u8)VMAPermission::Read ? 'R' : '-',
-                    (u8)vma.permissions & (u8)VMAPermission::Write ? 'W' : '-',
+                  (u8)vma.permissions & (u8)VMAPermission::Write ? 'W' : '-',
-                    (u8)vma.permissions & (u8)VMAPermission::Execute ? 'X' : '-',
+                  (u8)vma.permissions & (u8)VMAPermission::Execute ? 'X' : '-',
-                    GetMemoryStateName(vma.meminfo_state));
+                  GetMemoryStateName(vma.meminfo_state));
    }
 }
@@ -392,22 +392,22 @@ void VMManager::UpdatePageTableForVMA(const VirtualMemoryArea& vma) {
 }
 u64 VMManager::GetTotalMemoryUsage() {
-    NGLOG_WARNING(Kernel, "(STUBBED) called");
+    LOG_WARNING(Kernel, "(STUBBED) called");
    return 0xF8000000;
 }
 u64 VMManager::GetTotalHeapUsage() {
-    NGLOG_WARNING(Kernel, "(STUBBED) called");
+    LOG_WARNING(Kernel, "(STUBBED) called");
    return 0x0;
 }
 VAddr VMManager::GetAddressSpaceBaseAddr() {
-    NGLOG_WARNING(Kernel, "(STUBBED) called");
+    LOG_WARNING(Kernel, "(STUBBED) called");
    return 0x8000000;
 }
 u64 VMManager::GetAddressSpaceSize() {
-    NGLOG_WARNING(Kernel, "(STUBBED) called");
+    LOG_WARNING(Kernel, "(STUBBED) called");
    return MAX_ADDRESS;
 }
diff --git a/src/core/hle/service/acc/acc.cpp b/src/core/hle/service/acc/acc.cpp
index f2fffa760..6bafb2dce 100644
--- a/src/core/hle/service/acc/acc.cpp
+++ b/src/core/hle/service/acc/acc.cpp
@@ -47,7 +47,7 @@ public:
 private:
    void GetBase(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_ACC, "(STUBBED) called");
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
        ProfileBase profile_base{};
        IPC::ResponseBuilder rb{ctx, 16};
        rb.Push(RESULT_SUCCESS);
@@ -72,14 +72,14 @@ public:
 private:
    void CheckAvailability(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_ACC, "(STUBBED) called");
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push(true); // TODO: Check when this is supposed to return true and when not
    }
    void GetAccountId(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_ACC, "(STUBBED) called");
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u64>(0x12345678ABCDEF);
@@ -87,14 +87,14 @@ private:
 };
 void Module::Interface::GetUserExistence(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_ACC, "(STUBBED) called");
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push(true); // TODO: Check when this is supposed to return true and when not
 }
 void Module::Interface::ListAllUsers(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_ACC, "(STUBBED) called");
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
    constexpr std::array<u128, 10> user_ids{DEFAULT_USER_ID};
    ctx.WriteBuffer(user_ids.data(), user_ids.size());
    IPC::ResponseBuilder rb{ctx, 2};
@@ -102,7 +102,7 @@ void Module::Interface::ListAllUsers(Kernel::HLERequestContext& ctx) {
 }
 void Module::Interface::ListOpenUsers(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_ACC, "(STUBBED) called");
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
    constexpr std::array<u128, 10> user_ids{DEFAULT_USER_ID};
    ctx.WriteBuffer(user_ids.data(), user_ids.size());
    IPC::ResponseBuilder rb{ctx, 2};
@@ -113,11 +113,11 @@ void Module::Interface::GetProfile(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IProfile>();
-    NGLOG_DEBUG(Service_ACC, "called");
+    LOG_DEBUG(Service_ACC, "called");
 }
 void Module::Interface::InitializeApplicationInfo(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_ACC, "(STUBBED) called");
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }
@@ -126,11 +126,11 @@ void Module::Interface::GetBaasAccountManagerForApplication(Kernel::HLERequestCo
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IManagerForApplication>();
-    NGLOG_DEBUG(Service_ACC, "called");
+    LOG_DEBUG(Service_ACC, "called");
 }
 void Module::Interface::GetLastOpenedUser(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_ACC, "(STUBBED) called");
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 6};
    rb.Push(RESULT_SUCCESS);
    rb.PushRaw(DEFAULT_USER_ID);
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index b8d6b8d4d..a871b3eaa 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -30,14 +30,14 @@ IWindowController::IWindowController() : ServiceFramework("IWindowController") {
 }
 void IWindowController::GetAppletResourceUserId(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u64>(0);
 }
 void IWindowController::AcquireForegroundRights(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }
@@ -56,20 +56,20 @@ IAudioController::IAudioController() : ServiceFramework("IAudioController") {
 }
 void IAudioController::SetExpectedMasterVolume(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }
 void IAudioController::GetMainAppletExpectedMasterVolume(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push(volume);
 }
 void IAudioController::GetLibraryAppletExpectedMasterVolume(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push(volume);
@@ -174,14 +174,14 @@ void ISelfController::SetFocusHandlingMode(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::SetRestartMessageEnabled(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::SetPerformanceModeChangedNotification(Kernel::HLERequestContext& ctx) {
@@ -192,14 +192,14 @@ void ISelfController::SetPerformanceModeChangedNotification(Kernel::HLERequestCo
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called flag={}", flag);
+    LOG_WARNING(Service_AM, "(STUBBED) called flag={}", flag);
 }
 void ISelfController::SetScreenShotPermission(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::SetOperationModeChangedNotification(Kernel::HLERequestContext& ctx) {
@@ -210,7 +210,7 @@ void ISelfController::SetOperationModeChangedNotification(Kernel::HLERequestCont
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called flag={}", flag);
+    LOG_WARNING(Service_AM, "(STUBBED) called flag={}", flag);
 }
 void ISelfController::SetOutOfFocusSuspendingEnabled(Kernel::HLERequestContext& ctx) {
@@ -223,21 +223,21 @@ void ISelfController::SetOutOfFocusSuspendingEnabled(Kernel::HLERequestContext&
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called enabled={}", enabled);
+    LOG_WARNING(Service_AM, "(STUBBED) called enabled={}", enabled);
 }
 void ISelfController::LockExit(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::UnlockExit(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& ctx) {
@@ -247,7 +247,7 @@ void ISelfController::GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext&
    rb.Push(RESULT_SUCCESS);
    rb.PushCopyObjects(launchable_event);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx) {
@@ -260,14 +260,14 @@ void ISelfController::CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx)
    rb.Push(RESULT_SUCCESS);
    rb.Push(layer_id);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ISelfController::SetHandlesRequestToDisplay(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 ICommonStateGetter::ICommonStateGetter() : ServiceFramework("ICommonStateGetter") {
@@ -311,7 +311,7 @@ void ICommonStateGetter::GetEventHandle(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.PushCopyObjects(event);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ICommonStateGetter::ReceiveMessage(Kernel::HLERequestContext& ctx) {
@@ -319,7 +319,7 @@ void ICommonStateGetter::ReceiveMessage(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(15);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ICommonStateGetter::GetCurrentFocusState(Kernel::HLERequestContext& ctx) {
@@ -327,7 +327,7 @@ void ICommonStateGetter::GetCurrentFocusState(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.Push(static_cast<u8>(FocusState::InFocus));
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ICommonStateGetter::GetOperationMode(Kernel::HLERequestContext& ctx) {
@@ -336,7 +336,7 @@ void ICommonStateGetter::GetOperationMode(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.Push(static_cast<u8>(use_docked_mode ? OperationMode::Docked : OperationMode::Handheld));
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void ICommonStateGetter::GetPerformanceMode(Kernel::HLERequestContext& ctx) {
@@ -346,7 +346,7 @@ void ICommonStateGetter::GetPerformanceMode(Kernel::HLERequestContext& ctx) {
    rb.Push(static_cast<u32>(use_docked_mode ? APM::PerformanceMode::Docked
                                             : APM::PerformanceMode::Handheld));
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 class IStorageAccessor final : public ServiceFramework<IStorageAccessor> {
@@ -370,7 +370,7 @@ private:
        rb.Push(RESULT_SUCCESS);
        rb.Push(static_cast<u64>(buffer.size()));
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void Write(Kernel::HLERequestContext& ctx) {
@@ -386,7 +386,7 @@ private:
        IPC::ResponseBuilder rb{rp.MakeBuilder(2, 0, 0)};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_DEBUG(Service_AM, "called, offset={}", offset);
+        LOG_DEBUG(Service_AM, "called, offset={}", offset);
    }
    void Read(Kernel::HLERequestContext& ctx) {
@@ -402,7 +402,7 @@ private:
        IPC::ResponseBuilder rb{rp.MakeBuilder(2, 0, 0)};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_DEBUG(Service_AM, "called, offset={}", offset);
+        LOG_DEBUG(Service_AM, "called, offset={}", offset);
    }
 };
@@ -426,7 +426,7 @@ private:
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<AM::IStorageAccessor>(buffer);
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
 };
@@ -467,21 +467,21 @@ private:
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(state_changed_event);
-        NGLOG_WARNING(Service_AM, "(STUBBED) called");
+        LOG_WARNING(Service_AM, "(STUBBED) called");
    }
    void GetResult(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_AM, "(STUBBED) called");
+        LOG_WARNING(Service_AM, "(STUBBED) called");
    }
    void Start(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_AM, "(STUBBED) called");
+        LOG_WARNING(Service_AM, "(STUBBED) called");
    }
    void PushInData(Kernel::HLERequestContext& ctx) {
@@ -491,7 +491,7 @@ private:
        IPC::ResponseBuilder rb{rp.MakeBuilder(2, 0, 0)};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void PopOutData(Kernel::HLERequestContext& ctx) {
@@ -501,7 +501,7 @@ private:
        storage_stack.pop();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    std::stack<std::shared_ptr<AM::IStorage>> storage_stack;
@@ -526,7 +526,7 @@ void ILibraryAppletCreator::CreateLibraryApplet(Kernel::HLERequestContext& ctx)
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<AM::ILibraryAppletAccessor>();
-    NGLOG_DEBUG(Service_AM, "called");
+    LOG_DEBUG(Service_AM, "called");
 }
 void ILibraryAppletCreator::CreateStorage(Kernel::HLERequestContext& ctx) {
@@ -538,7 +538,7 @@ void ILibraryAppletCreator::CreateStorage(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<AM::IStorage>(std::move(buffer));
-    NGLOG_DEBUG(Service_AM, "called, size={}", size);
+    LOG_DEBUG(Service_AM, "called, size={}", size);
 }
 IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationFunctions") {
@@ -602,21 +602,21 @@ void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<AM::IStorage>(buffer);
-    NGLOG_DEBUG(Service_AM, "called");
+    LOG_DEBUG(Service_AM, "called");
 }
 void IApplicationFunctions::CreateApplicationAndRequestToStartForQuest(
    Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void IApplicationFunctions::EnsureSaveData(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    u128 uid = rp.PopRaw<u128>();
-    NGLOG_WARNING(Service, "(STUBBED) called uid = {:016X}{:016X}", uid[1], uid[0]);
+    LOG_WARNING(Service, "(STUBBED) called uid = {:016X}{:016X}", uid[1], uid[0]);
    IPC::ResponseBuilder rb{ctx, 4};
@@ -644,7 +644,7 @@ void IApplicationFunctions::SetTerminateResult(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called, result=0x{:08X}", result);
+    LOG_WARNING(Service_AM, "(STUBBED) called, result=0x{:08X}", result);
 }
 void IApplicationFunctions::GetDisplayVersion(Kernel::HLERequestContext& ctx) {
@@ -652,7 +652,7 @@ void IApplicationFunctions::GetDisplayVersion(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.Push<u64>(1);
    rb.Push<u64>(0);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
@@ -660,20 +660,20 @@ void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(RESULT_SUCCESS);
    rb.Push(static_cast<u64>(Service::Set::LanguageCode::EN_US));
-    NGLOG_DEBUG(Service_AM, "called");
+    LOG_DEBUG(Service_AM, "called");
 }
 void IApplicationFunctions::InitializeGamePlayRecording(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void IApplicationFunctions::SetGamePlayRecordingState(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void IApplicationFunctions::NotifyRunning(Kernel::HLERequestContext& ctx) {
@@ -681,7 +681,7 @@ void IApplicationFunctions::NotifyRunning(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.Push<u8>(0); // Unknown, seems to be ignored by official processes
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void IApplicationFunctions::GetPseudoDeviceId(Kernel::HLERequestContext& ctx) {
@@ -692,7 +692,7 @@ void IApplicationFunctions::GetPseudoDeviceId(Kernel::HLERequestContext& ctx) {
    rb.Push<u64>(0);
    rb.Push<u64>(0);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 void InstallInterfaces(SM::ServiceManager& service_manager,
@@ -717,7 +717,7 @@ IHomeMenuFunctions::IHomeMenuFunctions() : ServiceFramework("IHomeMenuFunctions"
 void IHomeMenuFunctions::RequestToGetForeground(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 IGlobalStateController::IGlobalStateController() : ServiceFramework("IGlobalStateController") {
diff --git a/src/core/hle/service/am/applet_ae.cpp b/src/core/hle/service/am/applet_ae.cpp
index 7ce551de3..180057ec2 100644
--- a/src/core/hle/service/am/applet_ae.cpp
+++ b/src/core/hle/service/am/applet_ae.cpp
@@ -33,63 +33,63 @@ private:
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ICommonStateGetter>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetSelfController(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ISelfController>(nvflinger);
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetWindowController(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IWindowController>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetAudioController(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IAudioController>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetDisplayController(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IDisplayController>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetProcessWindingController(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IProcessWindingController>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetDebugFunctions(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IDebugFunctions>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetLibraryAppletCreator(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ILibraryAppletCreator>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetApplicationFunctions(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IApplicationFunctions>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
@@ -120,70 +120,70 @@ private:
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ICommonStateGetter>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetSelfController(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ISelfController>(nvflinger);
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetWindowController(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IWindowController>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetAudioController(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IAudioController>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetDisplayController(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IDisplayController>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetDebugFunctions(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IDebugFunctions>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetLibraryAppletCreator(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ILibraryAppletCreator>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetHomeMenuFunctions(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IHomeMenuFunctions>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetGlobalStateController(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IGlobalStateController>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetApplicationCreator(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IApplicationCreator>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
 };
@@ -192,21 +192,21 @@ void AppletAE::OpenSystemAppletProxy(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ISystemAppletProxy>(nvflinger);
-    NGLOG_DEBUG(Service_AM, "called");
+    LOG_DEBUG(Service_AM, "called");
 }
 void AppletAE::OpenLibraryAppletProxy(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger);
-    NGLOG_DEBUG(Service_AM, "called");
+    LOG_DEBUG(Service_AM, "called");
 }
 void AppletAE::OpenLibraryAppletProxyOld(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger);
-    NGLOG_DEBUG(Service_AM, "called");
+    LOG_DEBUG(Service_AM, "called");
 }
 AppletAE::AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
diff --git a/src/core/hle/service/am/applet_oe.cpp b/src/core/hle/service/am/applet_oe.cpp
index 587a922fe..278259eda 100644
--- a/src/core/hle/service/am/applet_oe.cpp
+++ b/src/core/hle/service/am/applet_oe.cpp
@@ -33,56 +33,56 @@ private:
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IAudioController>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetDisplayController(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IDisplayController>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetDebugFunctions(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IDebugFunctions>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetWindowController(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IWindowController>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetSelfController(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ISelfController>(nvflinger);
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetCommonStateGetter(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ICommonStateGetter>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetLibraryAppletCreator(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<ILibraryAppletCreator>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    void GetApplicationFunctions(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IApplicationFunctions>();
-        NGLOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service_AM, "called");
    }
    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
@@ -92,7 +92,7 @@ void AppletOE::OpenApplicationProxy(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IApplicationProxy>(nvflinger);
-    NGLOG_DEBUG(Service_AM, "called");
+    LOG_DEBUG(Service_AM, "called");
 }
 AppletOE::AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
diff --git a/src/core/hle/service/aoc/aoc_u.cpp b/src/core/hle/service/aoc/aoc_u.cpp
index 5b6dfb48f..6e7438580 100644
--- a/src/core/hle/service/aoc/aoc_u.cpp
+++ b/src/core/hle/service/aoc/aoc_u.cpp
@@ -27,14 +27,14 @@ void AOC_U::CountAddOnContent(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u64>(0);
-    NGLOG_WARNING(Service_AOC, "(STUBBED) called");
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
 }
 void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u64>(0);
-    NGLOG_WARNING(Service_AOC, "(STUBBED) called");
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
 }
 void InstallInterfaces(SM::ServiceManager& service_manager) {
diff --git a/src/core/hle/service/apm/interface.cpp b/src/core/hle/service/apm/interface.cpp
index 3a03188ce..751d73f8d 100644
--- a/src/core/hle/service/apm/interface.cpp
+++ b/src/core/hle/service/apm/interface.cpp
@@ -29,8 +29,8 @@ private:
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_APM, "(STUBBED) called mode={} config={}", static_cast<u32>(mode),
+        LOG_WARNING(Service_APM, "(STUBBED) called mode={} config={}", static_cast<u32>(mode),
-                      config);
+                    config);
    }
    void GetPerformanceConfiguration(Kernel::HLERequestContext& ctx) {
@@ -42,7 +42,7 @@ private:
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(0); // Performance configuration
-        NGLOG_WARNING(Service_APM, "(STUBBED) called mode={}", static_cast<u32>(mode));
+        LOG_WARNING(Service_APM, "(STUBBED) called mode={}", static_cast<u32>(mode));
    }
 };
diff --git a/src/core/hle/service/audio/audio.cpp b/src/core/hle/service/audio/audio.cpp
index 92f910b5f..d231e91e1 100644
--- a/src/core/hle/service/audio/audio.cpp
+++ b/src/core/hle/service/audio/audio.cpp
@@ -8,6 +8,7 @@
 #include "core/hle/service/audio/audrec_u.h"
 #include "core/hle/service/audio/audren_u.h"
 #include "core/hle/service/audio/codecctl.h"
+#include "core/hle/service/audio/hwopus.h"
 namespace Service::Audio {
@@ -17,6 +18,7 @@ void InstallInterfaces(SM::ServiceManager& service_manager) {
    std::make_shared<AudRecU>()->InstallAsService(service_manager);
    std::make_shared<AudRenU>()->InstallAsService(service_manager);
    std::make_shared<CodecCtl>()->InstallAsService(service_manager);
+    std::make_shared<HwOpus>()->InstallAsService(service_manager);
 }
 } // namespace Service::Audio
diff --git a/src/core/hle/service/audio/audout_u.cpp b/src/core/hle/service/audio/audout_u.cpp
index 402eaa306..1b4b649d8 100644
--- a/src/core/hle/service/audio/audout_u.cpp
+++ b/src/core/hle/service/audio/audout_u.cpp
@@ -60,14 +60,14 @@ public:
 private:
    void GetAudioOutState(Kernel::HLERequestContext& ctx) {
-        NGLOG_DEBUG(Service_Audio, "called");
+        LOG_DEBUG(Service_Audio, "called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push(static_cast<u32>(audio_out_state));
    }
    void StartAudioOut(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
        // Start audio
        audio_out_state = AudioState::Started;
@@ -77,7 +77,7 @@ private:
    }
    void StopAudioOut(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
        // Stop audio
        audio_out_state = AudioState::Stopped;
@@ -89,7 +89,7 @@ private:
    }
    void RegisterBufferEvent(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
@@ -97,7 +97,7 @@ private:
    }
    void AppendAudioOutBuffer(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        const u64 key{rp.Pop<u64>()};
@@ -108,7 +108,7 @@ private:
    }
    void GetReleasedAudioOutBuffer(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
        // TODO(st4rk): This is how libtransistor currently implements the
        // GetReleasedAudioOutBuffer, it should return the key (a VAddr) to the app and this address
@@ -164,7 +164,7 @@ private:
 };
 void AudOutU::ListAudioOuts(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+    LOG_WARNING(Service_Audio, "(STUBBED) called");
    IPC::RequestParser rp{ctx};
    const std::string audio_interface = "AudioInterface";
@@ -180,7 +180,7 @@ void AudOutU::ListAudioOuts(Kernel::HLERequestContext& ctx) {
 }
 void AudOutU::OpenAudioOut(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+    LOG_WARNING(Service_Audio, "(STUBBED) called");
    if (!audio_out_interface) {
        audio_out_interface = std::make_shared<IAudioOut>();
diff --git a/src/core/hle/service/audio/audren_u.cpp b/src/core/hle/service/audio/audren_u.cpp
index 2188b5625..2da936b27 100644
--- a/src/core/hle/service/audio/audren_u.cpp
+++ b/src/core/hle/service/audio/audren_u.cpp
@@ -47,6 +47,7 @@ public:
        // Start the audio event
        CoreTiming::ScheduleEvent(audio_ticks, audio_event);
+        voice_status_list.reserve(worker_params.voice_count);
    }
    ~IAudioRenderer() {
        CoreTiming::UnscheduleEvent(audio_event, 0);
@@ -68,6 +69,12 @@ private:
                    buf.data() + sizeof(UpdateDataHeader) + config.behavior_size,
                    memory_pool_count * sizeof(MemoryPoolInfo));
+        std::vector<VoiceInfo> voice_info(worker_params.voice_count);
+        std::memcpy(voice_info.data(),
+                    buf.data() + sizeof(UpdateDataHeader) + config.behavior_size +
+                        config.memory_pools_size + config.voice_resource_size,
+                    worker_params.voice_count * sizeof(VoiceInfo));
        UpdateDataHeader response_data{worker_params};
        ASSERT(ctx.GetWriteBufferSize() == response_data.total_size);
@@ -86,12 +93,29 @@ private:
        std::memcpy(output.data() + sizeof(UpdateDataHeader), memory_pool.data(),
                    response_data.memory_pools_size);
+        for (unsigned i = 0; i < voice_info.size(); i++) {
+            if (voice_info[i].is_new) {
+                voice_status_list[i].played_sample_count = 0;
+                voice_status_list[i].wave_buffer_consumed = 0;
+            } else if (voice_info[i].play_state == (u8)PlayStates::Started) {
+                for (u32 buff_idx = 0; buff_idx < voice_info[i].wave_buffer_count; buff_idx++) {
+                    voice_status_list[i].played_sample_count +=
+                        (voice_info[i].wave_buffer[buff_idx].end_sample_offset -
+                         voice_info[i].wave_buffer[buff_idx].start_sample_offset) /
+                        2;
+                    voice_status_list[i].wave_buffer_consumed++;
+                }
+            }
+        }
+        std::memcpy(output.data() + sizeof(UpdateDataHeader) + response_data.memory_pools_size,
+                    voice_status_list.data(), response_data.voices_size);
        ctx.WriteBuffer(output);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
    }
    void StartAudioRenderer(Kernel::HLERequestContext& ctx) {
@@ -99,7 +123,7 @@ private:
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
    }
    void StopAudioRenderer(Kernel::HLERequestContext& ctx) {
@@ -107,7 +131,7 @@ private:
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
    }
    void QuerySystemEvent(Kernel::HLERequestContext& ctx) {
@@ -117,7 +141,7 @@ private:
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(system_event);
-        NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
    }
    enum class MemoryPoolStates : u32 { // Should be LE
@@ -130,6 +154,11 @@ private:
        Released = 0x6,
    };
+    enum class PlayStates : u8 {
+        Started = 0,
+        Stopped = 1,
+    };
    struct MemoryPoolEntry {
        MemoryPoolStates state;
        u32_le unknown_4;
@@ -150,7 +179,7 @@ private:
        UpdateDataHeader() {}
        UpdateDataHeader(const AudioRendererParameter& config) {
-            revision = config.revision;
+            revision = Common::MakeMagic('R', 'E', 'V', '4'); // 5.1.0 Revision
            behavior_size = 0xb0;
            memory_pools_size = (config.effect_count + (config.voice_count * 4)) * 0x10;
            voices_size = config.voice_count * 0x10;
@@ -175,11 +204,69 @@ private:
    };
    static_assert(sizeof(UpdateDataHeader) == 0x40, "UpdateDataHeader has wrong size");
+    struct BiquadFilter {
+        u8 enable;
+        INSERT_PADDING_BYTES(1);
+        s16_le numerator[3];
+        s16_le denominator[2];
+    };
+    static_assert(sizeof(BiquadFilter) == 0xc, "BiquadFilter has wrong size");
+    struct WaveBuffer {
+        u64_le buffer_addr;
+        u64_le buffer_sz;
+        s32_le start_sample_offset;
+        s32_le end_sample_offset;
+        u8 loop;
+        u8 end_of_stream;
+        u8 sent_to_server;
+        INSERT_PADDING_BYTES(5);
+        u64 context_addr;
+        u64 context_sz;
+        INSERT_PADDING_BYTES(8);
+    };
+    static_assert(sizeof(WaveBuffer) == 0x38, "WaveBuffer has wrong size");
+    struct VoiceInfo {
+        u32_le id;
+        u32_le node_id;
+        u8 is_new;
+        u8 is_in_use;
+        u8 play_state;
+        u8 sample_format;
+        u32_le sample_rate;
+        u32_le priority;
+        u32_le sorting_order;
+        u32_le channel_count;
+        float_le pitch;
+        float_le volume;
+        BiquadFilter biquad_filter[2];
+        u32_le wave_buffer_count;
+        u16_le wave_buffer_head;
+        INSERT_PADDING_BYTES(6);
+        u64_le additional_params_addr;
+        u64_le additional_params_sz;
+        u32_le mix_id;
+        u32_le splitter_info_id;
+        WaveBuffer wave_buffer[4];
+        u32_le voice_channel_resource_ids[6];
+        INSERT_PADDING_BYTES(24);
+    };
+    static_assert(sizeof(VoiceInfo) == 0x170, "VoiceInfo is wrong size");
+    struct VoiceOutStatus {
+        u64_le played_sample_count;
+        u32_le wave_buffer_consumed;
+        INSERT_PADDING_WORDS(1);
+    };
+    static_assert(sizeof(VoiceOutStatus) == 0x10, "VoiceOutStatus has wrong size");
    /// This is used to trigger the audio event callback.
    CoreTiming::EventType* audio_event;
    Kernel::SharedPtr<Kernel::Event> system_event;
    AudioRendererParameter worker_params;
+    std::vector<VoiceOutStatus> voice_status_list;
 };
 class IAudioDevice final : public ServiceFramework<IAudioDevice> {
@@ -208,7 +295,7 @@ public:
 private:
    void ListAudioDeviceName(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        const std::string audio_interface = "AudioInterface";
@@ -220,7 +307,7 @@ private:
    }
    void SetAudioDeviceOutputVolume(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        f32 volume = static_cast<f32>(rp.Pop<u32>());
@@ -233,7 +320,7 @@ private:
    }
    void GetActiveAudioDeviceName(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        const std::string audio_interface = "AudioDevice";
@@ -245,7 +332,7 @@ private:
    }
    void QueryAudioDeviceSystemEvent(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
        buffer_event->Signal();
@@ -255,7 +342,7 @@ private:
    }
    void GetActiveChannelCount(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(1);
@@ -284,7 +371,7 @@ void AudRenU::OpenAudioRenderer(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<Audio::IAudioRenderer>(std::move(params));
-    NGLOG_DEBUG(Service_Audio, "called");
+    LOG_DEBUG(Service_Audio, "called");
 }
 void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
@@ -343,7 +430,7 @@ void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.Push<u64>(output_sz);
-    NGLOG_DEBUG(Service_Audio, "called, buffer_size=0x{:X}", output_sz);
+    LOG_DEBUG(Service_Audio, "called, buffer_size=0x{:X}", output_sz);
 }
 void AudRenU::GetAudioDevice(Kernel::HLERequestContext& ctx) {
@@ -352,7 +439,7 @@ void AudRenU::GetAudioDevice(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<Audio::IAudioDevice>();
-    NGLOG_DEBUG(Service_Audio, "called");
+    LOG_DEBUG(Service_Audio, "called");
 }
 bool AudRenU::IsFeatureSupported(AudioFeatures feature, u32_le revision) const {
diff --git a/src/core/hle/service/audio/hwopus.cpp b/src/core/hle/service/audio/hwopus.cpp
new file mode 100644
index 000000000..844df382c
--- /dev/null
+++ b/src/core/hle/service/audio/hwopus.cpp
@@ -0,0 +1,29 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/hle_ipc.h"
+#include "core/hle/service/audio/hwopus.h"
+namespace Service::Audio {
+void HwOpus::GetWorkBufferSize(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_Audio, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push<u32>(0x4000);
+}
+HwOpus::HwOpus() : ServiceFramework("hwopus") {
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "Initialize"},
+        {1, &HwOpus::GetWorkBufferSize, "GetWorkBufferSize"},
+        {2, nullptr, "InitializeMultiStream"},
+        {3, nullptr, "GetWorkBufferSizeMultiStream"},
+    };
+    RegisterHandlers(functions);
+}
+} // namespace Service::Audio
diff --git a/src/core/hle/service/audio/hwopus.h b/src/core/hle/service/audio/hwopus.h
new file mode 100644
index 000000000..090b8c825
--- /dev/null
+++ b/src/core/hle/service/audio/hwopus.h
@@ -0,0 +1,20 @@
+// 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::Audio {
+class HwOpus final : public ServiceFramework<HwOpus> {
+public:
+    explicit HwOpus();
+    ~HwOpus() = default;
+private:
+    void GetWorkBufferSize(Kernel::HLERequestContext& ctx);
+};
+} // namespace Service::Audio
diff --git a/src/core/hle/service/bcat/module.cpp b/src/core/hle/service/bcat/module.cpp
index 52be9db22..35e024c3d 100644
--- a/src/core/hle/service/bcat/module.cpp
+++ b/src/core/hle/service/bcat/module.cpp
@@ -36,7 +36,7 @@ void Module::Interface::CreateBcatService(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IBcatService>();
-    NGLOG_DEBUG(Service_BCAT, "called");
+    LOG_DEBUG(Service_BCAT, "called");
 }
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
diff --git a/src/core/hle/service/fatal/fatal.cpp b/src/core/hle/service/fatal/fatal.cpp
index 2d4282209..299b9474f 100644
--- a/src/core/hle/service/fatal/fatal.cpp
+++ b/src/core/hle/service/fatal/fatal.cpp
@@ -16,13 +16,13 @@ Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
 void Module::Interface::ThrowFatalWithPolicy(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp(ctx);
    u32 error_code = rp.Pop<u32>();
-    NGLOG_WARNING(Service_Fatal, "(STUBBED) called, error_code=0x{:X}", error_code);
+    LOG_WARNING(Service_Fatal, "(STUBBED) called, error_code=0x{:X}", error_code);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }
 void Module::Interface::ThrowFatalWithCpuContext(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_Fatal, "(STUBBED) called");
+    LOG_WARNING(Service_Fatal, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }
diff --git a/src/core/hle/service/filesystem/filesystem.cpp b/src/core/hle/service/filesystem/filesystem.cpp
index 68d1c90a5..f58b518b6 100644
--- a/src/core/hle/service/filesystem/filesystem.cpp
+++ b/src/core/hle/service/filesystem/filesystem.cpp
@@ -25,14 +25,14 @@ ResultCode RegisterFileSystem(std::unique_ptr<FileSys::FileSystemFactory>&& fact
    ASSERT_MSG(inserted, "Tried to register more than one system with same id code");
    auto& filesystem = result.first->second;
-    NGLOG_DEBUG(Service_FS, "Registered file system {} with id code 0x{:08X}",
+    LOG_DEBUG(Service_FS, "Registered file system {} with id code 0x{:08X}", filesystem->GetName(),
-                filesystem->GetName(), static_cast<u32>(type));
+              static_cast<u32>(type));
    return RESULT_SUCCESS;
 }
 ResultVal<std::unique_ptr<FileSys::FileSystemBackend>> OpenFileSystem(Type type,
                                                                      FileSys::Path& path) {
-    NGLOG_TRACE(Service_FS, "Opening FileSystem with type={}", static_cast<u32>(type));
+    LOG_TRACE(Service_FS, "Opening FileSystem with type={}", static_cast<u32>(type));
    auto itr = filesystem_map.find(type);
    if (itr == filesystem_map.end()) {
@@ -44,7 +44,7 @@ ResultVal<std::unique_ptr<FileSys::FileSystemBackend>> OpenFileSystem(Type type,
 }
 ResultCode FormatFileSystem(Type type) {
-    NGLOG_TRACE(Service_FS, "Formatting FileSystem with type={}", static_cast<u32>(type));
+    LOG_TRACE(Service_FS, "Formatting FileSystem with type={}", static_cast<u32>(type));
    auto itr = filesystem_map.find(type);
    if (itr == filesystem_map.end()) {
diff --git a/src/core/hle/service/filesystem/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp_srv.cpp
index 1cf97e876..216bfea0a 100644
--- a/src/core/hle/service/filesystem/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp_srv.cpp
@@ -36,7 +36,7 @@ private:
        const s64 offset = rp.Pop<s64>();
        const s64 length = rp.Pop<s64>();
-        NGLOG_DEBUG(Service_FS, "called, offset=0x{:X}, length={}", offset, length);
+        LOG_DEBUG(Service_FS, "called, offset=0x{:X}, length={}", offset, length);
        // Error checking
        if (length < 0) {
@@ -88,7 +88,7 @@ private:
        const s64 offset = rp.Pop<s64>();
        const s64 length = rp.Pop<s64>();
-        NGLOG_DEBUG(Service_FS, "called, offset=0x{:X}, length={}", offset, length);
+        LOG_DEBUG(Service_FS, "called, offset=0x{:X}, length={}", offset, length);
        // Error checking
        if (length < 0) {
@@ -125,7 +125,7 @@ private:
        const s64 offset = rp.Pop<s64>();
        const s64 length = rp.Pop<s64>();
-        NGLOG_DEBUG(Service_FS, "called, offset=0x{:X}, length={}", offset, length);
+        LOG_DEBUG(Service_FS, "called, offset=0x{:X}, length={}", offset, length);
        // Error checking
        if (length < 0) {
@@ -153,7 +153,7 @@ private:
    }
    void Flush(Kernel::HLERequestContext& ctx) {
-        NGLOG_DEBUG(Service_FS, "called");
+        LOG_DEBUG(Service_FS, "called");
        backend->Flush();
        IPC::ResponseBuilder rb{ctx, 2};
@@ -164,7 +164,7 @@ private:
        IPC::RequestParser rp{ctx};
        const u64 size = rp.Pop<u64>();
        backend->SetSize(size);
-        NGLOG_DEBUG(Service_FS, "called, size={}", size);
+        LOG_DEBUG(Service_FS, "called, size={}", size);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
@@ -172,7 +172,7 @@ private:
    void GetSize(Kernel::HLERequestContext& ctx) {
        const u64 size = backend->GetSize();
-        NGLOG_DEBUG(Service_FS, "called, size={}", size);
+        LOG_DEBUG(Service_FS, "called, size={}", size);
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(RESULT_SUCCESS);
@@ -198,7 +198,7 @@ private:
        IPC::RequestParser rp{ctx};
        const u64 unk = rp.Pop<u64>();
-        NGLOG_DEBUG(Service_FS, "called, unk=0x{:X}", unk);
+        LOG_DEBUG(Service_FS, "called, unk=0x{:X}", unk);
        // Calculate how many entries we can fit in the output buffer
        u64 count_entries = ctx.GetWriteBufferSize() / sizeof(FileSys::Entry);
@@ -220,7 +220,7 @@ private:
    }
    void GetEntryCount(Kernel::HLERequestContext& ctx) {
-        NGLOG_DEBUG(Service_FS, "called");
+        LOG_DEBUG(Service_FS, "called");
        u64 count = backend->GetEntryCount();
@@ -264,7 +264,7 @@ public:
        u64 mode = rp.Pop<u64>();
        u32 size = rp.Pop<u32>();
-        NGLOG_DEBUG(Service_FS, "called file {} mode 0x{:X} size 0x{:08X}", name, mode, size);
+        LOG_DEBUG(Service_FS, "called file {} mode 0x{:X} size 0x{:08X}", name, mode, size);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(backend->CreateFile(name, size));
@@ -276,7 +276,7 @@ public:
        auto file_buffer = ctx.ReadBuffer();
        std::string name = Common::StringFromBuffer(file_buffer);
-        NGLOG_DEBUG(Service_FS, "called file {}", name);
+        LOG_DEBUG(Service_FS, "called file {}", name);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(backend->DeleteFile(name));
@@ -288,7 +288,7 @@ public:
        auto file_buffer = ctx.ReadBuffer();
        std::string name = Common::StringFromBuffer(file_buffer);
-        NGLOG_DEBUG(Service_FS, "called directory {}", name);
+        LOG_DEBUG(Service_FS, "called directory {}", name);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(backend->CreateDirectory(name));
@@ -306,7 +306,7 @@ public:
        Memory::ReadBlock(ctx.BufferDescriptorX()[1].Address(), buffer.data(), buffer.size());
        std::string dst_name = Common::StringFromBuffer(buffer);
-        NGLOG_DEBUG(Service_FS, "called file '{}' to file '{}'", src_name, dst_name);
+        LOG_DEBUG(Service_FS, "called file '{}' to file '{}'", src_name, dst_name);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(backend->RenameFile(src_name, dst_name));
@@ -320,7 +320,7 @@ public:
        auto mode = static_cast<FileSys::Mode>(rp.Pop<u32>());
-        NGLOG_DEBUG(Service_FS, "called file {} mode {}", name, static_cast<u32>(mode));
+        LOG_DEBUG(Service_FS, "called file {} mode {}", name, static_cast<u32>(mode));
        auto result = backend->OpenFile(name, mode);
        if (result.Failed()) {
@@ -345,7 +345,7 @@ public:
        // TODO(Subv): Implement this filter.
        u32 filter_flags = rp.Pop<u32>();
-        NGLOG_DEBUG(Service_FS, "called directory {} filter {}", name, filter_flags);
+        LOG_DEBUG(Service_FS, "called directory {} filter {}", name, filter_flags);
        auto result = backend->OpenDirectory(name);
        if (result.Failed()) {
@@ -367,7 +367,7 @@ public:
        auto file_buffer = ctx.ReadBuffer();
        std::string name = Common::StringFromBuffer(file_buffer);
-        NGLOG_DEBUG(Service_FS, "called file {}", name);
+        LOG_DEBUG(Service_FS, "called file {}", name);
        auto result = backend->GetEntryType(name);
        if (result.Failed()) {
@@ -382,7 +382,7 @@ public:
    }
    void Commit(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_FS, "(STUBBED) called");
+        LOG_WARNING(Service_FS, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
@@ -498,14 +498,14 @@ void FSP_SRV::TryLoadRomFS() {
 }
 void FSP_SRV::Initialize(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_FS, "(STUBBED) called");
+    LOG_WARNING(Service_FS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }
 void FSP_SRV::MountSdCard(Kernel::HLERequestContext& ctx) {
-    NGLOG_DEBUG(Service_FS, "called");
+    LOG_DEBUG(Service_FS, "called");
    FileSys::Path unused;
    auto filesystem = OpenFileSystem(Type::SDMC, unused).Unwrap();
@@ -522,14 +522,14 @@ void FSP_SRV::CreateSaveData(Kernel::HLERequestContext& ctx) {
    auto save_create_struct = rp.PopRaw<std::array<u8, 0x40>>();
    u128 uid = rp.PopRaw<u128>();
-    NGLOG_WARNING(Service_FS, "(STUBBED) called uid = {:016X}{:016X}", uid[1], uid[0]);
+    LOG_WARNING(Service_FS, "(STUBBED) called uid = {:016X}{:016X}", uid[1], uid[0]);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }
 void FSP_SRV::MountSaveData(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_FS, "(STUBBED) called");
+    LOG_WARNING(Service_FS, "(STUBBED) called");
    FileSys::Path unused;
    auto filesystem = OpenFileSystem(Type::SaveData, unused).Unwrap();
@@ -540,7 +540,7 @@ void FSP_SRV::MountSaveData(Kernel::HLERequestContext& ctx) {
 }
 void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_FS, "(STUBBED) called");
+    LOG_WARNING(Service_FS, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
@@ -548,12 +548,12 @@ void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
 }
 void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
-    NGLOG_DEBUG(Service_FS, "called");
+    LOG_DEBUG(Service_FS, "called");
    TryLoadRomFS();
    if (!romfs) {
        // TODO (bunnei): Find the right error code to use here
-        NGLOG_CRITICAL(Service_FS, "no file system interface available!");
+        LOG_CRITICAL(Service_FS, "no file system interface available!");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(ResultCode(-1));
        return;
@@ -562,7 +562,7 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
    // Attempt to open a StorageBackend interface to the RomFS
    auto storage = romfs->OpenFile({}, {});
    if (storage.Failed()) {
-        NGLOG_CRITICAL(Service_FS, "no storage interface available!");
+        LOG_CRITICAL(Service_FS, "no storage interface available!");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(storage.Code());
        return;
@@ -574,7 +574,7 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
 }
 void FSP_SRV::OpenRomStorage(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_FS, "(STUBBED) called, using OpenDataStorageByCurrentProcess");
+    LOG_WARNING(Service_FS, "(STUBBED) called, using OpenDataStorageByCurrentProcess");
    OpenDataStorageByCurrentProcess(ctx);
 }
diff --git a/src/core/hle/service/friend/friend.cpp b/src/core/hle/service/friend/friend.cpp
index 94d9fbf25..c98a46e05 100644
--- a/src/core/hle/service/friend/friend.cpp
+++ b/src/core/hle/service/friend/friend.cpp
@@ -13,7 +13,7 @@ namespace Service::Friend {
 void Module::Interface::CreateFriendService(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_WARNING(Service_Friend, "(STUBBED) called");
+    LOG_WARNING(Service_Friend, "(STUBBED) called");
 }
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 2696a8bf0..b0f4a384e 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -53,7 +53,7 @@ private:
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(shared_mem);
-        NGLOG_DEBUG(Service_HID, "called");
+        LOG_DEBUG(Service_HID, "called");
    }
    void LoadInputDevices() {
@@ -75,7 +75,7 @@ private:
        // 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 | ControllerType_JoyconPair;
+        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;
@@ -84,23 +84,21 @@ private:
        for (size_t controller = 0; controller < mem.controllers.size(); controller++) {
            for (int index = 0; index < HID_NUM_LAYOUTS; index++) {
-                // TODO(DarkLordZach): Is this layout/controller config actually invalid?
-                if (controller == Controller_Handheld && index == Layout_Single)
-                    continue;
                ControllerLayout& layout = mem.controllers[controller].layouts[index];
                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++;
+                entry.timestamp = last_entry.timestamp + 1;
                // TODO(shinyquagsire23): Is this always identical to timestamp?
-                entry.timestamp_2++;
+                entry.timestamp_2 = entry.timestamp;
                // TODO(shinyquagsire23): More than just handheld input
                if (controller != Controller_Handheld)
@@ -267,7 +265,7 @@ private:
    void ActivateVibrationDevice(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
 };
@@ -399,144 +397,144 @@ private:
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IAppletResource>(applet_resource);
-        NGLOG_DEBUG(Service_HID, "called");
+        LOG_DEBUG(Service_HID, "called");
    }
    void ActivateDebugPad(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void ActivateTouchScreen(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void ActivateMouse(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void ActivateKeyboard(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void StartSixAxisSensor(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void SetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void SetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void GetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(0);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void SetSupportedNpadIdType(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void ActivateNpad(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void AcquireNpadStyleSetUpdateEventHandle(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(event);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void GetPlayerLedPattern(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void SetNpadJoyHoldType(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void GetNpadJoyHoldType(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push(joy_hold_type);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void SetNpadJoyAssignmentModeSingleByDefault(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void SendVibrationValue(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void GetActualVibrationValue(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void SetNpadJoyAssignmentModeDual(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void SetNpadHandheldActivationMode(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void GetVibrationDeviceInfo(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u64>(0);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
    void CreateActiveVibrationDeviceList(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IActiveVibrationDeviceList>();
-        NGLOG_DEBUG(Service_HID, "called");
+        LOG_DEBUG(Service_HID, "called");
    }
    void SendVibrationValues(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_HID, "(STUBBED) called");
+        LOG_WARNING(Service_HID, "(STUBBED) called");
    }
 };
diff --git a/src/core/hle/service/lm/lm.cpp b/src/core/hle/service/lm/lm.cpp
index 46194643e..e85a8bdb9 100644
--- a/src/core/hle/service/lm/lm.cpp
+++ b/src/core/hle/service/lm/lm.cpp
@@ -141,19 +141,19 @@ private:
        if (header.IsTailLog()) {
            switch (header.severity) {
            case MessageHeader::Severity::Trace:
-                NGLOG_TRACE(Debug_Emulated, "{}", log_stream.str());
+                LOG_TRACE(Debug_Emulated, "{}", log_stream.str());
                break;
            case MessageHeader::Severity::Info:
-                NGLOG_INFO(Debug_Emulated, "{}", log_stream.str());
+                LOG_INFO(Debug_Emulated, "{}", log_stream.str());
                break;
            case MessageHeader::Severity::Warning:
-                NGLOG_WARNING(Debug_Emulated, "{}", log_stream.str());
+                LOG_WARNING(Debug_Emulated, "{}", log_stream.str());
                break;
            case MessageHeader::Severity::Error:
-                NGLOG_ERROR(Debug_Emulated, "{}", log_stream.str());
+                LOG_ERROR(Debug_Emulated, "{}", log_stream.str());
                break;
            case MessageHeader::Severity::Critical:
-                NGLOG_CRITICAL(Debug_Emulated, "{}", log_stream.str());
+                LOG_CRITICAL(Debug_Emulated, "{}", log_stream.str());
                break;
            }
        }
@@ -178,7 +178,7 @@ void LM::Initialize(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<Logger>();
-    NGLOG_DEBUG(Service_LM, "called");
+    LOG_DEBUG(Service_LM, "called");
 }
 LM::LM() : ServiceFramework("lm") {
diff --git a/src/core/hle/service/mm/mm_u.cpp b/src/core/hle/service/mm/mm_u.cpp
index b3a85b818..08f45b78a 100644
--- a/src/core/hle/service/mm/mm_u.cpp
+++ b/src/core/hle/service/mm/mm_u.cpp
@@ -14,7 +14,7 @@ void InstallInterfaces(SM::ServiceManager& service_manager) {
 }
 void MM_U::Initialize(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_MM, "(STUBBED) called");
+    LOG_WARNING(Service_MM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }
@@ -25,13 +25,13 @@ void MM_U::SetAndWait(Kernel::HLERequestContext& ctx) {
    max = rp.Pop<u32>();
    current = min;
-    NGLOG_WARNING(Service_MM, "(STUBBED) called, min=0x{:X}, max=0x{:X}", min, max);
+    LOG_WARNING(Service_MM, "(STUBBED) called, min=0x{:X}, max=0x{:X}", min, max);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }
 void MM_U::Get(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_MM, "(STUBBED) called");
+    LOG_WARNING(Service_MM, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push(current);
diff --git a/src/core/hle/service/nfp/nfp.cpp b/src/core/hle/service/nfp/nfp.cpp
index 2a9f84037..56b05e9e8 100644
--- a/src/core/hle/service/nfp/nfp.cpp
+++ b/src/core/hle/service/nfp/nfp.cpp
@@ -64,7 +64,7 @@ private:
    };
    void Initialize(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_NFP, "(STUBBED) called");
+        LOG_WARNING(Service_NFP, "(STUBBED) called");
        state = State::Initialized;
@@ -78,7 +78,7 @@ private:
        ctx.WriteBuffer(&device_handle, sizeof(device_handle));
-        NGLOG_WARNING(Service_NFP, "(STUBBED) called, array_size={}", array_size);
+        LOG_WARNING(Service_NFP, "(STUBBED) called, array_size={}", array_size);
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
@@ -88,7 +88,7 @@ private:
    void AttachActivateEvent(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const u64 dev_handle = rp.Pop<u64>();
-        NGLOG_WARNING(Service_NFP, "(STUBBED) called, dev_handle=0x{:X}", dev_handle);
+        LOG_WARNING(Service_NFP, "(STUBBED) called, dev_handle=0x{:X}", dev_handle);
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
@@ -98,7 +98,7 @@ private:
    void AttachDeactivateEvent(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const u64 dev_handle = rp.Pop<u64>();
-        NGLOG_WARNING(Service_NFP, "(STUBBED) called, dev_handle=0x{:X}", dev_handle);
+        LOG_WARNING(Service_NFP, "(STUBBED) called, dev_handle=0x{:X}", dev_handle);
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
@@ -106,14 +106,14 @@ private:
    }
    void GetState(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_NFP, "(STUBBED) called");
+        LOG_WARNING(Service_NFP, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(static_cast<u32>(state));
    }
    void GetDeviceState(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_NFP, "(STUBBED) called");
+        LOG_WARNING(Service_NFP, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(static_cast<u32>(device_state));
@@ -122,7 +122,7 @@ private:
    void GetNpadId(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const u64 dev_handle = rp.Pop<u64>();
-        NGLOG_WARNING(Service_NFP, "(STUBBED) called, dev_handle=0x{:X}", dev_handle);
+        LOG_WARNING(Service_NFP, "(STUBBED) called, dev_handle=0x{:X}", dev_handle);
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(npad_id);
@@ -131,7 +131,7 @@ private:
    void AttachAvailabilityChangeEvent(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const u64 dev_handle = rp.Pop<u64>();
-        NGLOG_WARNING(Service_NFP, "(STUBBED) called, dev_handle=0x{:X}", dev_handle);
+        LOG_WARNING(Service_NFP, "(STUBBED) called, dev_handle=0x{:X}", dev_handle);
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
@@ -148,7 +148,7 @@ private:
 };
 void Module::Interface::CreateUserInterface(Kernel::HLERequestContext& ctx) {
-    NGLOG_DEBUG(Service_NFP, "called");
+    LOG_DEBUG(Service_NFP, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IUser>();
diff --git a/src/core/hle/service/nifm/nifm.cpp b/src/core/hle/service/nifm/nifm.cpp
index 62489c7fe..54a151c26 100644
--- a/src/core/hle/service/nifm/nifm.cpp
+++ b/src/core/hle/service/nifm/nifm.cpp
@@ -62,33 +62,33 @@ public:
 private:
    void GetRequestState(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_NIFM, "(STUBBED) called");
+        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(0);
    }
    void GetResult(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_NIFM, "(STUBBED) called");
+        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
    void GetSystemEventReadableHandles(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_NIFM, "(STUBBED) called");
+        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2, 2};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(event1, event2);
    }
    void Cancel(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_NIFM, "(STUBBED) called");
+        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
    void SetConnectionConfirmationOption(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_NIFM, "(STUBBED) called");
+        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
@@ -114,7 +114,7 @@ public:
 private:
    void GetClientId(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_NIFM, "(STUBBED) called");
+        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u64>(0);
@@ -125,7 +125,7 @@ private:
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IScanRequest>();
-        NGLOG_DEBUG(Service_NIFM, "called");
+        LOG_DEBUG(Service_NIFM, "called");
    }
    void CreateRequest(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
@@ -133,10 +133,10 @@ private:
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IRequest>();
-        NGLOG_DEBUG(Service_NIFM, "called");
+        LOG_DEBUG(Service_NIFM, "called");
    }
    void RemoveNetworkProfile(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_NIFM, "(STUBBED) called");
+        LOG_WARNING(Service_NIFM, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
@@ -146,7 +146,7 @@ private:
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<INetworkProfile>();
-        NGLOG_DEBUG(Service_NIFM, "called");
+        LOG_DEBUG(Service_NIFM, "called");
    }
 };
@@ -196,14 +196,14 @@ void Module::Interface::CreateGeneralServiceOld(Kernel::HLERequestContext& ctx)
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IGeneralService>();
-    NGLOG_DEBUG(Service_NIFM, "called");
+    LOG_DEBUG(Service_NIFM, "called");
 }
 void Module::Interface::CreateGeneralService(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IGeneralService>();
-    NGLOG_DEBUG(Service_NIFM, "called");
+    LOG_DEBUG(Service_NIFM, "called");
 }
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
diff --git a/src/core/hle/service/ns/pl_u.cpp b/src/core/hle/service/ns/pl_u.cpp
index 636af9a1e..d6a12ede5 100644
--- a/src/core/hle/service/ns/pl_u.cpp
+++ b/src/core/hle/service/ns/pl_u.cpp
@@ -52,7 +52,7 @@ PL_U::PL_U() : ServiceFramework("pl:u") {
        ASSERT(file.GetSize() == SHARED_FONT_MEM_SIZE);
        file.ReadBytes(shared_font->data(), shared_font->size());
    } else {
-        NGLOG_WARNING(Service_NS, "Unable to load shared font: {}", filepath);
+        LOG_WARNING(Service_NS, "Unable to load shared font: {}", filepath);
    }
 }
@@ -60,7 +60,7 @@ void PL_U::RequestLoad(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const u32 shared_font_type{rp.Pop<u32>()};
-    NGLOG_DEBUG(Service_NS, "called, shared_font_type={}", shared_font_type);
+    LOG_DEBUG(Service_NS, "called, shared_font_type={}", shared_font_type);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }
@@ -69,7 +69,7 @@ void PL_U::GetLoadState(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const u32 font_id{rp.Pop<u32>()};
-    NGLOG_DEBUG(Service_NS, "called, font_id={}", font_id);
+    LOG_DEBUG(Service_NS, "called, font_id={}", font_id);
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(static_cast<u32>(LoadState::Done));
@@ -79,7 +79,7 @@ void PL_U::GetSize(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const u32 font_id{rp.Pop<u32>()};
-    NGLOG_DEBUG(Service_NS, "called, font_id={}", font_id);
+    LOG_DEBUG(Service_NS, "called, font_id={}", font_id);
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(SHARED_FONT_REGIONS[font_id].size);
@@ -89,7 +89,7 @@ void PL_U::GetSharedMemoryAddressOffset(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const u32 font_id{rp.Pop<u32>()};
-    NGLOG_DEBUG(Service_NS, "called, font_id={}", font_id);
+    LOG_DEBUG(Service_NS, "called, font_id={}", font_id);
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(SHARED_FONT_REGIONS[font_id].offset);
@@ -110,7 +110,7 @@ void PL_U::GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx) {
        Kernel::MemoryPermission::Read, SHARED_FONT_MEM_VADDR, Kernel::MemoryRegion::BASE,
        "PL_U:shared_font_mem");
-    NGLOG_DEBUG(Service_NS, "called");
+    LOG_DEBUG(Service_NS, "called");
    IPC::ResponseBuilder rb{ctx, 2, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushCopyObjects(shared_font_mem);
@@ -119,7 +119,7 @@ void PL_U::GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx) {
 void PL_U::GetSharedFontInOrderOfPriority(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const u64 language_code{rp.Pop<u64>()}; // TODO(ogniK): Find out what this is used for
-    NGLOG_DEBUG(Service_NS, "called, language_code=%lx", language_code);
+    LOG_DEBUG(Service_NS, "called, language_code=%lx", language_code);
    IPC::ResponseBuilder rb{ctx, 4};
    std::vector<u32> font_codes;
    std::vector<u32> font_offsets;
diff --git a/src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp b/src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp
index 103e66d0c..c39d5a164 100644
--- a/src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp
@@ -20,9 +20,9 @@ u32 nvdisp_disp0::ioctl(Ioctl command, const std::vector<u8>& input, std::vector
 void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u32 height,
                        u32 stride, NVFlinger::BufferQueue::BufferTransformFlags transform) {
    VAddr addr = nvmap_dev->GetObjectAddress(buffer_handle);
-    NGLOG_WARNING(Service,
+    LOG_WARNING(Service,
-                  "Drawing from address {:X} offset {:08X} Width {} Height {} Stride {} Format {}",
+                "Drawing from address {:X} offset {:08X} Width {} Height {} Stride {} Format {}",
-                  addr, offset, width, height, stride, format);
+                addr, offset, width, height, stride, format);
    using PixelFormat = Tegra::FramebufferConfig::PixelFormat;
    const Tegra::FramebufferConfig framebuffer{
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
index c1eea861d..57b128b40 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
@@ -8,12 +8,14 @@
 #include "core/core.h"
 #include "core/hle/service/nvdrv/devices/nvhost_as_gpu.h"
 #include "core/hle/service/nvdrv/devices/nvmap.h"
+#include "video_core/renderer_base.h"
+#include "video_core/video_core.h"
 namespace Service::Nvidia::Devices {
 u32 nvhost_as_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
+    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
-                command.raw, input.size(), output.size());
+              command.raw, input.size(), output.size());
    switch (static_cast<IoctlCommand>(command.raw)) {
    case IoctlCommand::IocInitalizeExCommand:
@@ -40,15 +42,15 @@ u32 nvhost_as_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vecto
 u32 nvhost_as_gpu::InitalizeEx(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlInitalizeEx params{};
    std::memcpy(&params, input.data(), input.size());
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called, big_page_size=0x{:X}", params.big_page_size);
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called, big_page_size=0x{:X}", params.big_page_size);
    return 0;
 }
 u32 nvhost_as_gpu::AllocateSpace(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlAllocSpace params{};
    std::memcpy(&params, input.data(), input.size());
-    NGLOG_DEBUG(Service_NVDRV, "called, pages={:X}, page_size={:X}, flags={:X}", params.pages,
+    LOG_DEBUG(Service_NVDRV, "called, pages={:X}, page_size={:X}, flags={:X}", params.pages,
-                params.page_size, params.flags);
+              params.page_size, params.flags);
    auto& gpu = Core::System::GetInstance().GPU();
    const u64 size{static_cast<u64>(params.pages) * static_cast<u64>(params.page_size)};
@@ -65,7 +67,7 @@ u32 nvhost_as_gpu::AllocateSpace(const std::vector<u8>& input, std::vector<u8>&
 u32 nvhost_as_gpu::Remap(const std::vector<u8>& input, std::vector<u8>& output) {
    size_t num_entries = input.size() / sizeof(IoctlRemapEntry);
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called, num_entries=0x{:X}", num_entries);
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called, num_entries=0x{:X}", num_entries);
    std::vector<IoctlRemapEntry> entries(num_entries);
    std::memcpy(entries.data(), input.data(), input.size());
@@ -73,8 +75,8 @@ u32 nvhost_as_gpu::Remap(const std::vector<u8>& input, std::vector<u8>& output)
    auto& gpu = Core::System::GetInstance().GPU();
    for (const auto& entry : entries) {
-        NGLOG_WARNING(Service_NVDRV, "remap entry, offset=0x{:X} handle=0x{:X} pages=0x{:X}",
+        LOG_WARNING(Service_NVDRV, "remap entry, offset=0x{:X} handle=0x{:X} pages=0x{:X}",
-                      entry.offset, entry.nvmap_handle, entry.pages);
+                    entry.offset, entry.nvmap_handle, entry.pages);
        Tegra::GPUVAddr offset = static_cast<Tegra::GPUVAddr>(entry.offset) << 0x10;
        auto object = nvmap_dev->GetObject(entry.nvmap_handle);
@@ -96,11 +98,11 @@ u32 nvhost_as_gpu::MapBufferEx(const std::vector<u8>& input, std::vector<u8>& ou
    IoctlMapBufferEx params{};
    std::memcpy(&params, input.data(), input.size());
-    NGLOG_DEBUG(Service_NVDRV,
+    LOG_DEBUG(Service_NVDRV,
-                "called, flags={:X}, nvmap_handle={:X}, buffer_offset={}, mapping_size={}"
+              "called, flags={:X}, nvmap_handle={:X}, buffer_offset={}, mapping_size={}"
-                ", offset={}",
+              ", offset={}",
-                params.flags, params.nvmap_handle, params.buffer_offset, params.mapping_size,
+              params.flags, params.nvmap_handle, params.buffer_offset, params.mapping_size,
-                params.offset);
+              params.offset);
    if (!params.nvmap_handle) {
        return 0;
@@ -146,7 +148,7 @@ u32 nvhost_as_gpu::UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& ou
    IoctlUnmapBuffer params{};
    std::memcpy(&params, input.data(), input.size());
-    NGLOG_DEBUG(Service_NVDRV, "called, offset=0x{:X}", params.offset);
+    LOG_DEBUG(Service_NVDRV, "called, offset=0x{:X}", params.offset);
    auto& gpu = Core::System::GetInstance().GPU();
@@ -154,6 +156,9 @@ u32 nvhost_as_gpu::UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& ou
    ASSERT_MSG(itr != buffer_mappings.end(), "Tried to unmap invalid mapping");
+    // Remove this memory region from the rasterizer cache.
+    VideoCore::g_renderer->Rasterizer()->FlushAndInvalidateRegion(params.offset, itr->second.size);
    params.offset = gpu.memory_manager->UnmapBuffer(params.offset, itr->second.size);
    buffer_mappings.erase(itr->second.offset);
@@ -165,7 +170,7 @@ u32 nvhost_as_gpu::UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& ou
 u32 nvhost_as_gpu::BindChannel(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlBindChannel params{};
    std::memcpy(&params, input.data(), input.size());
-    NGLOG_DEBUG(Service_NVDRV, "called, fd={:X}", params.fd);
+    LOG_DEBUG(Service_NVDRV, "called, fd={:X}", params.fd);
    channel = params.fd;
    return 0;
 }
@@ -173,8 +178,8 @@ u32 nvhost_as_gpu::BindChannel(const std::vector<u8>& input, std::vector<u8>& ou
 u32 nvhost_as_gpu::GetVARegions(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlGetVaRegions params{};
    std::memcpy(&params, input.data(), input.size());
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called, buf_addr={:X}, buf_size={:X}", params.buf_addr,
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called, buf_addr={:X}, buf_size={:X}", params.buf_addr,
-                  params.buf_size);
+                params.buf_size);
    params.buf_size = 0x30;
    params.regions[0].offset = 0x04000000;
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp b/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp
index 7872d1e09..671b092e1 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp
@@ -9,8 +9,8 @@
 namespace Service::Nvidia::Devices {
 u32 nvhost_ctrl::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
+    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
-                command.raw, input.size(), output.size());
+              command.raw, input.size(), output.size());
    switch (static_cast<IoctlCommand>(command.raw)) {
    case IoctlCommand::IocGetConfigCommand:
@@ -29,33 +29,18 @@ u32 nvhost_ctrl::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<
 u32 nvhost_ctrl::NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output) {
    IocGetConfigParams params{};
    std::memcpy(&params, input.data(), sizeof(params));
-    NGLOG_DEBUG(Service_NVDRV, "called, setting={}!{}", params.domain_str.data(),
+    LOG_TRACE(Service_NVDRV, "called, setting={}!{}", params.domain_str.data(),
-                params.param_str.data());
+              params.param_str.data());
+    return 0x30006; // Returns error on production mode
-    if (!strcmp(params.domain_str.data(), "nv")) {
-        if (!strcmp(params.param_str.data(), "NV_MEMORY_PROFILER")) {
-            params.config_str[0] = '0';
-        } else if (!strcmp(params.param_str.data(), "NVN_THROUGH_OPENGL")) {
-            params.config_str[0] = '0';
-        } else if (!strcmp(params.param_str.data(), "NVRM_GPU_PREVENT_USE")) {
-            params.config_str[0] = '0';
-        } else {
-            params.config_str[0] = '\0';
-        }
-    } else {
-        UNIMPLEMENTED(); // unknown domain? Only nv has been seen so far on hardware
-    }
-    std::memcpy(output.data(), &params, sizeof(params));
-    return 0;
 }
 u32 nvhost_ctrl::IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output,
                                  bool is_async) {
    IocCtrlEventWaitParams params{};
    std::memcpy(&params, input.data(), sizeof(params));
-    NGLOG_WARNING(Service_NVDRV,
+    LOG_WARNING(Service_NVDRV,
-                  "(STUBBED) called, syncpt_id={}, threshold={}, timeout={}, is_async={}",
+                "(STUBBED) called, syncpt_id={}, threshold={}, timeout={}, is_async={}",
-                  params.syncpt_id, params.threshold, params.timeout, is_async);
+                params.syncpt_id, params.threshold, params.timeout, is_async);
    // TODO(Subv): Implement actual syncpt waiting.
    params.value = 0;
@@ -64,7 +49,7 @@ u32 nvhost_ctrl::IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>&
 }
 u32 nvhost_ctrl::IocCtrlEventRegister(const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called");
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
    // TODO(bunnei): Implement this.
    return 0;
 }
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp b/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
index 0abc0de83..44e062f50 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
@@ -10,8 +10,8 @@
 namespace Service::Nvidia::Devices {
 u32 nvhost_ctrl_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
+    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
-                command.raw, input.size(), output.size());
+              command.raw, input.size(), output.size());
    switch (static_cast<IoctlCommand>(command.raw)) {
    case IoctlCommand::IocGetCharacteristicsCommand:
@@ -36,7 +36,7 @@ u32 nvhost_ctrl_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vec
 }
 u32 nvhost_ctrl_gpu::GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_DEBUG(Service_NVDRV, "called");
+    LOG_DEBUG(Service_NVDRV, "called");
    IoctlCharacteristics params{};
    std::memcpy(&params, input.data(), input.size());
    params.gc.arch = 0x120;
@@ -83,8 +83,8 @@ u32 nvhost_ctrl_gpu::GetCharacteristics(const std::vector<u8>& input, std::vecto
 u32 nvhost_ctrl_gpu::GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlGpuGetTpcMasksArgs params{};
    std::memcpy(&params, input.data(), input.size());
-    NGLOG_INFO(Service_NVDRV, "called, mask=0x{:X}, mask_buf_addr=0x{:X}", params.mask_buf_size,
+    LOG_INFO(Service_NVDRV, "called, mask=0x{:X}, mask_buf_addr=0x{:X}", params.mask_buf_size,
-               params.mask_buf_addr);
+             params.mask_buf_addr);
    // TODO(ogniK): Confirm value on hardware
    if (params.mask_buf_size)
        params.tpc_mask_size = 4 * 1; // 4 * num_gpc
@@ -95,7 +95,7 @@ u32 nvhost_ctrl_gpu::GetTPCMasks(const std::vector<u8>& input, std::vector<u8>&
 }
 u32 nvhost_ctrl_gpu::GetActiveSlotMask(const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_DEBUG(Service_NVDRV, "called");
+    LOG_DEBUG(Service_NVDRV, "called");
    IoctlActiveSlotMask params{};
    std::memcpy(&params, input.data(), input.size());
    params.slot = 0x07;
@@ -105,7 +105,7 @@ u32 nvhost_ctrl_gpu::GetActiveSlotMask(const std::vector<u8>& input, std::vector
 }
 u32 nvhost_ctrl_gpu::ZCullGetCtxSize(const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_DEBUG(Service_NVDRV, "called");
+    LOG_DEBUG(Service_NVDRV, "called");
    IoctlZcullGetCtxSize params{};
    std::memcpy(&params, input.data(), input.size());
    params.size = 0x1;
@@ -114,7 +114,7 @@ u32 nvhost_ctrl_gpu::ZCullGetCtxSize(const std::vector<u8>& input, std::vector<u
 }
 u32 nvhost_ctrl_gpu::ZCullGetInfo(const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_DEBUG(Service_NVDRV, "called");
+    LOG_DEBUG(Service_NVDRV, "called");
    IoctlNvgpuGpuZcullGetInfoArgs params{};
    std::memcpy(&params, input.data(), input.size());
    params.width_align_pixels = 0x20;
@@ -132,7 +132,7 @@ u32 nvhost_ctrl_gpu::ZCullGetInfo(const std::vector<u8>& input, std::vector<u8>&
 }
 u32 nvhost_ctrl_gpu::ZBCSetTable(const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called");
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
    IoctlZbcSetTable params{};
    std::memcpy(&params, input.data(), input.size());
    // TODO(ogniK): What does this even actually do?
@@ -141,7 +141,7 @@ u32 nvhost_ctrl_gpu::ZBCSetTable(const std::vector<u8>& input, std::vector<u8>&
 }
 u32 nvhost_ctrl_gpu::ZBCQueryTable(const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called");
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
    IoctlZbcQueryTable params{};
    std::memcpy(&params, input.data(), input.size());
    // TODO : To implement properly
@@ -150,7 +150,7 @@ u32 nvhost_ctrl_gpu::ZBCQueryTable(const std::vector<u8>& input, std::vector<u8>
 }
 u32 nvhost_ctrl_gpu::FlushL2(const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called");
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
    IoctlFlushL2 params{};
    std::memcpy(&params, input.data(), input.size());
    // TODO : To implement properly
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp b/src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp
index ed7b6dc03..8de870596 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp
@@ -12,8 +12,8 @@
 namespace Service::Nvidia::Devices {
 u32 nvhost_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
+    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
-                command.raw, input.size(), output.size());
+              command.raw, input.size(), output.size());
    switch (static_cast<IoctlCommand>(command.raw)) {
    case IoctlCommand::IocSetNVMAPfdCommand:
@@ -51,13 +51,13 @@ u32 nvhost_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u
 u32 nvhost_gpu::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlSetNvmapFD params{};
    std::memcpy(&params, input.data(), input.size());
-    NGLOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
+    LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
    nvmap_fd = params.nvmap_fd;
    return 0;
 }
 u32 nvhost_gpu::SetClientData(const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_DEBUG(Service_NVDRV, "called");
+    LOG_DEBUG(Service_NVDRV, "called");
    IoctlClientData params{};
    std::memcpy(&params, input.data(), input.size());
    user_data = params.data;
@@ -65,7 +65,7 @@ u32 nvhost_gpu::SetClientData(const std::vector<u8>& input, std::vector<u8>& out
 }
 u32 nvhost_gpu::GetClientData(const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_DEBUG(Service_NVDRV, "called");
+    LOG_DEBUG(Service_NVDRV, "called");
    IoctlClientData params{};
    std::memcpy(&params, input.data(), input.size());
    params.data = user_data;
@@ -75,8 +75,8 @@ u32 nvhost_gpu::GetClientData(const std::vector<u8>& input, std::vector<u8>& out
 u32 nvhost_gpu::ZCullBind(const std::vector<u8>& input, std::vector<u8>& output) {
    std::memcpy(&zcull_params, input.data(), input.size());
-    NGLOG_DEBUG(Service_NVDRV, "called, gpu_va={:X}, mode={:X}", zcull_params.gpu_va,
+    LOG_DEBUG(Service_NVDRV, "called, gpu_va={:X}, mode={:X}", zcull_params.gpu_va,
-                zcull_params.mode);
+              zcull_params.mode);
    std::memcpy(output.data(), &zcull_params, output.size());
    return 0;
 }
@@ -84,26 +84,26 @@ u32 nvhost_gpu::ZCullBind(const std::vector<u8>& input, std::vector<u8>& output)
 u32 nvhost_gpu::SetErrorNotifier(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlSetErrorNotifier params{};
    std::memcpy(&params, input.data(), input.size());
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called, offset={:X}, size={:X}, mem={:X}",
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called, offset={:X}, size={:X}, mem={:X}", params.offset,
-                  params.offset, params.size, params.mem);
+                params.size, params.mem);
    std::memcpy(output.data(), &params, output.size());
    return 0;
 }
 u32 nvhost_gpu::SetChannelPriority(const std::vector<u8>& input, std::vector<u8>& output) {
    std::memcpy(&channel_priority, input.data(), input.size());
-    NGLOG_DEBUG(Service_NVDRV, "(STUBBED) called, priority={:X}", channel_priority);
+    LOG_DEBUG(Service_NVDRV, "(STUBBED) called, priority={:X}", channel_priority);
    return 0;
 }
 u32 nvhost_gpu::AllocGPFIFOEx2(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlAllocGpfifoEx2 params{};
    std::memcpy(&params, input.data(), input.size());
-    NGLOG_WARNING(Service_NVDRV,
+    LOG_WARNING(Service_NVDRV,
-                  "(STUBBED) called, num_entries={:X}, flags={:X}, unk0={:X}, "
+                "(STUBBED) called, num_entries={:X}, flags={:X}, unk0={:X}, "
-                  "unk1={:X}, unk2={:X}, unk3={:X}",
+                "unk1={:X}, unk2={:X}, unk3={:X}",
-                  params.num_entries, params.flags, params.unk0, params.unk1, params.unk2,
+                params.num_entries, params.flags, params.unk0, params.unk1, params.unk2,
-                  params.unk3);
+                params.unk3);
    params.fence_out.id = 0;
    params.fence_out.value = 0;
    std::memcpy(output.data(), &params, output.size());
@@ -113,8 +113,8 @@ u32 nvhost_gpu::AllocGPFIFOEx2(const std::vector<u8>& input, std::vector<u8>& ou
 u32 nvhost_gpu::AllocateObjectContext(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlAllocObjCtx params{};
    std::memcpy(&params, input.data(), input.size());
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called, class_num={:X}, flags={:X}", params.class_num,
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called, class_num={:X}, flags={:X}", params.class_num,
-                  params.flags);
+                params.flags);
    params.obj_id = 0x0;
    std::memcpy(output.data(), &params, output.size());
    return 0;
@@ -126,8 +126,8 @@ u32 nvhost_gpu::SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& outp
    }
    IoctlSubmitGpfifo params{};
    std::memcpy(&params, input.data(), sizeof(IoctlSubmitGpfifo));
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called, gpfifo={:X}, num_entries={:X}, flags={:X}",
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called, gpfifo={:X}, num_entries={:X}, flags={:X}",
-                  params.gpfifo, params.num_entries, params.flags);
+                params.gpfifo, params.num_entries, params.flags);
    auto entries = std::vector<IoctlGpfifoEntry>();
    entries.resize(params.num_entries);
@@ -146,7 +146,7 @@ u32 nvhost_gpu::SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& outp
 u32 nvhost_gpu::GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlGetWaitbase params{};
    std::memcpy(&params, input.data(), sizeof(IoctlGetWaitbase));
-    NGLOG_INFO(Service_NVDRV, "called, unknown=0x{:X}", params.unknown);
+    LOG_INFO(Service_NVDRV, "called, unknown=0x{:X}", params.unknown);
    params.value = 0; // Seems to be hard coded at 0
    std::memcpy(output.data(), &params, output.size());
    return 0;
@@ -155,7 +155,7 @@ u32 nvhost_gpu::GetWaitbase(const std::vector<u8>& input, std::vector<u8>& outpu
 u32 nvhost_gpu::ChannelSetTimeout(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlChannelSetTimeout params{};
    std::memcpy(&params, input.data(), sizeof(IoctlChannelSetTimeout));
-    NGLOG_INFO(Service_NVDRV, "called, timeout=0x{:X}", params.timeout);
+    LOG_INFO(Service_NVDRV, "called, timeout=0x{:X}", params.timeout);
    return 0;
 }
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp b/src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp
index 0b6c22898..b51c73ee8 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp
@@ -9,8 +9,8 @@
 namespace Service::Nvidia::Devices {
 u32 nvhost_nvdec::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
+    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
-                command.raw, input.size(), output.size());
+              command.raw, input.size(), output.size());
    switch (static_cast<IoctlCommand>(command.raw)) {
    case IoctlCommand::IocSetNVMAPfdCommand:
@@ -24,7 +24,7 @@ u32 nvhost_nvdec::ioctl(Ioctl command, const std::vector<u8>& input, std::vector
 u32 nvhost_nvdec::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlSetNvmapFD params{};
    std::memcpy(&params, input.data(), input.size());
-    NGLOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
+    LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
    nvmap_fd = params.nvmap_fd;
    return 0;
 }
diff --git a/src/core/hle/service/nvdrv/devices/nvmap.cpp b/src/core/hle/service/nvdrv/devices/nvmap.cpp
index 23fe98190..724eeb139 100644
--- a/src/core/hle/service/nvdrv/devices/nvmap.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvmap.cpp
@@ -52,7 +52,7 @@ u32 nvmap::IocCreate(const std::vector<u8>& input, std::vector<u8>& output) {
    u32 handle = next_handle++;
    handles[handle] = std::move(object);
-    NGLOG_DEBUG(Service_NVDRV, "size=0x{:08X}", params.size);
+    LOG_DEBUG(Service_NVDRV, "size=0x{:08X}", params.size);
    params.handle = handle;
@@ -73,7 +73,7 @@ u32 nvmap::IocAlloc(const std::vector<u8>& input, std::vector<u8>& output) {
    object->addr = params.addr;
    object->status = Object::Status::Allocated;
-    NGLOG_DEBUG(Service_NVDRV, "called, addr={:X}", params.addr);
+    LOG_DEBUG(Service_NVDRV, "called, addr={:X}", params.addr);
    std::memcpy(output.data(), &params, sizeof(params));
    return 0;
@@ -83,7 +83,7 @@ u32 nvmap::IocGetId(const std::vector<u8>& input, std::vector<u8>& output) {
    IocGetIdParams params;
    std::memcpy(&params, input.data(), sizeof(params));
-    NGLOG_WARNING(Service_NVDRV, "called");
+    LOG_WARNING(Service_NVDRV, "called");
    auto object = GetObject(params.handle);
    ASSERT(object);
@@ -98,7 +98,7 @@ u32 nvmap::IocFromId(const std::vector<u8>& input, std::vector<u8>& output) {
    IocFromIdParams params;
    std::memcpy(&params, input.data(), sizeof(params));
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called");
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
    auto itr = std::find_if(handles.begin(), handles.end(),
                            [&](const auto& entry) { return entry.second->id == params.id; });
@@ -119,7 +119,7 @@ u32 nvmap::IocParam(const std::vector<u8>& input, std::vector<u8>& output) {
    IocParamParams params;
    std::memcpy(&params, input.data(), sizeof(params));
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called type={}", params.param);
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called type={}", params.param);
    auto object = GetObject(params.handle);
    ASSERT(object);
@@ -148,6 +148,7 @@ u32 nvmap::IocParam(const std::vector<u8>& input, std::vector<u8>& output) {
 }
 u32 nvmap::IocFree(const std::vector<u8>& input, std::vector<u8>& output) {
+    // TODO(Subv): These flags are unconfirmed.
    enum FreeFlags {
        Freed = 0,
        NotFreedYet = 1,
@@ -156,20 +157,26 @@ u32 nvmap::IocFree(const std::vector<u8>& input, std::vector<u8>& output) {
    IocFreeParams params;
    std::memcpy(&params, input.data(), sizeof(params));
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called");
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
    auto itr = handles.find(params.handle);
    ASSERT(itr != handles.end());
+    ASSERT(itr->second->refcount > 0);
    itr->second->refcount--;
-    params.refcount = itr->second->refcount;
    params.size = itr->second->size;
-    if (itr->second->refcount == 0)
+    if (itr->second->refcount == 0) {
        params.flags = Freed;
-    else
+        // The address of the nvmap is written to the output if we're finally freeing it, otherwise
+        // 0 is written.
+        params.address = itr->second->addr;
+    } else {
        params.flags = NotFreedYet;
+        params.address = 0;
+    }
    handles.erase(params.handle);
diff --git a/src/core/hle/service/nvdrv/devices/nvmap.h b/src/core/hle/service/nvdrv/devices/nvmap.h
index 39fafaa7c..f2eec6409 100644
--- a/src/core/hle/service/nvdrv/devices/nvmap.h
+++ b/src/core/hle/service/nvdrv/devices/nvmap.h
@@ -94,7 +94,7 @@ private:
    struct IocFreeParams {
        u32_le handle;
        INSERT_PADDING_BYTES(4);
-        u64_le refcount;
+        u64_le address;
        u32_le size;
        u32_le flags;
    };
diff --git a/src/core/hle/service/nvdrv/interface.cpp b/src/core/hle/service/nvdrv/interface.cpp
index 45d2862ef..b10efd5c9 100644
--- a/src/core/hle/service/nvdrv/interface.cpp
+++ b/src/core/hle/service/nvdrv/interface.cpp
@@ -12,7 +12,7 @@
 namespace Service::Nvidia {
 void NVDRV::Open(Kernel::HLERequestContext& ctx) {
-    NGLOG_DEBUG(Service_NVDRV, "called");
+    LOG_DEBUG(Service_NVDRV, "called");
    const auto& buffer = ctx.ReadBuffer();
    std::string device_name(buffer.begin(), buffer.end());
@@ -25,7 +25,7 @@ void NVDRV::Open(Kernel::HLERequestContext& ctx) {
 }
 void NVDRV::Ioctl(Kernel::HLERequestContext& ctx) {
-    NGLOG_DEBUG(Service_NVDRV, "called");
+    LOG_DEBUG(Service_NVDRV, "called");
    IPC::RequestParser rp{ctx};
    u32 fd = rp.Pop<u32>();
@@ -41,7 +41,7 @@ void NVDRV::Ioctl(Kernel::HLERequestContext& ctx) {
 }
 void NVDRV::Close(Kernel::HLERequestContext& ctx) {
-    NGLOG_DEBUG(Service_NVDRV, "called");
+    LOG_DEBUG(Service_NVDRV, "called");
    IPC::RequestParser rp{ctx};
    u32 fd = rp.Pop<u32>();
@@ -53,7 +53,7 @@ void NVDRV::Close(Kernel::HLERequestContext& ctx) {
 }
 void NVDRV::Initialize(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called");
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(0);
@@ -63,7 +63,7 @@ void NVDRV::QueryEvent(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    u32 fd = rp.Pop<u32>();
    u32 event_id = rp.Pop<u32>();
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called, fd={:X}, event_id={:X}", fd, event_id);
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called, fd={:X}, event_id={:X}", fd, event_id);
    IPC::ResponseBuilder rb{ctx, 3, 1};
    rb.Push(RESULT_SUCCESS);
@@ -75,14 +75,14 @@ void NVDRV::SetClientPID(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    pid = rp.Pop<u64>();
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called, pid=0x{:X}", pid);
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called, pid=0x{:X}", pid);
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(0);
 }
 void NVDRV::FinishInitialize(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called");
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }
diff --git a/src/core/hle/service/nvflinger/buffer_queue.cpp b/src/core/hle/service/nvflinger/buffer_queue.cpp
index 49e88b394..f7f2fe1b2 100644
--- a/src/core/hle/service/nvflinger/buffer_queue.cpp
+++ b/src/core/hle/service/nvflinger/buffer_queue.cpp
@@ -23,7 +23,7 @@ void BufferQueue::SetPreallocatedBuffer(u32 slot, IGBPBuffer& igbp_buffer) {
    buffer.igbp_buffer = igbp_buffer;
    buffer.status = Buffer::Status::Free;
-    NGLOG_WARNING(Service, "Adding graphics buffer {}", slot);
+    LOG_WARNING(Service, "Adding graphics buffer {}", slot);
    queue.emplace_back(buffer);
@@ -94,7 +94,7 @@ void BufferQueue::ReleaseBuffer(u32 slot) {
 }
 u32 BufferQueue::Query(QueryType type) {
-    NGLOG_WARNING(Service, "(STUBBED) called type={}", static_cast<u32>(type));
+    LOG_WARNING(Service, "(STUBBED) called type={}", static_cast<u32>(type));
    switch (type) {
    case QueryType::NativeWindowFormat:
        // TODO(Subv): Use an enum for this
diff --git a/src/core/hle/service/nvflinger/nvflinger.cpp b/src/core/hle/service/nvflinger/nvflinger.cpp
index 5c50ed601..ef3c2cc98 100644
--- a/src/core/hle/service/nvflinger/nvflinger.cpp
+++ b/src/core/hle/service/nvflinger/nvflinger.cpp
@@ -48,7 +48,7 @@ NVFlinger::~NVFlinger() {
 }
 u64 NVFlinger::OpenDisplay(const std::string& name) {
-    NGLOG_WARNING(Service, "Opening display {}", name);
+    LOG_WARNING(Service, "Opening display {}", name);
    // TODO(Subv): Currently we only support the Default display.
    ASSERT(name == "Default");
diff --git a/src/core/hle/service/pctl/module.cpp b/src/core/hle/service/pctl/module.cpp
index dd20d5ae7..fcf1f3da3 100644
--- a/src/core/hle/service/pctl/module.cpp
+++ b/src/core/hle/service/pctl/module.cpp
@@ -112,7 +112,7 @@ public:
 private:
    void Initialize(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_PCTL, "(STUBBED) called");
+        LOG_WARNING(Service_PCTL, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 0};
        rb.Push(RESULT_SUCCESS);
    }
@@ -122,14 +122,14 @@ void Module::Interface::CreateService(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IParentalControlService>();
-    NGLOG_DEBUG(Service_PCTL, "called");
+    LOG_DEBUG(Service_PCTL, "called");
 }
 void Module::Interface::CreateServiceWithoutInitialize(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IParentalControlService>();
-    NGLOG_DEBUG(Service_PCTL, "called");
+    LOG_DEBUG(Service_PCTL, "called");
 }
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
diff --git a/src/core/hle/service/prepo/prepo.cpp b/src/core/hle/service/prepo/prepo.cpp
index eaf30ee6b..3c43b8d8c 100644
--- a/src/core/hle/service/prepo/prepo.cpp
+++ b/src/core/hle/service/prepo/prepo.cpp
@@ -27,7 +27,7 @@ PlayReport::PlayReport(const char* name) : ServiceFramework(name) {
 void PlayReport::SaveReportWithUser(Kernel::HLERequestContext& ctx) {
    // TODO(ogniK): Do we want to add play report?
-    NGLOG_WARNING(Service_PREPO, "(STUBBED) called");
+    LOG_WARNING(Service_PREPO, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index bdd9eb5a5..0d036bfaa 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -122,7 +122,7 @@ void ServiceFrameworkBase::ReportUnimplementedFunction(Kernel::HLERequestContext
    }
    buf.push_back('}');
-    NGLOG_ERROR(Service, "unknown / unimplemented {}", fmt::to_string(buf));
+    LOG_ERROR(Service, "unknown / unimplemented {}", fmt::to_string(buf));
    UNIMPLEMENTED();
 }
@@ -133,7 +133,7 @@ void ServiceFrameworkBase::InvokeRequest(Kernel::HLERequestContext& ctx) {
        return ReportUnimplementedFunction(ctx, info);
    }
-    NGLOG_TRACE(
+    LOG_TRACE(
        Service, "{}",
        MakeFunctionString(info->name, GetServiceName().c_str(), ctx.CommandBuffer()).c_str());
    handler_invoker(this, info->handler_callback, ctx);
@@ -206,12 +206,12 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm) {
    VI::InstallInterfaces(*sm, nv_flinger);
    Set::InstallInterfaces(*sm);
-    NGLOG_DEBUG(Service, "initialized OK");
+    LOG_DEBUG(Service, "initialized OK");
 }
 /// Shutdown ServiceManager
 void Shutdown() {
    g_kernel_named_ports.clear();
-    NGLOG_DEBUG(Service, "shutdown OK");
+    LOG_DEBUG(Service, "shutdown OK");
 }
 } // namespace Service
diff --git a/src/core/hle/service/set/set.cpp b/src/core/hle/service/set/set.cpp
index baeecb0ec..bd295cdf6 100644
--- a/src/core/hle/service/set/set.cpp
+++ b/src/core/hle/service/set/set.cpp
@@ -37,7 +37,7 @@ void SET::GetAvailableLanguageCodes(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.Push(static_cast<u64>(available_language_codes.size()));
-    NGLOG_DEBUG(Service_SET, "called");
+    LOG_DEBUG(Service_SET, "called");
 }
 SET::SET() : ServiceFramework("set") {
diff --git a/src/core/hle/service/set/set_sys.cpp b/src/core/hle/service/set/set_sys.cpp
index 762a664c5..fa85277fe 100644
--- a/src/core/hle/service/set/set_sys.cpp
+++ b/src/core/hle/service/set/set_sys.cpp
@@ -16,7 +16,7 @@ void SET_SYS::GetColorSetId(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(0);
-    NGLOG_WARNING(Service_SET, "(STUBBED) called");
+    LOG_WARNING(Service_SET, "(STUBBED) called");
 }
 SET_SYS::SET_SYS() : ServiceFramework("set:sys") {
diff --git a/src/core/hle/service/sm/controller.cpp b/src/core/hle/service/sm/controller.cpp
index fe5097cdc..518a0cc46 100644
--- a/src/core/hle/service/sm/controller.cpp
+++ b/src/core/hle/service/sm/controller.cpp
@@ -17,7 +17,7 @@ void Controller::ConvertSessionToDomain(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(1); // Converted sessions start with 1 request handler
-    NGLOG_DEBUG(Service, "called, server_session={}", ctx.Session()->GetObjectId());
+    LOG_DEBUG(Service, "called, server_session={}", ctx.Session()->GetObjectId());
 }
 void Controller::DuplicateSession(Kernel::HLERequestContext& ctx) {
@@ -29,11 +29,11 @@ void Controller::DuplicateSession(Kernel::HLERequestContext& ctx) {
    Kernel::SharedPtr<Kernel::ClientSession> session{ctx.Session()->parent->client};
    rb.PushMoveObjects(session);
-    NGLOG_DEBUG(Service, "called, session={}", session->GetObjectId());
+    LOG_DEBUG(Service, "called, session={}", session->GetObjectId());
 }
 void Controller::DuplicateSessionEx(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service, "(STUBBED) called, using DuplicateSession");
+    LOG_WARNING(Service, "(STUBBED) called, using DuplicateSession");
    DuplicateSession(ctx);
 }
@@ -43,7 +43,7 @@ void Controller::QueryPointerBufferSize(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(0x500);
-    NGLOG_WARNING(Service, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
 }
 Controller::Controller() : ServiceFramework("IpcController") {
diff --git a/src/core/hle/service/sm/sm.cpp b/src/core/hle/service/sm/sm.cpp
index bded8421f..f22a2a79f 100644
--- a/src/core/hle/service/sm/sm.cpp
+++ b/src/core/hle/service/sm/sm.cpp
@@ -86,7 +86,7 @@ SM::~SM() = default;
 void SM::Initialize(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_DEBUG(Service_SM, "called");
+    LOG_DEBUG(Service_SM, "called");
 }
 void SM::GetService(Kernel::HLERequestContext& ctx) {
@@ -102,8 +102,7 @@ void SM::GetService(Kernel::HLERequestContext& ctx) {
    if (client_port.Failed()) {
        IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
        rb.Push(client_port.Code());
-        NGLOG_ERROR(Service_SM, "called service={} -> error 0x{:08X}", name,
+        LOG_ERROR(Service_SM, "called service={} -> error 0x{:08X}", name, client_port.Code().raw);
-                    client_port.Code().raw);
        if (name.length() == 0)
            return; // LibNX Fix
        UNIMPLEMENTED();
@@ -113,7 +112,7 @@ void SM::GetService(Kernel::HLERequestContext& ctx) {
    auto session = client_port.Unwrap()->Connect();
    ASSERT(session.Succeeded());
    if (session.Succeeded()) {
-        NGLOG_DEBUG(Service_SM, "called service={} -> session={}", name, (*session)->GetObjectId());
+        LOG_DEBUG(Service_SM, "called service={} -> session={}", name, (*session)->GetObjectId());
        IPC::ResponseBuilder rb =
            rp.MakeBuilder(2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles);
        rb.Push(session.Code());
diff --git a/src/core/hle/service/sockets/bsd.cpp b/src/core/hle/service/sockets/bsd.cpp
index ab909fdaa..32648bdd9 100644
--- a/src/core/hle/service/sockets/bsd.cpp
+++ b/src/core/hle/service/sockets/bsd.cpp
@@ -8,7 +8,7 @@
 namespace Service::Sockets {
 void BSD::RegisterClient(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 3};
@@ -17,7 +17,7 @@ void BSD::RegisterClient(Kernel::HLERequestContext& ctx) {
 }
 void BSD::StartMonitoring(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 3};
@@ -32,8 +32,7 @@ void BSD::Socket(Kernel::HLERequestContext& ctx) {
    u32 type = rp.Pop<u32>();
    u32 protocol = rp.Pop<u32>();
-    NGLOG_WARNING(Service, "(STUBBED) called domain={} type={} protocol={}", domain, type,
+    LOG_WARNING(Service, "(STUBBED) called domain={} type={} protocol={}", domain, type, protocol);
-                  protocol);
    u32 fd = next_fd++;
@@ -45,7 +44,7 @@ void BSD::Socket(Kernel::HLERequestContext& ctx) {
 }
 void BSD::Connect(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 4};
@@ -55,7 +54,7 @@ void BSD::Connect(Kernel::HLERequestContext& ctx) {
 }
 void BSD::SendTo(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 4};
@@ -65,7 +64,7 @@ void BSD::SendTo(Kernel::HLERequestContext& ctx) {
 }
 void BSD::Close(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 4};
diff --git a/src/core/hle/service/sockets/sfdnsres.cpp b/src/core/hle/service/sockets/sfdnsres.cpp
index f377e59f2..d235c4cfd 100644
--- a/src/core/hle/service/sockets/sfdnsres.cpp
+++ b/src/core/hle/service/sockets/sfdnsres.cpp
@@ -10,7 +10,7 @@ namespace Service::Sockets {
 void SFDNSRES::GetAddrInfo(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
-    NGLOG_WARNING(Service, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2};
diff --git a/src/core/hle/service/spl/module.cpp b/src/core/hle/service/spl/module.cpp
index 76ba97156..3f5a342a7 100644
--- a/src/core/hle/service/spl/module.cpp
+++ b/src/core/hle/service/spl/module.cpp
@@ -28,7 +28,7 @@ void Module::Interface::GetRandomBytes(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
-    NGLOG_DEBUG(Service_SPL, "called");
+    LOG_DEBUG(Service_SPL, "called");
 }
 void InstallInterfaces(SM::ServiceManager& service_manager) {
diff --git a/src/core/hle/service/ssl/ssl.cpp b/src/core/hle/service/ssl/ssl.cpp
index b3dad8b06..40aea6090 100644
--- a/src/core/hle/service/ssl/ssl.cpp
+++ b/src/core/hle/service/ssl/ssl.cpp
@@ -65,7 +65,7 @@ public:
 private:
    void SetOption(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_SSL, "(STUBBED) called");
+        LOG_WARNING(Service_SSL, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
@@ -73,7 +73,7 @@ private:
    }
    void CreateConnection(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_SSL, "(STUBBED) called");
+        LOG_WARNING(Service_SSL, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
@@ -82,7 +82,7 @@ private:
 };
 void SSL::CreateContext(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_SSL, "(STUBBED) called");
+    LOG_WARNING(Service_SSL, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
@@ -103,7 +103,7 @@ SSL::SSL() : ServiceFramework("ssl") {
 }
 void SSL::SetInterfaceVersion(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_SSL, "(STUBBED) called");
+    LOG_WARNING(Service_SSL, "(STUBBED) called");
    IPC::RequestParser rp{ctx};
    u32 unk1 = rp.Pop<u32>(); // Probably minor/major?
    u32 unk2 = rp.Pop<u32>(); // TODO(ogniK): Figure out what this does
diff --git a/src/core/hle/service/time/time.cpp b/src/core/hle/service/time/time.cpp
index 654012189..507ae95f4 100644
--- a/src/core/hle/service/time/time.cpp
+++ b/src/core/hle/service/time/time.cpp
@@ -33,14 +33,14 @@ private:
        const s64 time_since_epoch{std::chrono::duration_cast<std::chrono::seconds>(
                                       std::chrono::system_clock::now().time_since_epoch())
                                       .count()};
-        NGLOG_DEBUG(Service_Time, "called");
+        LOG_DEBUG(Service_Time, "called");
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u64>(time_since_epoch);
    }
    void GetSystemClockContext(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_Time, "(STUBBED) called");
+        LOG_WARNING(Service_Time, "(STUBBED) called");
        SystemClockContext system_clock_ontext{};
        IPC::ResponseBuilder rb{ctx, (sizeof(SystemClockContext) / 4) + 2};
        rb.Push(RESULT_SUCCESS);
@@ -59,7 +59,7 @@ public:
 private:
    void GetCurrentTimePoint(Kernel::HLERequestContext& ctx) {
-        NGLOG_DEBUG(Service_Time, "called");
+        LOG_DEBUG(Service_Time, "called");
        SteadyClockTimePoint steady_clock_time_point{
            CoreTiming::cyclesToMs(CoreTiming::GetTicks()) / 1000};
        IPC::ResponseBuilder rb{ctx, (sizeof(SteadyClockTimePoint) / 4) + 2};
@@ -91,21 +91,21 @@ private:
    TimeZoneRule my_time_zone_rule{};
    void GetDeviceLocationName(Kernel::HLERequestContext& ctx) {
-        NGLOG_DEBUG(Service_Time, "called");
+        LOG_DEBUG(Service_Time, "called");
        IPC::ResponseBuilder rb{ctx, (sizeof(LocationName) / 4) + 2};
        rb.Push(RESULT_SUCCESS);
        rb.PushRaw(location_name);
    }
    void GetTotalLocationNameCount(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_Time, "(STUBBED) called");
+        LOG_WARNING(Service_Time, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(0);
    }
    void LoadTimeZoneRule(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_Time, "(STUBBED) called");
+        LOG_WARNING(Service_Time, "(STUBBED) called");
        ctx.WriteBuffer(&my_time_zone_rule, sizeof(TimeZoneRule));
@@ -117,7 +117,7 @@ private:
        IPC::RequestParser rp{ctx};
        const u64 posix_time = rp.Pop<u64>();
-        NGLOG_WARNING(Service_Time, "(STUBBED) called, posix_time=0x{:016X}", posix_time);
+        LOG_WARNING(Service_Time, "(STUBBED) called, posix_time=0x{:016X}", posix_time);
        TimeZoneRule time_zone_rule{};
        auto buffer = ctx.ReadBuffer();
@@ -138,7 +138,7 @@ private:
        IPC::RequestParser rp{ctx};
        const u64 posix_time = rp.Pop<u64>();
-        NGLOG_WARNING(Service_Time, "(STUBBED) called, posix_time=0x{:016X}", posix_time);
+        LOG_WARNING(Service_Time, "(STUBBED) called, posix_time=0x{:016X}", posix_time);
        CalendarTime calendar_time{2018, 1, 1, 0, 0, 0};
        CalendarAdditionalInfo additional_info{};
@@ -176,35 +176,35 @@ void Module::Interface::GetStandardUserSystemClock(Kernel::HLERequestContext& ct
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ISystemClock>();
-    NGLOG_DEBUG(Service_Time, "called");
+    LOG_DEBUG(Service_Time, "called");
 }
 void Module::Interface::GetStandardNetworkSystemClock(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ISystemClock>();
-    NGLOG_DEBUG(Service_Time, "called");
+    LOG_DEBUG(Service_Time, "called");
 }
 void Module::Interface::GetStandardSteadyClock(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ISteadyClock>();
-    NGLOG_DEBUG(Service_Time, "called");
+    LOG_DEBUG(Service_Time, "called");
 }
 void Module::Interface::GetTimeZoneService(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ITimeZoneService>();
-    NGLOG_DEBUG(Service_Time, "called");
+    LOG_DEBUG(Service_Time, "called");
 }
 void Module::Interface::GetStandardLocalSystemClock(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<ISystemClock>();
-    NGLOG_DEBUG(Service_Time, "called");
+    LOG_DEBUG(Service_Time, "called");
 }
 Module::Interface::Interface(std::shared_ptr<Module> time, const char* name)
diff --git a/src/core/hle/service/vi/vi.cpp b/src/core/hle/service/vi/vi.cpp
index e86556671..f3765b555 100644
--- a/src/core/hle/service/vi/vi.cpp
+++ b/src/core/hle/service/vi/vi.cpp
@@ -470,7 +470,7 @@ private:
        u32 flags = rp.Pop<u32>();
        auto buffer_queue = nv_flinger->GetBufferQueue(id);
-        NGLOG_DEBUG(Service_VI, "called, transaction={:X}", static_cast<u32>(transaction));
+        LOG_DEBUG(Service_VI, "called, transaction={:X}", static_cast<u32>(transaction));
        if (transaction == TransactionId::Connect) {
            IGBPConnectRequestParcel request{ctx.ReadBuffer()};
@@ -532,7 +532,7 @@ private:
            IGBPQueryResponseParcel response{value};
            ctx.WriteBuffer(response.Serialize());
        } else if (transaction == TransactionId::CancelBuffer) {
-            NGLOG_WARNING(Service_VI, "(STUBBED) called, transaction=CancelBuffer");
+            LOG_WARNING(Service_VI, "(STUBBED) called, transaction=CancelBuffer");
        } else {
            ASSERT_MSG(false, "Unimplemented");
        }
@@ -547,8 +547,8 @@ private:
        s32 addval = rp.PopRaw<s32>();
        u32 type = rp.Pop<u32>();
-        NGLOG_WARNING(Service_VI, "(STUBBED) called id={}, addval={:08X}, type={:08X}", id, addval,
+        LOG_WARNING(Service_VI, "(STUBBED) called id={}, addval={:08X}, type={:08X}", id, addval,
-                      type);
+                    type);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
@@ -562,7 +562,7 @@ private:
        // TODO(Subv): Find out what this actually is.
-        NGLOG_WARNING(Service_VI, "(STUBBED) called id={}, unknown={:08X}", id, unknown);
+        LOG_WARNING(Service_VI, "(STUBBED) called id={}, unknown={:08X}", id, unknown);
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(buffer_queue->GetNativeHandle());
@@ -625,7 +625,7 @@ public:
 private:
    void SetLayerZ(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u64 layer_id = rp.Pop<u64>();
        u64 z_value = rp.Pop<u64>();
@@ -640,8 +640,8 @@ private:
        bool visibility = rp.Pop<bool>();
        IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_VI, "(STUBBED) called, layer_id=0x{:08X}, visibility={}", layer_id,
+        LOG_WARNING(Service_VI, "(STUBBED) called, layer_id=0x{:08X}, visibility={}", layer_id,
-                      visibility);
+                    visibility);
    }
 };
@@ -723,7 +723,7 @@ public:
 private:
    void CloseDisplay(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u64 display = rp.Pop<u64>();
@@ -732,7 +732,7 @@ private:
    }
    void CreateManagedLayer(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u32 unknown = rp.Pop<u32>();
        rp.Skip(1, false);
@@ -747,7 +747,7 @@ private:
    }
    void AddToLayerStack(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u32 stack = rp.Pop<u32>();
        u64 layer_id = rp.Pop<u64>();
@@ -762,8 +762,8 @@ private:
        bool visibility = rp.Pop<bool>();
        IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
        rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_VI, "(STUBBED) called, layer_id=0x{:X}, visibility={}", layer_id,
+        LOG_WARNING(Service_VI, "(STUBBED) called, layer_id=0x{:X}, visibility={}", layer_id,
-                      visibility);
+                    visibility);
    }
    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
@@ -776,7 +776,7 @@ public:
 private:
    void GetRelayService(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
@@ -784,7 +784,7 @@ private:
    }
    void GetSystemDisplayService(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
@@ -792,7 +792,7 @@ private:
    }
    void GetManagerDisplayService(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
@@ -800,7 +800,7 @@ private:
    }
    void GetIndirectDisplayTransactionService(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
@@ -808,7 +808,7 @@ private:
    }
    void OpenDisplay(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        auto name_buf = rp.PopRaw<std::array<u8, 0x40>>();
        auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
@@ -823,7 +823,7 @@ private:
    }
    void CloseDisplay(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u64 display_id = rp.Pop<u64>();
@@ -832,7 +832,7 @@ private:
    }
    void GetDisplayResolution(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u64 display_id = rp.Pop<u64>();
@@ -849,7 +849,7 @@ private:
    }
    void SetLayerScalingMode(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u32 scaling_mode = rp.Pop<u32>();
        u64 unknown = rp.Pop<u64>();
@@ -865,11 +865,11 @@ private:
        IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
        rb.Push(RESULT_SUCCESS);
        rb.Push<u64>(1);
-        NGLOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service_VI, "(STUBBED) called");
    }
    void OpenLayer(Kernel::HLERequestContext& ctx) {
-        NGLOG_DEBUG(Service_VI, "called");
+        LOG_DEBUG(Service_VI, "called");
        IPC::RequestParser rp{ctx};
        auto name_buf = rp.PopRaw<std::array<u8, 0x40>>();
        auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
@@ -889,7 +889,7 @@ private:
    }
    void CreateStrayLayer(Kernel::HLERequestContext& ctx) {
-        NGLOG_DEBUG(Service_VI, "called");
+        LOG_DEBUG(Service_VI, "called");
        IPC::RequestParser rp{ctx};
        u32 flags = rp.Pop<u32>();
@@ -909,7 +909,7 @@ private:
    }
    void DestroyStrayLayer(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u64 layer_id = rp.Pop<u64>();
@@ -919,7 +919,7 @@ private:
    }
    void GetDisplayVsyncEvent(Kernel::HLERequestContext& ctx) {
-        NGLOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service_VI, "(STUBBED) called");
        IPC::RequestParser rp{ctx};
        u64 display_id = rp.Pop<u64>();
@@ -968,7 +968,7 @@ Module::Interface::Interface(std::shared_ptr<Module> module, const char* name,
    : ServiceFramework(name), module(std::move(module)), nv_flinger(std::move(nv_flinger)) {}
 void Module::Interface::GetDisplayService(Kernel::HLERequestContext& ctx) {
-    NGLOG_WARNING(Service_VI, "(STUBBED) called");
+    LOG_WARNING(Service_VI, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
diff --git a/src/core/hw/hw.cpp b/src/core/hw/hw.cpp
index 8fc91dc9c..2f48068c1 100644
--- a/src/core/hw/hw.cpp
+++ b/src/core/hw/hw.cpp
@@ -33,7 +33,7 @@ inline void Read(T& var, const u32 addr) {
        LCD::Read(var, addr);
        break;
    default:
-        NGLOG_ERROR(HW_Memory, "Unknown Read{} @ 0x{:08X}", sizeof(var) * 8, addr);
+        LOG_ERROR(HW_Memory, "Unknown Read{} @ 0x{:08X}", sizeof(var) * 8, addr);
        break;
    }
 }
@@ -62,7 +62,7 @@ inline void Write(u32 addr, const T data) {
        LCD::Write(addr, data);
        break;
    default:
-        NGLOG_ERROR(HW_Memory, "Unknown Write{} 0x{:08X} @ 0x{:08X}", sizeof(data) * 8, data, addr);
+        LOG_ERROR(HW_Memory, "Unknown Write{} 0x{:08X} @ 0x{:08X}", sizeof(data) * 8, data, addr);
        break;
    }
 }
@@ -85,12 +85,12 @@ void Update() {}
 /// Initialize hardware
 void Init() {
    LCD::Init();
-    NGLOG_DEBUG(HW, "Initialized OK");
+    LOG_DEBUG(HW, "Initialized OK");
 }
 /// Shutdown hardware
 void Shutdown() {
    LCD::Shutdown();
-    NGLOG_DEBUG(HW, "Shutdown OK");
+    LOG_DEBUG(HW, "Shutdown OK");
 }
 } // namespace HW
diff --git a/src/core/hw/lcd.cpp b/src/core/hw/lcd.cpp
index e8525efde..0b62174d5 100644
--- a/src/core/hw/lcd.cpp
+++ b/src/core/hw/lcd.cpp
@@ -20,7 +20,7 @@ inline void Read(T& var, const u32 raw_addr) {
    // Reads other than u32 are untested, so I'd rather have them abort than silently fail
    if (index >= 0x400 || !std::is_same<T, u32>::value) {
-        NGLOG_ERROR(HW_LCD, "Unknown Read{} @ 0x{:08X}", sizeof(var) * 8, addr);
+        LOG_ERROR(HW_LCD, "Unknown Read{} @ 0x{:08X}", sizeof(var) * 8, addr);
        return;
    }
@@ -34,7 +34,7 @@ inline void Write(u32 addr, const T data) {
    // Writes other than u32 are untested, so I'd rather have them abort than silently fail
    if (index >= 0x400 || !std::is_same<T, u32>::value) {
-        NGLOG_ERROR(HW_LCD, "Unknown Write{} 0x{:08X} @ 0x{:08X}", sizeof(data) * 8, data, addr);
+        LOG_ERROR(HW_LCD, "Unknown Write{} 0x{:08X} @ 0x{:08X}", sizeof(data) * 8, data, addr);
        return;
    }
@@ -56,12 +56,12 @@ template void Write<u8>(u32 addr, const u8 data);
 /// Initialize hardware
 void Init() {
    memset(&g_regs, 0, sizeof(g_regs));
-    NGLOG_DEBUG(HW_LCD, "Initialized OK");
+    LOG_DEBUG(HW_LCD, "Initialized OK");
 }
 /// Shutdown hardware
 void Shutdown() {
-    NGLOG_DEBUG(HW_LCD, "Shutdown OK");
+    LOG_DEBUG(HW_LCD, "Shutdown OK");
 }
 } // namespace LCD
diff --git a/src/core/loader/deconstructed_rom_directory.cpp b/src/core/loader/deconstructed_rom_directory.cpp
index b01b2caf6..eb7feb617 100644
--- a/src/core/loader/deconstructed_rom_directory.cpp
+++ b/src/core/loader/deconstructed_rom_directory.cpp
@@ -132,7 +132,7 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
        const VAddr load_addr = next_load_addr;
        next_load_addr = AppLoader_NSO::LoadModule(path, load_addr);
        if (next_load_addr) {
-            NGLOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", module, load_addr);
+            LOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", module, load_addr);
        } else {
            next_load_addr = load_addr;
        }
@@ -163,7 +163,7 @@ ResultStatus AppLoader_DeconstructedRomDirectory::ReadRomFS(
    std::shared_ptr<FileUtil::IOFile>& romfs_file, u64& offset, u64& size) {
    if (filepath_romfs.empty()) {
-        NGLOG_DEBUG(Loader, "No RomFS available");
+        LOG_DEBUG(Loader, "No RomFS available");
        return ResultStatus::ErrorNotUsed;
    }
@@ -176,8 +176,8 @@ ResultStatus AppLoader_DeconstructedRomDirectory::ReadRomFS(
    offset = 0;
    size = romfs_file->GetSize();
-    NGLOG_DEBUG(Loader, "RomFS offset:           0x{:016X}", offset);
+    LOG_DEBUG(Loader, "RomFS offset:           0x{:016X}", offset);
-    NGLOG_DEBUG(Loader, "RomFS size:             0x{:016X}", size);
+    LOG_DEBUG(Loader, "RomFS size:             0x{:016X}", size);
    // Reset read pointer
    file.Seek(0, SEEK_SET);
diff --git a/src/core/loader/elf.cpp b/src/core/loader/elf.cpp
index e42d3a870..b69e5c6ef 100644
--- a/src/core/loader/elf.cpp
+++ b/src/core/loader/elf.cpp
@@ -273,18 +273,18 @@ const char* ElfReader::GetSectionName(int section) const {
 }
 SharedPtr<CodeSet> ElfReader::LoadInto(u32 vaddr) {
-    NGLOG_DEBUG(Loader, "String section: {}", header->e_shstrndx);
+    LOG_DEBUG(Loader, "String section: {}", header->e_shstrndx);
    // Should we relocate?
    relocate = (header->e_type != ET_EXEC);
    if (relocate) {
-        NGLOG_DEBUG(Loader, "Relocatable module");
+        LOG_DEBUG(Loader, "Relocatable module");
        entryPoint += vaddr;
    } else {
-        NGLOG_DEBUG(Loader, "Prerelocated executable");
+        LOG_DEBUG(Loader, "Prerelocated executable");
    }
-    NGLOG_DEBUG(Loader, "{} segments:", header->e_phnum);
+    LOG_DEBUG(Loader, "{} segments:", header->e_phnum);
    // First pass : Get the bits into RAM
    u32 base_addr = relocate ? vaddr : 0;
@@ -304,8 +304,8 @@ SharedPtr<CodeSet> ElfReader::LoadInto(u32 vaddr) {
    for (unsigned int i = 0; i < header->e_phnum; ++i) {
        Elf32_Phdr* p = &segments[i];
-        NGLOG_DEBUG(Loader, "Type: {} Vaddr: {:08X} Filesz: {:08X} Memsz: {:08X} ", p->p_type,
+        LOG_DEBUG(Loader, "Type: {} Vaddr: {:08X} Filesz: {:08X} Memsz: {:08X} ", p->p_type,
-                    p->p_vaddr, p->p_filesz, p->p_memsz);
+                  p->p_vaddr, p->p_filesz, p->p_memsz);
        if (p->p_type == PT_LOAD) {
            CodeSet::Segment* codeset_segment;
@@ -317,16 +317,16 @@ SharedPtr<CodeSet> ElfReader::LoadInto(u32 vaddr) {
            } else if (permission_flags == (PF_R | PF_W)) {
                codeset_segment = &codeset->data;
            } else {
-                NGLOG_ERROR(Loader, "Unexpected ELF PT_LOAD segment id {} with flags {:X}", i,
+                LOG_ERROR(Loader, "Unexpected ELF PT_LOAD segment id {} with flags {:X}", i,
-                            p->p_flags);
+                          p->p_flags);
                continue;
            }
            if (codeset_segment->size != 0) {
-                NGLOG_ERROR(Loader,
+                LOG_ERROR(Loader,
-                            "ELF has more than one segment of the same type. Skipping extra "
+                          "ELF has more than one segment of the same type. Skipping extra "
-                            "segment (id {})",
+                          "segment (id {})",
-                            i);
+                          i);
                continue;
            }
@@ -345,7 +345,7 @@ SharedPtr<CodeSet> ElfReader::LoadInto(u32 vaddr) {
    codeset->entrypoint = base_addr + header->e_entry;
    codeset->memory = std::make_shared<std::vector<u8>>(std::move(program_image));
-    NGLOG_DEBUG(Loader, "Done loading.");
+    LOG_DEBUG(Loader, "Done loading.");
    return codeset;
 }
diff --git a/src/core/loader/linker.cpp b/src/core/loader/linker.cpp
index c7be5f265..769516b6f 100644
--- a/src/core/loader/linker.cpp
+++ b/src/core/loader/linker.cpp
@@ -84,7 +84,7 @@ void Linker::WriteRelocations(std::vector<u8>& program_image, const std::vector<
            }
            break;
        default:
-            NGLOG_CRITICAL(Loader, "Unknown relocation type: {}", static_cast<int>(rela.type));
+            LOG_CRITICAL(Loader, "Unknown relocation type: {}", static_cast<int>(rela.type));
            break;
        }
    }
@@ -141,7 +141,7 @@ void Linker::ResolveImports() {
        if (search != exports.end()) {
            Memory::Write64(import.second.ea, search->second + import.second.addend);
        } else {
-            NGLOG_ERROR(Loader, "Unresolved import: {}", import.first);
+            LOG_ERROR(Loader, "Unresolved import: {}", import.first);
        }
    }
 }
diff --git a/src/core/loader/loader.cpp b/src/core/loader/loader.cpp
index 20cc0bac0..8831d8e83 100644
--- a/src/core/loader/loader.cpp
+++ b/src/core/loader/loader.cpp
@@ -43,7 +43,7 @@ FileType IdentifyFile(FileUtil::IOFile& file, const std::string& filepath) {
 FileType IdentifyFile(const std::string& file_name) {
    FileUtil::IOFile file(file_name, "rb");
    if (!file.IsOpen()) {
-        NGLOG_ERROR(Loader, "Failed to load file {}", file_name);
+        LOG_ERROR(Loader, "Failed to load file {}", file_name);
        return FileType::Unknown;
    }
@@ -126,7 +126,7 @@ static std::unique_ptr<AppLoader> GetFileLoader(FileUtil::IOFile&& file, FileTyp
 std::unique_ptr<AppLoader> GetLoader(const std::string& filename) {
    FileUtil::IOFile file(filename, "rb");
    if (!file.IsOpen()) {
-        NGLOG_ERROR(Loader, "Failed to load file {}", filename);
+        LOG_ERROR(Loader, "Failed to load file {}", filename);
        return nullptr;
    }
@@ -137,12 +137,12 @@ std::unique_ptr<AppLoader> GetLoader(const std::string& filename) {
    FileType filename_type = GuessFromExtension(filename_extension);
    if (type != filename_type) {
-        NGLOG_WARNING(Loader, "File {} has a different type than its extension.", filename);
+        LOG_WARNING(Loader, "File {} has a different type than its extension.", filename);
        if (FileType::Unknown == type)
            type = filename_type;
    }
-    NGLOG_DEBUG(Loader, "Loading file {} as {}...", filename, GetFileTypeString(type));
+    LOG_DEBUG(Loader, "Loading file {} as {}...", filename, GetFileTypeString(type));
    return GetFileLoader(std::move(file), type, filename_filename, filename);
 }
diff --git a/src/core/loader/nca.cpp b/src/core/loader/nca.cpp
index 067945d46..da064f8e3 100644
--- a/src/core/loader/nca.cpp
+++ b/src/core/loader/nca.cpp
@@ -123,7 +123,7 @@ ResultStatus Nca::Load(FileUtil::IOFile&& in_file, std::string in_path) {
    file.Seek(0, SEEK_SET);
    std::array<u8, sizeof(NcaHeader)> header_array{};
    if (sizeof(NcaHeader) != file.ReadBytes(header_array.data(), sizeof(NcaHeader)))
-        NGLOG_CRITICAL(Loader, "File reader errored out during header read.");
+        LOG_CRITICAL(Loader, "File reader errored out during header read.");
    NcaHeader header{};
    std::memcpy(&header, header_array.data(), sizeof(NcaHeader));
@@ -140,7 +140,7 @@ ResultStatus Nca::Load(FileUtil::IOFile&& in_file, std::string in_path) {
        std::array<u8, sizeof(NcaSectionHeaderBlock)> array{};
        if (sizeof(NcaSectionHeaderBlock) !=
            file.ReadBytes(array.data(), sizeof(NcaSectionHeaderBlock)))
-            NGLOG_CRITICAL(Loader, "File reader errored out during header read.");
+            LOG_CRITICAL(Loader, "File reader errored out during header read.");
        NcaSectionHeaderBlock block{};
        std::memcpy(&block, array.data(), sizeof(NcaSectionHeaderBlock));
@@ -154,7 +154,7 @@ ResultStatus Nca::Load(FileUtil::IOFile&& in_file, std::string in_path) {
            // Seek back to beginning of this section.
            file.Seek(SECTION_HEADER_OFFSET + i * SECTION_HEADER_SIZE, SEEK_SET);
            if (sizeof(Pfs0Superblock) != file.ReadBytes(&sb, sizeof(Pfs0Superblock)))
-                NGLOG_CRITICAL(Loader, "File reader errored out during header read.");
+                LOG_CRITICAL(Loader, "File reader errored out during header read.");
            u64 offset = (static_cast<u64>(header.section_tables[i].media_offset) *
                          MEDIA_OFFSET_MULTIPLIER) +
@@ -258,7 +258,7 @@ ResultStatus AppLoader_NCA::Load(Kernel::SharedPtr<Kernel::Process>& process) {
        const VAddr load_addr = next_load_addr;
        next_load_addr = AppLoader_NSO::LoadModule(module, nca->GetExeFsFile(module), load_addr);
        if (next_load_addr) {
-            NGLOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", module, load_addr);
+            LOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", module, load_addr);
        } else {
            next_load_addr = load_addr;
        }
@@ -283,7 +283,7 @@ ResultStatus AppLoader_NCA::Load(Kernel::SharedPtr<Kernel::Process>& process) {
 ResultStatus AppLoader_NCA::ReadRomFS(std::shared_ptr<FileUtil::IOFile>& romfs_file, u64& offset,
                                      u64& size) {
    if (nca->GetRomFsSize() == 0) {
-        NGLOG_DEBUG(Loader, "No RomFS available");
+        LOG_DEBUG(Loader, "No RomFS available");
        return ResultStatus::ErrorNotUsed;
    }
@@ -292,8 +292,8 @@ ResultStatus AppLoader_NCA::ReadRomFS(std::shared_ptr<FileUtil::IOFile>& romfs_f
    offset = nca->GetRomFsOffset();
    size = nca->GetRomFsSize();
-    NGLOG_DEBUG(Loader, "RomFS offset:           0x{:016X}", offset);
+    LOG_DEBUG(Loader, "RomFS offset:           0x{:016X}", offset);
-    NGLOG_DEBUG(Loader, "RomFS size:             0x{:016X}", size);
+    LOG_DEBUG(Loader, "RomFS size:             0x{:016X}", size);
    return ResultStatus::Success;
 }
diff --git a/src/core/loader/nso.cpp b/src/core/loader/nso.cpp
index 845ed7e90..7f84e4b1b 100644
--- a/src/core/loader/nso.cpp
+++ b/src/core/loader/nso.cpp
@@ -87,7 +87,7 @@ static std::vector<u8> ReadSegment(FileUtil::IOFile& file, const NsoSegmentHeade
    file.Seek(header.offset, SEEK_SET);
    if (compressed_size != file.ReadBytes(compressed_data.data(), compressed_size)) {
-        NGLOG_CRITICAL(Loader, "Failed to read {} NSO LZ4 compressed bytes", compressed_size);
+        LOG_CRITICAL(Loader, "Failed to read {} NSO LZ4 compressed bytes", compressed_size);
        return {};
    }
@@ -215,7 +215,7 @@ ResultStatus AppLoader_NSO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
    // Load module
    LoadModule(filepath, Memory::PROCESS_IMAGE_VADDR);
-    NGLOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", filepath, Memory::PROCESS_IMAGE_VADDR);
+    LOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", filepath, Memory::PROCESS_IMAGE_VADDR);
    process->svc_access_mask.set();
    process->address_mappings = default_address_mappings;
diff --git a/src/core/memory.cpp b/src/core/memory.cpp
index f070dee7d..190ccc25c 100644
--- a/src/core/memory.cpp
+++ b/src/core/memory.cpp
@@ -43,8 +43,8 @@ PageTable* GetCurrentPageTable() {
 }
 static void MapPages(PageTable& page_table, VAddr base, u64 size, u8* memory, PageType type) {
-    NGLOG_DEBUG(HW_Memory, "Mapping {} onto {:016X}-{:016X}", fmt::ptr(memory), base * PAGE_SIZE,
+    LOG_DEBUG(HW_Memory, "Mapping {} onto {:016X}-{:016X}", fmt::ptr(memory), base * PAGE_SIZE,
-                (base + size) * PAGE_SIZE);
+              (base + size) * PAGE_SIZE);
    RasterizerFlushVirtualRegion(base << PAGE_BITS, size * PAGE_SIZE,
                                 FlushMode::FlushAndInvalidate);
@@ -173,7 +173,7 @@ T Read(const VAddr vaddr) {
    PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
    switch (type) {
    case PageType::Unmapped:
-        NGLOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:08X}", sizeof(T) * 8, vaddr);
+        LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:08X}", sizeof(T) * 8, vaddr);
        return 0;
    case PageType::Memory:
        ASSERT_MSG(false, "Mapped memory page without a pointer @ {:016X}", vaddr);
@@ -205,8 +205,8 @@ void Write(const VAddr vaddr, const T data) {
    PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
    switch (type) {
    case PageType::Unmapped:
-        NGLOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
+        LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
-                    static_cast<u32>(data), vaddr);
+                  static_cast<u32>(data), vaddr);
        return;
    case PageType::Memory:
        ASSERT_MSG(false, "Mapped memory page without a pointer @ {:016X}", vaddr);
@@ -259,7 +259,7 @@ u8* GetPointer(const VAddr vaddr) {
        return GetPointerFromVMA(vaddr);
    }
-    NGLOG_ERROR(HW_Memory, "Unknown GetPointer @ 0x{:016X}", vaddr);
+    LOG_ERROR(HW_Memory, "Unknown GetPointer @ 0x{:016X}", vaddr);
    return nullptr;
 }
@@ -296,12 +296,12 @@ u8* GetPhysicalPointer(PAddr address) {
        });
    if (area == std::end(memory_areas)) {
-        NGLOG_ERROR(HW_Memory, "Unknown GetPhysicalPointer @ 0x{:016X}", address);
+        LOG_ERROR(HW_Memory, "Unknown GetPhysicalPointer @ 0x{:016X}", address);
        return nullptr;
    }
    if (area->paddr_base == IO_AREA_PADDR) {
-        NGLOG_ERROR(HW_Memory, "MMIO mappings are not supported yet. phys_addr={:016X}", address);
+        LOG_ERROR(HW_Memory, "MMIO mappings are not supported yet. phys_addr={:016X}", address);
        return nullptr;
    }
@@ -348,9 +348,9 @@ void RasterizerMarkRegionCached(Tegra::GPUVAddr gpu_addr, u64 size, bool cached)
            Core::System::GetInstance().GPU().memory_manager->GpuToCpuAddress(gpu_addr);
        // The GPU <-> CPU virtual memory mapping is not 1:1
        if (!maybe_vaddr) {
-            NGLOG_ERROR(HW_Memory,
+            LOG_ERROR(HW_Memory,
-                        "Trying to flush a cached region to an invalid physical address {:016X}",
+                      "Trying to flush a cached region to an invalid physical address {:016X}",
-                        gpu_addr);
+                      gpu_addr);
            continue;
        }
        VAddr vaddr = *maybe_vaddr;
@@ -484,9 +484,9 @@ void ReadBlock(const Kernel::Process& process, const VAddr src_addr, void* dest_
        switch (page_table.attributes[page_index]) {
        case PageType::Unmapped: {
-            NGLOG_ERROR(HW_Memory,
+            LOG_ERROR(HW_Memory,
-                        "Unmapped ReadBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
+                      "Unmapped ReadBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
-                        current_vaddr, src_addr, size);
+                      current_vaddr, src_addr, size);
            std::memset(dest_buffer, 0, copy_amount);
            break;
        }
@@ -548,9 +548,9 @@ void WriteBlock(const Kernel::Process& process, const VAddr dest_addr, const voi
        switch (page_table.attributes[page_index]) {
        case PageType::Unmapped: {
-            NGLOG_ERROR(HW_Memory,
+            LOG_ERROR(HW_Memory,
-                        "Unmapped WriteBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
+                      "Unmapped WriteBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
-                        current_vaddr, dest_addr, size);
+                      current_vaddr, dest_addr, size);
            break;
        }
        case PageType::Memory: {
@@ -596,9 +596,9 @@ void ZeroBlock(const Kernel::Process& process, const VAddr dest_addr, const size
        switch (page_table.attributes[page_index]) {
        case PageType::Unmapped: {
-            NGLOG_ERROR(HW_Memory,
+            LOG_ERROR(HW_Memory,
-                        "Unmapped ZeroBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
+                      "Unmapped ZeroBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
-                        current_vaddr, dest_addr, size);
+                      current_vaddr, dest_addr, size);
            break;
        }
        case PageType::Memory: {
@@ -637,9 +637,9 @@ void CopyBlock(const Kernel::Process& process, VAddr dest_addr, VAddr src_addr,
        switch (page_table.attributes[page_index]) {
        case PageType::Unmapped: {
-            NGLOG_ERROR(HW_Memory,
+            LOG_ERROR(HW_Memory,
-                        "Unmapped CopyBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
+                      "Unmapped CopyBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
-                        current_vaddr, src_addr, size);
+                      current_vaddr, src_addr, size);
            ZeroBlock(process, dest_addr, copy_amount);
            break;
        }
@@ -692,7 +692,7 @@ boost::optional<PAddr> TryVirtualToPhysicalAddress(const VAddr addr) {
 PAddr VirtualToPhysicalAddress(const VAddr addr) {
    auto paddr = TryVirtualToPhysicalAddress(addr);
    if (!paddr) {
-        NGLOG_ERROR(HW_Memory, "Unknown virtual address @ 0x{:016X}", addr);
+        LOG_ERROR(HW_Memory, "Unknown virtual address @ 0x{:016X}", addr);
        // To help with debugging, set bit on address so that it's obviously invalid.
        return addr | 0x80000000;
    }
diff --git a/src/core/settings.h b/src/core/settings.h
index a7f1e5fa0..7150d9755 100644
--- a/src/core/settings.h
+++ b/src/core/settings.h
@@ -129,6 +129,7 @@ struct Values {
    // Renderer
    float resolution_factor;
    bool toggle_framelimit;
+    bool use_accurate_framebuffers;
    float bg_red;
    float bg_green;
diff --git a/src/core/telemetry_session.cpp b/src/core/telemetry_session.cpp
index a60aa1143..b9a603df3 100644
--- a/src/core/telemetry_session.cpp
+++ b/src/core/telemetry_session.cpp
@@ -42,14 +42,14 @@ u64 GetTelemetryId() {
    if (FileUtil::Exists(filename)) {
        FileUtil::IOFile file(filename, "rb");
        if (!file.IsOpen()) {
-            NGLOG_ERROR(Core, "failed to open telemetry_id: {}", filename);
+            LOG_ERROR(Core, "failed to open telemetry_id: {}", filename);
            return {};
        }
        file.ReadBytes(&telemetry_id, sizeof(u64));
    } else {
        FileUtil::IOFile file(filename, "wb");
        if (!file.IsOpen()) {
-            NGLOG_ERROR(Core, "failed to open telemetry_id: {}", filename);
+            LOG_ERROR(Core, "failed to open telemetry_id: {}", filename);
            return {};
        }
        telemetry_id = GenerateTelemetryId();
@@ -65,7 +65,7 @@ u64 RegenerateTelemetryId() {
    FileUtil::IOFile file(filename, "wb");
    if (!file.IsOpen()) {
-        NGLOG_ERROR(Core, "failed to open telemetry_id: {}", filename);
+        LOG_ERROR(Core, "failed to open telemetry_id: {}", filename);
        return {};
    }
    file.WriteBytes(&new_telemetry_id, sizeof(u64));
@@ -161,6 +161,8 @@ TelemetrySession::TelemetrySession() {
             Settings::values.resolution_factor);
    AddField(Telemetry::FieldType::UserConfig, "Renderer_ToggleFramelimit",
             Settings::values.toggle_framelimit);
+    AddField(Telemetry::FieldType::UserConfig, "Renderer_UseAccurateFramebuffers",
+             Settings::values.use_accurate_framebuffers);
    AddField(Telemetry::FieldType::UserConfig, "System_UseDockedMode",
             Settings::values.use_docked_mode);
 }
diff --git a/src/core/tracer/recorder.cpp b/src/core/tracer/recorder.cpp
index 2f848c994..af032f0c9 100644
--- a/src/core/tracer/recorder.cpp
+++ b/src/core/tracer/recorder.cpp
@@ -159,7 +159,7 @@ void Recorder::Finish(const std::string& filename) {
                throw "Failed to write stream element";
        }
    } catch (const char* str) {
-        NGLOG_ERROR(HW_GPU, "Writing CiTrace file failed: {}", str);
+        LOG_ERROR(HW_GPU, "Writing CiTrace file failed: {}", str);
    }
 }
diff --git a/src/input_common/sdl/sdl.cpp b/src/input_common/sdl/sdl.cpp
index 231a0f7af..8d117c2d4 100644
--- a/src/input_common/sdl/sdl.cpp
+++ b/src/input_common/sdl/sdl.cpp
@@ -32,7 +32,7 @@ public:
    explicit SDLJoystick(int joystick_index)
        : joystick{SDL_JoystickOpen(joystick_index), SDL_JoystickClose} {
        if (!joystick) {
-            NGLOG_ERROR(Input, "failed to open joystick {}", joystick_index);
+            LOG_ERROR(Input, "failed to open joystick {}", joystick_index);
        }
    }
@@ -204,7 +204,7 @@ public:
                trigger_if_greater = false;
            } else {
                trigger_if_greater = true;
-                NGLOG_ERROR(Input, "Unknown direction '{}'", direction_name);
+                LOG_ERROR(Input, "Unknown direction '{}'", direction_name);
            }
            return std::make_unique<SDLAxisButton>(GetJoystick(joystick_index), axis, threshold,
                                                   trigger_if_greater);
@@ -235,7 +235,7 @@ public:
 void Init() {
    if (SDL_Init(SDL_INIT_JOYSTICK) < 0) {
-        NGLOG_CRITICAL(Input, "SDL_Init(SDL_INIT_JOYSTICK) failed with: {}", SDL_GetError());
+        LOG_CRITICAL(Input, "SDL_Init(SDL_INIT_JOYSTICK) failed with: {}", SDL_GetError());
    } else {
        using namespace Input;
        RegisterFactory<ButtonDevice>("sdl", std::make_shared<SDLButtonFactory>());
diff --git a/src/video_core/command_processor.cpp b/src/video_core/command_processor.cpp
index cec9cb9f3..31ea3adad 100644
--- a/src/video_core/command_processor.cpp
+++ b/src/video_core/command_processor.cpp
@@ -29,21 +29,21 @@ enum class BufferMethods {
 };
 void GPU::WriteReg(u32 method, u32 subchannel, u32 value, u32 remaining_params) {
-    NGLOG_WARNING(HW_GPU,
+    LOG_WARNING(HW_GPU,
-                  "Processing method {:08X} on subchannel {} value "
+                "Processing method {:08X} on subchannel {} value "
-                  "{:08X} remaining params {}",
+                "{:08X} remaining params {}",
-                  method, subchannel, value, remaining_params);
+                method, subchannel, value, remaining_params);
    if (method == static_cast<u32>(BufferMethods::BindObject)) {
        // Bind the current subchannel to the desired engine id.
-        NGLOG_DEBUG(HW_GPU, "Binding subchannel {} to engine {}", subchannel, value);
+        LOG_DEBUG(HW_GPU, "Binding subchannel {} to engine {}", subchannel, value);
        bound_engines[subchannel] = static_cast<EngineID>(value);
        return;
    }
    if (method < static_cast<u32>(BufferMethods::CountBufferMethods)) {
        // TODO(Subv): Research and implement these methods.
-        NGLOG_ERROR(HW_GPU, "Special buffer methods other than Bind are not implemented");
+        LOG_ERROR(HW_GPU, "Special buffer methods other than Bind are not implemented");
        return;
    }
diff --git a/src/video_core/debug_utils/debug_utils.h b/src/video_core/debug_utils/debug_utils.h
index bbba8e380..9382a75e5 100644
--- a/src/video_core/debug_utils/debug_utils.h
+++ b/src/video_core/debug_utils/debug_utils.h
@@ -55,8 +55,10 @@ public:
        virtual ~BreakPointObserver() {
            auto context = context_weak.lock();
            if (context) {
-                std::unique_lock<std::mutex> lock(context->breakpoint_mutex);
+                {
-                context->breakpoint_observers.remove(this);
+                    std::unique_lock<std::mutex> lock(context->breakpoint_mutex);
+                    context->breakpoint_observers.remove(this);
+                }
                // If we are the last observer to be destroyed, tell the debugger context that
                // it is free to continue. In particular, this is required for a proper yuzu
diff --git a/src/video_core/engines/fermi_2d.cpp b/src/video_core/engines/fermi_2d.cpp
index 998b7c843..34053e393 100644
--- a/src/video_core/engines/fermi_2d.cpp
+++ b/src/video_core/engines/fermi_2d.cpp
@@ -26,8 +26,8 @@ void Fermi2D::WriteReg(u32 method, u32 value) {
 }
 void Fermi2D::HandleSurfaceCopy() {
-    NGLOG_WARNING(HW_GPU, "Requested a surface copy with operation {}",
+    LOG_WARNING(HW_GPU, "Requested a surface copy with operation {}",
-                  static_cast<u32>(regs.operation));
+                static_cast<u32>(regs.operation));
    const GPUVAddr source = regs.src.Address();
    const GPUVAddr dest = regs.dst.Address();
diff --git a/src/video_core/engines/maxwell_3d.cpp b/src/video_core/engines/maxwell_3d.cpp
index 93c43c8cb..3bca16364 100644
--- a/src/video_core/engines/maxwell_3d.cpp
+++ b/src/video_core/engines/maxwell_3d.cpp
@@ -126,6 +126,10 @@ void Maxwell3D::WriteReg(u32 method, u32 value, u32 remaining_params) {
        DrawArrays();
        break;
    }
+    case MAXWELL3D_REG_INDEX(clear_buffers): {
+        ProcessClearBuffers();
+        break;
+    }
    case MAXWELL3D_REG_INDEX(query.query_get): {
        ProcessQueryGet();
        break;
@@ -207,8 +211,8 @@ void Maxwell3D::ProcessQueryGet() {
 }
 void Maxwell3D::DrawArrays() {
-    NGLOG_DEBUG(HW_GPU, "called, topology={}, count={}",
+    LOG_DEBUG(HW_GPU, "called, topology={}, count={}", static_cast<u32>(regs.draw.topology.Value()),
-                static_cast<u32>(regs.draw.topology.Value()), regs.vertex_buffer.count);
+              regs.vertex_buffer.count);
    ASSERT_MSG(!(regs.index_array.count && regs.vertex_buffer.count), "Both indexed and direct?");
    auto debug_context = Core::System::GetInstance().GetGPUDebugContext();
@@ -415,5 +419,13 @@ bool Maxwell3D::IsShaderStageEnabled(Regs::ShaderStage stage) const {
    UNREACHABLE();
 }
+void Maxwell3D::ProcessClearBuffers() {
+    ASSERT(regs.clear_buffers.R == regs.clear_buffers.G &&
+           regs.clear_buffers.R == regs.clear_buffers.B &&
+           regs.clear_buffers.R == regs.clear_buffers.A);
+    VideoCore::g_renderer->Rasterizer()->Clear();
+}
 } // namespace Engines
 } // namespace Tegra
diff --git a/src/video_core/engines/maxwell_3d.h b/src/video_core/engines/maxwell_3d.h
index 2dc251205..5a7cf0107 100644
--- a/src/video_core/engines/maxwell_3d.h
+++ b/src/video_core/engines/maxwell_3d.h
@@ -280,6 +280,46 @@ public:
            UnsignedInt = 0x2,
        };
+        enum class ComparisonOp : u32 {
+            // These values are used by Nouveau and most games, they correspond to the OpenGL token
+            // values for these operations.
+            Never = 0x200,
+            Less = 0x201,
+            Equal = 0x202,
+            LessEqual = 0x203,
+            Greater = 0x204,
+            NotEqual = 0x205,
+            GreaterEqual = 0x206,
+            Always = 0x207,
+            // These values are used by some games, they seem to be NV04 values.
+            NeverOld = 1,
+            LessOld = 2,
+            EqualOld = 3,
+            LessEqualOld = 4,
+            GreaterOld = 5,
+            NotEqualOld = 6,
+            GreaterEqualOld = 7,
+            AlwaysOld = 8,
+        };
+        struct Cull {
+            enum class FrontFace : u32 {
+                ClockWise = 0x0900,
+                CounterClockWise = 0x0901,
+            };
+            enum class CullFace : u32 {
+                Front = 0x0404,
+                Back = 0x0405,
+                FrontAndBack = 0x0408,
+            };
+            u32 enabled;
+            FrontFace front_face;
+            CullFace cull_face;
+        };
        struct Blend {
            enum class Equation : u32 {
                Add = 1,
@@ -321,6 +361,24 @@ public:
            INSERT_PADDING_WORDS(1);
        };
+        struct RenderTargetConfig {
+            u32 address_high;
+            u32 address_low;
+            u32 width;
+            u32 height;
+            Tegra::RenderTargetFormat format;
+            u32 block_dimensions;
+            u32 array_mode;
+            u32 layer_stride;
+            u32 base_layer;
+            INSERT_PADDING_WORDS(7);
+            GPUVAddr Address() const {
+                return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) |
+                                             address_low);
+            }
+        };
        union {
            struct {
                INSERT_PADDING_WORDS(0x45);
@@ -333,23 +391,7 @@ public:
                INSERT_PADDING_WORDS(0x1B8);
-                struct {
+                RenderTargetConfig rt[NumRenderTargets];
-                    u32 address_high;
-                    u32 address_low;
-                    u32 width;
-                    u32 height;
-                    Tegra::RenderTargetFormat format;
-                    u32 block_dimensions;
-                    u32 array_mode;
-                    u32 layer_stride;
-                    u32 base_layer;
-                    INSERT_PADDING_WORDS(7);
-                    GPUVAddr Address() const {
-                        return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) |
-                                                     address_low);
-                    }
-                } rt[NumRenderTargets];
                struct {
                    f32 scale_x;
@@ -406,12 +448,17 @@ public:
                    u32 count;
                } vertex_buffer;
-                INSERT_PADDING_WORDS(0x99);
+                INSERT_PADDING_WORDS(1);
+                float clear_color[4];
+                float clear_depth;
+                INSERT_PADDING_WORDS(0x93);
                struct {
                    u32 address_high;
                    u32 address_low;
-                    u32 format;
+                    Tegra::DepthFormat format;
                    u32 block_dimensions;
                    u32 layer_stride;
@@ -433,11 +480,23 @@ public:
                    };
                } rt_control;
-                INSERT_PADDING_WORDS(0x31);
+                INSERT_PADDING_WORDS(0x2B);
+                u32 depth_test_enable;
+                INSERT_PADDING_WORDS(0x5);
                u32 independent_blend_enable;
-                INSERT_PADDING_WORDS(0x15);
+                u32 depth_write_enabled;
+                INSERT_PADDING_WORDS(0x7);
+                u32 d3d_cull_mode;
+                ComparisonOp depth_test_func;
+                INSERT_PADDING_WORDS(0xB);
                struct {
                    u32 separate_alpha;
@@ -453,7 +512,17 @@ public:
                    u32 enable[NumRenderTargets];
                } blend;
-                INSERT_PADDING_WORDS(0x77);
+                INSERT_PADDING_WORDS(0xB);
+                union {
+                    BitField<4, 1, u32> triangle_rast_flip;
+                } screen_y_control;
+                INSERT_PADDING_WORDS(0x21);
+                u32 vb_element_base;
+                INSERT_PADDING_WORDS(0x49);
                struct {
                    u32 tsc_address_high;
@@ -479,7 +548,12 @@ public:
                    }
                } tic;
-                INSERT_PADDING_WORDS(0x22);
+                INSERT_PADDING_WORDS(0x21);
+                union {
+                    BitField<2, 1, u32> coord_origin;
+                    BitField<3, 10, u32> enable;
+                } point_coord_replace;
                struct {
                    u32 code_address_high;
@@ -534,7 +608,27 @@ public:
                    }
                } index_array;
-                INSERT_PADDING_WORDS(0xC7);
+                INSERT_PADDING_WORDS(0x7);
+                INSERT_PADDING_WORDS(0x46);
+                Cull cull;
+                INSERT_PADDING_WORDS(0x2B);
+                union {
+                    u32 raw;
+                    BitField<0, 1, u32> Z;
+                    BitField<1, 1, u32> S;
+                    BitField<2, 1, u32> R;
+                    BitField<3, 1, u32> G;
+                    BitField<4, 1, u32> B;
+                    BitField<5, 1, u32> A;
+                    BitField<6, 4, u32> RT;
+                    BitField<10, 11, u32> layer;
+                } clear_buffers;
+                INSERT_PADDING_WORDS(0x4B);
                struct {
                    u32 query_address_high;
@@ -716,6 +810,9 @@ private:
    /// Handles writes to the macro uploading registers.
    void ProcessMacroUpload(u32 data);
+    /// Handles a write to the CLEAR_BUFFERS register.
+    void ProcessClearBuffers();
    /// Handles a write to the QUERY_GET register.
    void ProcessQueryGet();
@@ -738,16 +835,27 @@ ASSERT_REG_POSITION(rt, 0x200);
 ASSERT_REG_POSITION(viewport_transform[0], 0x280);
 ASSERT_REG_POSITION(viewport, 0x300);
 ASSERT_REG_POSITION(vertex_buffer, 0x35D);
+ASSERT_REG_POSITION(clear_color[0], 0x360);
+ASSERT_REG_POSITION(clear_depth, 0x364);
 ASSERT_REG_POSITION(zeta, 0x3F8);
 ASSERT_REG_POSITION(vertex_attrib_format[0], 0x458);
 ASSERT_REG_POSITION(rt_control, 0x487);
+ASSERT_REG_POSITION(depth_test_enable, 0x4B3);
 ASSERT_REG_POSITION(independent_blend_enable, 0x4B9);
+ASSERT_REG_POSITION(depth_write_enabled, 0x4BA);
+ASSERT_REG_POSITION(d3d_cull_mode, 0x4C2);
+ASSERT_REG_POSITION(depth_test_func, 0x4C3);
 ASSERT_REG_POSITION(blend, 0x4CF);
+ASSERT_REG_POSITION(screen_y_control, 0x4EB);
+ASSERT_REG_POSITION(vb_element_base, 0x50D);
 ASSERT_REG_POSITION(tsc, 0x557);
 ASSERT_REG_POSITION(tic, 0x55D);
+ASSERT_REG_POSITION(point_coord_replace, 0x581);
 ASSERT_REG_POSITION(code_address, 0x582);
 ASSERT_REG_POSITION(draw, 0x585);
 ASSERT_REG_POSITION(index_array, 0x5F2);
+ASSERT_REG_POSITION(cull, 0x646);
+ASSERT_REG_POSITION(clear_buffers, 0x674);
 ASSERT_REG_POSITION(query, 0x6C0);
 ASSERT_REG_POSITION(vertex_array[0], 0x700);
 ASSERT_REG_POSITION(independent_blend, 0x780);
diff --git a/src/video_core/engines/maxwell_dma.cpp b/src/video_core/engines/maxwell_dma.cpp
index 442138988..6e740713f 100644
--- a/src/video_core/engines/maxwell_dma.cpp
+++ b/src/video_core/engines/maxwell_dma.cpp
@@ -31,7 +31,7 @@ void MaxwellDMA::WriteReg(u32 method, u32 value) {
 }
 void MaxwellDMA::HandleCopy() {
-    NGLOG_WARNING(HW_GPU, "Requested a DMA copy");
+    LOG_WARNING(HW_GPU, "Requested a DMA copy");
    const GPUVAddr source = regs.src_address.Address();
    const GPUVAddr dest = regs.dst_address.Address();
@@ -49,7 +49,11 @@ void MaxwellDMA::HandleCopy() {
    ASSERT(regs.src_params.pos_y == 0);
    ASSERT(regs.dst_params.pos_x == 0);
    ASSERT(regs.dst_params.pos_y == 0);
-    ASSERT(regs.exec.is_dst_linear != regs.exec.is_src_linear);
+    if (regs.exec.is_dst_linear == regs.exec.is_src_linear) {
+        Memory::CopyBlock(dest_cpu, source_cpu, regs.x_count * regs.y_count);
+        return;
+    }
    u8* src_buffer = Memory::GetPointer(source_cpu);
    u8* dst_buffer = Memory::GetPointer(dest_cpu);
diff --git a/src/video_core/engines/shader_bytecode.h b/src/video_core/engines/shader_bytecode.h
index cb4db0679..2bc1782ad 100644
--- a/src/video_core/engines/shader_bytecode.h
+++ b/src/video_core/engines/shader_bytecode.h
@@ -142,6 +142,7 @@ enum class PredCondition : u64 {
    GreaterThan = 4,
    NotEqual = 5,
    GreaterEqual = 6,
+    NotEqualWithNan = 13,
    // TODO(Subv): Other condition types
 };
@@ -165,7 +166,7 @@ enum class SubOp : u64 {
    Lg2 = 0x3,
    Rcp = 0x4,
    Rsq = 0x5,
-    Min = 0x8,
+    Sqrt = 0x8,
 };
 enum class F2iRoundingOp : u64 {
@@ -193,6 +194,13 @@ enum class UniformType : u64 {
    Double = 5,
 };
+enum class IMinMaxExchange : u64 {
+    None = 0,
+    XLo = 1,
+    XMed = 2,
+    XHi = 3,
+};
 union Instruction {
    Instruction& operator=(const Instruction& instr) {
        value = instr.value;
@@ -209,7 +217,7 @@ union Instruction {
    } pred;
    BitField<19, 1, u64> negate_pred;
    BitField<20, 8, Register> gpr20;
-    BitField<20, 7, SubOp> sub_op;
+    BitField<20, 4, SubOp> sub_op;
    BitField<28, 8, Register> gpr28;
    BitField<39, 8, Register> gpr39;
    BitField<48, 16, u64> opcode;
@@ -278,6 +286,13 @@ union Instruction {
    } alu_integer;
    union {
+        BitField<39, 3, u64> pred;
+        BitField<42, 1, u64> negate_pred;
+        BitField<43, 2, IMinMaxExchange> exchange;
+        BitField<48, 1, u64> is_signed;
+    } imnmx;
+    union {
        BitField<54, 1, u64> saturate;
        BitField<56, 1, u64> negate_a;
    } iadd32i;
@@ -328,6 +343,19 @@ union Instruction {
    } isetp;
    union {
+        BitField<0, 3, u64> pred0;
+        BitField<3, 3, u64> pred3;
+        BitField<12, 3, u64> pred12;
+        BitField<15, 1, u64> neg_pred12;
+        BitField<24, 2, PredOperation> cond;
+        BitField<29, 3, u64> pred29;
+        BitField<32, 1, u64> neg_pred29;
+        BitField<39, 3, u64> pred39;
+        BitField<42, 1, u64> neg_pred39;
+        BitField<45, 2, PredOperation> op;
+    } psetp;
+    union {
        BitField<39, 3, u64> pred39;
        BitField<42, 1, u64> neg_pred;
        BitField<43, 1, u64> neg_a;
@@ -437,6 +465,8 @@ public:
    enum class Id {
        KIL,
        SSY,
+        SYNC,
+        DEPBAR,
        BFE_C,
        BFE_R,
        BFE_IMM,
@@ -533,6 +563,7 @@ public:
        Shift,
        Ffma,
        Flow,
+        Synch,
        Memory,
        FloatSet,
        FloatSetPredicate,
@@ -637,10 +668,12 @@ private:
            INST("111000110011----", Id::KIL, Type::Flow, "KIL"),
            INST("111000101001----", Id::SSY, Type::Flow, "SSY"),
            INST("111000100100----", Id::BRA, Type::Flow, "BRA"),
+            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"),
-            INST("1100000000111---", Id::TEX, Type::Memory, "TEX"),
+            INST("110000----111---", Id::TEX, Type::Memory, "TEX"),
            INST("1101111101001---", Id::TEXQ, Type::Memory, "TEXQ"),
            INST("1101100---------", Id::TEXS, Type::Memory, "TEXS"),
            INST("1101101---------", Id::TLDS, Type::Memory, "TLDS"),
@@ -681,9 +714,9 @@ private:
            INST("0100110001100---", Id::FMNMX_C, Type::Arithmetic, "FMNMX_C"),
            INST("0101110001100---", Id::FMNMX_R, Type::Arithmetic, "FMNMX_R"),
            INST("0011100-01100---", Id::FMNMX_IMM, Type::Arithmetic, "FMNMX_IMM"),
-            INST("0100110000100---", Id::IMNMX_C, Type::Arithmetic, "FMNMX_IMM"),
+            INST("0100110000100---", Id::IMNMX_C, Type::ArithmeticInteger, "IMNMX_C"),
-            INST("0101110000100---", Id::IMNMX_R, Type::Arithmetic, "FMNMX_IMM"),
+            INST("0101110000100---", Id::IMNMX_R, Type::ArithmeticInteger, "IMNMX_R"),
-            INST("0011100-00100---", Id::IMNMX_IMM, Type::Arithmetic, "FMNMX_IMM"),
+            INST("0011100-00100---", Id::IMNMX_IMM, Type::ArithmeticInteger, "IMNMX_IMM"),
            INST("0100110000000---", Id::BFE_C, Type::Bfe, "BFE_C"),
            INST("0101110000000---", Id::BFE_R, Type::Bfe, "BFE_R"),
            INST("0011100-00000---", Id::BFE_IMM, Type::Bfe, "BFE_IMM"),
diff --git a/src/video_core/gpu.h b/src/video_core/gpu.h
index 7b4e9b842..cc5ca656e 100644
--- a/src/video_core/gpu.h
+++ b/src/video_core/gpu.h
@@ -16,6 +16,7 @@ namespace Tegra {
 enum class RenderTargetFormat : u32 {
    NONE = 0x0,
    RGBA32_FLOAT = 0xC0,
+    RGBA32_UINT = 0xC2,
    RGBA16_FLOAT = 0xCA,
    RGB10_A2_UNORM = 0xD1,
    RGBA8_UNORM = 0xD5,
@@ -23,6 +24,15 @@ enum class RenderTargetFormat : u32 {
    R11G11B10_FLOAT = 0xE0,
 };
+enum class DepthFormat : u32 {
+    Z32_FLOAT = 0xA,
+    Z16_UNORM = 0x13,
+    S8_Z24_UNORM = 0x14,
+    Z24_X8_UNORM = 0x15,
+    Z24_S8_UNORM = 0x16,
+    Z24_C8_UNORM = 0x18,
+};
 /// Returns the number of bytes per pixel of each rendertarget format.
 u32 RenderTargetBytesPerPixel(RenderTargetFormat format);
diff --git a/src/video_core/memory_manager.cpp b/src/video_core/memory_manager.cpp
index 5cefce9fc..2f814a184 100644
--- a/src/video_core/memory_manager.cpp
+++ b/src/video_core/memory_manager.cpp
@@ -100,9 +100,9 @@ boost::optional<GPUVAddr> MemoryManager::FindFreeBlock(u64 size, u64 align) {
 boost::optional<VAddr> MemoryManager::GpuToCpuAddress(GPUVAddr gpu_addr) {
    VAddr base_addr = PageSlot(gpu_addr);
-    ASSERT(base_addr != static_cast<u64>(PageStatus::Unmapped));
-    if (base_addr == static_cast<u64>(PageStatus::Allocated)) {
+    if (base_addr == static_cast<u64>(PageStatus::Allocated) ||
+        base_addr == static_cast<u64>(PageStatus::Unmapped)) {
        return {};
    }
diff --git a/src/video_core/rasterizer_interface.h b/src/video_core/rasterizer_interface.h
index f0e48a802..499e84b89 100644
--- a/src/video_core/rasterizer_interface.h
+++ b/src/video_core/rasterizer_interface.h
@@ -19,6 +19,9 @@ public:
    /// Draw the current batch of vertex arrays
    virtual void DrawArrays() = 0;
+    /// Clear the current framebuffer
+    virtual void Clear() = 0;
    /// Notify rasterizer that the specified Maxwell register has been changed
    virtual void NotifyMaxwellRegisterChanged(u32 method) = 0;
@@ -51,9 +54,8 @@ public:
    }
    /// Attempt to use a faster method to display the framebuffer to screen
-    virtual bool AccelerateDisplay(const Tegra::FramebufferConfig& framebuffer,
+    virtual bool AccelerateDisplay(const Tegra::FramebufferConfig& config, VAddr framebuffer_addr,
-                                   VAddr framebuffer_addr, u32 pixel_stride,
+                                   u32 pixel_stride, ScreenInfo& screen_info) {
-                                   ScreenInfo& screen_info) {
        return false;
    }
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.cpp b/src/video_core/renderer_opengl/gl_rasterizer.cpp
index 3ba20f978..ea138d402 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer.cpp
@@ -112,7 +112,7 @@ RasterizerOpenGL::RasterizerOpenGL() {
    glEnable(GL_BLEND);
-    NGLOG_CRITICAL(Render_OpenGL, "Sync fixed function OpenGL state here!");
+    LOG_CRITICAL(Render_OpenGL, "Sync fixed function OpenGL state here!");
 }
 RasterizerOpenGL::~RasterizerOpenGL() {
@@ -146,7 +146,6 @@ std::pair<u8*, GLintptr> RasterizerOpenGL::SetupVertexArrays(u8* array_ptr,
        u64 size = end - start + 1;
        // Copy vertex array data
-        res_cache.FlushRegion(start, size, nullptr);
        Memory::ReadBlock(*memory_manager->GpuToCpuAddress(start), array_ptr, size);
        // Bind the vertex array to the buffer at the current offset.
@@ -166,9 +165,9 @@ std::pair<u8*, GLintptr> RasterizerOpenGL::SetupVertexArrays(u8* array_ptr,
    // assume every shader uses them all.
    for (unsigned index = 0; index < 16; ++index) {
        auto& attrib = regs.vertex_attrib_format[index];
-        NGLOG_DEBUG(HW_GPU, "vertex attrib {}, count={}, size={}, type={}, offset={}, normalize={}",
+        LOG_DEBUG(HW_GPU, "vertex attrib {}, count={}, size={}, type={}, offset={}, normalize={}",
-                    index, attrib.ComponentCount(), attrib.SizeString(), attrib.TypeString(),
+                  index, attrib.ComponentCount(), attrib.SizeString(), attrib.TypeString(),
-                    attrib.offset.Value(), attrib.IsNormalized());
+                  attrib.offset.Value(), attrib.IsNormalized());
        auto& buffer = regs.vertex_array[attrib.buffer];
        ASSERT(buffer.IsEnabled());
@@ -197,8 +196,8 @@ void RasterizerOpenGL::SetupShaders(u8* buffer_ptr, GLintptr buffer_offset) {
    ASSERT_MSG(!gpu.regs.shader_config[0].enable, "VertexA is unsupported!");
    // Next available bindpoints to use when uploading the const buffers and textures to the GLSL
-    // shaders.
+    // shaders. The constbuffer bindpoint starts after the shader stage configuration bind points.
-    u32 current_constbuffer_bindpoint = 0;
+    u32 current_constbuffer_bindpoint = uniform_buffers.size();
    u32 current_texture_bindpoint = 0;
    for (unsigned index = 1; index < Maxwell::MaxShaderProgram; ++index) {
@@ -252,8 +251,8 @@ void RasterizerOpenGL::SetupShaders(u8* buffer_ptr, GLintptr buffer_offset) {
            break;
        }
        default:
-            NGLOG_CRITICAL(HW_GPU, "Unimplemented shader index={}, enable={}, offset=0x{:08X}",
+            LOG_CRITICAL(HW_GPU, "Unimplemented shader index={}, enable={}, offset=0x{:08X}", index,
-                           index, shader_config.enable.Value(), shader_config.offset);
+                         shader_config.enable.Value(), shader_config.offset);
            UNREACHABLE();
        }
@@ -298,17 +297,16 @@ bool RasterizerOpenGL::AccelerateDrawBatch(bool is_indexed) {
    return true;
 }
-void RasterizerOpenGL::DrawArrays() {
+std::pair<Surface, Surface> RasterizerOpenGL::ConfigureFramebuffers(bool using_color_fb,
-    if (accelerate_draw == AccelDraw::Disabled)
+                                                                    bool using_depth_fb) {
-        return;
-    MICROPROFILE_SCOPE(OpenGL_Drawing);
    const auto& regs = Core::System().GetInstance().GPU().Maxwell3D().regs;
-    // TODO(bunnei): Implement these
+    // Sync the depth test state before configuring the framebuffer surfaces.
+    SyncDepthTestState();
+    // TODO(bunnei): Implement this
    const bool has_stencil = false;
-    const bool using_color_fb = true;
-    const bool using_depth_fb = false;
    const MathUtil::Rectangle<s32> viewport_rect{regs.viewport_transform[0].GetRect()};
    const bool write_color_fb =
@@ -325,35 +323,21 @@ void RasterizerOpenGL::DrawArrays() {
    std::tie(color_surface, depth_surface, surfaces_rect) =
        res_cache.GetFramebufferSurfaces(using_color_fb, using_depth_fb, viewport_rect);
-    const u16 res_scale = color_surface != nullptr
-                              ? color_surface->res_scale
-                              : (depth_surface == nullptr ? 1u : depth_surface->res_scale);
    MathUtil::Rectangle<u32> draw_rect{
+        static_cast<u32>(std::clamp<s32>(static_cast<s32>(surfaces_rect.left) + viewport_rect.left,
+                                         surfaces_rect.left, surfaces_rect.right)), // Left
+        static_cast<u32>(std::clamp<s32>(static_cast<s32>(surfaces_rect.bottom) + viewport_rect.top,
+                                         surfaces_rect.bottom, surfaces_rect.top)), // Top
+        static_cast<u32>(std::clamp<s32>(static_cast<s32>(surfaces_rect.left) + viewport_rect.right,
+                                         surfaces_rect.left, surfaces_rect.right)), // Right
        static_cast<u32>(
-            std::clamp<s32>(static_cast<s32>(surfaces_rect.left) + viewport_rect.left * res_scale,
+            std::clamp<s32>(static_cast<s32>(surfaces_rect.bottom) + viewport_rect.bottom,
-                            surfaces_rect.left, surfaces_rect.right)), // Left
+                            surfaces_rect.bottom, surfaces_rect.top))}; // Bottom
-        static_cast<u32>(
-            std::clamp<s32>(static_cast<s32>(surfaces_rect.bottom) + viewport_rect.top * res_scale,
-                            surfaces_rect.bottom, surfaces_rect.top)), // Top
-        static_cast<u32>(
-            std::clamp<s32>(static_cast<s32>(surfaces_rect.left) + viewport_rect.right * res_scale,
-                            surfaces_rect.left, surfaces_rect.right)), // Right
-        static_cast<u32>(std::clamp<s32>(static_cast<s32>(surfaces_rect.bottom) +
-                                             viewport_rect.bottom * res_scale,
-                                         surfaces_rect.bottom, surfaces_rect.top))}; // Bottom
    // Bind the framebuffer surfaces
    BindFramebufferSurfaces(color_surface, depth_surface, has_stencil);
-    // Sync the viewport
+    SyncViewport(surfaces_rect);
-    SyncViewport(surfaces_rect, res_scale);
-    // Sync the blend state registers
-    SyncBlendState();
-    // TODO(bunnei): Sync framebuffer_scale uniform here
-    // TODO(bunnei): Sync scissorbox uniform(s) here
    // Viewport can have negative offsets or larger dimensions than our framebuffer sub-rect. Enable
    // scissor test to prevent drawing outside of the framebuffer region
@@ -364,6 +348,66 @@ void RasterizerOpenGL::DrawArrays() {
    state.scissor.height = draw_rect.GetHeight();
    state.Apply();
+    // Only return the surface to be marked as dirty if writing to it is enabled.
+    return std::make_pair(write_color_fb ? color_surface : nullptr,
+                          write_depth_fb ? depth_surface : nullptr);
+}
+void RasterizerOpenGL::Clear() {
+    const auto& regs = Core::System().GetInstance().GPU().Maxwell3D().regs;
+    bool use_color_fb = false;
+    bool use_depth_fb = false;
+    GLbitfield clear_mask = 0;
+    if (regs.clear_buffers.R && regs.clear_buffers.G && regs.clear_buffers.B &&
+        regs.clear_buffers.A) {
+        clear_mask |= GL_COLOR_BUFFER_BIT;
+        use_color_fb = true;
+    }
+    if (regs.clear_buffers.Z) {
+        clear_mask |= GL_DEPTH_BUFFER_BIT;
+        use_depth_fb = true;
+    }
+    if (clear_mask == 0)
+        return;
+    auto [dirty_color_surface, dirty_depth_surface] =
+        ConfigureFramebuffers(use_color_fb, use_depth_fb);
+    // TODO(Subv): Support clearing only partial colors.
+    glClearColor(regs.clear_color[0], regs.clear_color[1], regs.clear_color[2],
+                 regs.clear_color[3]);
+    glClearDepth(regs.clear_depth);
+    glClear(clear_mask);
+    // Mark framebuffer surfaces as dirty
+    if (dirty_color_surface != nullptr) {
+        res_cache.MarkSurfaceAsDirty(dirty_color_surface);
+    }
+    if (dirty_depth_surface != nullptr) {
+        res_cache.MarkSurfaceAsDirty(dirty_depth_surface);
+    }
+}
+void RasterizerOpenGL::DrawArrays() {
+    if (accelerate_draw == AccelDraw::Disabled)
+        return;
+    MICROPROFILE_SCOPE(OpenGL_Drawing);
+    const auto& regs = Core::System().GetInstance().GPU().Maxwell3D().regs;
+    auto [dirty_color_surface, dirty_depth_surface] =
+        ConfigureFramebuffers(true, regs.zeta.Address() != 0);
+    SyncBlendState();
+    SyncCullMode();
+    // TODO(bunnei): Sync framebuffer_scale uniform here
+    // TODO(bunnei): Sync scissorbox uniform(s) here
    // Draw the vertex batch
    const bool is_indexed = accelerate_draw == AccelDraw::Indexed;
    const u64 index_buffer_size{regs.index_array.count * regs.index_array.FormatSizeInBytes()};
@@ -420,14 +464,16 @@ void RasterizerOpenGL::DrawArrays() {
    const GLenum primitive_mode{MaxwellToGL::PrimitiveTopology(regs.draw.topology)};
    if (is_indexed) {
-        const GLint index_min{static_cast<GLint>(regs.index_array.first)};
+        const GLint base_vertex{static_cast<GLint>(regs.vb_element_base)};
-        const GLint index_max{static_cast<GLint>(regs.index_array.first + regs.index_array.count)};
-        glDrawRangeElementsBaseVertex(primitive_mode, index_min, index_max, regs.index_array.count,
+        // Adjust the index buffer offset so it points to the first desired index.
-                                      MaxwellToGL::IndexFormat(regs.index_array.format),
+        index_buffer_offset += regs.index_array.first * regs.index_array.FormatSizeInBytes();
-                                      reinterpret_cast<const void*>(index_buffer_offset),
-                                      -index_min);
+        glDrawElementsBaseVertex(primitive_mode, regs.index_array.count,
+                                 MaxwellToGL::IndexFormat(regs.index_array.format),
+                                 reinterpret_cast<const void*>(index_buffer_offset), base_vertex);
    } else {
-        glDrawArrays(primitive_mode, 0, regs.vertex_buffer.count);
+        glDrawArrays(primitive_mode, regs.vertex_buffer.first, regs.vertex_buffer.count);
    }
    // Disable scissor test
@@ -437,24 +483,16 @@ void RasterizerOpenGL::DrawArrays() {
    // Unbind textures for potential future use as framebuffer attachments
    for (auto& texture_unit : state.texture_units) {
-        texture_unit.texture_2d = 0;
+        texture_unit.Unbind();
    }
    state.Apply();
    // Mark framebuffer surfaces as dirty
-    MathUtil::Rectangle<u32> draw_rect_unscaled{
+    if (dirty_color_surface != nullptr) {
-        draw_rect.left / res_scale, draw_rect.top / res_scale, draw_rect.right / res_scale,
+        res_cache.MarkSurfaceAsDirty(dirty_color_surface);
-        draw_rect.bottom / res_scale};
-    if (color_surface != nullptr && write_color_fb) {
-        auto interval = color_surface->GetSubRectInterval(draw_rect_unscaled);
-        res_cache.InvalidateRegion(boost::icl::first(interval), boost::icl::length(interval),
-                                   color_surface);
    }
-    if (depth_surface != nullptr && write_depth_fb) {
+    if (dirty_depth_surface != nullptr) {
-        auto interval = depth_surface->GetSubRectInterval(draw_rect_unscaled);
+        res_cache.MarkSurfaceAsDirty(dirty_depth_surface);
-        res_cache.InvalidateRegion(boost::icl::first(interval), boost::icl::length(interval),
-                                   depth_surface);
    }
 }
@@ -462,7 +500,7 @@ void RasterizerOpenGL::NotifyMaxwellRegisterChanged(u32 method) {}
 void RasterizerOpenGL::FlushAll() {
    MICROPROFILE_SCOPE(OpenGL_CacheManagement);
-    res_cache.FlushAll();
+    res_cache.FlushRegion(0, Kernel::VMManager::MAX_ADDRESS);
 }
 void RasterizerOpenGL::FlushRegion(Tegra::GPUVAddr addr, u64 size) {
@@ -472,13 +510,13 @@ void RasterizerOpenGL::FlushRegion(Tegra::GPUVAddr addr, u64 size) {
 void RasterizerOpenGL::InvalidateRegion(Tegra::GPUVAddr addr, u64 size) {
    MICROPROFILE_SCOPE(OpenGL_CacheManagement);
-    res_cache.InvalidateRegion(addr, size, nullptr);
+    res_cache.InvalidateRegion(addr, size);
 }
 void RasterizerOpenGL::FlushAndInvalidateRegion(Tegra::GPUVAddr addr, u64 size) {
    MICROPROFILE_SCOPE(OpenGL_CacheManagement);
    res_cache.FlushRegion(addr, size);
-    res_cache.InvalidateRegion(addr, size, nullptr);
+    res_cache.InvalidateRegion(addr, size);
 }
 bool RasterizerOpenGL::AccelerateDisplayTransfer(const void* config) {
@@ -497,45 +535,28 @@ bool RasterizerOpenGL::AccelerateFill(const void* config) {
    return true;
 }
-bool RasterizerOpenGL::AccelerateDisplay(const Tegra::FramebufferConfig& framebuffer,
+bool RasterizerOpenGL::AccelerateDisplay(const Tegra::FramebufferConfig& config,
                                         VAddr framebuffer_addr, u32 pixel_stride,
                                         ScreenInfo& screen_info) {
-    if (framebuffer_addr == 0) {
+    if (!framebuffer_addr) {
-        return false;
+        return {};
    }
    MICROPROFILE_SCOPE(OpenGL_CacheManagement);
-    SurfaceParams src_params;
+    const auto& surface{res_cache.TryFindFramebufferSurface(framebuffer_addr)};
-    src_params.cpu_addr = framebuffer_addr;
+    if (!surface) {
-    src_params.addr = res_cache.TryFindFramebufferGpuAddress(framebuffer_addr).get_value_or(0);
+        return {};
-    src_params.width = std::min(framebuffer.width, pixel_stride);
-    src_params.height = framebuffer.height;
-    src_params.stride = pixel_stride;
-    src_params.is_tiled = true;
-    src_params.block_height = Tegra::Texture::TICEntry::DefaultBlockHeight;
-    src_params.pixel_format =
-        SurfaceParams::PixelFormatFromGPUPixelFormat(framebuffer.pixel_format);
-    src_params.component_type =
-        SurfaceParams::ComponentTypeFromGPUPixelFormat(framebuffer.pixel_format);
-    src_params.UpdateParams();
-    MathUtil::Rectangle<u32> src_rect;
-    Surface src_surface;
-    std::tie(src_surface, src_rect) =
-        res_cache.GetSurfaceSubRect(src_params, ScaleMatch::Ignore, true);
-    if (src_surface == nullptr) {
-        return false;
    }
-    u32 scaled_width = src_surface->GetScaledWidth();
+    // Verify that the cached surface is the same size and format as the requested framebuffer
-    u32 scaled_height = src_surface->GetScaledHeight();
+    const auto& params{surface->GetSurfaceParams()};
+    const auto& pixel_format{SurfaceParams::PixelFormatFromGPUPixelFormat(config.pixel_format)};
-    screen_info.display_texcoords = MathUtil::Rectangle<float>(
+    ASSERT_MSG(params.width == config.width, "Framebuffer width is different");
-        (float)src_rect.bottom / (float)scaled_height, (float)src_rect.left / (float)scaled_width,
+    ASSERT_MSG(params.height == config.height, "Framebuffer height is different");
-        (float)src_rect.top / (float)scaled_height, (float)src_rect.right / (float)scaled_width);
+    ASSERT_MSG(params.pixel_format == pixel_format, "Framebuffer pixel_format is different");
-    screen_info.display_texture = src_surface->texture.handle;
+    screen_info.display_texture = surface->Texture().handle;
    return true;
 }
@@ -608,27 +629,39 @@ u32 RasterizerOpenGL::SetupConstBuffers(Maxwell::ShaderStage stage, GLuint progr
        boost::optional<VAddr> addr = gpu.memory_manager->GpuToCpuAddress(buffer.address);
-        std::vector<u8> data;
+        size_t size = 0;
        if (used_buffer.IsIndirect()) {
            // Buffer is accessed indirectly, so upload the entire thing
-            data.resize(buffer.size * sizeof(float));
+            size = buffer.size * sizeof(float);
+            if (size > MaxConstbufferSize) {
+                LOG_ERROR(HW_GPU, "indirect constbuffer size {} exceeds maximum {}", size,
+                          MaxConstbufferSize);
+                size = MaxConstbufferSize;
+            }
        } else {
            // Buffer is accessed directly, upload just what we use
-            data.resize(used_buffer.GetSize() * sizeof(float));
+            size = used_buffer.GetSize() * sizeof(float);
        }
+        // Align the actual size so it ends up being a multiple of vec4 to meet the OpenGL std140
+        // UBO alignment requirements.
+        size = Common::AlignUp(size, sizeof(GLvec4));
+        ASSERT_MSG(size <= MaxConstbufferSize, "Constbuffer too big");
+        std::vector<u8> data(size);
        Memory::ReadBlock(*addr, data.data(), data.size());
-        glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer_draw_state.ssbo);
+        glBindBuffer(GL_UNIFORM_BUFFER, buffer_draw_state.ssbo);
-        glBufferData(GL_SHADER_STORAGE_BUFFER, data.size(), data.data(), GL_DYNAMIC_DRAW);
+        glBufferData(GL_UNIFORM_BUFFER, data.size(), data.data(), GL_DYNAMIC_DRAW);
-        glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
+        glBindBuffer(GL_UNIFORM_BUFFER, 0);
        // Now configure the bindpoint of the buffer inside the shader
        std::string buffer_name = used_buffer.GetName();
-        GLuint index =
+        GLuint index = glGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, buffer_name.c_str());
-            glGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, buffer_name.c_str());
        if (index != -1)
-            glShaderStorageBlockBinding(program, index, buffer_draw_state.bindpoint);
+            glUniformBlockBinding(program, index, buffer_draw_state.bindpoint);
    }
    state.Apply();
@@ -653,16 +686,23 @@ u32 RasterizerOpenGL::SetupTextures(Maxwell::ShaderStage stage, GLuint program,
        // Bind the uniform to the sampler.
        GLint uniform = glGetUniformLocation(program, entry.GetName().c_str());
-        ASSERT(uniform != -1);
+        if (uniform == -1) {
+            continue;
+        }
        glProgramUniform1i(program, uniform, current_bindpoint);
        const auto texture = maxwell3d.GetStageTexture(entry.GetStage(), entry.GetOffset());
-        ASSERT(texture.enabled);
+        if (!texture.enabled) {
+            state.texture_units[current_bindpoint].texture_2d = 0;
+            continue;
+        }
        texture_samplers[current_bindpoint].SyncWithConfig(texture.tsc);
        Surface surface = res_cache.GetTextureSurface(texture);
        if (surface != nullptr) {
-            state.texture_units[current_bindpoint].texture_2d = surface->texture.handle;
+            state.texture_units[current_bindpoint].texture_2d = surface->Texture().handle;
            state.texture_units[current_bindpoint].swizzle.r =
                MaxwellToGL::SwizzleSource(texture.tic.x_source);
            state.texture_units[current_bindpoint].swizzle.g =
@@ -688,16 +728,16 @@ void RasterizerOpenGL::BindFramebufferSurfaces(const Surface& color_surface,
    state.Apply();
    glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
-                           color_surface != nullptr ? color_surface->texture.handle : 0, 0);
+                           color_surface != nullptr ? color_surface->Texture().handle : 0, 0);
    if (depth_surface != nullptr) {
        if (has_stencil) {
            // attach both depth and stencil
            glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
-                                   depth_surface->texture.handle, 0);
+                                   depth_surface->Texture().handle, 0);
        } else {
            // attach depth
            glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D,
-                                   depth_surface->texture.handle, 0);
+                                   depth_surface->Texture().handle, 0);
            // clear stencil attachment
            glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
        }
@@ -708,14 +748,14 @@ void RasterizerOpenGL::BindFramebufferSurfaces(const Surface& color_surface,
    }
 }
-void RasterizerOpenGL::SyncViewport(const MathUtil::Rectangle<u32>& surfaces_rect, u16 res_scale) {
+void RasterizerOpenGL::SyncViewport(const MathUtil::Rectangle<u32>& surfaces_rect) {
    const auto& regs = Core::System().GetInstance().GPU().Maxwell3D().regs;
    const MathUtil::Rectangle<s32> viewport_rect{regs.viewport_transform[0].GetRect()};
-    state.viewport.x = static_cast<GLint>(surfaces_rect.left) + viewport_rect.left * res_scale;
+    state.viewport.x = static_cast<GLint>(surfaces_rect.left) + viewport_rect.left;
-    state.viewport.y = static_cast<GLint>(surfaces_rect.bottom) + viewport_rect.bottom * res_scale;
+    state.viewport.y = static_cast<GLint>(surfaces_rect.bottom) + viewport_rect.bottom;
-    state.viewport.width = static_cast<GLsizei>(viewport_rect.GetWidth() * res_scale);
+    state.viewport.width = static_cast<GLsizei>(viewport_rect.GetWidth());
-    state.viewport.height = static_cast<GLsizei>(viewport_rect.GetHeight() * res_scale);
+    state.viewport.height = static_cast<GLsizei>(viewport_rect.GetHeight());
 }
 void RasterizerOpenGL::SyncClipEnabled() {
@@ -727,7 +767,27 @@ void RasterizerOpenGL::SyncClipCoef() {
 }
 void RasterizerOpenGL::SyncCullMode() {
-    UNREACHABLE();
+    const auto& regs = Core::System().GetInstance().GPU().Maxwell3D().regs;
+    state.cull.enabled = regs.cull.enabled != 0;
+    if (state.cull.enabled) {
+        state.cull.front_face = MaxwellToGL::FrontFace(regs.cull.front_face);
+        state.cull.mode = MaxwellToGL::CullFace(regs.cull.cull_face);
+        const bool flip_triangles{regs.screen_y_control.triangle_rast_flip == 0 ||
+                                  regs.viewport_transform[0].scale_y < 0.0f};
+        // If the GPU is configured to flip the rasterized triangles, then we need to flip the
+        // notion of front and back. Note: We flip the triangles when the value of the register is 0
+        // because OpenGL already does it for us.
+        if (flip_triangles) {
+            if (state.cull.front_face == GL_CCW)
+                state.cull.front_face = GL_CW;
+            else if (state.cull.front_face == GL_CW)
+                state.cull.front_face = GL_CCW;
+        }
+    }
 }
 void RasterizerOpenGL::SyncDepthScale() {
@@ -738,6 +798,18 @@ void RasterizerOpenGL::SyncDepthOffset() {
    UNREACHABLE();
 }
+void RasterizerOpenGL::SyncDepthTestState() {
+    const auto& regs = Core::System().GetInstance().GPU().Maxwell3D().regs;
+    state.depth.test_enabled = regs.depth_test_enable != 0;
+    state.depth.write_mask = regs.depth_write_enabled ? GL_TRUE : GL_FALSE;
+    if (!state.depth.test_enabled)
+        return;
+    state.depth.test_func = MaxwellToGL::ComparisonOp(regs.depth_test_func);
+}
 void RasterizerOpenGL::SyncBlendState() {
    const auto& regs = Core::System().GetInstance().GPU().Maxwell3D().regs;
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.h b/src/video_core/renderer_opengl/gl_rasterizer.h
index b7c8cf843..c406142e4 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.h
+++ b/src/video_core/renderer_opengl/gl_rasterizer.h
@@ -7,6 +7,7 @@
 #include <array>
 #include <cstddef>
 #include <memory>
+#include <utility>
 #include <vector>
 #include <glad/glad.h>
 #include "common/common_types.h"
@@ -28,6 +29,7 @@ public:
    ~RasterizerOpenGL() override;
    void DrawArrays() override;
+    void Clear() override;
    void NotifyMaxwellRegisterChanged(u32 method) override;
    void FlushAll() override;
    void FlushRegion(Tegra::GPUVAddr addr, u64 size) override;
@@ -54,6 +56,11 @@ public:
        OGLShader shader;
    };
+    /// Maximum supported size that a constbuffer can have in bytes.
+    static constexpr size_t MaxConstbufferSize = 0x10000;
+    static_assert(MaxConstbufferSize % sizeof(GLvec4) == 0,
+                  "The maximum size of a constbuffer must be a multiple of the size of GLvec4");
 private:
    class SamplerInfo {
    public:
@@ -76,6 +83,10 @@ private:
        u32 border_color_a;
    };
+    /// Configures the color and depth framebuffer states and returns the dirty <Color, Depth>
+    /// surfaces if writing was enabled.
+    std::pair<Surface, Surface> ConfigureFramebuffers(bool using_color_fb, bool using_depth_fb);
    /// Binds the framebuffer color and depth surface
    void BindFramebufferSurfaces(const Surface& color_surface, const Surface& depth_surface,
                                 bool has_stencil);
@@ -104,7 +115,7 @@ private:
                      u32 current_unit, const std::vector<GLShader::SamplerEntry>& entries);
    /// Syncs the viewport to match the guest state
-    void SyncViewport(const MathUtil::Rectangle<u32>& surfaces_rect, u16 res_scale);
+    void SyncViewport(const MathUtil::Rectangle<u32>& surfaces_rect);
    /// Syncs the clip enabled status to match the guest state
    void SyncClipEnabled();
@@ -121,6 +132,9 @@ private:
    /// Syncs the depth offset to match the guest state
    void SyncDepthOffset();
+    /// Syncs the depth test state to match the guest state
+    void SyncDepthTestState();
    /// Syncs the blend state to match the guest state
    void SyncBlendState();
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
index 61d670dcb..323ff7408 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
@@ -1,37 +1,23 @@
-// Copyright 2015 Citra Emulator Project
+// Copyright 2018 yuzu Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 #include <algorithm>
-#include <atomic>
-#include <cstring>
-#include <iterator>
-#include <memory>
-#include <utility>
-#include <vector>
-#include <boost/optional.hpp>
-#include <boost/range/iterator_range.hpp>
 #include <glad/glad.h>
 #include "common/alignment.h"
-#include "common/bit_field.h"
+#include "common/assert.h"
-#include "common/color.h"
-#include "common/logging/log.h"
-#include "common/math_util.h"
 #include "common/microprofile.h"
 #include "common/scope_exit.h"
 #include "core/core.h"
-#include "core/frontend/emu_window.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/vm_manager.h"
 #include "core/memory.h"
 #include "core/settings.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_opengl/gl_rasterizer_cache.h"
-#include "video_core/renderer_opengl/gl_state.h"
 #include "video_core/textures/astc.h"
 #include "video_core/textures/decoders.h"
 #include "video_core/utils.h"
-#include "video_core/video_core.h"
 using SurfaceType = SurfaceParams::SurfaceType;
 using PixelFormat = SurfaceParams::PixelFormat;
@@ -41,113 +27,178 @@ struct FormatTuple {
    GLint internal_format;
    GLenum format;
    GLenum type;
+    ComponentType component_type;
    bool compressed;
 };
+/*static*/ SurfaceParams SurfaceParams::CreateForTexture(
+    const Tegra::Texture::FullTextureInfo& config) {
+    SurfaceParams params{};
+    params.addr = config.tic.Address();
+    params.is_tiled = config.tic.IsTiled();
+    params.block_height = params.is_tiled ? config.tic.BlockHeight() : 0,
+    params.pixel_format = PixelFormatFromTextureFormat(config.tic.format);
+    params.component_type = ComponentTypeFromTexture(config.tic.r_type.Value());
+    params.type = GetFormatType(params.pixel_format);
+    params.width = Common::AlignUp(config.tic.Width(), GetCompressionFactor(params.pixel_format));
+    params.height = Common::AlignUp(config.tic.Height(), GetCompressionFactor(params.pixel_format));
+    params.unaligned_height = config.tic.Height();
+    params.size_in_bytes = params.SizeInBytes();
+    return params;
+}
+/*static*/ SurfaceParams SurfaceParams::CreateForFramebuffer(
+    const Tegra::Engines::Maxwell3D::Regs::RenderTargetConfig& config) {
+    SurfaceParams params{};
+    params.addr = config.Address();
+    params.is_tiled = true;
+    params.block_height = Tegra::Texture::TICEntry::DefaultBlockHeight;
+    params.pixel_format = PixelFormatFromRenderTargetFormat(config.format);
+    params.component_type = ComponentTypeFromRenderTarget(config.format);
+    params.type = GetFormatType(params.pixel_format);
+    params.width = config.width;
+    params.height = config.height;
+    params.unaligned_height = config.height;
+    params.size_in_bytes = params.SizeInBytes();
+    return params;
+}
+/*static*/ SurfaceParams SurfaceParams::CreateForDepthBuffer(
+    const Tegra::Engines::Maxwell3D::Regs::RenderTargetConfig& config, Tegra::GPUVAddr zeta_address,
+    Tegra::DepthFormat format) {
+    SurfaceParams params{};
+    params.addr = zeta_address;
+    params.is_tiled = true;
+    params.block_height = Tegra::Texture::TICEntry::DefaultBlockHeight;
+    params.pixel_format = PixelFormatFromDepthFormat(format);
+    params.component_type = ComponentTypeFromDepthFormat(format);
+    params.type = GetFormatType(params.pixel_format);
+    params.size_in_bytes = params.SizeInBytes();
+    params.width = config.width;
+    params.height = config.height;
+    params.unaligned_height = config.height;
+    params.size_in_bytes = params.SizeInBytes();
+    return params;
+}
 static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_format_tuples = {{
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, false},                    // ABGR8
+    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, ComponentType::UNorm, false}, // ABGR8
-    {GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, false},                           // B5G6R5
+    {GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV, ComponentType::UNorm, false},    // B5G6R5
-    {GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, false},              // A2B10G10R10
+    {GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, ComponentType::UNorm,
-    {GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, false},                // A1B5G5R5
+     false}, // A2B10G10R10
-    {GL_R8, GL_RED, GL_UNSIGNED_BYTE, false},                                   // R8
+    {GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, ComponentType::UNorm, false}, // A1B5G5R5
-    {GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT, false},                                // RGBA16F
+    {GL_R8, GL_RED, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},                    // R8
-    {GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, false},        // R11FG11FB10F
+    {GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT, ComponentType::Float, false},                 // RGBA16F
-    {GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, true},   // DXT1
+    {GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, ComponentType::Float,
-    {GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, true}, // DXT23
+     false},                                                                     // R11FG11FB10F
-    {GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, true}, // DXT45
+    {GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false}, // RGBA32UI
-    {GL_COMPRESSED_RED_RGTC1, GL_RED, GL_UNSIGNED_INT_8_8_8_8, true},           // DXN1
+    {GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, false},                               // ASTC_2D_4X4
+     true}, // DXT1
+    {GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
+     true}, // DXT23
+    {GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
+     true},                                                                                 // DXT45
+    {GL_COMPRESSED_RED_RGTC1, GL_RED, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm, true}, // DXN1
+    {GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
+     true},                                                             // BC7U
+    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_4X4
+    // DepthStencil formats
+    {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, ComponentType::UNorm,
+     false}, // Z24S8
+    {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, ComponentType::UNorm,
+     false},                                                                            // S8Z24
+    {GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT, ComponentType::Float, false}, // Z32F
 }};
 static const FormatTuple& GetFormatTuple(PixelFormat pixel_format, ComponentType component_type) {
-    const SurfaceType type = SurfaceParams::GetFormatType(pixel_format);
+    ASSERT(static_cast<size_t>(pixel_format) < tex_format_tuples.size());
-    if (type == SurfaceType::ColorTexture) {
+    auto& format = tex_format_tuples[static_cast<unsigned int>(pixel_format)];
-        ASSERT(static_cast<size_t>(pixel_format) < tex_format_tuples.size());
+    ASSERT(component_type == format.component_type);
-        // For now only UNORM components are supported, or either R11FG11FB10F or RGBA16F which are
-        // type FLOAT
-        ASSERT(component_type == ComponentType::UNorm || pixel_format == PixelFormat::RGBA16F ||
-               pixel_format == PixelFormat::R11FG11FB10F);
-        return tex_format_tuples[static_cast<unsigned int>(pixel_format)];
-    } else if (type == SurfaceType::Depth || type == SurfaceType::DepthStencil) {
-        // TODO(Subv): Implement depth formats
-        ASSERT_MSG(false, "Unimplemented");
-    }
-    UNREACHABLE();
+    return format;
-    return {};
 }
-template <typename Map, typename Interval>
+VAddr SurfaceParams::GetCpuAddr() const {
-constexpr auto RangeFromInterval(Map& map, const Interval& interval) {
+    const auto& gpu = Core::System::GetInstance().GPU();
-    return boost::make_iterator_range(map.equal_range(interval));
+    return *gpu.memory_manager->GpuToCpuAddress(addr);
 }
-static u16 GetResolutionScaleFactor() {
+static bool IsPixelFormatASTC(PixelFormat format) {
-    return static_cast<u16>(!Settings::values.resolution_factor
+    switch (format) {
-                                ? VideoCore::g_emu_window->GetFramebufferLayout().GetScalingRatio()
+    case PixelFormat::ASTC_2D_4X4:
-                                : Settings::values.resolution_factor);
+        return true;
+    default:
+        return false;
+    }
 }
-static void ConvertASTCToRGBA8(std::vector<u8>& data, PixelFormat format, u32 width, u32 height) {
+static std::pair<u32, u32> GetASTCBlockSize(PixelFormat format) {
-    u32 block_width{};
-    u32 block_height{};
    switch (format) {
    case PixelFormat::ASTC_2D_4X4:
-        block_width = 4;
+        return {4, 4};
-        block_height = 4;
-        break;
    default:
-        NGLOG_CRITICAL(HW_GPU, "Unhandled format: {}", static_cast<u32>(format));
+        LOG_CRITICAL(HW_GPU, "Unhandled format: {}", static_cast<u32>(format));
        UNREACHABLE();
    }
+}
-    data = Tegra::Texture::ASTC::Decompress(data, width, height, block_width, block_height);
+MathUtil::Rectangle<u32> SurfaceParams::GetRect() const {
+    u32 actual_height{unaligned_height};
+    if (IsPixelFormatASTC(pixel_format)) {
+        // ASTC formats must stop at the ATSC block size boundary
+        actual_height = Common::AlignDown(actual_height, GetASTCBlockSize(pixel_format).second);
+    }
+    return {0, actual_height, width, 0};
 }
 template <bool morton_to_gl, PixelFormat format>
-void MortonCopy(u32 stride, u32 block_height, u32 height, u8* gl_buffer, Tegra::GPUVAddr base,
+void MortonCopy(u32 stride, u32 block_height, u32 height, u8* gl_buffer, Tegra::GPUVAddr addr) {
-                Tegra::GPUVAddr start, Tegra::GPUVAddr end) {
    constexpr u32 bytes_per_pixel = SurfaceParams::GetFormatBpp(format) / CHAR_BIT;
    constexpr u32 gl_bytes_per_pixel = CachedSurface::GetGLBytesPerPixel(format);
    const auto& gpu = Core::System::GetInstance().GPU();
    if (morton_to_gl) {
-        auto data = Tegra::Texture::UnswizzleTexture(
+        if (SurfaceParams::GetFormatType(format) == SurfaceType::ColorTexture) {
-            *gpu.memory_manager->GpuToCpuAddress(base),
+            auto data = Tegra::Texture::UnswizzleTexture(
-            SurfaceParams::TextureFormatFromPixelFormat(format), stride, height, block_height);
+                *gpu.memory_manager->GpuToCpuAddress(addr),
+                SurfaceParams::TextureFormatFromPixelFormat(format), stride, height, block_height);
-        if (SurfaceParams::IsFormatASTC(format)) {
+            std::memcpy(gl_buffer, data.data(), data.size());
-            // ASTC formats are converted to RGBA8 in software, as most PC GPUs do not support this
+        } else {
-            ConvertASTCToRGBA8(data, format, stride, height);
+            auto data = Tegra::Texture::UnswizzleDepthTexture(
+                *gpu.memory_manager->GpuToCpuAddress(addr),
+                SurfaceParams::DepthFormatFromPixelFormat(format), stride, height, block_height);
+            std::memcpy(gl_buffer, data.data(), data.size());
        }
-        std::memcpy(gl_buffer, data.data(), data.size());
    } else {
-        // TODO(bunnei): Assumes the default rendering GOB size of 16 (128 lines). We should check
+        // TODO(bunnei): Assumes the default rendering GOB size of 16 (128 lines). We should
-        // the configuration for this and perform more generic un/swizzle
+        // check the configuration for this and perform more generic un/swizzle
-        NGLOG_WARNING(Render_OpenGL, "need to use correct swizzle/GOB parameters!");
+        LOG_WARNING(Render_OpenGL, "need to use correct swizzle/GOB parameters!");
        VideoCore::MortonCopyPixels128(
            stride, height, bytes_per_pixel, gl_bytes_per_pixel,
-            Memory::GetPointer(*gpu.memory_manager->GpuToCpuAddress(base)), gl_buffer,
+            Memory::GetPointer(*gpu.memory_manager->GpuToCpuAddress(addr)), gl_buffer,
            morton_to_gl);
    }
 }
-static constexpr std::array<void (*)(u32, u32, u32, u8*, Tegra::GPUVAddr, Tegra::GPUVAddr,
+static constexpr std::array<void (*)(u32, u32, u32, u8*, Tegra::GPUVAddr),
-                                     Tegra::GPUVAddr),
                            SurfaceParams::MaxPixelFormat>
    morton_to_gl_fns = {
        MortonCopy<true, PixelFormat::ABGR8>,        MortonCopy<true, PixelFormat::B5G6R5>,
        MortonCopy<true, PixelFormat::A2B10G10R10>,  MortonCopy<true, PixelFormat::A1B5G5R5>,
        MortonCopy<true, PixelFormat::R8>,           MortonCopy<true, PixelFormat::RGBA16F>,
-        MortonCopy<true, PixelFormat::R11FG11FB10F>, MortonCopy<true, PixelFormat::DXT1>,
+        MortonCopy<true, PixelFormat::R11FG11FB10F>, MortonCopy<true, PixelFormat::RGBA32UI>,
-        MortonCopy<true, PixelFormat::DXT23>,        MortonCopy<true, PixelFormat::DXT45>,
+        MortonCopy<true, PixelFormat::DXT1>,         MortonCopy<true, PixelFormat::DXT23>,
-        MortonCopy<true, PixelFormat::DXN1>,         MortonCopy<true, PixelFormat::ASTC_2D_4X4>,
+        MortonCopy<true, PixelFormat::DXT45>,        MortonCopy<true, PixelFormat::DXN1>,
+        MortonCopy<true, PixelFormat::BC7U>,         MortonCopy<true, PixelFormat::ASTC_2D_4X4>,
+        MortonCopy<true, PixelFormat::Z24S8>,        MortonCopy<true, PixelFormat::S8Z24>,
+        MortonCopy<true, PixelFormat::Z32F>,
 };
-static constexpr std::array<void (*)(u32, u32, u32, u8*, Tegra::GPUVAddr, Tegra::GPUVAddr,
+static constexpr std::array<void (*)(u32, u32, u32, u8*, Tegra::GPUVAddr),
-                                     Tegra::GPUVAddr),
                            SurfaceParams::MaxPixelFormat>
    gl_to_morton_fns = {
        MortonCopy<false, PixelFormat::ABGR8>,
@@ -157,12 +208,17 @@ static constexpr std::array<void (*)(u32, u32, u32, u8*, Tegra::GPUVAddr, Tegra:
        MortonCopy<false, PixelFormat::R8>,
        MortonCopy<false, PixelFormat::RGBA16F>,
        MortonCopy<false, PixelFormat::R11FG11FB10F>,
-        // TODO(Subv): Swizzling the DXT1/DXT23/DXT45/DXN1 formats is not yet supported
+        MortonCopy<false, PixelFormat::RGBA32UI>,
+        // TODO(Subv): Swizzling the DXT1/DXT23/DXT45/DXN1/BC7U formats is not yet supported
+        nullptr,
        nullptr,
        nullptr,
        nullptr,
        nullptr,
        MortonCopy<false, PixelFormat::ABGR8>,
+        MortonCopy<false, PixelFormat::Z24S8>,
+        MortonCopy<false, PixelFormat::S8Z24>,
+        MortonCopy<false, PixelFormat::Z32F>,
 };
 // Allocate an uninitialized texture of appropriate size and format for the surface
@@ -192,374 +248,144 @@ static void AllocateSurfaceTexture(GLuint texture, const FormatTuple& format_tup
    cur_state.Apply();
 }
-static bool BlitTextures(GLuint src_tex, const MathUtil::Rectangle<u32>& src_rect, GLuint dst_tex,
+CachedSurface::CachedSurface(const SurfaceParams& params) : params(params) {
-                         const MathUtil::Rectangle<u32>& dst_rect, SurfaceType type,
+    texture.Create();
-                         GLuint read_fb_handle, GLuint draw_fb_handle) {
+    const auto& rect{params.GetRect()};
+    AllocateSurfaceTexture(texture.handle,
-    glCopyImageSubData(src_tex, GL_TEXTURE_2D, 0, src_rect.left, src_rect.bottom, 0, dst_tex,
+                           GetFormatTuple(params.pixel_format, params.component_type),
-                       GL_TEXTURE_2D, 0, dst_rect.left, dst_rect.bottom, 0, src_rect.GetWidth(),
+                           rect.GetWidth(), rect.GetHeight());
-                       src_rect.GetHeight(), 0);
+}
-    return true;
-}
+static void ConvertS8Z24ToZ24S8(std::vector<u8>& data, u32 width, u32 height) {
+    union S8Z24 {
-static bool FillSurface(const Surface& surface, const u8* fill_data,
+        BitField<0, 24, u32> z24;
-                        const MathUtil::Rectangle<u32>& fill_rect, GLuint draw_fb_handle) {
+        BitField<24, 8, u32> s8;
-    UNREACHABLE();
+    };
-    return {};
+    static_assert(sizeof(S8Z24) == 4, "S8Z24 is incorrect size");
-}
+    union Z24S8 {
-SurfaceParams SurfaceParams::FromInterval(SurfaceInterval interval) const {
+        BitField<0, 8, u32> s8;
-    SurfaceParams params = *this;
+        BitField<8, 24, u32> z24;
-    const u32 tiled_size = is_tiled ? 8 : 1;
+    };
-    const u64 stride_tiled_bytes = BytesInPixels(stride * tiled_size);
+    static_assert(sizeof(Z24S8) == 4, "Z24S8 is incorrect size");
-    Tegra::GPUVAddr aligned_start =
-        addr + Common::AlignDown(boost::icl::first(interval) - addr, stride_tiled_bytes);
+    S8Z24 input_pixel{};
-    Tegra::GPUVAddr aligned_end =
+    Z24S8 output_pixel{};
-        addr + Common::AlignUp(boost::icl::last_next(interval) - addr, stride_tiled_bytes);
+    for (size_t y = 0; y < height; ++y) {
+        for (size_t x = 0; x < width; ++x) {
-    if (aligned_end - aligned_start > stride_tiled_bytes) {
+            const size_t offset{y * width + x};
-        params.addr = aligned_start;
+            std::memcpy(&input_pixel, &data[offset], sizeof(S8Z24));
-        params.height = static_cast<u32>((aligned_end - aligned_start) / BytesInPixels(stride));
+            output_pixel.s8.Assign(input_pixel.s8);
-    } else {
+            output_pixel.z24.Assign(input_pixel.z24);
-        // 1 row
+            std::memcpy(&data[offset], &output_pixel, sizeof(Z24S8));
-        ASSERT(aligned_end - aligned_start == stride_tiled_bytes);
-        const u64 tiled_alignment = BytesInPixels(is_tiled ? 8 * 8 : 1);
-        aligned_start =
-            addr + Common::AlignDown(boost::icl::first(interval) - addr, tiled_alignment);
-        aligned_end =
-            addr + Common::AlignUp(boost::icl::last_next(interval) - addr, tiled_alignment);
-        params.addr = aligned_start;
-        params.width = static_cast<u32>(PixelsInBytes(aligned_end - aligned_start) / tiled_size);
-        params.stride = params.width;
-        params.height = tiled_size;
-    }
-    params.UpdateParams();
-    return params;
-}
-SurfaceInterval SurfaceParams::GetSubRectInterval(MathUtil::Rectangle<u32> unscaled_rect) const {
-    if (unscaled_rect.GetHeight() == 0 || unscaled_rect.GetWidth() == 0) {
-        return {};
-    }
-    if (is_tiled) {
-        unscaled_rect.left = Common::AlignDown(unscaled_rect.left, 8) * 8;
-        unscaled_rect.bottom = Common::AlignDown(unscaled_rect.bottom, 8) / 8;
-        unscaled_rect.right = Common::AlignUp(unscaled_rect.right, 8) * 8;
-        unscaled_rect.top = Common::AlignUp(unscaled_rect.top, 8) / 8;
-    }
-    const u32 stride_tiled = !is_tiled ? stride : stride * 8;
-    const u32 pixel_offset =
-        stride_tiled * (!is_tiled ? unscaled_rect.bottom : (height / 8) - unscaled_rect.top) +
-        unscaled_rect.left;
-    const u32 pixels = (unscaled_rect.GetHeight() - 1) * stride_tiled + unscaled_rect.GetWidth();
-    return {addr + BytesInPixels(pixel_offset), addr + BytesInPixels(pixel_offset + pixels)};
-}
-MathUtil::Rectangle<u32> SurfaceParams::GetSubRect(const SurfaceParams& sub_surface) const {
-    const u32 begin_pixel_index = static_cast<u32>(PixelsInBytes(sub_surface.addr - addr));
-    if (is_tiled) {
-        const int x0 = (begin_pixel_index % (stride * 8)) / 8;
-        const int y0 = (begin_pixel_index / (stride * 8)) * 8;
-        // Top to bottom
-        return MathUtil::Rectangle<u32>(x0, height - y0, x0 + sub_surface.width,
-                                        height - (y0 + sub_surface.height));
-    }
-    const int x0 = begin_pixel_index % stride;
-    const int y0 = begin_pixel_index / stride;
-    // Bottom to top
-    return MathUtil::Rectangle<u32>(x0, y0 + sub_surface.height, x0 + sub_surface.width, y0);
-}
-MathUtil::Rectangle<u32> SurfaceParams::GetScaledSubRect(const SurfaceParams& sub_surface) const {
-    auto rect = GetSubRect(sub_surface);
-    rect.left = rect.left * res_scale;
-    rect.right = rect.right * res_scale;
-    rect.top = rect.top * res_scale;
-    rect.bottom = rect.bottom * res_scale;
-    return rect;
-}
-bool SurfaceParams::ExactMatch(const SurfaceParams& other_surface) const {
-    return std::tie(other_surface.addr, other_surface.width, other_surface.height,
-                    other_surface.stride, other_surface.block_height, other_surface.pixel_format,
-                    other_surface.component_type,
-                    other_surface.is_tiled) == std::tie(addr, width, height, stride, block_height,
-                                                        pixel_format, component_type, is_tiled) &&
-           pixel_format != PixelFormat::Invalid;
-}
-bool SurfaceParams::CanSubRect(const SurfaceParams& sub_surface) const {
-    return sub_surface.addr >= addr && sub_surface.end <= end &&
-           sub_surface.pixel_format == pixel_format && pixel_format != PixelFormat::Invalid &&
-           sub_surface.is_tiled == is_tiled && sub_surface.block_height == block_height &&
-           sub_surface.component_type == component_type &&
-           (sub_surface.addr - addr) % BytesInPixels(is_tiled ? 64 : 1) == 0 &&
-           (sub_surface.stride == stride || sub_surface.height <= (is_tiled ? 8u : 1u)) &&
-           GetSubRect(sub_surface).left + sub_surface.width <= stride;
-}
-bool SurfaceParams::CanExpand(const SurfaceParams& expanded_surface) const {
-    return pixel_format != PixelFormat::Invalid && pixel_format == expanded_surface.pixel_format &&
-           addr <= expanded_surface.end && expanded_surface.addr <= end &&
-           is_tiled == expanded_surface.is_tiled && block_height == expanded_surface.block_height &&
-           component_type == expanded_surface.component_type && stride == expanded_surface.stride &&
-           (std::max(expanded_surface.addr, addr) - std::min(expanded_surface.addr, addr)) %
-                   BytesInPixels(stride * (is_tiled ? 8 : 1)) ==
-               0;
-}
-bool SurfaceParams::CanTexCopy(const SurfaceParams& texcopy_params) const {
-    if (pixel_format == PixelFormat::Invalid || addr > texcopy_params.addr ||
-        end < texcopy_params.end) {
-        return false;
-    }
-    if (texcopy_params.block_height != block_height ||
-        texcopy_params.component_type != component_type)
-        return false;
-    if (texcopy_params.width != texcopy_params.stride) {
-        const u32 tile_stride = static_cast<u32>(BytesInPixels(stride * (is_tiled ? 8 : 1)));
-        return (texcopy_params.addr - addr) % BytesInPixels(is_tiled ? 64 : 1) == 0 &&
-               texcopy_params.width % BytesInPixels(is_tiled ? 64 : 1) == 0 &&
-               (texcopy_params.height == 1 || texcopy_params.stride == tile_stride) &&
-               ((texcopy_params.addr - addr) % tile_stride) + texcopy_params.width <= tile_stride;
-    }
-    return FromInterval(texcopy_params.GetInterval()).GetInterval() == texcopy_params.GetInterval();
-}
-VAddr SurfaceParams::GetCpuAddr() const {
-    // When this function is used, only cpu_addr or (GPU) addr should be set, not both
-    ASSERT(!(cpu_addr && addr));
-    const auto& gpu = Core::System::GetInstance().GPU();
-    return cpu_addr.get_value_or(*gpu.memory_manager->GpuToCpuAddress(addr));
-}
-bool CachedSurface::CanFill(const SurfaceParams& dest_surface,
-                            SurfaceInterval fill_interval) const {
-    if (type == SurfaceType::Fill && IsRegionValid(fill_interval) &&
-        boost::icl::first(fill_interval) >= addr &&
-        boost::icl::last_next(fill_interval) <= end && // dest_surface is within our fill range
-        dest_surface.FromInterval(fill_interval).GetInterval() ==
-            fill_interval) { // make sure interval is a rectangle in dest surface
-        if (fill_size * CHAR_BIT != dest_surface.GetFormatBpp()) {
-            // Check if bits repeat for our fill_size
-            const u32 dest_bytes_per_pixel = std::max(dest_surface.GetFormatBpp() / CHAR_BIT, 1u);
-            std::vector<u8> fill_test(fill_size * dest_bytes_per_pixel);
-            for (u32 i = 0; i < dest_bytes_per_pixel; ++i)
-                std::memcpy(&fill_test[i * fill_size], &fill_data[0], fill_size);
-            for (u32 i = 0; i < fill_size; ++i)
-                if (std::memcmp(&fill_test[dest_bytes_per_pixel * i], &fill_test[0],
-                                dest_bytes_per_pixel) != 0)
-                    return false;
-            if (dest_surface.GetFormatBpp() == 4 && (fill_test[0] & 0xF) != (fill_test[0] >> 4))
-                return false;
        }
-        return true;
    }
-    return false;
 }
+/**
-bool CachedSurface::CanCopy(const SurfaceParams& dest_surface,
+ * Helper function to perform software conversion (as needed) when loading a buffer from Switch
-                            SurfaceInterval copy_interval) const {
+ * memory. This is for Maxwell pixel formats that cannot be represented as-is in OpenGL or with
-    SurfaceParams subrect_params = dest_surface.FromInterval(copy_interval);
+ * typical desktop GPUs.
-    ASSERT(subrect_params.GetInterval() == copy_interval);
+ */
-    if (CanSubRect(subrect_params))
+static void ConvertFormatAsNeeded_LoadGLBuffer(std::vector<u8>& data, PixelFormat pixel_format,
-        return true;
+                                               u32 width, u32 height) {
+    switch (pixel_format) {
-    if (CanFill(dest_surface, copy_interval))
+    case PixelFormat::ASTC_2D_4X4: {
-        return true;
+        // Convert ASTC pixel formats to RGBA8, as most desktop GPUs do not support ASTC.
+        u32 block_width{};
-    return false;
+        u32 block_height{};
-}
+        std::tie(block_width, block_height) = GetASTCBlockSize(pixel_format);
+        data = Tegra::Texture::ASTC::Decompress(data, width, height, block_width, block_height);
-SurfaceInterval SurfaceParams::GetCopyableInterval(const Surface& src_surface) const {
+        break;
-    SurfaceInterval result{};
+    }
-    const auto valid_regions =
+    case PixelFormat::S8Z24:
-        SurfaceRegions(GetInterval() & src_surface->GetInterval()) - src_surface->invalid_regions;
+        // Convert the S8Z24 depth format to Z24S8, as OpenGL does not support S8Z24.
-    for (auto& valid_interval : valid_regions) {
+        ConvertS8Z24ToZ24S8(data, width, height);
-        const SurfaceInterval aligned_interval{
+        break;
-            addr + Common::AlignUp(boost::icl::first(valid_interval) - addr,
-                                   BytesInPixels(is_tiled ? 8 * 8 : 1)),
-            addr + Common::AlignDown(boost::icl::last_next(valid_interval) - addr,
-                                     BytesInPixels(is_tiled ? 8 * 8 : 1))};
-        if (BytesInPixels(is_tiled ? 8 * 8 : 1) > boost::icl::length(valid_interval) ||
-            boost::icl::length(aligned_interval) == 0) {
-            continue;
-        }
-        // Get the rectangle within aligned_interval
-        const u32 stride_bytes = static_cast<u32>(BytesInPixels(stride)) * (is_tiled ? 8 : 1);
-        SurfaceInterval rect_interval{
-            addr + Common::AlignUp(boost::icl::first(aligned_interval) - addr, stride_bytes),
-            addr + Common::AlignDown(boost::icl::last_next(aligned_interval) - addr, stride_bytes),
-        };
-        if (boost::icl::first(rect_interval) > boost::icl::last_next(rect_interval)) {
-            // 1 row
-            rect_interval = aligned_interval;
-        } else if (boost::icl::length(rect_interval) == 0) {
-            // 2 rows that do not make a rectangle, return the larger one
-            const SurfaceInterval row1{boost::icl::first(aligned_interval),
-                                       boost::icl::first(rect_interval)};
-            const SurfaceInterval row2{boost::icl::first(rect_interval),
-                                       boost::icl::last_next(aligned_interval)};
-            rect_interval = (boost::icl::length(row1) > boost::icl::length(row2)) ? row1 : row2;
-        }
-        if (boost::icl::length(rect_interval) > boost::icl::length(result)) {
-            result = rect_interval;
-        }
    }
-    return result;
 }
-void RasterizerCacheOpenGL::CopySurface(const Surface& src_surface, const Surface& dst_surface,
+/**
-                                        SurfaceInterval copy_interval) {
+ * Helper function to perform software conversion (as needed) when flushing a buffer to Switch
-    SurfaceParams subrect_params = dst_surface->FromInterval(copy_interval);
+ * memory. This is for Maxwell pixel formats that cannot be represented as-is in OpenGL or with
-    ASSERT(subrect_params.GetInterval() == copy_interval);
+ * typical desktop GPUs.
+ */
-    ASSERT(src_surface != dst_surface);
+static void ConvertFormatAsNeeded_FlushGLBuffer(std::vector<u8>& /*data*/, PixelFormat pixel_format,
+                                                u32 /*width*/, u32 /*height*/) {
-    // This is only called when CanCopy is true, no need to run checks here
+    switch (pixel_format) {
-    if (src_surface->type == SurfaceType::Fill) {
+    case PixelFormat::ASTC_2D_4X4:
-        // FillSurface needs a 4 bytes buffer
+    case PixelFormat::S8Z24:
-        const u64 fill_offset =
+        LOG_CRITICAL(Render_OpenGL, "Unimplemented pixel_format={}",
-            (boost::icl::first(copy_interval) - src_surface->addr) % src_surface->fill_size;
+                     static_cast<u32>(pixel_format));
-        std::array<u8, 4> fill_buffer;
+        UNREACHABLE();
+        break;
-        u64 fill_buff_pos = fill_offset;
-        for (int i : {0, 1, 2, 3})
-            fill_buffer[i] = src_surface->fill_data[fill_buff_pos++ % src_surface->fill_size];
-        FillSurface(dst_surface, &fill_buffer[0], dst_surface->GetScaledSubRect(subrect_params),
-                    draw_framebuffer.handle);
-        return;
-    }
-    if (src_surface->CanSubRect(subrect_params)) {
-        BlitTextures(src_surface->texture.handle, src_surface->GetScaledSubRect(subrect_params),
-                     dst_surface->texture.handle, dst_surface->GetScaledSubRect(subrect_params),
-                     src_surface->type, read_framebuffer.handle, draw_framebuffer.handle);
-        return;
    }
-    UNREACHABLE();
 }
 MICROPROFILE_DEFINE(OpenGL_SurfaceLoad, "OpenGL", "Surface Load", MP_RGB(128, 64, 192));
-void CachedSurface::LoadGLBuffer(Tegra::GPUVAddr load_start, Tegra::GPUVAddr load_end) {
+void CachedSurface::LoadGLBuffer() {
-    ASSERT(type != SurfaceType::Fill);
+    ASSERT(params.type != SurfaceType::Fill);
-    u8* const texture_src_data = Memory::GetPointer(GetCpuAddr());
+    u8* const texture_src_data = Memory::GetPointer(params.GetCpuAddr());
-    if (texture_src_data == nullptr)
-        return;
-    if (gl_buffer == nullptr) {
+    ASSERT(texture_src_data);
-        gl_buffer_size = GetActualWidth() * GetActualHeight() * GetGLBytesPerPixel(pixel_format);
-        gl_buffer.reset(new u8[gl_buffer_size]);
-    }
-    MICROPROFILE_SCOPE(OpenGL_SurfaceLoad);
+    gl_buffer.resize(params.width * params.height * GetGLBytesPerPixel(params.pixel_format));
-    ASSERT(load_start >= addr && load_end <= end);
+    MICROPROFILE_SCOPE(OpenGL_SurfaceLoad);
-    const u64 start_offset = load_start - addr;
-    if (!is_tiled) {
+    if (!params.is_tiled) {
-        const u32 bytes_per_pixel{GetFormatBpp() >> 3};
+        const u32 bytes_per_pixel{params.GetFormatBpp() >> 3};
-        std::memcpy(&gl_buffer[start_offset], texture_src_data + start_offset,
+        std::memcpy(gl_buffer.data(), texture_src_data,
-                    bytes_per_pixel * width * height);
+                    bytes_per_pixel * params.width * params.height);
    } else {
-        morton_to_gl_fns[static_cast<size_t>(pixel_format)](GetActualWidth(), block_height,
+        morton_to_gl_fns[static_cast<size_t>(params.pixel_format)](
-                                                            GetActualHeight(), &gl_buffer[0], addr,
+            params.width, params.block_height, params.height, gl_buffer.data(), params.addr);
-                                                            load_start, load_end);
    }
+    ConvertFormatAsNeeded_LoadGLBuffer(gl_buffer, params.pixel_format, params.width, params.height);
 }
 MICROPROFILE_DEFINE(OpenGL_SurfaceFlush, "OpenGL", "Surface Flush", MP_RGB(128, 192, 64));
-void CachedSurface::FlushGLBuffer(Tegra::GPUVAddr flush_start, Tegra::GPUVAddr flush_end) {
+void CachedSurface::FlushGLBuffer() {
-    u8* const dst_buffer = Memory::GetPointer(GetCpuAddr());
+    u8* const dst_buffer = Memory::GetPointer(params.GetCpuAddr());
-    if (dst_buffer == nullptr)
-        return;
-    ASSERT(gl_buffer_size == width * height * GetGLBytesPerPixel(pixel_format));
-    // TODO: Should probably be done in ::Memory:: and check for other regions too
+    ASSERT(dst_buffer);
-    // same as loadglbuffer()
+    ASSERT(gl_buffer.size() ==
-    if (flush_start < Memory::VRAM_VADDR_END && flush_end > Memory::VRAM_VADDR_END)
+           params.width * params.height * GetGLBytesPerPixel(params.pixel_format));
-        flush_end = Memory::VRAM_VADDR_END;
-    if (flush_start < Memory::VRAM_VADDR && flush_end > Memory::VRAM_VADDR)
-        flush_start = Memory::VRAM_VADDR;
    MICROPROFILE_SCOPE(OpenGL_SurfaceFlush);
-    ASSERT(flush_start >= addr && flush_end <= end);
+    ConvertFormatAsNeeded_FlushGLBuffer(gl_buffer, params.pixel_format, params.width,
-    const u64 start_offset = flush_start - addr;
+                                        params.height);
-    const u64 end_offset = flush_end - addr;
-    if (type == SurfaceType::Fill) {
-        const u64 coarse_start_offset = start_offset - (start_offset % fill_size);
-        const u64 backup_bytes = start_offset % fill_size;
-        std::array<u8, 4> backup_data;
-        if (backup_bytes)
-            std::memcpy(&backup_data[0], &dst_buffer[coarse_start_offset], backup_bytes);
-        for (u64 offset = coarse_start_offset; offset < end_offset; offset += fill_size) {
+    if (!params.is_tiled) {
-            std::memcpy(&dst_buffer[offset], &fill_data[0],
+        std::memcpy(dst_buffer, gl_buffer.data(), params.size_in_bytes);
-                        std::min(fill_size, end_offset - offset));
-        }
-        if (backup_bytes)
-            std::memcpy(&dst_buffer[coarse_start_offset], &backup_data[0], backup_bytes);
-    } else if (!is_tiled) {
-        std::memcpy(dst_buffer + start_offset, &gl_buffer[start_offset], flush_end - flush_start);
    } else {
-        gl_to_morton_fns[static_cast<size_t>(pixel_format)](
+        gl_to_morton_fns[static_cast<size_t>(params.pixel_format)](
-            stride, block_height, height, &gl_buffer[0], addr, flush_start, flush_end);
+            params.width, params.block_height, params.height, gl_buffer.data(), params.addr);
    }
 }
 MICROPROFILE_DEFINE(OpenGL_TextureUL, "OpenGL", "Texture Upload", MP_RGB(128, 64, 192));
-void CachedSurface::UploadGLTexture(const MathUtil::Rectangle<u32>& rect, GLuint read_fb_handle,
+void CachedSurface::UploadGLTexture(GLuint read_fb_handle, GLuint draw_fb_handle) {
-                                    GLuint draw_fb_handle) {
+    if (params.type == SurfaceType::Fill)
-    if (type == SurfaceType::Fill)
        return;
    MICROPROFILE_SCOPE(OpenGL_TextureUL);
-    ASSERT(gl_buffer_size ==
+    ASSERT(gl_buffer.size() ==
-           GetActualWidth() * GetActualHeight() * GetGLBytesPerPixel(pixel_format));
+           params.width * params.height * GetGLBytesPerPixel(params.pixel_format));
+    const auto& rect{params.GetRect()};
    // Load data from memory to the surface
    GLint x0 = static_cast<GLint>(rect.left);
    GLint y0 = static_cast<GLint>(rect.bottom);
-    size_t buffer_offset = (y0 * stride + x0) * GetGLBytesPerPixel(pixel_format);
+    size_t buffer_offset = (y0 * params.width + x0) * GetGLBytesPerPixel(params.pixel_format);
-    const FormatTuple& tuple = GetFormatTuple(pixel_format, component_type);
+    const FormatTuple& tuple = GetFormatTuple(params.pixel_format, params.component_type);
    GLuint target_tex = texture.handle;
-    // If not 1x scale, create 1x texture that we will blit from to replace texture subrect in
-    // surface
-    OGLTexture unscaled_tex;
-    if (res_scale != 1) {
-        x0 = 0;
-        y0 = 0;
-        unscaled_tex.Create();
-        AllocateSurfaceTexture(unscaled_tex.handle, tuple, rect.GetWidth(), rect.GetHeight());
-        target_tex = unscaled_tex.handle;
-    }
    OpenGLState cur_state = OpenGLState::GetCurState();
    GLuint old_tex = cur_state.texture_units[0].texture_2d;
@@ -567,15 +393,15 @@ void CachedSurface::UploadGLTexture(const MathUtil::Rectangle<u32>& rect, GLuint
    cur_state.Apply();
    // Ensure no bad interactions with GL_UNPACK_ALIGNMENT
-    ASSERT(stride * GetGLBytesPerPixel(pixel_format) % 4 == 0);
+    ASSERT(params.width * GetGLBytesPerPixel(params.pixel_format) % 4 == 0);
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, static_cast<GLint>(stride));
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, static_cast<GLint>(params.width));
    glActiveTexture(GL_TEXTURE0);
    if (tuple.compressed) {
-        glCompressedTexImage2D(GL_TEXTURE_2D, 0, tuple.internal_format,
+        glCompressedTexImage2D(
-                               static_cast<GLsizei>(rect.GetWidth() * GetCompresssionFactor()),
+            GL_TEXTURE_2D, 0, tuple.internal_format, static_cast<GLsizei>(params.width),
-                               static_cast<GLsizei>(rect.GetHeight() * GetCompresssionFactor()), 0,
+            static_cast<GLsizei>(params.height), 0, static_cast<GLsizei>(params.size_in_bytes),
-                               static_cast<GLsizei>(size), &gl_buffer[buffer_offset]);
+            &gl_buffer[buffer_offset]);
    } else {
        glTexSubImage2D(GL_TEXTURE_2D, 0, x0, y0, static_cast<GLsizei>(rect.GetWidth()),
                        static_cast<GLsizei>(rect.GetHeight()), tuple.format, tuple.type,
@@ -586,827 +412,250 @@ void CachedSurface::UploadGLTexture(const MathUtil::Rectangle<u32>& rect, GLuint
    cur_state.texture_units[0].texture_2d = old_tex;
    cur_state.Apply();
-    if (res_scale != 1) {
-        auto scaled_rect = rect;
-        scaled_rect.left *= res_scale;
-        scaled_rect.top *= res_scale;
-        scaled_rect.right *= res_scale;
-        scaled_rect.bottom *= res_scale;
-        BlitTextures(unscaled_tex.handle, {0, rect.GetHeight(), rect.GetWidth(), 0}, texture.handle,
-                     scaled_rect, type, read_fb_handle, draw_fb_handle);
-    }
 }
 MICROPROFILE_DEFINE(OpenGL_TextureDL, "OpenGL", "Texture Download", MP_RGB(128, 192, 64));
-void CachedSurface::DownloadGLTexture(const MathUtil::Rectangle<u32>& rect, GLuint read_fb_handle,
+void CachedSurface::DownloadGLTexture(GLuint read_fb_handle, GLuint draw_fb_handle) {
-                                      GLuint draw_fb_handle) {
+    if (params.type == SurfaceType::Fill)
-    if (type == SurfaceType::Fill)
        return;
    MICROPROFILE_SCOPE(OpenGL_TextureDL);
-    if (gl_buffer == nullptr) {
+    gl_buffer.resize(params.width * params.height * GetGLBytesPerPixel(params.pixel_format));
-        gl_buffer_size = width * height * GetGLBytesPerPixel(pixel_format);
-        gl_buffer.reset(new u8[gl_buffer_size]);
-    }
    OpenGLState state = OpenGLState::GetCurState();
    OpenGLState prev_state = state;
    SCOPE_EXIT({ prev_state.Apply(); });
-    const FormatTuple& tuple = GetFormatTuple(pixel_format, component_type);
+    const FormatTuple& tuple = GetFormatTuple(params.pixel_format, params.component_type);
    // Ensure no bad interactions with GL_PACK_ALIGNMENT
-    ASSERT(stride * GetGLBytesPerPixel(pixel_format) % 4 == 0);
+    ASSERT(params.width * GetGLBytesPerPixel(params.pixel_format) % 4 == 0);
-    glPixelStorei(GL_PACK_ROW_LENGTH, static_cast<GLint>(stride));
+    glPixelStorei(GL_PACK_ROW_LENGTH, static_cast<GLint>(params.width));
-    size_t buffer_offset = (rect.bottom * stride + rect.left) * GetGLBytesPerPixel(pixel_format);
-    // If not 1x scale, blit scaled texture to a new 1x texture and use that to flush
-    if (res_scale != 1) {
-        auto scaled_rect = rect;
-        scaled_rect.left *= res_scale;
-        scaled_rect.top *= res_scale;
-        scaled_rect.right *= res_scale;
-        scaled_rect.bottom *= res_scale;
-        OGLTexture unscaled_tex;
-        unscaled_tex.Create();
-        MathUtil::Rectangle<u32> unscaled_tex_rect{0, rect.GetHeight(), rect.GetWidth(), 0};
-        AllocateSurfaceTexture(unscaled_tex.handle, tuple, rect.GetWidth(), rect.GetHeight());
-        BlitTextures(texture.handle, scaled_rect, unscaled_tex.handle, unscaled_tex_rect, type,
-                     read_fb_handle, draw_fb_handle);
-        state.texture_units[0].texture_2d = unscaled_tex.handle;
-        state.Apply();
-        glActiveTexture(GL_TEXTURE0);
-        glGetTexImage(GL_TEXTURE_2D, 0, tuple.format, tuple.type, &gl_buffer[buffer_offset]);
-    } else {
-        state.ResetTexture(texture.handle);
-        state.draw.read_framebuffer = read_fb_handle;
-        state.Apply();
-        if (type == SurfaceType::ColorTexture) {
-            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
-                                   texture.handle, 0);
-            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
-                                   0, 0);
-        } else if (type == SurfaceType::Depth) {
-            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
-            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D,
-                                   texture.handle, 0);
-            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
-        } else {
-            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
-            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
-                                   texture.handle, 0);
-        }
-        glReadPixels(static_cast<GLint>(rect.left), static_cast<GLint>(rect.bottom),
-                     static_cast<GLsizei>(rect.GetWidth()), static_cast<GLsizei>(rect.GetHeight()),
-                     tuple.format, tuple.type, &gl_buffer[buffer_offset]);
-    }
-    glPixelStorei(GL_PACK_ROW_LENGTH, 0);
-}
-enum class MatchFlags {
+    const auto& rect{params.GetRect()};
-    None = 0,
+    size_t buffer_offset =
-    Invalid = 1,      // Flag that can be applied to other match types, invalid matches require
+        (rect.bottom * params.width + rect.left) * GetGLBytesPerPixel(params.pixel_format);
-                      // validation before they can be used
-    Exact = 1 << 1,   // Surfaces perfectly match
-    SubRect = 1 << 2, // Surface encompasses params
-    Copy = 1 << 3,    // Surface we can copy from
-    Expand = 1 << 4,  // Surface that can expand params
-    TexCopy = 1 << 5  // Surface that will match a display transfer "texture copy" parameters
-};
-constexpr MatchFlags operator|(MatchFlags lhs, MatchFlags rhs) {
-    return static_cast<MatchFlags>(static_cast<int>(lhs) | static_cast<int>(rhs));
-}
-constexpr MatchFlags operator&(MatchFlags lhs, MatchFlags rhs) {
+    state.UnbindTexture(texture.handle);
-    return static_cast<MatchFlags>(static_cast<int>(lhs) & static_cast<int>(rhs));
+    state.draw.read_framebuffer = read_fb_handle;
-}
+    state.Apply();
-/// Get the best surface match (and its match type) for the given flags
+    if (params.type == SurfaceType::ColorTexture) {
-template <MatchFlags find_flags>
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
-Surface FindMatch(const SurfaceCache& surface_cache, const SurfaceParams& params,
+                               texture.handle, 0);
-                  ScaleMatch match_scale_type,
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0,
-                  boost::optional<SurfaceInterval> validate_interval = boost::none) {
+                               0);
-    Surface match_surface = nullptr;
+    } else if (params.type == SurfaceType::Depth) {
-    bool match_valid = false;
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
-    u32 match_scale = 0;
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D,
-    SurfaceInterval match_interval{};
+                               texture.handle, 0);
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
-    for (auto& pair : RangeFromInterval(surface_cache, params.GetInterval())) {
+    } else {
-        for (auto& surface : pair.second) {
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
-            bool res_scale_matched = match_scale_type == ScaleMatch::Exact
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
-                                         ? (params.res_scale == surface->res_scale)
+                               texture.handle, 0);
-                                         : (params.res_scale <= surface->res_scale);
-            // validity will be checked in GetCopyableInterval
-            bool is_valid =
-                (find_flags & MatchFlags::Copy) != MatchFlags::None
-                    ? true
-                    : surface->IsRegionValid(validate_interval.value_or(params.GetInterval()));
-            if ((find_flags & MatchFlags::Invalid) == MatchFlags::None && !is_valid)
-                continue;
-            auto IsMatch_Helper = [&](auto check_type, auto match_fn) {
-                if ((find_flags & check_type) == MatchFlags::None)
-                    return;
-                bool matched;
-                SurfaceInterval surface_interval;
-                std::tie(matched, surface_interval) = match_fn();
-                if (!matched)
-                    return;
-                if (!res_scale_matched && match_scale_type != ScaleMatch::Ignore &&
-                    surface->type != SurfaceType::Fill)
-                    return;
-                // Found a match, update only if this is better than the previous one
-                auto UpdateMatch = [&] {
-                    match_surface = surface;
-                    match_valid = is_valid;
-                    match_scale = surface->res_scale;
-                    match_interval = surface_interval;
-                };
-                if (surface->res_scale > match_scale) {
-                    UpdateMatch();
-                    return;
-                } else if (surface->res_scale < match_scale) {
-                    return;
-                }
-                if (is_valid && !match_valid) {
-                    UpdateMatch();
-                    return;
-                } else if (is_valid != match_valid) {
-                    return;
-                }
-                if (boost::icl::length(surface_interval) > boost::icl::length(match_interval)) {
-                    UpdateMatch();
-                }
-            };
-            IsMatch_Helper(std::integral_constant<MatchFlags, MatchFlags::Exact>{}, [&] {
-                return std::make_pair(surface->ExactMatch(params), surface->GetInterval());
-            });
-            IsMatch_Helper(std::integral_constant<MatchFlags, MatchFlags::SubRect>{}, [&] {
-                return std::make_pair(surface->CanSubRect(params), surface->GetInterval());
-            });
-            IsMatch_Helper(std::integral_constant<MatchFlags, MatchFlags::Copy>{}, [&] {
-                auto copy_interval =
-                    params.FromInterval(*validate_interval).GetCopyableInterval(surface);
-                bool matched = boost::icl::length(copy_interval & *validate_interval) != 0 &&
-                               surface->CanCopy(params, copy_interval);
-                return std::make_pair(matched, copy_interval);
-            });
-            IsMatch_Helper(std::integral_constant<MatchFlags, MatchFlags::Expand>{}, [&] {
-                return std::make_pair(surface->CanExpand(params), surface->GetInterval());
-            });
-            IsMatch_Helper(std::integral_constant<MatchFlags, MatchFlags::TexCopy>{}, [&] {
-                return std::make_pair(surface->CanTexCopy(params), surface->GetInterval());
-            });
-        }
    }
-    return match_surface;
+    glReadPixels(static_cast<GLint>(rect.left), static_cast<GLint>(rect.bottom),
+                 static_cast<GLsizei>(rect.GetWidth()), static_cast<GLsizei>(rect.GetHeight()),
+                 tuple.format, tuple.type, &gl_buffer[buffer_offset]);
+    glPixelStorei(GL_PACK_ROW_LENGTH, 0);
 }
 RasterizerCacheOpenGL::RasterizerCacheOpenGL() {
    read_framebuffer.Create();
    draw_framebuffer.Create();
-    attributeless_vao.Create();
-    d24s8_abgr_buffer.Create();
-    d24s8_abgr_buffer_size = 0;
-    const char* vs_source = R"(
-#version 330 core
-const vec2 vertices[4] = vec2[4](vec2(-1.0, -1.0), vec2(1.0, -1.0), vec2(-1.0, 1.0), vec2(1.0, 1.0));
-void main() {
-    gl_Position = vec4(vertices[gl_VertexID], 0.0, 1.0);
-}
-)";
-    const char* fs_source = R"(
-#version 330 core
-uniform samplerBuffer tbo;
-uniform vec2 tbo_size;
-uniform vec4 viewport;
-out vec4 color;
-void main() {
-    vec2 tbo_coord = (gl_FragCoord.xy - viewport.xy) * tbo_size / viewport.zw;
-    int tbo_offset = int(tbo_coord.y) * int(tbo_size.x) + int(tbo_coord.x);
-    color = texelFetch(tbo, tbo_offset).rabg;
-}
-)";
-    d24s8_abgr_shader.CreateFromSource(vs_source, nullptr, fs_source);
-    OpenGLState state = OpenGLState::GetCurState();
-    GLuint old_program = state.draw.shader_program;
-    state.draw.shader_program = d24s8_abgr_shader.handle;
-    state.Apply();
-    GLint tbo_u_id = glGetUniformLocation(d24s8_abgr_shader.handle, "tbo");
-    ASSERT(tbo_u_id != -1);
-    glUniform1i(tbo_u_id, 0);
-    state.draw.shader_program = old_program;
-    state.Apply();
-    d24s8_abgr_tbo_size_u_id = glGetUniformLocation(d24s8_abgr_shader.handle, "tbo_size");
-    ASSERT(d24s8_abgr_tbo_size_u_id != -1);
-    d24s8_abgr_viewport_u_id = glGetUniformLocation(d24s8_abgr_shader.handle, "viewport");
-    ASSERT(d24s8_abgr_viewport_u_id != -1);
 }
 RasterizerCacheOpenGL::~RasterizerCacheOpenGL() {
-    FlushAll();
+    while (!surface_cache.empty()) {
-    while (!surface_cache.empty())
+        UnregisterSurface(surface_cache.begin()->second);
-        UnregisterSurface(*surface_cache.begin()->second.begin());
-}
-bool RasterizerCacheOpenGL::BlitSurfaces(const Surface& src_surface,
-                                         const MathUtil::Rectangle<u32>& src_rect,
-                                         const Surface& dst_surface,
-                                         const MathUtil::Rectangle<u32>& dst_rect) {
-    if (!SurfaceParams::CheckFormatsBlittable(src_surface->pixel_format, dst_surface->pixel_format))
-        return false;
-    return BlitTextures(src_surface->texture.handle, src_rect, dst_surface->texture.handle,
-                        dst_rect, src_surface->type, read_framebuffer.handle,
-                        draw_framebuffer.handle);
-}
-void RasterizerCacheOpenGL::ConvertD24S8toABGR(GLuint src_tex,
-                                               const MathUtil::Rectangle<u32>& src_rect,
-                                               GLuint dst_tex,
-                                               const MathUtil::Rectangle<u32>& dst_rect) {
-    OpenGLState prev_state = OpenGLState::GetCurState();
-    SCOPE_EXIT({ prev_state.Apply(); });
-    OpenGLState state;
-    state.draw.read_framebuffer = read_framebuffer.handle;
-    state.draw.draw_framebuffer = draw_framebuffer.handle;
-    state.Apply();
-    glBindBuffer(GL_PIXEL_PACK_BUFFER, d24s8_abgr_buffer.handle);
-    GLsizeiptr target_pbo_size = src_rect.GetWidth() * src_rect.GetHeight() * 4;
-    if (target_pbo_size > d24s8_abgr_buffer_size) {
-        d24s8_abgr_buffer_size = target_pbo_size * 2;
-        glBufferData(GL_PIXEL_PACK_BUFFER, d24s8_abgr_buffer_size, nullptr, GL_STREAM_COPY);
    }
-    glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
-    glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, src_tex,
-                           0);
-    glReadPixels(static_cast<GLint>(src_rect.left), static_cast<GLint>(src_rect.bottom),
-                 static_cast<GLsizei>(src_rect.GetWidth()),
-                 static_cast<GLsizei>(src_rect.GetHeight()), GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8,
-                 0);
-    glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
-    // PBO now contains src_tex in RABG format
-    state.draw.shader_program = d24s8_abgr_shader.handle;
-    state.draw.vertex_array = attributeless_vao.handle;
-    state.viewport.x = static_cast<GLint>(dst_rect.left);
-    state.viewport.y = static_cast<GLint>(dst_rect.bottom);
-    state.viewport.width = static_cast<GLsizei>(dst_rect.GetWidth());
-    state.viewport.height = static_cast<GLsizei>(dst_rect.GetHeight());
-    state.Apply();
-    OGLTexture tbo;
-    tbo.Create();
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(GL_TEXTURE_BUFFER, tbo.handle);
-    glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA8, d24s8_abgr_buffer.handle);
-    glUniform2f(d24s8_abgr_tbo_size_u_id, static_cast<GLfloat>(src_rect.GetWidth()),
-                static_cast<GLfloat>(src_rect.GetHeight()));
-    glUniform4f(d24s8_abgr_viewport_u_id, static_cast<GLfloat>(state.viewport.x),
-                static_cast<GLfloat>(state.viewport.y), static_cast<GLfloat>(state.viewport.width),
-                static_cast<GLfloat>(state.viewport.height));
-    glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, dst_tex, 0);
-    glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
-    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-    glBindTexture(GL_TEXTURE_BUFFER, 0);
-}
-Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params, ScaleMatch match_res_scale,
-                                          bool load_if_create) {
-    if (params.addr == 0 || params.height * params.width == 0) {
-        return nullptr;
-    }
-    // Use GetSurfaceSubRect instead
-    ASSERT(params.width == params.stride);
-    // Check for an exact match in existing surfaces
-    Surface surface =
-        FindMatch<MatchFlags::Exact | MatchFlags::Invalid>(surface_cache, params, match_res_scale);
-    if (surface == nullptr) {
-        u16 target_res_scale = params.res_scale;
-        if (match_res_scale != ScaleMatch::Exact) {
-            // This surface may have a subrect of another surface with a higher res_scale, find it
-            // to adjust our params
-            SurfaceParams find_params = params;
-            Surface expandable = FindMatch<MatchFlags::Expand | MatchFlags::Invalid>(
-                surface_cache, find_params, match_res_scale);
-            if (expandable != nullptr && expandable->res_scale > target_res_scale) {
-                target_res_scale = expandable->res_scale;
-            }
-        }
-        SurfaceParams new_params = params;
-        new_params.res_scale = target_res_scale;
-        surface = CreateSurface(new_params);
-        RegisterSurface(surface);
-    }
-    if (load_if_create) {
-        ValidateSurface(surface, params.addr, params.size);
-    }
-    return surface;
-}
-boost::optional<Tegra::GPUVAddr> RasterizerCacheOpenGL::TryFindFramebufferGpuAddress(
-    VAddr cpu_addr) const {
-    // Tries to find the GPU address of a framebuffer based on the CPU address. This is because
-    // final output framebuffers are specified by CPU address, but internally our GPU cache uses GPU
-    // addresses. We iterate through all cached framebuffers, and compare their starting CPU address
-    // to the one provided. This is obviously not great, and won't work if the framebuffer overlaps
-    // surfaces.
-    std::vector<Tegra::GPUVAddr> gpu_addresses;
-    for (const auto& pair : surface_cache) {
-        for (const auto& surface : pair.second) {
-            const VAddr surface_cpu_addr = surface->GetCpuAddr();
-            if (cpu_addr >= surface_cpu_addr && cpu_addr < (surface_cpu_addr + surface->size)) {
-                ASSERT_MSG(cpu_addr == surface_cpu_addr, "overlapping surfaces are unsupported");
-                gpu_addresses.push_back(surface->addr);
-            }
-        }
-    }
-    if (gpu_addresses.empty()) {
-        return {};
-    }
-    ASSERT_MSG(gpu_addresses.size() == 1, ">1 surface is unsupported");
-    return gpu_addresses[0];
-}
-SurfaceRect_Tuple RasterizerCacheOpenGL::GetSurfaceSubRect(const SurfaceParams& params,
-                                                           ScaleMatch match_res_scale,
-                                                           bool load_if_create) {
-    if (params.addr == 0 || params.height * params.width == 0) {
-        return std::make_tuple(nullptr, MathUtil::Rectangle<u32>{});
-    }
-    // Attempt to find encompassing surface
-    Surface surface = FindMatch<MatchFlags::SubRect | MatchFlags::Invalid>(surface_cache, params,
-                                                                           match_res_scale);
-    // Check if FindMatch failed because of res scaling
-    // If that's the case create a new surface with
-    // the dimensions of the lower res_scale surface
-    // to suggest it should not be used again
-    if (surface == nullptr && match_res_scale != ScaleMatch::Ignore) {
-        surface = FindMatch<MatchFlags::SubRect | MatchFlags::Invalid>(surface_cache, params,
-                                                                       ScaleMatch::Ignore);
-        if (surface != nullptr) {
-            ASSERT(surface->res_scale < params.res_scale);
-            SurfaceParams new_params = *surface;
-            new_params.res_scale = params.res_scale;
-            surface = CreateSurface(new_params);
-            RegisterSurface(surface);
-        }
-    }
-    SurfaceParams aligned_params = params;
-    if (params.is_tiled) {
-        aligned_params.height = Common::AlignUp(params.height, 8);
-        aligned_params.width = Common::AlignUp(params.width, 8);
-        aligned_params.stride = Common::AlignUp(params.stride, 8);
-        aligned_params.UpdateParams();
-    }
-    // Check for a surface we can expand before creating a new one
-    if (surface == nullptr) {
-        surface = FindMatch<MatchFlags::Expand | MatchFlags::Invalid>(surface_cache, aligned_params,
-                                                                      match_res_scale);
-        if (surface != nullptr) {
-            aligned_params.width = aligned_params.stride;
-            aligned_params.UpdateParams();
-            SurfaceParams new_params = *surface;
-            new_params.addr = std::min(aligned_params.addr, surface->addr);
-            new_params.end = std::max(aligned_params.end, surface->end);
-            new_params.size = new_params.end - new_params.addr;
-            new_params.height = static_cast<u32>(
-                new_params.size / aligned_params.BytesInPixels(aligned_params.stride));
-            ASSERT(new_params.size % aligned_params.BytesInPixels(aligned_params.stride) == 0);
-            Surface new_surface = CreateSurface(new_params);
-            DuplicateSurface(surface, new_surface);
-            // Delete the expanded surface, this can't be done safely yet
-            // because it may still be in use
-            remove_surfaces.emplace(surface);
-            surface = new_surface;
-            RegisterSurface(new_surface);
-        }
-    }
-    // No subrect found - create and return a new surface
-    if (surface == nullptr) {
-        SurfaceParams new_params = aligned_params;
-        // Can't have gaps in a surface
-        new_params.width = aligned_params.stride;
-        new_params.UpdateParams();
-        // GetSurface will create the new surface and possibly adjust res_scale if necessary
-        surface = GetSurface(new_params, match_res_scale, load_if_create);
-    } else if (load_if_create) {
-        ValidateSurface(surface, aligned_params.addr, aligned_params.size);
-    }
-    return std::make_tuple(surface, surface->GetScaledSubRect(params));
 }
 Surface RasterizerCacheOpenGL::GetTextureSurface(const Tegra::Texture::FullTextureInfo& config) {
-    auto& gpu = Core::System::GetInstance().GPU();
+    return GetSurface(SurfaceParams::CreateForTexture(config));
-    SurfaceParams params;
-    params.addr = config.tic.Address();
-    params.is_tiled = config.tic.IsTiled();
-    params.pixel_format = SurfaceParams::PixelFormatFromTextureFormat(config.tic.format);
-    params.width = Common::AlignUp(config.tic.Width(), params.GetCompresssionFactor()) /
-                   params.GetCompresssionFactor();
-    params.height = Common::AlignUp(config.tic.Height(), params.GetCompresssionFactor()) /
-                    params.GetCompresssionFactor();
-    // TODO(Subv): Different types per component are not supported.
-    ASSERT(config.tic.r_type.Value() == config.tic.g_type.Value() &&
-           config.tic.r_type.Value() == config.tic.b_type.Value() &&
-           config.tic.r_type.Value() == config.tic.a_type.Value());
-    params.component_type = SurfaceParams::ComponentTypeFromTexture(config.tic.r_type.Value());
-    if (config.tic.IsTiled()) {
-        params.block_height = config.tic.BlockHeight();
-        // TODO(bunnei): The below align up is a hack. This is here because some compressed textures
-        // are not a multiple of their own compression factor, and so this accounts for that. This
-        // could potentially result in an extra row of 4px being decoded if a texture is not a
-        // multiple of 4.
-        params.width = Common::AlignUp(params.width, 4);
-        params.height = Common::AlignUp(params.height, 4);
-    } else {
-        // Use the texture-provided stride value if the texture isn't tiled.
-        params.stride = static_cast<u32>(params.PixelsInBytes(config.tic.Pitch()));
-    }
-    params.UpdateParams();
-    return GetSurface(params, ScaleMatch::Ignore, true);
 }
 SurfaceSurfaceRect_Tuple RasterizerCacheOpenGL::GetFramebufferSurfaces(
    bool using_color_fb, bool using_depth_fb, const MathUtil::Rectangle<s32>& viewport) {
    const auto& regs = Core::System().GetInstance().GPU().Maxwell3D().regs;
-    const auto& config = regs.rt[0];
    // TODO(bunnei): This is hard corded to use just the first render buffer
-    NGLOG_WARNING(Render_OpenGL, "hard-coded for render target 0!");
+    LOG_WARNING(Render_OpenGL, "hard-coded for render target 0!");
-    // update resolution_scale_factor and reset cache if changed
-    // TODO (bunnei): This code was ported as-is from Citra, and is technically not thread-safe. We
-    // need to fix this before making the renderer multi-threaded.
-    static u16 resolution_scale_factor = GetResolutionScaleFactor();
-    if (resolution_scale_factor != GetResolutionScaleFactor()) {
-        resolution_scale_factor = GetResolutionScaleFactor();
-        FlushAll();
-        while (!surface_cache.empty())
-            UnregisterSurface(*surface_cache.begin()->second.begin());
-    }
-    MathUtil::Rectangle<u32> viewport_clamped{
-        static_cast<u32>(std::clamp(viewport.left, 0, static_cast<s32>(config.width))),
-        static_cast<u32>(std::clamp(viewport.top, 0, static_cast<s32>(config.height))),
-        static_cast<u32>(std::clamp(viewport.right, 0, static_cast<s32>(config.width))),
-        static_cast<u32>(std::clamp(viewport.bottom, 0, static_cast<s32>(config.height)))};
    // get color and depth surfaces
-    SurfaceParams color_params;
+    SurfaceParams color_params{};
-    color_params.is_tiled = true;
+    SurfaceParams depth_params{};
-    color_params.res_scale = resolution_scale_factor;
-    color_params.width = config.width;
+    if (using_color_fb) {
-    color_params.height = config.height;
+        color_params = SurfaceParams::CreateForFramebuffer(regs.rt[0]);
-    // TODO(Subv): Can framebuffers use a different block height?
+    }
-    color_params.block_height = Tegra::Texture::TICEntry::DefaultBlockHeight;
-    SurfaceParams depth_params = color_params;
+    if (using_depth_fb) {
+        depth_params =
-    color_params.addr = config.Address();
+            SurfaceParams::CreateForDepthBuffer(regs.rt[0], regs.zeta.Address(), regs.zeta.format);
-    color_params.pixel_format = SurfaceParams::PixelFormatFromRenderTargetFormat(config.format);
-    color_params.component_type = SurfaceParams::ComponentTypeFromRenderTarget(config.format);
-    color_params.UpdateParams();
-    ASSERT_MSG(!using_depth_fb, "depth buffer is unimplemented");
-    // depth_params.addr = config.GetDepthBufferPhysicalAddress();
-    // depth_params.pixel_format = SurfaceParams::PixelFormatFromDepthFormat(config.depth_format);
-    // depth_params.UpdateParams();
-    auto color_vp_interval = color_params.GetSubRectInterval(viewport_clamped);
-    auto depth_vp_interval = depth_params.GetSubRectInterval(viewport_clamped);
-    // Make sure that framebuffers don't overlap if both color and depth are being used
-    if (using_color_fb && using_depth_fb &&
-        boost::icl::length(color_vp_interval & depth_vp_interval)) {
-        NGLOG_CRITICAL(Render_OpenGL, "Color and depth framebuffer memory regions overlap; "
-                                      "overlapping framebuffers not supported!");
-        using_depth_fb = false;
    }
    MathUtil::Rectangle<u32> color_rect{};
-    Surface color_surface = nullptr;
+    Surface color_surface;
-    if (using_color_fb)
+    if (using_color_fb) {
-        std::tie(color_surface, color_rect) =
+        color_surface = GetSurface(color_params);
-            GetSurfaceSubRect(color_params, ScaleMatch::Exact, false);
+        if (color_surface) {
+            color_rect = color_surface->GetSurfaceParams().GetRect();
+        }
+    }
    MathUtil::Rectangle<u32> depth_rect{};
-    Surface depth_surface = nullptr;
+    Surface depth_surface;
-    if (using_depth_fb)
+    if (using_depth_fb) {
-        std::tie(depth_surface, depth_rect) =
+        depth_surface = GetSurface(depth_params);
-            GetSurfaceSubRect(depth_params, ScaleMatch::Exact, false);
+        if (depth_surface) {
+            depth_rect = depth_surface->GetSurfaceParams().GetRect();
+        }
+    }
    MathUtil::Rectangle<u32> fb_rect{};
-    if (color_surface != nullptr && depth_surface != nullptr) {
+    if (color_surface && depth_surface) {
        fb_rect = color_rect;
        // Color and Depth surfaces must have the same dimensions and offsets
        if (color_rect.bottom != depth_rect.bottom || color_rect.top != depth_rect.top ||
            color_rect.left != depth_rect.left || color_rect.right != depth_rect.right) {
-            color_surface = GetSurface(color_params, ScaleMatch::Exact, false);
+            color_surface = GetSurface(color_params);
-            depth_surface = GetSurface(depth_params, ScaleMatch::Exact, false);
+            depth_surface = GetSurface(depth_params);
-            fb_rect = color_surface->GetScaledRect();
+            fb_rect = color_surface->GetSurfaceParams().GetRect();
        }
-    } else if (color_surface != nullptr) {
+    } else if (color_surface) {
        fb_rect = color_rect;
-    } else if (depth_surface != nullptr) {
+    } else if (depth_surface) {
        fb_rect = depth_rect;
    }
-    if (color_surface != nullptr) {
-        ValidateSurface(color_surface, boost::icl::first(color_vp_interval),
-                        boost::icl::length(color_vp_interval));
-    }
-    if (depth_surface != nullptr) {
-        ValidateSurface(depth_surface, boost::icl::first(depth_vp_interval),
-                        boost::icl::length(depth_vp_interval));
-    }
    return std::make_tuple(color_surface, depth_surface, fb_rect);
 }
-Surface RasterizerCacheOpenGL::GetFillSurface(const void* config) {
+void RasterizerCacheOpenGL::LoadSurface(const Surface& surface) {
-    UNREACHABLE();
+    surface->LoadGLBuffer();
-    return {};
+    surface->UploadGLTexture(read_framebuffer.handle, draw_framebuffer.handle);
 }
-SurfaceRect_Tuple RasterizerCacheOpenGL::GetTexCopySurface(const SurfaceParams& params) {
+void RasterizerCacheOpenGL::MarkSurfaceAsDirty(const Surface& surface) {
-    MathUtil::Rectangle<u32> rect{};
+    if (Settings::values.use_accurate_framebuffers) {
+        // If enabled, always flush dirty surfaces
+        surface->DownloadGLTexture(read_framebuffer.handle, draw_framebuffer.handle);
+        surface->FlushGLBuffer();
+    } else {
+        // Otherwise, don't mark surfaces that we write to as cached, because the resulting loads
+        // and flushes are very slow and do not seem to improve accuracy
+        const auto& params{surface->GetSurfaceParams()};
+        Memory::RasterizerMarkRegionCached(params.addr, params.size_in_bytes, false);
+    }
+}
-    Surface match_surface = FindMatch<MatchFlags::TexCopy | MatchFlags::Invalid>(
+Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params) {
-        surface_cache, params, ScaleMatch::Ignore);
+    if (params.addr == 0 || params.height * params.width == 0) {
+        return {};
+    }
-    if (match_surface != nullptr) {
+    const auto& gpu = Core::System::GetInstance().GPU();
-        ValidateSurface(match_surface, params.addr, params.size);
+    // Don't try to create any entries in the cache if the address of the texture is invalid.
+    if (gpu.memory_manager->GpuToCpuAddress(params.addr) == boost::none)
+        return {};
-        SurfaceParams match_subrect;
+    // Check for an exact match in existing surfaces
-        if (params.width != params.stride) {
+    const auto& surface_key{SurfaceKey::Create(params)};
-            const u32 tiled_size = match_surface->is_tiled ? 8 : 1;
+    const auto& search{surface_cache.find(surface_key)};
-            match_subrect = params;
+    Surface surface;
-            match_subrect.width =
+    if (search != surface_cache.end()) {
-                static_cast<u32>(match_surface->PixelsInBytes(params.width) / tiled_size);
+        surface = search->second;
-            match_subrect.stride =
+        if (Settings::values.use_accurate_framebuffers) {
-                static_cast<u32>(match_surface->PixelsInBytes(params.stride) / tiled_size);
+            // Reload the surface from Switch memory
-            match_subrect.height *= tiled_size;
+            LoadSurface(surface);
-        } else {
-            match_subrect = match_surface->FromInterval(params.GetInterval());
-            ASSERT(match_subrect.GetInterval() == params.GetInterval());
        }
+    } else {
-        rect = match_surface->GetScaledSubRect(match_subrect);
+        surface = std::make_shared<CachedSurface>(params);
+        RegisterSurface(surface);
+        LoadSurface(surface);
    }
-    return std::make_tuple(match_surface, rect);
+    return surface;
 }
-void RasterizerCacheOpenGL::DuplicateSurface(const Surface& src_surface,
+Surface RasterizerCacheOpenGL::TryFindFramebufferSurface(VAddr cpu_addr) const {
-                                             const Surface& dest_surface) {
+    // Tries to find the GPU address of a framebuffer based on the CPU address. This is because
-    ASSERT(dest_surface->addr <= src_surface->addr && dest_surface->end >= src_surface->end);
+    // final output framebuffers are specified by CPU address, but internally our GPU cache uses
+    // GPU addresses. We iterate through all cached framebuffers, and compare their starting CPU
-    BlitSurfaces(src_surface, src_surface->GetScaledRect(), dest_surface,
+    // address to the one provided. This is obviously not great, and won't work if the
-                 dest_surface->GetScaledSubRect(*src_surface));
+    // framebuffer overlaps surfaces.
-    dest_surface->invalid_regions -= src_surface->GetInterval();
+    std::vector<Surface> surfaces;
-    dest_surface->invalid_regions += src_surface->invalid_regions;
+    for (const auto& surface : surface_cache) {
+        const auto& params = surface.second->GetSurfaceParams();
-    SurfaceRegions regions;
+        const VAddr surface_cpu_addr = params.GetCpuAddr();
-    for (auto& pair : RangeFromInterval(dirty_regions, src_surface->GetInterval())) {
+        if (cpu_addr >= surface_cpu_addr && cpu_addr < (surface_cpu_addr + params.size_in_bytes)) {
-        if (pair.second == src_surface) {
+            ASSERT_MSG(cpu_addr == surface_cpu_addr, "overlapping surfaces are unsupported");
-            regions += pair.first;
+            surfaces.push_back(surface.second);
        }
    }
-    for (auto& interval : regions) {
-        dirty_regions.set({interval, dest_surface});
-    }
-}
-void RasterizerCacheOpenGL::ValidateSurface(const Surface& surface, Tegra::GPUVAddr addr,
+    if (surfaces.empty()) {
-                                            u64 size) {
+        return {};
-    if (size == 0)
-        return;
-    const SurfaceInterval validate_interval(addr, addr + size);
-    if (surface->type == SurfaceType::Fill) {
-        // Sanity check, fill surfaces will always be valid when used
-        ASSERT(surface->IsRegionValid(validate_interval));
-        return;
    }
-    while (true) {
+    ASSERT_MSG(surfaces.size() == 1, ">1 surface is unsupported");
-        const auto it = surface->invalid_regions.find(validate_interval);
-        if (it == surface->invalid_regions.end())
-            break;
-        const auto interval = *it & validate_interval;
-        // Look for a valid surface to copy from
-        SurfaceParams params = *surface;
-        Surface copy_surface =
-            FindMatch<MatchFlags::Copy>(surface_cache, params, ScaleMatch::Ignore, interval);
-        if (copy_surface != nullptr) {
-            SurfaceInterval copy_interval = params.GetCopyableInterval(copy_surface);
-            CopySurface(copy_surface, surface, copy_interval);
-            surface->invalid_regions.erase(copy_interval);
-            continue;
-        }
-        // Load data from Switch memory
+    return surfaces[0];
-        FlushRegion(params.addr, params.size);
-        surface->LoadGLBuffer(params.addr, params.end);
-        surface->UploadGLTexture(surface->GetSubRect(params), read_framebuffer.handle,
-                                 draw_framebuffer.handle);
-        surface->invalid_regions.erase(params.GetInterval());
-    }
 }
-void RasterizerCacheOpenGL::FlushRegion(Tegra::GPUVAddr addr, u64 size, Surface flush_surface) {
+void RasterizerCacheOpenGL::FlushRegion(Tegra::GPUVAddr /*addr*/, size_t /*size*/) {
-    if (size == 0)
+    // TODO(bunnei): This is unused in the current implementation of the rasterizer cache. We should
-        return;
+    // probably implement this in the future, but for now, the `use_accurate_framebufers` setting
+    // can be used to always flush.
-    const SurfaceInterval flush_interval(addr, addr + size);
+}
-    SurfaceRegions flushed_intervals;
-    for (auto& pair : RangeFromInterval(dirty_regions, flush_interval)) {
-        // small sizes imply that this most likely comes from the cpu, flush the entire region
-        // the point is to avoid thousands of small writes every frame if the cpu decides to access
-        // that region, anything higher than 8 you're guaranteed it comes from a service
-        const auto interval = size <= 8 ? pair.first : pair.first & flush_interval;
-        auto& surface = pair.second;
-        if (flush_surface != nullptr && surface != flush_surface)
-            continue;
-        // Sanity check, this surface is the last one that marked this region dirty
+void RasterizerCacheOpenGL::InvalidateRegion(Tegra::GPUVAddr addr, size_t size) {
-        ASSERT(surface->IsRegionValid(interval));
+    for (const auto& pair : surface_cache) {
+        const auto& surface{pair.second};
+        const auto& params{surface->GetSurfaceParams()};
-        if (surface->type != SurfaceType::Fill) {
+        if (params.IsOverlappingRegion(addr, size)) {
-            SurfaceParams params = surface->FromInterval(interval);
+            UnregisterSurface(surface);
-            surface->DownloadGLTexture(surface->GetSubRect(params), read_framebuffer.handle,
-                                       draw_framebuffer.handle);
        }
-        surface->FlushGLBuffer(boost::icl::first(interval), boost::icl::last_next(interval));
-        flushed_intervals += interval;
    }
-    // Reset dirty regions
-    dirty_regions -= flushed_intervals;
 }
-void RasterizerCacheOpenGL::FlushAll() {
+void RasterizerCacheOpenGL::RegisterSurface(const Surface& surface) {
-    FlushRegion(0, Kernel::VMManager::MAX_ADDRESS);
+    const auto& params{surface->GetSurfaceParams()};
-}
+    const auto& surface_key{SurfaceKey::Create(params)};
+    const auto& search{surface_cache.find(surface_key)};
-void RasterizerCacheOpenGL::InvalidateRegion(Tegra::GPUVAddr addr, u64 size,
+    if (search != surface_cache.end()) {
-                                             const Surface& region_owner) {
+        // Registered already
-    if (size == 0)
        return;
-    const SurfaceInterval invalid_interval(addr, addr + size);
-    if (region_owner != nullptr) {
-        ASSERT(addr >= region_owner->addr && addr + size <= region_owner->end);
-        // Surfaces can't have a gap
-        ASSERT(region_owner->width == region_owner->stride);
-        region_owner->invalid_regions.erase(invalid_interval);
-    }
-    for (auto& pair : RangeFromInterval(surface_cache, invalid_interval)) {
-        for (auto& cached_surface : pair.second) {
-            if (cached_surface == region_owner)
-                continue;
-            // If cpu is invalidating this region we want to remove it
-            // to (likely) mark the memory pages as uncached
-            if (region_owner == nullptr && size <= 8) {
-                FlushRegion(cached_surface->addr, cached_surface->size, cached_surface);
-                remove_surfaces.emplace(cached_surface);
-                continue;
-            }
-            const auto interval = cached_surface->GetInterval() & invalid_interval;
-            cached_surface->invalid_regions.insert(interval);
-            // Remove only "empty" fill surfaces to avoid destroying and recreating OGL textures
-            if (cached_surface->type == SurfaceType::Fill &&
-                cached_surface->IsSurfaceFullyInvalid()) {
-                remove_surfaces.emplace(cached_surface);
-            }
-        }
    }
-    if (region_owner != nullptr)
+    surface_cache[surface_key] = surface;
-        dirty_regions.set({invalid_interval, region_owner});
+    UpdatePagesCachedCount(params.addr, params.size_in_bytes, 1);
-    else
-        dirty_regions.erase(invalid_interval);
-    for (auto& remove_surface : remove_surfaces) {
-        if (remove_surface == region_owner) {
-            Surface expanded_surface = FindMatch<MatchFlags::SubRect | MatchFlags::Invalid>(
-                surface_cache, *region_owner, ScaleMatch::Ignore);
-            ASSERT(expanded_surface);
-            if ((region_owner->invalid_regions - expanded_surface->invalid_regions).empty()) {
-                DuplicateSurface(region_owner, expanded_surface);
-            } else {
-                continue;
-            }
-        }
-        UnregisterSurface(remove_surface);
-    }
-    remove_surfaces.clear();
 }
-Surface RasterizerCacheOpenGL::CreateSurface(const SurfaceParams& params) {
+void RasterizerCacheOpenGL::UnregisterSurface(const Surface& surface) {
-    Surface surface = std::make_shared<CachedSurface>();
+    const auto& params{surface->GetSurfaceParams()};
-    static_cast<SurfaceParams&>(*surface) = params;
+    const auto& surface_key{SurfaceKey::Create(params)};
+    const auto& search{surface_cache.find(surface_key)};
-    surface->texture.Create();
-    surface->gl_buffer_size = 0;
-    surface->invalid_regions.insert(surface->GetInterval());
-    AllocateSurfaceTexture(surface->texture.handle,
-                           GetFormatTuple(surface->pixel_format, surface->component_type),
-                           surface->GetScaledWidth(), surface->GetScaledHeight());
-    return surface;
-}
-void RasterizerCacheOpenGL::RegisterSurface(const Surface& surface) {
+    if (search == surface_cache.end()) {
-    if (surface->registered) {
+        // Unregistered already
        return;
    }
-    surface->registered = true;
-    surface_cache.add({surface->GetInterval(), SurfaceSet{surface}});
+    UpdatePagesCachedCount(params.addr, params.size_in_bytes, -1);
-    UpdatePagesCachedCount(surface->addr, surface->size, 1);
+    surface_cache.erase(search);
 }
-void RasterizerCacheOpenGL::UnregisterSurface(const Surface& surface) {
+template <typename Map, typename Interval>
-    if (!surface->registered) {
+constexpr auto RangeFromInterval(Map& map, const Interval& interval) {
-        return;
+    return boost::make_iterator_range(map.equal_range(interval));
-    }
-    surface->registered = false;
-    UpdatePagesCachedCount(surface->addr, surface->size, -1);
-    surface_cache.subtract({surface->GetInterval(), SurfaceSet{surface}});
 }
 void RasterizerCacheOpenGL::UpdatePagesCachedCount(Tegra::GPUVAddr addr, u64 size, int delta) {
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.h b/src/video_core/renderer_opengl/gl_rasterizer_cache.h
index 9da945e19..1bedae992 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.h
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.h
@@ -1,57 +1,26 @@
-// Copyright 2015 Citra Emulator Project
+// Copyright 2018 yuzu Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 #pragma once
 #include <array>
+#include <map>
 #include <memory>
-#include <set>
+#include <vector>
-#include <tuple>
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
-#endif
 #include <boost/icl/interval_map.hpp>
-#include <boost/icl/interval_set.hpp>
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-#include <boost/optional.hpp>
-#include <glad/glad.h>
-#include "common/assert.h"
-#include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "common/hash.h"
 #include "common/math_util.h"
-#include "video_core/gpu.h"
+#include "video_core/engines/maxwell_3d.h"
-#include "video_core/memory_manager.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/textures/texture.h"
-struct CachedSurface;
+class CachedSurface;
 using Surface = std::shared_ptr<CachedSurface>;
-using SurfaceSet = std::set<Surface>;
-using SurfaceRegions = boost::icl::interval_set<Tegra::GPUVAddr>;
-using SurfaceMap = boost::icl::interval_map<Tegra::GPUVAddr, Surface>;
-using SurfaceCache = boost::icl::interval_map<Tegra::GPUVAddr, SurfaceSet>;
-using SurfaceInterval = SurfaceCache::interval_type;
-static_assert(std::is_same<SurfaceRegions::interval_type, SurfaceCache::interval_type>() &&
-                  std::is_same<SurfaceMap::interval_type, SurfaceCache::interval_type>(),
-              "incorrect interval types");
-using SurfaceRect_Tuple = std::tuple<Surface, MathUtil::Rectangle<u32>>;
 using SurfaceSurfaceRect_Tuple = std::tuple<Surface, Surface, MathUtil::Rectangle<u32>>;
 using PageMap = boost::icl::interval_map<u64, int>;
-enum class ScaleMatch {
-    Exact,   // only accept same res scale
-    Upscale, // only allow higher scale than params
-    Ignore   // accept every scaled res
-};
 struct SurfaceParams {
    enum class PixelFormat {
        ABGR8 = 0,
@@ -61,13 +30,24 @@ struct SurfaceParams {
        R8 = 4,
        RGBA16F = 5,
        R11FG11FB10F = 6,
-        DXT1 = 7,
+        RGBA32UI = 7,
-        DXT23 = 8,
+        DXT1 = 8,
-        DXT45 = 9,
+        DXT23 = 9,
-        DXN1 = 10, // This is also known as BC4
+        DXT45 = 10,
-        ASTC_2D_4X4 = 11,
+        DXN1 = 11, // This is also known as BC4
+        BC7U = 12,
+        ASTC_2D_4X4 = 13,
+        MaxColorFormat,
-        Max,
+        // DepthStencil formats
+        Z24S8 = 14,
+        S8Z24 = 15,
+        Z32F = 16,
+        MaxDepthStencilFormat,
+        Max = MaxDepthStencilFormat,
        Invalid = 255,
    };
@@ -93,10 +73,10 @@ struct SurfaceParams {
    /**
     * Gets the compression factor for the specified PixelFormat. This applies to just the
     * "compressed width" and "compressed height", not the overall compression factor of a
-     * compressed image. This is used for maintaining proper surface sizes for compressed texture
+     * compressed image. This is used for maintaining proper surface sizes for compressed
-     * formats.
+     * texture formats.
     */
-    static constexpr u32 GetCompresssionFactor(PixelFormat format) {
+    static constexpr u32 GetCompressionFactor(PixelFormat format) {
        if (format == PixelFormat::Invalid)
            return 0;
@@ -108,19 +88,21 @@ struct SurfaceParams {
            1, // R8
            1, // RGBA16F
            1, // R11FG11FB10F
+            1, // RGBA32UI
            4, // DXT1
            4, // DXT23
            4, // DXT45
            4, // DXN1
-            1, // ASTC_2D_4X4
+            4, // BC7U
+            4, // ASTC_2D_4X4
+            1, // Z24S8
+            1, // S8Z24
+            1, // Z32F
        }};
        ASSERT(static_cast<size_t>(format) < compression_factor_table.size());
        return compression_factor_table[static_cast<size_t>(format)];
    }
-    u32 GetCompresssionFactor() const {
-        return GetCompresssionFactor(pixel_format);
-    }
    static constexpr u32 GetFormatBpp(PixelFormat format) {
        if (format == PixelFormat::Invalid)
@@ -134,11 +116,16 @@ struct SurfaceParams {
            8,   // R8
            64,  // RGBA16F
            32,  // R11FG11FB10F
+            128, // RGBA32UI
            64,  // DXT1
            128, // DXT23
            128, // DXT45
            64,  // DXN1
+            128, // BC7U
            32,  // ASTC_2D_4X4
+            32,  // Z24S8
+            32,  // S8Z24
+            32,  // Z32F
        }};
        ASSERT(static_cast<size_t>(format) < bpp_table.size());
@@ -148,6 +135,20 @@ struct SurfaceParams {
        return GetFormatBpp(pixel_format);
    }
+    static PixelFormat PixelFormatFromDepthFormat(Tegra::DepthFormat format) {
+        switch (format) {
+        case Tegra::DepthFormat::S8_Z24_UNORM:
+            return PixelFormat::S8Z24;
+        case Tegra::DepthFormat::Z24_S8_UNORM:
+            return PixelFormat::Z24S8;
+        case Tegra::DepthFormat::Z32_FLOAT:
+            return PixelFormat::Z32F;
+        default:
+            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
+            UNREACHABLE();
+        }
+    }
    static PixelFormat PixelFormatFromRenderTargetFormat(Tegra::RenderTargetFormat format) {
        switch (format) {
        case Tegra::RenderTargetFormat::RGBA8_UNORM:
@@ -159,27 +160,10 @@ struct SurfaceParams {
            return PixelFormat::RGBA16F;
        case Tegra::RenderTargetFormat::R11G11B10_FLOAT:
            return PixelFormat::R11FG11FB10F;
+        case Tegra::RenderTargetFormat::RGBA32_UINT:
+            return PixelFormat::RGBA32UI;
        default:
-            NGLOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
+            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
-            UNREACHABLE();
-        }
-    }
-    static bool IsFormatASTC(PixelFormat format) {
-        switch (format) {
-        case PixelFormat::ASTC_2D_4X4:
-            return true;
-        default:
-            return false;
-        }
-    }
-    static PixelFormat PixelFormatFromGPUPixelFormat(Tegra::FramebufferConfig::PixelFormat format) {
-        switch (format) {
-        case Tegra::FramebufferConfig::PixelFormat::ABGR8:
-            return PixelFormat::ABGR8;
-        default:
-            NGLOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
            UNREACHABLE();
        }
    }
@@ -201,6 +185,8 @@ struct SurfaceParams {
            return PixelFormat::RGBA16F;
        case Tegra::Texture::TextureFormat::BF10GF11RF11:
            return PixelFormat::R11FG11FB10F;
+        case Tegra::Texture::TextureFormat::R32_G32_B32_A32:
+            return PixelFormat::RGBA32UI;
        case Tegra::Texture::TextureFormat::DXT1:
            return PixelFormat::DXT1;
        case Tegra::Texture::TextureFormat::DXT23:
@@ -209,10 +195,12 @@ struct SurfaceParams {
            return PixelFormat::DXT45;
        case Tegra::Texture::TextureFormat::DXN1:
            return PixelFormat::DXN1;
+        case Tegra::Texture::TextureFormat::BC7U:
+            return PixelFormat::BC7U;
        case Tegra::Texture::TextureFormat::ASTC_2D_4X4:
            return PixelFormat::ASTC_2D_4X4;
        default:
-            NGLOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
+            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
            UNREACHABLE();
        }
    }
@@ -234,6 +222,8 @@ struct SurfaceParams {
            return Tegra::Texture::TextureFormat::R16_G16_B16_A16;
        case PixelFormat::R11FG11FB10F:
            return Tegra::Texture::TextureFormat::BF10GF11RF11;
+        case PixelFormat::RGBA32UI:
+            return Tegra::Texture::TextureFormat::R32_G32_B32_A32;
        case PixelFormat::DXT1:
            return Tegra::Texture::TextureFormat::DXT1;
        case PixelFormat::DXT23:
@@ -242,6 +232,8 @@ struct SurfaceParams {
            return Tegra::Texture::TextureFormat::DXT45;
        case PixelFormat::DXN1:
            return Tegra::Texture::TextureFormat::DXN1;
+        case PixelFormat::BC7U:
+            return Tegra::Texture::TextureFormat::BC7U;
        case PixelFormat::ASTC_2D_4X4:
            return Tegra::Texture::TextureFormat::ASTC_2D_4X4;
        default:
@@ -249,13 +241,26 @@ struct SurfaceParams {
        }
    }
+    static Tegra::DepthFormat DepthFormatFromPixelFormat(PixelFormat format) {
+        switch (format) {
+        case PixelFormat::S8Z24:
+            return Tegra::DepthFormat::S8_Z24_UNORM;
+        case PixelFormat::Z24S8:
+            return Tegra::DepthFormat::Z24_S8_UNORM;
+        case PixelFormat::Z32F:
+            return Tegra::DepthFormat::Z32_FLOAT;
+        default:
+            UNREACHABLE();
+        }
+    }
    static ComponentType ComponentTypeFromTexture(Tegra::Texture::ComponentType type) {
        // TODO(Subv): Implement more component types
        switch (type) {
        case Tegra::Texture::ComponentType::UNORM:
            return ComponentType::UNorm;
        default:
-            NGLOG_CRITICAL(HW_GPU, "Unimplemented component type={}", static_cast<u32>(type));
+            LOG_CRITICAL(HW_GPU, "Unimplemented component type={}", static_cast<u32>(type));
            UNREACHABLE();
        }
    }
@@ -270,215 +275,153 @@ struct SurfaceParams {
        case Tegra::RenderTargetFormat::RGBA16_FLOAT:
        case Tegra::RenderTargetFormat::R11G11B10_FLOAT:
            return ComponentType::Float;
+        case Tegra::RenderTargetFormat::RGBA32_UINT:
+            return ComponentType::UInt;
        default:
-            NGLOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
+            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
            UNREACHABLE();
        }
    }
-    static ComponentType ComponentTypeFromGPUPixelFormat(
+    static PixelFormat PixelFormatFromGPUPixelFormat(Tegra::FramebufferConfig::PixelFormat format) {
-        Tegra::FramebufferConfig::PixelFormat format) {
        switch (format) {
        case Tegra::FramebufferConfig::PixelFormat::ABGR8:
-            return ComponentType::UNorm;
+            return PixelFormat::ABGR8;
        default:
-            NGLOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
+            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
            UNREACHABLE();
        }
    }
-    static bool CheckFormatsBlittable(PixelFormat pixel_format_a, PixelFormat pixel_format_b) {
+    static ComponentType ComponentTypeFromDepthFormat(Tegra::DepthFormat format) {
-        SurfaceType a_type = GetFormatType(pixel_format_a);
+        switch (format) {
-        SurfaceType b_type = GetFormatType(pixel_format_b);
+        case Tegra::DepthFormat::S8_Z24_UNORM:
+        case Tegra::DepthFormat::Z24_S8_UNORM:
-        if (a_type == SurfaceType::ColorTexture && b_type == SurfaceType::ColorTexture) {
+            return ComponentType::UNorm;
-            return true;
+        case Tegra::DepthFormat::Z32_FLOAT:
-        }
+            return ComponentType::Float;
+        default:
-        if (a_type == SurfaceType::Depth && b_type == SurfaceType::Depth) {
+            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
-            return true;
+            UNREACHABLE();
-        }
-        if (a_type == SurfaceType::DepthStencil && b_type == SurfaceType::DepthStencil) {
-            return true;
        }
-        return false;
    }
    static SurfaceType GetFormatType(PixelFormat pixel_format) {
-        if (static_cast<size_t>(pixel_format) < MaxPixelFormat) {
+        if (static_cast<size_t>(pixel_format) < static_cast<size_t>(PixelFormat::MaxColorFormat)) {
            return SurfaceType::ColorTexture;
        }
+        if (static_cast<size_t>(pixel_format) <
+            static_cast<size_t>(PixelFormat::MaxDepthStencilFormat)) {
+            return SurfaceType::DepthStencil;
+        }
        // TODO(Subv): Implement the other formats
        ASSERT(false);
        return SurfaceType::Invalid;
    }
-    /// Update the params "size", "end" and "type" from the already set "addr", "width", "height"
+    /// Returns the rectangle corresponding to this surface
-    /// and "pixel_format"
+    MathUtil::Rectangle<u32> GetRect() const;
-    void UpdateParams() {
-        if (stride == 0) {
-            stride = width;
-        }
-        type = GetFormatType(pixel_format);
-        size = !is_tiled ? BytesInPixels(stride * (height - 1) + width)
-                         : BytesInPixels(stride * 8 * (height / 8 - 1) + width * 8);
-        end = addr + size;
-    }
-    SurfaceInterval GetInterval() const {
+    /// Returns the size of this surface in bytes, adjusted for compression
-        return SurfaceInterval::right_open(addr, end);
+    size_t SizeInBytes() 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;
    }
-    // Returns the outer rectangle containing "interval"
+    /// Returns the CPU virtual address for this surface
-    SurfaceParams FromInterval(SurfaceInterval interval) const;
+    VAddr GetCpuAddr() const;
-    SurfaceInterval GetSubRectInterval(MathUtil::Rectangle<u32> unscaled_rect) const;
-    // Returns the region of the biggest valid rectange within interval
-    SurfaceInterval GetCopyableInterval(const Surface& src_surface) const;
-    /**
-     * Gets the actual width (in pixels) of the surface. This is provided because `width` is used
-     * for tracking the surface region in memory, which may be compressed for certain formats. In
-     * this scenario, `width` is actually the compressed width.
-     */
-    u32 GetActualWidth() const {
-        return width * GetCompresssionFactor();
-    }
-    /**
-     * Gets the actual height (in pixels) of the surface. This is provided because `height` is used
-     * for tracking the surface region in memory, which may be compressed for certain formats. In
-     * this scenario, `height` is actually the compressed height.
-     */
-    u32 GetActualHeight() const {
-        return height * GetCompresssionFactor();
-    }
-    u32 GetScaledWidth() const {
-        return width * res_scale;
-    }
-    u32 GetScaledHeight() const {
-        return height * res_scale;
-    }
-    MathUtil::Rectangle<u32> GetRect() const {
+    /// Returns true if the specified region overlaps with this surface's region in Switch memory
-        return {0, height, width, 0};
+    bool IsOverlappingRegion(Tegra::GPUVAddr region_addr, size_t region_size) const {
+        return addr <= (region_addr + region_size) && region_addr <= (addr + size_in_bytes);
    }
-    MathUtil::Rectangle<u32> GetScaledRect() const {
+    /// Creates SurfaceParams from a texture configuration
-        return {0, GetScaledHeight(), GetScaledWidth(), 0};
+    static SurfaceParams CreateForTexture(const Tegra::Texture::FullTextureInfo& config);
-    }
+    /// Creates SurfaceParams from a framebuffer configuration
+    static SurfaceParams CreateForFramebuffer(
+        const Tegra::Engines::Maxwell3D::Regs::RenderTargetConfig& config);
+    /// Creates SurfaceParams for a depth buffer configuration
+    static SurfaceParams CreateForDepthBuffer(
+        const Tegra::Engines::Maxwell3D::Regs::RenderTargetConfig& config,
+        Tegra::GPUVAddr zeta_address, Tegra::DepthFormat format);
+    Tegra::GPUVAddr addr;
+    bool is_tiled;
+    u32 block_height;
+    PixelFormat pixel_format;
+    ComponentType component_type;
+    SurfaceType type;
+    u32 width;
+    u32 height;
+    u32 unaligned_height;
+    size_t size_in_bytes;
+};
-    u64 PixelsInBytes(u64 size) const {
+/// Hashable variation of SurfaceParams, used for a key in the surface cache
-        return size * CHAR_BIT / GetFormatBpp(pixel_format);
+struct SurfaceKey : Common::HashableStruct<SurfaceParams> {
+    static SurfaceKey Create(const SurfaceParams& params) {
+        SurfaceKey res;
+        res.state = params;
+        return res;
    }
+};
-    u64 BytesInPixels(u64 pixels) const {
+namespace std {
-        return pixels * GetFormatBpp(pixel_format) / CHAR_BIT;
+template <>
+struct hash<SurfaceKey> {
+    size_t operator()(const SurfaceKey& k) const {
+        return k.Hash();
    }
-    VAddr GetCpuAddr() const;
-    bool ExactMatch(const SurfaceParams& other_surface) const;
-    bool CanSubRect(const SurfaceParams& sub_surface) const;
-    bool CanExpand(const SurfaceParams& expanded_surface) const;
-    bool CanTexCopy(const SurfaceParams& texcopy_params) const;
-    MathUtil::Rectangle<u32> GetSubRect(const SurfaceParams& sub_surface) const;
-    MathUtil::Rectangle<u32> GetScaledSubRect(const SurfaceParams& sub_surface) const;
-    Tegra::GPUVAddr addr = 0;
-    Tegra::GPUVAddr end = 0;
-    boost::optional<VAddr> cpu_addr;
-    u64 size = 0;
-    u32 width = 0;
-    u32 height = 0;
-    u32 stride = 0;
-    u32 block_height = 0;
-    u16 res_scale = 1;
-    bool is_tiled = false;
-    PixelFormat pixel_format = PixelFormat::Invalid;
-    SurfaceType type = SurfaceType::Invalid;
-    ComponentType component_type = ComponentType::Invalid;
 };
+} // namespace std
-struct CachedSurface : SurfaceParams {
+class CachedSurface final {
-    bool CanFill(const SurfaceParams& dest_surface, SurfaceInterval fill_interval) const;
+public:
-    bool CanCopy(const SurfaceParams& dest_surface, SurfaceInterval copy_interval) const;
+    CachedSurface(const SurfaceParams& params);
-    bool IsRegionValid(SurfaceInterval interval) const {
-        return (invalid_regions.find(interval) == invalid_regions.end());
-    }
-    bool IsSurfaceFullyInvalid() const {
+    const OGLTexture& Texture() const {
-        return (invalid_regions & GetInterval()) == SurfaceRegions(GetInterval());
+        return texture;
    }
-    bool registered = false;
+    static constexpr unsigned int GetGLBytesPerPixel(SurfaceParams::PixelFormat format) {
-    SurfaceRegions invalid_regions;
+        if (format == SurfaceParams::PixelFormat::Invalid)
-    u64 fill_size = 0; /// Number of bytes to read from fill_data
-    std::array<u8, 4> fill_data;
-    OGLTexture texture;
-    static constexpr unsigned int GetGLBytesPerPixel(PixelFormat format) {
-        if (format == PixelFormat::Invalid)
            return 0;
        return SurfaceParams::GetFormatBpp(format) / CHAR_BIT;
    }
-    std::unique_ptr<u8[]> gl_buffer;
+    const SurfaceParams& GetSurfaceParams() const {
-    size_t gl_buffer_size = 0;
+        return params;
+    }
    // Read/Write data in Switch memory to/from gl_buffer
-    void LoadGLBuffer(Tegra::GPUVAddr load_start, Tegra::GPUVAddr load_end);
+    void LoadGLBuffer();
-    void FlushGLBuffer(Tegra::GPUVAddr flush_start, Tegra::GPUVAddr flush_end);
+    void FlushGLBuffer();
    // Upload/Download data in gl_buffer in/to this surface's texture
-    void UploadGLTexture(const MathUtil::Rectangle<u32>& rect, GLuint read_fb_handle,
+    void UploadGLTexture(GLuint read_fb_handle, GLuint draw_fb_handle);
-                         GLuint draw_fb_handle);
+    void DownloadGLTexture(GLuint read_fb_handle, GLuint draw_fb_handle);
-    void DownloadGLTexture(const MathUtil::Rectangle<u32>& rect, GLuint read_fb_handle,
-                           GLuint draw_fb_handle);
+private:
+    OGLTexture texture;
+    std::vector<u8> gl_buffer;
+    SurfaceParams params;
 };
-class RasterizerCacheOpenGL : NonCopyable {
+class RasterizerCacheOpenGL final : NonCopyable {
 public:
    RasterizerCacheOpenGL();
    ~RasterizerCacheOpenGL();
-    /// Blit one surface's texture to another
-    bool BlitSurfaces(const Surface& src_surface, const MathUtil::Rectangle<u32>& src_rect,
-                      const Surface& dst_surface, const MathUtil::Rectangle<u32>& dst_rect);
-    void ConvertD24S8toABGR(GLuint src_tex, const MathUtil::Rectangle<u32>& src_rect,
-                            GLuint dst_tex, const MathUtil::Rectangle<u32>& dst_rect);
-    /// Copy one surface's region to another
-    void CopySurface(const Surface& src_surface, const Surface& dst_surface,
-                     SurfaceInterval copy_interval);
-    /// Load a texture from Switch memory to OpenGL and cache it (if not already cached)
-    Surface GetSurface(const SurfaceParams& params, ScaleMatch match_res_scale,
-                       bool load_if_create);
-    /// Tries to find a framebuffer GPU address based on the provided CPU address
-    boost::optional<Tegra::GPUVAddr> TryFindFramebufferGpuAddress(VAddr cpu_addr) const;
-    /// Attempt to find a subrect (resolution scaled) of a surface, otherwise loads a texture from
-    /// Switch memory to OpenGL and caches it (if not already cached)
-    SurfaceRect_Tuple GetSurfaceSubRect(const SurfaceParams& params, ScaleMatch match_res_scale,
-                                        bool load_if_create);
    /// Get a surface based on the texture configuration
    Surface GetTextureSurface(const Tegra::Texture::FullTextureInfo& config);
@@ -486,29 +429,21 @@ public:
    SurfaceSurfaceRect_Tuple GetFramebufferSurfaces(bool using_color_fb, bool using_depth_fb,
                                                    const MathUtil::Rectangle<s32>& viewport);
-    /// Get a surface that matches the fill config
+    /// Marks the specified surface as "dirty", in that it is out of sync with Switch memory
-    Surface GetFillSurface(const void* config);
+    void MarkSurfaceAsDirty(const Surface& surface);
-    /// Get a surface that matches a "texture copy" display transfer config
+    /// Tries to find a framebuffer GPU address based on the provided CPU address
-    SurfaceRect_Tuple GetTexCopySurface(const SurfaceParams& params);
+    Surface TryFindFramebufferSurface(VAddr cpu_addr) const;
    /// Write any cached resources overlapping the region back to memory (if dirty)
-    void FlushRegion(Tegra::GPUVAddr addr, u64 size, Surface flush_surface = nullptr);
+    void FlushRegion(Tegra::GPUVAddr addr, size_t size);
-    /// Mark region as being invalidated by region_owner (nullptr if Switch memory)
-    void InvalidateRegion(Tegra::GPUVAddr addr, u64 size, const Surface& region_owner);
-    /// Flush all cached resources tracked by this cache manager
+    /// Mark the specified region as being invalidated
-    void FlushAll();
+    void InvalidateRegion(Tegra::GPUVAddr addr, size_t size);
 private:
-    void DuplicateSurface(const Surface& src_surface, const Surface& dest_surface);
+    void LoadSurface(const Surface& surface);
+    Surface GetSurface(const SurfaceParams& params);
-    /// Update surface's texture for given region when necessary
-    void ValidateSurface(const Surface& surface, Tegra::GPUVAddr addr, u64 size);
-    /// Create a new surface
-    Surface CreateSurface(const SurfaceParams& params);
    /// Register surface into the cache
    void RegisterSurface(const Surface& surface);
@@ -519,18 +454,9 @@ private:
    /// Increase/decrease the number of surface in pages touching the specified region
    void UpdatePagesCachedCount(Tegra::GPUVAddr addr, u64 size, int delta);
-    SurfaceCache surface_cache;
+    std::unordered_map<SurfaceKey, Surface> surface_cache;
    PageMap cached_pages;
-    SurfaceMap dirty_regions;
-    SurfaceSet remove_surfaces;
    OGLFramebuffer read_framebuffer;
    OGLFramebuffer draw_framebuffer;
-    OGLVertexArray attributeless_vao;
-    OGLBuffer d24s8_abgr_buffer;
-    GLsizeiptr d24s8_abgr_buffer_size;
-    OGLProgram d24s8_abgr_shader;
-    GLint d24s8_abgr_tbo_size_u_id;
-    GLint d24s8_abgr_viewport_u_id;
 };
diff --git a/src/video_core/renderer_opengl/gl_resource_manager.h b/src/video_core/renderer_opengl/gl_resource_manager.h
index 93f9172e7..0fed93ca5 100644
--- a/src/video_core/renderer_opengl/gl_resource_manager.h
+++ b/src/video_core/renderer_opengl/gl_resource_manager.h
@@ -38,7 +38,7 @@ public:
        if (handle == 0)
            return;
        glDeleteTextures(1, &handle);
-        OpenGLState::GetCurState().ResetTexture(handle).Apply();
+        OpenGLState::GetCurState().UnbindTexture(handle).Apply();
        handle = 0;
    }
diff --git a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
index 65fed77ef..5914077e8 100644
--- a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
@@ -9,6 +9,7 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "video_core/engines/shader_bytecode.h"
+#include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/gl_shader_decompiler.h"
 namespace GLShader {
@@ -282,7 +283,7 @@ public:
            // Default - do nothing
            return value;
        default:
-            NGLOG_CRITICAL(HW_GPU, "Unimplemented conversion size {}", static_cast<u32>(size));
+            LOG_CRITICAL(HW_GPU, "Unimplemented conversion size {}", static_cast<u32>(size));
            UNREACHABLE();
        }
    }
@@ -397,7 +398,8 @@ public:
    /// Generates code representing a uniform (C buffer) register, interpreted as the input type.
    std::string GetUniform(u64 index, u64 offset, GLSLRegister::Type type) {
        declr_const_buffers[index].MarkAsUsed(index, offset, stage);
-        std::string value = 'c' + std::to_string(index) + '[' + std::to_string(offset) + ']';
+        std::string value = 'c' + std::to_string(index) + '[' + std::to_string(offset / 4) + "][" +
+                            std::to_string(offset % 4) + ']';
        if (type == GLSLRegister::Type::Float) {
            return value;
@@ -411,8 +413,12 @@ public:
    std::string GetUniformIndirect(u64 index, s64 offset, const Register& index_reg,
                                   GLSLRegister::Type type) {
        declr_const_buffers[index].MarkAsUsedIndirect(index, stage);
-        std::string value = 'c' + std::to_string(index) + "[(floatBitsToInt(" +
-                            GetRegister(index_reg, 0) + ") + " + std::to_string(offset) + ") / 4]";
+        std::string final_offset = "((floatBitsToInt(" + GetRegister(index_reg, 0) + ") + " +
+                                   std::to_string(offset) + ") / 4)";
+        std::string value =
+            'c' + std::to_string(index) + '[' + final_offset + " / 4][" + final_offset + " % 4]";
        if (type == GLSLRegister::Type::Float) {
            return value;
@@ -454,9 +460,10 @@ public:
        unsigned const_buffer_layout = 0;
        for (const auto& entry : GetConstBuffersDeclarations()) {
-            declarations.AddLine("layout(std430) buffer " + entry.GetName());
+            declarations.AddLine("layout(std140) uniform " + entry.GetName());
            declarations.AddLine('{');
-            declarations.AddLine("    float c" + std::to_string(entry.GetIndex()) + "[];");
+            declarations.AddLine("    vec4 c" + std::to_string(entry.GetIndex()) +
+                                 "[MAX_CONSTBUFFER_ELEMENTS];");
            declarations.AddLine("};");
            declarations.AddNewLine();
            ++const_buffer_layout;
@@ -574,7 +581,7 @@ private:
                return "input_attribute_" + std::to_string(index);
            }
-            NGLOG_CRITICAL(HW_GPU, "Unhandled input attribute: {}", index);
+            LOG_CRITICAL(HW_GPU, "Unhandled input attribute: {}", index);
            UNREACHABLE();
        }
    }
@@ -592,7 +599,7 @@ private:
                return "output_attribute_" + std::to_string(index);
            }
-            NGLOG_CRITICAL(HW_GPU, "Unhandled output attribute: {}", index);
+            LOG_CRITICAL(HW_GPU, "Unhandled output attribute: {}", index);
            UNREACHABLE();
        }
    }
@@ -712,21 +719,31 @@ private:
    /**
     * Returns the comparison string to use to compare two values in the 'set' family of
     * instructions.
-     * @params condition The condition used in the 'set'-family instruction.
+     * @param condition The condition used in the 'set'-family instruction.
+     * @param op_a First operand to use for the comparison.
+     * @param op_b Second operand to use for the comparison.
     * @returns String corresponding to the GLSL operator that matches the desired comparison.
     */
-    std::string GetPredicateComparison(Tegra::Shader::PredCondition condition) const {
+    std::string GetPredicateComparison(Tegra::Shader::PredCondition condition,
+                                       const std::string& op_a, const std::string& op_b) const {
        using Tegra::Shader::PredCondition;
        static const std::unordered_map<PredCondition, const char*> PredicateComparisonStrings = {
-            {PredCondition::LessThan, "<"},   {PredCondition::Equal, "=="},
+            {PredCondition::LessThan, "<"},         {PredCondition::Equal, "=="},
-            {PredCondition::LessEqual, "<="}, {PredCondition::GreaterThan, ">"},
+            {PredCondition::LessEqual, "<="},       {PredCondition::GreaterThan, ">"},
-            {PredCondition::NotEqual, "!="},  {PredCondition::GreaterEqual, ">="},
+            {PredCondition::NotEqual, "!="},        {PredCondition::GreaterEqual, ">="},
+            {PredCondition::NotEqualWithNan, "!="},
        };
-        auto comparison = PredicateComparisonStrings.find(condition);
+        const auto& comparison{PredicateComparisonStrings.find(condition)};
        ASSERT_MSG(comparison != PredicateComparisonStrings.end(),
                   "Unknown predicate comparison operation");
-        return comparison->second;
+        std::string predicate{'(' + op_a + ") " + comparison->second + " (" + op_b + ')'};
+        if (condition == PredCondition::NotEqualWithNan) {
+            predicate += " || isnan(" + op_a + ") || isnan(" + op_b + ')';
+        }
+        return predicate;
    }
    /**
@@ -780,7 +797,7 @@ private:
            break;
        }
        default:
-            NGLOG_CRITICAL(HW_GPU, "Unimplemented logic operation: {}", static_cast<u32>(logic_op));
+            LOG_CRITICAL(HW_GPU, "Unimplemented logic operation: {}", static_cast<u32>(logic_op));
            UNREACHABLE();
        }
    }
@@ -802,8 +819,9 @@ private:
        // Decoding failure
        if (!opcode) {
-            NGLOG_CRITICAL(HW_GPU, "Unhandled instruction: {0:x}", instr.value);
+            LOG_CRITICAL(HW_GPU, "Unhandled instruction: {0:x}", instr.value);
            UNREACHABLE();
+            return offset + 1;
        }
        shader.AddLine("// " + std::to_string(offset) + ": " + opcode->GetName());
@@ -899,13 +917,13 @@ private:
                    regs.SetRegisterToFloat(instr.gpr0, 0, "inversesqrt(" + op_a + ')', 1, 1,
                                            instr.alu.saturate_d);
                    break;
-                case SubOp::Min:
+                case SubOp::Sqrt:
-                    regs.SetRegisterToFloat(instr.gpr0, 0, "min(" + op_a + "," + op_b + ')', 1, 1,
+                    regs.SetRegisterToFloat(instr.gpr0, 0, "sqrt(" + op_a + ')', 1, 1,
                                            instr.alu.saturate_d);
                    break;
                default:
-                    NGLOG_CRITICAL(HW_GPU, "Unhandled MUFU sub op: {0:x}",
+                    LOG_CRITICAL(HW_GPU, "Unhandled MUFU sub op: {0:x}",
-                                   static_cast<unsigned>(instr.sub_op.Value()));
+                                 static_cast<unsigned>(instr.sub_op.Value()));
                    UNREACHABLE();
                }
                break;
@@ -928,11 +946,11 @@ private:
                // Currently RRO is only implemented as a register move.
                // Usage of `abs_b` and `negate_b` here should also be correct.
                regs.SetRegisterToFloat(instr.gpr0, 0, op_b, 1, 1);
-                NGLOG_WARNING(HW_GPU, "RRO instruction is incomplete");
+                LOG_WARNING(HW_GPU, "RRO instruction is incomplete");
                break;
            }
            default: {
-                NGLOG_CRITICAL(HW_GPU, "Unhandled arithmetic instruction: {}", opcode->GetName());
+                LOG_CRITICAL(HW_GPU, "Unhandled arithmetic instruction: {}", opcode->GetName());
                UNREACHABLE();
            }
            }
@@ -971,7 +989,7 @@ private:
                break;
            }
            default: {
-                NGLOG_CRITICAL(HW_GPU, "Unhandled BFE instruction: {}", opcode->GetName());
+                LOG_CRITICAL(HW_GPU, "Unhandled BFE instruction: {}", opcode->GetName());
                UNREACHABLE();
            }
            }
@@ -1014,7 +1032,7 @@ private:
                regs.SetRegisterToInteger(instr.gpr0, true, 0, op_a + " << " + op_b, 1, 1);
                break;
            default: {
-                NGLOG_CRITICAL(HW_GPU, "Unhandled shift instruction: {}", opcode->GetName());
+                LOG_CRITICAL(HW_GPU, "Unhandled shift instruction: {}", opcode->GetName());
                UNREACHABLE();
            }
            }
@@ -1044,8 +1062,8 @@ private:
                break;
            }
            default: {
-                NGLOG_CRITICAL(HW_GPU, "Unhandled ArithmeticIntegerImmediate instruction: {}",
+                LOG_CRITICAL(HW_GPU, "Unhandled ArithmeticIntegerImmediate instruction: {}",
-                               opcode->GetName());
+                             opcode->GetName());
                UNREACHABLE();
            }
            }
@@ -1109,9 +1127,23 @@ private:
                WriteLogicOperation(instr.gpr0, instr.alu.lop.operation, op_a, op_b);
                break;
            }
+            case OpCode::Id::IMNMX_C:
+            case OpCode::Id::IMNMX_R:
+            case OpCode::Id::IMNMX_IMM: {
+                ASSERT_MSG(instr.imnmx.exchange == Tegra::Shader::IMinMaxExchange::None,
+                           "Unimplemented");
+                std::string condition =
+                    GetPredicateCondition(instr.imnmx.pred, instr.imnmx.negate_pred != 0);
+                std::string parameters = op_a + ',' + op_b;
+                regs.SetRegisterToInteger(instr.gpr0, instr.imnmx.is_signed, 0,
+                                          '(' + condition + ") ? min(" + parameters + ") : max(" +
+                                              parameters + ')',
+                                          1, 1);
+                break;
+            }
            default: {
-                NGLOG_CRITICAL(HW_GPU, "Unhandled ArithmeticInteger instruction: {}",
+                LOG_CRITICAL(HW_GPU, "Unhandled ArithmeticInteger instruction: {}",
-                               opcode->GetName());
+                             opcode->GetName());
                UNREACHABLE();
            }
            }
@@ -1147,7 +1179,7 @@ private:
                break;
            }
            default: {
-                NGLOG_CRITICAL(HW_GPU, "Unhandled FFMA instruction: {}", opcode->GetName());
+                LOG_CRITICAL(HW_GPU, "Unhandled FFMA instruction: {}", opcode->GetName());
                UNREACHABLE();
            }
            }
@@ -1195,6 +1227,9 @@ private:
                switch (instr.conversion.f2f.rounding) {
                case Tegra::Shader::F2fRoundingOp::None:
                    break;
+                case Tegra::Shader::F2fRoundingOp::Round:
+                    op_a = "roundEven(" + op_a + ')';
+                    break;
                case Tegra::Shader::F2fRoundingOp::Floor:
                    op_a = "floor(" + op_a + ')';
                    break;
@@ -1205,8 +1240,8 @@ private:
                    op_a = "trunc(" + op_a + ')';
                    break;
                default:
-                    NGLOG_CRITICAL(HW_GPU, "Unimplemented f2f rounding mode {}",
+                    LOG_CRITICAL(HW_GPU, "Unimplemented f2f rounding mode {}",
-                                   static_cast<u32>(instr.conversion.f2f.rounding.Value()));
+                                 static_cast<u32>(instr.conversion.f2f.rounding.Value()));
                    UNREACHABLE();
                    break;
                }
@@ -1239,8 +1274,8 @@ private:
                    op_a = "trunc(" + op_a + ')';
                    break;
                default:
-                    NGLOG_CRITICAL(HW_GPU, "Unimplemented f2i rounding mode {}",
+                    LOG_CRITICAL(HW_GPU, "Unimplemented f2i rounding mode {}",
-                                   static_cast<u32>(instr.conversion.f2i.rounding.Value()));
+                                 static_cast<u32>(instr.conversion.f2i.rounding.Value()));
                    UNREACHABLE();
                    break;
                }
@@ -1256,7 +1291,7 @@ private:
                break;
            }
            default: {
-                NGLOG_CRITICAL(HW_GPU, "Unhandled conversion instruction: {}", opcode->GetName());
+                LOG_CRITICAL(HW_GPU, "Unhandled conversion instruction: {}", opcode->GetName());
                UNREACHABLE();
            }
            }
@@ -1291,8 +1326,8 @@ private:
                    break;
                default:
-                    NGLOG_CRITICAL(HW_GPU, "Unhandled type: {}",
+                    LOG_CRITICAL(HW_GPU, "Unhandled type: {}",
-                                   static_cast<unsigned>(instr.ld_c.type.Value()));
+                                 static_cast<unsigned>(instr.ld_c.type.Value()));
                    UNREACHABLE();
                }
                break;
@@ -1365,7 +1400,7 @@ private:
                break;
            }
            default: {
-                NGLOG_CRITICAL(HW_GPU, "Unhandled memory instruction: {}", opcode->GetName());
+                LOG_CRITICAL(HW_GPU, "Unhandled memory instruction: {}", opcode->GetName());
                UNREACHABLE();
            }
            }
@@ -1407,10 +1442,9 @@ private:
            std::string second_pred =
                GetPredicateCondition(instr.fsetp.pred39, instr.fsetp.neg_pred != 0);
-            std::string comparator = GetPredicateComparison(instr.fsetp.cond);
            std::string combiner = GetPredicateCombiner(instr.fsetp.op);
-            std::string predicate = '(' + op_a + ") " + comparator + " (" + op_b + ')';
+            std::string predicate = GetPredicateComparison(instr.fsetp.cond, op_a, op_b);
            // Set the primary predicate to the result of Predicate OP SecondPredicate
            SetPredicate(instr.fsetp.pred3,
                         '(' + predicate + ") " + combiner + " (" + second_pred + ')');
@@ -1445,10 +1479,9 @@ private:
            std::string second_pred =
                GetPredicateCondition(instr.isetp.pred39, instr.isetp.neg_pred != 0);
-            std::string comparator = GetPredicateComparison(instr.isetp.cond);
            std::string combiner = GetPredicateCombiner(instr.isetp.op);
-            std::string predicate = '(' + op_a + ") " + comparator + " (" + op_b + ')';
+            std::string predicate = GetPredicateComparison(instr.isetp.cond, op_a, op_b);
            // Set the primary predicate to the result of Predicate OP SecondPredicate
            SetPredicate(instr.isetp.pred3,
                         '(' + predicate + ") " + combiner + " (" + second_pred + ')');
@@ -1461,6 +1494,36 @@ private:
            }
            break;
        }
+        case OpCode::Type::PredicateSetPredicate: {
+            std::string op_a =
+                GetPredicateCondition(instr.psetp.pred12, instr.psetp.neg_pred12 != 0);
+            std::string op_b =
+                GetPredicateCondition(instr.psetp.pred29, instr.psetp.neg_pred29 != 0);
+            using Tegra::Shader::Pred;
+            // We can't use the constant predicate as destination.
+            ASSERT(instr.psetp.pred3 != static_cast<u64>(Pred::UnusedIndex));
+            std::string second_pred =
+                GetPredicateCondition(instr.psetp.pred39, instr.psetp.neg_pred39 != 0);
+            std::string combiner = GetPredicateCombiner(instr.psetp.op);
+            std::string predicate =
+                '(' + op_a + ") " + GetPredicateCombiner(instr.psetp.cond) + " (" + op_b + ')';
+            // Set the primary predicate to the result of Predicate OP SecondPredicate
+            SetPredicate(instr.psetp.pred3,
+                         '(' + predicate + ") " + combiner + " (" + second_pred + ')');
+            if (instr.psetp.pred0 != static_cast<u64>(Pred::UnusedIndex)) {
+                // Set the secondary predicate to the result of !Predicate OP SecondPredicate,
+                // if enabled
+                SetPredicate(instr.psetp.pred0,
+                             "!(" + predicate + ") " + combiner + " (" + second_pred + ')');
+            }
+            break;
+        }
        case OpCode::Type::FloatSet: {
            std::string op_a = instr.fset.neg_a ? "-" : "";
            op_a += regs.GetRegisterAsFloat(instr.gpr8);
@@ -1495,11 +1558,10 @@ private:
            std::string second_pred =
                GetPredicateCondition(instr.fset.pred39, instr.fset.neg_pred != 0);
-            std::string comparator = GetPredicateComparison(instr.fset.cond);
            std::string combiner = GetPredicateCombiner(instr.fset.op);
-            std::string predicate = "(((" + op_a + ") " + comparator + " (" + op_b + ")) " +
+            std::string predicate = "((" + GetPredicateComparison(instr.fset.cond, op_a, op_b) +
-                                    combiner + " (" + second_pred + "))";
+                                    ") " + combiner + " (" + second_pred + "))";
            if (instr.fset.bf) {
                regs.SetRegisterToFloat(instr.gpr0, 0, predicate + " ? 1.0 : 0.0", 1, 1);
@@ -1530,11 +1592,10 @@ private:
            std::string second_pred =
                GetPredicateCondition(instr.iset.pred39, instr.iset.neg_pred != 0);
-            std::string comparator = GetPredicateComparison(instr.iset.cond);
            std::string combiner = GetPredicateCombiner(instr.iset.op);
-            std::string predicate = "(((" + op_a + ") " + comparator + " (" + op_b + ")) " +
+            std::string predicate = "((" + GetPredicateComparison(instr.iset.cond, op_a, op_b) +
-                                    combiner + " (" + second_pred + "))";
+                                    ") " + combiner + " (" + second_pred + "))";
            if (instr.iset.bf) {
                regs.SetRegisterToFloat(instr.gpr0, 0, predicate + " ? 1.0 : 0.0", 1, 1);
@@ -1585,8 +1646,15 @@ private:
                // can ignore this when generating GLSL code.
                break;
            }
+            case OpCode::Id::DEPBAR:
+            case OpCode::Id::SYNC: {
+                // TODO(Subv): Find out if we actually have to care about these instructions or if
+                // the GLSL compiler takes care of that for us.
+                LOG_WARNING(HW_GPU, "DEPBAR/SYNC instruction is stubbed");
+                break;
+            }
            default: {
-                NGLOG_CRITICAL(HW_GPU, "Unhandled instruction: {}", opcode->GetName());
+                LOG_CRITICAL(HW_GPU, "Unhandled instruction: {}", opcode->GetName());
                UNREACHABLE();
            }
            }
@@ -1713,7 +1781,10 @@ private:
 }; // namespace Decompiler
 std::string GetCommonDeclarations() {
-    return "bool exec_shader();";
+    std::string declarations = "bool exec_shader();\n";
+    declarations += "#define MAX_CONSTBUFFER_ELEMENTS " +
+                    std::to_string(RasterizerOpenGL::MaxConstbufferSize / (sizeof(GLvec4)));
+    return declarations;
 }
 boost::optional<ProgramResult> DecompileProgram(const ProgramCode& program_code, u32 main_offset,
@@ -1723,7 +1794,7 @@ boost::optional<ProgramResult> DecompileProgram(const ProgramCode& program_code,
        GLSLGenerator generator(subroutines, program_code, main_offset, stage);
        return ProgramResult{generator.GetShaderCode(), generator.GetEntries()};
    } catch (const DecompileFail& exception) {
-        NGLOG_ERROR(HW_GPU, "Shader decompilation failed: {}", exception.what());
+        LOG_ERROR(HW_GPU, "Shader decompilation failed: {}", exception.what());
    }
    return boost::none;
 }
diff --git a/src/video_core/renderer_opengl/gl_shader_util.cpp b/src/video_core/renderer_opengl/gl_shader_util.cpp
index 8568fface..3c087d638 100644
--- a/src/video_core/renderer_opengl/gl_shader_util.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_util.cpp
@@ -27,7 +27,7 @@ GLuint LoadShader(const char* source, GLenum type) {
    }
    GLuint shader_id = glCreateShader(type);
    glShaderSource(shader_id, 1, &source, nullptr);
-    NGLOG_DEBUG(Render_OpenGL, "Compiling {} shader...", debug_type);
+    LOG_DEBUG(Render_OpenGL, "Compiling {} shader...", debug_type);
    glCompileShader(shader_id);
    GLint result = GL_FALSE;
@@ -39,9 +39,9 @@ GLuint LoadShader(const char* source, GLenum type) {
        std::string shader_error(info_log_length, ' ');
        glGetShaderInfoLog(shader_id, info_log_length, nullptr, &shader_error[0]);
        if (result == GL_TRUE) {
-            NGLOG_DEBUG(Render_OpenGL, "{}", shader_error);
+            LOG_DEBUG(Render_OpenGL, "{}", shader_error);
        } else {
-            NGLOG_ERROR(Render_OpenGL, "Error compiling {} shader:\n{}", debug_type, shader_error);
+            LOG_ERROR(Render_OpenGL, "Error compiling {} shader:\n{}", debug_type, shader_error);
        }
    }
    return shader_id;
diff --git a/src/video_core/renderer_opengl/gl_shader_util.h b/src/video_core/renderer_opengl/gl_shader_util.h
index 2036a06a9..0e4d782e2 100644
--- a/src/video_core/renderer_opengl/gl_shader_util.h
+++ b/src/video_core/renderer_opengl/gl_shader_util.h
@@ -29,7 +29,7 @@ void LogShaderSource(T... shaders) {
        std::string source(source_length, ' ');
        glGetShaderSource(shader, source_length, nullptr, &source[0]);
-        NGLOG_INFO(Render_OpenGL, "Shader source {}", source);
+        LOG_INFO(Render_OpenGL, "Shader source {}", source);
    }
 }
@@ -49,7 +49,7 @@ GLuint LoadShader(const char* source, GLenum type);
 template <typename... T>
 GLuint LoadProgram(bool separable_program, T... shaders) {
    // Link the program
-    NGLOG_DEBUG(Render_OpenGL, "Linking program...");
+    LOG_DEBUG(Render_OpenGL, "Linking program...");
    GLuint program_id = glCreateProgram();
@@ -71,9 +71,9 @@ GLuint LoadProgram(bool separable_program, T... shaders) {
        std::string program_error(info_log_length, ' ');
        glGetProgramInfoLog(program_id, info_log_length, nullptr, &program_error[0]);
        if (result == GL_TRUE) {
-            NGLOG_DEBUG(Render_OpenGL, "{}", program_error);
+            LOG_DEBUG(Render_OpenGL, "{}", program_error);
        } else {
-            NGLOG_ERROR(Render_OpenGL, "Error linking shader:\n{}", program_error);
+            LOG_ERROR(Render_OpenGL, "Error linking shader:\n{}", program_error);
        }
    }
diff --git a/src/video_core/renderer_opengl/gl_state.cpp b/src/video_core/renderer_opengl/gl_state.cpp
index 1f1e48425..2e8a422a8 100644
--- a/src/video_core/renderer_opengl/gl_state.cpp
+++ b/src/video_core/renderer_opengl/gl_state.cpp
@@ -48,24 +48,9 @@ OpenGLState::OpenGLState() {
    logic_op = GL_COPY;
    for (auto& texture_unit : texture_units) {
-        texture_unit.texture_2d = 0;
+        texture_unit.Reset();
-        texture_unit.sampler = 0;
-        texture_unit.swizzle.r = GL_RED;
-        texture_unit.swizzle.g = GL_GREEN;
-        texture_unit.swizzle.b = GL_BLUE;
-        texture_unit.swizzle.a = GL_ALPHA;
    }
-    lighting_lut.texture_buffer = 0;
-    fog_lut.texture_buffer = 0;
-    proctex_lut.texture_buffer = 0;
-    proctex_diff_lut.texture_buffer = 0;
-    proctex_color_map.texture_buffer = 0;
-    proctex_alpha_map.texture_buffer = 0;
-    proctex_noise_lut.texture_buffer = 0;
    draw.read_framebuffer = 0;
    draw.draw_framebuffer = 0;
    draw.vertex_array = 0;
@@ -223,54 +208,12 @@ void OpenGLState::Apply() const {
            if (current.enabled != new_state.enabled || current.bindpoint != new_state.bindpoint ||
                current.ssbo != new_state.ssbo) {
                if (new_state.enabled) {
-                    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, new_state.bindpoint, new_state.ssbo);
+                    glBindBufferBase(GL_UNIFORM_BUFFER, new_state.bindpoint, new_state.ssbo);
                }
            }
        }
    }
-    // Lighting LUTs
-    if (lighting_lut.texture_buffer != cur_state.lighting_lut.texture_buffer) {
-        glActiveTexture(TextureUnits::LightingLUT.Enum());
-        glBindTexture(GL_TEXTURE_BUFFER, lighting_lut.texture_buffer);
-    }
-    // Fog LUT
-    if (fog_lut.texture_buffer != cur_state.fog_lut.texture_buffer) {
-        glActiveTexture(TextureUnits::FogLUT.Enum());
-        glBindTexture(GL_TEXTURE_BUFFER, fog_lut.texture_buffer);
-    }
-    // ProcTex Noise LUT
-    if (proctex_noise_lut.texture_buffer != cur_state.proctex_noise_lut.texture_buffer) {
-        glActiveTexture(TextureUnits::ProcTexNoiseLUT.Enum());
-        glBindTexture(GL_TEXTURE_BUFFER, proctex_noise_lut.texture_buffer);
-    }
-    // ProcTex Color Map
-    if (proctex_color_map.texture_buffer != cur_state.proctex_color_map.texture_buffer) {
-        glActiveTexture(TextureUnits::ProcTexColorMap.Enum());
-        glBindTexture(GL_TEXTURE_BUFFER, proctex_color_map.texture_buffer);
-    }
-    // ProcTex Alpha Map
-    if (proctex_alpha_map.texture_buffer != cur_state.proctex_alpha_map.texture_buffer) {
-        glActiveTexture(TextureUnits::ProcTexAlphaMap.Enum());
-        glBindTexture(GL_TEXTURE_BUFFER, proctex_alpha_map.texture_buffer);
-    }
-    // ProcTex LUT
-    if (proctex_lut.texture_buffer != cur_state.proctex_lut.texture_buffer) {
-        glActiveTexture(TextureUnits::ProcTexLUT.Enum());
-        glBindTexture(GL_TEXTURE_BUFFER, proctex_lut.texture_buffer);
-    }
-    // ProcTex Diff LUT
-    if (proctex_diff_lut.texture_buffer != cur_state.proctex_diff_lut.texture_buffer) {
-        glActiveTexture(TextureUnits::ProcTexDiffLUT.Enum());
-        glBindTexture(GL_TEXTURE_BUFFER, proctex_diff_lut.texture_buffer);
-    }
    // Framebuffer
    if (draw.read_framebuffer != cur_state.draw.read_framebuffer) {
        glBindFramebuffer(GL_READ_FRAMEBUFFER, draw.read_framebuffer);
@@ -338,26 +281,12 @@ void OpenGLState::Apply() const {
    cur_state = *this;
 }
-OpenGLState& OpenGLState::ResetTexture(GLuint handle) {
+OpenGLState& OpenGLState::UnbindTexture(GLuint handle) {
    for (auto& unit : texture_units) {
        if (unit.texture_2d == handle) {
-            unit.texture_2d = 0;
+            unit.Unbind();
        }
    }
-    if (lighting_lut.texture_buffer == handle)
-        lighting_lut.texture_buffer = 0;
-    if (fog_lut.texture_buffer == handle)
-        fog_lut.texture_buffer = 0;
-    if (proctex_noise_lut.texture_buffer == handle)
-        proctex_noise_lut.texture_buffer = 0;
-    if (proctex_color_map.texture_buffer == handle)
-        proctex_color_map.texture_buffer = 0;
-    if (proctex_alpha_map.texture_buffer == handle)
-        proctex_alpha_map.texture_buffer = 0;
-    if (proctex_lut.texture_buffer == handle)
-        proctex_lut.texture_buffer = 0;
-    if (proctex_diff_lut.texture_buffer == handle)
-        proctex_diff_lut.texture_buffer = 0;
    return *this;
 }
diff --git a/src/video_core/renderer_opengl/gl_state.h b/src/video_core/renderer_opengl/gl_state.h
index 839e50e93..3398d7c04 100644
--- a/src/video_core/renderer_opengl/gl_state.h
+++ b/src/video_core/renderer_opengl/gl_state.h
@@ -91,35 +91,20 @@ public:
            GLint b; // GL_TEXTURE_SWIZZLE_B
            GLint a; // GL_TEXTURE_SWIZZLE_A
        } swizzle;
-    } texture_units[32];
-    struct {
-        GLuint texture_buffer; // GL_TEXTURE_BINDING_BUFFER
-    } lighting_lut;
-    struct {
-        GLuint texture_buffer; // GL_TEXTURE_BINDING_BUFFER
-    } fog_lut;
-    struct {
-        GLuint texture_buffer; // GL_TEXTURE_BINDING_BUFFER
-    } proctex_noise_lut;
-    struct {
+        void Unbind() {
-        GLuint texture_buffer; // GL_TEXTURE_BINDING_BUFFER
+            texture_2d = 0;
-    } proctex_color_map;
+            swizzle.r = GL_RED;
+            swizzle.g = GL_GREEN;
-    struct {
+            swizzle.b = GL_BLUE;
-        GLuint texture_buffer; // GL_TEXTURE_BINDING_BUFFER
+            swizzle.a = GL_ALPHA;
-    } proctex_alpha_map;
+        }
-    struct {
+        void Reset() {
-        GLuint texture_buffer; // GL_TEXTURE_BINDING_BUFFER
+            Unbind();
-    } proctex_lut;
+            sampler = 0;
+        }
-    struct {
+    } texture_units[32];
-        GLuint texture_buffer; // GL_TEXTURE_BINDING_BUFFER
-    } proctex_diff_lut;
    struct {
        GLuint read_framebuffer; // GL_READ_FRAMEBUFFER_BINDING
@@ -165,7 +150,7 @@ public:
    void Apply() const;
    /// Resets any references to the given resource
-    OpenGLState& ResetTexture(GLuint handle);
+    OpenGLState& UnbindTexture(GLuint handle);
    OpenGLState& ResetSampler(GLuint handle);
    OpenGLState& ResetProgram(GLuint handle);
    OpenGLState& ResetPipeline(GLuint handle);
diff --git a/src/video_core/renderer_opengl/maxwell_to_gl.h b/src/video_core/renderer_opengl/maxwell_to_gl.h
index 2155fb019..e19c3b280 100644
--- a/src/video_core/renderer_opengl/maxwell_to_gl.h
+++ b/src/video_core/renderer_opengl/maxwell_to_gl.h
@@ -29,9 +29,13 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
        switch (attrib.size) {
        case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
            return GL_UNSIGNED_BYTE;
+        case Maxwell::VertexAttribute::Size::Size_16_16:
+            return GL_UNSIGNED_SHORT;
+        case Maxwell::VertexAttribute::Size::Size_10_10_10_2:
+            return GL_UNSIGNED_INT_2_10_10_10_REV;
        }
-        NGLOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
+        LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
        UNREACHABLE();
        return {};
    }
@@ -41,9 +45,13 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
        switch (attrib.size) {
        case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
            return GL_BYTE;
+        case Maxwell::VertexAttribute::Size::Size_16_16:
+            return GL_SHORT;
+        case Maxwell::VertexAttribute::Size::Size_10_10_10_2:
+            return GL_INT_2_10_10_10_REV;
        }
-        NGLOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
+        LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
        UNREACHABLE();
        return {};
    }
@@ -52,7 +60,7 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
        return GL_FLOAT;
    }
-    NGLOG_CRITICAL(Render_OpenGL, "Unimplemented vertex type={}", attrib.TypeString());
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex type={}", attrib.TypeString());
    UNREACHABLE();
    return {};
 }
@@ -66,7 +74,7 @@ inline GLenum IndexFormat(Maxwell::IndexFormat index_format) {
    case Maxwell::IndexFormat::UnsignedInt:
        return GL_UNSIGNED_INT;
    }
-    NGLOG_CRITICAL(Render_OpenGL, "Unimplemented index_format={}", static_cast<u32>(index_format));
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented index_format={}", static_cast<u32>(index_format));
    UNREACHABLE();
    return {};
 }
@@ -78,7 +86,7 @@ inline GLenum PrimitiveTopology(Maxwell::PrimitiveTopology topology) {
    case Maxwell::PrimitiveTopology::TriangleStrip:
        return GL_TRIANGLE_STRIP;
    }
-    NGLOG_CRITICAL(Render_OpenGL, "Unimplemented topology={}", static_cast<u32>(topology));
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented topology={}", static_cast<u32>(topology));
    UNREACHABLE();
    return {};
 }
@@ -90,8 +98,8 @@ inline GLenum TextureFilterMode(Tegra::Texture::TextureFilter filter_mode) {
    case Tegra::Texture::TextureFilter::Nearest:
        return GL_NEAREST;
    }
-    NGLOG_CRITICAL(Render_OpenGL, "Unimplemented texture filter mode={}",
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented texture filter mode={}",
-                   static_cast<u32>(filter_mode));
+                 static_cast<u32>(filter_mode));
    UNREACHABLE();
    return {};
 }
@@ -110,8 +118,7 @@ inline GLenum WrapMode(Tegra::Texture::WrapMode wrap_mode) {
        // manually mix them. However the shader part of this is not yet implemented.
        return GL_CLAMP_TO_BORDER;
    }
-    NGLOG_CRITICAL(Render_OpenGL, "Unimplemented texture wrap mode={}",
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented texture wrap mode={}", static_cast<u32>(wrap_mode));
-                   static_cast<u32>(wrap_mode));
    UNREACHABLE();
    return {};
 }
@@ -129,7 +136,7 @@ inline GLenum BlendEquation(Maxwell::Blend::Equation equation) {
    case Maxwell::Blend::Equation::Max:
        return GL_MAX;
    }
-    NGLOG_CRITICAL(Render_OpenGL, "Unimplemented blend equation={}", static_cast<u32>(equation));
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented blend equation={}", static_cast<u32>(equation));
    UNREACHABLE();
    return {};
 }
@@ -175,7 +182,7 @@ inline GLenum BlendFunc(Maxwell::Blend::Factor factor) {
    case Maxwell::Blend::Factor::OneMinusConstantAlpha:
        return GL_ONE_MINUS_CONSTANT_ALPHA;
    }
-    NGLOG_CRITICAL(Render_OpenGL, "Unimplemented blend factor={}", static_cast<u32>(factor));
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented blend factor={}", static_cast<u32>(factor));
    UNREACHABLE();
    return {};
 }
@@ -196,7 +203,65 @@ inline GLenum SwizzleSource(Tegra::Texture::SwizzleSource source) {
    case Tegra::Texture::SwizzleSource::OneFloat:
        return GL_ONE;
    }
-    NGLOG_CRITICAL(Render_OpenGL, "Unimplemented swizzle source={}", static_cast<u32>(source));
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented swizzle source={}", static_cast<u32>(source));
+    UNREACHABLE();
+    return {};
+}
+inline GLenum ComparisonOp(Maxwell::ComparisonOp comparison) {
+    switch (comparison) {
+    case Maxwell::ComparisonOp::Never:
+    case Maxwell::ComparisonOp::NeverOld:
+        return GL_NEVER;
+    case Maxwell::ComparisonOp::Less:
+    case Maxwell::ComparisonOp::LessOld:
+        return GL_LESS;
+    case Maxwell::ComparisonOp::Equal:
+    case Maxwell::ComparisonOp::EqualOld:
+        return GL_EQUAL;
+    case Maxwell::ComparisonOp::LessEqual:
+    case Maxwell::ComparisonOp::LessEqualOld:
+        return GL_LEQUAL;
+    case Maxwell::ComparisonOp::Greater:
+    case Maxwell::ComparisonOp::GreaterOld:
+        return GL_GREATER;
+    case Maxwell::ComparisonOp::NotEqual:
+    case Maxwell::ComparisonOp::NotEqualOld:
+        return GL_NOTEQUAL;
+    case Maxwell::ComparisonOp::GreaterEqual:
+    case Maxwell::ComparisonOp::GreaterEqualOld:
+        return GL_GEQUAL;
+    case Maxwell::ComparisonOp::Always:
+    case Maxwell::ComparisonOp::AlwaysOld:
+        return GL_ALWAYS;
+    }
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented comparison op={}", static_cast<u32>(comparison));
+    UNREACHABLE();
+    return {};
+}
+inline GLenum FrontFace(Maxwell::Cull::FrontFace front_face) {
+    switch (front_face) {
+    case Maxwell::Cull::FrontFace::ClockWise:
+        return GL_CW;
+    case Maxwell::Cull::FrontFace::CounterClockWise:
+        return GL_CCW;
+    }
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented front face cull={}", static_cast<u32>(front_face));
+    UNREACHABLE();
+    return {};
+}
+inline GLenum CullFace(Maxwell::Cull::CullFace cull_face) {
+    switch (cull_face) {
+    case Maxwell::Cull::CullFace::Front:
+        return GL_FRONT;
+    case Maxwell::Cull::CullFace::Back:
+        return GL_BACK;
+    case Maxwell::Cull::CullFace::FrontAndBack:
+        return GL_FRONT_AND_BACK;
+    }
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented cull face={}", static_cast<u32>(cull_face));
    UNREACHABLE();
    return {};
 }
diff --git a/src/video_core/renderer_opengl/renderer_opengl.cpp b/src/video_core/renderer_opengl/renderer_opengl.cpp
index f33766bfd..00841e937 100644
--- a/src/video_core/renderer_opengl/renderer_opengl.cpp
+++ b/src/video_core/renderer_opengl/renderer_opengl.cpp
@@ -150,7 +150,6 @@ void RendererOpenGL::LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuf
                                         screen_info)) {
        // Reset the screen info's display texture to its own permanent texture
        screen_info.display_texture = screen_info.texture.resource.handle;
-        screen_info.display_texcoords = MathUtil::Rectangle<float>(0.f, 0.f, 1.f, 1.f);
        Memory::RasterizerFlushVirtualRegion(framebuffer_addr, size_in_bytes,
                                             Memory::FlushMode::Flush);
@@ -302,8 +301,8 @@ void RendererOpenGL::DrawScreenTriangles(const ScreenInfo& screen_info, float x,
            right = texcoords.left;
        } else {
            // Other transformations are unsupported
-            NGLOG_CRITICAL(Render_OpenGL, "Unsupported framebuffer_transform_flags={}",
+            LOG_CRITICAL(Render_OpenGL, "Unsupported framebuffer_transform_flags={}",
-                           static_cast<u32>(framebuffer_transform_flags));
+                         static_cast<u32>(framebuffer_transform_flags));
            UNIMPLEMENTED();
        }
    }
@@ -405,14 +404,14 @@ static void APIENTRY DebugHandler(GLenum source, GLenum type, GLuint id, GLenum
    switch (severity) {
    case GL_DEBUG_SEVERITY_HIGH:
-        NGLOG_ERROR(Render_OpenGL, format, str_source, str_type, id, message);
+        LOG_ERROR(Render_OpenGL, format, str_source, str_type, id, message);
        break;
    case GL_DEBUG_SEVERITY_MEDIUM:
-        NGLOG_WARNING(Render_OpenGL, format, str_source, str_type, id, message);
+        LOG_WARNING(Render_OpenGL, format, str_source, str_type, id, message);
        break;
    case GL_DEBUG_SEVERITY_NOTIFICATION:
    case GL_DEBUG_SEVERITY_LOW:
-        NGLOG_DEBUG(Render_OpenGL, format, str_source, str_type, id, message);
+        LOG_DEBUG(Render_OpenGL, format, str_source, str_type, id, message);
        break;
    }
 }
@@ -430,9 +429,9 @@ bool RendererOpenGL::Init() {
    const char* gpu_vendor{reinterpret_cast<char const*>(glGetString(GL_VENDOR))};
    const char* gpu_model{reinterpret_cast<char const*>(glGetString(GL_RENDERER))};
-    NGLOG_INFO(Render_OpenGL, "GL_VERSION: {}", gl_version);
+    LOG_INFO(Render_OpenGL, "GL_VERSION: {}", gl_version);
-    NGLOG_INFO(Render_OpenGL, "GL_VENDOR: {}", gpu_vendor);
+    LOG_INFO(Render_OpenGL, "GL_VENDOR: {}", gpu_vendor);
-    NGLOG_INFO(Render_OpenGL, "GL_RENDERER: {}", gpu_model);
+    LOG_INFO(Render_OpenGL, "GL_RENDERER: {}", gpu_model);
    Core::Telemetry().AddField(Telemetry::FieldType::UserSystem, "GPU_Vendor", gpu_vendor);
    Core::Telemetry().AddField(Telemetry::FieldType::UserSystem, "GPU_Model", gpu_model);
diff --git a/src/video_core/renderer_opengl/renderer_opengl.h b/src/video_core/renderer_opengl/renderer_opengl.h
index 2cc6d9a00..21f0d298c 100644
--- a/src/video_core/renderer_opengl/renderer_opengl.h
+++ b/src/video_core/renderer_opengl/renderer_opengl.h
@@ -27,7 +27,7 @@ struct TextureInfo {
 /// Structure used for storing information about the display target for the Switch screen
 struct ScreenInfo {
    GLuint display_texture;
-    MathUtil::Rectangle<float> display_texcoords;
+    const MathUtil::Rectangle<float> display_texcoords{0.0f, 0.0f, 1.0f, 1.0f};
    TextureInfo texture;
 };
diff --git a/src/video_core/textures/decoders.cpp b/src/video_core/textures/decoders.cpp
index 0db4367f1..b3937b2fe 100644
--- a/src/video_core/textures/decoders.cpp
+++ b/src/video_core/textures/decoders.cpp
@@ -5,6 +5,7 @@
 #include <cstring>
 #include "common/assert.h"
 #include "core/memory.h"
+#include "video_core/gpu.h"
 #include "video_core/textures/decoders.h"
 #include "video_core/textures/texture.h"
@@ -51,6 +52,7 @@ u32 BytesPerPixel(TextureFormat format) {
        return 8;
    case TextureFormat::DXT23:
    case TextureFormat::DXT45:
+    case TextureFormat::BC7U:
        // In this case a 'pixel' actually refers to a 4x4 tile.
        return 16;
    case TextureFormat::ASTC_2D_4X4:
@@ -65,6 +67,20 @@ u32 BytesPerPixel(TextureFormat format) {
        return 1;
    case TextureFormat::R16_G16_B16_A16:
        return 8;
+    case TextureFormat::R32_G32_B32_A32:
+        return 16;
+    default:
+        UNIMPLEMENTED_MSG("Format not implemented");
+        break;
+    }
+}
+static u32 DepthBytesPerPixel(DepthFormat format) {
+    switch (format) {
+    case DepthFormat::S8_Z24_UNORM:
+    case DepthFormat::Z24_S8_UNORM:
+    case DepthFormat::Z32_FLOAT:
+        return 4;
    default:
        UNIMPLEMENTED_MSG("Format not implemented");
        break;
@@ -83,6 +99,7 @@ std::vector<u8> UnswizzleTexture(VAddr address, TextureFormat format, u32 width,
    case TextureFormat::DXT23:
    case TextureFormat::DXT45:
    case TextureFormat::DXN1:
+    case TextureFormat::BC7U:
        // In the DXT and DXN formats, each 4x4 tile is swizzled instead of just individual pixel
        // values.
        CopySwizzledData(width / 4, height / 4, bytes_per_pixel, bytes_per_pixel, data,
@@ -94,6 +111,7 @@ std::vector<u8> UnswizzleTexture(VAddr address, TextureFormat format, u32 width,
    case TextureFormat::B5G6R5:
    case TextureFormat::R8:
    case TextureFormat::R16_G16_B16_A16:
+    case TextureFormat::R32_G32_B32_A32:
    case TextureFormat::BF10GF11RF11:
    case TextureFormat::ASTC_2D_4X4:
        CopySwizzledData(width, height, bytes_per_pixel, bytes_per_pixel, data,
@@ -107,6 +125,28 @@ std::vector<u8> UnswizzleTexture(VAddr address, TextureFormat format, u32 width,
    return unswizzled_data;
 }
+std::vector<u8> UnswizzleDepthTexture(VAddr address, DepthFormat format, u32 width, u32 height,
+                                      u32 block_height) {
+    u8* data = Memory::GetPointer(address);
+    u32 bytes_per_pixel = DepthBytesPerPixel(format);
+    std::vector<u8> unswizzled_data(width * height * bytes_per_pixel);
+    switch (format) {
+    case DepthFormat::S8_Z24_UNORM:
+    case DepthFormat::Z24_S8_UNORM:
+    case DepthFormat::Z32_FLOAT:
+        CopySwizzledData(width, height, bytes_per_pixel, bytes_per_pixel, data,
+                         unswizzled_data.data(), true, block_height);
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Format not implemented");
+        break;
+    }
+    return unswizzled_data;
+}
 std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat format, u32 width,
                              u32 height) {
    std::vector<u8> rgba_data;
@@ -117,6 +157,7 @@ std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat
    case TextureFormat::DXT23:
    case TextureFormat::DXT45:
    case TextureFormat::DXN1:
+    case TextureFormat::BC7U:
    case TextureFormat::ASTC_2D_4X4:
    case TextureFormat::A8R8G8B8:
    case TextureFormat::A2B10G10R10:
@@ -124,6 +165,7 @@ std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat
    case TextureFormat::B5G6R5:
    case TextureFormat::R8:
    case TextureFormat::BF10GF11RF11:
+    case TextureFormat::R32_G32_B32_A32:
        // TODO(Subv): For the time being just forward the same data without any decoding.
        rgba_data = texture_data;
        break;
diff --git a/src/video_core/textures/decoders.h b/src/video_core/textures/decoders.h
index 2562c4b06..2b088c077 100644
--- a/src/video_core/textures/decoders.h
+++ b/src/video_core/textures/decoders.h
@@ -17,6 +17,12 @@ namespace Texture {
 std::vector<u8> UnswizzleTexture(VAddr address, TextureFormat format, u32 width, u32 height,
                                 u32 block_height = TICEntry::DefaultBlockHeight);
+/**
+ * Unswizzles a swizzled depth texture without changing its format.
+ */
+std::vector<u8> UnswizzleDepthTexture(VAddr address, DepthFormat format, u32 width, u32 height,
+                                      u32 block_height = TICEntry::DefaultBlockHeight);
 /// Copies texture data from a buffer and performs swizzling/unswizzling as necessary.
 void CopySwizzledData(u32 width, u32 height, u32 bytes_per_pixel, u32 out_bytes_per_pixel,
                      u8* swizzled_data, u8* unswizzled_data, bool unswizzle, u32 block_height);
diff --git a/src/video_core/video_core.cpp b/src/video_core/video_core.cpp
index 89dc8ed1e..289140f31 100644
--- a/src/video_core/video_core.cpp
+++ b/src/video_core/video_core.cpp
@@ -24,9 +24,9 @@ bool Init(EmuWindow* emu_window) {
    g_renderer = std::make_unique<RendererOpenGL>();
    g_renderer->SetWindow(g_emu_window);
    if (g_renderer->Init()) {
-        NGLOG_DEBUG(Render, "initialized OK");
+        LOG_DEBUG(Render, "initialized OK");
    } else {
-        NGLOG_CRITICAL(Render, "initialization failed !");
+        LOG_CRITICAL(Render, "initialization failed !");
        return false;
    }
    return true;
@@ -36,7 +36,7 @@ bool Init(EmuWindow* emu_window) {
 void Shutdown() {
    g_renderer.reset();
-    NGLOG_DEBUG(Render, "shutdown OK");
+    LOG_DEBUG(Render, "shutdown OK");
 }
 } // namespace VideoCore
diff --git a/src/yuzu/CMakeLists.txt b/src/yuzu/CMakeLists.txt
index c662570d2..7de919a8e 100644
--- a/src/yuzu/CMakeLists.txt
+++ b/src/yuzu/CMakeLists.txt
@@ -30,6 +30,8 @@ add_executable(yuzu
    debugger/graphics/graphics_breakpoints_p.h
    debugger/graphics/graphics_surface.cpp
    debugger/graphics/graphics_surface.h
+    debugger/console.cpp
+    debugger/console.h
    debugger/profiler.cpp
    debugger/profiler.h
    debugger/wait_tree.cpp
@@ -81,6 +83,14 @@ if (APPLE)
    target_sources(yuzu PRIVATE ${MACOSX_ICON})
    set_target_properties(yuzu PROPERTIES MACOSX_BUNDLE TRUE)
    set_target_properties(yuzu PROPERTIES MACOSX_BUNDLE_INFO_PLIST ${CMAKE_CURRENT_SOURCE_DIR}/Info.plist)
+elseif(WIN32)
+    # compile as a win32 gui application instead of a console application
+    target_link_libraries(yuzu PRIVATE Qt5::WinMain)
+    if(MSVC)
+        set_target_properties(yuzu PROPERTIES LINK_FLAGS_RELEASE "/SUBSYSTEM:WINDOWS")
+    elseif(MINGW)
+        set_target_properties(yuzu PROPERTIES LINK_FLAGS_RELEASE "-mwindows")
+    endif()
 endif()
 create_target_directory_groups(yuzu)
diff --git a/src/yuzu/bootmanager.cpp b/src/yuzu/bootmanager.cpp
index 5c17cd0d9..833085559 100644
--- a/src/yuzu/bootmanager.cpp
+++ b/src/yuzu/bootmanager.cpp
@@ -127,13 +127,14 @@ void GRenderWindow::moveContext() {
 }
 void GRenderWindow::SwapBuffers() {
-#if !defined(QT_NO_DEBUG)
+    // In our multi-threaded QGLWidget use case we shouldn't need to call `makeCurrent`,
-    // Qt debug runtime prints a bogus warning on the console if you haven't called makeCurrent
+    // since we never call `doneCurrent` in this thread.
-    // since the last time you called swapBuffers. This presumably means something if you're using
+    // However:
-    // QGLWidget the "regular" way, but in our multi-threaded use case is harmless since we never
+    // - The Qt debug runtime prints a bogus warning on the console if `makeCurrent` wasn't called
-    // call doneCurrent in this thread.
+    // since the last time `swapBuffers` was executed;
+    // - On macOS, if `makeCurrent` isn't called explicitely, resizing the buffer breaks.
    child->makeCurrent();
-#endif
    child->swapBuffers();
 }
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index 8316db708..a32134fbe 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -84,6 +84,8 @@ void Config::ReadValues() {
    qt_config->beginGroup("Renderer");
    Settings::values.resolution_factor = qt_config->value("resolution_factor", 1.0).toFloat();
    Settings::values.toggle_framelimit = qt_config->value("toggle_framelimit", true).toBool();
+    Settings::values.use_accurate_framebuffers =
+        qt_config->value("use_accurate_framebuffers", 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();
@@ -158,6 +160,7 @@ void Config::ReadValues() {
    UISettings::values.confirm_before_closing = qt_config->value("confirmClose", true).toBool();
    UISettings::values.first_start = qt_config->value("firstStart", true).toBool();
    UISettings::values.callout_flags = qt_config->value("calloutFlags", 0).toUInt();
+    UISettings::values.show_console = qt_config->value("showConsole", false).toBool();
    qt_config->endGroup();
 }
@@ -184,6 +187,7 @@ void Config::SaveValues() {
    qt_config->beginGroup("Renderer");
    qt_config->setValue("resolution_factor", (double)Settings::values.resolution_factor);
    qt_config->setValue("toggle_framelimit", Settings::values.toggle_framelimit);
+    qt_config->setValue("use_accurate_framebuffers", Settings::values.use_accurate_framebuffers);
    // Cast to double because Qt's written float values are not human-readable
    qt_config->setValue("bg_red", (double)Settings::values.bg_red);
@@ -243,7 +247,7 @@ void Config::SaveValues() {
    qt_config->setValue("confirmClose", UISettings::values.confirm_before_closing);
    qt_config->setValue("firstStart", UISettings::values.first_start);
    qt_config->setValue("calloutFlags", UISettings::values.callout_flags);
+    qt_config->setValue("showConsole", UISettings::values.show_console);
    qt_config->endGroup();
 }
diff --git a/src/yuzu/configuration/configure_debug.cpp b/src/yuzu/configuration/configure_debug.cpp
index a45edd510..241db4ae3 100644
--- a/src/yuzu/configuration/configure_debug.cpp
+++ b/src/yuzu/configuration/configure_debug.cpp
@@ -2,13 +2,26 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#include <QDesktopServices>
+#include <QUrl>
+#include "common/file_util.h"
+#include "common/logging/backend.h"
+#include "common/logging/filter.h"
+#include "common/logging/log.h"
+#include "core/core.h"
 #include "core/settings.h"
 #include "ui_configure_debug.h"
 #include "yuzu/configuration/configure_debug.h"
+#include "yuzu/debugger/console.h"
+#include "yuzu/ui_settings.h"
 ConfigureDebug::ConfigureDebug(QWidget* parent) : QWidget(parent), ui(new Ui::ConfigureDebug) {
    ui->setupUi(this);
    this->setConfiguration();
+    connect(ui->open_log_button, &QPushButton::pressed, []() {
+        QString path = QString::fromStdString(FileUtil::GetUserPath(D_LOGS_IDX));
+        QDesktopServices::openUrl(QUrl::fromLocalFile(path));
+    });
 }
 ConfigureDebug::~ConfigureDebug() {}
@@ -17,10 +30,19 @@ void ConfigureDebug::setConfiguration() {
    ui->toggle_gdbstub->setChecked(Settings::values.use_gdbstub);
    ui->gdbport_spinbox->setEnabled(Settings::values.use_gdbstub);
    ui->gdbport_spinbox->setValue(Settings::values.gdbstub_port);
+    ui->toggle_console->setEnabled(!Core::System::GetInstance().IsPoweredOn());
+    ui->toggle_console->setChecked(UISettings::values.show_console);
+    ui->log_filter_edit->setText(QString::fromStdString(Settings::values.log_filter));
 }
 void ConfigureDebug::applyConfiguration() {
    Settings::values.use_gdbstub = ui->toggle_gdbstub->isChecked();
    Settings::values.gdbstub_port = ui->gdbport_spinbox->value();
+    UISettings::values.show_console = ui->toggle_console->isChecked();
+    Settings::values.log_filter = ui->log_filter_edit->text().toStdString();
+    Debugger::ToggleConsole();
+    Log::Filter filter;
+    filter.ParseFilterString(Settings::values.log_filter);
+    Log::SetGlobalFilter(filter);
    Settings::Apply();
 }
diff --git a/src/yuzu/configuration/configure_debug.ui b/src/yuzu/configuration/configure_debug.ui
index a10bea2f4..118e91cf1 100644
--- a/src/yuzu/configuration/configure_debug.ui
+++ b/src/yuzu/configuration/configure_debug.ui
@@ -73,6 +73,47 @@
    </layout>
   </item>
   <item>
+    <widget class="QGroupBox" name="groupBox_2">
+     <property name="title">
+      <string>Logging</string>
+     </property>
+     <layout class="QVBoxLayout" name="verticalLayout">
+      <item>
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <item>
+         <widget class="QLabel" name="label">
+          <property name="text">
+           <string>Global Log Filter</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLineEdit" name="log_filter_edit"/>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <layout class="QHBoxLayout" name="horizontalLayout_2">
+        <item>
+         <widget class="QCheckBox" name="toggle_console">
+          <property name="text">
+           <string>Show Log Console (Windows Only)</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="open_log_button">
+          <property name="text">
+           <string>Open Log Location</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
    <spacer name="verticalSpacer">
     <property name="orientation">
      <enum>Qt::Vertical</enum>
diff --git a/src/yuzu/configuration/configure_graphics.cpp b/src/yuzu/configuration/configure_graphics.cpp
index 47b9b6e95..7664880d5 100644
--- a/src/yuzu/configuration/configure_graphics.cpp
+++ b/src/yuzu/configuration/configure_graphics.cpp
@@ -59,11 +59,13 @@ void ConfigureGraphics::setConfiguration() {
    ui->resolution_factor_combobox->setCurrentIndex(
        static_cast<int>(FromResolutionFactor(Settings::values.resolution_factor)));
    ui->toggle_framelimit->setChecked(Settings::values.toggle_framelimit);
+    ui->use_accurate_framebuffers->setChecked(Settings::values.use_accurate_framebuffers);
 }
 void ConfigureGraphics::applyConfiguration() {
    Settings::values.resolution_factor =
        ToResolutionFactor(static_cast<Resolution>(ui->resolution_factor_combobox->currentIndex()));
    Settings::values.toggle_framelimit = ui->toggle_framelimit->isChecked();
+    Settings::values.use_accurate_framebuffers = ui->use_accurate_framebuffers->isChecked();
    Settings::Apply();
 }
diff --git a/src/yuzu/configuration/configure_graphics.ui b/src/yuzu/configuration/configure_graphics.ui
index 366931a9a..7d092df03 100644
--- a/src/yuzu/configuration/configure_graphics.ui
+++ b/src/yuzu/configuration/configure_graphics.ui
@@ -30,6 +30,13 @@
         </widget>
        </item>
        <item>
+         <widget class="QCheckBox" name="use_accurate_framebuffers">
+          <property name="text">
+           <string>Use accurate framebuffers (slow)</string>
+          </property>
+         </widget>
+        </item>
+        <item>
         <layout class="QHBoxLayout" name="horizontalLayout">
          <item>
           <widget class="QLabel" name="label">
diff --git a/src/yuzu/debugger/console.cpp b/src/yuzu/debugger/console.cpp
new file mode 100644
index 000000000..e3d2d975f
--- /dev/null
+++ b/src/yuzu/debugger/console.cpp
@@ -0,0 +1,45 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#ifdef _WIN32
+#include <windows.h>
+#include <wincon.h>
+#endif
+#include "common/logging/backend.h"
+#include "yuzu/debugger/console.h"
+#include "yuzu/ui_settings.h"
+namespace Debugger {
+void ToggleConsole() {
+#if defined(_WIN32) && !defined(_DEBUG)
+    FILE* temp;
+    if (UISettings::values.show_console) {
+        if (AllocConsole()) {
+            // The first parameter for freopen_s is a out parameter, so we can just ignore it
+            freopen_s(&temp, "CONIN$", "r", stdin);
+            freopen_s(&temp, "CONOUT$", "w", stdout);
+            freopen_s(&temp, "CONOUT$", "w", stderr);
+            Log::AddBackend(std::make_unique<Log::ColorConsoleBackend>());
+        }
+    } else {
+        if (FreeConsole()) {
+            // In order to close the console, we have to also detach the streams on it.
+            // Just redirect them to NUL if there is no console window
+            Log::RemoveBackend(Log::ColorConsoleBackend::Name());
+            freopen_s(&temp, "NUL", "r", stdin);
+            freopen_s(&temp, "NUL", "w", stdout);
+            freopen_s(&temp, "NUL", "w", stderr);
+        }
+    }
+#else
+    if (UISettings::values.show_console) {
+        Log::AddBackend(std::make_unique<Log::ColorConsoleBackend>());
+    } else {
+        Log::RemoveBackend(Log::ColorConsoleBackend::Name());
+    }
+#endif
+}
+} // namespace Debugger
diff --git a/src/yuzu/debugger/console.h b/src/yuzu/debugger/console.h
new file mode 100644
index 000000000..d1990c496
--- /dev/null
+++ b/src/yuzu/debugger/console.h
@@ -0,0 +1,14 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#pragma once
+namespace Debugger {
+/**
+ * Uses the WINAPI to hide or show the stderr console. This function is a placeholder until we can
+ * get a real qt logging window which would work for all platforms.
+ */
+void ToggleConsole();
+} // namespace Debugger
+\ No newline at end of file
diff --git a/src/yuzu/game_list.cpp b/src/yuzu/game_list.cpp
index 55dce6d47..5a708dc73 100644
--- a/src/yuzu/game_list.cpp
+++ b/src/yuzu/game_list.cpp
@@ -325,8 +325,7 @@ void GameList::PopupContextMenu(const QPoint& menu_location) {
 void GameList::PopulateAsync(const QString& dir_path, bool deep_scan) {
    if (!FileUtil::Exists(dir_path.toStdString()) ||
        !FileUtil::IsDirectory(dir_path.toStdString())) {
-        NGLOG_ERROR(Frontend, "Could not find game list folder at {}",
+        LOG_ERROR(Frontend, "Could not find game list folder at {}", dir_path.toLocal8Bit().data());
-                    dir_path.toLocal8Bit().data());
        search_field->setFilterResult(0, 0);
        return;
    }
@@ -388,7 +387,7 @@ static QString FormatGameName(const std::string& physical_name) {
 void GameList::RefreshGameDirectory() {
    if (!UISettings::values.gamedir.isEmpty() && current_worker != nullptr) {
-        NGLOG_INFO(Frontend, "Change detected in the games directory. Reloading game list.");
+        LOG_INFO(Frontend, "Change detected in the games directory. Reloading game list.");
        search_field->clear();
        PopulateAsync(UISettings::values.gamedir, UISettings::values.gamedir_deepscan);
    }
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index 97be548d7..05a8ae6d2 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -31,6 +31,7 @@
 #include "yuzu/bootmanager.h"
 #include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_dialog.h"
+#include "yuzu/debugger/console.h"
 #include "yuzu/debugger/graphics/graphics_breakpoints.h"
 #include "yuzu/debugger/graphics/graphics_surface.h"
 #include "yuzu/debugger/profiler.h"
@@ -261,6 +262,7 @@ void GMainWindow::RestoreUIState() {
    ui.action_Show_Status_Bar->setChecked(UISettings::values.show_status_bar);
    statusBar()->setVisible(ui.action_Show_Status_Bar->isChecked());
+    Debugger::ToggleConsole();
 }
 void GMainWindow::ConnectWidgetEvents() {
@@ -334,13 +336,11 @@ bool GMainWindow::SupportsRequiredGLExtensions() {
        unsupported_ext.append("ARB_program_interface_query");
    if (!GLAD_GL_ARB_separate_shader_objects)
        unsupported_ext.append("ARB_separate_shader_objects");
-    if (!GLAD_GL_ARB_shader_storage_buffer_object)
-        unsupported_ext.append("ARB_shader_storage_buffer_object");
    if (!GLAD_GL_ARB_vertex_attrib_binding)
        unsupported_ext.append("ARB_vertex_attrib_binding");
    for (const QString& ext : unsupported_ext)
-        NGLOG_CRITICAL(Frontend, "Unsupported GL extension: {}", ext.toStdString());
+        LOG_CRITICAL(Frontend, "Unsupported GL extension: {}", ext.toStdString());
    return unsupported_ext.empty();
 }
@@ -377,17 +377,17 @@ bool GMainWindow::LoadROM(const QString& filename) {
    if (result != Core::System::ResultStatus::Success) {
        switch (result) {
        case Core::System::ResultStatus::ErrorGetLoader:
-            NGLOG_CRITICAL(Frontend, "Failed to obtain loader for {}!", filename.toStdString());
+            LOG_CRITICAL(Frontend, "Failed to obtain loader for {}!", filename.toStdString());
            QMessageBox::critical(this, tr("Error while loading ROM!"),
                                  tr("The ROM format is not supported."));
            break;
        case Core::System::ResultStatus::ErrorUnsupportedArch:
-            NGLOG_CRITICAL(Frontend, "Unsupported architecture detected!", filename.toStdString());
+            LOG_CRITICAL(Frontend, "Unsupported architecture detected!", filename.toStdString());
            QMessageBox::critical(this, tr("Error while loading ROM!"),
                                  tr("The ROM uses currently unusable 32-bit architecture"));
            break;
        case Core::System::ResultStatus::ErrorSystemMode:
-            NGLOG_CRITICAL(Frontend, "Failed to load ROM!");
+            LOG_CRITICAL(Frontend, "Failed to load ROM!");
            QMessageBox::critical(this, tr("Error while loading ROM!"),
                                  tr("Could not determine the system mode."));
            break;
@@ -437,7 +437,7 @@ bool GMainWindow::LoadROM(const QString& filename) {
 }
 void GMainWindow::BootGame(const QString& filename) {
-    NGLOG_INFO(Frontend, "yuzu starting...");
+    LOG_INFO(Frontend, "yuzu starting...");
    StoreRecentFile(filename); // Put the filename on top of the list
    if (!LoadROM(filename))
@@ -884,7 +884,7 @@ void GMainWindow::UpdateUITheme() {
        QString theme_uri(":" + UISettings::values.theme + "/style.qss");
        QFile f(theme_uri);
        if (!f.exists()) {
-            NGLOG_ERROR(Frontend, "Unable to set style, stylesheet file not found");
+            LOG_ERROR(Frontend, "Unable to set style, stylesheet file not found");
        } else {
            f.open(QFile::ReadOnly | QFile::Text);
            QTextStream ts(&f);
@@ -908,8 +908,7 @@ void GMainWindow::UpdateUITheme() {
 #endif
 int main(int argc, char* argv[]) {
-    Log::Filter log_filter(Log::Level::Info);
+    Log::AddBackend(std::make_unique<Log::ColorConsoleBackend>());
-    Log::SetFilter(&log_filter);
    MicroProfileOnThreadCreate("Frontend");
    SCOPE_EXIT({ MicroProfileShutdown(); });
@@ -927,7 +926,12 @@ int main(int argc, char* argv[]) {
    GMainWindow main_window;
    // After settings have been loaded by GMainWindow, apply the filter
+    Log::Filter log_filter;
    log_filter.ParseFilterString(Settings::values.log_filter);
+    Log::SetGlobalFilter(log_filter);
+    FileUtil::CreateFullPath(FileUtil::GetUserPath(D_LOGS_IDX));
+    Log::AddBackend(
+        std::make_unique<Log::FileBackend>(FileUtil::GetUserPath(D_LOGS_IDX) + LOG_FILE));
    main_window.show();
    return app.exec();
diff --git a/src/yuzu/ui_settings.h b/src/yuzu/ui_settings.h
index 8e215a002..2286c2559 100644
--- a/src/yuzu/ui_settings.h
+++ b/src/yuzu/ui_settings.h
@@ -51,6 +51,9 @@ struct Values {
    std::vector<Shortcut> shortcuts;
    uint32_t callout_flags;
+    // logging
+    bool show_console;
 };
 extern Values values;
diff --git a/src/yuzu_cmd/config.cpp b/src/yuzu_cmd/config.cpp
index ee6e4d658..3a311b69f 100644
--- a/src/yuzu_cmd/config.cpp
+++ b/src/yuzu_cmd/config.cpp
@@ -27,17 +27,17 @@ bool Config::LoadINI(const std::string& default_contents, bool retry) {
    const char* location = this->sdl2_config_loc.c_str();
    if (sdl2_config->ParseError() < 0) {
        if (retry) {
-            NGLOG_WARNING(Config, "Failed to load {}. Creating file from defaults...", location);
+            LOG_WARNING(Config, "Failed to load {}. Creating file from defaults...", location);
            FileUtil::CreateFullPath(location);
            FileUtil::WriteStringToFile(true, default_contents, location);
            sdl2_config = std::make_unique<INIReader>(location); // Reopen file
            return LoadINI(default_contents, false);
        }
-        NGLOG_ERROR(Config, "Failed.");
+        LOG_ERROR(Config, "Failed.");
        return false;
    }
-    NGLOG_INFO(Config, "Successfully loaded {}", location);
+    LOG_INFO(Config, "Successfully loaded {}", location);
    return true;
 }
@@ -98,6 +98,8 @@ void Config::ReadValues() {
        (float)sdl2_config->GetReal("Renderer", "resolution_factor", 1.0);
    Settings::values.toggle_framelimit =
        sdl2_config->GetBoolean("Renderer", "toggle_framelimit", true);
+    Settings::values.use_accurate_framebuffers =
+        sdl2_config->GetBoolean("Renderer", "use_accurate_framebuffers", 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 1c438c3f5..71d2e040f 100644
--- a/src/yuzu_cmd/default_ini.h
+++ b/src/yuzu_cmd/default_ini.h
@@ -102,6 +102,10 @@ resolution_factor =
 # 0 (default): Off, 1: On
 use_vsync =
+# Whether to use accurate framebuffers
+# 0 (default): Off (fast), 1 : On (slow)
+use_accurate_framebuffers =
 # 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.
 bg_red =
@@ -162,7 +166,7 @@ use_virtual_sd =
 # 1 (default): Yes, 0: No
 use_docked_mode =
-# The system region that Citra will use during emulation
+# The system region that yuzu will use during emulation
 # -1: Auto-select (default), 0: Japan, 1: USA, 2: Europe, 3: Australia, 4: China, 5: Korea, 6: Taiwan
 region_value =
diff --git a/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp b/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
index cfd8eb7e6..e6f0bbe8f 100644
--- a/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
+++ b/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
@@ -62,19 +62,19 @@ void EmuWindow_SDL2::Fullscreen() {
        return;
    }
-    NGLOG_ERROR(Frontend, "Fullscreening failed: {}", SDL_GetError());
+    LOG_ERROR(Frontend, "Fullscreening failed: {}", SDL_GetError());
    // Try a different fullscreening method
-    NGLOG_INFO(Frontend, "Attempting to use borderless fullscreen...");
+    LOG_INFO(Frontend, "Attempting to use borderless fullscreen...");
    if (SDL_SetWindowFullscreen(render_window, SDL_WINDOW_FULLSCREEN_DESKTOP) == 0) {
        return;
    }
-    NGLOG_ERROR(Frontend, "Borderless fullscreening failed: {}", SDL_GetError());
+    LOG_ERROR(Frontend, "Borderless fullscreening failed: {}", SDL_GetError());
    // Fallback algorithm: Maximise window.
    // Works on all systems (unless something is seriously wrong), so no fallback for this one.
-    NGLOG_INFO(Frontend, "Falling back on a maximised window...");
+    LOG_INFO(Frontend, "Falling back on a maximised window...");
    SDL_MaximizeWindow(render_window);
 }
@@ -91,7 +91,7 @@ bool EmuWindow_SDL2::SupportsRequiredGLExtensions() {
        unsupported_ext.push_back("ARB_vertex_attrib_binding");
    for (const std::string& ext : unsupported_ext)
-        NGLOG_CRITICAL(Frontend, "Unsupported GL extension: {}", ext);
+        LOG_CRITICAL(Frontend, "Unsupported GL extension: {}", ext);
    return unsupported_ext.empty();
 }
@@ -103,7 +103,7 @@ EmuWindow_SDL2::EmuWindow_SDL2(bool fullscreen) {
    // Initialize the window
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
-        NGLOG_CRITICAL(Frontend, "Failed to initialize SDL2! Exiting...");
+        LOG_CRITICAL(Frontend, "Failed to initialize SDL2! Exiting...");
        exit(1);
    }
@@ -126,7 +126,7 @@ EmuWindow_SDL2::EmuWindow_SDL2(bool fullscreen) {
                         SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
    if (render_window == nullptr) {
-        NGLOG_CRITICAL(Frontend, "Failed to create SDL2 window! Exiting...");
+        LOG_CRITICAL(Frontend, "Failed to create SDL2 window! Exiting...");
        exit(1);
    }
@@ -137,17 +137,17 @@ EmuWindow_SDL2::EmuWindow_SDL2(bool fullscreen) {
    gl_context = SDL_GL_CreateContext(render_window);
    if (gl_context == nullptr) {
-        NGLOG_CRITICAL(Frontend, "Failed to create SDL2 GL context! Exiting...");
+        LOG_CRITICAL(Frontend, "Failed to create SDL2 GL context! Exiting...");
        exit(1);
    }
    if (!gladLoadGLLoader(static_cast<GLADloadproc>(SDL_GL_GetProcAddress))) {
-        NGLOG_CRITICAL(Frontend, "Failed to initialize GL functions! Exiting...");
+        LOG_CRITICAL(Frontend, "Failed to initialize GL functions! Exiting...");
        exit(1);
    }
    if (!SupportsRequiredGLExtensions()) {
-        NGLOG_CRITICAL(Frontend, "GPU does not support all required OpenGL extensions! Exiting...");
+        LOG_CRITICAL(Frontend, "GPU does not support all required OpenGL extensions! Exiting...");
        exit(1);
    }
diff --git a/src/yuzu_cmd/yuzu.cpp b/src/yuzu_cmd/yuzu.cpp
index 95e568b7b..8ddd202d8 100644
--- a/src/yuzu_cmd/yuzu.cpp
+++ b/src/yuzu_cmd/yuzu.cpp
@@ -7,6 +7,7 @@
 #include <string>
 #include <thread>
+#include "common/common_paths.h"
 #include "common/logging/backend.h"
 #include "common/logging/filter.h"
 #include "common/logging/log.h"
@@ -69,7 +70,7 @@ int main(int argc, char** argv) {
    auto argv_w = CommandLineToArgvW(GetCommandLineW(), &argc_w);
    if (argv_w == nullptr) {
-        NGLOG_CRITICAL(Frontend, "Failed to get command line arguments");
+        LOG_CRITICAL(Frontend, "Failed to get command line arguments");
        return -1;
    }
 #endif
@@ -102,7 +103,7 @@ int main(int argc, char** argv) {
                break;
            case 'f':
                fullscreen = true;
-                NGLOG_INFO(Frontend, "Starting in fullscreen mode...");
+                LOG_INFO(Frontend, "Starting in fullscreen mode...");
                break;
            case 'h':
                PrintHelp(argv[0]);
@@ -126,13 +127,18 @@ int main(int argc, char** argv) {
 #endif
    Log::Filter log_filter(Log::Level::Debug);
-    Log::SetFilter(&log_filter);
+    Log::SetGlobalFilter(log_filter);
+    Log::AddBackend(std::make_unique<Log::ColorConsoleBackend>());
+    FileUtil::CreateFullPath(FileUtil::GetUserPath(D_LOGS_IDX));
+    Log::AddBackend(
+        std::make_unique<Log::FileBackend>(FileUtil::GetUserPath(D_LOGS_IDX) + LOG_FILE));
    MicroProfileOnThreadCreate("EmuThread");
    SCOPE_EXIT({ MicroProfileShutdown(); });
    if (filepath.empty()) {
-        NGLOG_CRITICAL(Frontend, "Failed to load ROM: No ROM specified");
+        LOG_CRITICAL(Frontend, "Failed to load ROM: No ROM specified");
        return -1;
    }
@@ -153,28 +159,28 @@ int main(int argc, char** argv) {
    switch (load_result) {
    case Core::System::ResultStatus::ErrorGetLoader:
-        NGLOG_CRITICAL(Frontend, "Failed to obtain loader for %s!", filepath.c_str());
+        LOG_CRITICAL(Frontend, "Failed to obtain loader for %s!", filepath.c_str());
        return -1;
    case Core::System::ResultStatus::ErrorLoader:
-        NGLOG_CRITICAL(Frontend, "Failed to load ROM!");
+        LOG_CRITICAL(Frontend, "Failed to load ROM!");
        return -1;
    case Core::System::ResultStatus::ErrorLoader_ErrorEncrypted:
-        NGLOG_CRITICAL(Frontend, "The game that you are trying to load must be decrypted before "
+        LOG_CRITICAL(Frontend, "The game that you are trying to load must be decrypted before "
-                                 "being used with yuzu. \n\n For more information on dumping and "
+                               "being used with yuzu. \n\n For more information on dumping and "
-                                 "decrypting games, please refer to: "
+                               "decrypting games, please refer to: "
-                                 "https://yuzu-emu.org/wiki/dumping-game-cartridges/");
+                               "https://yuzu-emu.org/wiki/dumping-game-cartridges/");
        return -1;
    case Core::System::ResultStatus::ErrorLoader_ErrorInvalidFormat:
-        NGLOG_CRITICAL(Frontend, "Error while loading ROM: The ROM format is not supported.");
+        LOG_CRITICAL(Frontend, "Error while loading ROM: The ROM format is not supported.");
        return -1;
    case Core::System::ResultStatus::ErrorNotInitialized:
-        NGLOG_CRITICAL(Frontend, "CPUCore not initialized");
+        LOG_CRITICAL(Frontend, "CPUCore not initialized");
        return -1;
    case Core::System::ResultStatus::ErrorSystemMode:
-        NGLOG_CRITICAL(Frontend, "Failed to determine system mode!");
+        LOG_CRITICAL(Frontend, "Failed to determine system mode!");
        return -1;
    case Core::System::ResultStatus::ErrorVideoCore:
-        NGLOG_CRITICAL(Frontend, "VideoCore not initialized");
+        LOG_CRITICAL(Frontend, "VideoCore not initialized");
        return -1;
    case Core::System::ResultStatus::Success:
        break; // Expected case