201 files changed, 1444 insertions, 1669 deletions
diff --git a/.ci/scripts/linux/docker.sh b/.ci/scripts/linux/docker.sh
index 05f6ffe7d..e0c018cfd 100755
--- a/.ci/scripts/linux/docker.sh
+++ b/.ci/scripts/linux/docker.sh
@@ -5,7 +5,7 @@ cd /yuzu
 ccache -s
 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DYUZU_USE_BUNDLED_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON
+cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON
 ninja
diff --git a/.ci/scripts/windows/docker.sh b/.ci/scripts/windows/docker.sh
index adfd636fa..2bc9f36ab 100755
--- a/.ci/scripts/windows/docker.sh
+++ b/.ci/scripts/windows/docker.sh
@@ -5,7 +5,7 @@ cd /yuzu
 ccache -s
 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_QT_TRANSLATION=ON
+cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_QT_TRANSLATION=ON
 ninja
 ccache -s
diff --git a/.ci/templates/build-msvc.yml b/.ci/templates/build-msvc.yml
index 0b4bbd341..33ff8201f 100644
--- a/.ci/templates/build-msvc.yml
+++ b/.ci/templates/build-msvc.yml
@@ -8,7 +8,7 @@ steps:
  displayName: 'Install vulkan-sdk'
 - script: python -m pip install --upgrade pip conan
  displayName: 'Install conan'
- script: refreshenv && mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 --config Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cd ..
+- script: refreshenv && mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 --config Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cd ..
  displayName: 'Configure CMake'
 - task: MSBuild@1
  displayName: 'Build'
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 273260378..2316f7684 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -113,6 +113,9 @@ if (NOT DEFINED ARCHITECTURE)
 endif()
 message(STATUS "Target architecture: ${ARCHITECTURE}")
+if (UNIX)
+    add_definitions(-DYUZU_UNIX=1)
+endif()
 # Configure C++ standard
 # ===========================
diff --git a/externals/cubeb b/externals/cubeb
-Subproject 616d773441b5355800ce64197a699e6cd6b3617
+Subproject 1d66483ad2b93f0e00e175f9480c771af90003a
diff --git a/src/audio_core/cubeb_sink.cpp b/src/audio_core/cubeb_sink.cpp
index cf7b186e4..043447eaa 100644
--- a/src/audio_core/cubeb_sink.cpp
+++ b/src/audio_core/cubeb_sink.cpp
@@ -30,6 +30,7 @@ public:
        params.rate = sample_rate;
        params.channels = num_channels;
        params.format = CUBEB_SAMPLE_S16NE;
+        params.prefs = CUBEB_STREAM_PREF_PERSIST;
        switch (num_channels) {
        case 1:
            params.layout = CUBEB_LAYOUT_MONO;
diff --git a/src/common/file_util.cpp b/src/common/file_util.cpp
index 18fbfa25b..a286b9341 100644
--- a/src/common/file_util.cpp
+++ b/src/common/file_util.cpp
@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 #include <array>
+#include <filesystem>
 #include <limits>
 #include <memory>
 #include <sstream>
@@ -67,290 +68,128 @@
 #include <algorithm>
 #include <sys/stat.h>
-#ifndef S_ISDIR
-#define S_ISDIR(m) (((m)&S_IFMT) == S_IFDIR)
-#endif
-// This namespace has various generic functions related to files and paths.
-// The code still needs a ton of cleanup.
-// REMEMBER: strdup considered harmful!
 namespace Common::FS {
+namespace fs = std::filesystem;
-// Remove any ending forward slashes from directory paths
+bool Exists(const fs::path& path) {
-// Modifies argument.
+    std::error_code ec;
-static void StripTailDirSlashes(std::string& fname) {
+    return fs::exists(path, ec);
-    if (fname.length() <= 1) {
-        return;
-    }
-    std::size_t i = fname.length();
-    while (i > 0 && fname[i - 1] == DIR_SEP_CHR) {
-        --i;
-    }
-    fname.resize(i);
 }
-bool Exists(const std::string& filename) {
+bool IsDirectory(const fs::path& path) {
-    struct stat file_info;
+    std::error_code ec;
+    return fs::is_directory(path, ec);
-    std::string copy(filename);
-    StripTailDirSlashes(copy);
-#ifdef _WIN32
-    // Windows needs a slash to identify a driver root
-    if (copy.size() != 0 && copy.back() == ':')
-        copy += DIR_SEP_CHR;
-    int result = _wstat64(Common::UTF8ToUTF16W(copy).c_str(), &file_info);
-#else
-    int result = stat(copy.c_str(), &file_info);
-#endif
-    return (result == 0);
 }
-bool IsDirectory(const std::string& filename) {
+bool Delete(const fs::path& path) {
-    struct stat file_info;
+    LOG_TRACE(Common_Filesystem, "file {}", path.string());
-    std::string copy(filename);
-    StripTailDirSlashes(copy);
-#ifdef _WIN32
+    // Return true because we care about the file no
-    // Windows needs a slash to identify a driver root
+    // being there, not the actual delete.
-    if (copy.size() != 0 && copy.back() == ':')
+    if (!Exists(path)) {
-        copy += DIR_SEP_CHR;
+        LOG_DEBUG(Common_Filesystem, "{} does not exist", path.string());
+        return true;
-    int result = _wstat64(Common::UTF8ToUTF16W(copy).c_str(), &file_info);
-#else
-    int result = stat(copy.c_str(), &file_info);
-#endif
-    if (result < 0) {
-        LOG_DEBUG(Common_Filesystem, "stat failed on {}: {}", filename, GetLastErrorMsg());
-        return false;
    }
-    return S_ISDIR(file_info.st_mode);
+    std::error_code ec;
+    return fs::remove(path, ec);
 }
-bool Delete(const std::string& filename) {
+bool CreateDir(const fs::path& path) {
-    LOG_TRACE(Common_Filesystem, "file {}", filename);
+    LOG_TRACE(Common_Filesystem, "directory {}", path.string());
-    // Return true because we care about the file no
+    if (Exists(path)) {
-    // being there, not the actual delete.
+        LOG_DEBUG(Common_Filesystem, "path exists {}", path.string());
-    if (!Exists(filename)) {
-        LOG_DEBUG(Common_Filesystem, "{} does not exist", filename);
        return true;
    }
-    // We can't delete a directory
+    std::error_code ec;
-    if (IsDirectory(filename)) {
+    const bool success = fs::create_directory(path, ec);
-        LOG_ERROR(Common_Filesystem, "Failed: {} is a directory", filename);
-        return false;
-    }
-#ifdef _WIN32
+    if (!success) {
-    if (!DeleteFileW(Common::UTF8ToUTF16W(filename).c_str())) {
+        LOG_ERROR(Common_Filesystem, "Unable to create directory: {}", ec.message());
-        LOG_ERROR(Common_Filesystem, "DeleteFile failed on {}: {}", filename, GetLastErrorMsg());
-        return false;
-    }
-#else
-    if (unlink(filename.c_str()) == -1) {
-        LOG_ERROR(Common_Filesystem, "unlink failed on {}: {}", filename, GetLastErrorMsg());
        return false;
    }
-#endif
    return true;
 }
-bool CreateDir(const std::string& path) {
+bool CreateDirs(const fs::path& path) {
-    LOG_TRACE(Common_Filesystem, "directory {}", path);
+    LOG_TRACE(Common_Filesystem, "path {}", path.string());
-#ifdef _WIN32
-    if (::CreateDirectoryW(Common::UTF8ToUTF16W(path).c_str(), nullptr))
-        return true;
-    DWORD error = GetLastError();
-    if (error == ERROR_ALREADY_EXISTS) {
-        LOG_DEBUG(Common_Filesystem, "CreateDirectory failed on {}: already exists", path);
-        return true;
-    }
-    LOG_ERROR(Common_Filesystem, "CreateDirectory failed on {}: {}", path, error);
-    return false;
-#else
-    if (mkdir(path.c_str(), 0755) == 0)
-        return true;
-    int err = errno;
-    if (err == EEXIST) {
+    if (Exists(path)) {
-        LOG_DEBUG(Common_Filesystem, "mkdir failed on {}: already exists", path);
+        LOG_DEBUG(Common_Filesystem, "path exists {}", path.string());
        return true;
    }
-    LOG_ERROR(Common_Filesystem, "mkdir failed on {}: {}", path, strerror(err));
+    std::error_code ec;
-    return false;
+    const bool success = fs::create_directories(path, ec);
-#endif
-}
-bool CreateFullPath(const std::string& fullPath) {
+    if (!success) {
-    int panicCounter = 100;
+        LOG_ERROR(Common_Filesystem, "Unable to create directories: {}", ec.message());
-    LOG_TRACE(Common_Filesystem, "path {}", fullPath);
+        return false;
-    if (Exists(fullPath)) {
-        LOG_DEBUG(Common_Filesystem, "path exists {}", fullPath);
-        return true;
    }
-    std::size_t position = 0;
+    return true;
-    while (true) {
+}
-        // Find next sub path
-        position = fullPath.find(DIR_SEP_CHR, position);
-        // we're done, yay!
+bool CreateFullPath(const fs::path& path) {
-        if (position == fullPath.npos)
+    LOG_TRACE(Common_Filesystem, "path {}", path);
-            return true;
-        // Include the '/' so the first call is CreateDir("/") rather than CreateDir("")
+    // Removes trailing slashes and turns any '\' into '/'
-        std::string const subPath(fullPath.substr(0, position + 1));
+    const auto new_path = SanitizePath(path.string(), DirectorySeparator::ForwardSlash);
-        if (!IsDirectory(subPath) && !CreateDir(subPath)) {
-            LOG_ERROR(Common, "CreateFullPath: directory creation failed");
-            return false;
-        }
-        // A safety check
+    if (new_path.rfind('.') == std::string::npos) {
-        panicCounter--;
+        // The path is a directory
-        if (panicCounter <= 0) {
+        return CreateDirs(new_path);
-            LOG_ERROR(Common, "CreateFullPath: directory structure is too deep");
+    } else {
-            return false;
+        // The path is a file
-        }
+        // Creates directory preceding the last '/'
-        position++;
+        return CreateDirs(new_path.substr(0, new_path.rfind('/')));
    }
 }
-bool DeleteDir(const std::string& filename) {
+bool Rename(const fs::path& src, const fs::path& dst) {
-    LOG_TRACE(Common_Filesystem, "directory {}", filename);
+    LOG_TRACE(Common_Filesystem, "{} --> {}", src.string(), dst.string());
-    // check if a directory
+    std::error_code ec;
-    if (!IsDirectory(filename)) {
+    fs::rename(src, dst, ec);
-        LOG_ERROR(Common_Filesystem, "Not a directory {}", filename);
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Unable to rename file from {} to {}: {}", src.string(),
+                  dst.string(), ec.message());
        return false;
    }
-#ifdef _WIN32
+    return true;
-    if (::RemoveDirectoryW(Common::UTF8ToUTF16W(filename).c_str()))
-        return true;
-#else
-    if (rmdir(filename.c_str()) == 0)
-        return true;
-#endif
-    LOG_ERROR(Common_Filesystem, "failed {}: {}", filename, GetLastErrorMsg());
-    return false;
-}
-bool Rename(const std::string& srcFilename, const std::string& destFilename) {
-    LOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
-#ifdef _WIN32
-    if (_wrename(Common::UTF8ToUTF16W(srcFilename).c_str(),
-                 Common::UTF8ToUTF16W(destFilename).c_str()) == 0)
-        return true;
-#else
-    if (rename(srcFilename.c_str(), destFilename.c_str()) == 0)
-        return true;
-#endif
-    LOG_ERROR(Common_Filesystem, "failed {} --> {}: {}", srcFilename, destFilename,
-              GetLastErrorMsg());
-    return false;
 }
-bool Copy(const std::string& srcFilename, const std::string& destFilename) {
+bool Copy(const fs::path& src, const fs::path& dst) {
-    LOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
+    LOG_TRACE(Common_Filesystem, "{} --> {}", src.string(), dst.string());
-#ifdef _WIN32
-    if (CopyFileW(Common::UTF8ToUTF16W(srcFilename).c_str(),
-                  Common::UTF8ToUTF16W(destFilename).c_str(), FALSE))
-        return true;
-    LOG_ERROR(Common_Filesystem, "failed {} --> {}: {}", srcFilename, destFilename,
+    std::error_code ec;
-              GetLastErrorMsg());
+    const bool success = fs::copy_file(src, dst, fs::copy_options::overwrite_existing, ec);
-    return false;
-#else
-    using CFilePointer = std::unique_ptr<FILE, decltype(&std::fclose)>;
-    // Open input file
+    if (!success) {
-    CFilePointer input{fopen(srcFilename.c_str(), "rb"), std::fclose};
+        LOG_ERROR(Common_Filesystem, "Unable to copy file {} to {}: {}", src.string(), dst.string(),
-    if (!input) {
+                  ec.message());
-        LOG_ERROR(Common_Filesystem, "opening input failed {} --> {}: {}", srcFilename,
-                  destFilename, GetLastErrorMsg());
        return false;
    }
-    // open output file
-    CFilePointer output{fopen(destFilename.c_str(), "wb"), std::fclose};
-    if (!output) {
-        LOG_ERROR(Common_Filesystem, "opening output failed {} --> {}: {}", srcFilename,
-                  destFilename, GetLastErrorMsg());
-        return false;
-    }
-    // copy loop
-    std::array<char, 1024> buffer;
-    while (!feof(input.get())) {
-        // read input
-        std::size_t rnum = fread(buffer.data(), sizeof(char), buffer.size(), input.get());
-        if (rnum != buffer.size()) {
-            if (ferror(input.get()) != 0) {
-                LOG_ERROR(Common_Filesystem, "failed reading from source, {} --> {}: {}",
-                          srcFilename, destFilename, GetLastErrorMsg());
-                return false;
-            }
-        }
-        // write output
-        std::size_t wnum = fwrite(buffer.data(), sizeof(char), rnum, output.get());
-        if (wnum != rnum) {
-            LOG_ERROR(Common_Filesystem, "failed writing to output, {} --> {}: {}", srcFilename,
-                      destFilename, GetLastErrorMsg());
-            return false;
-        }
-    }
    return true;
-#endif
 }
-u64 GetSize(const std::string& filename) {
+u64 GetSize(const fs::path& path) {
-    if (!Exists(filename)) {
+    std::error_code ec;
-        LOG_ERROR(Common_Filesystem, "failed {}: No such file", filename);
+    const auto size = fs::file_size(path, ec);
-        return 0;
-    }
-    if (IsDirectory(filename)) {
+    if (ec) {
-        LOG_ERROR(Common_Filesystem, "failed {}: is a directory", filename);
+        LOG_ERROR(Common_Filesystem, "Unable to retrieve file size ({}): {}", path.string(),
+                  ec.message());
        return 0;
    }
-    struct stat buf;
+    return size;
-#ifdef _WIN32
-    if (_wstat64(Common::UTF8ToUTF16W(filename).c_str(), &buf) == 0)
-#else
-    if (stat(filename.c_str(), &buf) == 0)
-#endif
-    {
-        LOG_TRACE(Common_Filesystem, "{}: {}", filename, buf.st_size);
-        return buf.st_size;
-    }
-    LOG_ERROR(Common_Filesystem, "Stat failed {}: {}", filename, GetLastErrorMsg());
-    return 0;
-}
-u64 GetSize(const int fd) {
-    struct stat buf;
-    if (fstat(fd, &buf) != 0) {
-        LOG_ERROR(Common_Filesystem, "GetSize: stat failed {}: {}", fd, GetLastErrorMsg());
-        return 0;
-    }
-    return buf.st_size;
 }
 u64 GetSize(FILE* f) {
@@ -400,7 +239,7 @@ bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
    }
    // windows loop
    do {
-        const std::string virtual_name(Common::UTF16ToUTF8(ffd.cFileName));
+        const std::string virtual_name = std::filesystem::path(ffd.cFileName).string();
 #else
    DIR* dirp = opendir(directory.c_str());
    if (!dirp)
@@ -438,132 +277,58 @@ bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
    return true;
 }
-u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
+bool DeleteDirRecursively(const fs::path& path) {
-                      unsigned int recursion) {
+    std::error_code ec;
-    const auto callback = [recursion, &parent_entry](u64* num_entries_out,
+    fs::remove_all(path, ec);
-                                                     const std::string& directory,
-                                                     const std::string& virtual_name) -> bool {
-        FSTEntry entry;
-        entry.virtualName = virtual_name;
-        entry.physicalName = directory + DIR_SEP + virtual_name;
-        if (IsDirectory(entry.physicalName)) {
-            entry.isDirectory = true;
-            // is a directory, lets go inside if we didn't recurse to often
-            if (recursion > 0) {
-                entry.size = ScanDirectoryTree(entry.physicalName, entry, recursion - 1);
-                *num_entries_out += entry.size;
-            } else {
-                entry.size = 0;
-            }
-        } else { // is a file
-            entry.isDirectory = false;
-            entry.size = GetSize(entry.physicalName);
-        }
-        (*num_entries_out)++;
-        // Push into the tree
-        parent_entry.children.push_back(std::move(entry));
-        return true;
-    };
-    u64 num_entries;
-    return ForeachDirectoryEntry(&num_entries, directory, callback) ? num_entries : 0;
-}
-bool DeleteDirRecursively(const std::string& directory, unsigned int recursion) {
-    const auto callback = [recursion](u64*, const std::string& directory,
-                                      const std::string& virtual_name) {
-        const std::string new_path = directory + DIR_SEP_CHR + virtual_name;
-        if (IsDirectory(new_path)) {
+    if (ec) {
-            if (recursion == 0) {
+        LOG_ERROR(Common_Filesystem, "Unable to completely delete directory {}: {}", path.string(),
-                return false;
+                  ec.message());
-            }
-            return DeleteDirRecursively(new_path, recursion - 1);
-        }
-        return Delete(new_path);
-    };
-    if (!ForeachDirectoryEntry(nullptr, directory, callback))
        return false;
+    }
-    // Delete the outermost directory
-    DeleteDir(directory);
    return true;
 }
-void CopyDir([[maybe_unused]] const std::string& source_path,
+void CopyDir(const fs::path& src, const fs::path& dst) {
-             [[maybe_unused]] const std::string& dest_path) {
+    constexpr auto copy_flags = fs::copy_options::skip_existing | fs::copy_options::recursive;
-#ifndef _WIN32
-    if (source_path == dest_path) {
+    std::error_code ec;
-        return;
+    fs::copy(src, dst, copy_flags, ec);
-    }
-    if (!Exists(source_path)) {
-        return;
-    }
-    if (!Exists(dest_path)) {
-        CreateFullPath(dest_path);
-    }
-    DIR* dirp = opendir(source_path.c_str());
+    if (ec) {
-    if (!dirp) {
+        LOG_ERROR(Common_Filesystem, "Error copying directory {} to {}: {}", src.string(),
+                  dst.string(), ec.message());
        return;
    }
-    while (struct dirent* result = readdir(dirp)) {
+    LOG_TRACE(Common_Filesystem, "Successfully copied directory.");
-        const std::string virtualName(result->d_name);
-        // check for "." and ".."
-        if (((virtualName[0] == '.') && (virtualName[1] == '\0')) ||
-            ((virtualName[0] == '.') && (virtualName[1] == '.') && (virtualName[2] == '\0'))) {
-            continue;
-        }
-        std::string source, dest;
-        source = source_path + virtualName;
-        dest = dest_path + virtualName;
-        if (IsDirectory(source)) {
-            source += '/';
-            dest += '/';
-            if (!Exists(dest)) {
-                CreateFullPath(dest);
-            }
-            CopyDir(source, dest);
-        } else if (!Exists(dest)) {
-            Copy(source, dest);
-        }
-    }
-    closedir(dirp);
-#endif
 }
-std::optional<std::string> GetCurrentDir() {
+std::optional<fs::path> GetCurrentDir() {
-// Get the current working directory (getcwd uses malloc)
+    std::error_code ec;
-#ifdef _WIN32
+    auto path = fs::current_path(ec);
-    wchar_t* dir = _wgetcwd(nullptr, 0);
-    if (!dir) {
+    if (ec) {
-#else
+        LOG_ERROR(Common_Filesystem, "Unable to retrieve current working directory: {}",
-    char* dir = getcwd(nullptr, 0);
+                  ec.message());
-    if (!dir) {
-#endif
-        LOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: {}", GetLastErrorMsg());
        return std::nullopt;
    }
-#ifdef _WIN32
-    std::string strDir = Common::UTF16ToUTF8(dir);
+    return {std::move(path)};
-#else
-    std::string strDir = dir;
-#endif
-    free(dir);
-    return strDir;
 }
-bool SetCurrentDir(const std::string& directory) {
+bool SetCurrentDir(const fs::path& path) {
-#ifdef _WIN32
+    std::error_code ec;
-    return _wchdir(Common::UTF8ToUTF16W(directory).c_str()) == 0;
+    fs::current_path(path, ec);
-#else
-    return chdir(directory.c_str()) == 0;
+    if (ec) {
-#endif
+        LOG_ERROR(Common_Filesystem, "Unable to set {} as working directory: {}", path.string(),
+                  ec.message());
+        return false;
+    }
+    return true;
 }
 #if defined(__APPLE__)
diff --git a/src/common/file_util.h b/src/common/file_util.h
index 840cde2a6..cf006cc9d 100644
--- a/src/common/file_util.h
+++ b/src/common/file_util.h
@@ -6,6 +6,7 @@
 #include <array>
 #include <cstdio>
+#include <filesystem>
 #include <fstream>
 #include <functional>
 #include <limits>
@@ -38,48 +39,40 @@ enum class UserPath {
    UserDir,
 };
-// FileSystem tree node/
+// Returns true if the path exists
-struct FSTEntry {
+[[nodiscard]] bool Exists(const std::filesystem::path& path);
-    bool isDirectory;
-    u64 size;                 // file length or number of entries from children
-    std::string physicalName; // name on disk
-    std::string virtualName;  // name in FST names table
-    std::vector<FSTEntry> children;
-};
-// Returns true if file filename exists
-[[nodiscard]] bool Exists(const std::string& filename);
-// Returns true if filename is a directory
+// Returns true if path is a directory
-[[nodiscard]] bool IsDirectory(const std::string& filename);
+[[nodiscard]] bool IsDirectory(const std::filesystem::path& path);
 // Returns the size of filename (64bit)
-[[nodiscard]] u64 GetSize(const std::string& filename);
+[[nodiscard]] u64 GetSize(const std::filesystem::path& path);
-// Overloaded GetSize, accepts file descriptor
-[[nodiscard]] u64 GetSize(int fd);
 // Overloaded GetSize, accepts FILE*
 [[nodiscard]] u64 GetSize(FILE* f);
 // Returns true if successful, or path already exists.
-bool CreateDir(const std::string& filename);
+bool CreateDir(const std::filesystem::path& path);
-// Creates the full path of fullPath returns true on success
+// Create all directories in path
-bool CreateFullPath(const std::string& fullPath);
+// Returns true if successful, or path already exists.
+[[nodiscard("Directory creation can fail and must be tested")]] bool CreateDirs(
+    const std::filesystem::path& path);
-// Deletes a given filename, return true on success
+// Creates directories in path. Returns true on success.
-// Doesn't supports deleting a directory
+[[deprecated("This function is deprecated, use CreateDirs")]] bool CreateFullPath(
-bool Delete(const std::string& filename);
+    const std::filesystem::path& path);
-// Deletes a directory filename, returns true on success
+// Deletes a given file at the path.
-bool DeleteDir(const std::string& filename);
+// This will also delete empty directories.
+// Return true on success
+bool Delete(const std::filesystem::path& path);
-// renames file srcFilename to destFilename, returns true on success
+// Renames file src to dst, returns true on success
-bool Rename(const std::string& srcFilename, const std::string& destFilename);
+bool Rename(const std::filesystem::path& src, const std::filesystem::path& dst);
-// copies file srcFilename to destFilename, returns true on success
+// copies file src to dst, returns true on success
-bool Copy(const std::string& srcFilename, const std::string& destFilename);
+bool Copy(const std::filesystem::path& src, const std::filesystem::path& dst);
 // creates an empty file filename, returns true on success
 bool CreateEmptyFile(const std::string& filename);
@@ -106,27 +99,17 @@ using DirectoryEntryCallable = std::function<bool(
 bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
                           DirectoryEntryCallable callback);
-/**
+// Deletes the given path and anything under it. Returns true on success.
- * Scans the directory tree, storing the results.
+bool DeleteDirRecursively(const std::filesystem::path& path);
- * @param directory the parent directory to start scanning from
- * @param parent_entry FSTEntry where the filesystem tree results will be stored.
- * @param recursion Number of children directories to read before giving up.
- * @return the total number of files/directories found
- */
-u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
-                      unsigned int recursion = 0);
-// deletes the given directory and anything under it. Returns true on success.
-bool DeleteDirRecursively(const std::string& directory, unsigned int recursion = 256);
 // Returns the current directory
-[[nodiscard]] std::optional<std::string> GetCurrentDir();
+[[nodiscard]] std::optional<std::filesystem::path> GetCurrentDir();
 // Create directory and copy contents (does not overwrite existing files)
-void CopyDir(const std::string& source_path, const std::string& dest_path);
+void CopyDir(const std::filesystem::path& src, const std::filesystem::path& dst);
-// Set the current directory to given directory
+// Set the current directory to given path
-bool SetCurrentDir(const std::string& directory);
+bool SetCurrentDir(const std::filesystem::path& path);
 // Returns a pointer to a string with a yuzu data dir in the user's home
 // directory. To be used in "multi-user" mode (that is, installed).
diff --git a/src/common/scope_exit.h b/src/common/scope_exit.h
index 68ef5f197..fa46cb394 100644
--- a/src/common/scope_exit.h
+++ b/src/common/scope_exit.h
@@ -10,7 +10,7 @@
 namespace detail {
 template <typename Func>
 struct ScopeExitHelper {
-    explicit ScopeExitHelper(Func&& func) : func(std::move(func)) {}
+    explicit ScopeExitHelper(Func&& func_) : func(std::move(func_)) {}
    ~ScopeExitHelper() {
        if (active) {
            func();
diff --git a/src/common/telemetry.h b/src/common/telemetry.h
index a50c5d1de..49186e848 100644
--- a/src/common/telemetry.h
+++ b/src/common/telemetry.h
@@ -52,8 +52,8 @@ public:
 template <typename T>
 class Field : public FieldInterface {
 public:
-    Field(FieldType type, std::string name, T value)
+    Field(FieldType type_, std::string name_, T value_)
-        : name(std::move(name)), type(type), value(std::move(value)) {}
+        : name(std::move(name_)), type(type_), value(std::move(value_)) {}
    Field(const Field&) = default;
    Field& operator=(const Field&) = default;
diff --git a/src/common/x64/xbyak_abi.h b/src/common/x64/xbyak_abi.h
index 26e4bfda5..c2c9b6134 100644
--- a/src/common/x64/xbyak_abi.h
+++ b/src/common/x64/xbyak_abi.h
@@ -11,25 +11,25 @@
 namespace Common::X64 {
-constexpr std::size_t RegToIndex(const Xbyak::Reg& reg) {
+constexpr size_t RegToIndex(const Xbyak::Reg& reg) {
    using Kind = Xbyak::Reg::Kind;
    ASSERT_MSG((reg.getKind() & (Kind::REG | Kind::XMM)) != 0,
               "RegSet only support GPRs and XMM registers.");
    ASSERT_MSG(reg.getIdx() < 16, "RegSet only supports XXM0-15.");
-    return reg.getIdx() + (reg.getKind() == Kind::REG ? 0 : 16);
+    return static_cast<size_t>(reg.getIdx()) + (reg.getKind() == Kind::REG ? 0 : 16);
 }
-constexpr Xbyak::Reg64 IndexToReg64(std::size_t reg_index) {
+constexpr Xbyak::Reg64 IndexToReg64(size_t reg_index) {
    ASSERT(reg_index < 16);
    return Xbyak::Reg64(static_cast<int>(reg_index));
 }
-constexpr Xbyak::Xmm IndexToXmm(std::size_t reg_index) {
+constexpr Xbyak::Xmm IndexToXmm(size_t reg_index) {
    ASSERT(reg_index >= 16 && reg_index < 32);
    return Xbyak::Xmm(static_cast<int>(reg_index - 16));
 }
-constexpr Xbyak::Reg IndexToReg(std::size_t reg_index) {
+constexpr Xbyak::Reg IndexToReg(size_t reg_index) {
    if (reg_index < 16) {
        return IndexToReg64(reg_index);
    } else {
@@ -182,7 +182,7 @@ inline size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::b
                                              size_t rsp_alignment, size_t needed_frame_size = 0) {
    auto frame_info = ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size);
-    for (std::size_t i = 0; i < regs.size(); ++i) {
+    for (size_t i = 0; i < regs.size(); ++i) {
        if (regs[i] && ABI_ALL_GPRS[i]) {
            code.push(IndexToReg64(i));
        }
@@ -192,7 +192,7 @@ inline size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::b
        code.sub(code.rsp, frame_info.subtraction);
    }
-    for (std::size_t i = 0; i < regs.size(); ++i) {
+    for (size_t i = 0; i < regs.size(); ++i) {
        if (regs[i] && ABI_ALL_XMMS[i]) {
            code.movaps(code.xword[code.rsp + frame_info.xmm_offset], IndexToXmm(i));
            frame_info.xmm_offset += 0x10;
@@ -206,7 +206,7 @@ inline void ABI_PopRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::bits
                                           size_t rsp_alignment, size_t needed_frame_size = 0) {
    auto frame_info = ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size);
-    for (std::size_t i = 0; i < regs.size(); ++i) {
+    for (size_t i = 0; i < regs.size(); ++i) {
        if (regs[i] && ABI_ALL_XMMS[i]) {
            code.movaps(IndexToXmm(i), code.xword[code.rsp + frame_info.xmm_offset]);
            frame_info.xmm_offset += 0x10;
@@ -218,8 +218,8 @@ inline void ABI_PopRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::bits
    }
    // GPRs need to be popped in reverse order
-    for (std::size_t j = 0; j < regs.size(); ++j) {
+    for (size_t j = 0; j < regs.size(); ++j) {
-        const std::size_t i = regs.size() - j - 1;
+        const size_t i = regs.size() - j - 1;
        if (regs[i] && ABI_ALL_GPRS[i]) {
            code.pop(IndexToReg64(i));
        }
diff --git a/src/core/core.cpp b/src/core/core.cpp
index 01e4faac8..7e3c54618 100644
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -237,7 +237,7 @@ struct System::Impl {
            Kernel::Process::Create(system, "main", Kernel::Process::ProcessType::Userland);
        const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
        if (load_result != Loader::ResultStatus::Success) {
-            LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
+            LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", load_result);
            Shutdown();
            return static_cast<ResultStatus>(static_cast<u32>(ResultStatus::ErrorLoader) +
@@ -267,8 +267,7 @@ struct System::Impl {
        u64 title_id{0};
        if (app_loader->ReadProgramId(title_id) != Loader::ResultStatus::Success) {
-            LOG_ERROR(Core, "Failed to find title id for ROM (Error {})",
+            LOG_ERROR(Core, "Failed to find title id for ROM (Error {})", load_result);
-                      static_cast<u32>(load_result));
        }
        perf_stats = std::make_unique<PerfStats>(title_id);
        // Reset counters and set time origin to current frame
diff --git a/src/core/file_sys/content_archive.cpp b/src/core/file_sys/content_archive.cpp
index 76af47ff9..363ff980f 100644
--- a/src/core/file_sys/content_archive.cpp
+++ b/src/core/file_sys/content_archive.cpp
@@ -410,8 +410,9 @@ u8 NCA::GetCryptoRevision() const {
 std::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType type) const {
    const auto master_key_id = GetCryptoRevision();
-    if (!keys.HasKey(Core::Crypto::S128KeyType::KeyArea, master_key_id, header.key_index))
+    if (!keys.HasKey(Core::Crypto::S128KeyType::KeyArea, master_key_id, header.key_index)) {
-        return {};
+        return std::nullopt;
+    }
    std::vector<u8> key_area(header.key_area.begin(), header.key_area.end());
    Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(
@@ -420,15 +421,17 @@ std::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType type
    cipher.Transcode(key_area.data(), key_area.size(), key_area.data(), Core::Crypto::Op::Decrypt);
    Core::Crypto::Key128 out;
-    if (type == NCASectionCryptoType::XTS)
+    if (type == NCASectionCryptoType::XTS) {
        std::copy(key_area.begin(), key_area.begin() + 0x10, out.begin());
-    else if (type == NCASectionCryptoType::CTR || type == NCASectionCryptoType::BKTR)
+    } else if (type == NCASectionCryptoType::CTR || type == NCASectionCryptoType::BKTR) {
        std::copy(key_area.begin() + 0x20, key_area.begin() + 0x30, out.begin());
-    else
+    } else {
        LOG_CRITICAL(Crypto, "Called GetKeyAreaKey on invalid NCASectionCryptoType type={:02X}",
-                     static_cast<u8>(type));
+                     type);
+    }
    u128 out_128{};
-    memcpy(out_128.data(), out.data(), 16);
+    std::memcpy(out_128.data(), out.data(), sizeof(u128));
    LOG_TRACE(Crypto, "called with crypto_rev={:02X}, kak_index={:02X}, key={:016X}{:016X}",
              master_key_id, header.key_index, out_128[1], out_128[0]);
@@ -507,7 +510,7 @@ VirtualFile NCA::Decrypt(const NCASectionHeader& s_header, VirtualFile in, u64 s
        // TODO(DarkLordZach): Find a test case for XTS-encrypted NCAs
    default:
        LOG_ERROR(Crypto, "called with unhandled crypto type={:02X}",
-                  static_cast<u8>(s_header.raw.header.crypto_type));
+                  s_header.raw.header.crypto_type);
        return nullptr;
    }
 }
diff --git a/src/core/file_sys/system_archive/system_version.cpp b/src/core/file_sys/system_archive/system_version.cpp
index aa313de66..7bfbc9a67 100644
--- a/src/core/file_sys/system_archive/system_version.cpp
+++ b/src/core/file_sys/system_archive/system_version.cpp
@@ -12,17 +12,17 @@ namespace SystemVersionData {
 // This section should reflect the best system version to describe yuzu's HLE api.
 // TODO(DarkLordZach): Update when HLE gets better.
-constexpr u8 VERSION_MAJOR = 10;
+constexpr u8 VERSION_MAJOR = 11;
 constexpr u8 VERSION_MINOR = 0;
-constexpr u8 VERSION_MICRO = 2;
+constexpr u8 VERSION_MICRO = 0;
-constexpr u8 REVISION_MAJOR = 1;
+constexpr u8 REVISION_MAJOR = 5;
 constexpr u8 REVISION_MINOR = 0;
 constexpr char PLATFORM_STRING[] = "NX";
-constexpr char VERSION_HASH[] = "f90143fa8bbc061d4f68c35f95f04f8080c0ecdc";
+constexpr char VERSION_HASH[] = "34197eba8810e2edd5e9dfcfbde7b340882e856d";
-constexpr char DISPLAY_VERSION[] = "10.0.2";
+constexpr char DISPLAY_VERSION[] = "11.0.0";
-constexpr char DISPLAY_TITLE[] = "NintendoSDK Firmware for NX 10.0.2-1.0";
+constexpr char DISPLAY_TITLE[] = "NintendoSDK Firmware for NX 11.0.0-5.0";
 } // namespace SystemVersionData
diff --git a/src/core/file_sys/vfs_real.cpp b/src/core/file_sys/vfs_real.cpp
index 488687ba9..3b70f7755 100644
--- a/src/core/file_sys/vfs_real.cpp
+++ b/src/core/file_sys/vfs_real.cpp
@@ -94,9 +94,13 @@ VirtualFile RealVfsFilesystem::OpenFile(std::string_view path_, Mode perms) {
 VirtualFile RealVfsFilesystem::CreateFile(std::string_view path_, Mode perms) {
    const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault);
-    const auto path_fwd = FS::SanitizePath(path, FS::DirectorySeparator::ForwardSlash);
+    const auto parent_path = FS::GetParentPath(path);
    if (!FS::Exists(path)) {
-        FS::CreateFullPath(path_fwd);
+        if (!FS::CreateDirs(parent_path)) {
+            return nullptr;
+        }
        if (!FS::CreateEmptyFile(path)) {
            return nullptr;
        }
diff --git a/src/core/file_sys/vfs_vector.h b/src/core/file_sys/vfs_vector.h
index 95d3da2f2..c214db422 100644
--- a/src/core/file_sys/vfs_vector.h
+++ b/src/core/file_sys/vfs_vector.h
@@ -17,9 +17,9 @@ namespace FileSys {
 template <std::size_t size>
 class ArrayVfsFile : public VfsFile {
 public:
-    explicit ArrayVfsFile(const std::array<u8, size>& data, std::string name = "",
+    explicit ArrayVfsFile(const std::array<u8, size>& data_, std::string name_ = "",
-                          VirtualDir parent = nullptr)
+                          VirtualDir parent_ = nullptr)
-        : data(data), name(std::move(name)), parent(std::move(parent)) {}
+        : data(data_), name(std::move(name_)), parent(std::move(parent_)) {}
    std::string GetName() const override {
        return name;
@@ -51,12 +51,12 @@ public:
        return read;
    }
-    std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override {
+    std::size_t Write(const u8* data_, std::size_t length, std::size_t offset) override {
        return 0;
    }
-    bool Rename(std::string_view name) override {
+    bool Rename(std::string_view new_name) override {
-        this->name = name;
+        name = new_name;
        return true;
    }
diff --git a/src/core/frontend/applets/error.cpp b/src/core/frontend/applets/error.cpp
index 4002a9211..dceb20ff8 100644
--- a/src/core/frontend/applets/error.cpp
+++ b/src/core/frontend/applets/error.cpp
@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#include "common/logging/log.h"
 #include "core/frontend/applets/error.h"
 namespace Core::Frontend {
@@ -10,7 +11,7 @@ ErrorApplet::~ErrorApplet() = default;
 void DefaultErrorApplet::ShowError(ResultCode error, std::function<void()> finished) const {
    LOG_CRITICAL(Service_Fatal, "Application requested error display: {:04}-{:04} (raw={:08X})",
-                 static_cast<u32>(error.module.Value()), error.description.Value(), error.raw);
+                 error.module.Value(), error.description.Value(), error.raw);
 }
 void DefaultErrorApplet::ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
@@ -18,7 +19,7 @@ void DefaultErrorApplet::ShowErrorWithTimestamp(ResultCode error, std::chrono::s
    LOG_CRITICAL(
        Service_Fatal,
        "Application requested error display: {:04X}-{:04X} (raw={:08X}) with timestamp={:016X}",
-        static_cast<u32>(error.module.Value()), error.description.Value(), error.raw, time.count());
+        error.module.Value(), error.description.Value(), error.raw, time.count());
 }
 void DefaultErrorApplet::ShowCustomErrorText(ResultCode error, std::string main_text,
@@ -26,7 +27,7 @@ void DefaultErrorApplet::ShowCustomErrorText(ResultCode error, std::string main_
                                             std::function<void()> finished) const {
    LOG_CRITICAL(Service_Fatal,
                 "Application requested custom error with error_code={:04X}-{:04X} (raw={:08X})",
-                 static_cast<u32>(error.module.Value()), error.description.Value(), error.raw);
+                 error.module.Value(), error.description.Value(), error.raw);
    LOG_CRITICAL(Service_Fatal, "    Main Text: {}", main_text);
    LOG_CRITICAL(Service_Fatal, "    Detail Text: {}", detail_text);
 }
diff --git a/src/core/hle/ipc_helpers.h b/src/core/hle/ipc_helpers.h
index d57776ce9..56cc911d1 100644
--- a/src/core/hle/ipc_helpers.h
+++ b/src/core/hle/ipc_helpers.h
@@ -166,8 +166,23 @@ public:
        ValidateHeader();
    }
+    void PushImpl(s8 value);
+    void PushImpl(s16 value);
+    void PushImpl(s32 value);
+    void PushImpl(s64 value);
+    void PushImpl(u8 value);
+    void PushImpl(u16 value);
+    void PushImpl(u32 value);
+    void PushImpl(u64 value);
+    void PushImpl(float value);
+    void PushImpl(double value);
+    void PushImpl(bool value);
+    void PushImpl(ResultCode value);
    template <typename T>
-    void Push(T value);
+    void Push(T value) {
+        return PushImpl(value);
+    }
    template <typename First, typename... Other>
    void Push(const First& first_value, const Other&... other_values);
@@ -215,13 +230,11 @@ private:
 /// Push ///
-template <>
+inline void ResponseBuilder::PushImpl(s32 value) {
-inline void ResponseBuilder::Push(s32 value) {
    cmdbuf[index++] = static_cast<u32>(value);
 }
-template <>
+inline void ResponseBuilder::PushImpl(u32 value) {
-inline void ResponseBuilder::Push(u32 value) {
    cmdbuf[index++] = value;
 }
@@ -233,62 +246,52 @@ void ResponseBuilder::PushRaw(const T& value) {
    index += (sizeof(T) + 3) / 4; // round up to word length
 }
-template <>
+inline void ResponseBuilder::PushImpl(ResultCode value) {
-inline void ResponseBuilder::Push(ResultCode value) {
    // Result codes are actually 64-bit in the IPC buffer, but only the high part is discarded.
    Push(value.raw);
    Push<u32>(0);
 }
-template <>
+inline void ResponseBuilder::PushImpl(s8 value) {
-inline void ResponseBuilder::Push(s8 value) {
    PushRaw(value);
 }
-template <>
+inline void ResponseBuilder::PushImpl(s16 value) {
-inline void ResponseBuilder::Push(s16 value) {
    PushRaw(value);
 }
-template <>
+inline void ResponseBuilder::PushImpl(s64 value) {
-inline void ResponseBuilder::Push(s64 value) {
+    PushImpl(static_cast<u32>(value));
-    Push(static_cast<u32>(value));
+    PushImpl(static_cast<u32>(value >> 32));
-    Push(static_cast<u32>(value >> 32));
 }
-template <>
+inline void ResponseBuilder::PushImpl(u8 value) {
-inline void ResponseBuilder::Push(u8 value) {
    PushRaw(value);
 }
-template <>
+inline void ResponseBuilder::PushImpl(u16 value) {
-inline void ResponseBuilder::Push(u16 value) {
    PushRaw(value);
 }
-template <>
+inline void ResponseBuilder::PushImpl(u64 value) {
-inline void ResponseBuilder::Push(u64 value) {
+    PushImpl(static_cast<u32>(value));
-    Push(static_cast<u32>(value));
+    PushImpl(static_cast<u32>(value >> 32));
-    Push(static_cast<u32>(value >> 32));
 }
-template <>
+inline void ResponseBuilder::PushImpl(float value) {
-inline void ResponseBuilder::Push(float value) {
    u32 integral;
    std::memcpy(&integral, &value, sizeof(u32));
-    Push(integral);
+    PushImpl(integral);
 }
-template <>
+inline void ResponseBuilder::PushImpl(double value) {
-inline void ResponseBuilder::Push(double value) {
    u64 integral;
    std::memcpy(&integral, &value, sizeof(u64));
-    Push(integral);
+    PushImpl(integral);
 }
-template <>
+inline void ResponseBuilder::PushImpl(bool value) {
-inline void ResponseBuilder::Push(bool value) {
+    PushImpl(static_cast<u8>(value));
-    Push(static_cast<u8>(value));
 }
 template <typename First, typename... Other>
diff --git a/src/core/hle/kernel/memory/memory_block.h b/src/core/hle/kernel/memory/memory_block.h
index 9d7839d08..37fe19916 100644
--- a/src/core/hle/kernel/memory/memory_block.h
+++ b/src/core/hle/kernel/memory/memory_block.h
@@ -222,9 +222,9 @@ public:
 public:
    constexpr MemoryBlock() = default;
-    constexpr MemoryBlock(VAddr addr, std::size_t num_pages, MemoryState state,
+    constexpr MemoryBlock(VAddr addr_, std::size_t num_pages_, MemoryState state_,
-                          MemoryPermission perm, MemoryAttribute attribute)
+                          MemoryPermission perm_, MemoryAttribute attribute_)
-        : addr{addr}, num_pages(num_pages), state{state}, perm{perm}, attribute{attribute} {}
+        : addr{addr_}, num_pages(num_pages_), state{state_}, perm{perm_}, attribute{attribute_} {}
    constexpr VAddr GetAddress() const {
        return addr;
diff --git a/src/core/hle/kernel/memory/memory_block_manager.h b/src/core/hle/kernel/memory/memory_block_manager.h
index 6e1d41075..f57d1bbcc 100644
--- a/src/core/hle/kernel/memory/memory_block_manager.h
+++ b/src/core/hle/kernel/memory/memory_block_manager.h
@@ -57,8 +57,8 @@ public:
 private:
    void MergeAdjacent(iterator it, iterator& next_it);
-    const VAddr start_addr;
+    [[maybe_unused]] const VAddr start_addr;
-    const VAddr end_addr;
+    [[maybe_unused]] const VAddr end_addr;
    MemoryBlockTree memory_block_tree;
 };
diff --git a/src/core/hle/kernel/physical_core.h b/src/core/hle/kernel/physical_core.h
index 37513130a..801d24c28 100644
--- a/src/core/hle/kernel/physical_core.h
+++ b/src/core/hle/kernel/physical_core.h
@@ -36,7 +36,7 @@ public:
    PhysicalCore& operator=(const PhysicalCore&) = delete;
    PhysicalCore(PhysicalCore&&) = default;
-    PhysicalCore& operator=(PhysicalCore&&) = default;
+    PhysicalCore& operator=(PhysicalCore&&) = delete;
    /// Initialize the core for the specified parameters.
    void Initialize(bool is_64_bit);
diff --git a/src/core/hle/kernel/process_capability.cpp b/src/core/hle/kernel/process_capability.cpp
index 63880f13d..0f128c586 100644
--- a/src/core/hle/kernel/process_capability.cpp
+++ b/src/core/hle/kernel/process_capability.cpp
@@ -199,7 +199,7 @@ ResultCode ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& s
        break;
    }
-    LOG_ERROR(Kernel, "Invalid capability type! type={}", static_cast<u32>(type));
+    LOG_ERROR(Kernel, "Invalid capability type! type={}", type);
    return ERR_INVALID_CAPABILITY_DESCRIPTOR;
 }
diff --git a/src/core/hle/kernel/resource_limit.cpp b/src/core/hle/kernel/resource_limit.cpp
index 212e442f4..7bf50339d 100644
--- a/src/core/hle/kernel/resource_limit.cpp
+++ b/src/core/hle/kernel/resource_limit.cpp
@@ -65,8 +65,8 @@ ResultCode ResourceLimit::SetLimitValue(ResourceType resource, s64 value) {
        limit[index] = value;
        return RESULT_SUCCESS;
    } else {
-        LOG_ERROR(Kernel, "Limit value is too large! resource={}, value={}, index={}",
+        LOG_ERROR(Kernel, "Limit value is too large! resource={}, value={}, index={}", resource,
-                  static_cast<u32>(resource), value, index);
+                  value, index);
        return ERR_INVALID_STATE;
    }
 }
diff --git a/src/core/hle/kernel/server_session.cpp b/src/core/hle/kernel/server_session.cpp
index 8c19f2534..ae088cf41 100644
--- a/src/core/hle/kernel/server_session.cpp
+++ b/src/core/hle/kernel/server_session.cpp
@@ -130,8 +130,7 @@ ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& con
    }
    }
-    LOG_CRITICAL(IPC, "Unknown domain command={}",
+    LOG_CRITICAL(IPC, "Unknown domain command={}", domain_message_header.command.Value());
-                 static_cast<int>(domain_message_header.command.Value()));
    ASSERT(false);
    return RESULT_SUCCESS;
 }
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index 38d877f6e..cb13210e5 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -1092,14 +1092,14 @@ void ILibraryAppletCreator::CreateLibraryApplet(Kernel::HLERequestContext& ctx)
    const auto applet_id = rp.PopRaw<Applets::AppletId>();
    const auto applet_mode = rp.PopRaw<u32>();
-    LOG_DEBUG(Service_AM, "called with applet_id={:08X}, applet_mode={:08X}",
+    LOG_DEBUG(Service_AM, "called with applet_id={:08X}, applet_mode={:08X}", applet_id,
-              static_cast<u32>(applet_id), applet_mode);
+              applet_mode);
    const auto& applet_manager{system.GetAppletManager()};
    const auto applet = applet_manager.GetApplet(applet_id);
    if (applet == nullptr) {
-        LOG_ERROR(Service_AM, "Applet doesn't exist! applet_id={}", static_cast<u32>(applet_id));
+        LOG_ERROR(Service_AM, "Applet doesn't exist! applet_id={}", applet_id);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_UNKNOWN);
@@ -1290,7 +1290,7 @@ void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto kind = rp.PopEnum<LaunchParameterKind>();
-    LOG_DEBUG(Service_AM, "called, kind={:08X}", static_cast<u8>(kind));
+    LOG_DEBUG(Service_AM, "called, kind={:08X}", kind);
    if (kind == LaunchParameterKind::ApplicationSpecific && !launch_popped_application_specific) {
        const auto backend = BCAT::CreateBackendFromSettings(system, [this](u64 tid) {
@@ -1537,8 +1537,8 @@ void IApplicationFunctions::GetSaveDataSize(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto [type, user_id] = rp.PopRaw<Parameters>();
-    LOG_DEBUG(Service_AM, "called with type={:02X}, user_id={:016X}{:016X}", static_cast<u8>(type),
+    LOG_DEBUG(Service_AM, "called with type={:02X}, user_id={:016X}{:016X}", type, user_id[1],
-              user_id[1], user_id[0]);
+              user_id[0]);
    const auto size = system.GetFileSystemController().ReadSaveDataSize(
        type, system.CurrentProcess()->GetTitleID(), user_id);
diff --git a/src/core/hle/service/am/applets/controller.cpp b/src/core/hle/service/am/applets/controller.cpp
index e8ea4248b..7edfca64e 100644
--- a/src/core/hle/service/am/applets/controller.cpp
+++ b/src/core/hle/service/am/applets/controller.cpp
@@ -29,14 +29,14 @@ static Core::Frontend::ControllerParameters ConvertToFrontendParameters(
    npad_style_set.raw = private_arg.style_set;
    return {
-        .min_players = std::max(s8(1), header.player_count_min),
+        .min_players = std::max(s8{1}, header.player_count_min),
        .max_players = header.player_count_max,
        .keep_controllers_connected = header.enable_take_over_connection,
        .enable_single_mode = header.enable_single_mode,
        .enable_border_color = header.enable_identification_color,
-        .border_colors = identification_colors,
+        .border_colors = std::move(identification_colors),
        .enable_explain_text = enable_text,
-        .explain_text = text,
+        .explain_text = std::move(text),
        .allow_pro_controller = npad_style_set.pro_controller == 1,
        .allow_handheld = npad_style_set.handheld == 1,
        .allow_dual_joycons = npad_style_set.joycon_dual == 1,
@@ -227,15 +227,14 @@ void Controller::ConfigurationComplete() {
    // If enable_single_mode is enabled, player_count is 1 regardless of any other parameters.
    // Otherwise, only count connected players from P1-P8.
    result_info.player_count =
-        is_single_mode ? 1
+        is_single_mode
-                       : static_cast<s8>(std::count_if(
+            ? 1
-                             players.begin(), players.end() - 2,
+            : static_cast<s8>(std::count_if(players.begin(), players.end() - 2,
-                             [](Settings::PlayerInput player) { return player.connected; }));
+                                            [](const auto& player) { return player.connected; }));
-    result_info.selected_id = HID::Controller_NPad::IndexToNPad(
+    result_info.selected_id = HID::Controller_NPad::IndexToNPad(std::distance(
-        std::distance(players.begin(),
+        players.begin(), std::find_if(players.begin(), players.end(),
-                      std::find_if(players.begin(), players.end(),
+                                      [](const auto& player) { return player.connected; })));
-                                   [](Settings::PlayerInput player) { return player.connected; })));
    result_info.result = 0;
diff --git a/src/core/hle/service/am/applets/error.cpp b/src/core/hle/service/am/applets/error.cpp
index dcd4b2a35..d85505082 100644
--- a/src/core/hle/service/am/applets/error.cpp
+++ b/src/core/hle/service/am/applets/error.cpp
@@ -125,7 +125,7 @@ void Error::Initialize() {
        error_code = Decode64BitError(args->error_record.error_code_64);
        break;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented LibAppletError mode={:02X}!", static_cast<u8>(mode));
+        UNIMPLEMENTED_MSG("Unimplemented LibAppletError mode={:02X}!", mode);
    }
 }
@@ -179,7 +179,7 @@ void Error::Execute() {
            error_code, std::chrono::seconds{args->error_record.posix_time}, callback);
        break;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented LibAppletError mode={:02X}!", static_cast<u8>(mode));
+        UNIMPLEMENTED_MSG("Unimplemented LibAppletError mode={:02X}!", mode);
        DisplayCompleted();
    }
 }
diff --git a/src/core/hle/service/am/applets/general_backend.cpp b/src/core/hle/service/am/applets/general_backend.cpp
index bdb6fd464..4d1df5cbe 100644
--- a/src/core/hle/service/am/applets/general_backend.cpp
+++ b/src/core/hle/service/am/applets/general_backend.cpp
@@ -90,7 +90,7 @@ void Auth::Execute() {
    const auto unimplemented_log = [this] {
        UNIMPLEMENTED_MSG("Unimplemented Auth applet type for type={:08X}, arg0={:02X}, "
                          "arg1={:02X}, arg2={:02X}",
-                          static_cast<u32>(type), arg0, arg1, arg2);
+                          type, arg0, arg1, arg2);
    };
    switch (type) {
@@ -136,7 +136,7 @@ void Auth::Execute() {
 }
 void Auth::AuthFinished(bool is_successful) {
-    this->successful = is_successful;
+    successful = is_successful;
    struct Return {
        ResultCode result_code;
@@ -193,7 +193,7 @@ void PhotoViewer::Execute() {
        frontend.ShowAllPhotos(callback);
        break;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented PhotoViewer applet mode={:02X}!", static_cast<u8>(mode));
+        UNIMPLEMENTED_MSG("Unimplemented PhotoViewer applet mode={:02X}!", mode);
    }
 }
diff --git a/src/core/hle/service/apm/controller.cpp b/src/core/hle/service/apm/controller.cpp
index ce993bad3..03636642b 100644
--- a/src/core/hle/service/apm/controller.cpp
+++ b/src/core/hle/service/apm/controller.cpp
@@ -48,8 +48,7 @@ void Controller::SetPerformanceConfiguration(PerformanceMode mode,
                                   [config](const auto& entry) { return entry.first == config; });
    if (iter == config_to_speed.cend()) {
-        LOG_ERROR(Service_APM, "Invalid performance configuration value provided: {}",
+        LOG_ERROR(Service_APM, "Invalid performance configuration value provided: {}", config);
-                  static_cast<u32>(config));
        return;
    }
diff --git a/src/core/hle/service/apm/interface.cpp b/src/core/hle/service/apm/interface.cpp
index 89442e21e..298f6d520 100644
--- a/src/core/hle/service/apm/interface.cpp
+++ b/src/core/hle/service/apm/interface.cpp
@@ -28,8 +28,7 @@ private:
        const auto mode = rp.PopEnum<PerformanceMode>();
        const auto config = rp.PopEnum<PerformanceConfiguration>();
-        LOG_DEBUG(Service_APM, "called mode={} config={}", static_cast<u32>(mode),
+        LOG_DEBUG(Service_APM, "called mode={} config={}", mode, config);
-                  static_cast<u32>(config));
        controller.SetPerformanceConfiguration(mode, config);
@@ -41,7 +40,7 @@ private:
        IPC::RequestParser rp{ctx};
        const auto mode = rp.PopEnum<PerformanceMode>();
-        LOG_DEBUG(Service_APM, "called mode={}", static_cast<u32>(mode));
+        LOG_DEBUG(Service_APM, "called mode={}", mode);
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
@@ -111,7 +110,7 @@ void APM_Sys::SetCpuBoostMode(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto mode = rp.PopEnum<CpuBoostMode>();
-    LOG_DEBUG(Service_APM, "called, mode={:08X}", static_cast<u32>(mode));
+    LOG_DEBUG(Service_APM, "called, mode={:08X}", mode);
    controller.SetFromCpuBoostMode(mode);
diff --git a/src/core/hle/service/bcat/backend/boxcat.cpp b/src/core/hle/service/bcat/backend/boxcat.cpp
index 3b6f7498e..e43f3f47f 100644
--- a/src/core/hle/service/bcat/backend/boxcat.cpp
+++ b/src/core/hle/service/bcat/backend/boxcat.cpp
@@ -483,7 +483,7 @@ Boxcat::StatusResult Boxcat::GetStatus(std::optional<std::string>& global,
            global = json["global"].get<std::string>();
        if (json["games"].is_array()) {
-            for (const auto object : json["games"]) {
+            for (const auto& object : json["games"]) {
                if (object.is_object() && object.find("name") != object.end()) {
                    EventStatus detail{};
                    if (object["header"].is_string()) {
diff --git a/src/core/hle/service/fatal/fatal.cpp b/src/core/hle/service/fatal/fatal.cpp
index 9b7672a91..13147472e 100644
--- a/src/core/hle/service/fatal/fatal.cpp
+++ b/src/core/hle/service/fatal/fatal.cpp
@@ -111,8 +111,9 @@ static void GenerateErrorReport(Core::System& system, ResultCode error_code,
 static void ThrowFatalError(Core::System& system, ResultCode error_code, FatalType fatal_type,
                            const FatalInfo& info) {
-    LOG_ERROR(Service_Fatal, "Threw fatal error type {} with error code 0x{:X}",
+    LOG_ERROR(Service_Fatal, "Threw fatal error type {} with error code 0x{:X}", fatal_type,
-              static_cast<u32>(fatal_type), error_code.raw);
+              error_code.raw);
    switch (fatal_type) {
    case FatalType::ErrorReportAndScreen:
        GenerateErrorReport(system, error_code, info);
diff --git a/src/core/hle/service/filesystem/filesystem.cpp b/src/core/hle/service/filesystem/filesystem.cpp
index ca93062cf..6af818b5a 100644
--- a/src/core/hle/service/filesystem/filesystem.cpp
+++ b/src/core/hle/service/filesystem/filesystem.cpp
@@ -301,7 +301,7 @@ ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFSCurrentProcess()
 ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFS(
    u64 title_id, FileSys::StorageId storage_id, FileSys::ContentRecordType type) const {
    LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}, storage_id={:02X}, type={:02X}",
-              title_id, static_cast<u8>(storage_id), static_cast<u8>(type));
+              title_id, storage_id, type);
    if (romfs_factory == nullptr) {
        // TODO(bunnei): Find a better error code for this
@@ -313,8 +313,8 @@ ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFS(
 ResultVal<FileSys::VirtualDir> FileSystemController::CreateSaveData(
    FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const {
-    LOG_TRACE(Service_FS, "Creating Save Data for space_id={:01X}, save_struct={}",
+    LOG_TRACE(Service_FS, "Creating Save Data for space_id={:01X}, save_struct={}", space,
-              static_cast<u8>(space), save_struct.DebugInfo());
+              save_struct.DebugInfo());
    if (save_data_factory == nullptr) {
        return FileSys::ERROR_ENTITY_NOT_FOUND;
@@ -325,8 +325,8 @@ ResultVal<FileSys::VirtualDir> FileSystemController::CreateSaveData(
 ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveData(
    FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& attribute) const {
-    LOG_TRACE(Service_FS, "Opening Save Data for space_id={:01X}, save_struct={}",
+    LOG_TRACE(Service_FS, "Opening Save Data for space_id={:01X}, save_struct={}", space,
-              static_cast<u8>(space), attribute.DebugInfo());
+              attribute.DebugInfo());
    if (save_data_factory == nullptr) {
        return FileSys::ERROR_ENTITY_NOT_FOUND;
@@ -337,7 +337,7 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveData(
 ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveDataSpace(
    FileSys::SaveDataSpaceId space) const {
-    LOG_TRACE(Service_FS, "Opening Save Data Space for space_id={:01X}", static_cast<u8>(space));
+    LOG_TRACE(Service_FS, "Opening Save Data Space for space_id={:01X}", space);
    if (save_data_factory == nullptr) {
        return FileSys::ERROR_ENTITY_NOT_FOUND;
@@ -358,7 +358,7 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenSDMC() const {
 ResultVal<FileSys::VirtualDir> FileSystemController::OpenBISPartition(
    FileSys::BisPartitionId id) const {
-    LOG_TRACE(Service_FS, "Opening BIS Partition with id={:08X}", static_cast<u32>(id));
+    LOG_TRACE(Service_FS, "Opening BIS Partition with id={:08X}", id);
    if (bis_factory == nullptr) {
        return FileSys::ERROR_ENTITY_NOT_FOUND;
@@ -374,7 +374,7 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenBISPartition(
 ResultVal<FileSys::VirtualFile> FileSystemController::OpenBISPartitionStorage(
    FileSys::BisPartitionId id) const {
-    LOG_TRACE(Service_FS, "Opening BIS Partition Storage with id={:08X}", static_cast<u32>(id));
+    LOG_TRACE(Service_FS, "Opening BIS Partition Storage with id={:08X}", id);
    if (bis_factory == nullptr) {
        return FileSys::ERROR_ENTITY_NOT_FOUND;
diff --git a/src/core/hle/service/filesystem/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp_srv.cpp
index b3480494c..ef15160bf 100644
--- a/src/core/hle/service/filesystem/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp_srv.cpp
@@ -413,7 +413,7 @@ public:
        const auto mode = static_cast<FileSys::Mode>(rp.Pop<u32>());
-        LOG_DEBUG(Service_FS, "called. file={}, mode={}", name, static_cast<u32>(mode));
+        LOG_DEBUG(Service_FS, "called. file={}, mode={}", name, mode);
        auto result = backend.OpenFile(name, mode);
        if (result.Failed()) {
@@ -553,8 +553,7 @@ private:
        const auto save_root = fsc.OpenSaveDataSpace(space);
        if (save_root.Failed() || *save_root == nullptr) {
-            LOG_ERROR(Service_FS, "The save root for the space_id={:02X} was invalid!",
+            LOG_ERROR(Service_FS, "The save root for the space_id={:02X} was invalid!", space);
-                      static_cast<u8>(space));
            return;
        }
@@ -795,8 +794,7 @@ void FSP_SRV::OpenFileSystemWithPatch(Kernel::HLERequestContext& ctx) {
    const auto type = rp.PopRaw<FileSystemType>();
    const auto title_id = rp.PopRaw<u64>();
-    LOG_WARNING(Service_FS, "(STUBBED) called with type={}, title_id={:016X}",
+    LOG_WARNING(Service_FS, "(STUBBED) called with type={}, title_id={:016X}", type, title_id);
-                static_cast<u8>(type), title_id);
    IPC::ResponseBuilder rb{ctx, 2, 0, 0};
    rb.Push(RESULT_UNKNOWN);
@@ -883,7 +881,7 @@ void FSP_SRV::OpenReadOnlySaveDataFileSystem(Kernel::HLERequestContext& ctx) {
 void FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto space = rp.PopRaw<FileSys::SaveDataSpaceId>();
-    LOG_INFO(Service_FS, "called, space={}", static_cast<u8>(space));
+    LOG_INFO(Service_FS, "called, space={}", space);
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
@@ -915,10 +913,10 @@ void FSP_SRV::ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
                "(STUBBED) called, flags={}, space_id={}, attribute.title_id={:016X}\n"
                "attribute.user_id={:016X}{:016X}, attribute.save_id={:016X}\n"
                "attribute.type={}, attribute.rank={}, attribute.index={}",
-                flags, static_cast<u32>(parameters.space_id), parameters.attribute.title_id,
+                flags, parameters.space_id, parameters.attribute.title_id,
                parameters.attribute.user_id[1], parameters.attribute.user_id[0],
-                parameters.attribute.save_id, static_cast<u32>(parameters.attribute.type),
+                parameters.attribute.save_id, parameters.attribute.type, parameters.attribute.rank,
-                static_cast<u32>(parameters.attribute.rank), parameters.attribute.index);
+                parameters.attribute.index);
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
@@ -951,7 +949,7 @@ void FSP_SRV::OpenDataStorageByDataId(Kernel::HLERequestContext& ctx) {
    const auto title_id = rp.PopRaw<u64>();
    LOG_DEBUG(Service_FS, "called with storage_id={:02X}, unknown={:08X}, title_id={:016X}",
-              static_cast<u8>(storage_id), unknown, title_id);
+              storage_id, unknown, title_id);
    auto data = fsc.OpenRomFS(title_id, storage_id, FileSys::ContentRecordType::Data);
@@ -968,7 +966,7 @@ void FSP_SRV::OpenDataStorageByDataId(Kernel::HLERequestContext& ctx) {
        // TODO(DarkLordZach): Find the right error code to use here
        LOG_ERROR(Service_FS,
                  "could not open data storage with title_id={:016X}, storage_id={:02X}", title_id,
-                  static_cast<u8>(storage_id));
+                  storage_id);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_UNKNOWN);
        return;
@@ -987,11 +985,10 @@ void FSP_SRV::OpenDataStorageByDataId(Kernel::HLERequestContext& ctx) {
 void FSP_SRV::OpenPatchDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
-    auto storage_id = rp.PopRaw<FileSys::StorageId>();
+    const auto storage_id = rp.PopRaw<FileSys::StorageId>();
-    auto title_id = rp.PopRaw<u64>();
+    const auto title_id = rp.PopRaw<u64>();
-    LOG_DEBUG(Service_FS, "called with storage_id={:02X}, title_id={:016X}",
+    LOG_DEBUG(Service_FS, "called with storage_id={:02X}, title_id={:016X}", storage_id, title_id);
-              static_cast<u8>(storage_id), title_id);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(FileSys::ERROR_ENTITY_NOT_FOUND);
@@ -1001,7 +998,7 @@ void FSP_SRV::SetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    log_mode = rp.PopEnum<LogMode>();
-    LOG_DEBUG(Service_FS, "called, log_mode={:08X}", static_cast<u32>(log_mode));
+    LOG_DEBUG(Service_FS, "called, log_mode={:08X}", log_mode);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
diff --git a/src/core/hle/service/friend/friend.cpp b/src/core/hle/service/friend/friend.cpp
index 40a289594..c5b053c31 100644
--- a/src/core/hle/service/friend/friend.cpp
+++ b/src/core/hle/service/friend/friend.cpp
@@ -229,8 +229,7 @@ private:
            break;
        default:
            // HOS seems not have an error case for an unknown notification
-            LOG_WARNING(Service_ACC, "Unknown notification {:08X}",
+            LOG_WARNING(Service_ACC, "Unknown notification {:08X}", notification.notification_type);
-                        static_cast<u32>(notification.notification_type));
            break;
        }
diff --git a/src/core/hle/service/lm/lm.cpp b/src/core/hle/service/lm/lm.cpp
index f884b2735..8e49b068c 100644
--- a/src/core/hle/service/lm/lm.cpp
+++ b/src/core/hle/service/lm/lm.cpp
@@ -68,7 +68,7 @@ private:
        IPC::RequestParser rp{ctx};
        const auto destination = rp.PopEnum<DestinationFlag>();
-        LOG_DEBUG(Service_LM, "called, destination={:08X}", static_cast<u32>(destination));
+        LOG_DEBUG(Service_LM, "called, destination={:08X}", destination);
        manager.SetDestination(destination);
diff --git a/src/core/hle/service/ncm/ncm.cpp b/src/core/hle/service/ncm/ncm.cpp
index b8d627ca8..2dcda16f6 100644
--- a/src/core/hle/service/ncm/ncm.cpp
+++ b/src/core/hle/service/ncm/ncm.cpp
@@ -45,7 +45,7 @@ public:
    }
 private:
-    FileSys::StorageId storage;
+    [[maybe_unused]] FileSys::StorageId storage;
 };
 class IRegisteredLocationResolver final : public ServiceFramework<IRegisteredLocationResolver> {
diff --git a/src/core/hle/service/ns/pl_u.cpp b/src/core/hle/service/ns/pl_u.cpp
index ccc137e40..c8a215845 100644
--- a/src/core/hle/service/ns/pl_u.cpp
+++ b/src/core/hle/service/ns/pl_u.cpp
@@ -182,21 +182,18 @@ PL_U::PL_U(Core::System& system_)
        }
        if (!romfs) {
-            LOG_ERROR(Service_NS, "Failed to find or synthesize {:016X}! Skipping",
+            LOG_ERROR(Service_NS, "Failed to find or synthesize {:016X}! Skipping", font.first);
-                      static_cast<u64>(font.first));
            continue;
        }
        const auto extracted_romfs = FileSys::ExtractRomFS(romfs);
        if (!extracted_romfs) {
-            LOG_ERROR(Service_NS, "Failed to extract RomFS for {:016X}! Skipping",
+            LOG_ERROR(Service_NS, "Failed to extract RomFS for {:016X}! Skipping", font.first);
-                      static_cast<u64>(font.first));
            continue;
        }
        const auto font_fp = extracted_romfs->GetFile(font.second);
        if (!font_fp) {
-            LOG_ERROR(Service_NS, "{:016X} has no file \"{}\"! Skipping",
+            LOG_ERROR(Service_NS, "{:016X} has no file \"{}\"! Skipping", font.first, font.second);
-                      static_cast<u64>(font.first), font.second);
            continue;
        }
        std::vector<u32> font_data_u32(font_fp->GetSize() / sizeof(u32));
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.h b/src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.h
index ab152bf0e..d9f95ba58 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.h
+++ b/src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.h
@@ -18,39 +18,6 @@ public:
    explicit nvhost_nvdec_common(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
    ~nvhost_nvdec_common() override;
-    /**
-     * Handles an ioctl1 request.
-     * @param command The ioctl command id.
-     * @param input A buffer containing the input data for the ioctl.
-     * @param output A buffer where the output data will be written to.
-     * @returns The result code of the ioctl.
-     */
-    virtual NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                            IoctlCtrl& ctrl) = 0;
-    /**
-     * Handles an ioctl2 request.
-     * @param command The ioctl command id.
-     * @param input A buffer containing the input data for the ioctl.
-     * @param inline_input A buffer containing the input data for the ioctl which has been inlined.
-     * @param output A buffer where the output data will be written to.
-     * @returns The result code of the ioctl.
-     */
-    virtual NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
-                            const std::vector<u8>& inline_input, std::vector<u8>& output,
-                            IoctlCtrl& ctrl) = 0;
-    /**
-     * Handles an ioctl3 request.
-     * @param command The ioctl command id.
-     * @param input A buffer containing the input data for the ioctl.
-     * @param output A buffer where the output data will be written to.
-     * @param inline_output A buffer where the inlined output data will be written to.
-     * @returns The result code of the ioctl.
-     */
-    virtual NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                            std::vector<u8>& inline_output, IoctlCtrl& ctrl) = 0;
 protected:
    class BufferMap final {
    public:
diff --git a/src/core/hle/service/nvflinger/buffer_queue.cpp b/src/core/hle/service/nvflinger/buffer_queue.cpp
index b89a2d41b..191286ce9 100644
--- a/src/core/hle/service/nvflinger/buffer_queue.cpp
+++ b/src/core/hle/service/nvflinger/buffer_queue.cpp
@@ -153,7 +153,7 @@ void BufferQueue::Disconnect() {
 }
 u32 BufferQueue::Query(QueryType type) {
-    LOG_WARNING(Service, "(STUBBED) called type={}", static_cast<u32>(type));
+    LOG_WARNING(Service, "(STUBBED) called type={}", type);
    switch (type) {
    case QueryType::NativeWindowFormat:
diff --git a/src/core/hle/service/prepo/prepo.cpp b/src/core/hle/service/prepo/prepo.cpp
index 392fda73e..b417624c9 100644
--- a/src/core/hle/service/prepo/prepo.cpp
+++ b/src/core/hle/service/prepo/prepo.cpp
@@ -65,7 +65,7 @@ private:
        }
        LOG_DEBUG(Service_PREPO, "called, type={:02X}, process_id={:016X}, data1_size={:016X}",
-                  static_cast<u8>(Type), process_id, data[0].size());
+                  Type, process_id, data[0].size());
        const auto& reporter{system.GetReporter()};
        reporter.SavePlayReport(Type, system.CurrentProcess()->GetTitleID(), data, process_id);
@@ -92,7 +92,7 @@ private:
        LOG_DEBUG(
            Service_PREPO,
            "called, type={:02X}, user_id={:016X}{:016X}, process_id={:016X}, data1_size={:016X}",
-            static_cast<u8>(Type), user_id[1], user_id[0], process_id, data[0].size());
+            Type, user_id[1], user_id[0], process_id, data[0].size());
        const auto& reporter{system.GetReporter()};
        reporter.SavePlayReport(Type, system.CurrentProcess()->GetTitleID(), data, process_id,
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index 360e0bf37..abf3d1ea3 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -181,7 +181,7 @@ ResultCode ServiceFrameworkBase::HandleSyncRequest(Kernel::HLERequestContext& co
        break;
    }
    default:
-        UNIMPLEMENTED_MSG("command_type={}", static_cast<int>(context.GetCommandType()));
+        UNIMPLEMENTED_MSG("command_type={}", context.GetCommandType());
    }
    context.WriteToOutgoingCommandBuffer(context.GetThread());
diff --git a/src/core/hle/service/set/set_sys.cpp b/src/core/hle/service/set/set_sys.cpp
index 19b8f113d..b58b2c8c5 100644
--- a/src/core/hle/service/set/set_sys.cpp
+++ b/src/core/hle/service/set/set_sys.cpp
@@ -34,9 +34,9 @@ void GetFirmwareVersionImpl(Kernel::HLERequestContext& ctx, GetFirmwareVersionTy
    // consistence (currently reports as 5.1.0-0.0)
    const auto archive = FileSys::SystemArchive::SystemVersion();
-    const auto early_exit_failure = [&ctx](const std::string& desc, ResultCode code) {
+    const auto early_exit_failure = [&ctx](std::string_view desc, ResultCode code) {
        LOG_ERROR(Service_SET, "General failure while attempting to resolve firmware version ({}).",
-                  desc.c_str());
+                  desc);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(code);
    };
diff --git a/src/core/hle/service/sockets/bsd.cpp b/src/core/hle/service/sockets/bsd.cpp
index a9875b9a6..67b419503 100644
--- a/src/core/hle/service/sockets/bsd.cpp
+++ b/src/core/hle/service/sockets/bsd.cpp
@@ -30,7 +30,7 @@ bool IsConnectionBased(Type type) {
    case Type::DGRAM:
        return false;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented type={}", static_cast<int>(type));
+        UNIMPLEMENTED_MSG("Unimplemented type={}", type);
        return false;
    }
 }
@@ -489,18 +489,18 @@ std::pair<s32, Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std::vector<u
    }
    for (PollFD& pollfd : fds) {
-        ASSERT(pollfd.revents == 0);
+        ASSERT(False(pollfd.revents));
        if (pollfd.fd > static_cast<s32>(MAX_FD) || pollfd.fd < 0) {
            LOG_ERROR(Service, "File descriptor handle={} is invalid", pollfd.fd);
-            pollfd.revents = 0;
+            pollfd.revents = PollEvents{};
            return {0, Errno::SUCCESS};
        }
        const std::optional<FileDescriptor>& descriptor = file_descriptors[pollfd.fd];
        if (!descriptor) {
            LOG_ERROR(Service, "File descriptor handle={} is not allocated", pollfd.fd);
-            pollfd.revents = POLL_NVAL;
+            pollfd.revents = PollEvents::Nval;
            return {0, Errno::SUCCESS};
        }
    }
@@ -510,7 +510,7 @@ std::pair<s32, Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std::vector<u
        Network::PollFD result;
        result.socket = file_descriptors[pollfd.fd]->socket.get();
        result.events = TranslatePollEventsToHost(pollfd.events);
-        result.revents = 0;
+        result.revents = Network::PollEvents{};
        return result;
    });
@@ -636,7 +636,7 @@ std::pair<s32, Errno> BSD::FcntlImpl(s32 fd, FcntlCmd cmd, s32 arg) {
        return {0, Errno::SUCCESS};
    }
    default:
-        UNIMPLEMENTED_MSG("Unimplemented cmd={}", static_cast<int>(cmd));
+        UNIMPLEMENTED_MSG("Unimplemented cmd={}", cmd);
        return {-1, Errno::SUCCESS};
    }
 }
@@ -679,7 +679,7 @@ Errno BSD::SetSockOptImpl(s32 fd, u32 level, OptName optname, size_t optlen, con
    case OptName::RCVTIMEO:
        return Translate(socket->SetRcvTimeo(value));
    default:
-        UNIMPLEMENTED_MSG("Unimplemented optname={}", static_cast<int>(optname));
+        UNIMPLEMENTED_MSG("Unimplemented optname={}", optname);
        return Errno::SUCCESS;
    }
 }
diff --git a/src/core/hle/service/sockets/sockets.h b/src/core/hle/service/sockets/sockets.h
index 89a410076..5a65ed2a9 100644
--- a/src/core/hle/service/sockets/sockets.h
+++ b/src/core/hle/service/sockets/sockets.h
@@ -69,10 +69,22 @@ struct SockAddrIn {
    std::array<u8, 8> zeroes;
 };
+enum class PollEvents : u16 {
+    // Using Pascal case because IN is a macro on Windows.
+    In = 1 << 0,
+    Pri = 1 << 1,
+    Out = 1 << 2,
+    Err = 1 << 3,
+    Hup = 1 << 4,
+    Nval = 1 << 5,
+};
+DECLARE_ENUM_FLAG_OPERATORS(PollEvents);
 struct PollFD {
    s32 fd;
-    u16 events;
+    PollEvents events;
-    u16 revents;
+    PollEvents revents;
 };
 struct Linger {
@@ -80,13 +92,6 @@ struct Linger {
    u32 linger;
 };
-constexpr u16 POLL_IN = 0x01;
-constexpr u16 POLL_PRI = 0x02;
-constexpr u16 POLL_OUT = 0x04;
-constexpr u16 POLL_ERR = 0x08;
-constexpr u16 POLL_HUP = 0x10;
-constexpr u16 POLL_NVAL = 0x20;
 constexpr u32 FLAG_MSG_DONTWAIT = 0x80;
 constexpr u32 FLAG_O_NONBLOCK = 0x800;
diff --git a/src/core/hle/service/sockets/sockets_translate.cpp b/src/core/hle/service/sockets/sockets_translate.cpp
index 2e626fd86..c822d21b8 100644
--- a/src/core/hle/service/sockets/sockets_translate.cpp
+++ b/src/core/hle/service/sockets/sockets_translate.cpp
@@ -27,7 +27,7 @@ Errno Translate(Network::Errno value) {
    case Network::Errno::NOTCONN:
        return Errno::NOTCONN;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented errno={}", static_cast<int>(value));
+        UNIMPLEMENTED_MSG("Unimplemented errno={}", value);
        return Errno::SUCCESS;
    }
 }
@@ -41,7 +41,7 @@ Network::Domain Translate(Domain domain) {
    case Domain::INET:
        return Network::Domain::INET;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented domain={}", static_cast<int>(domain));
+        UNIMPLEMENTED_MSG("Unimplemented domain={}", domain);
        return {};
    }
 }
@@ -51,7 +51,7 @@ Domain Translate(Network::Domain domain) {
    case Network::Domain::INET:
        return Domain::INET;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented domain={}", static_cast<int>(domain));
+        UNIMPLEMENTED_MSG("Unimplemented domain={}", domain);
        return {};
    }
 }
@@ -63,7 +63,7 @@ Network::Type Translate(Type type) {
    case Type::DGRAM:
        return Network::Type::DGRAM;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented type={}", static_cast<int>(type));
+        UNIMPLEMENTED_MSG("Unimplemented type={}", type);
    }
 }
@@ -84,48 +84,48 @@ Network::Protocol Translate(Type type, Protocol protocol) {
    case Protocol::UDP:
        return Network::Protocol::UDP;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented protocol={}", static_cast<int>(protocol));
+        UNIMPLEMENTED_MSG("Unimplemented protocol={}", protocol);
        return Network::Protocol::TCP;
    }
 }
-u16 TranslatePollEventsToHost(u32 flags) {
+Network::PollEvents TranslatePollEventsToHost(PollEvents flags) {
-    u32 result = 0;
+    Network::PollEvents result{};
-    const auto translate = [&result, &flags](u32 from, u32 to) {
+    const auto translate = [&result, &flags](PollEvents from, Network::PollEvents to) {
-        if ((flags & from) != 0) {
+        if (True(flags & from)) {
            flags &= ~from;
            result |= to;
        }
    };
-    translate(POLL_IN, Network::POLL_IN);
+    translate(PollEvents::In, Network::PollEvents::In);
-    translate(POLL_PRI, Network::POLL_PRI);
+    translate(PollEvents::Pri, Network::PollEvents::Pri);
-    translate(POLL_OUT, Network::POLL_OUT);
+    translate(PollEvents::Out, Network::PollEvents::Out);
-    translate(POLL_ERR, Network::POLL_ERR);
+    translate(PollEvents::Err, Network::PollEvents::Err);
-    translate(POLL_HUP, Network::POLL_HUP);
+    translate(PollEvents::Hup, Network::PollEvents::Hup);
-    translate(POLL_NVAL, Network::POLL_NVAL);
+    translate(PollEvents::Nval, Network::PollEvents::Nval);
-    UNIMPLEMENTED_IF_MSG(flags != 0, "Unimplemented flags={}", flags);
+    UNIMPLEMENTED_IF_MSG((u16)flags != 0, "Unimplemented flags={}", (u16)flags);
-    return static_cast<u16>(result);
+    return result;
 }
-u16 TranslatePollEventsToGuest(u32 flags) {
+PollEvents TranslatePollEventsToGuest(Network::PollEvents flags) {
-    u32 result = 0;
+    PollEvents result{};
-    const auto translate = [&result, &flags](u32 from, u32 to) {
+    const auto translate = [&result, &flags](Network::PollEvents from, PollEvents to) {
-        if ((flags & from) != 0) {
+        if (True(flags & from)) {
            flags &= ~from;
            result |= to;
        }
    };
-    translate(Network::POLL_IN, POLL_IN);
+    translate(Network::PollEvents::In, PollEvents::In);
-    translate(Network::POLL_PRI, POLL_PRI);
+    translate(Network::PollEvents::Pri, PollEvents::Pri);
-    translate(Network::POLL_OUT, POLL_OUT);
+    translate(Network::PollEvents::Out, PollEvents::Out);
-    translate(Network::POLL_ERR, POLL_ERR);
+    translate(Network::PollEvents::Err, PollEvents::Err);
-    translate(Network::POLL_HUP, POLL_HUP);
+    translate(Network::PollEvents::Hup, PollEvents::Hup);
-    translate(Network::POLL_NVAL, POLL_NVAL);
+    translate(Network::PollEvents::Nval, PollEvents::Nval);
-    UNIMPLEMENTED_IF_MSG(flags != 0, "Unimplemented flags={}", flags);
+    UNIMPLEMENTED_IF_MSG((u16)flags != 0, "Unimplemented flags={}", (u16)flags);
-    return static_cast<u16>(result);
+    return result;
 }
 Network::SockAddrIn Translate(SockAddrIn value) {
@@ -157,7 +157,7 @@ Network::ShutdownHow Translate(ShutdownHow how) {
    case ShutdownHow::RDWR:
        return Network::ShutdownHow::RDWR;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented how={}", static_cast<int>(how));
+        UNIMPLEMENTED_MSG("Unimplemented how={}", how);
        return {};
    }
 }
diff --git a/src/core/hle/service/sockets/sockets_translate.h b/src/core/hle/service/sockets/sockets_translate.h
index e498913d4..057d1ff22 100644
--- a/src/core/hle/service/sockets/sockets_translate.h
+++ b/src/core/hle/service/sockets/sockets_translate.h
@@ -31,10 +31,10 @@ Network::Type Translate(Type type);
 Network::Protocol Translate(Type type, Protocol protocol);
 /// Translate abstract poll event flags to guest poll event flags
-u16 TranslatePollEventsToHost(u32 flags);
+Network::PollEvents TranslatePollEventsToHost(PollEvents flags);
 /// Translate guest poll event flags to abstract poll event flags
-u16 TranslatePollEventsToGuest(u32 flags);
+PollEvents TranslatePollEventsToGuest(Network::PollEvents flags);
 /// Translate guest socket address structure to abstract socket address structure
 Network::SockAddrIn Translate(SockAddrIn value);
diff --git a/src/core/hle/service/vi/vi.cpp b/src/core/hle/service/vi/vi.cpp
index af5b8b0b9..5d8841ae8 100644
--- a/src/core/hle/service/vi/vi.cpp
+++ b/src/core/hle/service/vi/vi.cpp
@@ -528,7 +528,7 @@ private:
        const u32 flags = rp.Pop<u32>();
        LOG_DEBUG(Service_VI, "called. id=0x{:08X} transaction={:X}, flags=0x{:08X}", id,
-                  static_cast<u32>(transaction), flags);
+                  transaction, flags);
        const auto guard = nv_flinger.Lock();
        auto& buffer_queue = nv_flinger.FindBufferQueue(id);
@@ -1066,8 +1066,8 @@ private:
        const auto scaling_mode = rp.PopEnum<NintendoScaleMode>();
        const u64 unknown = rp.Pop<u64>();
-        LOG_DEBUG(Service_VI, "called. scaling_mode=0x{:08X}, unknown=0x{:016X}",
+        LOG_DEBUG(Service_VI, "called. scaling_mode=0x{:08X}, unknown=0x{:016X}", scaling_mode,
-                  static_cast<u32>(scaling_mode), unknown);
+                  unknown);
        IPC::ResponseBuilder rb{ctx, 2};
@@ -1210,7 +1210,7 @@ private:
    void ConvertScalingMode(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const auto mode = rp.PopEnum<NintendoScaleMode>();
-        LOG_DEBUG(Service_VI, "called mode={}", static_cast<u32>(mode));
+        LOG_DEBUG(Service_VI, "called mode={}", mode);
        const auto converted_mode = ConvertScalingModeImpl(mode);
@@ -1230,8 +1230,8 @@ private:
        const auto height = rp.Pop<u64>();
        LOG_DEBUG(Service_VI, "called width={}, height={}", width, height);
-        constexpr std::size_t base_size = 0x20000;
+        constexpr u64 base_size = 0x20000;
-        constexpr std::size_t alignment = 0x1000;
+        constexpr u64 alignment = 0x1000;
        const auto texture_size = width * height * 4;
        const auto out_size = (texture_size + base_size - 1) / base_size * base_size;
@@ -1311,7 +1311,7 @@ void detail::GetDisplayServiceImpl(Kernel::HLERequestContext& ctx, Core::System&
    const auto policy = rp.PopEnum<Policy>();
    if (!IsValidServiceAccess(permission, policy)) {
-        LOG_ERROR(Service_VI, "Permission denied for policy {}", static_cast<u32>(policy));
+        LOG_ERROR(Service_VI, "Permission denied for policy {}", policy);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(ERR_PERMISSION_DENIED);
        return;
diff --git a/src/core/memory.cpp b/src/core/memory.cpp
index b88aa5c40..b7f21698f 100644
--- a/src/core/memory.cpp
+++ b/src/core/memory.cpp
@@ -667,8 +667,6 @@ struct Memory::Impl {
     * @tparam T The data type to write to memory. This type *must* be
     *           trivially copyable, otherwise the behavior of this function
     *           is undefined.
-     *
-     * @returns The instance of T write to the specified virtual address.
     */
    template <typename T>
    void Write(const VAddr vaddr, const T data) {
diff --git a/src/core/network/network.cpp b/src/core/network/network.cpp
index 5ef2e8511..681e93468 100644
--- a/src/core/network/network.cpp
+++ b/src/core/network/network.cpp
@@ -11,7 +11,7 @@
 #ifdef _WIN32
 #define _WINSOCK_DEPRECATED_NO_WARNINGS // gethostname
 #include <winsock2.h>
-#elif __unix__
+#elif YUZU_UNIX
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
@@ -54,7 +54,7 @@ constexpr IPv4Address TranslateIPv4(in_addr addr) {
 sockaddr TranslateFromSockAddrIn(SockAddrIn input) {
    sockaddr_in result;
-#ifdef __unix__
+#if YUZU_UNIX
    result.sin_len = sizeof(result);
 #endif
@@ -63,7 +63,7 @@ sockaddr TranslateFromSockAddrIn(SockAddrIn input) {
        result.sin_family = AF_INET;
        break;
    default:
-        UNIMPLEMENTED_MSG("Unhandled sockaddr family={}", static_cast<int>(input.family));
+        UNIMPLEMENTED_MSG("Unhandled sockaddr family={}", input.family);
        result.sin_family = AF_INET;
        break;
    }
@@ -99,7 +99,7 @@ bool EnableNonBlock(SOCKET fd, bool enable) {
    return ioctlsocket(fd, FIONBIO, &value) != SOCKET_ERROR;
 }
-#elif __unix__ // ^ _WIN32 v __unix__
+#elif YUZU_UNIX // ^ _WIN32 v YUZU_UNIX
 using SOCKET = int;
 using WSAPOLLFD = pollfd;
@@ -133,7 +133,7 @@ sockaddr TranslateFromSockAddrIn(SockAddrIn input) {
        result.sin_family = AF_INET;
        break;
    default:
-        UNIMPLEMENTED_MSG("Unhandled sockaddr family={}", static_cast<int>(input.family));
+        UNIMPLEMENTED_MSG("Unhandled sockaddr family={}", input.family);
        result.sin_family = AF_INET;
        break;
    }
@@ -186,7 +186,7 @@ int TranslateDomain(Domain domain) {
    case Domain::INET:
        return AF_INET;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented domain={}", static_cast<int>(domain));
+        UNIMPLEMENTED_MSG("Unimplemented domain={}", domain);
        return 0;
    }
 }
@@ -198,7 +198,7 @@ int TranslateType(Type type) {
    case Type::DGRAM:
        return SOCK_DGRAM;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented type={}", static_cast<int>(type));
+        UNIMPLEMENTED_MSG("Unimplemented type={}", type);
        return 0;
    }
 }
@@ -210,7 +210,7 @@ int TranslateProtocol(Protocol protocol) {
    case Protocol::UDP:
        return IPPROTO_UDP;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented protocol={}", static_cast<int>(protocol));
+        UNIMPLEMENTED_MSG("Unimplemented protocol={}", protocol);
        return 0;
    }
 }
@@ -238,49 +238,49 @@ SockAddrIn TranslateToSockAddrIn(sockaddr input_) {
    return result;
 }
-u16 TranslatePollEvents(u32 events) {
+short TranslatePollEvents(PollEvents events) {
-    u32 result = 0;
+    short result = 0;
-    if ((events & POLL_IN) != 0) {
+    if (True(events & PollEvents::In)) {
-        events &= ~POLL_IN;
+        events &= ~PollEvents::In;
        result |= POLLIN;
    }
-    if ((events & POLL_PRI) != 0) {
+    if (True(events & PollEvents::Pri)) {
-        events &= ~POLL_PRI;
+        events &= ~PollEvents::Pri;
 #ifdef _WIN32
        LOG_WARNING(Service, "Winsock doesn't support POLLPRI");
 #else
-        result |= POLL_PRI;
+        result |= POLLPRI;
 #endif
    }
-    if ((events & POLL_OUT) != 0) {
+    if (True(events & PollEvents::Out)) {
-        events &= ~POLL_OUT;
+        events &= ~PollEvents::Out;
        result |= POLLOUT;
    }
-    UNIMPLEMENTED_IF_MSG(events != 0, "Unhandled guest events=0x{:x}", events);
+    UNIMPLEMENTED_IF_MSG((u16)events != 0, "Unhandled guest events=0x{:x}", (u16)events);
-    return static_cast<u16>(result);
+    return result;
 }
-u16 TranslatePollRevents(u32 revents) {
+PollEvents TranslatePollRevents(short revents) {
-    u32 result = 0;
+    PollEvents result{};
-    const auto translate = [&result, &revents](u32 host, u32 guest) {
+    const auto translate = [&result, &revents](short host, PollEvents guest) {
        if ((revents & host) != 0) {
-            revents &= ~host;
+            revents &= static_cast<short>(~host);
            result |= guest;
        }
    };
-    translate(POLLIN, POLL_IN);
+    translate(POLLIN, PollEvents::In);
-    translate(POLLPRI, POLL_PRI);
+    translate(POLLPRI, PollEvents::Pri);
-    translate(POLLOUT, POLL_OUT);
+    translate(POLLOUT, PollEvents::Out);
-    translate(POLLERR, POLL_ERR);
+    translate(POLLERR, PollEvents::Err);
-    translate(POLLHUP, POLL_HUP);
+    translate(POLLHUP, PollEvents::Hup);
    UNIMPLEMENTED_IF_MSG(revents != 0, "Unhandled host revents=0x{:x}", revents);
-    return static_cast<u16>(result);
+    return result;
 }
 template <typename T>
@@ -350,7 +350,7 @@ std::pair<s32, Errno> Poll(std::vector<PollFD>& pollfds, s32 timeout) {
    }
    for (size_t i = 0; i < num; ++i) {
-        pollfds[i].revents = TranslatePollRevents(static_cast<u32>(host_pollfds[i].revents));
+        pollfds[i].revents = TranslatePollRevents(host_pollfds[i].revents);
    }
    if (result > 0) {
@@ -482,7 +482,7 @@ Errno Socket::Shutdown(ShutdownHow how) {
        host_how = SD_BOTH;
        break;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented flag how={}", static_cast<int>(how));
+        UNIMPLEMENTED_MSG("Unimplemented flag how={}", how);
        return Errno::SUCCESS;
    }
    if (shutdown(fd, host_how) != SOCKET_ERROR) {
diff --git a/src/core/network/network.h b/src/core/network/network.h
index 0622e4593..76b2821f2 100644
--- a/src/core/network/network.h
+++ b/src/core/network/network.h
@@ -61,19 +61,25 @@ struct SockAddrIn {
 };
 /// Cross-platform poll fd structure
+enum class PollEvents : u16 {
+    // Using Pascal case because IN is a macro on Windows.
+    In = 1 << 0,
+    Pri = 1 << 1,
+    Out = 1 << 2,
+    Err = 1 << 3,
+    Hup = 1 << 4,
+    Nval = 1 << 5,
+};
+DECLARE_ENUM_FLAG_OPERATORS(PollEvents);
 struct PollFD {
    Socket* socket;
-    u16 events;
+    PollEvents events;
-    u16 revents;
+    PollEvents revents;
 };
-constexpr u16 POLL_IN = 1 << 0;
-constexpr u16 POLL_PRI = 1 << 1;
-constexpr u16 POLL_OUT = 1 << 2;
-constexpr u16 POLL_ERR = 1 << 3;
-constexpr u16 POLL_HUP = 1 << 4;
-constexpr u16 POLL_NVAL = 1 << 5;
 class NetworkInstance {
 public:
    explicit NetworkInstance();
diff --git a/src/core/network/sockets.h b/src/core/network/sockets.h
index 7bdff0fe4..a44393325 100644
--- a/src/core/network/sockets.h
+++ b/src/core/network/sockets.h
@@ -9,7 +9,7 @@
 #if defined(_WIN32)
 #include <winsock.h>
-#elif !defined(__unix__)
+#elif !YUZU_UNIX
 #error "Platform not implemented"
 #endif
@@ -84,7 +84,7 @@ public:
 #if defined(_WIN32)
    SOCKET fd = INVALID_SOCKET;
-#elif defined(__unix__)
+#elif YUZU_UNIX
    int fd = -1;
 #endif
 };
diff --git a/src/core/settings.h b/src/core/settings.h
index 8e076f7ef..d5f8d2b7e 100644
--- a/src/core/settings.h
+++ b/src/core/settings.h
@@ -180,6 +180,8 @@ struct Values {
    std::string motion_device;
    std::string udp_input_servers;
+    bool emulate_analog_keyboard;
    bool mouse_enabled;
    std::string mouse_device;
    MouseButtonsRaw mouse_buttons;
diff --git a/src/input_common/analog_from_button.cpp b/src/input_common/analog_from_button.cpp
index d748c1c04..40b516f85 100755
--- a/src/input_common/analog_from_button.cpp
+++ b/src/input_common/analog_from_button.cpp
@@ -6,6 +6,7 @@
 #include <cmath>
 #include <thread>
 #include "common/math_util.h"
+#include "core/settings.h"
 #include "input_common/analog_from_button.h"
 namespace InputCommon {
@@ -112,7 +113,26 @@ public:
    }
    std::tuple<float, float> GetStatus() const override {
-        return std::make_tuple(std::cos(angle) * amplitude, std::sin(angle) * amplitude);
+        if (Settings::values.emulate_analog_keyboard) {
+            return std::make_tuple(std::cos(angle) * amplitude, std::sin(angle) * amplitude);
+        }
+        constexpr float SQRT_HALF = 0.707106781f;
+        int x = 0, y = 0;
+        if (right->GetStatus()) {
+            ++x;
+        }
+        if (left->GetStatus()) {
+            --x;
+        }
+        if (up->GetStatus()) {
+            ++y;
+        }
+        if (down->GetStatus()) {
+            --y;
+        }
+        const float coef = modifier->GetStatus() ? modifier_scale : 1.0f;
+        return std::make_tuple(static_cast<float>(x) * coef * (y == 0 ? 1.0f : SQRT_HALF),
+                               static_cast<float>(y) * coef * (x == 0 ? 1.0f : SQRT_HALF));
    }
    bool GetAnalogDirectionStatus(Input::AnalogDirection direction) const override {
diff --git a/src/video_core/CMakeLists.txt b/src/video_core/CMakeLists.txt
index abcee2a1c..a021d61f5 100644
--- a/src/video_core/CMakeLists.txt
+++ b/src/video_core/CMakeLists.txt
@@ -297,13 +297,20 @@ if (ENABLE_NSIGHT_AFTERMATH)
 endif()
 if (MSVC)
-    target_compile_options(video_core PRIVATE /we4267)
+    target_compile_options(video_core PRIVATE
+        /we4267 # 'var' : conversion from 'size_t' to 'type', possible loss of data
+        /we4456 # Declaration of 'identifier' hides previous local declaration
+        /we4457 # Declaration of 'identifier' hides function parameter
+        /we4458 # Declaration of 'identifier' hides class member
+        /we4459 # Declaration of 'identifier' hides global declaration
+    )
 else()
    target_compile_options(video_core PRIVATE
        -Werror=conversion
        -Wno-error=sign-conversion
        -Werror=pessimizing-move
        -Werror=redundant-move
+        -Werror=shadow
        -Werror=switch
        -Werror=type-limits
        -Werror=unused-variable
diff --git a/src/video_core/buffer_cache/buffer_block.h b/src/video_core/buffer_cache/buffer_block.h
index e64170e66..e9306194a 100644
--- a/src/video_core/buffer_cache/buffer_block.h
+++ b/src/video_core/buffer_cache/buffer_block.h
@@ -4,34 +4,29 @@
 #pragma once
-#include <unordered_set>
-#include <utility>
-#include "common/alignment.h"
 #include "common/common_types.h"
-#include "video_core/gpu.h"
 namespace VideoCommon {
 class BufferBlock {
 public:
-    bool Overlaps(VAddr start, VAddr end) const {
+    [[nodiscard]] bool Overlaps(VAddr start, VAddr end) const {
        return (cpu_addr < end) && (cpu_addr_end > start);
    }
-    bool IsInside(VAddr other_start, VAddr other_end) const {
+    [[nodiscard]] bool IsInside(VAddr other_start, VAddr other_end) const {
        return cpu_addr <= other_start && other_end <= cpu_addr_end;
    }
-    std::size_t Offset(VAddr in_addr) const {
+    [[nodiscard]] std::size_t Offset(VAddr in_addr) const {
        return static_cast<std::size_t>(in_addr - cpu_addr);
    }
-    VAddr CpuAddr() const {
+    [[nodiscard]] VAddr CpuAddr() const {
        return cpu_addr;
    }
-    VAddr CpuAddrEnd() const {
+    [[nodiscard]] VAddr CpuAddrEnd() const {
        return cpu_addr_end;
    }
@@ -40,11 +35,11 @@ public:
        cpu_addr_end = new_addr + size;
    }
-    std::size_t Size() const {
+    [[nodiscard]] std::size_t Size() const {
        return size;
    }
-    u64 Epoch() const {
+    [[nodiscard]] u64 Epoch() const {
        return epoch;
    }
diff --git a/src/video_core/buffer_cache/buffer_cache.h b/src/video_core/buffer_cache/buffer_cache.h
index e7edd733f..38961f3fd 100644
--- a/src/video_core/buffer_cache/buffer_cache.h
+++ b/src/video_core/buffer_cache/buffer_cache.h
@@ -545,7 +545,7 @@ private:
    bool IsRegionWritten(VAddr start, VAddr end) const {
        const u64 page_end = end >> WRITE_PAGE_BIT;
        for (u64 page_start = start >> WRITE_PAGE_BIT; page_start <= page_end; ++page_start) {
-            if (written_pages.count(page_start) > 0) {
+            if (written_pages.contains(page_start)) {
                return true;
            }
        }
diff --git a/src/video_core/buffer_cache/map_interval.h b/src/video_core/buffer_cache/map_interval.h
index fe0bcd1d8..ef974b08a 100644
--- a/src/video_core/buffer_cache/map_interval.h
+++ b/src/video_core/buffer_cache/map_interval.h
@@ -84,9 +84,10 @@ private:
    void FillFreeList(Chunk& chunk);
    std::vector<MapInterval*> free_list;
-    std::unique_ptr<Chunk>* new_chunk = &first_chunk.next;
    Chunk first_chunk;
+    std::unique_ptr<Chunk>* new_chunk = &first_chunk.next;
 };
 } // namespace VideoCommon
diff --git a/src/video_core/cdma_pusher.cpp b/src/video_core/cdma_pusher.cpp
index b60f86260..e3e7432f7 100644
--- a/src/video_core/cdma_pusher.cpp
+++ b/src/video_core/cdma_pusher.cpp
@@ -29,8 +29,8 @@
 #include "video_core/memory_manager.h"
 namespace Tegra {
-CDmaPusher::CDmaPusher(GPU& gpu)
+CDmaPusher::CDmaPusher(GPU& gpu_)
-    : gpu(gpu), nvdec_processor(std::make_shared<Nvdec>(gpu)),
+    : gpu{gpu_}, nvdec_processor(std::make_shared<Nvdec>(gpu)),
      vic_processor(std::make_unique<Vic>(gpu, nvdec_processor)),
      host1x_processor(std::make_unique<Host1x>(gpu)),
      nvdec_sync(std::make_unique<SyncptIncrManager>(gpu)),
@@ -100,11 +100,11 @@ void CDmaPusher::Step() {
    }
 }
-void CDmaPusher::ExecuteCommand(u32 offset, u32 data) {
+void CDmaPusher::ExecuteCommand(u32 state_offset, u32 data) {
    switch (current_class) {
    case ChClassId::NvDec:
-        ThiStateWrite(nvdec_thi_state, offset, {data});
+        ThiStateWrite(nvdec_thi_state, state_offset, {data});
-        switch (static_cast<ThiMethod>(offset)) {
+        switch (static_cast<ThiMethod>(state_offset)) {
        case ThiMethod::IncSyncpt: {
            LOG_DEBUG(Service_NVDRV, "NVDEC Class IncSyncpt Method");
            const auto syncpoint_id = static_cast<u32>(data & 0xFF);
@@ -120,16 +120,16 @@ void CDmaPusher::ExecuteCommand(u32 offset, u32 data) {
        case ThiMethod::SetMethod1:
            LOG_DEBUG(Service_NVDRV, "NVDEC method 0x{:X}",
                      static_cast<u32>(nvdec_thi_state.method_0));
-            nvdec_processor->ProcessMethod(
+            nvdec_processor->ProcessMethod(static_cast<Nvdec::Method>(nvdec_thi_state.method_0),
-                static_cast<Tegra::Nvdec::Method>(nvdec_thi_state.method_0), {data});
+                                           {data});
            break;
        default:
            break;
        }
        break;
    case ChClassId::GraphicsVic:
-        ThiStateWrite(vic_thi_state, static_cast<u32>(offset), {data});
+        ThiStateWrite(vic_thi_state, static_cast<u32>(state_offset), {data});
-        switch (static_cast<ThiMethod>(offset)) {
+        switch (static_cast<ThiMethod>(state_offset)) {
        case ThiMethod::IncSyncpt: {
            LOG_DEBUG(Service_NVDRV, "VIC Class IncSyncpt Method");
            const auto syncpoint_id = static_cast<u32>(data & 0xFF);
@@ -145,8 +145,7 @@ void CDmaPusher::ExecuteCommand(u32 offset, u32 data) {
        case ThiMethod::SetMethod1:
            LOG_DEBUG(Service_NVDRV, "VIC method 0x{:X}, Args=({})",
                      static_cast<u32>(vic_thi_state.method_0), data);
-            vic_processor->ProcessMethod(static_cast<Tegra::Vic::Method>(vic_thi_state.method_0),
+            vic_processor->ProcessMethod(static_cast<Vic::Method>(vic_thi_state.method_0), {data});
-                                         {data});
            break;
        default:
            break;
@@ -155,7 +154,7 @@ void CDmaPusher::ExecuteCommand(u32 offset, u32 data) {
    case ChClassId::Host1x:
        // This device is mainly for syncpoint synchronization
        LOG_DEBUG(Service_NVDRV, "Host1X Class Method");
-        host1x_processor->ProcessMethod(static_cast<Tegra::Host1x::Method>(offset), {data});
+        host1x_processor->ProcessMethod(static_cast<Host1x::Method>(state_offset), {data});
        break;
    default:
        UNIMPLEMENTED_MSG("Current class not implemented {:X}", static_cast<u32>(current_class));
@@ -163,9 +162,10 @@ void CDmaPusher::ExecuteCommand(u32 offset, u32 data) {
    }
 }
-void CDmaPusher::ThiStateWrite(ThiRegisters& state, u32 offset, const std::vector<u32>& arguments) {
+void CDmaPusher::ThiStateWrite(ThiRegisters& state, u32 state_offset,
-    u8* const state_offset = reinterpret_cast<u8*>(&state) + sizeof(u32) * offset;
+                               const std::vector<u32>& arguments) {
-    std::memcpy(state_offset, arguments.data(), sizeof(u32) * arguments.size());
+    u8* const state_offset_ptr = reinterpret_cast<u8*>(&state) + sizeof(u32) * state_offset;
+    std::memcpy(state_offset_ptr, arguments.data(), sizeof(u32) * arguments.size());
 }
 } // namespace Tegra
diff --git a/src/video_core/cdma_pusher.h b/src/video_core/cdma_pusher.h
index 982f309c5..0db1cd646 100644
--- a/src/video_core/cdma_pusher.h
+++ b/src/video_core/cdma_pusher.h
@@ -68,8 +68,8 @@ struct ChCommand {
    std::vector<u32> arguments;
 };
-using ChCommandHeaderList = std::vector<Tegra::ChCommandHeader>;
+using ChCommandHeaderList = std::vector<ChCommandHeader>;
-using ChCommandList = std::vector<Tegra::ChCommand>;
+using ChCommandList = std::vector<ChCommand>;
 struct ThiRegisters {
    u32_le increment_syncpt{};
@@ -96,7 +96,7 @@ enum class ThiMethod : u32 {
 class CDmaPusher {
 public:
-    explicit CDmaPusher(GPU& gpu);
+    explicit CDmaPusher(GPU& gpu_);
    ~CDmaPusher();
    /// Push NVDEC command buffer entries into queue
@@ -109,17 +109,17 @@ public:
    void Step();
    /// Invoke command class devices to execute the command based on the current state
-    void ExecuteCommand(u32 offset, u32 data);
+    void ExecuteCommand(u32 state_offset, u32 data);
 private:
    /// Write arguments value to the ThiRegisters member at the specified offset
-    void ThiStateWrite(ThiRegisters& state, u32 offset, const std::vector<u32>& arguments);
+    void ThiStateWrite(ThiRegisters& state, u32 state_offset, const std::vector<u32>& arguments);
    GPU& gpu;
-    std::shared_ptr<Tegra::Nvdec> nvdec_processor;
+    std::shared_ptr<Nvdec> nvdec_processor;
-    std::unique_ptr<Tegra::Vic> vic_processor;
+    std::unique_ptr<Vic> vic_processor;
-    std::unique_ptr<Tegra::Host1x> host1x_processor;
+    std::unique_ptr<Host1x> host1x_processor;
    std::unique_ptr<SyncptIncrManager> nvdec_sync;
    std::unique_ptr<SyncptIncrManager> vic_sync;
    ChClassId current_class{};
diff --git a/src/video_core/command_classes/codecs/codec.cpp b/src/video_core/command_classes/codecs/codec.cpp
index 9a88f64e4..39bc923a5 100644
--- a/src/video_core/command_classes/codecs/codec.cpp
+++ b/src/video_core/command_classes/codecs/codec.cpp
@@ -44,7 +44,7 @@ Codec::~Codec() {
 }
 void Codec::SetTargetCodec(NvdecCommon::VideoCodec codec) {
-    LOG_INFO(Service_NVDRV, "NVDEC video codec initialized to {}", static_cast<u32>(codec));
+    LOG_INFO(Service_NVDRV, "NVDEC video codec initialized to {}", codec);
    current_codec = codec;
 }
@@ -62,12 +62,11 @@ void Codec::Decode() {
        } else if (current_codec == NvdecCommon::VideoCodec::Vp9) {
            av_codec = avcodec_find_decoder(AV_CODEC_ID_VP9);
        } else {
-            LOG_ERROR(Service_NVDRV, "Unknown video codec {}", static_cast<u32>(current_codec));
+            LOG_ERROR(Service_NVDRV, "Unknown video codec {}", current_codec);
            return;
        }
        av_codec_ctx = avcodec_alloc_context3(av_codec);
-        av_codec_ctx->refcounted_frames = 1;
        av_opt_set(av_codec_ctx->priv_data, "tune", "zerolatency", 0);
        // TODO(ameerj): libavcodec gpu hw acceleration
diff --git a/src/video_core/command_classes/codecs/vp9.cpp b/src/video_core/command_classes/codecs/vp9.cpp
index 7d8d6ee3c..59e586695 100644
--- a/src/video_core/command_classes/codecs/vp9.cpp
+++ b/src/video_core/command_classes/codecs/vp9.cpp
@@ -233,7 +233,7 @@ constexpr std::array<s32, 254> map_lut{
 }
 } // Anonymous namespace
-VP9::VP9(GPU& gpu) : gpu(gpu) {}
+VP9::VP9(GPU& gpu_) : gpu{gpu_} {}
 VP9::~VP9() = default;
@@ -374,43 +374,43 @@ void VP9::InsertEntropy(u64 offset, Vp9EntropyProbs& dst) {
 }
 Vp9FrameContainer VP9::GetCurrentFrame(const NvdecCommon::NvdecRegisters& state) {
-    Vp9FrameContainer frame{};
+    Vp9FrameContainer current_frame{};
    {
        gpu.SyncGuestHost();
-        frame.info = GetVp9PictureInfo(state);
+        current_frame.info = GetVp9PictureInfo(state);
-        frame.bit_stream.resize(frame.info.bitstream_size);
+        current_frame.bit_stream.resize(current_frame.info.bitstream_size);
-        gpu.MemoryManager().ReadBlock(state.frame_bitstream_offset, frame.bit_stream.data(),
+        gpu.MemoryManager().ReadBlock(state.frame_bitstream_offset, current_frame.bit_stream.data(),
-                                      frame.info.bitstream_size);
+                                      current_frame.info.bitstream_size);
    }
    // Buffer two frames, saving the last show frame info
    if (!next_next_frame.bit_stream.empty()) {
        Vp9FrameContainer temp{
-            .info = frame.info,
+            .info = current_frame.info,
-            .bit_stream = std::move(frame.bit_stream),
+            .bit_stream = std::move(current_frame.bit_stream),
        };
-        next_next_frame.info.show_frame = frame.info.last_frame_shown;
+        next_next_frame.info.show_frame = current_frame.info.last_frame_shown;
-        frame.info = next_next_frame.info;
+        current_frame.info = next_next_frame.info;
-        frame.bit_stream = std::move(next_next_frame.bit_stream);
+        current_frame.bit_stream = std::move(next_next_frame.bit_stream);
        next_next_frame = std::move(temp);
        if (!next_frame.bit_stream.empty()) {
            Vp9FrameContainer temp2{
-                .info = frame.info,
+                .info = current_frame.info,
-                .bit_stream = std::move(frame.bit_stream),
+                .bit_stream = std::move(current_frame.bit_stream),
            };
-            next_frame.info.show_frame = frame.info.last_frame_shown;
+            next_frame.info.show_frame = current_frame.info.last_frame_shown;
-            frame.info = next_frame.info;
+            current_frame.info = next_frame.info;
-            frame.bit_stream = std::move(next_frame.bit_stream);
+            current_frame.bit_stream = std::move(next_frame.bit_stream);
            next_frame = std::move(temp2);
        } else {
-            next_frame.info = frame.info;
+            next_frame.info = current_frame.info;
-            next_frame.bit_stream = std::move(frame.bit_stream);
+            next_frame.bit_stream = std::move(current_frame.bit_stream);
        }
    } else {
-        next_next_frame.info = frame.info;
+        next_next_frame.info = current_frame.info;
-        next_next_frame.bit_stream = std::move(frame.bit_stream);
+        next_next_frame.bit_stream = std::move(current_frame.bit_stream);
    }
-    return frame;
+    return current_frame;
 }
 std::vector<u8> VP9::ComposeCompressedHeader() {
diff --git a/src/video_core/command_classes/codecs/vp9.h b/src/video_core/command_classes/codecs/vp9.h
index 9ebbbf59e..8396c8105 100644
--- a/src/video_core/command_classes/codecs/vp9.h
+++ b/src/video_core/command_classes/codecs/vp9.h
@@ -108,7 +108,7 @@ private:
 class VP9 {
 public:
-    explicit VP9(GPU& gpu);
+    explicit VP9(GPU& gpu_);
    ~VP9();
    VP9(const VP9&) = delete;
diff --git a/src/video_core/command_classes/vic.cpp b/src/video_core/command_classes/vic.cpp
index 6cfc193fa..66e21ce9c 100644
--- a/src/video_core/command_classes/vic.cpp
+++ b/src/video_core/command_classes/vic.cpp
@@ -27,7 +27,7 @@ void Vic::VicStateWrite(u32 offset, u32 arguments) {
 }
 void Vic::ProcessMethod(Method method, const std::vector<u32>& arguments) {
-    LOG_DEBUG(HW_GPU, "Vic method 0x{:X}", static_cast<u32>(method));
+    LOG_DEBUG(HW_GPU, "Vic method 0x{:X}", method);
    VicStateWrite(static_cast<u32>(method), arguments[0]);
    const u64 arg = static_cast<u64>(arguments[0]) << 8;
    switch (method) {
diff --git a/src/video_core/dirty_flags.cpp b/src/video_core/dirty_flags.cpp
index e16075993..2faa6ef0e 100644
--- a/src/video_core/dirty_flags.cpp
+++ b/src/video_core/dirty_flags.cpp
@@ -9,7 +9,7 @@
 #include "video_core/dirty_flags.h"
 #define OFF(field_name) MAXWELL3D_REG_INDEX(field_name)
-#define NUM(field_name) (sizeof(::Tegra::Engines::Maxwell3D::Regs::field_name) / sizeof(u32))
+#define NUM(field_name) (sizeof(::Tegra::Engines::Maxwell3D::Regs::field_name) / (sizeof(u32)))
 namespace VideoCommon::Dirty {
diff --git a/src/video_core/dma_pusher.cpp b/src/video_core/dma_pusher.cpp
index d8801b1f5..2c8b20024 100644
--- a/src/video_core/dma_pusher.cpp
+++ b/src/video_core/dma_pusher.cpp
@@ -13,7 +13,7 @@
 namespace Tegra {
-DmaPusher::DmaPusher(Core::System& system, GPU& gpu) : gpu{gpu}, system{system} {}
+DmaPusher::DmaPusher(Core::System& system_, GPU& gpu_) : gpu{gpu_}, system{system_} {}
 DmaPusher::~DmaPusher() = default;
@@ -152,7 +152,12 @@ void DmaPusher::SetState(const CommandHeader& command_header) {
 void DmaPusher::CallMethod(u32 argument) const {
    if (dma_state.method < non_puller_methods) {
-        gpu.CallMethod({dma_state.method, argument, dma_state.subchannel, dma_state.method_count});
+        gpu.CallMethod(GPU::MethodCall{
+            dma_state.method,
+            argument,
+            dma_state.subchannel,
+            dma_state.method_count,
+        });
    } else {
        subchannels[dma_state.subchannel]->CallMethod(dma_state.method, argument,
                                                      dma_state.is_last_call);
diff --git a/src/video_core/dma_pusher.h b/src/video_core/dma_pusher.h
index 96ac267f7..19f286fa7 100644
--- a/src/video_core/dma_pusher.h
+++ b/src/video_core/dma_pusher.h
@@ -87,11 +87,11 @@ inline CommandHeader BuildCommandHeader(BufferMethods method, u32 arg_count, Sub
 struct CommandList final {
    CommandList() = default;
    explicit CommandList(std::size_t size) : command_lists(size) {}
-    explicit CommandList(std::vector<Tegra::CommandHeader>&& prefetch_command_list)
+    explicit CommandList(std::vector<CommandHeader>&& prefetch_command_list_)
-        : prefetch_command_list{std::move(prefetch_command_list)} {}
+        : prefetch_command_list{std::move(prefetch_command_list_)} {}
-    std::vector<Tegra::CommandListHeader> command_lists;
+    std::vector<CommandListHeader> command_lists;
-    std::vector<Tegra::CommandHeader> prefetch_command_list;
+    std::vector<CommandHeader> prefetch_command_list;
 };
 /**
@@ -103,7 +103,7 @@ struct CommandList final {
 */
 class DmaPusher final {
 public:
-    explicit DmaPusher(Core::System& system, GPU& gpu);
+    explicit DmaPusher(Core::System& system_, GPU& gpu_);
    ~DmaPusher();
    void Push(CommandList&& entries) {
@@ -112,7 +112,7 @@ public:
    void DispatchCalls();
-    void BindSubchannel(Tegra::Engines::EngineInterface* engine, u32 subchannel_id) {
+    void BindSubchannel(Engines::EngineInterface* engine, u32 subchannel_id) {
        subchannels[subchannel_id] = engine;
    }
@@ -145,7 +145,7 @@ private:
    bool ib_enable{true}; ///< IB mode enabled
-    std::array<Tegra::Engines::EngineInterface*, max_subchannels> subchannels{};
+    std::array<Engines::EngineInterface*, max_subchannels> subchannels{};
    GPU& gpu;
    Core::System& system;
diff --git a/src/video_core/engines/engine_upload.cpp b/src/video_core/engines/engine_upload.cpp
index d44ad0cd8..71d7e1473 100644
--- a/src/video_core/engines/engine_upload.cpp
+++ b/src/video_core/engines/engine_upload.cpp
@@ -11,16 +11,16 @@
 namespace Tegra::Engines::Upload {
-State::State(MemoryManager& memory_manager, Registers& regs)
+State::State(MemoryManager& memory_manager_, Registers& regs_)
-    : regs{regs}, memory_manager{memory_manager} {}
+    : regs{regs_}, memory_manager{memory_manager_} {}
 State::~State() = default;
-void State::ProcessExec(const bool is_linear) {
+void State::ProcessExec(const bool is_linear_) {
    write_offset = 0;
    copy_size = regs.line_length_in * regs.line_count;
    inner_buffer.resize(copy_size);
-    this->is_linear = is_linear;
+    is_linear = is_linear_;
 }
 void State::ProcessData(const u32 data, const bool is_last_call) {
diff --git a/src/video_core/engines/engine_upload.h b/src/video_core/engines/engine_upload.h
index 462da419e..1c7f1effa 100644
--- a/src/video_core/engines/engine_upload.h
+++ b/src/video_core/engines/engine_upload.h
@@ -54,10 +54,10 @@ struct Registers {
 class State {
 public:
-    State(MemoryManager& memory_manager, Registers& regs);
+    explicit State(MemoryManager& memory_manager_, Registers& regs_);
    ~State();
-    void ProcessExec(bool is_linear);
+    void ProcessExec(bool is_linear_);
    void ProcessData(u32 data, bool is_last_call);
 private:
diff --git a/src/video_core/engines/fermi_2d.cpp b/src/video_core/engines/fermi_2d.cpp
index 9409c4075..4293d676c 100644
--- a/src/video_core/engines/fermi_2d.cpp
+++ b/src/video_core/engines/fermi_2d.cpp
@@ -48,8 +48,7 @@ static std::pair<u32, u32> DelimitLine(u32 src_1, u32 src_2, u32 dst_1, u32 dst_
 }
 void Fermi2D::HandleSurfaceCopy() {
-    LOG_DEBUG(HW_GPU, "Requested a surface copy with operation {}",
+    LOG_DEBUG(HW_GPU, "Requested a surface copy with operation {}", regs.operation);
-              static_cast<u32>(regs.operation));
    // TODO(Subv): Only raw copies are implemented.
    ASSERT(regs.operation == Operation::SrcCopy);
diff --git a/src/video_core/engines/kepler_memory.cpp b/src/video_core/engines/kepler_memory.cpp
index dc71b2eec..9911140e9 100644
--- a/src/video_core/engines/kepler_memory.cpp
+++ b/src/video_core/engines/kepler_memory.cpp
@@ -14,8 +14,8 @@
 namespace Tegra::Engines {
-KeplerMemory::KeplerMemory(Core::System& system, MemoryManager& memory_manager)
+KeplerMemory::KeplerMemory(Core::System& system_, MemoryManager& memory_manager)
-    : system{system}, upload_state{memory_manager, regs.upload} {}
+    : system{system_}, upload_state{memory_manager, regs.upload} {}
 KeplerMemory::~KeplerMemory() = default;
diff --git a/src/video_core/engines/kepler_memory.h b/src/video_core/engines/kepler_memory.h
index 5b7f71a00..62483589e 100644
--- a/src/video_core/engines/kepler_memory.h
+++ b/src/video_core/engines/kepler_memory.h
@@ -35,7 +35,7 @@ namespace Tegra::Engines {
 class KeplerMemory final : public EngineInterface {
 public:
-    KeplerMemory(Core::System& system, MemoryManager& memory_manager);
+    explicit KeplerMemory(Core::System& system_, MemoryManager& memory_manager);
    ~KeplerMemory();
    /// Write the value to the register identified by method.
diff --git a/src/video_core/engines/maxwell_3d.cpp b/src/video_core/engines/maxwell_3d.cpp
index 6287df633..761962ed0 100644
--- a/src/video_core/engines/maxwell_3d.cpp
+++ b/src/video_core/engines/maxwell_3d.cpp
@@ -359,7 +359,7 @@ void Maxwell3D::CallMethodFromMME(u32 method, u32 method_argument) {
 }
 void Maxwell3D::FlushMMEInlineDraw() {
-    LOG_TRACE(HW_GPU, "called, topology={}, count={}", static_cast<u32>(regs.draw.topology.Value()),
+    LOG_TRACE(HW_GPU, "called, topology={}, count={}", regs.draw.topology.Value(),
              regs.vertex_buffer.count);
    ASSERT_MSG(!(regs.index_array.count && regs.vertex_buffer.count), "Both indexed and direct?");
    ASSERT(mme_draw.instance_count == mme_draw.gl_end_count);
@@ -504,8 +504,7 @@ void Maxwell3D::ProcessCounterReset() {
        rasterizer->ResetCounter(QueryType::SamplesPassed);
        break;
    default:
-        LOG_DEBUG(Render_OpenGL, "Unimplemented counter reset={}",
+        LOG_DEBUG(Render_OpenGL, "Unimplemented counter reset={}", regs.counter_reset);
-                  static_cast<int>(regs.counter_reset));
        break;
    }
 }
@@ -520,7 +519,7 @@ void Maxwell3D::ProcessSyncPoint() {
 }
 void Maxwell3D::DrawArrays() {
-    LOG_TRACE(HW_GPU, "called, topology={}, count={}", static_cast<u32>(regs.draw.topology.Value()),
+    LOG_TRACE(HW_GPU, "called, topology={}, count={}", regs.draw.topology.Value(),
              regs.vertex_buffer.count);
    ASSERT_MSG(!(regs.index_array.count && regs.vertex_buffer.count), "Both indexed and direct?");
@@ -558,12 +557,12 @@ std::optional<u64> Maxwell3D::GetQueryResult() {
        return 0;
    case Regs::QuerySelect::SamplesPassed:
        // Deferred.
-        rasterizer->Query(regs.query.QueryAddress(), VideoCore::QueryType::SamplesPassed,
+        rasterizer->Query(regs.query.QueryAddress(), QueryType::SamplesPassed,
                          system.GPU().GetTicks());
        return std::nullopt;
    default:
        LOG_DEBUG(HW_GPU, "Unimplemented query select type {}",
-                  static_cast<u32>(regs.query.query_get.select.Value()));
+                  regs.query.query_get.select.Value());
        return 1;
    }
 }
diff --git a/src/video_core/engines/maxwell_dma.cpp b/src/video_core/engines/maxwell_dma.cpp
index 8fa359d0a..1c29e895e 100644
--- a/src/video_core/engines/maxwell_dma.cpp
+++ b/src/video_core/engines/maxwell_dma.cpp
@@ -16,8 +16,10 @@ namespace Tegra::Engines {
 using namespace Texture;
-MaxwellDMA::MaxwellDMA(Core::System& system, MemoryManager& memory_manager)
+MaxwellDMA::MaxwellDMA(Core::System& system_, MemoryManager& memory_manager_)
-    : system{system}, memory_manager{memory_manager} {}
+    : system{system_}, memory_manager{memory_manager_} {}
+MaxwellDMA::~MaxwellDMA() = default;
 void MaxwellDMA::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
    ASSERT_MSG(method < NUM_REGS, "Invalid MaxwellDMA register");
diff --git a/src/video_core/engines/maxwell_dma.h b/src/video_core/engines/maxwell_dma.h
index 50f445efc..3c59eeb13 100644
--- a/src/video_core/engines/maxwell_dma.h
+++ b/src/video_core/engines/maxwell_dma.h
@@ -72,11 +72,13 @@ public:
    struct RenderEnable {
        enum class Mode : u32 {
-            FALSE = 0,
+            // Note: This uses Pascal case in order to avoid the identifiers
-            TRUE = 1,
+            // FALSE and TRUE, which are reserved on Darwin.
-            CONDITIONAL = 2,
+            False = 0,
-            RENDER_IF_EQUAL = 3,
+            True = 1,
-            RENDER_IF_NOT_EQUAL = 4,
+            Conditional = 2,
+            RenderIfEqual = 3,
+            RenderIfNotEqual = 4,
        };
        PackedGPUVAddr address;
@@ -185,8 +187,8 @@ public:
    };
    static_assert(sizeof(RemapConst) == 12);
-    explicit MaxwellDMA(Core::System& system, MemoryManager& memory_manager);
+    explicit MaxwellDMA(Core::System& system_, MemoryManager& memory_manager_);
-    ~MaxwellDMA() = default;
+    ~MaxwellDMA();
    /// Write the value to the register identified by method.
    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
diff --git a/src/video_core/engines/shader_bytecode.h b/src/video_core/engines/shader_bytecode.h
index 37d17efdc..8b45f1b62 100644
--- a/src/video_core/engines/shader_bytecode.h
+++ b/src/video_core/engines/shader_bytecode.h
@@ -1437,8 +1437,7 @@ union Instruction {
                return TextureType::TextureCube;
            }
-            LOG_CRITICAL(HW_GPU, "Unhandled texture_info: {}",
+            LOG_CRITICAL(HW_GPU, "Unhandled texture_info: {}", texture_info.Value());
-                         static_cast<u32>(texture_info.Value()));
            UNREACHABLE();
            return TextureType::Texture1D;
        }
@@ -1533,8 +1532,7 @@ union Instruction {
                return TextureType::Texture3D;
            }
-            LOG_CRITICAL(HW_GPU, "Unhandled texture_info: {}",
+            LOG_CRITICAL(HW_GPU, "Unhandled texture_info: {}", texture_info.Value());
-                         static_cast<u32>(texture_info.Value()));
            UNREACHABLE();
            return TextureType::Texture1D;
        }
diff --git a/src/video_core/fence_manager.h b/src/video_core/fence_manager.h
index de6991ef6..c5f26896e 100644
--- a/src/video_core/fence_manager.h
+++ b/src/video_core/fence_manager.h
@@ -17,11 +17,11 @@ namespace VideoCommon {
 class FenceBase {
 public:
-    FenceBase(u32 payload, bool is_stubbed)
+    explicit FenceBase(u32 payload_, bool is_stubbed_)
-        : address{}, payload{payload}, is_semaphore{false}, is_stubbed{is_stubbed} {}
+        : address{}, payload{payload_}, is_semaphore{false}, is_stubbed{is_stubbed_} {}
-    FenceBase(GPUVAddr address, u32 payload, bool is_stubbed)
+    explicit FenceBase(GPUVAddr address_, u32 payload_, bool is_stubbed_)
-        : address{address}, payload{payload}, is_semaphore{true}, is_stubbed{is_stubbed} {}
+        : address{address_}, payload{payload_}, is_semaphore{true}, is_stubbed{is_stubbed_} {}
    GPUVAddr GetAddress() const {
        return address;
diff --git a/src/video_core/gpu.cpp b/src/video_core/gpu.cpp
index e91f52938..e2512a7f2 100644
--- a/src/video_core/gpu.cpp
+++ b/src/video_core/gpu.cpp
@@ -232,8 +232,12 @@ void GPU::CallMultiMethod(u32 method, u32 subchannel, const u32* base_start, u32
        CallEngineMultiMethod(method, subchannel, base_start, amount, methods_pending);
    } else {
        for (std::size_t i = 0; i < amount; i++) {
-            CallPullerMethod(
+            CallPullerMethod(MethodCall{
-                {method, base_start[i], subchannel, methods_pending - static_cast<u32>(i)});
+                method,
+                base_start[i],
+                subchannel,
+                methods_pending - static_cast<u32>(i),
+            });
        }
    }
 }
@@ -295,8 +299,7 @@ void GPU::CallPullerMethod(const MethodCall& method_call) {
        break;
    }
    default:
-        LOG_ERROR(HW_GPU, "Special puller engine method {:X} not implemented",
+        LOG_ERROR(HW_GPU, "Special puller engine method {:X} not implemented", method);
-                  static_cast<u32>(method));
        break;
    }
 }
@@ -375,7 +378,7 @@ void GPU::ProcessBindMethod(const MethodCall& method_call) {
        dma_pusher->BindSubchannel(kepler_memory.get(), method_call.subchannel);
        break;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented engine {:04X}", static_cast<u32>(engine_id));
+        UNIMPLEMENTED_MSG("Unimplemented engine {:04X}", engine_id);
    }
 }
@@ -388,8 +391,7 @@ void GPU::ProcessFenceActionMethod() {
        IncrementSyncPoint(regs.fence_action.syncpoint_id);
        break;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented operation {}",
+        UNIMPLEMENTED_MSG("Unimplemented operation {}", regs.fence_action.op.Value());
-                          static_cast<u32>(regs.fence_action.op.Value()));
    }
 }
diff --git a/src/video_core/gpu.h b/src/video_core/gpu.h
index 21410e125..660641d04 100644
--- a/src/video_core/gpu.h
+++ b/src/video_core/gpu.h
@@ -149,16 +149,16 @@ public:
        u32 subchannel{};
        u32 method_count{};
-        MethodCall(u32 method, u32 argument, u32 subchannel = 0, u32 method_count = 0)
+        explicit MethodCall(u32 method_, u32 argument_, u32 subchannel_ = 0, u32 method_count_ = 0)
-            : method(method), argument(argument), subchannel(subchannel),
+            : method(method_), argument(argument_), subchannel(subchannel_),
-              method_count(method_count) {}
+              method_count(method_count_) {}
        [[nodiscard]] bool IsLastCall() const {
            return method_count <= 1;
        }
    };
-    explicit GPU(Core::System& system, bool is_async, bool use_nvdec);
+    explicit GPU(Core::System& system_, bool is_async_, bool use_nvdec_);
    virtual ~GPU();
    /// Binds a renderer to the GPU.
@@ -414,8 +414,8 @@ private:
    std::condition_variable sync_cv;
    struct FlushRequest {
-        FlushRequest(u64 fence, VAddr addr, std::size_t size)
+        explicit FlushRequest(u64 fence_, VAddr addr_, std::size_t size_)
-            : fence{fence}, addr{addr}, size{size} {}
+            : fence{fence_}, addr{addr_}, size{size_} {}
        u64 fence;
        VAddr addr;
        std::size_t size;
diff --git a/src/video_core/gpu_asynch.cpp b/src/video_core/gpu_asynch.cpp
index a9baaf7ef..6cc091ecd 100644
--- a/src/video_core/gpu_asynch.cpp
+++ b/src/video_core/gpu_asynch.cpp
@@ -10,8 +10,8 @@
 namespace VideoCommon {
-GPUAsynch::GPUAsynch(Core::System& system, bool use_nvdec)
+GPUAsynch::GPUAsynch(Core::System& system_, bool use_nvdec_)
-    : GPU{system, true, use_nvdec}, gpu_thread{system} {}
+    : GPU{system_, true, use_nvdec_}, gpu_thread{system_} {}
 GPUAsynch::~GPUAsynch() = default;
diff --git a/src/video_core/gpu_asynch.h b/src/video_core/gpu_asynch.h
index 0c0872e73..a384113f4 100644
--- a/src/video_core/gpu_asynch.h
+++ b/src/video_core/gpu_asynch.h
@@ -20,7 +20,7 @@ namespace VideoCommon {
 /// Implementation of GPU interface that runs the GPU asynchronously
 class GPUAsynch final : public Tegra::GPU {
 public:
-    explicit GPUAsynch(Core::System& system, bool use_nvdec);
+    explicit GPUAsynch(Core::System& system_, bool use_nvdec_);
    ~GPUAsynch() override;
    void Start() override;
diff --git a/src/video_core/gpu_synch.cpp b/src/video_core/gpu_synch.cpp
index ecf7bbdf3..1e9d4b9b2 100644
--- a/src/video_core/gpu_synch.cpp
+++ b/src/video_core/gpu_synch.cpp
@@ -7,7 +7,7 @@
 namespace VideoCommon {
-GPUSynch::GPUSynch(Core::System& system, bool use_nvdec) : GPU{system, false, use_nvdec} {}
+GPUSynch::GPUSynch(Core::System& system_, bool use_nvdec_) : GPU{system_, false, use_nvdec_} {}
 GPUSynch::~GPUSynch() = default;
diff --git a/src/video_core/gpu_synch.h b/src/video_core/gpu_synch.h
index 9d778c71a..c5904b8db 100644
--- a/src/video_core/gpu_synch.h
+++ b/src/video_core/gpu_synch.h
@@ -19,7 +19,7 @@ namespace VideoCommon {
 /// Implementation of GPU interface that runs the GPU synchronously
 class GPUSynch final : public Tegra::GPU {
 public:
-    explicit GPUSynch(Core::System& system, bool use_nvdec);
+    explicit GPUSynch(Core::System& system_, bool use_nvdec_);
    ~GPUSynch() override;
    void Start() override;
diff --git a/src/video_core/gpu_thread.cpp b/src/video_core/gpu_thread.cpp
index 4b8f58283..e27218b96 100644
--- a/src/video_core/gpu_thread.cpp
+++ b/src/video_core/gpu_thread.cpp
@@ -39,23 +39,23 @@ static void RunThread(Core::System& system, VideoCore::RendererBase& renderer,
    CommandDataContainer next;
    while (state.is_running) {
        next = state.queue.PopWait();
-        if (const auto submit_list = std::get_if<SubmitListCommand>(&next.data)) {
+        if (auto* submit_list = std::get_if<SubmitListCommand>(&next.data)) {
            dma_pusher.Push(std::move(submit_list->entries));
            dma_pusher.DispatchCalls();
-        } else if (const auto command_list = std::get_if<SubmitChCommandEntries>(&next.data)) {
+        } else if (auto* command_list = std::get_if<SubmitChCommandEntries>(&next.data)) {
            // NVDEC
            cdma_pusher.Push(std::move(command_list->entries));
            cdma_pusher.DispatchCalls();
-        } else if (const auto data = std::get_if<SwapBuffersCommand>(&next.data)) {
+        } else if (const auto* data = std::get_if<SwapBuffersCommand>(&next.data)) {
            renderer.SwapBuffers(data->framebuffer ? &*data->framebuffer : nullptr);
        } else if (std::holds_alternative<OnCommandListEndCommand>(next.data)) {
            renderer.Rasterizer().ReleaseFences();
        } else if (std::holds_alternative<GPUTickCommand>(next.data)) {
            system.GPU().TickWork();
-        } else if (const auto data = std::get_if<FlushRegionCommand>(&next.data)) {
+        } else if (const auto* flush = std::get_if<FlushRegionCommand>(&next.data)) {
-            renderer.Rasterizer().FlushRegion(data->addr, data->size);
+            renderer.Rasterizer().FlushRegion(flush->addr, flush->size);
-        } else if (const auto data = std::get_if<InvalidateRegionCommand>(&next.data)) {
+        } else if (const auto* invalidate = std::get_if<InvalidateRegionCommand>(&next.data)) {
-            renderer.Rasterizer().OnCPUWrite(data->addr, data->size);
+            renderer.Rasterizer().OnCPUWrite(invalidate->addr, invalidate->size);
        } else if (std::holds_alternative<EndProcessingCommand>(next.data)) {
            return;
        } else {
@@ -65,7 +65,7 @@ static void RunThread(Core::System& system, VideoCore::RendererBase& renderer,
    }
 }
-ThreadManager::ThreadManager(Core::System& system) : system{system} {}
+ThreadManager::ThreadManager(Core::System& system_) : system{system_} {}
 ThreadManager::~ThreadManager() {
    if (!thread.joinable()) {
diff --git a/src/video_core/gpu_thread.h b/src/video_core/gpu_thread.h
index 32a34e3a7..f1c52cd9e 100644
--- a/src/video_core/gpu_thread.h
+++ b/src/video_core/gpu_thread.h
@@ -32,30 +32,30 @@ struct EndProcessingCommand final {};
 /// Command to signal to the GPU thread that a command list is ready for processing
 struct SubmitListCommand final {
-    explicit SubmitListCommand(Tegra::CommandList&& entries) : entries{std::move(entries)} {}
+    explicit SubmitListCommand(Tegra::CommandList&& entries_) : entries{std::move(entries_)} {}
    Tegra::CommandList entries;
 };
 /// Command to signal to the GPU thread that a cdma command list is ready for processing
 struct SubmitChCommandEntries final {
-    explicit SubmitChCommandEntries(Tegra::ChCommandHeaderList&& entries)
+    explicit SubmitChCommandEntries(Tegra::ChCommandHeaderList&& entries_)
-        : entries{std::move(entries)} {}
+        : entries{std::move(entries_)} {}
    Tegra::ChCommandHeaderList entries;
 };
 /// Command to signal to the GPU thread that a swap buffers is pending
 struct SwapBuffersCommand final {
-    explicit SwapBuffersCommand(std::optional<const Tegra::FramebufferConfig> framebuffer)
+    explicit SwapBuffersCommand(std::optional<const Tegra::FramebufferConfig> framebuffer_)
-        : framebuffer{std::move(framebuffer)} {}
+        : framebuffer{std::move(framebuffer_)} {}
    std::optional<Tegra::FramebufferConfig> framebuffer;
 };
 /// Command to signal to the GPU thread to flush a region
 struct FlushRegionCommand final {
-    explicit constexpr FlushRegionCommand(VAddr addr, u64 size) : addr{addr}, size{size} {}
+    explicit constexpr FlushRegionCommand(VAddr addr_, u64 size_) : addr{addr_}, size{size_} {}
    VAddr addr;
    u64 size;
@@ -63,7 +63,7 @@ struct FlushRegionCommand final {
 /// Command to signal to the GPU thread to invalidate a region
 struct InvalidateRegionCommand final {
-    explicit constexpr InvalidateRegionCommand(VAddr addr, u64 size) : addr{addr}, size{size} {}
+    explicit constexpr InvalidateRegionCommand(VAddr addr_, u64 size_) : addr{addr_}, size{size_} {}
    VAddr addr;
    u64 size;
@@ -71,8 +71,8 @@ struct InvalidateRegionCommand final {
 /// Command to signal to the GPU thread to flush and invalidate a region
 struct FlushAndInvalidateRegionCommand final {
-    explicit constexpr FlushAndInvalidateRegionCommand(VAddr addr, u64 size)
+    explicit constexpr FlushAndInvalidateRegionCommand(VAddr addr_, u64 size_)
-        : addr{addr}, size{size} {}
+        : addr{addr_}, size{size_} {}
    VAddr addr;
    u64 size;
@@ -92,8 +92,8 @@ using CommandData =
 struct CommandDataContainer {
    CommandDataContainer() = default;
-    CommandDataContainer(CommandData&& data, u64 next_fence)
+    explicit CommandDataContainer(CommandData&& data_, u64 next_fence_)
-        : data{std::move(data)}, fence{next_fence} {}
+        : data{std::move(data_)}, fence{next_fence_} {}
    CommandData data;
    u64 fence{};
@@ -112,7 +112,7 @@ struct SynchState final {
 /// Class used to manage the GPU thread
 class ThreadManager final {
 public:
-    explicit ThreadManager(Core::System& system);
+    explicit ThreadManager(Core::System& system_);
    ~ThreadManager();
    /// Creates and starts the GPU thread.
@@ -146,7 +146,6 @@ private:
    /// Pushes a command to be executed by the GPU thread
    u64 PushCommand(CommandData&& command_data);
-private:
    SynchState state;
    Core::System& system;
    std::thread thread;
diff --git a/src/video_core/guest_driver.h b/src/video_core/guest_driver.h
index 99450777e..21e569ba1 100644
--- a/src/video_core/guest_driver.h
+++ b/src/video_core/guest_driver.h
@@ -19,8 +19,8 @@ namespace VideoCore {
 class GuestDriverProfile {
 public:
    explicit GuestDriverProfile() = default;
-    explicit GuestDriverProfile(std::optional<u32> texture_handler_size)
+    explicit GuestDriverProfile(std::optional<u32> texture_handler_size_)
-        : texture_handler_size{texture_handler_size} {}
+        : texture_handler_size{texture_handler_size_} {}
    void DeduceTextureHandlerSize(std::vector<u32> bound_offsets);
diff --git a/src/video_core/macro/macro_hle.cpp b/src/video_core/macro/macro_hle.cpp
index df00b57df..70ac7c620 100644
--- a/src/video_core/macro/macro_hle.cpp
+++ b/src/video_core/macro/macro_hle.cpp
@@ -85,7 +85,7 @@ constexpr std::array<std::pair<u64, HLEFunction>, 3> hle_funcs{{
    {0x0217920100488FF7, &HLE_0217920100488FF7},
 }};
-HLEMacro::HLEMacro(Engines::Maxwell3D& maxwell3d) : maxwell3d(maxwell3d) {}
+HLEMacro::HLEMacro(Engines::Maxwell3D& maxwell3d_) : maxwell3d{maxwell3d_} {}
 HLEMacro::~HLEMacro() = default;
 std::optional<std::unique_ptr<CachedMacro>> HLEMacro::GetHLEProgram(u64 hash) const {
@@ -99,8 +99,8 @@ std::optional<std::unique_ptr<CachedMacro>> HLEMacro::GetHLEProgram(u64 hash) co
 HLEMacroImpl::~HLEMacroImpl() = default;
-HLEMacroImpl::HLEMacroImpl(Engines::Maxwell3D& maxwell3d, HLEFunction func)
+HLEMacroImpl::HLEMacroImpl(Engines::Maxwell3D& maxwell3d_, HLEFunction func_)
-    : maxwell3d(maxwell3d), func(func) {}
+    : maxwell3d{maxwell3d_}, func{func_} {}
 void HLEMacroImpl::Execute(const std::vector<u32>& parameters, u32 method) {
    func(maxwell3d, parameters);
diff --git a/src/video_core/macro/macro_hle.h b/src/video_core/macro/macro_hle.h
index 37af875a0..cb3bd1600 100644
--- a/src/video_core/macro/macro_hle.h
+++ b/src/video_core/macro/macro_hle.h
@@ -20,7 +20,7 @@ using HLEFunction = void (*)(Engines::Maxwell3D& maxwell3d, const std::vector<u3
 class HLEMacro {
 public:
-    explicit HLEMacro(Engines::Maxwell3D& maxwell3d);
+    explicit HLEMacro(Engines::Maxwell3D& maxwell3d_);
    ~HLEMacro();
    std::optional<std::unique_ptr<CachedMacro>> GetHLEProgram(u64 hash) const;
diff --git a/src/video_core/macro/macro_interpreter.cpp b/src/video_core/macro/macro_interpreter.cpp
index bd01fd1f2..8da26fd59 100644
--- a/src/video_core/macro/macro_interpreter.cpp
+++ b/src/video_core/macro/macro_interpreter.cpp
@@ -11,29 +11,29 @@
 MICROPROFILE_DEFINE(MacroInterp, "GPU", "Execute macro interpreter", MP_RGB(128, 128, 192));
 namespace Tegra {
-MacroInterpreter::MacroInterpreter(Engines::Maxwell3D& maxwell3d)
+MacroInterpreter::MacroInterpreter(Engines::Maxwell3D& maxwell3d_)
-    : MacroEngine::MacroEngine(maxwell3d), maxwell3d(maxwell3d) {}
+    : MacroEngine{maxwell3d_}, maxwell3d{maxwell3d_} {}
 std::unique_ptr<CachedMacro> MacroInterpreter::Compile(const std::vector<u32>& code) {
    return std::make_unique<MacroInterpreterImpl>(maxwell3d, code);
 }
-MacroInterpreterImpl::MacroInterpreterImpl(Engines::Maxwell3D& maxwell3d,
+MacroInterpreterImpl::MacroInterpreterImpl(Engines::Maxwell3D& maxwell3d_,
-                                           const std::vector<u32>& code)
+                                           const std::vector<u32>& code_)
-    : maxwell3d(maxwell3d), code(code) {}
+    : maxwell3d{maxwell3d_}, code{code_} {}
-void MacroInterpreterImpl::Execute(const std::vector<u32>& parameters, u32 method) {
+void MacroInterpreterImpl::Execute(const std::vector<u32>& params, u32 method) {
    MICROPROFILE_SCOPE(MacroInterp);
    Reset();
-    registers[1] = parameters[0];
+    registers[1] = params[0];
-    num_parameters = parameters.size();
+    num_parameters = params.size();
    if (num_parameters > parameters_capacity) {
        parameters_capacity = num_parameters;
-        this->parameters = std::make_unique<u32[]>(num_parameters);
+        parameters = std::make_unique<u32[]>(num_parameters);
    }
-    std::memcpy(this->parameters.get(), parameters.data(), num_parameters * sizeof(u32));
+    std::memcpy(parameters.get(), params.data(), num_parameters * sizeof(u32));
    // Execute the code until we hit an exit condition.
    bool keep_executing = true;
@@ -133,8 +133,7 @@ bool MacroInterpreterImpl::Step(bool is_delay_slot) {
        break;
    }
    default:
-        UNIMPLEMENTED_MSG("Unimplemented macro operation {}",
+        UNIMPLEMENTED_MSG("Unimplemented macro operation {}", opcode.operation.Value());
-                          static_cast<u32>(opcode.operation.Value()));
    }
    // An instruction with the Exit flag will not actually
@@ -182,7 +181,7 @@ u32 MacroInterpreterImpl::GetALUResult(Macro::ALUOperation operation, u32 src_a,
        return ~(src_a & src_b);
    default:
-        UNIMPLEMENTED_MSG("Unimplemented ALU operation {}", static_cast<u32>(operation));
+        UNIMPLEMENTED_MSG("Unimplemented ALU operation {}", operation);
        return 0;
    }
 }
@@ -230,7 +229,7 @@ void MacroInterpreterImpl::ProcessResult(Macro::ResultOperation operation, u32 r
        Send((result >> 12) & 0b111111);
        break;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented result operation {}", static_cast<u32>(operation));
+        UNIMPLEMENTED_MSG("Unimplemented result operation {}", operation);
    }
 }
diff --git a/src/video_core/macro/macro_interpreter.h b/src/video_core/macro/macro_interpreter.h
index 90217fc89..d50c619ce 100644
--- a/src/video_core/macro/macro_interpreter.h
+++ b/src/video_core/macro/macro_interpreter.h
@@ -17,7 +17,7 @@ class Maxwell3D;
 class MacroInterpreter final : public MacroEngine {
 public:
-    explicit MacroInterpreter(Engines::Maxwell3D& maxwell3d);
+    explicit MacroInterpreter(Engines::Maxwell3D& maxwell3d_);
 protected:
    std::unique_ptr<CachedMacro> Compile(const std::vector<u32>& code) override;
@@ -28,8 +28,8 @@ private:
 class MacroInterpreterImpl : public CachedMacro {
 public:
-    MacroInterpreterImpl(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& code);
+    explicit MacroInterpreterImpl(Engines::Maxwell3D& maxwell3d_, const std::vector<u32>& code_);
-    void Execute(const std::vector<u32>& parameters, u32 method) override;
+    void Execute(const std::vector<u32>& params, u32 method) override;
 private:
    /// Resets the execution engine state, zeroing registers, etc.
@@ -38,9 +38,9 @@ private:
    /**
     * Executes a single macro instruction located at the current program counter. Returns whether
     * the interpreter should keep running.
-     * @param offset Offset to start execution at.
+     *
     * @param is_delay_slot Whether the current step is being executed due to a delay slot in a
-     * previous instruction.
+     *                      previous instruction.
     */
    bool Step(bool is_delay_slot);
diff --git a/src/video_core/macro/macro_jit_x64.cpp b/src/video_core/macro/macro_jit_x64.cpp
index 954b87515..c6b2b2109 100644
--- a/src/video_core/macro/macro_jit_x64.cpp
+++ b/src/video_core/macro/macro_jit_x64.cpp
@@ -28,15 +28,15 @@ static const std::bitset<32> PERSISTENT_REGISTERS = Common::X64::BuildRegSet({
    BRANCH_HOLDER,
 });
-MacroJITx64::MacroJITx64(Engines::Maxwell3D& maxwell3d)
+MacroJITx64::MacroJITx64(Engines::Maxwell3D& maxwell3d_)
-    : MacroEngine::MacroEngine(maxwell3d), maxwell3d(maxwell3d) {}
+    : MacroEngine{maxwell3d_}, maxwell3d{maxwell3d_} {}
 std::unique_ptr<CachedMacro> MacroJITx64::Compile(const std::vector<u32>& code) {
    return std::make_unique<MacroJITx64Impl>(maxwell3d, code);
 }
-MacroJITx64Impl::MacroJITx64Impl(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& code)
+MacroJITx64Impl::MacroJITx64Impl(Engines::Maxwell3D& maxwell3d_, const std::vector<u32>& code_)
-    : Xbyak::CodeGenerator(MAX_CODE_SIZE), code(code), maxwell3d(maxwell3d) {
+    : CodeGenerator{MAX_CODE_SIZE}, code{code_}, maxwell3d{maxwell3d_} {
    Compile();
 }
@@ -165,8 +165,7 @@ void MacroJITx64Impl::Compile_ALU(Macro::Opcode opcode) {
        }
        break;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented ALU operation {}",
+        UNIMPLEMENTED_MSG("Unimplemented ALU operation {}", opcode.alu_operation.Value());
-                          static_cast<std::size_t>(opcode.alu_operation.Value()));
        break;
    }
    Compile_ProcessResult(opcode.result_operation, opcode.dst);
@@ -553,15 +552,15 @@ Xbyak::Reg32 MacroJITx64Impl::Compile_GetRegister(u32 index, Xbyak::Reg32 dst) {
 }
 void MacroJITx64Impl::Compile_ProcessResult(Macro::ResultOperation operation, u32 reg) {
-    const auto SetRegister = [this](u32 reg, const Xbyak::Reg32& result) {
+    const auto SetRegister = [this](u32 reg_index, const Xbyak::Reg32& result) {
        // Register 0 is supposed to always return 0. NOP is implemented as a store to the zero
        // register.
-        if (reg == 0) {
+        if (reg_index == 0) {
            return;
        }
-        mov(dword[STATE + offsetof(JITState, registers) + reg * sizeof(u32)], result);
+        mov(dword[STATE + offsetof(JITState, registers) + reg_index * sizeof(u32)], result);
    };
-    const auto SetMethodAddress = [this](const Xbyak::Reg32& reg) { mov(METHOD_ADDRESS, reg); };
+    const auto SetMethodAddress = [this](const Xbyak::Reg32& reg32) { mov(METHOD_ADDRESS, reg32); };
    switch (operation) {
    case Macro::ResultOperation::IgnoreAndFetch:
@@ -604,7 +603,7 @@ void MacroJITx64Impl::Compile_ProcessResult(Macro::ResultOperation operation, u3
        Compile_Send(RESULT);
        break;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented macro operation {}", static_cast<std::size_t>(operation));
+        UNIMPLEMENTED_MSG("Unimplemented macro operation {}", operation);
    }
 }
diff --git a/src/video_core/macro/macro_jit_x64.h b/src/video_core/macro/macro_jit_x64.h
index a180e7428..7f50ac2f8 100644
--- a/src/video_core/macro/macro_jit_x64.h
+++ b/src/video_core/macro/macro_jit_x64.h
@@ -23,7 +23,7 @@ constexpr size_t MAX_CODE_SIZE = 0x10000;
 class MacroJITx64 final : public MacroEngine {
 public:
-    explicit MacroJITx64(Engines::Maxwell3D& maxwell3d);
+    explicit MacroJITx64(Engines::Maxwell3D& maxwell3d_);
 protected:
    std::unique_ptr<CachedMacro> Compile(const std::vector<u32>& code) override;
@@ -34,7 +34,7 @@ private:
 class MacroJITx64Impl : public Xbyak::CodeGenerator, public CachedMacro {
 public:
-    MacroJITx64Impl(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& code);
+    explicit MacroJITx64Impl(Engines::Maxwell3D& maxwell3d_, const std::vector<u32>& code_);
    ~MacroJITx64Impl();
    void Execute(const std::vector<u32>& parameters, u32 method) override;
diff --git a/src/video_core/memory_manager.h b/src/video_core/memory_manager.h
index c078193d9..c35e57689 100644
--- a/src/video_core/memory_manager.h
+++ b/src/video_core/memory_manager.h
@@ -28,7 +28,7 @@ public:
    };
    constexpr PageEntry() = default;
-    constexpr PageEntry(State state) : state{state} {}
+    constexpr PageEntry(State state_) : state{state_} {}
    constexpr PageEntry(VAddr addr) : state{static_cast<State>(addr >> ShiftBits)} {}
    [[nodiscard]] constexpr bool IsUnmapped() const {
@@ -68,7 +68,7 @@ static_assert(sizeof(PageEntry) == 4, "PageEntry is too large");
 class MemoryManager final {
 public:
-    explicit MemoryManager(Core::System& system);
+    explicit MemoryManager(Core::System& system_);
    ~MemoryManager();
    /// Binds a renderer to the memory manager.
diff --git a/src/video_core/query_cache.h b/src/video_core/query_cache.h
index fc54ca0ef..203f2af05 100644
--- a/src/video_core/query_cache.h
+++ b/src/video_core/query_cache.h
@@ -28,8 +28,8 @@ namespace VideoCommon {
 template <class QueryCache, class HostCounter>
 class CounterStreamBase {
 public:
-    explicit CounterStreamBase(QueryCache& cache, VideoCore::QueryType type)
+    explicit CounterStreamBase(QueryCache& cache_, VideoCore::QueryType type_)
-        : cache{cache}, type{type} {}
+        : cache{cache_}, type{type_} {}
    /// Updates the state of the stream, enabling or disabling as needed.
    void Update(bool enabled) {
@@ -334,8 +334,8 @@ private:
 template <class HostCounter>
 class CachedQueryBase {
 public:
-    explicit CachedQueryBase(VAddr cpu_addr, u8* host_ptr)
+    explicit CachedQueryBase(VAddr cpu_addr_, u8* host_ptr_)
-        : cpu_addr{cpu_addr}, host_ptr{host_ptr} {}
+        : cpu_addr{cpu_addr_}, host_ptr{host_ptr_} {}
    virtual ~CachedQueryBase() = default;
    CachedQueryBase(CachedQueryBase&&) noexcept = default;
diff --git a/src/video_core/renderer_opengl/gl_arb_decompiler.cpp b/src/video_core/renderer_opengl/gl_arb_decompiler.cpp
index d6120c23e..3e4d88c30 100644
--- a/src/video_core/renderer_opengl/gl_arb_decompiler.cpp
+++ b/src/video_core/renderer_opengl/gl_arb_decompiler.cpp
@@ -71,7 +71,7 @@ std::string_view GetInputFlags(PixelImap attribute) {
    case PixelImap::Unused:
        break;
    }
-    UNIMPLEMENTED_MSG("Unknown attribute usage index={}", static_cast<int>(attribute));
+    UNIMPLEMENTED_MSG("Unknown attribute usage index={}", attribute);
    return {};
 }
@@ -123,7 +123,7 @@ std::string_view PrimitiveDescription(Tegra::Engines::Maxwell3D::Regs::Primitive
    case Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology::TriangleStripAdjacency:
        return "TRIANGLES_ADJACENCY";
    default:
-        UNIMPLEMENTED_MSG("topology={}", static_cast<int>(topology));
+        UNIMPLEMENTED_MSG("topology={}", topology);
        return "POINTS";
    }
 }
@@ -137,7 +137,7 @@ std::string_view TopologyName(Tegra::Shader::OutputTopology topology) {
    case Tegra::Shader::OutputTopology::TriangleStrip:
        return "TRIANGLE_STRIP";
    default:
-        UNIMPLEMENTED_MSG("Unknown output topology: {}", static_cast<u32>(topology));
+        UNIMPLEMENTED_MSG("Unknown output topology: {}", topology);
        return "points";
    }
 }
@@ -187,8 +187,8 @@ std::string TextureType(const MetaTexture& meta) {
 class ARBDecompiler final {
 public:
-    explicit ARBDecompiler(const Device& device, const ShaderIR& ir, const Registry& registry,
+    explicit ARBDecompiler(const Device& device_, const ShaderIR& ir_, const Registry& registry_,
-                           ShaderType stage, std::string_view identifier);
+                           ShaderType stage_, std::string_view identifier);
    std::string Code() const {
        return shader_source;
@@ -802,9 +802,9 @@ private:
    };
 };
-ARBDecompiler::ARBDecompiler(const Device& device, const ShaderIR& ir, const Registry& registry,
+ARBDecompiler::ARBDecompiler(const Device& device_, const ShaderIR& ir_, const Registry& registry_,
-                             ShaderType stage, std::string_view identifier)
+                             ShaderType stage_, std::string_view identifier)
-    : device{device}, ir{ir}, registry{registry}, stage{stage} {
+    : device{device_}, ir{ir_}, registry{registry_}, stage{stage_} {
    DefineGlobalMemory();
    AddLine("TEMP RC;");
@@ -1134,44 +1134,44 @@ void ARBDecompiler::VisitAST(const ASTNode& node) {
        for (ASTNode current = ast->nodes.GetFirst(); current; current = current->GetNext()) {
            VisitAST(current);
        }
-    } else if (const auto ast = std::get_if<ASTIfThen>(&*node->GetInnerData())) {
+    } else if (const auto if_then = std::get_if<ASTIfThen>(&*node->GetInnerData())) {
-        const std::string condition = VisitExpression(ast->condition);
+        const std::string condition = VisitExpression(if_then->condition);
        ResetTemporaries();
        AddLine("MOVC.U RC.x, {};", condition);
        AddLine("IF NE.x;");
-        for (ASTNode current = ast->nodes.GetFirst(); current; current = current->GetNext()) {
+        for (ASTNode current = if_then->nodes.GetFirst(); current; current = current->GetNext()) {
            VisitAST(current);
        }
        AddLine("ENDIF;");
-    } else if (const auto ast = std::get_if<ASTIfElse>(&*node->GetInnerData())) {
+    } else if (const auto if_else = std::get_if<ASTIfElse>(&*node->GetInnerData())) {
        AddLine("ELSE;");
-        for (ASTNode current = ast->nodes.GetFirst(); current; current = current->GetNext()) {
+        for (ASTNode current = if_else->nodes.GetFirst(); current; current = current->GetNext()) {
            VisitAST(current);
        }
-    } else if (const auto ast = std::get_if<ASTBlockDecoded>(&*node->GetInnerData())) {
+    } else if (const auto decoded = std::get_if<ASTBlockDecoded>(&*node->GetInnerData())) {
-        VisitBlock(ast->nodes);
+        VisitBlock(decoded->nodes);
-    } else if (const auto ast = std::get_if<ASTVarSet>(&*node->GetInnerData())) {
+    } else if (const auto var_set = std::get_if<ASTVarSet>(&*node->GetInnerData())) {
-        AddLine("MOV.U F{}, {};", ast->index, VisitExpression(ast->condition));
+        AddLine("MOV.U F{}, {};", var_set->index, VisitExpression(var_set->condition));
        ResetTemporaries();
-    } else if (const auto ast = std::get_if<ASTDoWhile>(&*node->GetInnerData())) {
+    } else if (const auto do_while = std::get_if<ASTDoWhile>(&*node->GetInnerData())) {
-        const std::string condition = VisitExpression(ast->condition);
+        const std::string condition = VisitExpression(do_while->condition);
        ResetTemporaries();
        AddLine("REP;");
-        for (ASTNode current = ast->nodes.GetFirst(); current; current = current->GetNext()) {
+        for (ASTNode current = do_while->nodes.GetFirst(); current; current = current->GetNext()) {
            VisitAST(current);
        }
        AddLine("MOVC.U RC.x, {};", condition);
        AddLine("BRK (NE.x);");
        AddLine("ENDREP;");
-    } else if (const auto ast = std::get_if<ASTReturn>(&*node->GetInnerData())) {
+    } else if (const auto ast_return = std::get_if<ASTReturn>(&*node->GetInnerData())) {
-        const bool is_true = ExprIsTrue(ast->condition);
+        const bool is_true = ExprIsTrue(ast_return->condition);
        if (!is_true) {
-            AddLine("MOVC.U RC.x, {};", VisitExpression(ast->condition));
+            AddLine("MOVC.U RC.x, {};", VisitExpression(ast_return->condition));
            AddLine("IF NE.x;");
            ResetTemporaries();
        }
-        if (ast->kills) {
+        if (ast_return->kills) {
            AddLine("KIL TR;");
        } else {
            Exit();
@@ -1179,11 +1179,11 @@ void ARBDecompiler::VisitAST(const ASTNode& node) {
        if (!is_true) {
            AddLine("ENDIF;");
        }
-    } else if (const auto ast = std::get_if<ASTBreak>(&*node->GetInnerData())) {
+    } else if (const auto ast_break = std::get_if<ASTBreak>(&*node->GetInnerData())) {
-        if (ExprIsTrue(ast->condition)) {
+        if (ExprIsTrue(ast_break->condition)) {
            AddLine("BRK;");
        } else {
-            AddLine("MOVC.U RC.x, {};", VisitExpression(ast->condition));
+            AddLine("MOVC.U RC.x, {};", VisitExpression(ast_break->condition));
            AddLine("BRK (NE.x);");
            ResetTemporaries();
        }
@@ -1351,7 +1351,7 @@ std::string ARBDecompiler::Visit(const Node& node) {
                                       GetGenericAttributeIndex(index), swizzle);
                }
            }
-            UNIMPLEMENTED_MSG("Unimplemented input attribute={}", static_cast<int>(index));
+            UNIMPLEMENTED_MSG("Unimplemented input attribute={}", index);
            break;
        }
        return "{0, 0, 0, 0}.x";
@@ -1485,9 +1485,7 @@ void ARBDecompiler::Exit() {
    }
    const auto safe_get_register = [this](u32 reg) -> std::string {
-        // TODO(Rodrigo): Replace with contains once C++20 releases
+        if (ir.GetRegisters().contains(reg)) {
-        const auto& used_registers = ir.GetRegisters();
-        if (used_registers.find(reg) != used_registers.end()) {
            return fmt::format("R{}.x", reg);
        }
        return "{0, 0, 0, 0}.x";
diff --git a/src/video_core/renderer_opengl/gl_buffer_cache.cpp b/src/video_core/renderer_opengl/gl_buffer_cache.cpp
index b1c4cd62f..60735d502 100644
--- a/src/video_core/renderer_opengl/gl_buffer_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_buffer_cache.cpp
@@ -22,11 +22,11 @@ using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 MICROPROFILE_DEFINE(OpenGL_Buffer_Download, "OpenGL", "Buffer Download", MP_RGB(192, 192, 128));
-Buffer::Buffer(const Device& device, VAddr cpu_addr, std::size_t size)
+Buffer::Buffer(const Device& device_, VAddr cpu_addr_, std::size_t size_)
-    : VideoCommon::BufferBlock{cpu_addr, size} {
+    : BufferBlock{cpu_addr_, size_} {
    gl_buffer.Create();
-    glNamedBufferData(gl_buffer.handle, static_cast<GLsizeiptr>(size), nullptr, GL_DYNAMIC_DRAW);
+    glNamedBufferData(gl_buffer.handle, static_cast<GLsizeiptr>(size_), nullptr, GL_DYNAMIC_DRAW);
-    if (device.UseAssemblyShaders() || device.HasVertexBufferUnifiedMemory()) {
+    if (device_.UseAssemblyShaders() || device_.HasVertexBufferUnifiedMemory()) {
        glMakeNamedBufferResidentNV(gl_buffer.handle, GL_READ_WRITE);
        glGetNamedBufferParameterui64vNV(gl_buffer.handle, GL_BUFFER_GPU_ADDRESS_NV, &gpu_address);
    }
@@ -34,14 +34,14 @@ Buffer::Buffer(const Device& device, VAddr cpu_addr, std::size_t size)
 Buffer::~Buffer() = default;
-void Buffer::Upload(std::size_t offset, std::size_t size, const u8* data) {
+void Buffer::Upload(std::size_t offset, std::size_t data_size, const u8* data) {
-    glNamedBufferSubData(Handle(), static_cast<GLintptr>(offset), static_cast<GLsizeiptr>(size),
+    glNamedBufferSubData(Handle(), static_cast<GLintptr>(offset),
-                         data);
+                         static_cast<GLsizeiptr>(data_size), data);
 }
-void Buffer::Download(std::size_t offset, std::size_t size, u8* data) {
+void Buffer::Download(std::size_t offset, std::size_t data_size, u8* data) {
    MICROPROFILE_SCOPE(OpenGL_Buffer_Download);
-    const GLsizeiptr gl_size = static_cast<GLsizeiptr>(size);
+    const GLsizeiptr gl_size = static_cast<GLsizeiptr>(data_size);
    const GLintptr gl_offset = static_cast<GLintptr>(offset);
    if (read_buffer.handle == 0) {
        read_buffer.Create();
@@ -54,16 +54,16 @@ void Buffer::Download(std::size_t offset, std::size_t size, u8* data) {
 }
 void Buffer::CopyFrom(const Buffer& src, std::size_t src_offset, std::size_t dst_offset,
-                      std::size_t size) {
+                      std::size_t copy_size) {
    glCopyNamedBufferSubData(src.Handle(), Handle(), static_cast<GLintptr>(src_offset),
-                             static_cast<GLintptr>(dst_offset), static_cast<GLsizeiptr>(size));
+                             static_cast<GLintptr>(dst_offset), static_cast<GLsizeiptr>(copy_size));
 }
-OGLBufferCache::OGLBufferCache(VideoCore::RasterizerInterface& rasterizer,
+OGLBufferCache::OGLBufferCache(VideoCore::RasterizerInterface& rasterizer_,
-                               Tegra::MemoryManager& gpu_memory, Core::Memory::Memory& cpu_memory,
+                               Tegra::MemoryManager& gpu_memory_, Core::Memory::Memory& cpu_memory_,
-                               const Device& device_, std::size_t stream_size)
+                               const Device& device_, std::size_t stream_size_)
-    : GenericBufferCache{rasterizer, gpu_memory, cpu_memory,
+    : GenericBufferCache{rasterizer_, gpu_memory_, cpu_memory_,
-                         std::make_unique<OGLStreamBuffer>(device_, stream_size, true)},
+                         std::make_unique<OGLStreamBuffer>(device_, stream_size_, true)},
      device{device_} {
    if (!device.HasFastBufferSubData()) {
        return;
diff --git a/src/video_core/renderer_opengl/gl_buffer_cache.h b/src/video_core/renderer_opengl/gl_buffer_cache.h
index f75b32e31..95251e26b 100644
--- a/src/video_core/renderer_opengl/gl_buffer_cache.h
+++ b/src/video_core/renderer_opengl/gl_buffer_cache.h
@@ -25,15 +25,15 @@ class RasterizerOpenGL;
 class Buffer : public VideoCommon::BufferBlock {
 public:
-    explicit Buffer(const Device& device, VAddr cpu_addr, std::size_t size);
+    explicit Buffer(const Device& device_, VAddr cpu_addr_, std::size_t size_);
    ~Buffer();
-    void Upload(std::size_t offset, std::size_t size, const u8* data);
+    void Upload(std::size_t offset, std::size_t data_size, const u8* data);
-    void Download(std::size_t offset, std::size_t size, u8* data);
+    void Download(std::size_t offset, std::size_t data_size, u8* data);
    void CopyFrom(const Buffer& src, std::size_t src_offset, std::size_t dst_offset,
-                  std::size_t size);
+                  std::size_t copy_size);
    GLuint Handle() const noexcept {
        return gl_buffer.handle;
@@ -52,9 +52,9 @@ private:
 using GenericBufferCache = VideoCommon::BufferCache<Buffer, GLuint, OGLStreamBuffer>;
 class OGLBufferCache final : public GenericBufferCache {
 public:
-    explicit OGLBufferCache(VideoCore::RasterizerInterface& rasterizer,
+    explicit OGLBufferCache(VideoCore::RasterizerInterface& rasterizer_,
-                            Tegra::MemoryManager& gpu_memory, Core::Memory::Memory& cpu_memory,
+                            Tegra::MemoryManager& gpu_memory_, Core::Memory::Memory& cpu_memory_,
-                            const Device& device, std::size_t stream_size);
+                            const Device& device_, std::size_t stream_size_);
    ~OGLBufferCache();
    BufferInfo GetEmptyBuffer(std::size_t) override;
diff --git a/src/video_core/renderer_opengl/gl_fence_manager.cpp b/src/video_core/renderer_opengl/gl_fence_manager.cpp
index b532fdcc2..6040646cb 100644
--- a/src/video_core/renderer_opengl/gl_fence_manager.cpp
+++ b/src/video_core/renderer_opengl/gl_fence_manager.cpp
@@ -11,10 +11,10 @@
 namespace OpenGL {
-GLInnerFence::GLInnerFence(u32 payload, bool is_stubbed) : FenceBase(payload, is_stubbed) {}
+GLInnerFence::GLInnerFence(u32 payload_, bool is_stubbed_) : FenceBase{payload_, is_stubbed_} {}
-GLInnerFence::GLInnerFence(GPUVAddr address, u32 payload, bool is_stubbed)
+GLInnerFence::GLInnerFence(GPUVAddr address_, u32 payload_, bool is_stubbed_)
-    : FenceBase(address, payload, is_stubbed) {}
+    : FenceBase{address_, payload_, is_stubbed_} {}
 GLInnerFence::~GLInnerFence() = default;
@@ -45,10 +45,10 @@ void GLInnerFence::Wait() {
    glClientWaitSync(sync_object.handle, 0, GL_TIMEOUT_IGNORED);
 }
-FenceManagerOpenGL::FenceManagerOpenGL(VideoCore::RasterizerInterface& rasterizer, Tegra::GPU& gpu,
+FenceManagerOpenGL::FenceManagerOpenGL(VideoCore::RasterizerInterface& rasterizer_,
-                                       TextureCacheOpenGL& texture_cache,
+                                       Tegra::GPU& gpu_, TextureCacheOpenGL& texture_cache_,
-                                       OGLBufferCache& buffer_cache, QueryCache& query_cache)
+                                       OGLBufferCache& buffer_cache_, QueryCache& query_cache_)
-    : GenericFenceManager{rasterizer, gpu, texture_cache, buffer_cache, query_cache} {}
+    : GenericFenceManager{rasterizer_, gpu_, texture_cache_, buffer_cache_, query_cache_} {}
 Fence FenceManagerOpenGL::CreateFence(u32 value, bool is_stubbed) {
    return std::make_shared<GLInnerFence>(value, is_stubbed);
diff --git a/src/video_core/renderer_opengl/gl_fence_manager.h b/src/video_core/renderer_opengl/gl_fence_manager.h
index da1dcdace..39ca6125b 100644
--- a/src/video_core/renderer_opengl/gl_fence_manager.h
+++ b/src/video_core/renderer_opengl/gl_fence_manager.h
@@ -17,8 +17,8 @@ namespace OpenGL {
 class GLInnerFence : public VideoCommon::FenceBase {
 public:
-    GLInnerFence(u32 payload, bool is_stubbed);
+    explicit GLInnerFence(u32 payload_, bool is_stubbed_);
-    GLInnerFence(GPUVAddr address, u32 payload, bool is_stubbed);
+    explicit GLInnerFence(GPUVAddr address_, u32 payload_, bool is_stubbed_);
    ~GLInnerFence();
    void Queue();
@@ -37,9 +37,9 @@ using GenericFenceManager =
 class FenceManagerOpenGL final : public GenericFenceManager {
 public:
-    explicit FenceManagerOpenGL(VideoCore::RasterizerInterface& rasterizer, Tegra::GPU& gpu,
+    explicit FenceManagerOpenGL(VideoCore::RasterizerInterface& rasterizer_, Tegra::GPU& gpu_,
-                                TextureCacheOpenGL& texture_cache, OGLBufferCache& buffer_cache,
+                                TextureCacheOpenGL& texture_cache_, OGLBufferCache& buffer_cache_,
-                                QueryCache& query_cache);
+                                QueryCache& query_cache_);
 protected:
    Fence CreateFence(u32 value, bool is_stubbed) override;
diff --git a/src/video_core/renderer_opengl/gl_query_cache.cpp b/src/video_core/renderer_opengl/gl_query_cache.cpp
index 1a3d9720e..acebbf5f4 100644
--- a/src/video_core/renderer_opengl/gl_query_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_query_cache.cpp
@@ -30,11 +30,9 @@ constexpr GLenum GetTarget(VideoCore::QueryType type) {
 } // Anonymous namespace
-QueryCache::QueryCache(RasterizerOpenGL& rasterizer, Tegra::Engines::Maxwell3D& maxwell3d,
+QueryCache::QueryCache(RasterizerOpenGL& rasterizer_, Tegra::Engines::Maxwell3D& maxwell3d_,
-                       Tegra::MemoryManager& gpu_memory)
+                       Tegra::MemoryManager& gpu_memory_)
-    : VideoCommon::QueryCacheBase<QueryCache, CachedQuery, CounterStream, HostCounter>(
+    : QueryCacheBase(rasterizer_, maxwell3d_, gpu_memory_), gl_rasterizer{rasterizer_} {}
-          rasterizer, maxwell3d, gpu_memory),
-      gl_rasterizer{rasterizer} {}
 QueryCache::~QueryCache() = default;
@@ -59,10 +57,11 @@ bool QueryCache::AnyCommandQueued() const noexcept {
    return gl_rasterizer.AnyCommandQueued();
 }
-HostCounter::HostCounter(QueryCache& cache, std::shared_ptr<HostCounter> dependency,
+HostCounter::HostCounter(QueryCache& cache_, std::shared_ptr<HostCounter> dependency_,
-                         VideoCore::QueryType type)
+                         VideoCore::QueryType type_)
-    : VideoCommon::HostCounterBase<QueryCache, HostCounter>{std::move(dependency)}, cache{cache},
+    : HostCounterBase{std::move(dependency_)}, cache{cache_}, type{type_}, query{
-      type{type}, query{cache.AllocateQuery(type)} {
+                                                                               cache.AllocateQuery(
+                                                                                   type)} {
    glBeginQuery(GetTarget(type), query.handle);
 }
@@ -86,13 +85,14 @@ u64 HostCounter::BlockingQuery() const {
    return static_cast<u64>(value);
 }
-CachedQuery::CachedQuery(QueryCache& cache, VideoCore::QueryType type, VAddr cpu_addr, u8* host_ptr)
+CachedQuery::CachedQuery(QueryCache& cache_, VideoCore::QueryType type_, VAddr cpu_addr_,
-    : VideoCommon::CachedQueryBase<HostCounter>{cpu_addr, host_ptr}, cache{&cache}, type{type} {}
+                         u8* host_ptr_)
+    : CachedQueryBase{cpu_addr_, host_ptr_}, cache{&cache_}, type{type_} {}
 CachedQuery::~CachedQuery() = default;
 CachedQuery::CachedQuery(CachedQuery&& rhs) noexcept
-    : VideoCommon::CachedQueryBase<HostCounter>(std::move(rhs)), cache{rhs.cache}, type{rhs.type} {}
+    : CachedQueryBase(std::move(rhs)), cache{rhs.cache}, type{rhs.type} {}
 CachedQuery& CachedQuery::operator=(CachedQuery&& rhs) noexcept {
    cache = rhs.cache;
diff --git a/src/video_core/renderer_opengl/gl_query_cache.h b/src/video_core/renderer_opengl/gl_query_cache.h
index 82cac51ee..7bbe5cfe9 100644
--- a/src/video_core/renderer_opengl/gl_query_cache.h
+++ b/src/video_core/renderer_opengl/gl_query_cache.h
@@ -29,8 +29,8 @@ using CounterStream = VideoCommon::CounterStreamBase<QueryCache, HostCounter>;
 class QueryCache final
    : public VideoCommon::QueryCacheBase<QueryCache, CachedQuery, CounterStream, HostCounter> {
 public:
-    explicit QueryCache(RasterizerOpenGL& rasterizer, Tegra::Engines::Maxwell3D& maxwell3d,
+    explicit QueryCache(RasterizerOpenGL& rasterizer_, Tegra::Engines::Maxwell3D& maxwell3d_,
-                        Tegra::MemoryManager& gpu_memory);
+                        Tegra::MemoryManager& gpu_memory_);
    ~QueryCache();
    OGLQuery AllocateQuery(VideoCore::QueryType type);
@@ -46,8 +46,8 @@ private:
 class HostCounter final : public VideoCommon::HostCounterBase<QueryCache, HostCounter> {
 public:
-    explicit HostCounter(QueryCache& cache, std::shared_ptr<HostCounter> dependency,
+    explicit HostCounter(QueryCache& cache_, std::shared_ptr<HostCounter> dependency_,
-                         VideoCore::QueryType type);
+                         VideoCore::QueryType type_);
    ~HostCounter();
    void EndQuery();
@@ -62,8 +62,8 @@ private:
 class CachedQuery final : public VideoCommon::CachedQueryBase<HostCounter> {
 public:
-    explicit CachedQuery(QueryCache& cache, VideoCore::QueryType type, VAddr cpu_addr,
+    explicit CachedQuery(QueryCache& cache_, VideoCore::QueryType type_, VAddr cpu_addr_,
-                         u8* host_ptr);
+                         u8* host_ptr_);
    ~CachedQuery() override;
    CachedQuery(CachedQuery&& rhs) noexcept;
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.cpp b/src/video_core/renderer_opengl/gl_rasterizer.cpp
index cfddbde5d..e58e84759 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer.cpp
@@ -131,7 +131,7 @@ std::pair<GLint, GLint> TransformFeedbackEnum(u8 location) {
    case 43:
        return {GL_BACK_SECONDARY_COLOR_NV, 0};
    }
-    UNIMPLEMENTED_MSG("index={}", static_cast<int>(index));
+    UNIMPLEMENTED_MSG("index={}", index);
    return {GL_POSITION, 0};
 }
@@ -149,19 +149,19 @@ void UpdateBindlessSSBOs(GLenum target, const BindlessSSBO* ssbos, size_t num_ss
 } // Anonymous namespace
-RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& emu_window, Tegra::GPU& gpu_,
+RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,
-                                   Core::Memory::Memory& cpu_memory, const Device& device_,
+                                   Core::Memory::Memory& cpu_memory_, const Device& device_,
                                   ScreenInfo& screen_info_, ProgramManager& program_manager_,
                                   StateTracker& state_tracker_)
-    : RasterizerAccelerated{cpu_memory}, gpu(gpu_), maxwell3d(gpu.Maxwell3D()),
+    : RasterizerAccelerated{cpu_memory_}, gpu(gpu_), maxwell3d(gpu.Maxwell3D()),
      kepler_compute(gpu.KeplerCompute()), gpu_memory(gpu.MemoryManager()), device(device_),
      screen_info(screen_info_), program_manager(program_manager_), state_tracker(state_tracker_),
      texture_cache(*this, maxwell3d, gpu_memory, device, state_tracker),
-      shader_cache(*this, emu_window, gpu, maxwell3d, kepler_compute, gpu_memory, device),
+      shader_cache(*this, emu_window_, gpu, maxwell3d, kepler_compute, gpu_memory, device),
      query_cache(*this, maxwell3d, gpu_memory),
-      buffer_cache(*this, gpu_memory, cpu_memory, device, STREAM_BUFFER_SIZE),
+      buffer_cache(*this, gpu_memory, cpu_memory_, device, STREAM_BUFFER_SIZE),
      fence_manager(*this, gpu, texture_cache, buffer_cache, query_cache),
-      async_shaders(emu_window) {
+      async_shaders(emu_window_) {
    CheckExtensions();
    unified_uniform_buffer.Create();
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.h b/src/video_core/renderer_opengl/gl_rasterizer.h
index 1d0f585fa..de28cff15 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.h
+++ b/src/video_core/renderer_opengl/gl_rasterizer.h
@@ -62,10 +62,10 @@ static_assert(sizeof(BindlessSSBO) * CHAR_BIT == 128);
 class RasterizerOpenGL : public VideoCore::RasterizerAccelerated {
 public:
-    explicit RasterizerOpenGL(Core::Frontend::EmuWindow& emu_window, Tegra::GPU& gpu,
+    explicit RasterizerOpenGL(Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,
-                              Core::Memory::Memory& cpu_memory, const Device& device,
+                              Core::Memory::Memory& cpu_memory_, const Device& device_,
-                              ScreenInfo& screen_info, ProgramManager& program_manager,
+                              ScreenInfo& screen_info_, ProgramManager& program_manager_,
-                              StateTracker& state_tracker);
+                              StateTracker& state_tracker_);
    ~RasterizerOpenGL() override;
    void Draw(bool is_indexed, bool is_instanced) override;
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.cpp b/src/video_core/renderer_opengl/gl_shader_cache.cpp
index bd56bed0c..eabfdea5d 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_cache.cpp
@@ -198,10 +198,10 @@ ProgramSharedPtr BuildShader(const Device& device, ShaderType shader_type, u64 u
    return program;
 }
-Shader::Shader(std::shared_ptr<VideoCommon::Shader::Registry> registry_, ShaderEntries entries_,
+Shader::Shader(std::shared_ptr<Registry> registry_, ShaderEntries entries_,
-               ProgramSharedPtr program_, bool is_built)
+               ProgramSharedPtr program_, bool is_built_)
    : registry{std::move(registry_)}, entries{std::move(entries_)}, program{std::move(program_)},
-      is_built(is_built) {
+      is_built{is_built_} {
    handle = program->assembly_program.handle;
    if (handle == 0) {
        handle = program->source_program.handle;
@@ -318,14 +318,13 @@ std::unique_ptr<Shader> Shader::CreateFromCache(const ShaderParameters& params,
        precompiled_shader.registry, precompiled_shader.entries, precompiled_shader.program));
 }
-ShaderCacheOpenGL::ShaderCacheOpenGL(RasterizerOpenGL& rasterizer,
+ShaderCacheOpenGL::ShaderCacheOpenGL(RasterizerOpenGL& rasterizer_,
                                     Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,
                                     Tegra::Engines::Maxwell3D& maxwell3d_,
                                     Tegra::Engines::KeplerCompute& kepler_compute_,
                                     Tegra::MemoryManager& gpu_memory_, const Device& device_)
-    : VideoCommon::ShaderCache<Shader>{rasterizer}, emu_window{emu_window_}, gpu{gpu_},
+    : ShaderCache{rasterizer_}, emu_window{emu_window_}, gpu{gpu_}, gpu_memory{gpu_memory_},
-      gpu_memory{gpu_memory_}, maxwell3d{maxwell3d_},
+      maxwell3d{maxwell3d_}, kepler_compute{kepler_compute_}, device{device_} {}
-      kepler_compute{kepler_compute_}, device{device_} {}
 ShaderCacheOpenGL::~ShaderCacheOpenGL() = default;
@@ -460,7 +459,7 @@ void ShaderCacheOpenGL::LoadDiskCache(u64 title_id, const std::atomic_bool& stop
 ProgramSharedPtr ShaderCacheOpenGL::GeneratePrecompiledProgram(
    const ShaderDiskCacheEntry& entry, const ShaderDiskCachePrecompiled& precompiled_entry,
    const std::unordered_set<GLenum>& supported_formats) {
-    if (supported_formats.find(precompiled_entry.binary_format) == supported_formats.end()) {
+    if (!supported_formats.contains(precompiled_entry.binary_format)) {
        LOG_INFO(Render_OpenGL, "Precompiled cache entry with unsupported format, removing");
        return {};
    }
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.h b/src/video_core/renderer_opengl/gl_shader_cache.h
index 1708af06a..2aed0697e 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.h
+++ b/src/video_core/renderer_opengl/gl_shader_cache.h
@@ -108,7 +108,7 @@ public:
 private:
    explicit Shader(std::shared_ptr<VideoCommon::Shader::Registry> registry, ShaderEntries entries,
-                    ProgramSharedPtr program, bool is_built = true);
+                    ProgramSharedPtr program, bool is_built_ = true);
    std::shared_ptr<VideoCommon::Shader::Registry> registry;
    ShaderEntries entries;
@@ -119,10 +119,11 @@ private:
 class ShaderCacheOpenGL final : public VideoCommon::ShaderCache<Shader> {
 public:
-    explicit ShaderCacheOpenGL(RasterizerOpenGL& rasterizer, Core::Frontend::EmuWindow& emu_window,
+    explicit ShaderCacheOpenGL(RasterizerOpenGL& rasterizer_,
-                               Tegra::GPU& gpu, Tegra::Engines::Maxwell3D& maxwell3d,
+                               Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu,
-                               Tegra::Engines::KeplerCompute& kepler_compute,
+                               Tegra::Engines::Maxwell3D& maxwell3d_,
-                               Tegra::MemoryManager& gpu_memory, const Device& device);
+                               Tegra::Engines::KeplerCompute& kepler_compute_,
+                               Tegra::MemoryManager& gpu_memory_, const Device& device_);
    ~ShaderCacheOpenGL() override;
    /// Loads disk cache for the current game
diff --git a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
index 95ca96c8e..ccbdfe967 100644
--- a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
@@ -131,7 +131,7 @@ private:
 class Expression final {
 public:
-    Expression(std::string code, Type type) : code{std::move(code)}, type{type} {
+    Expression(std::string code_, Type type_) : code{std::move(code_)}, type{type_} {
        ASSERT(type != Type::Void);
    }
    Expression() : type{Type::Void} {}
@@ -148,8 +148,8 @@ public:
        ASSERT(type == Type::Void);
    }
-    std::string As(Type type) const {
+    std::string As(Type type_) const {
-        switch (type) {
+        switch (type_) {
        case Type::Bool:
            return AsBool();
        case Type::Bool2:
@@ -316,7 +316,7 @@ std::pair<const char*, u32> GetPrimitiveDescription(Maxwell::PrimitiveTopology t
    case Maxwell::PrimitiveTopology::TriangleStripAdjacency:
        return {"triangles_adjacency", 6};
    default:
-        UNIMPLEMENTED_MSG("topology={}", static_cast<int>(topology));
+        UNIMPLEMENTED_MSG("topology={}", topology);
        return {"points", 1};
    }
 }
@@ -342,7 +342,7 @@ std::string GetTopologyName(Tegra::Shader::OutputTopology topology) {
    case Tegra::Shader::OutputTopology::TriangleStrip:
        return "triangle_strip";
    default:
-        UNIMPLEMENTED_MSG("Unknown output topology: {}", static_cast<u32>(topology));
+        UNIMPLEMENTED_MSG("Unknown output topology: {}", topology);
        return "points";
    }
 }
@@ -418,11 +418,12 @@ struct GenericVaryingDescription {
 class GLSLDecompiler final {
 public:
-    explicit GLSLDecompiler(const Device& device, const ShaderIR& ir, const Registry& registry,
+    explicit GLSLDecompiler(const Device& device_, const ShaderIR& ir_, const Registry& registry_,
-                            ShaderType stage, std::string_view identifier, std::string_view suffix)
+                            ShaderType stage_, std::string_view identifier_,
-        : device{device}, ir{ir}, registry{registry}, stage{stage}, identifier{identifier},
+                            std::string_view suffix_)
-          suffix{suffix}, header{ir.GetHeader()}, use_unified_uniforms{
+        : device{device_}, ir{ir_}, registry{registry_}, stage{stage_}, identifier{identifier_},
-                                                      UseUnifiedUniforms(device, ir, stage)} {
+          suffix{suffix_}, header{ir.GetHeader()}, use_unified_uniforms{
+                                                       UseUnifiedUniforms(device_, ir_, stage_)} {
        if (stage != ShaderType::Compute) {
            transform_feedback = BuildTransformFeedback(registry.GetGraphicsInfo());
        }
@@ -744,7 +745,7 @@ private:
        case PixelImap::Unused:
            break;
        }
-        UNIMPLEMENTED_MSG("Unknown attribute usage index={}", static_cast<int>(attribute));
+        UNIMPLEMENTED_MSG("Unknown attribute usage index={}", attribute);
        return {};
    }
@@ -777,16 +778,16 @@ private:
            name = "gs_" + name + "[]";
        }
-        std::string suffix;
+        std::string suffix_;
        if (stage == ShaderType::Fragment) {
            const auto input_mode{header.ps.GetPixelImap(location)};
            if (input_mode == PixelImap::Unused) {
                return;
            }
-            suffix = GetInputFlags(input_mode);
+            suffix_ = GetInputFlags(input_mode);
        }
-        code.AddLine("layout (location = {}) {} in vec4 {};", location, suffix, name);
+        code.AddLine("layout (location = {}) {} in vec4 {};", location, suffix_, name);
    }
    void DeclareOutputAttributes() {
@@ -877,7 +878,7 @@ private:
        }
        u32 binding = device.GetBaseBindings(stage).uniform_buffer;
-        for (const auto [index, info] : ir.GetConstantBuffers()) {
+        for (const auto& [index, info] : ir.GetConstantBuffers()) {
            const u32 num_elements = Common::AlignUp(info.GetSize(), 4) / 4;
            const u32 size = info.IsIndirect() ? MAX_CONSTBUFFER_ELEMENTS : num_elements;
            code.AddLine("layout (std140, binding = {}) uniform {} {{", binding++,
@@ -1251,7 +1252,7 @@ private:
            }
            break;
        }
-        UNIMPLEMENTED_MSG("Unhandled input attribute: {}", static_cast<u32>(attribute));
+        UNIMPLEMENTED_MSG("Unhandled input attribute: {}", attribute);
        return {"0", Type::Int};
    }
@@ -1331,7 +1332,7 @@ private:
                                     GetSwizzle(element)),
                         Type::Float}};
            }
-            UNIMPLEMENTED_MSG("Unhandled output attribute: {}", static_cast<u32>(attribute));
+            UNIMPLEMENTED_MSG("Unhandled output attribute: {}", attribute);
            return std::nullopt;
        }
    }
@@ -2100,13 +2101,13 @@ private:
        const auto type = meta.sampler.is_shadow ? Type::Float : Type::Int;
        const bool separate_dc = meta.sampler.is_shadow;
-        std::vector<TextureIR> ir;
+        std::vector<TextureIR> ir_;
        if (meta.sampler.is_shadow) {
-            ir = {TextureOffset{}};
+            ir_ = {TextureOffset{}};
        } else {
-            ir = {TextureOffset{}, TextureArgument{type, meta.component}};
+            ir_ = {TextureOffset{}, TextureArgument{type, meta.component}};
        }
-        return {GenerateTexture(operation, "Gather", ir, separate_dc) + GetSwizzle(meta.element),
+        return {GenerateTexture(operation, "Gather", ir_, separate_dc) + GetSwizzle(meta.element),
                Type::Float};
    }
@@ -2801,7 +2802,7 @@ std::string GetFlowVariable(u32 index) {
 class ExprDecompiler {
 public:
-    explicit ExprDecompiler(GLSLDecompiler& decomp) : decomp{decomp} {}
+    explicit ExprDecompiler(GLSLDecompiler& decomp_) : decomp{decomp_} {}
    void operator()(const ExprAnd& expr) {
        inner += '(';
@@ -2856,7 +2857,7 @@ private:
 class ASTDecompiler {
 public:
-    explicit ASTDecompiler(GLSLDecompiler& decomp) : decomp{decomp} {}
+    explicit ASTDecompiler(GLSLDecompiler& decomp_) : decomp{decomp_} {}
    void operator()(const ASTProgram& ast) {
        ASTNode current = ast.nodes.GetFirst();
diff --git a/src/video_core/renderer_opengl/gl_shader_decompiler.h b/src/video_core/renderer_opengl/gl_shader_decompiler.h
index 451c9689a..c4ff47875 100644
--- a/src/video_core/renderer_opengl/gl_shader_decompiler.h
+++ b/src/video_core/renderer_opengl/gl_shader_decompiler.h
@@ -25,8 +25,8 @@ using ImageEntry = VideoCommon::Shader::Image;
 class ConstBufferEntry : public VideoCommon::Shader::ConstBuffer {
 public:
-    explicit ConstBufferEntry(u32 max_offset, bool is_indirect, u32 index)
+    explicit ConstBufferEntry(u32 max_offset_, bool is_indirect_, u32 index_)
-        : VideoCommon::Shader::ConstBuffer{max_offset, is_indirect}, index{index} {}
+        : ConstBuffer{max_offset_, is_indirect_}, index{index_} {}
    u32 GetIndex() const {
        return index;
@@ -37,10 +37,10 @@ private:
 };
 struct GlobalMemoryEntry {
-    constexpr explicit GlobalMemoryEntry(u32 cbuf_index, u32 cbuf_offset, bool is_read,
+    constexpr explicit GlobalMemoryEntry(u32 cbuf_index_, u32 cbuf_offset_, bool is_read_,
-                                         bool is_written)
+                                         bool is_written_)
-        : cbuf_index{cbuf_index}, cbuf_offset{cbuf_offset}, is_read{is_read}, is_written{
+        : cbuf_index{cbuf_index_}, cbuf_offset{cbuf_offset_}, is_read{is_read_}, is_written{
-                                                                                  is_written} {}
+                                                                                     is_written_} {}
    u32 cbuf_index = 0;
    u32 cbuf_offset = 0;
diff --git a/src/video_core/renderer_opengl/gl_shader_disk_cache.cpp b/src/video_core/renderer_opengl/gl_shader_disk_cache.cpp
index 70dd0c3c6..955b2abc4 100644
--- a/src/video_core/renderer_opengl/gl_shader_disk_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_disk_cache.cpp
@@ -343,7 +343,7 @@ void ShaderDiskCacheOpenGL::SaveEntry(const ShaderDiskCacheEntry& entry) {
    }
    const u64 id = entry.unique_identifier;
-    if (stored_transferable.find(id) != stored_transferable.end()) {
+    if (stored_transferable.contains(id)) {
        // The shader already exists
        return;
    }
diff --git a/src/video_core/renderer_opengl/gl_state_tracker.cpp b/src/video_core/renderer_opengl/gl_state_tracker.cpp
index 6bcf831f2..45f4fc565 100644
--- a/src/video_core/renderer_opengl/gl_state_tracker.cpp
+++ b/src/video_core/renderer_opengl/gl_state_tracker.cpp
@@ -13,7 +13,7 @@
 #include "video_core/renderer_opengl/gl_state_tracker.h"
 #define OFF(field_name) MAXWELL3D_REG_INDEX(field_name)
-#define NUM(field_name) (sizeof(Maxwell3D::Regs::field_name) / sizeof(u32))
+#define NUM(field_name) (sizeof(Maxwell3D::Regs::field_name) / (sizeof(u32)))
 namespace OpenGL {
diff --git a/src/video_core/renderer_opengl/gl_texture_cache.cpp b/src/video_core/renderer_opengl/gl_texture_cache.cpp
index a863ef218..daf352b50 100644
--- a/src/video_core/renderer_opengl/gl_texture_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_texture_cache.cpp
@@ -258,9 +258,9 @@ constexpr u32 EncodeSwizzle(SwizzleSource x_source, SwizzleSource y_source, Swiz
 } // Anonymous namespace
-CachedSurface::CachedSurface(const GPUVAddr gpu_addr, const SurfaceParams& params,
+CachedSurface::CachedSurface(const GPUVAddr gpu_addr_, const SurfaceParams& params_,
-                             bool is_astc_supported)
+                             bool is_astc_supported_)
-    : VideoCommon::SurfaceBase<View>(gpu_addr, params, is_astc_supported) {
+    : SurfaceBase<View>{gpu_addr_, params_, is_astc_supported_} {
    if (is_converted) {
        internal_format = params.srgb_conversion ? GL_SRGB8_ALPHA8 : GL_RGBA8;
        format = GL_RGBA;
@@ -347,14 +347,14 @@ void CachedSurface::UploadTextureMipmap(u32 level, const std::vector<u8>& stagin
                                          internal_format, image_size, buffer);
            break;
        case SurfaceTarget::TextureCubemap: {
-            const std::size_t layer_size{params.GetHostLayerSize(level)};
+            const std::size_t host_layer_size{params.GetHostLayerSize(level)};
            for (std::size_t face = 0; face < params.depth; ++face) {
                glCompressedTextureSubImage3D(texture.handle, level, 0, 0, static_cast<GLint>(face),
                                              static_cast<GLsizei>(params.GetMipWidth(level)),
                                              static_cast<GLsizei>(params.GetMipHeight(level)), 1,
-                                              internal_format, static_cast<GLsizei>(layer_size),
+                                              internal_format,
-                                              buffer);
+                                              static_cast<GLsizei>(host_layer_size), buffer);
-                buffer += layer_size;
+                buffer += host_layer_size;
            }
            break;
        }
@@ -419,11 +419,11 @@ View CachedSurface::CreateViewInner(const ViewParams& view_key, const bool is_pr
    return view;
 }
-CachedSurfaceView::CachedSurfaceView(CachedSurface& surface, const ViewParams& params,
+CachedSurfaceView::CachedSurfaceView(CachedSurface& surface_, const ViewParams& params_,
-                                     bool is_proxy)
+                                     bool is_proxy_)
-    : VideoCommon::ViewBase(params), surface{surface}, format{surface.internal_format},
+    : ViewBase{params_}, surface{surface_}, format{surface_.internal_format},
-      target{GetTextureTarget(params.target)}, is_proxy{is_proxy} {
+      target{GetTextureTarget(params_.target)}, is_proxy{is_proxy_} {
-    if (!is_proxy) {
+    if (!is_proxy_) {
        main_view = CreateTextureView();
    }
 }
@@ -493,13 +493,13 @@ GLuint CachedSurfaceView::GetTexture(SwizzleSource x_source, SwizzleSource y_sou
    std::array swizzle{x_source, y_source, z_source, w_source};
-    switch (const PixelFormat format = GetSurfaceParams().pixel_format) {
+    switch (const PixelFormat pixel_format = GetSurfaceParams().pixel_format) {
    case PixelFormat::D24_UNORM_S8_UINT:
    case PixelFormat::D32_FLOAT_S8_UINT:
    case PixelFormat::S8_UINT_D24_UNORM:
        UNIMPLEMENTED_IF(x_source != SwizzleSource::R && x_source != SwizzleSource::G);
        glTextureParameteri(view.handle, GL_DEPTH_STENCIL_TEXTURE_MODE,
-                            GetComponent(format, x_source == SwizzleSource::R));
+                            GetComponent(pixel_format, x_source == SwizzleSource::R));
        // Make sure we sample the first component
        std::transform(swizzle.begin(), swizzle.end(), swizzle.begin(), [](SwizzleSource value) {
@@ -532,12 +532,12 @@ OGLTextureView CachedSurfaceView::CreateTextureView() const {
    return texture_view;
 }
-TextureCacheOpenGL::TextureCacheOpenGL(VideoCore::RasterizerInterface& rasterizer,
+TextureCacheOpenGL::TextureCacheOpenGL(VideoCore::RasterizerInterface& rasterizer_,
-                                       Tegra::Engines::Maxwell3D& maxwell3d,
+                                       Tegra::Engines::Maxwell3D& maxwell3d_,
-                                       Tegra::MemoryManager& gpu_memory, const Device& device,
+                                       Tegra::MemoryManager& gpu_memory_, const Device& device_,
                                       StateTracker& state_tracker_)
-    : TextureCacheBase{rasterizer, maxwell3d, gpu_memory, device.HasASTC()}, state_tracker{
+    : TextureCacheBase{rasterizer_, maxwell3d_, gpu_memory_, device_.HasASTC()},
-                                                                                 state_tracker_} {
+      state_tracker{state_tracker_} {
    src_framebuffer.Create();
    dst_framebuffer.Create();
 }
@@ -689,8 +689,7 @@ void TextureCacheOpenGL::BufferCopy(Surface& src_surface, Surface& dst_surface)
                                dest_format.format, dest_format.type, nullptr);
            break;
        default:
-            LOG_CRITICAL(Render_OpenGL, "Unimplemented surface target={}",
+            LOG_CRITICAL(Render_OpenGL, "Unimplemented surface target={}", dst_params.target);
-                         static_cast<u32>(dst_params.target));
            UNREACHABLE();
        }
    }
diff --git a/src/video_core/renderer_opengl/gl_texture_cache.h b/src/video_core/renderer_opengl/gl_texture_cache.h
index 7787134fc..72b284fab 100644
--- a/src/video_core/renderer_opengl/gl_texture_cache.h
+++ b/src/video_core/renderer_opengl/gl_texture_cache.h
@@ -37,7 +37,8 @@ class CachedSurface final : public VideoCommon::SurfaceBase<View> {
    friend CachedSurfaceView;
 public:
-    explicit CachedSurface(GPUVAddr gpu_addr, const SurfaceParams& params, bool is_astc_supported);
+    explicit CachedSurface(GPUVAddr gpu_addr_, const SurfaceParams& params_,
+                           bool is_astc_supported_);
    ~CachedSurface();
    void UploadTexture(const std::vector<u8>& staging_buffer) override;
@@ -77,7 +78,7 @@ private:
 class CachedSurfaceView final : public VideoCommon::ViewBase {
 public:
-    explicit CachedSurfaceView(CachedSurface& surface, const ViewParams& params, bool is_proxy);
+    explicit CachedSurfaceView(CachedSurface& surface_, const ViewParams& params_, bool is_proxy_);
    ~CachedSurfaceView();
    /// @brief Attaches this texture view to the currently bound fb_target framebuffer
@@ -129,9 +130,9 @@ private:
 class TextureCacheOpenGL final : public TextureCacheBase {
 public:
-    explicit TextureCacheOpenGL(VideoCore::RasterizerInterface& rasterizer,
+    explicit TextureCacheOpenGL(VideoCore::RasterizerInterface& rasterizer_,
-                                Tegra::Engines::Maxwell3D& maxwell3d,
+                                Tegra::Engines::Maxwell3D& maxwell3d_,
-                                Tegra::MemoryManager& gpu_memory, const Device& device,
+                                Tegra::MemoryManager& gpu_memory_, const Device& device_,
                                StateTracker& state_tracker);
    ~TextureCacheOpenGL();
diff --git a/src/video_core/renderer_opengl/maxwell_to_gl.h b/src/video_core/renderer_opengl/maxwell_to_gl.h
index a8be2aa37..dd4ee3361 100644
--- a/src/video_core/renderer_opengl/maxwell_to_gl.h
+++ b/src/video_core/renderer_opengl/maxwell_to_gl.h
@@ -107,7 +107,7 @@ inline GLenum IndexFormat(Maxwell::IndexFormat index_format) {
    case Maxwell::IndexFormat::UnsignedInt:
        return GL_UNSIGNED_INT;
    }
-    UNREACHABLE_MSG("Invalid index_format={}", static_cast<u32>(index_format));
+    UNREACHABLE_MSG("Invalid index_format={}", index_format);
    return {};
 }
@@ -144,7 +144,7 @@ inline GLenum PrimitiveTopology(Maxwell::PrimitiveTopology topology) {
    case Maxwell::PrimitiveTopology::Patches:
        return GL_PATCHES;
    }
-    UNREACHABLE_MSG("Invalid topology={}", static_cast<int>(topology));
+    UNREACHABLE_MSG("Invalid topology={}", topology);
    return GL_POINTS;
 }
@@ -172,8 +172,8 @@ inline GLenum TextureFilterMode(Tegra::Texture::TextureFilter filter_mode,
        }
        break;
    }
-    UNREACHABLE_MSG("Invalid texture filter mode={} and mipmap filter mode={}",
+    UNREACHABLE_MSG("Invalid texture filter mode={} and mipmap filter mode={}", filter_mode,
-                    static_cast<u32>(filter_mode), static_cast<u32>(mipmap_filter_mode));
+                    mipmap_filter_mode);
    return GL_NEAREST;
 }
@@ -204,7 +204,7 @@ inline GLenum WrapMode(Tegra::Texture::WrapMode wrap_mode) {
            return GL_MIRROR_CLAMP_TO_EDGE;
        }
    }
-    UNIMPLEMENTED_MSG("Unimplemented texture wrap mode={}", static_cast<u32>(wrap_mode));
+    UNIMPLEMENTED_MSG("Unimplemented texture wrap mode={}", wrap_mode);
    return GL_REPEAT;
 }
@@ -227,7 +227,7 @@ inline GLenum DepthCompareFunc(Tegra::Texture::DepthCompareFunc func) {
    case Tegra::Texture::DepthCompareFunc::Always:
        return GL_ALWAYS;
    }
-    UNIMPLEMENTED_MSG("Unimplemented texture depth compare function={}", static_cast<u32>(func));
+    UNIMPLEMENTED_MSG("Unimplemented texture depth compare function={}", func);
    return GL_GREATER;
 }
@@ -249,7 +249,7 @@ inline GLenum BlendEquation(Maxwell::Blend::Equation equation) {
    case Maxwell::Blend::Equation::MaxGL:
        return GL_MAX;
    }
-    UNIMPLEMENTED_MSG("Unimplemented blend equation={}", static_cast<u32>(equation));
+    UNIMPLEMENTED_MSG("Unimplemented blend equation={}", equation);
    return GL_FUNC_ADD;
 }
@@ -313,7 +313,7 @@ inline GLenum BlendFunc(Maxwell::Blend::Factor factor) {
    case Maxwell::Blend::Factor::OneMinusConstantAlphaGL:
        return GL_ONE_MINUS_CONSTANT_ALPHA;
    }
-    UNIMPLEMENTED_MSG("Unimplemented blend factor={}", static_cast<u32>(factor));
+    UNIMPLEMENTED_MSG("Unimplemented blend factor={}", factor);
    return GL_ZERO;
 }
@@ -333,7 +333,7 @@ inline GLenum SwizzleSource(Tegra::Texture::SwizzleSource source) {
    case Tegra::Texture::SwizzleSource::OneFloat:
        return GL_ONE;
    }
-    UNIMPLEMENTED_MSG("Unimplemented swizzle source={}", static_cast<u32>(source));
+    UNIMPLEMENTED_MSG("Unimplemented swizzle source={}", source);
    return GL_ZERO;
 }
@@ -364,7 +364,7 @@ inline GLenum ComparisonOp(Maxwell::ComparisonOp comparison) {
    case Maxwell::ComparisonOp::AlwaysOld:
        return GL_ALWAYS;
    }
-    UNIMPLEMENTED_MSG("Unimplemented comparison op={}", static_cast<u32>(comparison));
+    UNIMPLEMENTED_MSG("Unimplemented comparison op={}", comparison);
    return GL_ALWAYS;
 }
@@ -395,7 +395,7 @@ inline GLenum StencilOp(Maxwell::StencilOp stencil) {
    case Maxwell::StencilOp::DecrWrapOGL:
        return GL_DECR_WRAP;
    }
-    UNIMPLEMENTED_MSG("Unimplemented stencil op={}", static_cast<u32>(stencil));
+    UNIMPLEMENTED_MSG("Unimplemented stencil op={}", stencil);
    return GL_KEEP;
 }
@@ -406,7 +406,7 @@ inline GLenum FrontFace(Maxwell::FrontFace front_face) {
    case Maxwell::FrontFace::CounterClockWise:
        return GL_CCW;
    }
-    UNIMPLEMENTED_MSG("Unimplemented front face cull={}", static_cast<u32>(front_face));
+    UNIMPLEMENTED_MSG("Unimplemented front face cull={}", front_face);
    return GL_CCW;
 }
@@ -419,7 +419,7 @@ inline GLenum CullFace(Maxwell::CullFace cull_face) {
    case Maxwell::CullFace::FrontAndBack:
        return GL_FRONT_AND_BACK;
    }
-    UNIMPLEMENTED_MSG("Unimplemented cull face={}", static_cast<u32>(cull_face));
+    UNIMPLEMENTED_MSG("Unimplemented cull face={}", cull_face);
    return GL_BACK;
 }
@@ -458,7 +458,7 @@ inline GLenum LogicOp(Maxwell::LogicOperation operation) {
    case Maxwell::LogicOperation::Set:
        return GL_SET;
    }
-    UNIMPLEMENTED_MSG("Unimplemented logic operation={}", static_cast<u32>(operation));
+    UNIMPLEMENTED_MSG("Unimplemented logic operation={}", operation);
    return GL_COPY;
 }
@@ -471,7 +471,7 @@ inline GLenum PolygonMode(Maxwell::PolygonMode polygon_mode) {
    case Maxwell::PolygonMode::Fill:
        return GL_FILL;
    }
-    UNREACHABLE_MSG("Invalid polygon mode={}", static_cast<int>(polygon_mode));
+    UNREACHABLE_MSG("Invalid polygon mode={}", polygon_mode);
    return GL_FILL;
 }
diff --git a/src/video_core/renderer_opengl/renderer_opengl.cpp b/src/video_core/renderer_opengl/renderer_opengl.cpp
index c869bb0e2..cbfaaa99c 100644
--- a/src/video_core/renderer_opengl/renderer_opengl.cpp
+++ b/src/video_core/renderer_opengl/renderer_opengl.cpp
@@ -130,8 +130,8 @@ void APIENTRY DebugHandler(GLenum source, GLenum type, GLuint id, GLenum severit
 RendererOpenGL::RendererOpenGL(Core::TelemetrySession& telemetry_session_,
                               Core::Frontend::EmuWindow& emu_window_,
                               Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu_,
-                               std::unique_ptr<Core::Frontend::GraphicsContext> context)
+                               std::unique_ptr<Core::Frontend::GraphicsContext> context_)
-    : RendererBase{emu_window_, std::move(context)}, telemetry_session{telemetry_session_},
+    : RendererBase{emu_window_, std::move(context_)}, telemetry_session{telemetry_session_},
      emu_window{emu_window_}, cpu_memory{cpu_memory_}, gpu{gpu_}, program_manager{device} {}
 RendererOpenGL::~RendererOpenGL() = default;
@@ -275,9 +275,9 @@ void RendererOpenGL::AddTelemetryFields() {
    LOG_INFO(Render_OpenGL, "GL_RENDERER: {}", gpu_model);
    constexpr auto user_system = Common::Telemetry::FieldType::UserSystem;
-    telemetry_session.AddField(user_system, "GPU_Vendor", gpu_vendor);
+    telemetry_session.AddField(user_system, "GPU_Vendor", std::string(gpu_vendor));
-    telemetry_session.AddField(user_system, "GPU_Model", gpu_model);
+    telemetry_session.AddField(user_system, "GPU_Model", std::string(gpu_model));
-    telemetry_session.AddField(user_system, "GPU_OpenGL_Version", gl_version);
+    telemetry_session.AddField(user_system, "GPU_OpenGL_Version", std::string(gl_version));
 }
 void RendererOpenGL::CreateRasterizer() {
@@ -348,7 +348,7 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
        } else {
            // Other transformations are unsupported
            LOG_CRITICAL(Render_OpenGL, "Unsupported framebuffer_transform_flags={}",
-                         static_cast<u32>(framebuffer_transform_flags));
+                         framebuffer_transform_flags);
            UNIMPLEMENTED();
        }
    }
diff --git a/src/video_core/renderer_opengl/renderer_opengl.h b/src/video_core/renderer_opengl/renderer_opengl.h
index 9ef181f95..376f88766 100644
--- a/src/video_core/renderer_opengl/renderer_opengl.h
+++ b/src/video_core/renderer_opengl/renderer_opengl.h
@@ -57,10 +57,10 @@ struct ScreenInfo {
 class RendererOpenGL final : public VideoCore::RendererBase {
 public:
-    explicit RendererOpenGL(Core::TelemetrySession& telemetry_session,
+    explicit RendererOpenGL(Core::TelemetrySession& telemetry_session_,
-                            Core::Frontend::EmuWindow& emu_window, Core::Memory::Memory& cpu_memory,
+                            Core::Frontend::EmuWindow& emu_window_,
-                            Tegra::GPU& gpu,
+                            Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu_,
-                            std::unique_ptr<Core::Frontend::GraphicsContext> context);
+                            std::unique_ptr<Core::Frontend::GraphicsContext> context_);
    ~RendererOpenGL() override;
    bool Init() override;
diff --git a/src/video_core/renderer_vulkan/maxwell_to_vk.cpp b/src/video_core/renderer_vulkan/maxwell_to_vk.cpp
index d22de1d81..58e117eb3 100644
--- a/src/video_core/renderer_vulkan/maxwell_to_vk.cpp
+++ b/src/video_core/renderer_vulkan/maxwell_to_vk.cpp
@@ -26,7 +26,7 @@ VkFilter Filter(Tegra::Texture::TextureFilter filter) {
    case Tegra::Texture::TextureFilter::Linear:
        return VK_FILTER_LINEAR;
    }
-    UNREACHABLE_MSG("Invalid sampler filter={}", static_cast<u32>(filter));
+    UNREACHABLE_MSG("Invalid sampler filter={}", filter);
    return {};
 }
@@ -43,7 +43,7 @@ VkSamplerMipmapMode MipmapMode(Tegra::Texture::TextureMipmapFilter mipmap_filter
    case Tegra::Texture::TextureMipmapFilter::Linear:
        return VK_SAMPLER_MIPMAP_MODE_LINEAR;
    }
-    UNREACHABLE_MSG("Invalid sampler mipmap mode={}", static_cast<u32>(mipmap_filter));
+    UNREACHABLE_MSG("Invalid sampler mipmap mode={}", mipmap_filter);
    return {};
 }
@@ -79,7 +79,7 @@ VkSamplerAddressMode WrapMode(const VKDevice& device, Tegra::Texture::WrapMode w
        UNIMPLEMENTED();
        return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented wrap mode={}", static_cast<u32>(wrap_mode));
+        UNIMPLEMENTED_MSG("Unimplemented wrap mode={}", wrap_mode);
        return {};
    }
 }
@@ -103,8 +103,7 @@ VkCompareOp DepthCompareFunction(Tegra::Texture::DepthCompareFunc depth_compare_
    case Tegra::Texture::DepthCompareFunc::Always:
        return VK_COMPARE_OP_ALWAYS;
    }
-    UNIMPLEMENTED_MSG("Unimplemented sampler depth compare function={}",
+    UNIMPLEMENTED_MSG("Unimplemented sampler depth compare function={}", depth_compare_func);
-                      static_cast<u32>(depth_compare_func));
    return {};
 }
@@ -228,8 +227,7 @@ FormatInfo SurfaceFormat(const VKDevice& device, FormatType format_type, PixelFo
    auto tuple = tex_format_tuples[static_cast<std::size_t>(pixel_format)];
    if (tuple.format == VK_FORMAT_UNDEFINED) {
-        UNIMPLEMENTED_MSG("Unimplemented texture format with pixel format={}",
+        UNIMPLEMENTED_MSG("Unimplemented texture format with pixel format={}", pixel_format);
-                          static_cast<u32>(pixel_format));
        return {VK_FORMAT_A8B8G8R8_UNORM_PACK32, true, true};
    }
@@ -275,7 +273,7 @@ VkShaderStageFlagBits ShaderStage(Tegra::Engines::ShaderType stage) {
    case Tegra::Engines::ShaderType::Compute:
        return VK_SHADER_STAGE_COMPUTE_BIT;
    }
-    UNIMPLEMENTED_MSG("Unimplemented shader stage={}", static_cast<u32>(stage));
+    UNIMPLEMENTED_MSG("Unimplemented shader stage={}", stage);
    return {};
 }
@@ -300,7 +298,7 @@ VkPrimitiveTopology PrimitiveTopology([[maybe_unused]] const VKDevice& device,
    case Maxwell::PrimitiveTopology::Patches:
        return VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented topology={}", static_cast<u32>(topology));
+        UNIMPLEMENTED_MSG("Unimplemented topology={}", topology);
        return {};
    }
 }
@@ -490,8 +488,7 @@ VkFormat VertexFormat(Maxwell::VertexAttribute::Type type, Maxwell::VertexAttrib
        }
        break;
    }
-    UNIMPLEMENTED_MSG("Unimplemented vertex format of type={} and size={}", static_cast<u32>(type),
+    UNIMPLEMENTED_MSG("Unimplemented vertex format of type={} and size={}", type, size);
-                      static_cast<u32>(size));
    return {};
 }
@@ -522,7 +519,7 @@ VkCompareOp ComparisonOp(Maxwell::ComparisonOp comparison) {
    case Maxwell::ComparisonOp::AlwaysOld:
        return VK_COMPARE_OP_ALWAYS;
    }
-    UNIMPLEMENTED_MSG("Unimplemented comparison op={}", static_cast<u32>(comparison));
+    UNIMPLEMENTED_MSG("Unimplemented comparison op={}", comparison);
    return {};
 }
@@ -539,7 +536,7 @@ VkIndexType IndexFormat(const VKDevice& device, Maxwell::IndexFormat index_forma
    case Maxwell::IndexFormat::UnsignedInt:
        return VK_INDEX_TYPE_UINT32;
    }
-    UNIMPLEMENTED_MSG("Unimplemented index_format={}", static_cast<u32>(index_format));
+    UNIMPLEMENTED_MSG("Unimplemented index_format={}", index_format);
    return {};
 }
@@ -570,7 +567,7 @@ VkStencilOp StencilOp(Maxwell::StencilOp stencil_op) {
    case Maxwell::StencilOp::DecrWrapOGL:
        return VK_STENCIL_OP_DECREMENT_AND_WRAP;
    }
-    UNIMPLEMENTED_MSG("Unimplemented stencil op={}", static_cast<u32>(stencil_op));
+    UNIMPLEMENTED_MSG("Unimplemented stencil op={}", stencil_op);
    return {};
 }
@@ -592,7 +589,7 @@ VkBlendOp BlendEquation(Maxwell::Blend::Equation equation) {
    case Maxwell::Blend::Equation::MaxGL:
        return VK_BLEND_OP_MAX;
    }
-    UNIMPLEMENTED_MSG("Unimplemented blend equation={}", static_cast<u32>(equation));
+    UNIMPLEMENTED_MSG("Unimplemented blend equation={}", equation);
    return {};
 }
@@ -656,7 +653,7 @@ VkBlendFactor BlendFactor(Maxwell::Blend::Factor factor) {
    case Maxwell::Blend::Factor::OneMinusConstantAlphaGL:
        return VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA;
    }
-    UNIMPLEMENTED_MSG("Unimplemented blend factor={}", static_cast<u32>(factor));
+    UNIMPLEMENTED_MSG("Unimplemented blend factor={}", factor);
    return {};
 }
@@ -667,7 +664,7 @@ VkFrontFace FrontFace(Maxwell::FrontFace front_face) {
    case Maxwell::FrontFace::CounterClockWise:
        return VK_FRONT_FACE_COUNTER_CLOCKWISE;
    }
-    UNIMPLEMENTED_MSG("Unimplemented front face={}", static_cast<u32>(front_face));
+    UNIMPLEMENTED_MSG("Unimplemented front face={}", front_face);
    return {};
 }
@@ -680,7 +677,7 @@ VkCullModeFlags CullFace(Maxwell::CullFace cull_face) {
    case Maxwell::CullFace::FrontAndBack:
        return VK_CULL_MODE_FRONT_AND_BACK;
    }
-    UNIMPLEMENTED_MSG("Unimplemented cull face={}", static_cast<u32>(cull_face));
+    UNIMPLEMENTED_MSG("Unimplemented cull face={}", cull_face);
    return {};
 }
@@ -700,7 +697,7 @@ VkComponentSwizzle SwizzleSource(Tegra::Texture::SwizzleSource swizzle) {
    case Tegra::Texture::SwizzleSource::OneFloat:
        return VK_COMPONENT_SWIZZLE_ONE;
    }
-    UNIMPLEMENTED_MSG("Unimplemented swizzle source={}", static_cast<u32>(swizzle));
+    UNIMPLEMENTED_MSG("Unimplemented swizzle source={}", swizzle);
    return {};
 }
@@ -723,7 +720,7 @@ VkViewportCoordinateSwizzleNV ViewportSwizzle(Maxwell::ViewportSwizzle swizzle)
    case Maxwell::ViewportSwizzle::NegativeW:
        return VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV;
    }
-    UNREACHABLE_MSG("Invalid swizzle={}", static_cast<int>(swizzle));
+    UNREACHABLE_MSG("Invalid swizzle={}", swizzle);
    return {};
 }
diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.cpp b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
index a2173edd2..ea4b7c1e6 100644
--- a/src/video_core/renderer_vulkan/renderer_vulkan.cpp
+++ b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
@@ -243,8 +243,8 @@ std::string BuildCommaSeparatedExtensions(std::vector<std::string> available_ext
 RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
                               Core::Frontend::EmuWindow& emu_window,
                               Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu_,
-                               std::unique_ptr<Core::Frontend::GraphicsContext> context)
+                               std::unique_ptr<Core::Frontend::GraphicsContext> context_)
-    : RendererBase{emu_window, std::move(context)}, telemetry_session{telemetry_session_},
+    : RendererBase{emu_window, std::move(context_)}, telemetry_session{telemetry_session_},
      cpu_memory{cpu_memory_}, gpu{gpu_} {}
 RendererVulkan::~RendererVulkan() {
diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.h b/src/video_core/renderer_vulkan/renderer_vulkan.h
index 1044ca124..977b86003 100644
--- a/src/video_core/renderer_vulkan/renderer_vulkan.h
+++ b/src/video_core/renderer_vulkan/renderer_vulkan.h
@@ -45,9 +45,9 @@ struct VKScreenInfo {
 class RendererVulkan final : public VideoCore::RendererBase {
 public:
    explicit RendererVulkan(Core::TelemetrySession& telemtry_session,
-                            Core::Frontend::EmuWindow& emu_window, Core::Memory::Memory& cpu_memory,
+                            Core::Frontend::EmuWindow& emu_window,
-                            Tegra::GPU& gpu,
+                            Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu_,
-                            std::unique_ptr<Core::Frontend::GraphicsContext> context);
+                            std::unique_ptr<Core::Frontend::GraphicsContext> context_);
    ~RendererVulkan() override;
    bool Init() override;
diff --git a/src/video_core/renderer_vulkan/vk_buffer_cache.cpp b/src/video_core/renderer_vulkan/vk_buffer_cache.cpp
index d9d3da9ea..444d3fb93 100644
--- a/src/video_core/renderer_vulkan/vk_buffer_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_buffer_cache.cpp
@@ -38,13 +38,13 @@ std::unique_ptr<VKStreamBuffer> CreateStreamBuffer(const VKDevice& device, VKSch
 } // Anonymous namespace
 Buffer::Buffer(const VKDevice& device, VKMemoryManager& memory_manager, VKScheduler& scheduler_,
-               VKStagingBufferPool& staging_pool_, VAddr cpu_addr, std::size_t size)
+               VKStagingBufferPool& staging_pool_, VAddr cpu_addr_, std::size_t size_)
-    : BufferBlock{cpu_addr, size}, scheduler{scheduler_}, staging_pool{staging_pool_} {
+    : BufferBlock{cpu_addr_, size_}, scheduler{scheduler_}, staging_pool{staging_pool_} {
    const VkBufferCreateInfo ci{
        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
-        .size = static_cast<VkDeviceSize>(size),
+        .size = static_cast<VkDeviceSize>(size_),
        .usage = BUFFER_USAGE | VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
        .queueFamilyIndexCount = 0,
@@ -57,69 +57,71 @@ Buffer::Buffer(const VKDevice& device, VKMemoryManager& memory_manager, VKSchedu
 Buffer::~Buffer() = default;
-void Buffer::Upload(std::size_t offset, std::size_t size, const u8* data) {
+void Buffer::Upload(std::size_t offset, std::size_t data_size, const u8* data) {
-    const auto& staging = staging_pool.GetUnusedBuffer(size, true);
+    const auto& staging = staging_pool.GetUnusedBuffer(data_size, true);
-    std::memcpy(staging.commit->Map(size), data, size);
+    std::memcpy(staging.commit->Map(data_size), data, data_size);
    scheduler.RequestOutsideRenderPassOperationContext();
    const VkBuffer handle = Handle();
-    scheduler.Record([staging = *staging.handle, handle, offset, size](vk::CommandBuffer cmdbuf) {
+    scheduler.Record(
-        cmdbuf.CopyBuffer(staging, handle, VkBufferCopy{0, offset, size});
+        [staging = *staging.handle, handle, offset, data_size](vk::CommandBuffer cmdbuf) {
+            cmdbuf.CopyBuffer(staging, handle, VkBufferCopy{0, offset, data_size});
-        const VkBufferMemoryBarrier barrier{
-            .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+            const VkBufferMemoryBarrier barrier{
-            .pNext = nullptr,
+                .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
-            .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+                .pNext = nullptr,
-            .dstAccessMask = UPLOAD_ACCESS_BARRIERS,
+                .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .dstAccessMask = UPLOAD_ACCESS_BARRIERS,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .buffer = handle,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .offset = offset,
+                .buffer = handle,
-            .size = size,
+                .offset = offset,
-        };
+                .size = data_size,
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, UPLOAD_PIPELINE_STAGE, 0, {},
+            };
-                               barrier, {});
+            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, UPLOAD_PIPELINE_STAGE, 0, {},
-    });
+                                   barrier, {});
+        });
 }
-void Buffer::Download(std::size_t offset, std::size_t size, u8* data) {
+void Buffer::Download(std::size_t offset, std::size_t data_size, u8* data) {
-    const auto& staging = staging_pool.GetUnusedBuffer(size, true);
+    const auto& staging = staging_pool.GetUnusedBuffer(data_size, true);
    scheduler.RequestOutsideRenderPassOperationContext();
    const VkBuffer handle = Handle();
-    scheduler.Record([staging = *staging.handle, handle, offset, size](vk::CommandBuffer cmdbuf) {
+    scheduler.Record(
-        const VkBufferMemoryBarrier barrier{
+        [staging = *staging.handle, handle, offset, data_size](vk::CommandBuffer cmdbuf) {
-            .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+            const VkBufferMemoryBarrier barrier{
-            .pNext = nullptr,
+                .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
-            .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
+                .pNext = nullptr,
-            .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
+                .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .buffer = handle,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .offset = offset,
+                .buffer = handle,
-            .size = size,
+                .offset = offset,
-        };
+                .size = data_size,
+            };
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
-                                   VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
+            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
-                                   VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+                                       VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
-                               VK_PIPELINE_STAGE_TRANSFER_BIT, 0, {}, barrier, {});
+                                       VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-        cmdbuf.CopyBuffer(handle, staging, VkBufferCopy{offset, 0, size});
+                                   VK_PIPELINE_STAGE_TRANSFER_BIT, 0, {}, barrier, {});
-    });
+            cmdbuf.CopyBuffer(handle, staging, VkBufferCopy{offset, 0, data_size});
+        });
    scheduler.Finish();
-    std::memcpy(data, staging.commit->Map(size), size);
+    std::memcpy(data, staging.commit->Map(data_size), data_size);
 }
 void Buffer::CopyFrom(const Buffer& src, std::size_t src_offset, std::size_t dst_offset,
-                      std::size_t size) {
+                      std::size_t copy_size) {
    scheduler.RequestOutsideRenderPassOperationContext();
    const VkBuffer dst_buffer = Handle();
    scheduler.Record([src_buffer = src.Handle(), dst_buffer, src_offset, dst_offset,
-                      size](vk::CommandBuffer cmdbuf) {
+                      copy_size](vk::CommandBuffer cmdbuf) {
-        cmdbuf.CopyBuffer(src_buffer, dst_buffer, VkBufferCopy{src_offset, dst_offset, size});
+        cmdbuf.CopyBuffer(src_buffer, dst_buffer, VkBufferCopy{src_offset, dst_offset, copy_size});
        std::array<VkBufferMemoryBarrier, 2> barriers;
        barriers[0].sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
@@ -130,7 +132,7 @@ void Buffer::CopyFrom(const Buffer& src, std::size_t src_offset, std::size_t dst
        barriers[0].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barriers[0].buffer = src_buffer;
        barriers[0].offset = src_offset;
-        barriers[0].size = size;
+        barriers[0].size = copy_size;
        barriers[1].sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
        barriers[1].pNext = nullptr;
        barriers[1].srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
@@ -139,19 +141,17 @@ void Buffer::CopyFrom(const Buffer& src, std::size_t src_offset, std::size_t dst
        barriers[1].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barriers[1].buffer = dst_buffer;
        barriers[1].offset = dst_offset;
-        barriers[1].size = size;
+        barriers[1].size = copy_size;
        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, UPLOAD_PIPELINE_STAGE, 0, {},
                               barriers, {});
    });
 }
-VKBufferCache::VKBufferCache(VideoCore::RasterizerInterface& rasterizer,
+VKBufferCache::VKBufferCache(VideoCore::RasterizerInterface& rasterizer_,
-                             Tegra::MemoryManager& gpu_memory, Core::Memory::Memory& cpu_memory,
+                             Tegra::MemoryManager& gpu_memory_, Core::Memory::Memory& cpu_memory_,
                             const VKDevice& device_, VKMemoryManager& memory_manager_,
                             VKScheduler& scheduler_, VKStagingBufferPool& staging_pool_)
-    : VideoCommon::BufferCache<Buffer, VkBuffer, VKStreamBuffer>{rasterizer, gpu_memory, cpu_memory,
+    : BufferCache{rasterizer_, gpu_memory_, cpu_memory_, CreateStreamBuffer(device_, scheduler_)},
-                                                                 CreateStreamBuffer(device_,
-                                                                                    scheduler_)},
      device{device_}, memory_manager{memory_manager_}, scheduler{scheduler_}, staging_pool{
                                                                                   staging_pool_} {}
diff --git a/src/video_core/renderer_vulkan/vk_buffer_cache.h b/src/video_core/renderer_vulkan/vk_buffer_cache.h
index 7fb5ceedf..6008b8373 100644
--- a/src/video_core/renderer_vulkan/vk_buffer_cache.h
+++ b/src/video_core/renderer_vulkan/vk_buffer_cache.h
@@ -22,15 +22,15 @@ class VKScheduler;
 class Buffer final : public VideoCommon::BufferBlock {
 public:
    explicit Buffer(const VKDevice& device, VKMemoryManager& memory_manager, VKScheduler& scheduler,
-                    VKStagingBufferPool& staging_pool, VAddr cpu_addr, std::size_t size);
+                    VKStagingBufferPool& staging_pool, VAddr cpu_addr_, std::size_t size_);
    ~Buffer();
-    void Upload(std::size_t offset, std::size_t size, const u8* data);
+    void Upload(std::size_t offset, std::size_t data_size, const u8* data);
-    void Download(std::size_t offset, std::size_t size, u8* data);
+    void Download(std::size_t offset, std::size_t data_size, u8* data);
    void CopyFrom(const Buffer& src, std::size_t src_offset, std::size_t dst_offset,
-                  std::size_t size);
+                  std::size_t copy_size);
    VkBuffer Handle() const {
        return *buffer.handle;
@@ -49,10 +49,10 @@ private:
 class VKBufferCache final : public VideoCommon::BufferCache<Buffer, VkBuffer, VKStreamBuffer> {
 public:
-    explicit VKBufferCache(VideoCore::RasterizerInterface& rasterizer,
+    explicit VKBufferCache(VideoCore::RasterizerInterface& rasterizer_,
-                           Tegra::MemoryManager& gpu_memory, Core::Memory::Memory& cpu_memory,
+                           Tegra::MemoryManager& gpu_memory_, Core::Memory::Memory& cpu_memory_,
-                           const VKDevice& device, VKMemoryManager& memory_manager,
+                           const VKDevice& device_, VKMemoryManager& memory_manager_,
-                           VKScheduler& scheduler, VKStagingBufferPool& staging_pool);
+                           VKScheduler& scheduler_, VKStagingBufferPool& staging_pool_);
    ~VKBufferCache();
    BufferInfo GetEmptyBuffer(std::size_t size) override;
diff --git a/src/video_core/renderer_vulkan/vk_command_pool.cpp b/src/video_core/renderer_vulkan/vk_command_pool.cpp
index 6339f4fe0..8f7d6410e 100644
--- a/src/video_core/renderer_vulkan/vk_command_pool.cpp
+++ b/src/video_core/renderer_vulkan/vk_command_pool.cpp
@@ -17,8 +17,8 @@ struct CommandPool::Pool {
    vk::CommandBuffers cmdbufs;
 };
-CommandPool::CommandPool(MasterSemaphore& master_semaphore, const VKDevice& device)
+CommandPool::CommandPool(MasterSemaphore& master_semaphore_, const VKDevice& device_)
-    : ResourcePool(master_semaphore, COMMAND_BUFFER_POOL_SIZE), device{device} {}
+    : ResourcePool(master_semaphore_, COMMAND_BUFFER_POOL_SIZE), device{device_} {}
 CommandPool::~CommandPool() = default;
diff --git a/src/video_core/renderer_vulkan/vk_command_pool.h b/src/video_core/renderer_vulkan/vk_command_pool.h
index b9cb3fb5d..62a7ce3f1 100644
--- a/src/video_core/renderer_vulkan/vk_command_pool.h
+++ b/src/video_core/renderer_vulkan/vk_command_pool.h
@@ -17,7 +17,7 @@ class VKDevice;
 class CommandPool final : public ResourcePool {
 public:
-    explicit CommandPool(MasterSemaphore& master_semaphore, const VKDevice& device);
+    explicit CommandPool(MasterSemaphore& master_semaphore_, const VKDevice& device_);
    ~CommandPool() override;
    void Allocate(size_t begin, size_t end) override;
diff --git a/src/video_core/renderer_vulkan/vk_compute_pass.cpp b/src/video_core/renderer_vulkan/vk_compute_pass.cpp
index 9637c6059..1ac7e2a30 100644
--- a/src/video_core/renderer_vulkan/vk_compute_pass.cpp
+++ b/src/video_core/renderer_vulkan/vk_compute_pass.cpp
@@ -461,15 +461,15 @@ VkDescriptorSet VKComputePass::CommitDescriptorSet(
    return set;
 }
-QuadArrayPass::QuadArrayPass(const VKDevice& device, VKScheduler& scheduler,
+QuadArrayPass::QuadArrayPass(const VKDevice& device_, VKScheduler& scheduler_,
-                             VKDescriptorPool& descriptor_pool,
+                             VKDescriptorPool& descriptor_pool_,
-                             VKStagingBufferPool& staging_buffer_pool,
+                             VKStagingBufferPool& staging_buffer_pool_,
-                             VKUpdateDescriptorQueue& update_descriptor_queue)
+                             VKUpdateDescriptorQueue& update_descriptor_queue_)
-    : VKComputePass(device, descriptor_pool, BuildQuadArrayPassDescriptorSetLayoutBinding(),
+    : VKComputePass(device_, descriptor_pool_, BuildQuadArrayPassDescriptorSetLayoutBinding(),
                    BuildQuadArrayPassDescriptorUpdateTemplateEntry(),
                    BuildComputePushConstantRange(sizeof(u32)), std::size(quad_array), quad_array),
-      scheduler{scheduler}, staging_buffer_pool{staging_buffer_pool},
+      scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
-      update_descriptor_queue{update_descriptor_queue} {}
+      update_descriptor_queue{update_descriptor_queue_} {}
 QuadArrayPass::~QuadArrayPass() = default;
@@ -510,14 +510,14 @@ std::pair<VkBuffer, VkDeviceSize> QuadArrayPass::Assemble(u32 num_vertices, u32
    return {*buffer.handle, 0};
 }
-Uint8Pass::Uint8Pass(const VKDevice& device, VKScheduler& scheduler,
+Uint8Pass::Uint8Pass(const VKDevice& device_, VKScheduler& scheduler_,
-                     VKDescriptorPool& descriptor_pool, VKStagingBufferPool& staging_buffer_pool,
+                     VKDescriptorPool& descriptor_pool_, VKStagingBufferPool& staging_buffer_pool_,
-                     VKUpdateDescriptorQueue& update_descriptor_queue)
+                     VKUpdateDescriptorQueue& update_descriptor_queue_)
-    : VKComputePass(device, descriptor_pool, BuildInputOutputDescriptorSetBindings(),
+    : VKComputePass(device_, descriptor_pool_, BuildInputOutputDescriptorSetBindings(),
                    BuildInputOutputDescriptorUpdateTemplate(), {}, std::size(uint8_pass),
                    uint8_pass),
-      scheduler{scheduler}, staging_buffer_pool{staging_buffer_pool},
+      scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
-      update_descriptor_queue{update_descriptor_queue} {}
+      update_descriptor_queue{update_descriptor_queue_} {}
 Uint8Pass::~Uint8Pass() = default;
@@ -555,16 +555,16 @@ std::pair<VkBuffer, u64> Uint8Pass::Assemble(u32 num_vertices, VkBuffer src_buff
    return {*buffer.handle, 0};
 }
-QuadIndexedPass::QuadIndexedPass(const VKDevice& device, VKScheduler& scheduler,
+QuadIndexedPass::QuadIndexedPass(const VKDevice& device_, VKScheduler& scheduler_,
-                                 VKDescriptorPool& descriptor_pool,
+                                 VKDescriptorPool& descriptor_pool_,
-                                 VKStagingBufferPool& staging_buffer_pool,
+                                 VKStagingBufferPool& staging_buffer_pool_,
-                                 VKUpdateDescriptorQueue& update_descriptor_queue)
+                                 VKUpdateDescriptorQueue& update_descriptor_queue_)
-    : VKComputePass(device, descriptor_pool, BuildInputOutputDescriptorSetBindings(),
+    : VKComputePass(device_, descriptor_pool_, BuildInputOutputDescriptorSetBindings(),
                    BuildInputOutputDescriptorUpdateTemplate(),
                    BuildComputePushConstantRange(sizeof(u32) * 2), std::size(QUAD_INDEXED_SPV),
                    QUAD_INDEXED_SPV),
-      scheduler{scheduler}, staging_buffer_pool{staging_buffer_pool},
+      scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
-      update_descriptor_queue{update_descriptor_queue} {}
+      update_descriptor_queue{update_descriptor_queue_} {}
 QuadIndexedPass::~QuadIndexedPass() = default;
diff --git a/src/video_core/renderer_vulkan/vk_compute_pass.h b/src/video_core/renderer_vulkan/vk_compute_pass.h
index acc94f27e..2dc87902c 100644
--- a/src/video_core/renderer_vulkan/vk_compute_pass.h
+++ b/src/video_core/renderer_vulkan/vk_compute_pass.h
@@ -43,10 +43,10 @@ private:
 class QuadArrayPass final : public VKComputePass {
 public:
-    explicit QuadArrayPass(const VKDevice& device, VKScheduler& scheduler,
+    explicit QuadArrayPass(const VKDevice& device_, VKScheduler& scheduler_,
-                           VKDescriptorPool& descriptor_pool,
+                           VKDescriptorPool& descriptor_pool_,
-                           VKStagingBufferPool& staging_buffer_pool,
+                           VKStagingBufferPool& staging_buffer_pool_,
-                           VKUpdateDescriptorQueue& update_descriptor_queue);
+                           VKUpdateDescriptorQueue& update_descriptor_queue_);
    ~QuadArrayPass();
    std::pair<VkBuffer, VkDeviceSize> Assemble(u32 num_vertices, u32 first);
@@ -59,9 +59,10 @@ private:
 class Uint8Pass final : public VKComputePass {
 public:
-    explicit Uint8Pass(const VKDevice& device, VKScheduler& scheduler,
+    explicit Uint8Pass(const VKDevice& device_, VKScheduler& scheduler_,
-                       VKDescriptorPool& descriptor_pool, VKStagingBufferPool& staging_buffer_pool,
+                       VKDescriptorPool& descriptor_pool_,
-                       VKUpdateDescriptorQueue& update_descriptor_queue);
+                       VKStagingBufferPool& staging_buffer_pool_,
+                       VKUpdateDescriptorQueue& update_descriptor_queue_);
    ~Uint8Pass();
    std::pair<VkBuffer, u64> Assemble(u32 num_vertices, VkBuffer src_buffer, u64 src_offset);
@@ -74,10 +75,10 @@ private:
 class QuadIndexedPass final : public VKComputePass {
 public:
-    explicit QuadIndexedPass(const VKDevice& device, VKScheduler& scheduler,
+    explicit QuadIndexedPass(const VKDevice& device_, VKScheduler& scheduler_,
-                             VKDescriptorPool& descriptor_pool,
+                             VKDescriptorPool& descriptor_pool_,
-                             VKStagingBufferPool& staging_buffer_pool,
+                             VKStagingBufferPool& staging_buffer_pool_,
-                             VKUpdateDescriptorQueue& update_descriptor_queue);
+                             VKUpdateDescriptorQueue& update_descriptor_queue_);
    ~QuadIndexedPass();
    std::pair<VkBuffer, u64> Assemble(Tegra::Engines::Maxwell3D::Regs::IndexFormat index_format,
diff --git a/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp b/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp
index 9be72dc9b..62f44d6da 100644
--- a/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp
+++ b/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp
@@ -15,16 +15,16 @@
 namespace Vulkan {
-VKComputePipeline::VKComputePipeline(const VKDevice& device, VKScheduler& scheduler,
+VKComputePipeline::VKComputePipeline(const VKDevice& device_, VKScheduler& scheduler_,
-                                     VKDescriptorPool& descriptor_pool,
+                                     VKDescriptorPool& descriptor_pool_,
-                                     VKUpdateDescriptorQueue& update_descriptor_queue,
+                                     VKUpdateDescriptorQueue& update_descriptor_queue_,
-                                     const SPIRVShader& shader)
+                                     const SPIRVShader& shader_)
-    : device{device}, scheduler{scheduler}, entries{shader.entries},
+    : device{device_}, scheduler{scheduler_}, entries{shader_.entries},
      descriptor_set_layout{CreateDescriptorSetLayout()},
-      descriptor_allocator{descriptor_pool, *descriptor_set_layout},
+      descriptor_allocator{descriptor_pool_, *descriptor_set_layout},
-      update_descriptor_queue{update_descriptor_queue}, layout{CreatePipelineLayout()},
+      update_descriptor_queue{update_descriptor_queue_}, layout{CreatePipelineLayout()},
      descriptor_template{CreateDescriptorUpdateTemplate()},
-      shader_module{CreateShaderModule(shader.code)}, pipeline{CreatePipeline()} {}
+      shader_module{CreateShaderModule(shader_.code)}, pipeline{CreatePipeline()} {}
 VKComputePipeline::~VKComputePipeline() = default;
diff --git a/src/video_core/renderer_vulkan/vk_compute_pipeline.h b/src/video_core/renderer_vulkan/vk_compute_pipeline.h
index 6e2f22a4a..49e2113a2 100644
--- a/src/video_core/renderer_vulkan/vk_compute_pipeline.h
+++ b/src/video_core/renderer_vulkan/vk_compute_pipeline.h
@@ -17,10 +17,10 @@ class VKUpdateDescriptorQueue;
 class VKComputePipeline final {
 public:
-    explicit VKComputePipeline(const VKDevice& device, VKScheduler& scheduler,
+    explicit VKComputePipeline(const VKDevice& device_, VKScheduler& scheduler_,
-                               VKDescriptorPool& descriptor_pool,
+                               VKDescriptorPool& descriptor_pool_,
-                               VKUpdateDescriptorQueue& update_descriptor_queue,
+                               VKUpdateDescriptorQueue& update_descriptor_queue_,
-                               const SPIRVShader& shader);
+                               const SPIRVShader& shader_);
    ~VKComputePipeline();
    VkDescriptorSet CommitDescriptorSet();
diff --git a/src/video_core/renderer_vulkan/vk_device.cpp b/src/video_core/renderer_vulkan/vk_device.cpp
index f34ed6735..ce3846195 100644
--- a/src/video_core/renderer_vulkan/vk_device.cpp
+++ b/src/video_core/renderer_vulkan/vk_device.cpp
@@ -491,8 +491,8 @@ bool VKDevice::IsOptimalAstcSupported(const VkPhysicalDeviceFeatures& features)
        VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
        VK_FORMAT_FEATURE_TRANSFER_DST_BIT};
    for (const auto format : astc_formats) {
-        const auto format_properties{physical.GetFormatProperties(format)};
+        const auto physical_format_properties{physical.GetFormatProperties(format)};
-        if (!(format_properties.optimalTilingFeatures & format_feature_usage)) {
+        if ((physical_format_properties.optimalTilingFeatures & format_feature_usage) == 0) {
            return false;
        }
    }
@@ -644,8 +644,8 @@ std::vector<const char*> VKDevice::LoadExtensions() {
    VkPhysicalDeviceFeatures2KHR features;
    features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
-    VkPhysicalDeviceProperties2KHR properties;
+    VkPhysicalDeviceProperties2KHR physical_properties;
-    properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
+    physical_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
    if (has_khr_shader_float16_int8) {
        VkPhysicalDeviceFloat16Int8FeaturesKHR float16_int8_features;
@@ -670,8 +670,8 @@ std::vector<const char*> VKDevice::LoadExtensions() {
        subgroup_properties.sType =
            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT;
        subgroup_properties.pNext = nullptr;
-        properties.pNext = &subgroup_properties;
+        physical_properties.pNext = &subgroup_properties;
-        physical.GetProperties2KHR(properties);
+        physical.GetProperties2KHR(physical_properties);
        is_warp_potentially_bigger = subgroup_properties.maxSubgroupSize > GuestWarpSize;
@@ -695,8 +695,8 @@ std::vector<const char*> VKDevice::LoadExtensions() {
        VkPhysicalDeviceTransformFeedbackPropertiesEXT tfb_properties;
        tfb_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
        tfb_properties.pNext = nullptr;
-        properties.pNext = &tfb_properties;
+        physical_properties.pNext = &tfb_properties;
-        physical.GetProperties2KHR(properties);
+        physical.GetProperties2KHR(physical_properties);
        if (tfb_features.transformFeedback && tfb_features.geometryStreams &&
            tfb_properties.maxTransformFeedbackStreams >= 4 &&
diff --git a/src/video_core/renderer_vulkan/vk_fence_manager.cpp b/src/video_core/renderer_vulkan/vk_fence_manager.cpp
index 5babbdd0b..0bcaee714 100644
--- a/src/video_core/renderer_vulkan/vk_fence_manager.cpp
+++ b/src/video_core/renderer_vulkan/vk_fence_manager.cpp
@@ -14,12 +14,13 @@
 namespace Vulkan {
-InnerFence::InnerFence(const VKDevice& device, VKScheduler& scheduler, u32 payload, bool is_stubbed)
+InnerFence::InnerFence(const VKDevice& device_, VKScheduler& scheduler_, u32 payload_,
-    : VideoCommon::FenceBase(payload, is_stubbed), device{device}, scheduler{scheduler} {}
+                       bool is_stubbed_)
+    : FenceBase{payload_, is_stubbed_}, device{device_}, scheduler{scheduler_} {}
-InnerFence::InnerFence(const VKDevice& device, VKScheduler& scheduler, GPUVAddr address,
+InnerFence::InnerFence(const VKDevice& device_, VKScheduler& scheduler_, GPUVAddr address_,
-                       u32 payload, bool is_stubbed)
+                       u32 payload_, bool is_stubbed_)
-    : VideoCommon::FenceBase(address, payload, is_stubbed), device{device}, scheduler{scheduler} {}
+    : FenceBase{address_, payload_, is_stubbed_}, device{device_}, scheduler{scheduler_} {}
 InnerFence::~InnerFence() = default;
@@ -71,11 +72,12 @@ bool InnerFence::IsEventSignalled() const {
    }
 }
-VKFenceManager::VKFenceManager(VideoCore::RasterizerInterface& rasterizer, Tegra::GPU& gpu,
+VKFenceManager::VKFenceManager(VideoCore::RasterizerInterface& rasterizer_, Tegra::GPU& gpu_,
-                               Tegra::MemoryManager& memory_manager, VKTextureCache& texture_cache,
+                               Tegra::MemoryManager& memory_manager_,
-                               VKBufferCache& buffer_cache, VKQueryCache& query_cache,
+                               VKTextureCache& texture_cache_, VKBufferCache& buffer_cache_,
-                               const VKDevice& device_, VKScheduler& scheduler_)
+                               VKQueryCache& query_cache_, const VKDevice& device_,
-    : GenericFenceManager(rasterizer, gpu, texture_cache, buffer_cache, query_cache),
+                               VKScheduler& scheduler_)
+    : GenericFenceManager{rasterizer_, gpu_, texture_cache_, buffer_cache_, query_cache_},
      device{device_}, scheduler{scheduler_} {}
 Fence VKFenceManager::CreateFence(u32 value, bool is_stubbed) {
diff --git a/src/video_core/renderer_vulkan/vk_fence_manager.h b/src/video_core/renderer_vulkan/vk_fence_manager.h
index 1547d6d30..c8547cc24 100644
--- a/src/video_core/renderer_vulkan/vk_fence_manager.h
+++ b/src/video_core/renderer_vulkan/vk_fence_manager.h
@@ -28,10 +28,10 @@ class VKTextureCache;
 class InnerFence : public VideoCommon::FenceBase {
 public:
-    explicit InnerFence(const VKDevice& device, VKScheduler& scheduler, u32 payload,
+    explicit InnerFence(const VKDevice& device_, VKScheduler& scheduler_, u32 payload_,
-                        bool is_stubbed);
+                        bool is_stubbed_);
-    explicit InnerFence(const VKDevice& device, VKScheduler& scheduler, GPUVAddr address,
+    explicit InnerFence(const VKDevice& device_, VKScheduler& scheduler_, GPUVAddr address_,
-                        u32 payload, bool is_stubbed);
+                        u32 payload_, bool is_stubbed_);
    ~InnerFence();
    void Queue();
@@ -55,10 +55,10 @@ using GenericFenceManager =
 class VKFenceManager final : public GenericFenceManager {
 public:
-    explicit VKFenceManager(VideoCore::RasterizerInterface& rasterizer, Tegra::GPU& gpu,
+    explicit VKFenceManager(VideoCore::RasterizerInterface& rasterizer_, Tegra::GPU& gpu_,
-                            Tegra::MemoryManager& memory_manager, VKTextureCache& texture_cache,
+                            Tegra::MemoryManager& memory_manager_, VKTextureCache& texture_cache_,
-                            VKBufferCache& buffer_cache, VKQueryCache& query_cache,
+                            VKBufferCache& buffer_cache_, VKQueryCache& query_cache_,
-                            const VKDevice& device, VKScheduler& scheduler);
+                            const VKDevice& device_, VKScheduler& scheduler_);
 protected:
    Fence CreateFence(u32 value, bool is_stubbed) override;
diff --git a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
index 0e8f9c352..970979fa1 100644
--- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
+++ b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
@@ -71,21 +71,21 @@ VkViewportSwizzleNV UnpackViewportSwizzle(u16 swizzle) {
 } // Anonymous namespace
-VKGraphicsPipeline::VKGraphicsPipeline(const VKDevice& device, VKScheduler& scheduler,
+VKGraphicsPipeline::VKGraphicsPipeline(const VKDevice& device_, VKScheduler& scheduler_,
-                                       VKDescriptorPool& descriptor_pool,
+                                       VKDescriptorPool& descriptor_pool_,
-                                       VKUpdateDescriptorQueue& update_descriptor_queue,
+                                       VKUpdateDescriptorQueue& update_descriptor_queue_,
-                                       VKRenderPassCache& renderpass_cache,
+                                       VKRenderPassCache& renderpass_cache_,
-                                       const GraphicsPipelineCacheKey& key,
+                                       const GraphicsPipelineCacheKey& key_,
-                                       vk::Span<VkDescriptorSetLayoutBinding> bindings,
+                                       vk::Span<VkDescriptorSetLayoutBinding> bindings_,
-                                       const SPIRVProgram& program)
+                                       const SPIRVProgram& program_)
-    : device{device}, scheduler{scheduler}, cache_key{key}, hash{cache_key.Hash()},
+    : device{device_}, scheduler{scheduler_}, cache_key{key_}, hash{cache_key.Hash()},
-      descriptor_set_layout{CreateDescriptorSetLayout(bindings)},
+      descriptor_set_layout{CreateDescriptorSetLayout(bindings_)},
-      descriptor_allocator{descriptor_pool, *descriptor_set_layout},
+      descriptor_allocator{descriptor_pool_, *descriptor_set_layout},
-      update_descriptor_queue{update_descriptor_queue}, layout{CreatePipelineLayout()},
+      update_descriptor_queue{update_descriptor_queue_}, layout{CreatePipelineLayout()},
-      descriptor_template{CreateDescriptorUpdateTemplate(program)}, modules{CreateShaderModules(
+      descriptor_template{CreateDescriptorUpdateTemplate(program_)}, modules{CreateShaderModules(
-                                                                        program)},
+                                                                         program_)},
-      renderpass{renderpass_cache.GetRenderPass(cache_key.renderpass_params)},
+      renderpass{renderpass_cache_.GetRenderPass(cache_key.renderpass_params)},
-      pipeline{CreatePipeline(cache_key.renderpass_params, program)} {}
+      pipeline{CreatePipeline(cache_key.renderpass_params, program_)} {}
 VKGraphicsPipeline::~VKGraphicsPipeline() = default;
@@ -162,8 +162,8 @@ std::vector<vk::ShaderModule> VKGraphicsPipeline::CreateShaderModules(
        .codeSize = 0,
    };
-    std::vector<vk::ShaderModule> modules;
+    std::vector<vk::ShaderModule> shader_modules;
-    modules.reserve(Maxwell::MaxShaderStage);
+    shader_modules.reserve(Maxwell::MaxShaderStage);
    for (std::size_t i = 0; i < Maxwell::MaxShaderStage; ++i) {
        const auto& stage = program[i];
        if (!stage) {
@@ -174,9 +174,9 @@ std::vector<vk::ShaderModule> VKGraphicsPipeline::CreateShaderModules(
        ci.codeSize = stage->code.size() * sizeof(u32);
        ci.pCode = stage->code.data();
-        modules.push_back(device.GetLogical().CreateShaderModule(ci));
+        shader_modules.push_back(device.GetLogical().CreateShaderModule(ci));
    }
-    return modules;
+    return shader_modules;
 }
 vk::Pipeline VKGraphicsPipeline::CreatePipeline(const RenderPassParams& renderpass_params,
@@ -230,7 +230,7 @@ vk::Pipeline VKGraphicsPipeline::CreatePipeline(const RenderPassParams& renderpa
        if (!attribute.enabled) {
            continue;
        }
-        if (input_attributes.find(static_cast<u32>(index)) == input_attributes.end()) {
+        if (!input_attributes.contains(static_cast<u32>(index))) {
            // Skip attributes not used by the vertex shaders.
            continue;
        }
diff --git a/src/video_core/renderer_vulkan/vk_graphics_pipeline.h b/src/video_core/renderer_vulkan/vk_graphics_pipeline.h
index 58aa35efd..3fb31d55a 100644
--- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.h
+++ b/src/video_core/renderer_vulkan/vk_graphics_pipeline.h
@@ -51,13 +51,13 @@ using SPIRVProgram = std::array<std::optional<SPIRVShader>, Maxwell::MaxShaderSt
 class VKGraphicsPipeline final {
 public:
-    explicit VKGraphicsPipeline(const VKDevice& device, VKScheduler& scheduler,
+    explicit VKGraphicsPipeline(const VKDevice& device_, VKScheduler& scheduler_,
-                                VKDescriptorPool& descriptor_pool,
+                                VKDescriptorPool& descriptor_pool_,
-                                VKUpdateDescriptorQueue& update_descriptor_queue,
+                                VKUpdateDescriptorQueue& update_descriptor_queue_,
-                                VKRenderPassCache& renderpass_cache,
+                                VKRenderPassCache& renderpass_cache_,
-                                const GraphicsPipelineCacheKey& key,
+                                const GraphicsPipelineCacheKey& key_,
-                                vk::Span<VkDescriptorSetLayoutBinding> bindings,
+                                vk::Span<VkDescriptorSetLayoutBinding> bindings_,
-                                const SPIRVProgram& program);
+                                const SPIRVProgram& program_);
    ~VKGraphicsPipeline();
    VkDescriptorSet CommitDescriptorSet();
diff --git a/src/video_core/renderer_vulkan/vk_image.cpp b/src/video_core/renderer_vulkan/vk_image.cpp
index 1c418ea17..072d14e3b 100644
--- a/src/video_core/renderer_vulkan/vk_image.cpp
+++ b/src/video_core/renderer_vulkan/vk_image.cpp
@@ -13,18 +13,18 @@
 namespace Vulkan {
-VKImage::VKImage(const VKDevice& device, VKScheduler& scheduler, const VkImageCreateInfo& image_ci,
+VKImage::VKImage(const VKDevice& device_, VKScheduler& scheduler_,
-                 VkImageAspectFlags aspect_mask)
+                 const VkImageCreateInfo& image_ci_, VkImageAspectFlags aspect_mask_)
-    : device{device}, scheduler{scheduler}, format{image_ci.format}, aspect_mask{aspect_mask},
+    : device{device_}, scheduler{scheduler_}, format{image_ci_.format}, aspect_mask{aspect_mask_},
-      image_num_layers{image_ci.arrayLayers}, image_num_levels{image_ci.mipLevels} {
+      image_num_layers{image_ci_.arrayLayers}, image_num_levels{image_ci_.mipLevels} {
-    UNIMPLEMENTED_IF_MSG(image_ci.queueFamilyIndexCount != 0,
+    UNIMPLEMENTED_IF_MSG(image_ci_.queueFamilyIndexCount != 0,
                         "Queue family tracking is not implemented");
-    image = device.GetLogical().CreateImage(image_ci);
+    image = device_.GetLogical().CreateImage(image_ci_);
    const u32 num_ranges = image_num_layers * image_num_levels;
    barriers.resize(num_ranges);
-    subrange_states.resize(num_ranges, {{}, image_ci.initialLayout});
+    subrange_states.resize(num_ranges, {{}, image_ci_.initialLayout});
 }
 VKImage::~VKImage() = default;
diff --git a/src/video_core/renderer_vulkan/vk_image.h b/src/video_core/renderer_vulkan/vk_image.h
index b4d7229e5..287ab90ca 100644
--- a/src/video_core/renderer_vulkan/vk_image.h
+++ b/src/video_core/renderer_vulkan/vk_image.h
@@ -17,8 +17,8 @@ class VKScheduler;
 class VKImage {
 public:
-    explicit VKImage(const VKDevice& device, VKScheduler& scheduler,
+    explicit VKImage(const VKDevice& device_, VKScheduler& scheduler_,
-                     const VkImageCreateInfo& image_ci, VkImageAspectFlags aspect_mask);
+                     const VkImageCreateInfo& image_ci_, VkImageAspectFlags aspect_mask_);
    ~VKImage();
    /// Records in the passed command buffer an image transition and updates the state of the image.
diff --git a/src/video_core/renderer_vulkan/vk_memory_manager.cpp b/src/video_core/renderer_vulkan/vk_memory_manager.cpp
index 24c8960ac..be53d450f 100644
--- a/src/video_core/renderer_vulkan/vk_memory_manager.cpp
+++ b/src/video_core/renderer_vulkan/vk_memory_manager.cpp
@@ -29,10 +29,10 @@ u64 GetAllocationChunkSize(u64 required_size) {
 class VKMemoryAllocation final {
 public:
-    explicit VKMemoryAllocation(const VKDevice& device, vk::DeviceMemory memory,
+    explicit VKMemoryAllocation(const VKDevice& device_, vk::DeviceMemory memory_,
-                                VkMemoryPropertyFlags properties, u64 allocation_size, u32 type)
+                                VkMemoryPropertyFlags properties_, u64 allocation_size_, u32 type_)
-        : device{device}, memory{std::move(memory)}, properties{properties},
+        : device{device_}, memory{std::move(memory_)}, properties{properties_},
-          allocation_size{allocation_size}, shifted_type{ShiftType(type)} {}
+          allocation_size{allocation_size_}, shifted_type{ShiftType(type_)} {}
    VKMemoryCommit Commit(VkDeviceSize commit_size, VkDeviceSize alignment) {
        auto found = TryFindFreeSection(free_iterator, allocation_size,
@@ -117,8 +117,8 @@ private:
    std::vector<const VKMemoryCommitImpl*> commits;
 };
-VKMemoryManager::VKMemoryManager(const VKDevice& device)
+VKMemoryManager::VKMemoryManager(const VKDevice& device_)
-    : device{device}, properties{device.GetPhysical().GetMemoryProperties()} {}
+    : device{device_}, properties{device_.GetPhysical().GetMemoryProperties()} {}
 VKMemoryManager::~VKMemoryManager() = default;
@@ -207,9 +207,9 @@ VKMemoryCommit VKMemoryManager::TryAllocCommit(const VkMemoryRequirements& requi
    return {};
 }
-VKMemoryCommitImpl::VKMemoryCommitImpl(const VKDevice& device, VKMemoryAllocation* allocation,
+VKMemoryCommitImpl::VKMemoryCommitImpl(const VKDevice& device_, VKMemoryAllocation* allocation_,
-                                       const vk::DeviceMemory& memory, u64 begin, u64 end)
+                                       const vk::DeviceMemory& memory_, u64 begin_, u64 end_)
-    : device{device}, memory{memory}, interval{begin, end}, allocation{allocation} {}
+    : device{device_}, memory{memory_}, interval{begin_, end_}, allocation{allocation_} {}
 VKMemoryCommitImpl::~VKMemoryCommitImpl() {
    allocation->Free(this);
diff --git a/src/video_core/renderer_vulkan/vk_memory_manager.h b/src/video_core/renderer_vulkan/vk_memory_manager.h
index 1af88e3d4..39f903ec8 100644
--- a/src/video_core/renderer_vulkan/vk_memory_manager.h
+++ b/src/video_core/renderer_vulkan/vk_memory_manager.h
@@ -21,7 +21,7 @@ using VKMemoryCommit = std::unique_ptr<VKMemoryCommitImpl>;
 class VKMemoryManager final {
 public:
-    explicit VKMemoryManager(const VKDevice& device);
+    explicit VKMemoryManager(const VKDevice& device_);
    VKMemoryManager(const VKMemoryManager&) = delete;
    ~VKMemoryManager();
@@ -58,8 +58,8 @@ class VKMemoryCommitImpl final {
    friend MemoryMap;
 public:
-    explicit VKMemoryCommitImpl(const VKDevice& device, VKMemoryAllocation* allocation,
+    explicit VKMemoryCommitImpl(const VKDevice& device_, VKMemoryAllocation* allocation_,
-                                const vk::DeviceMemory& memory, u64 begin, u64 end);
+                                const vk::DeviceMemory& memory_, u64 begin_, u64 end_);
    ~VKMemoryCommitImpl();
    /// Maps a memory region and returns a pointer to it.
@@ -93,8 +93,8 @@ private:
 /// Holds ownership of a memory map.
 class MemoryMap final {
 public:
-    explicit MemoryMap(const VKMemoryCommitImpl* commit, u8* address)
+    explicit MemoryMap(const VKMemoryCommitImpl* commit_, u8* address_)
-        : commit{commit}, address{address} {}
+        : commit{commit_}, address{address_} {}
    ~MemoryMap() {
        if (commit) {
diff --git a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
index df7e8c864..3fb264d03 100644
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
@@ -75,7 +75,7 @@ ShaderType GetShaderType(Maxwell::ShaderProgram program) {
    case Maxwell::ShaderProgram::Fragment:
        return ShaderType::Fragment;
    default:
-        UNIMPLEMENTED_MSG("program={}", static_cast<u32>(program));
+        UNIMPLEMENTED_MSG("program={}", program);
        return ShaderType::Vertex;
    }
 }
@@ -136,26 +136,25 @@ bool ComputePipelineCacheKey::operator==(const ComputePipelineCacheKey& rhs) con
    return std::memcmp(&rhs, this, sizeof *this) == 0;
 }
-Shader::Shader(Tegra::Engines::ConstBufferEngineInterface& engine, Tegra::Engines::ShaderType stage,
+Shader::Shader(Tegra::Engines::ConstBufferEngineInterface& engine_, ShaderType stage_,
-               GPUVAddr gpu_addr_, VAddr cpu_addr, VideoCommon::Shader::ProgramCode program_code_,
+               GPUVAddr gpu_addr_, VAddr cpu_addr_, ProgramCode program_code_, u32 main_offset_)
-               u32 main_offset)
+    : gpu_addr(gpu_addr_), program_code(std::move(program_code_)), registry(stage_, engine_),
-    : gpu_addr(gpu_addr_), program_code(std::move(program_code_)), registry(stage, engine),
+      shader_ir(program_code, main_offset_, compiler_settings, registry),
-      shader_ir(program_code, main_offset, compiler_settings, registry),
      entries(GenerateShaderEntries(shader_ir)) {}
 Shader::~Shader() = default;
-VKPipelineCache::VKPipelineCache(RasterizerVulkan& rasterizer, Tegra::GPU& gpu_,
+VKPipelineCache::VKPipelineCache(RasterizerVulkan& rasterizer_, Tegra::GPU& gpu_,
                                 Tegra::Engines::Maxwell3D& maxwell3d_,
                                 Tegra::Engines::KeplerCompute& kepler_compute_,
                                 Tegra::MemoryManager& gpu_memory_, const VKDevice& device_,
                                 VKScheduler& scheduler_, VKDescriptorPool& descriptor_pool_,
                                 VKUpdateDescriptorQueue& update_descriptor_queue_,
                                 VKRenderPassCache& renderpass_cache_)
-    : VideoCommon::ShaderCache<Shader>{rasterizer}, gpu{gpu_}, maxwell3d{maxwell3d_},
+    : ShaderCache{rasterizer_}, gpu{gpu_}, maxwell3d{maxwell3d_}, kepler_compute{kepler_compute_},
-      kepler_compute{kepler_compute_}, gpu_memory{gpu_memory_}, device{device_},
+      gpu_memory{gpu_memory_}, device{device_}, scheduler{scheduler_},
-      scheduler{scheduler_}, descriptor_pool{descriptor_pool_},
+      descriptor_pool{descriptor_pool_}, update_descriptor_queue{update_descriptor_queue_},
-      update_descriptor_queue{update_descriptor_queue_}, renderpass_cache{renderpass_cache_} {}
+      renderpass_cache{renderpass_cache_} {}
 VKPipelineCache::~VKPipelineCache() = default;
diff --git a/src/video_core/renderer_vulkan/vk_pipeline_cache.h b/src/video_core/renderer_vulkan/vk_pipeline_cache.h
index e558e6658..9e1f8fcbb 100644
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.h
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.h
@@ -84,9 +84,9 @@ namespace Vulkan {
 class Shader {
 public:
-    explicit Shader(Tegra::Engines::ConstBufferEngineInterface& engine,
+    explicit Shader(Tegra::Engines::ConstBufferEngineInterface& engine_,
-                    Tegra::Engines::ShaderType stage, GPUVAddr gpu_addr, VAddr cpu_addr,
+                    Tegra::Engines::ShaderType stage_, GPUVAddr gpu_addr, VAddr cpu_addr_,
-                    VideoCommon::Shader::ProgramCode program_code, u32 main_offset);
+                    VideoCommon::Shader::ProgramCode program_code, u32 main_offset_);
    ~Shader();
    GPUVAddr GetGpuAddr() const {
@@ -119,13 +119,13 @@ private:
 class VKPipelineCache final : public VideoCommon::ShaderCache<Shader> {
 public:
-    explicit VKPipelineCache(RasterizerVulkan& rasterizer, Tegra::GPU& gpu,
+    explicit VKPipelineCache(RasterizerVulkan& rasterizer_, Tegra::GPU& gpu_,
-                             Tegra::Engines::Maxwell3D& maxwell3d,
+                             Tegra::Engines::Maxwell3D& maxwell3d_,
-                             Tegra::Engines::KeplerCompute& kepler_compute,
+                             Tegra::Engines::KeplerCompute& kepler_compute_,
-                             Tegra::MemoryManager& gpu_memory, const VKDevice& device,
+                             Tegra::MemoryManager& gpu_memory_, const VKDevice& device_,
-                             VKScheduler& scheduler, VKDescriptorPool& descriptor_pool,
+                             VKScheduler& scheduler_, VKDescriptorPool& descriptor_pool_,
-                             VKUpdateDescriptorQueue& update_descriptor_queue,
+                             VKUpdateDescriptorQueue& update_descriptor_queue_,
-                             VKRenderPassCache& renderpass_cache);
+                             VKRenderPassCache& renderpass_cache_);
    ~VKPipelineCache() override;
    std::array<Shader*, Maxwell::MaxShaderProgram> GetShaders();
diff --git a/src/video_core/renderer_vulkan/vk_query_cache.cpp b/src/video_core/renderer_vulkan/vk_query_cache.cpp
index ee2d871e3..038760de3 100644
--- a/src/video_core/renderer_vulkan/vk_query_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_query_cache.cpp
@@ -66,15 +66,13 @@ void QueryPool::Reserve(std::pair<VkQueryPool, u32> query) {
    usage[pool_index * GROW_STEP + static_cast<std::ptrdiff_t>(query.second)] = false;
 }
-VKQueryCache::VKQueryCache(VideoCore::RasterizerInterface& rasterizer,
+VKQueryCache::VKQueryCache(VideoCore::RasterizerInterface& rasterizer_,
-                           Tegra::Engines::Maxwell3D& maxwell3d, Tegra::MemoryManager& gpu_memory,
+                           Tegra::Engines::Maxwell3D& maxwell3d_, Tegra::MemoryManager& gpu_memory_,
-                           const VKDevice& device, VKScheduler& scheduler)
+                           const VKDevice& device_, VKScheduler& scheduler_)
-    : VideoCommon::QueryCacheBase<VKQueryCache, CachedQuery, CounterStream,
+    : QueryCacheBase{rasterizer_, maxwell3d_, gpu_memory_}, device{device_}, scheduler{scheduler_},
-                                  HostCounter>{rasterizer, maxwell3d, gpu_memory},
+      query_pools{
-      device{device}, scheduler{scheduler}, query_pools{
+          QueryPool{device_, scheduler_, QueryType::SamplesPassed},
-                                                QueryPool{device, scheduler,
+      } {}
-                                                          QueryType::SamplesPassed},
-                                            } {}
 VKQueryCache::~VKQueryCache() {
    // TODO(Rodrigo): This is a hack to destroy all HostCounter instances before the base class
@@ -95,12 +93,12 @@ void VKQueryCache::Reserve(QueryType type, std::pair<VkQueryPool, u32> query) {
    query_pools[static_cast<std::size_t>(type)].Reserve(query);
 }
-HostCounter::HostCounter(VKQueryCache& cache, std::shared_ptr<HostCounter> dependency,
+HostCounter::HostCounter(VKQueryCache& cache_, std::shared_ptr<HostCounter> dependency_,
-                         QueryType type)
+                         QueryType type_)
-    : VideoCommon::HostCounterBase<VKQueryCache, HostCounter>{std::move(dependency)}, cache{cache},
+    : HostCounterBase{std::move(dependency_)}, cache{cache_}, type{type_},
-      type{type}, query{cache.AllocateQuery(type)}, tick{cache.Scheduler().CurrentTick()} {
+      query{cache_.AllocateQuery(type_)}, tick{cache_.Scheduler().CurrentTick()} {
-    const vk::Device* logical = &cache.Device().GetLogical();
+    const vk::Device* logical = &cache_.Device().GetLogical();
-    cache.Scheduler().Record([logical, query = query](vk::CommandBuffer cmdbuf) {
+    cache_.Scheduler().Record([logical, query = query](vk::CommandBuffer cmdbuf) {
        logical->ResetQueryPoolEXT(query.first, query.second, 1);
        cmdbuf.BeginQuery(query.first, query.second, VK_QUERY_CONTROL_PRECISE_BIT);
    });
@@ -119,18 +117,20 @@ u64 HostCounter::BlockingQuery() const {
    if (tick >= cache.Scheduler().CurrentTick()) {
        cache.Scheduler().Flush();
    }
    u64 data;
-    const VkResult result = cache.Device().GetLogical().GetQueryResults(
+    const VkResult query_result = cache.Device().GetLogical().GetQueryResults(
        query.first, query.second, 1, sizeof(data), &data, sizeof(data),
        VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
-    switch (result) {
+    switch (query_result) {
    case VK_SUCCESS:
        return data;
    case VK_ERROR_DEVICE_LOST:
        cache.Device().ReportLoss();
        [[fallthrough]];
    default:
-        throw vk::Exception(result);
+        throw vk::Exception(query_result);
    }
 }
diff --git a/src/video_core/renderer_vulkan/vk_query_cache.h b/src/video_core/renderer_vulkan/vk_query_cache.h
index 2e57fb75d..837fe9ebf 100644
--- a/src/video_core/renderer_vulkan/vk_query_cache.h
+++ b/src/video_core/renderer_vulkan/vk_query_cache.h
@@ -53,9 +53,9 @@ private:
 class VKQueryCache final
    : public VideoCommon::QueryCacheBase<VKQueryCache, CachedQuery, CounterStream, HostCounter> {
 public:
-    explicit VKQueryCache(VideoCore::RasterizerInterface& rasterizer,
+    explicit VKQueryCache(VideoCore::RasterizerInterface& rasterizer_,
-                          Tegra::Engines::Maxwell3D& maxwell3d, Tegra::MemoryManager& gpu_memory,
+                          Tegra::Engines::Maxwell3D& maxwell3d_, Tegra::MemoryManager& gpu_memory_,
-                          const VKDevice& device, VKScheduler& scheduler);
+                          const VKDevice& device_, VKScheduler& scheduler_);
    ~VKQueryCache();
    std::pair<VkQueryPool, u32> AllocateQuery(VideoCore::QueryType type);
@@ -78,8 +78,8 @@ private:
 class HostCounter final : public VideoCommon::HostCounterBase<VKQueryCache, HostCounter> {
 public:
-    explicit HostCounter(VKQueryCache& cache, std::shared_ptr<HostCounter> dependency,
+    explicit HostCounter(VKQueryCache& cache_, std::shared_ptr<HostCounter> dependency_,
-                         VideoCore::QueryType type);
+                         VideoCore::QueryType type_);
    ~HostCounter();
    void EndQuery();
@@ -95,8 +95,8 @@ private:
 class CachedQuery : public VideoCommon::CachedQueryBase<HostCounter> {
 public:
-    explicit CachedQuery(VKQueryCache&, VideoCore::QueryType, VAddr cpu_addr, u8* host_ptr)
+    explicit CachedQuery(VKQueryCache&, VideoCore::QueryType, VAddr cpu_addr_, u8* host_ptr_)
-        : VideoCommon::CachedQueryBase<HostCounter>{cpu_addr, host_ptr} {}
+        : CachedQueryBase{cpu_addr_, host_ptr_} {}
 };
 } // namespace Vulkan
diff --git a/src/video_core/renderer_vulkan/vk_rasterizer.cpp b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
index e0fb8693f..f93986aab 100644
--- a/src/video_core/renderer_vulkan/vk_rasterizer.cpp
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
@@ -128,12 +128,12 @@ Tegra::Texture::FullTextureInfo GetTextureInfo(const Engine& engine, const Entry
            const u32 offset_2 = entry.secondary_offset;
            const u32 handle_1 = engine.AccessConstBuffer32(stage_type, buffer_1, offset_1);
            const u32 handle_2 = engine.AccessConstBuffer32(stage_type, buffer_2, offset_2);
-            return engine.GetTextureInfo(handle_1 | handle_2);
+            return engine.GetTextureInfo(Tegra::Texture::TextureHandle{handle_1 | handle_2});
        }
    }
    if (entry.is_bindless) {
        const auto tex_handle = engine.AccessConstBuffer32(stage_type, entry.buffer, entry.offset);
-        return engine.GetTextureInfo(tex_handle);
+        return engine.GetTextureInfo(Tegra::Texture::TextureHandle{tex_handle});
    }
    const auto& gpu_profile = engine.AccessGuestDriverProfile();
    const u32 entry_offset = static_cast<u32>(index * gpu_profile.GetTextureHandlerSize());
@@ -380,12 +380,12 @@ void RasterizerVulkan::DrawParameters::Draw(vk::CommandBuffer cmdbuf) const {
    }
 }
-RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window, Tegra::GPU& gpu_,
+RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,
                                   Tegra::MemoryManager& gpu_memory_,
-                                   Core::Memory::Memory& cpu_memory, VKScreenInfo& screen_info_,
+                                   Core::Memory::Memory& cpu_memory_, VKScreenInfo& screen_info_,
                                   const VKDevice& device_, VKMemoryManager& memory_manager_,
                                   StateTracker& state_tracker_, VKScheduler& scheduler_)
-    : RasterizerAccelerated(cpu_memory), gpu(gpu_), gpu_memory(gpu_memory_),
+    : RasterizerAccelerated(cpu_memory_), gpu(gpu_), gpu_memory(gpu_memory_),
      maxwell3d(gpu.Maxwell3D()), kepler_compute(gpu.KeplerCompute()), screen_info(screen_info_),
      device(device_), memory_manager(memory_manager_), state_tracker(state_tracker_),
      scheduler(scheduler_), staging_pool(device, memory_manager, scheduler),
@@ -397,11 +397,11 @@ RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window, Tegra:
      texture_cache(*this, maxwell3d, gpu_memory, device, memory_manager, scheduler, staging_pool),
      pipeline_cache(*this, gpu, maxwell3d, kepler_compute, gpu_memory, device, scheduler,
                     descriptor_pool, update_descriptor_queue, renderpass_cache),
-      buffer_cache(*this, gpu_memory, cpu_memory, device, memory_manager, scheduler, staging_pool),
+      buffer_cache(*this, gpu_memory, cpu_memory_, device, memory_manager, scheduler, staging_pool),
      sampler_cache(device), query_cache(*this, maxwell3d, gpu_memory, device, scheduler),
      fence_manager(*this, gpu, gpu_memory, texture_cache, buffer_cache, query_cache, device,
                    scheduler),
-      wfi_event(device.GetLogical().CreateEvent()), async_shaders(emu_window) {
+      wfi_event(device.GetLogical().CreateEvent()), async_shaders(emu_window_) {
    scheduler.SetQueryCache(query_cache);
    if (device.UseAsynchronousShaders()) {
        async_shaders.AllocateWorkers();
@@ -904,15 +904,14 @@ void RasterizerVulkan::SetupShaderDescriptors(
    texture_cache.GuardSamplers(false);
 }
-void RasterizerVulkan::SetupImageTransitions(
+void RasterizerVulkan::SetupImageTransitions(Texceptions texceptions, const ColorAttachments& color,
-    Texceptions texceptions, const std::array<View, Maxwell::NumRenderTargets>& color_attachments,
+                                             const ZetaAttachment& zeta) {
-    const View& zeta_attachment) {
    TransitionImages(sampled_views, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_ACCESS_SHADER_READ_BIT);
    TransitionImages(image_views, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
                     VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT);
-    for (std::size_t rt = 0; rt < std::size(color_attachments); ++rt) {
+    for (std::size_t rt = 0; rt < color.size(); ++rt) {
-        const auto color_attachment = color_attachments[rt];
+        const auto color_attachment = color[rt];
        if (color_attachment == nullptr) {
            continue;
        }
@@ -923,13 +922,13 @@ void RasterizerVulkan::SetupImageTransitions(
                                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
    }
-    if (zeta_attachment != nullptr) {
+    if (zeta != nullptr) {
        const auto image_layout = texceptions[ZETA_TEXCEPTION_INDEX]
                                      ? VK_IMAGE_LAYOUT_GENERAL
                                      : VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
-        zeta_attachment->Transition(image_layout, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+        zeta->Transition(image_layout, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
-                                    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
+                         VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
-                                        VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
+                             VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
    }
 }
diff --git a/src/video_core/renderer_vulkan/vk_rasterizer.h b/src/video_core/renderer_vulkan/vk_rasterizer.h
index 237e51fa4..30ec58eb4 100644
--- a/src/video_core/renderer_vulkan/vk_rasterizer.h
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.h
@@ -105,11 +105,11 @@ struct ImageView {
 class RasterizerVulkan final : public VideoCore::RasterizerAccelerated {
 public:
-    explicit RasterizerVulkan(Core::Frontend::EmuWindow& emu_window, Tegra::GPU& gpu,
+    explicit RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,
-                              Tegra::MemoryManager& gpu_memory, Core::Memory::Memory& cpu_memory,
+                              Tegra::MemoryManager& gpu_memory_, Core::Memory::Memory& cpu_memory_,
-                              VKScreenInfo& screen_info, const VKDevice& device,
+                              VKScreenInfo& screen_info_, const VKDevice& device_,
-                              VKMemoryManager& memory_manager, StateTracker& state_tracker,
+                              VKMemoryManager& memory_manager_, StateTracker& state_tracker_,
-                              VKScheduler& scheduler);
+                              VKScheduler& scheduler_);
    ~RasterizerVulkan() override;
    void Draw(bool is_indexed, bool is_instanced) override;
@@ -160,6 +160,9 @@ private:
        bool is_indexed = 0;
    };
+    using ColorAttachments = std::array<View, Maxwell::NumRenderTargets>;
+    using ZetaAttachment = View;
    using Texceptions = std::bitset<Maxwell::NumRenderTargets + 1>;
    static constexpr std::size_t ZETA_TEXCEPTION_INDEX = 8;
@@ -181,9 +184,8 @@ private:
    /// Setup descriptors in the graphics pipeline.
    void SetupShaderDescriptors(const std::array<Shader*, Maxwell::MaxShaderProgram>& shaders);
-    void SetupImageTransitions(Texceptions texceptions,
+    void SetupImageTransitions(Texceptions texceptions, const ColorAttachments& color,
-                               const std::array<View, Maxwell::NumRenderTargets>& color_attachments,
+                               const ZetaAttachment& zeta);
-                               const View& zeta_attachment);
    void UpdateDynamicStates();
@@ -308,8 +310,8 @@ private:
    vk::Event wfi_event;
    VideoCommon::Shader::AsyncShaders async_shaders;
-    std::array<View, Maxwell::NumRenderTargets> color_attachments;
+    ColorAttachments color_attachments;
-    View zeta_attachment;
+    ZetaAttachment zeta_attachment;
    std::vector<ImageView> sampled_views;
    std::vector<ImageView> image_views;
diff --git a/src/video_core/renderer_vulkan/vk_renderpass_cache.cpp b/src/video_core/renderer_vulkan/vk_renderpass_cache.cpp
index 80284cf92..e812c7dd6 100644
--- a/src/video_core/renderer_vulkan/vk_renderpass_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_renderpass_cache.cpp
@@ -24,7 +24,7 @@ bool RenderPassParams::operator==(const RenderPassParams& rhs) const noexcept {
    return std::memcmp(&rhs, this, sizeof *this) == 0;
 }
-VKRenderPassCache::VKRenderPassCache(const VKDevice& device) : device{device} {}
+VKRenderPassCache::VKRenderPassCache(const VKDevice& device_) : device{device_} {}
 VKRenderPassCache::~VKRenderPassCache() = default;
diff --git a/src/video_core/renderer_vulkan/vk_renderpass_cache.h b/src/video_core/renderer_vulkan/vk_renderpass_cache.h
index 8b0fec720..652ecef7b 100644
--- a/src/video_core/renderer_vulkan/vk_renderpass_cache.h
+++ b/src/video_core/renderer_vulkan/vk_renderpass_cache.h
@@ -55,7 +55,7 @@ namespace Vulkan {
 class VKRenderPassCache final {
 public:
-    explicit VKRenderPassCache(const VKDevice& device);
+    explicit VKRenderPassCache(const VKDevice& device_);
    ~VKRenderPassCache();
    VkRenderPass GetRenderPass(const RenderPassParams& params);
diff --git a/src/video_core/renderer_vulkan/vk_sampler_cache.cpp b/src/video_core/renderer_vulkan/vk_sampler_cache.cpp
index b068888f9..b859691fa 100644
--- a/src/video_core/renderer_vulkan/vk_sampler_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_sampler_cache.cpp
@@ -36,7 +36,7 @@ VkBorderColor ConvertBorderColor(std::array<float, 4> color) {
 } // Anonymous namespace
-VKSamplerCache::VKSamplerCache(const VKDevice& device) : device{device} {}
+VKSamplerCache::VKSamplerCache(const VKDevice& device_) : device{device_} {}
 VKSamplerCache::~VKSamplerCache() = default;
diff --git a/src/video_core/renderer_vulkan/vk_sampler_cache.h b/src/video_core/renderer_vulkan/vk_sampler_cache.h
index a33d1c0ee..3f22c4610 100644
--- a/src/video_core/renderer_vulkan/vk_sampler_cache.h
+++ b/src/video_core/renderer_vulkan/vk_sampler_cache.h
@@ -14,7 +14,7 @@ class VKDevice;
 class VKSamplerCache final : public VideoCommon::SamplerCache<VkSampler, vk::Sampler> {
 public:
-    explicit VKSamplerCache(const VKDevice& device);
+    explicit VKSamplerCache(const VKDevice& device_);
    ~VKSamplerCache();
 protected:
diff --git a/src/video_core/renderer_vulkan/vk_scheduler.h b/src/video_core/renderer_vulkan/vk_scheduler.h
index 7be8a19f0..6d3a5da0b 100644
--- a/src/video_core/renderer_vulkan/vk_scheduler.h
+++ b/src/video_core/renderer_vulkan/vk_scheduler.h
@@ -104,7 +104,7 @@ private:
    template <typename T>
    class TypedCommand final : public Command {
    public:
-        explicit TypedCommand(T&& command) : command{std::move(command)} {}
+        explicit TypedCommand(T&& command_) : command{std::move(command_)} {}
        ~TypedCommand() override = default;
        TypedCommand(TypedCommand&&) = delete;
diff --git a/src/video_core/renderer_vulkan/vk_shader_decompiler.cpp b/src/video_core/renderer_vulkan/vk_shader_decompiler.cpp
index fed9ebecd..ca12b3793 100644
--- a/src/video_core/renderer_vulkan/vk_shader_decompiler.cpp
+++ b/src/video_core/renderer_vulkan/vk_shader_decompiler.cpp
@@ -55,8 +55,8 @@ enum class Type { Void, Bool, Bool2, Float, Int, Uint, HalfFloat };
 class Expression final {
 public:
-    Expression(Id id, Type type) : id{id}, type{type} {
+    Expression(Id id_, Type type_) : id{id_}, type{type_} {
-        ASSERT(type != Type::Void);
+        ASSERT(type_ != Type::Void);
    }
    Expression() : type{Type::Void} {}
@@ -114,7 +114,7 @@ spv::Dim GetSamplerDim(const Sampler& sampler) {
    case Tegra::Shader::TextureType::TextureCube:
        return spv::Dim::Cube;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented sampler type={}", static_cast<int>(sampler.type));
+        UNIMPLEMENTED_MSG("Unimplemented sampler type={}", sampler.type);
        return spv::Dim::Dim2D;
    }
 }
@@ -134,7 +134,7 @@ std::pair<spv::Dim, bool> GetImageDim(const Image& image) {
    case Tegra::Shader::ImageType::Texture3D:
        return {spv::Dim::Dim3D, false};
    default:
-        UNIMPLEMENTED_MSG("Unimplemented image type={}", static_cast<int>(image.type));
+        UNIMPLEMENTED_MSG("Unimplemented image type={}", image.type);
        return {spv::Dim::Dim2D, false};
    }
 }
@@ -281,12 +281,12 @@ u32 ShaderVersion(const VKDevice& device) {
 class SPIRVDecompiler final : public Sirit::Module {
 public:
-    explicit SPIRVDecompiler(const VKDevice& device, const ShaderIR& ir, ShaderType stage,
+    explicit SPIRVDecompiler(const VKDevice& device_, const ShaderIR& ir_, ShaderType stage_,
-                             const Registry& registry, const Specialization& specialization)
+                             const Registry& registry_, const Specialization& specialization_)
-        : Module(ShaderVersion(device)), device{device}, ir{ir}, stage{stage},
+        : Module(ShaderVersion(device_)), device{device_}, ir{ir_}, stage{stage_},
-          header{ir.GetHeader()}, registry{registry}, specialization{specialization} {
+          header{ir_.GetHeader()}, registry{registry_}, specialization{specialization_} {
-        if (stage != ShaderType::Compute) {
+        if (stage_ != ShaderType::Compute) {
-            transform_feedback = BuildTransformFeedback(registry.GetGraphicsInfo());
+            transform_feedback = BuildTransformFeedback(registry_.GetGraphicsInfo());
        }
        AddCapability(spv::Capability::Shader);
@@ -330,7 +330,7 @@ public:
        if (device.IsFloat16Supported()) {
            AddCapability(spv::Capability::Float16);
        }
-        t_scalar_half = Name(TypeFloat(device.IsFloat16Supported() ? 16 : 32), "scalar_half");
+        t_scalar_half = Name(TypeFloat(device_.IsFloat16Supported() ? 16 : 32), "scalar_half");
        t_half = Name(TypeVector(t_scalar_half, 2), "half");
        const Id main = Decompile();
@@ -1088,9 +1088,9 @@ private:
            indices.point_size = AddBuiltIn(t_float, spv::BuiltIn::PointSize, "point_size");
        }
-        const auto& output_attributes = ir.GetOutputAttributes();
+        const auto& ir_output_attributes = ir.GetOutputAttributes();
-        const bool declare_clip_distances =
+        const bool declare_clip_distances = std::any_of(
-            std::any_of(output_attributes.begin(), output_attributes.end(), [](const auto& index) {
+            ir_output_attributes.begin(), ir_output_attributes.end(), [](const auto& index) {
                return index == Attribute::Index::ClipDistances0123 ||
                       index == Attribute::Index::ClipDistances4567;
            });
@@ -1254,7 +1254,7 @@ private:
                const Id pointer = ArrayPass(type_descriptor.scalar, attribute_id, elements);
                return {OpLoad(GetTypeDefinition(type), pointer), type};
            }
-            UNIMPLEMENTED_MSG("Unhandled input attribute: {}", static_cast<u32>(attribute));
+            UNIMPLEMENTED_MSG("Unhandled input attribute: {}", attribute);
            return {v_float_zero, Type::Float};
        }
@@ -1890,7 +1890,7 @@ private:
            case Tegra::Shader::TextureType::Texture3D:
                return 3;
            default:
-                UNREACHABLE_MSG("Invalid texture type={}", static_cast<int>(type));
+                UNREACHABLE_MSG("Invalid texture type={}", type);
                return 2;
            }
        }();
@@ -2125,8 +2125,7 @@ private:
            OpStore(z_pointer, depth);
        }
        if (stage == ShaderType::Fragment) {
-            const auto SafeGetRegister = [&](u32 reg) {
+            const auto SafeGetRegister = [this](u32 reg) {
-                // TODO(Rodrigo): Replace with contains once C++20 releases
                if (const auto it = registers.find(reg); it != registers.end()) {
                    return OpLoad(t_float, it->second);
                }
@@ -2891,7 +2890,7 @@ private:
 class ExprDecompiler {
 public:
-    explicit ExprDecompiler(SPIRVDecompiler& decomp) : decomp{decomp} {}
+    explicit ExprDecompiler(SPIRVDecompiler& decomp_) : decomp{decomp_} {}
    Id operator()(const ExprAnd& expr) {
        const Id type_def = decomp.GetTypeDefinition(Type::Bool);
@@ -2947,7 +2946,7 @@ private:
 class ASTDecompiler {
 public:
-    explicit ASTDecompiler(SPIRVDecompiler& decomp) : decomp{decomp} {}
+    explicit ASTDecompiler(SPIRVDecompiler& decomp_) : decomp{decomp_} {}
    void operator()(const ASTProgram& ast) {
        ASTNode current = ast.nodes.GetFirst();
diff --git a/src/video_core/renderer_vulkan/vk_shader_decompiler.h b/src/video_core/renderer_vulkan/vk_shader_decompiler.h
index 110848922..df1812514 100644
--- a/src/video_core/renderer_vulkan/vk_shader_decompiler.h
+++ b/src/video_core/renderer_vulkan/vk_shader_decompiler.h
@@ -30,8 +30,8 @@ constexpr u32 DESCRIPTOR_SET = 0;
 class ConstBufferEntry : public VideoCommon::Shader::ConstBuffer {
 public:
-    explicit constexpr ConstBufferEntry(const VideoCommon::Shader::ConstBuffer& entry, u32 index)
+    explicit constexpr ConstBufferEntry(const ConstBuffer& entry_, u32 index_)
-        : VideoCommon::Shader::ConstBuffer{entry}, index{index} {}
+        : ConstBuffer{entry_}, index{index_} {}
    constexpr u32 GetIndex() const {
        return index;
@@ -43,8 +43,8 @@ private:
 class GlobalBufferEntry {
 public:
-    constexpr explicit GlobalBufferEntry(u32 cbuf_index, u32 cbuf_offset, bool is_written)
+    constexpr explicit GlobalBufferEntry(u32 cbuf_index_, u32 cbuf_offset_, bool is_written_)
-        : cbuf_index{cbuf_index}, cbuf_offset{cbuf_offset}, is_written{is_written} {}
+        : cbuf_index{cbuf_index_}, cbuf_offset{cbuf_offset_}, is_written{is_written_} {}
    constexpr u32 GetCbufIndex() const {
        return cbuf_index;
diff --git a/src/video_core/renderer_vulkan/vk_state_tracker.cpp b/src/video_core/renderer_vulkan/vk_state_tracker.cpp
index 5d2c4a796..50164cc08 100644
--- a/src/video_core/renderer_vulkan/vk_state_tracker.cpp
+++ b/src/video_core/renderer_vulkan/vk_state_tracker.cpp
@@ -14,7 +14,7 @@
 #include "video_core/renderer_vulkan/vk_state_tracker.h"
 #define OFF(field_name) MAXWELL3D_REG_INDEX(field_name)
-#define NUM(field_name) (sizeof(Maxwell3D::Regs::field_name) / sizeof(u32))
+#define NUM(field_name) (sizeof(Maxwell3D::Regs::field_name) / (sizeof(u32)))
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.cpp b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
index f2c8f2ae1..ae2e3322c 100644
--- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
@@ -52,7 +52,7 @@ VkImageType SurfaceTargetToImage(SurfaceTarget target) {
        UNREACHABLE();
        return {};
    }
-    UNREACHABLE_MSG("Unknown texture target={}", static_cast<u32>(target));
+    UNREACHABLE_MSG("Unknown texture target={}", target);
    return {};
 }
@@ -64,7 +64,7 @@ VkImageAspectFlags PixelFormatToImageAspect(PixelFormat pixel_format) {
    } else if (pixel_format < PixelFormat::MaxDepthStencilFormat) {
        return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
    } else {
-        UNREACHABLE_MSG("Invalid pixel format={}", static_cast<int>(pixel_format));
+        UNREACHABLE_MSG("Invalid pixel format={}", pixel_format);
        return VK_IMAGE_ASPECT_COLOR_BIT;
    }
 }
@@ -180,19 +180,19 @@ VkImageCreateInfo GenerateImageCreateInfo(const VKDevice& device, const SurfaceP
    return ci;
 }
-u32 EncodeSwizzle(Tegra::Texture::SwizzleSource x_source, Tegra::Texture::SwizzleSource y_source,
+u32 EncodeSwizzle(SwizzleSource x_source, SwizzleSource y_source, SwizzleSource z_source,
-                  Tegra::Texture::SwizzleSource z_source, Tegra::Texture::SwizzleSource w_source) {
+                  SwizzleSource w_source) {
    return (static_cast<u32>(x_source) << 24) | (static_cast<u32>(y_source) << 16) |
           (static_cast<u32>(z_source) << 8) | static_cast<u32>(w_source);
 }
 } // Anonymous namespace
-CachedSurface::CachedSurface(const VKDevice& device, VKMemoryManager& memory_manager,
+CachedSurface::CachedSurface(const VKDevice& device_, VKMemoryManager& memory_manager_,
-                             VKScheduler& scheduler, VKStagingBufferPool& staging_pool,
+                             VKScheduler& scheduler_, VKStagingBufferPool& staging_pool_,
-                             GPUVAddr gpu_addr, const SurfaceParams& params)
+                             GPUVAddr gpu_addr_, const SurfaceParams& params_)
-    : SurfaceBase<View>{gpu_addr, params, device.IsOptimalAstcSupported()}, device{device},
+    : SurfaceBase<View>{gpu_addr_, params_, device_.IsOptimalAstcSupported()}, device{device_},
-      memory_manager{memory_manager}, scheduler{scheduler}, staging_pool{staging_pool} {
+      memory_manager{memory_manager_}, scheduler{scheduler_}, staging_pool{staging_pool_} {
    if (params.IsBuffer()) {
        buffer = CreateBuffer(device, params, host_memory_size);
        commit = memory_manager.Commit(buffer, false);
@@ -234,7 +234,7 @@ void CachedSurface::UploadTexture(const std::vector<u8>& staging_buffer) {
 void CachedSurface::DownloadTexture(std::vector<u8>& staging_buffer) {
    UNIMPLEMENTED_IF(params.IsBuffer());
-    if (params.pixel_format == VideoCore::Surface::PixelFormat::A1B5G5R5_UNORM) {
+    if (params.pixel_format == PixelFormat::A1B5G5R5_UNORM) {
        LOG_WARNING(Render_Vulkan, "A1B5G5R5 flushing is stubbed");
    }
@@ -244,10 +244,10 @@ void CachedSurface::DownloadTexture(std::vector<u8>& staging_buffer) {
    FullTransition(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_ACCESS_TRANSFER_READ_BIT,
                   VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
-    const auto& buffer = staging_pool.GetUnusedBuffer(host_memory_size, true);
+    const auto& unused_buffer = staging_pool.GetUnusedBuffer(host_memory_size, true);
    // TODO(Rodrigo): Do this in a single copy
    for (u32 level = 0; level < params.num_levels; ++level) {
-        scheduler.Record([image = *image->GetHandle(), buffer = *buffer.handle,
+        scheduler.Record([image = *image->GetHandle(), buffer = *unused_buffer.handle,
                          copy = GetBufferImageCopy(level)](vk::CommandBuffer cmdbuf) {
            cmdbuf.CopyImageToBuffer(image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer, copy);
        });
@@ -255,16 +255,17 @@ void CachedSurface::DownloadTexture(std::vector<u8>& staging_buffer) {
    scheduler.Finish();
    // TODO(Rodrigo): Use an intern buffer for staging buffers and avoid this unnecessary memcpy.
-    std::memcpy(staging_buffer.data(), buffer.commit->Map(host_memory_size), host_memory_size);
+    std::memcpy(staging_buffer.data(), unused_buffer.commit->Map(host_memory_size),
+                host_memory_size);
 }
 void CachedSurface::DecorateSurfaceName() {
    // TODO(Rodrigo): Add name decorations
 }
-View CachedSurface::CreateView(const ViewParams& params) {
+View CachedSurface::CreateView(const ViewParams& view_params) {
    // TODO(Rodrigo): Add name decorations
-    return views[params] = std::make_shared<CachedSurfaceView>(device, *this, params);
+    return views[view_params] = std::make_shared<CachedSurfaceView>(device, *this, view_params);
 }
 void CachedSurface::UploadBuffer(const std::vector<u8>& staging_buffer) {
@@ -348,21 +349,21 @@ VkImageSubresourceRange CachedSurface::GetImageSubresourceRange() const {
            static_cast<u32>(params.GetNumLayers())};
 }
-CachedSurfaceView::CachedSurfaceView(const VKDevice& device, CachedSurface& surface,
+CachedSurfaceView::CachedSurfaceView(const VKDevice& device_, CachedSurface& surface_,
-                                     const ViewParams& params)
+                                     const ViewParams& view_params_)
-    : VideoCommon::ViewBase{params}, params{surface.GetSurfaceParams()},
+    : ViewBase{view_params_}, surface_params{surface_.GetSurfaceParams()},
-      image{surface.GetImageHandle()}, buffer_view{surface.GetBufferViewHandle()},
+      image{surface_.GetImageHandle()}, buffer_view{surface_.GetBufferViewHandle()},
-      aspect_mask{surface.GetAspectMask()}, device{device}, surface{surface},
+      aspect_mask{surface_.GetAspectMask()}, device{device_}, surface{surface_},
-      base_level{params.base_level}, num_levels{params.num_levels},
+      base_level{view_params_.base_level}, num_levels{view_params_.num_levels},
-      image_view_type{image ? GetImageViewType(params.target) : VK_IMAGE_VIEW_TYPE_1D} {
+      image_view_type{image ? GetImageViewType(view_params_.target) : VK_IMAGE_VIEW_TYPE_1D} {
    if (image_view_type == VK_IMAGE_VIEW_TYPE_3D) {
        base_layer = 0;
        num_layers = 1;
-        base_slice = params.base_layer;
+        base_slice = view_params_.base_layer;
-        num_slices = params.num_layers;
+        num_slices = view_params_.num_layers;
    } else {
-        base_layer = params.base_layer;
+        base_layer = view_params_.base_layer;
-        num_layers = params.num_layers;
+        num_layers = view_params_.num_layers;
    }
 }
@@ -384,7 +385,7 @@ VkImageView CachedSurfaceView::GetImageView(SwizzleSource x_source, SwizzleSourc
    std::array swizzle{MaxwellToVK::SwizzleSource(x_source), MaxwellToVK::SwizzleSource(y_source),
                       MaxwellToVK::SwizzleSource(z_source), MaxwellToVK::SwizzleSource(w_source)};
-    if (params.pixel_format == VideoCore::Surface::PixelFormat::A1B5G5R5_UNORM) {
+    if (surface_params.pixel_format == PixelFormat::A1B5G5R5_UNORM) {
        // A1B5G5R5 is implemented as A1R5G5B5, we have to change the swizzle here.
        std::swap(swizzle[0], swizzle[2]);
    }
@@ -395,12 +396,12 @@ VkImageView CachedSurfaceView::GetImageView(SwizzleSource x_source, SwizzleSourc
    if (aspect == (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {
        UNIMPLEMENTED_IF(x_source != SwizzleSource::R && x_source != SwizzleSource::G);
        const bool is_first = x_source == SwizzleSource::R;
-        switch (params.pixel_format) {
+        switch (surface_params.pixel_format) {
-        case VideoCore::Surface::PixelFormat::D24_UNORM_S8_UINT:
+        case PixelFormat::D24_UNORM_S8_UINT:
-        case VideoCore::Surface::PixelFormat::D32_FLOAT_S8_UINT:
+        case PixelFormat::D32_FLOAT_S8_UINT:
            aspect = is_first ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_STENCIL_BIT;
            break;
-        case VideoCore::Surface::PixelFormat::S8_UINT_D24_UNORM:
+        case PixelFormat::S8_UINT_D24_UNORM:
            aspect = is_first ? VK_IMAGE_ASPECT_STENCIL_BIT : VK_IMAGE_ASPECT_DEPTH_BIT;
            break;
        default:
@@ -417,7 +418,7 @@ VkImageView CachedSurfaceView::GetImageView(SwizzleSource x_source, SwizzleSourc
    if (image_view_type == VK_IMAGE_VIEW_TYPE_3D) {
        ASSERT(base_slice == 0);
-        ASSERT(num_slices == params.depth);
+        ASSERT(num_slices == surface_params.depth);
    }
    image_view = device.GetLogical().CreateImageView({
@@ -488,12 +489,12 @@ VkImageView CachedSurfaceView::GetAttachment() {
    return *render_target;
 }
-VKTextureCache::VKTextureCache(VideoCore::RasterizerInterface& rasterizer,
+VKTextureCache::VKTextureCache(VideoCore::RasterizerInterface& rasterizer_,
-                               Tegra::Engines::Maxwell3D& maxwell3d,
+                               Tegra::Engines::Maxwell3D& maxwell3d_,
-                               Tegra::MemoryManager& gpu_memory, const VKDevice& device_,
+                               Tegra::MemoryManager& gpu_memory_, const VKDevice& device_,
                               VKMemoryManager& memory_manager_, VKScheduler& scheduler_,
                               VKStagingBufferPool& staging_pool_)
-    : TextureCache(rasterizer, maxwell3d, gpu_memory, device_.IsOptimalAstcSupported()),
+    : TextureCache(rasterizer_, maxwell3d_, gpu_memory_, device_.IsOptimalAstcSupported()),
      device{device_}, memory_manager{memory_manager_}, scheduler{scheduler_}, staging_pool{
                                                                                   staging_pool_} {}
diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.h b/src/video_core/renderer_vulkan/vk_texture_cache.h
index 39202feba..b0be4cb0f 100644
--- a/src/video_core/renderer_vulkan/vk_texture_cache.h
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.h
@@ -40,9 +40,9 @@ class CachedSurface final : public VideoCommon::SurfaceBase<View> {
    friend CachedSurfaceView;
 public:
-    explicit CachedSurface(const VKDevice& device, VKMemoryManager& memory_manager,
+    explicit CachedSurface(const VKDevice& device_, VKMemoryManager& memory_manager_,
-                           VKScheduler& scheduler, VKStagingBufferPool& staging_pool,
+                           VKScheduler& scheduler_, VKStagingBufferPool& staging_pool_,
-                           GPUVAddr gpu_addr, const SurfaceParams& params);
+                           GPUVAddr gpu_addr_, const SurfaceParams& params_);
    ~CachedSurface();
    void UploadTexture(const std::vector<u8>& staging_buffer) override;
@@ -82,9 +82,9 @@ public:
    }
 protected:
-    void DecorateSurfaceName();
+    void DecorateSurfaceName() override;
-    View CreateView(const ViewParams& params) override;
+    View CreateView(const ViewParams& view_params) override;
 private:
    void UploadBuffer(const std::vector<u8>& staging_buffer);
@@ -110,8 +110,8 @@ private:
 class CachedSurfaceView final : public VideoCommon::ViewBase {
 public:
-    explicit CachedSurfaceView(const VKDevice& device, CachedSurface& surface,
+    explicit CachedSurfaceView(const VKDevice& device_, CachedSurface& surface_,
-                               const ViewParams& params);
+                               const ViewParams& view_params_);
    ~CachedSurfaceView();
    VkImageView GetImageView(Tegra::Texture::SwizzleSource x_source,
@@ -126,11 +126,11 @@ public:
    }
    u32 GetWidth() const {
-        return params.GetMipWidth(base_level);
+        return surface_params.GetMipWidth(base_level);
    }
    u32 GetHeight() const {
-        return params.GetMipHeight(base_level);
+        return surface_params.GetMipHeight(base_level);
    }
    u32 GetNumLayers() const {
@@ -169,7 +169,7 @@ public:
 private:
    // Store a copy of these values to avoid double dereference when reading them
-    const SurfaceParams params;
+    const SurfaceParams surface_params;
    const VkImage image;
    const VkBufferView buffer_view;
    const VkImageAspectFlags aspect_mask;
@@ -193,10 +193,11 @@ private:
 class VKTextureCache final : public TextureCacheBase {
 public:
-    explicit VKTextureCache(VideoCore::RasterizerInterface& rasterizer,
+    explicit VKTextureCache(VideoCore::RasterizerInterface& rasterizer_,
-                            Tegra::Engines::Maxwell3D& maxwell3d, Tegra::MemoryManager& gpu_memory,
+                            Tegra::Engines::Maxwell3D& maxwell3d_,
-                            const VKDevice& device, VKMemoryManager& memory_manager,
+                            Tegra::MemoryManager& gpu_memory_, const VKDevice& device_,
-                            VKScheduler& scheduler, VKStagingBufferPool& staging_pool);
+                            VKMemoryManager& memory_manager_, VKScheduler& scheduler_,
+                            VKStagingBufferPool& staging_pool_);
    ~VKTextureCache();
 private:
diff --git a/src/video_core/renderer_vulkan/vk_update_descriptor.cpp b/src/video_core/renderer_vulkan/vk_update_descriptor.cpp
index 351c048d2..8826da325 100644
--- a/src/video_core/renderer_vulkan/vk_update_descriptor.cpp
+++ b/src/video_core/renderer_vulkan/vk_update_descriptor.cpp
@@ -14,8 +14,8 @@
 namespace Vulkan {
-VKUpdateDescriptorQueue::VKUpdateDescriptorQueue(const VKDevice& device, VKScheduler& scheduler)
+VKUpdateDescriptorQueue::VKUpdateDescriptorQueue(const VKDevice& device_, VKScheduler& scheduler_)
-    : device{device}, scheduler{scheduler} {}
+    : device{device_}, scheduler{scheduler_} {}
 VKUpdateDescriptorQueue::~VKUpdateDescriptorQueue() = default;
diff --git a/src/video_core/renderer_vulkan/vk_update_descriptor.h b/src/video_core/renderer_vulkan/vk_update_descriptor.h
index 945320c72..f7e3c9821 100644
--- a/src/video_core/renderer_vulkan/vk_update_descriptor.h
+++ b/src/video_core/renderer_vulkan/vk_update_descriptor.h
@@ -31,7 +31,7 @@ struct DescriptorUpdateEntry {
 class VKUpdateDescriptorQueue final {
 public:
-    explicit VKUpdateDescriptorQueue(const VKDevice& device, VKScheduler& scheduler);
+    explicit VKUpdateDescriptorQueue(const VKDevice& device_, VKScheduler& scheduler_);
    ~VKUpdateDescriptorQueue();
    void TickFrame();
diff --git a/src/video_core/renderer_vulkan/wrapper.cpp b/src/video_core/renderer_vulkan/wrapper.cpp
index 4e83303d8..1eced809e 100644
--- a/src/video_core/renderer_vulkan/wrapper.cpp
+++ b/src/video_core/renderer_vulkan/wrapper.cpp
@@ -417,7 +417,7 @@ VkResult Free(VkDevice device, VkCommandPool handle, Span<VkCommandBuffer> buffe
 }
 Instance Instance::Create(u32 version, Span<const char*> layers, Span<const char*> extensions,
-                          InstanceDispatch& dld) noexcept {
+                          InstanceDispatch& dispatch) noexcept {
    const VkApplicationInfo application_info{
        .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
        .pNext = nullptr,
@@ -439,17 +439,17 @@ Instance Instance::Create(u32 version, Span<const char*> layers, Span<const char
    };
    VkInstance instance;
-    if (dld.vkCreateInstance(&ci, nullptr, &instance) != VK_SUCCESS) {
+    if (dispatch.vkCreateInstance(&ci, nullptr, &instance) != VK_SUCCESS) {
        // Failed to create the instance.
        return {};
    }
-    if (!Proc(dld.vkDestroyInstance, dld, "vkDestroyInstance", instance)) {
+    if (!Proc(dispatch.vkDestroyInstance, dispatch, "vkDestroyInstance", instance)) {
        // We successfully created an instance but the destroy function couldn't be loaded.
        // This is a good moment to panic.
        return {};
    }
-    return Instance(instance, dld);
+    return Instance(instance, dispatch);
 }
 std::optional<std::vector<VkPhysicalDevice>> Instance::EnumeratePhysicalDevices() {
@@ -540,7 +540,7 @@ std::vector<VkImage> SwapchainKHR::GetImages() const {
 Device Device::Create(VkPhysicalDevice physical_device, Span<VkDeviceQueueCreateInfo> queues_ci,
                      Span<const char*> enabled_extensions, const void* next,
-                      DeviceDispatch& dld) noexcept {
+                      DeviceDispatch& dispatch) noexcept {
    const VkDeviceCreateInfo ci{
        .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
        .pNext = next,
@@ -555,11 +555,11 @@ Device Device::Create(VkPhysicalDevice physical_device, Span<VkDeviceQueueCreate
    };
    VkDevice device;
-    if (dld.vkCreateDevice(physical_device, &ci, nullptr, &device) != VK_SUCCESS) {
+    if (dispatch.vkCreateDevice(physical_device, &ci, nullptr, &device) != VK_SUCCESS) {
        return {};
    }
-    Load(device, dld);
+    Load(device, dispatch);
-    return Device(device, dld);
+    return Device(device, dispatch);
 }
 Queue Device::GetQueue(u32 family_index) const noexcept {
diff --git a/src/video_core/renderer_vulkan/wrapper.h b/src/video_core/renderer_vulkan/wrapper.h
index f64919623..76f790eab 100644
--- a/src/video_core/renderer_vulkan/wrapper.h
+++ b/src/video_core/renderer_vulkan/wrapper.h
@@ -52,7 +52,7 @@ public:
    /// Construct a span from a pointer and a size.
    /// This is inteded for subranges.
-    constexpr Span(const T* ptr, std::size_t num) noexcept : ptr{ptr}, num{num} {}
+    constexpr Span(const T* ptr_, std::size_t num_) noexcept : ptr{ptr_}, num{num_} {}
    /// Returns the data pointer by the span.
    constexpr const T* data() const noexcept {
@@ -469,9 +469,10 @@ public:
    PoolAllocations() = default;
    /// Construct an allocation. Errors are reported through IsOutOfPoolMemory().
-    explicit PoolAllocations(std::unique_ptr<AllocationType[]> allocations, std::size_t num,
+    explicit PoolAllocations(std::unique_ptr<AllocationType[]> allocations_, std::size_t num_,
-                             VkDevice device, PoolType pool, const DeviceDispatch& dld) noexcept
+                             VkDevice device_, PoolType pool_, const DeviceDispatch& dld_) noexcept
-        : allocations{std::move(allocations)}, num{num}, device{device}, pool{pool}, dld{&dld} {}
+        : allocations{std::move(allocations_)}, num{num_}, device{device_}, pool{pool_},
+          dld{&dld_} {}
    /// Copying Vulkan allocations is not supported and will never be.
    PoolAllocations(const PoolAllocations&) = delete;
@@ -565,7 +566,7 @@ class Instance : public Handle<VkInstance, NoOwner, InstanceDispatch> {
 public:
    /// Creates a Vulkan instance. Use "operator bool" for error handling.
    static Instance Create(u32 version, Span<const char*> layers, Span<const char*> extensions,
-                           InstanceDispatch& dld) noexcept;
+                           InstanceDispatch& dispatch) noexcept;
    /// Enumerates physical devices.
    /// @return Physical devices and an empty handle on failure.
@@ -581,7 +582,8 @@ public:
    constexpr Queue() noexcept = default;
    /// Construct a queue handle.
-    constexpr Queue(VkQueue queue, const DeviceDispatch& dld) noexcept : queue{queue}, dld{&dld} {}
+    constexpr Queue(VkQueue queue_, const DeviceDispatch& dld_) noexcept
+        : queue{queue_}, dld{&dld_} {}
    VkResult Submit(Span<VkSubmitInfo> submit_infos,
                    VkFence fence = VK_NULL_HANDLE) const noexcept {
@@ -720,7 +722,7 @@ class Device : public Handle<VkDevice, NoOwner, DeviceDispatch> {
 public:
    static Device Create(VkPhysicalDevice physical_device, Span<VkDeviceQueueCreateInfo> queues_ci,
                         Span<const char*> enabled_extensions, const void* next,
-                         DeviceDispatch& dld) noexcept;
+                         DeviceDispatch& dispatch) noexcept;
    Queue GetQueue(u32 family_index) const noexcept;
@@ -809,8 +811,9 @@ class PhysicalDevice {
 public:
    constexpr PhysicalDevice() noexcept = default;
-    constexpr PhysicalDevice(VkPhysicalDevice physical_device, const InstanceDispatch& dld) noexcept
+    constexpr PhysicalDevice(VkPhysicalDevice physical_device_,
-        : physical_device{physical_device}, dld{&dld} {}
+                             const InstanceDispatch& dld_) noexcept
+        : physical_device{physical_device_}, dld{&dld_} {}
    constexpr operator VkPhysicalDevice() const noexcept {
        return physical_device;
@@ -849,8 +852,8 @@ class CommandBuffer {
 public:
    CommandBuffer() noexcept = default;
-    explicit CommandBuffer(VkCommandBuffer handle, const DeviceDispatch& dld) noexcept
+    explicit CommandBuffer(VkCommandBuffer handle_, const DeviceDispatch& dld_) noexcept
-        : handle{handle}, dld{&dld} {}
+        : handle{handle_}, dld{&dld_} {}
    const VkCommandBuffer* address() const noexcept {
        return &handle;
diff --git a/src/video_core/shader/ast.cpp b/src/video_core/shader/ast.cpp
index 3f96d9076..db11144c7 100644
--- a/src/video_core/shader/ast.cpp
+++ b/src/video_core/shader/ast.cpp
@@ -212,16 +212,15 @@ public:
    }
    void operator()(const ExprPredicate& expr) {
-        inner += "P" + std::to_string(expr.predicate);
+        inner += fmt::format("P{}", expr.predicate);
    }
    void operator()(const ExprCondCode& expr) {
-        u32 cc = static_cast<u32>(expr.cc);
+        inner += fmt::format("CC{}", expr.cc);
-        inner += "CC" + std::to_string(cc);
    }
    void operator()(const ExprVar& expr) {
-        inner += "V" + std::to_string(expr.var_index);
+        inner += fmt::format("V{}", expr.var_index);
    }
    void operator()(const ExprBoolean& expr) {
@@ -229,7 +228,7 @@ public:
    }
    void operator()(const ExprGprEqual& expr) {
-        inner += "( gpr_" + std::to_string(expr.gpr) + " == " + std::to_string(expr.value) + ')';
+        inner += fmt::format("(gpr_{} == {})", expr.gpr, expr.value);
    }
    const std::string& GetResult() const {
@@ -374,8 +373,8 @@ std::string ASTManager::Print() const {
    return printer.GetResult();
 }
-ASTManager::ASTManager(bool full_decompile, bool disable_else_derivation)
+ASTManager::ASTManager(bool do_full_decompile, bool disable_else_derivation_)
-    : full_decompile{full_decompile}, disable_else_derivation{disable_else_derivation} {};
+    : full_decompile{do_full_decompile}, disable_else_derivation{disable_else_derivation_} {}
 ASTManager::~ASTManager() {
    Clear();
diff --git a/src/video_core/shader/ast.h b/src/video_core/shader/ast.h
index 8e5a22ab3..dc49b369e 100644
--- a/src/video_core/shader/ast.h
+++ b/src/video_core/shader/ast.h
@@ -76,7 +76,7 @@ public:
 class ASTIfThen {
 public:
-    explicit ASTIfThen(Expr condition) : condition{std::move(condition)} {}
+    explicit ASTIfThen(Expr condition_) : condition{std::move(condition_)} {}
    Expr condition;
    ASTZipper nodes{};
 };
@@ -88,63 +88,68 @@ public:
 class ASTBlockEncoded {
 public:
-    explicit ASTBlockEncoded(u32 start, u32 end) : start{start}, end{end} {}
+    explicit ASTBlockEncoded(u32 start_, u32 _) : start{start_}, end{_} {}
    u32 start;
    u32 end;
 };
 class ASTBlockDecoded {
 public:
-    explicit ASTBlockDecoded(NodeBlock&& new_nodes) : nodes(std::move(new_nodes)) {}
+    explicit ASTBlockDecoded(NodeBlock&& new_nodes_) : nodes(std::move(new_nodes_)) {}
    NodeBlock nodes;
 };
 class ASTVarSet {
 public:
-    explicit ASTVarSet(u32 index, Expr condition) : index{index}, condition{std::move(condition)} {}
+    explicit ASTVarSet(u32 index_, Expr condition_)
+        : index{index_}, condition{std::move(condition_)} {}
    u32 index;
    Expr condition;
 };
 class ASTLabel {
 public:
-    explicit ASTLabel(u32 index) : index{index} {}
+    explicit ASTLabel(u32 index_) : index{index_} {}
    u32 index;
    bool unused{};
 };
 class ASTGoto {
 public:
-    explicit ASTGoto(Expr condition, u32 label) : condition{std::move(condition)}, label{label} {}
+    explicit ASTGoto(Expr condition_, u32 label_)
+        : condition{std::move(condition_)}, label{label_} {}
    Expr condition;
    u32 label;
 };
 class ASTDoWhile {
 public:
-    explicit ASTDoWhile(Expr condition) : condition{std::move(condition)} {}
+    explicit ASTDoWhile(Expr condition_) : condition{std::move(condition_)} {}
    Expr condition;
    ASTZipper nodes{};
 };
 class ASTReturn {
 public:
-    explicit ASTReturn(Expr condition, bool kills)
+    explicit ASTReturn(Expr condition_, bool kills_)
-        : condition{std::move(condition)}, kills{kills} {}
+        : condition{std::move(condition_)}, kills{kills_} {}
    Expr condition;
    bool kills;
 };
 class ASTBreak {
 public:
-    explicit ASTBreak(Expr condition) : condition{std::move(condition)} {}
+    explicit ASTBreak(Expr condition_) : condition{std::move(condition_)} {}
    Expr condition;
 };
 class ASTBase {
 public:
-    explicit ASTBase(ASTNode parent, ASTData data)
+    explicit ASTBase(ASTNode parent_, ASTData data_)
-        : data{std::move(data)}, parent{std::move(parent)} {}
+        : data{std::move(data_)}, parent{std::move(parent_)} {}
    template <class U, class... Args>
    static ASTNode Make(ASTNode parent, Args&&... args) {
@@ -300,7 +305,7 @@ private:
 class ASTManager final {
 public:
-    ASTManager(bool full_decompile, bool disable_else_derivation);
+    explicit ASTManager(bool do_full_decompile, bool disable_else_derivation_);
    ~ASTManager();
    ASTManager(const ASTManager& o) = delete;
diff --git a/src/video_core/shader/async_shaders.cpp b/src/video_core/shader/async_shaders.cpp
index 6920afdf2..78245473c 100644
--- a/src/video_core/shader/async_shaders.cpp
+++ b/src/video_core/shader/async_shaders.cpp
@@ -13,7 +13,7 @@
 namespace VideoCommon::Shader {
-AsyncShaders::AsyncShaders(Core::Frontend::EmuWindow& emu_window) : emu_window(emu_window) {}
+AsyncShaders::AsyncShaders(Core::Frontend::EmuWindow& emu_window_) : emu_window(emu_window_) {}
 AsyncShaders::~AsyncShaders() {
    KillWorkers();
diff --git a/src/video_core/shader/async_shaders.h b/src/video_core/shader/async_shaders.h
index 7a99e1dc5..5a7216019 100644
--- a/src/video_core/shader/async_shaders.h
+++ b/src/video_core/shader/async_shaders.h
@@ -66,7 +66,7 @@ public:
        Tegra::Engines::ShaderType shader_type;
    };
-    explicit AsyncShaders(Core::Frontend::EmuWindow& emu_window);
+    explicit AsyncShaders(Core::Frontend::EmuWindow& emu_window_);
    ~AsyncShaders();
    /// Start up shader worker threads
diff --git a/src/video_core/shader/control_flow.cpp b/src/video_core/shader/control_flow.cpp
index 4c8971615..43d965f2f 100644
--- a/src/video_core/shader/control_flow.cpp
+++ b/src/video_core/shader/control_flow.cpp
@@ -66,8 +66,8 @@ struct BlockInfo {
 };
 struct CFGRebuildState {
-    explicit CFGRebuildState(const ProgramCode& program_code, u32 start, Registry& registry)
+    explicit CFGRebuildState(const ProgramCode& program_code_, u32 start_, Registry& registry_)
-        : program_code{program_code}, registry{registry}, start{start} {}
+        : program_code{program_code_}, registry{registry_}, start{start_} {}
    const ProgramCode& program_code;
    Registry& registry;
@@ -241,10 +241,10 @@ std::pair<ParseResult, ParseInfo> ParseCode(CFGRebuildState& state, u32 address)
    ParseInfo parse_info{};
    SingleBranch single_branch{};
-    const auto insert_label = [](CFGRebuildState& state, u32 address) {
+    const auto insert_label = [](CFGRebuildState& rebuild_state, u32 label_address) {
-        const auto pair = state.labels.emplace(address);
+        const auto pair = rebuild_state.labels.emplace(label_address);
        if (pair.second) {
-            state.inspect_queries.push_back(address);
+            rebuild_state.inspect_queries.push_back(label_address);
        }
    };
@@ -257,7 +257,7 @@ std::pair<ParseResult, ParseInfo> ParseCode(CFGRebuildState& state, u32 address)
            single_branch.ignore = false;
            break;
        }
-        if (state.registered.count(offset) != 0) {
+        if (state.registered.contains(offset)) {
            single_branch.address = offset;
            single_branch.ignore = true;
            break;
@@ -632,12 +632,12 @@ void DecompileShader(CFGRebuildState& state) {
    for (auto label : state.labels) {
        state.manager->DeclareLabel(label);
    }
-    for (auto& block : state.block_info) {
+    for (const auto& block : state.block_info) {
-        if (state.labels.count(block.start) != 0) {
+        if (state.labels.contains(block.start)) {
            state.manager->InsertLabel(block.start);
        }
        const bool ignore = BlockBranchIsIgnored(block.branch);
-        u32 end = ignore ? block.end + 1 : block.end;
+        const u32 end = ignore ? block.end + 1 : block.end;
        state.manager->InsertBlock(block.start, end);
        if (!ignore) {
            InsertBranch(*state.manager, block.branch);
@@ -737,7 +737,7 @@ std::unique_ptr<ShaderCharacteristics> ScanFlow(const ProgramCode& program_code,
    auto back = result_out->blocks.begin();
    auto next = std::next(back);
    while (next != result_out->blocks.end()) {
-        if (state.labels.count(next->start) == 0 && next->start == back->end + 1) {
+        if (!state.labels.contains(next->start) && next->start == back->end + 1) {
            back->end = next->end;
            next = result_out->blocks.erase(next);
            continue;
diff --git a/src/video_core/shader/control_flow.h b/src/video_core/shader/control_flow.h
index 62a3510d8..37bf96492 100644
--- a/src/video_core/shader/control_flow.h
+++ b/src/video_core/shader/control_flow.h
@@ -42,10 +42,10 @@ struct Condition {
 class SingleBranch {
 public:
    SingleBranch() = default;
-    SingleBranch(Condition condition, s32 address, bool kill, bool is_sync, bool is_brk,
+    explicit SingleBranch(Condition condition_, s32 address_, bool kill_, bool is_sync_,
-                 bool ignore)
+                          bool is_brk_, bool ignore_)
-        : condition{condition}, address{address}, kill{kill}, is_sync{is_sync}, is_brk{is_brk},
+        : condition{condition_}, address{address_}, kill{kill_}, is_sync{is_sync_}, is_brk{is_brk_},
-          ignore{ignore} {}
+          ignore{ignore_} {}
    bool operator==(const SingleBranch& b) const {
        return std::tie(condition, address, kill, is_sync, is_brk, ignore) ==
@@ -65,15 +65,15 @@ public:
 };
 struct CaseBranch {
-    CaseBranch(u32 cmp_value, u32 address) : cmp_value{cmp_value}, address{address} {}
+    explicit CaseBranch(u32 cmp_value_, u32 address_) : cmp_value{cmp_value_}, address{address_} {}
    u32 cmp_value;
    u32 address;
 };
 class MultiBranch {
 public:
-    MultiBranch(u32 gpr, std::vector<CaseBranch>&& branches)
+    explicit MultiBranch(u32 gpr_, std::vector<CaseBranch>&& branches_)
-        : gpr{gpr}, branches{std::move(branches)} {}
+        : gpr{gpr_}, branches{std::move(branches_)} {}
    u32 gpr{};
    std::vector<CaseBranch> branches{};
diff --git a/src/video_core/shader/decode.cpp b/src/video_core/shader/decode.cpp
index eeac328a6..ab14c1aa3 100644
--- a/src/video_core/shader/decode.cpp
+++ b/src/video_core/shader/decode.cpp
@@ -66,7 +66,7 @@ std::optional<u32> TryDeduceSamplerSize(const Sampler& sampler_to_deduce,
 class ASTDecoder {
 public:
-    ASTDecoder(ShaderIR& ir) : ir(ir) {}
+    explicit ASTDecoder(ShaderIR& ir_) : ir(ir_) {}
    void operator()(ASTProgram& ast) {
        ASTNode current = ast.nodes.GetFirst();
@@ -153,8 +153,8 @@ void ShaderIR::Decode() {
        const auto& blocks = shader_info.blocks;
        NodeBlock current_block;
        u32 current_label = static_cast<u32>(exit_branch);
-        for (auto& block : blocks) {
+        for (const auto& block : blocks) {
-            if (shader_info.labels.count(block.start) != 0) {
+            if (shader_info.labels.contains(block.start)) {
                insert_block(current_block, current_label);
                current_block.clear();
                current_label = block.start;
diff --git a/src/video_core/shader/decode/arithmetic.cpp b/src/video_core/shader/decode/arithmetic.cpp
index afef5948d..15eb700e7 100644
--- a/src/video_core/shader/decode/arithmetic.cpp
+++ b/src/video_core/shader/decode/arithmetic.cpp
@@ -110,8 +110,7 @@ u32 ShaderIR::DecodeArithmetic(NodeBlock& bb, u32 pc) {
            case SubOp::Sqrt:
                return Operation(OperationCode::FSqrt, PRECISE, op_a);
            default:
-                UNIMPLEMENTED_MSG("Unhandled MUFU sub op={0:x}",
+                UNIMPLEMENTED_MSG("Unhandled MUFU sub op={0:x}", instr.sub_op.Value());
-                                  static_cast<unsigned>(instr.sub_op.Value()));
                return Immediate(0);
            }
        }();
diff --git a/src/video_core/shader/decode/arithmetic_integer.cpp b/src/video_core/shader/decode/arithmetic_integer.cpp
index 73155966f..7b5bb7003 100644
--- a/src/video_core/shader/decode/arithmetic_integer.cpp
+++ b/src/video_core/shader/decode/arithmetic_integer.cpp
@@ -83,7 +83,7 @@ u32 ShaderIR::DecodeArithmeticInteger(NodeBlock& bb, u32 pc) {
            case IAdd3Height::UpperHalfWord:
                return BitfieldExtract(value, 16, 16);
            default:
-                UNIMPLEMENTED_MSG("Unhandled IADD3 height: {}", static_cast<u32>(height));
+                UNIMPLEMENTED_MSG("Unhandled IADD3 height: {}", height);
                return Immediate(0);
            }
        };
@@ -258,7 +258,7 @@ u32 ShaderIR::DecodeArithmeticInteger(NodeBlock& bb, u32 pc) {
    case OpCode::Id::LEA_IMM:
    case OpCode::Id::LEA_RZ:
    case OpCode::Id::LEA_HI: {
-        auto [op_a, op_b, op_c] = [&]() -> std::tuple<Node, Node, Node> {
+        auto [op_a_, op_b_, op_c_] = [&]() -> std::tuple<Node, Node, Node> {
            switch (opcode->get().GetId()) {
            case OpCode::Id::LEA_R2: {
                return {GetRegister(instr.gpr20), GetRegister(instr.gpr39),
@@ -294,8 +294,9 @@ u32 ShaderIR::DecodeArithmeticInteger(NodeBlock& bb, u32 pc) {
        UNIMPLEMENTED_IF_MSG(instr.lea.pred48 != static_cast<u64>(Pred::UnusedIndex),
                             "Unhandled LEA Predicate");
-        Node value = Operation(OperationCode::ILogicalShiftLeft, std::move(op_a), std::move(op_c));
+        Node value =
-        value = Operation(OperationCode::IAdd, std::move(op_b), std::move(value));
+            Operation(OperationCode::ILogicalShiftLeft, std::move(op_a_), std::move(op_c_));
+        value = Operation(OperationCode::IAdd, std::move(op_b_), std::move(value));
        SetRegister(bb, instr.gpr0, std::move(value));
        break;
diff --git a/src/video_core/shader/decode/arithmetic_integer_immediate.cpp b/src/video_core/shader/decode/arithmetic_integer_immediate.cpp
index 2a30aab2b..73580277a 100644
--- a/src/video_core/shader/decode/arithmetic_integer_immediate.cpp
+++ b/src/video_core/shader/decode/arithmetic_integer_immediate.cpp
@@ -72,7 +72,7 @@ void ShaderIR::WriteLogicOperation(NodeBlock& bb, Register dest, LogicOperation
        case LogicOperation::PassB:
            return op_b;
        default:
-            UNIMPLEMENTED_MSG("Unimplemented logic operation={}", static_cast<u32>(logic_op));
+            UNIMPLEMENTED_MSG("Unimplemented logic operation={}", logic_op);
            return Immediate(0);
        }
    }();
@@ -92,8 +92,7 @@ void ShaderIR::WriteLogicOperation(NodeBlock& bb, Register dest, LogicOperation
        break;
    }
    default:
-        UNIMPLEMENTED_MSG("Unimplemented predicate result mode: {}",
+        UNIMPLEMENTED_MSG("Unimplemented predicate result mode: {}", predicate_mode);
-                          static_cast<u32>(predicate_mode));
    }
 }
diff --git a/src/video_core/shader/decode/conversion.cpp b/src/video_core/shader/decode/conversion.cpp
index b9989c88c..fea7a54df 100644
--- a/src/video_core/shader/decode/conversion.cpp
+++ b/src/video_core/shader/decode/conversion.cpp
@@ -244,7 +244,7 @@ u32 ShaderIR::DecodeConversion(NodeBlock& bb, u32 pc) {
                return Operation(OperationCode::FTrunc, value);
            default:
                UNIMPLEMENTED_MSG("Unimplemented F2F rounding mode {}",
-                                  static_cast<u32>(instr.conversion.f2f.rounding.Value()));
+                                  instr.conversion.f2f.rounding.Value());
                return value;
            }
        }();
@@ -300,7 +300,7 @@ u32 ShaderIR::DecodeConversion(NodeBlock& bb, u32 pc) {
                return Operation(OperationCode::FTrunc, PRECISE, value);
            default:
                UNIMPLEMENTED_MSG("Unimplemented F2I rounding mode {}",
-                                  static_cast<u32>(instr.conversion.f2i.rounding.Value()));
+                                  instr.conversion.f2i.rounding.Value());
                return Immediate(0);
            }
        }();
diff --git a/src/video_core/shader/decode/image.cpp b/src/video_core/shader/decode/image.cpp
index 1ed4212ee..532f66d27 100644
--- a/src/video_core/shader/decode/image.cpp
+++ b/src/video_core/shader/decode/image.cpp
@@ -358,9 +358,9 @@ u32 ShaderIR::DecodeImage(NodeBlock& bb, u32 pc) {
                             instr.suldst.GetStoreDataLayout() != StoreType::Bits64);
            auto descriptor = [this, instr] {
-                std::optional<Tegra::Engines::SamplerDescriptor> descriptor;
+                std::optional<Tegra::Engines::SamplerDescriptor> sampler_descriptor;
                if (instr.suldst.is_immediate) {
-                    descriptor =
+                    sampler_descriptor =
                        registry.ObtainBoundSampler(static_cast<u32>(instr.image.index.Value()));
                } else {
                    const Node image_register = GetRegister(instr.gpr39);
@@ -368,12 +368,12 @@ u32 ShaderIR::DecodeImage(NodeBlock& bb, u32 pc) {
                                                  static_cast<s64>(global_code.size()));
                    const auto buffer = std::get<1>(result);
                    const auto offset = std::get<2>(result);
-                    descriptor = registry.ObtainBindlessSampler(buffer, offset);
+                    sampler_descriptor = registry.ObtainBindlessSampler(buffer, offset);
                }
-                if (!descriptor) {
+                if (!sampler_descriptor) {
                    UNREACHABLE_MSG("Failed to obtain image descriptor");
                }
-                return *descriptor;
+                return *sampler_descriptor;
            }();
            const auto comp_mask = GetImageComponentMask(descriptor.format);
diff --git a/src/video_core/shader/decode/memory.cpp b/src/video_core/shader/decode/memory.cpp
index e2bba88dd..50f4e7d35 100644
--- a/src/video_core/shader/decode/memory.cpp
+++ b/src/video_core/shader/decode/memory.cpp
@@ -47,7 +47,7 @@ OperationCode GetAtomOperation(AtomicOp op) {
    case AtomicOp::Exch:
        return OperationCode::AtomicIExchange;
    default:
-        UNIMPLEMENTED_MSG("op={}", static_cast<int>(op));
+        UNIMPLEMENTED_MSG("op={}", op);
        return OperationCode::AtomicIAdd;
    }
 }
@@ -83,7 +83,7 @@ u32 GetMemorySize(Tegra::Shader::UniformType uniform_type) {
    case Tegra::Shader::UniformType::UnsignedQuad:
        return 128;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented size={}!", static_cast<u32>(uniform_type));
+        UNIMPLEMENTED_MSG("Unimplemented size={}!", uniform_type);
        return 32;
    }
 }
@@ -175,12 +175,12 @@ u32 ShaderIR::DecodeMemory(NodeBlock& bb, u32 pc) {
            break;
        }
        default:
-            UNIMPLEMENTED_MSG("Unhandled type: {}", static_cast<unsigned>(instr.ld_c.type.Value()));
+            UNIMPLEMENTED_MSG("Unhandled type: {}", instr.ld_c.type.Value());
        }
        break;
    }
    case OpCode::Id::LD_L:
-        LOG_DEBUG(HW_GPU, "LD_L cache management mode: {}", static_cast<u64>(instr.ld_l.unknown));
+        LOG_DEBUG(HW_GPU, "LD_L cache management mode: {}", instr.ld_l.unknown);
        [[fallthrough]];
    case OpCode::Id::LD_S: {
        const auto GetAddress = [&](s32 offset) {
@@ -224,7 +224,7 @@ u32 ShaderIR::DecodeMemory(NodeBlock& bb, u32 pc) {
        }
        default:
            UNIMPLEMENTED_MSG("{} Unhandled type: {}", opcode->get().GetName(),
-                              static_cast<u32>(instr.ldst_sl.type.Value()));
+                              instr.ldst_sl.type.Value());
        }
        break;
    }
@@ -306,8 +306,7 @@ u32 ShaderIR::DecodeMemory(NodeBlock& bb, u32 pc) {
        break;
    }
    case OpCode::Id::ST_L:
-        LOG_DEBUG(HW_GPU, "ST_L cache management mode: {}",
+        LOG_DEBUG(HW_GPU, "ST_L cache management mode: {}", instr.st_l.cache_management.Value());
-                  static_cast<u64>(instr.st_l.cache_management.Value()));
        [[fallthrough]];
    case OpCode::Id::ST_S: {
        const auto GetAddress = [&](s32 offset) {
@@ -340,7 +339,7 @@ u32 ShaderIR::DecodeMemory(NodeBlock& bb, u32 pc) {
        }
        default:
            UNIMPLEMENTED_MSG("{} unhandled type: {}", opcode->get().GetName(),
-                              static_cast<u32>(instr.ldst_sl.type.Value()));
+                              instr.ldst_sl.type.Value());
        }
        break;
    }
@@ -387,7 +386,7 @@ u32 ShaderIR::DecodeMemory(NodeBlock& bb, u32 pc) {
    }
    case OpCode::Id::RED: {
        UNIMPLEMENTED_IF_MSG(instr.red.type != GlobalAtomicType::U32, "type={}",
-                             static_cast<int>(instr.red.type.Value()));
+                             instr.red.type.Value());
        const auto [real_address, base_address, descriptor] =
            TrackGlobalMemory(bb, instr, true, true);
        if (!real_address || !base_address) {
@@ -403,12 +402,12 @@ u32 ShaderIR::DecodeMemory(NodeBlock& bb, u32 pc) {
        UNIMPLEMENTED_IF_MSG(instr.atom.operation == AtomicOp::Inc ||
                                 instr.atom.operation == AtomicOp::Dec ||
                                 instr.atom.operation == AtomicOp::SafeAdd,
-                             "operation={}", static_cast<int>(instr.atom.operation.Value()));
+                             "operation={}", instr.atom.operation.Value());
        UNIMPLEMENTED_IF_MSG(instr.atom.type == GlobalAtomicType::S64 ||
                                 instr.atom.type == GlobalAtomicType::U64 ||
                                 instr.atom.type == GlobalAtomicType::F16x2_FTZ_RN ||
                                 instr.atom.type == GlobalAtomicType::F32_FTZ_RN,
-                             "type={}", static_cast<int>(instr.atom.type.Value()));
+                             "type={}", instr.atom.type.Value());
        const auto [real_address, base_address, descriptor] =
            TrackGlobalMemory(bb, instr, true, true);
@@ -428,10 +427,10 @@ u32 ShaderIR::DecodeMemory(NodeBlock& bb, u32 pc) {
    case OpCode::Id::ATOMS: {
        UNIMPLEMENTED_IF_MSG(instr.atoms.operation == AtomicOp::Inc ||
                                 instr.atoms.operation == AtomicOp::Dec,
-                             "operation={}", static_cast<int>(instr.atoms.operation.Value()));
+                             "operation={}", instr.atoms.operation.Value());
        UNIMPLEMENTED_IF_MSG(instr.atoms.type == AtomicType::S64 ||
                                 instr.atoms.type == AtomicType::U64,
-                             "type={}", static_cast<int>(instr.atoms.type.Value()));
+                             "type={}", instr.atoms.type.Value());
        const bool is_signed =
            instr.atoms.type == AtomicType::S32 || instr.atoms.type == AtomicType::S64;
        const s32 offset = instr.atoms.GetImmediateOffset();
diff --git a/src/video_core/shader/decode/other.cpp b/src/video_core/shader/decode/other.cpp
index 29a7cfbfe..d3ea07aac 100644
--- a/src/video_core/shader/decode/other.cpp
+++ b/src/video_core/shader/decode/other.cpp
@@ -34,14 +34,13 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
        break;
    }
    case OpCode::Id::EXIT: {
-        const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
+        const ConditionCode cc = instr.flow_condition_code;
-        UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T, "EXIT condition code used: {}",
+        UNIMPLEMENTED_IF_MSG(cc != ConditionCode::T, "EXIT condition code used: {}", cc);
-                             static_cast<u32>(cc));
        switch (instr.flow.cond) {
        case Tegra::Shader::FlowCondition::Always:
            bb.push_back(Operation(OperationCode::Exit));
-            if (instr.pred.pred_index == static_cast<u64>(Tegra::Shader::Pred::UnusedIndex)) {
+            if (instr.pred.pred_index == static_cast<u64>(Pred::UnusedIndex)) {
                // If this is an unconditional exit then just end processing here,
                // otherwise we have to account for the possibility of the condition
                // not being met, so continue processing the next instruction.
@@ -56,17 +55,15 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
            break;
        default:
-            UNIMPLEMENTED_MSG("Unhandled flow condition: {}",
+            UNIMPLEMENTED_MSG("Unhandled flow condition: {}", instr.flow.cond.Value());
-                              static_cast<u32>(instr.flow.cond.Value()));
        }
        break;
    }
    case OpCode::Id::KIL: {
        UNIMPLEMENTED_IF(instr.flow.cond != Tegra::Shader::FlowCondition::Always);
-        const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
+        const ConditionCode cc = instr.flow_condition_code;
-        UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T, "KIL condition code used: {}",
+        UNIMPLEMENTED_IF_MSG(cc != ConditionCode::T, "KIL condition code used: {}", cc);
-                             static_cast<u32>(cc));
        bb.push_back(Operation(OperationCode::Discard));
        break;
@@ -90,11 +87,11 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
                UNIMPLEMENTED_MSG("S2R WscaleFactorZ is not implemented");
                return Immediate(0U);
            case SystemVariable::Tid: {
-                Node value = Immediate(0);
+                Node val = Immediate(0);
-                value = BitfieldInsert(value, Operation(OperationCode::LocalInvocationIdX), 0, 9);
+                val = BitfieldInsert(val, Operation(OperationCode::LocalInvocationIdX), 0, 9);
-                value = BitfieldInsert(value, Operation(OperationCode::LocalInvocationIdY), 16, 9);
+                val = BitfieldInsert(val, Operation(OperationCode::LocalInvocationIdY), 16, 9);
-                value = BitfieldInsert(value, Operation(OperationCode::LocalInvocationIdZ), 26, 5);
+                val = BitfieldInsert(val, Operation(OperationCode::LocalInvocationIdZ), 26, 5);
-                return value;
+                return val;
            }
            case SystemVariable::TidX:
                return Operation(OperationCode::LocalInvocationIdX);
@@ -130,8 +127,7 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
                    return Immediate(0u);
                }
            default:
-                UNIMPLEMENTED_MSG("Unhandled system move: {}",
+                UNIMPLEMENTED_MSG("Unhandled system move: {}", instr.sys20.Value());
-                                  static_cast<u32>(instr.sys20.Value()));
                return Immediate(0u);
            }
        }();
@@ -181,8 +177,8 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
        }
        const Node branch = Operation(OperationCode::BranchIndirect, operand);
-        const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
+        const ConditionCode cc = instr.flow_condition_code;
-        if (cc != Tegra::Shader::ConditionCode::T) {
+        if (cc != ConditionCode::T) {
            bb.push_back(Conditional(GetConditionCode(cc), {branch}));
        } else {
            bb.push_back(branch);
@@ -218,9 +214,8 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
        break;
    }
    case OpCode::Id::SYNC: {
-        const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
+        const ConditionCode cc = instr.flow_condition_code;
-        UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T, "SYNC condition code used: {}",
+        UNIMPLEMENTED_IF_MSG(cc != ConditionCode::T, "SYNC condition code used: {}", cc);
-                             static_cast<u32>(cc));
        if (decompiled) {
            break;
@@ -231,9 +226,8 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
        break;
    }
    case OpCode::Id::BRK: {
-        const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
+        const ConditionCode cc = instr.flow_condition_code;
-        UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T, "BRK condition code used: {}",
+        UNIMPLEMENTED_IF_MSG(cc != ConditionCode::T, "BRK condition code used: {}", cc);
-                             static_cast<u32>(cc));
        if (decompiled) {
            break;
        }
@@ -306,7 +300,7 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
            case Tegra::Shader::MembarType::GL:
                return OperationCode::MemoryBarrierGlobal;
            default:
-                UNIMPLEMENTED_MSG("MEMBAR type={}", static_cast<int>(instr.membar.type.Value()));
+                UNIMPLEMENTED_MSG("MEMBAR type={}", instr.membar.type.Value());
                return OperationCode::MemoryBarrierGlobal;
            }
        }();
diff --git a/src/video_core/shader/decode/shift.cpp b/src/video_core/shader/decode/shift.cpp
index d4ffa8014..a53819c15 100644
--- a/src/video_core/shader/decode/shift.cpp
+++ b/src/video_core/shader/decode/shift.cpp
@@ -125,7 +125,7 @@ u32 ShaderIR::DecodeShift(NodeBlock& bb, u32 pc) {
    case OpCode::Id::SHF_LEFT_IMM: {
        UNIMPLEMENTED_IF(instr.generates_cc);
        UNIMPLEMENTED_IF_MSG(instr.shf.xmode != ShfXmode::None, "xmode={}",
-                             static_cast<int>(instr.shf.xmode.Value()));
+                             instr.shf.xmode.Value());
        if (instr.is_b_imm) {
            op_b = Immediate(static_cast<u32>(instr.shf.immediate));
diff --git a/src/video_core/shader/decode/texture.cpp b/src/video_core/shader/decode/texture.cpp
index 02fdccd86..fb18f631f 100644
--- a/src/video_core/shader/decode/texture.cpp
+++ b/src/video_core/shader/decode/texture.cpp
@@ -34,7 +34,7 @@ static std::size_t GetCoordCount(TextureType texture_type) {
    case TextureType::TextureCube:
        return 3;
    default:
-        UNIMPLEMENTED_MSG("Unhandled texture type: {}", static_cast<u32>(texture_type));
+        UNIMPLEMENTED_MSG("Unhandled texture type: {}", texture_type);
        return 0;
    }
 }
@@ -255,8 +255,7 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
            break;
        }
        default:
-            UNIMPLEMENTED_MSG("Unhandled texture query type: {}",
+            UNIMPLEMENTED_MSG("Unhandled texture query type: {}", instr.txq.query_type.Value());
-                              static_cast<u32>(instr.txq.query_type.Value()));
        }
        break;
    }
@@ -302,7 +301,7 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
            case TextureType::TextureCube:
                return 3;
            default:
-                UNIMPLEMENTED_MSG("Unhandled texture type {}", static_cast<int>(texture_type));
+                UNIMPLEMENTED_MSG("Unhandled texture type {}", texture_type);
                return 2;
            }
        }();
@@ -595,7 +594,7 @@ Node4 ShaderIR::GetTextureCode(Instruction instr, TextureType texture_type,
        lod = GetRegister(instr.gpr20.Value() + bias_offset);
        break;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented process mode={}", static_cast<u32>(process_mode));
+        UNIMPLEMENTED_MSG("Unimplemented process mode={}", process_mode);
        break;
    }
diff --git a/src/video_core/shader/decode/warp.cpp b/src/video_core/shader/decode/warp.cpp
index 11b77f795..37433d783 100644
--- a/src/video_core/shader/decode/warp.cpp
+++ b/src/video_core/shader/decode/warp.cpp
@@ -27,7 +27,7 @@ OperationCode GetOperationCode(VoteOperation vote_op) {
    case VoteOperation::Eq:
        return OperationCode::VoteEqual;
    default:
-        UNREACHABLE_MSG("Invalid vote operation={}", static_cast<u64>(vote_op));
+        UNREACHABLE_MSG("Invalid vote operation={}", vote_op);
        return OperationCode::VoteAll;
    }
 }
diff --git a/src/video_core/shader/expr.h b/src/video_core/shader/expr.h
index 4e8264367..cda284c72 100644
--- a/src/video_core/shader/expr.h
+++ b/src/video_core/shader/expr.h
@@ -76,7 +76,7 @@ public:
 class ExprPredicate final {
 public:
-    explicit ExprPredicate(u32 predicate) : predicate{predicate} {}
+    explicit ExprPredicate(u32 predicate_) : predicate{predicate_} {}
    bool operator==(const ExprPredicate& b) const {
        return predicate == b.predicate;
@@ -91,7 +91,7 @@ public:
 class ExprCondCode final {
 public:
-    explicit ExprCondCode(ConditionCode cc) : cc{cc} {}
+    explicit ExprCondCode(ConditionCode condition_code) : cc{condition_code} {}
    bool operator==(const ExprCondCode& b) const {
        return cc == b.cc;
@@ -121,7 +121,7 @@ public:
 class ExprGprEqual final {
 public:
-    ExprGprEqual(u32 gpr, u32 value) : gpr{gpr}, value{value} {}
+    explicit ExprGprEqual(u32 gpr_, u32 value_) : gpr{gpr_}, value{value_} {}
    bool operator==(const ExprGprEqual& b) const {
        return gpr == b.gpr && value == b.value;
diff --git a/src/video_core/shader/node.h b/src/video_core/shader/node.h
index a1e2c4d8e..8db9e1de7 100644
--- a/src/video_core/shader/node.h
+++ b/src/video_core/shader/node.h
@@ -290,18 +290,18 @@ struct Sampler {
          is_buffer{is_buffer_}, is_indexed{is_indexed_} {}
    /// Separate sampler constructor
-    constexpr explicit Sampler(u32 index_, std::pair<u32, u32> offsets, std::pair<u32, u32> buffers,
+    constexpr explicit Sampler(u32 index_, std::pair<u32, u32> offsets_,
-                               Tegra::Shader::TextureType type, bool is_array_, bool is_shadow_,
+                               std::pair<u32, u32> buffers_, Tegra::Shader::TextureType type_,
-                               bool is_buffer_)
+                               bool is_array_, bool is_shadow_, bool is_buffer_)
-        : index{index_}, offset{offsets.first}, secondary_offset{offsets.second},
+        : index{index_}, offset{offsets_.first}, secondary_offset{offsets_.second},
-          buffer{buffers.first}, secondary_buffer{buffers.second}, type{type}, is_array{is_array_},
+          buffer{buffers_.first}, secondary_buffer{buffers_.second}, type{type_},
-          is_shadow{is_shadow_}, is_buffer{is_buffer_}, is_separated{true} {}
+          is_array{is_array_}, is_shadow{is_shadow_}, is_buffer{is_buffer_}, is_separated{true} {}
    /// Bindless samplers constructor
    constexpr explicit Sampler(u32 index_, u32 offset_, u32 buffer_,
-                               Tegra::Shader::TextureType type, bool is_array_, bool is_shadow_,
+                               Tegra::Shader::TextureType type_, bool is_array_, bool is_shadow_,
                               bool is_buffer_, bool is_indexed_)
-        : index{index_}, offset{offset_}, buffer{buffer_}, type{type}, is_array{is_array_},
+        : index{index_}, offset{offset_}, buffer{buffer_}, type{type_}, is_array{is_array_},
          is_shadow{is_shadow_}, is_buffer{is_buffer_}, is_bindless{true}, is_indexed{is_indexed_} {
    }
diff --git a/src/video_core/shader/node_helper.cpp b/src/video_core/shader/node_helper.cpp
index 7bf4ff387..6a5b6940d 100644
--- a/src/video_core/shader/node_helper.cpp
+++ b/src/video_core/shader/node_helper.cpp
@@ -107,7 +107,7 @@ OperationCode SignedToUnsignedCode(OperationCode operation_code, bool is_signed)
        UNREACHABLE_MSG("Can't apply absolute to an unsigned integer");
        return {};
    default:
-        UNREACHABLE_MSG("Unknown signed operation with code={}", static_cast<u32>(operation_code));
+        UNREACHABLE_MSG("Unknown signed operation with code={}", operation_code);
        return {};
    }
 }
diff --git a/src/video_core/shader/shader_ir.cpp b/src/video_core/shader/shader_ir.cpp
index 29d794b34..a4987ffc6 100644
--- a/src/video_core/shader/shader_ir.cpp
+++ b/src/video_core/shader/shader_ir.cpp
@@ -25,9 +25,10 @@ using Tegra::Shader::PredCondition;
 using Tegra::Shader::PredOperation;
 using Tegra::Shader::Register;
-ShaderIR::ShaderIR(const ProgramCode& program_code, u32 main_offset, CompilerSettings settings,
+ShaderIR::ShaderIR(const ProgramCode& program_code_, u32 main_offset_, CompilerSettings settings_,
-                   Registry& registry)
+                   Registry& registry_)
-    : program_code{program_code}, main_offset{main_offset}, settings{settings}, registry{registry} {
+    : program_code{program_code_}, main_offset{main_offset_}, settings{settings_}, registry{
+                                                                                       registry_} {
    Decode();
    PostDecode();
 }
@@ -170,7 +171,7 @@ Node ShaderIR::ConvertIntegerSize(Node value, Register::Size size, bool is_signe
        // Default - do nothing
        return value;
    default:
-        UNREACHABLE_MSG("Unimplemented conversion size: {}", static_cast<u32>(size));
+        UNREACHABLE_MSG("Unimplemented conversion size: {}", size);
        return value;
    }
 }
@@ -335,15 +336,15 @@ OperationCode ShaderIR::GetPredicateCombiner(PredOperation operation) {
    return operation_table[index];
 }
-Node ShaderIR::GetConditionCode(Tegra::Shader::ConditionCode cc) const {
+Node ShaderIR::GetConditionCode(ConditionCode cc) const {
    switch (cc) {
-    case Tegra::Shader::ConditionCode::NEU:
+    case ConditionCode::NEU:
        return GetInternalFlag(InternalFlag::Zero, true);
-    case Tegra::Shader::ConditionCode::FCSM_TR:
+    case ConditionCode::FCSM_TR:
        UNIMPLEMENTED_MSG("EXIT.FCSM_TR is not implemented");
        return MakeNode<PredicateNode>(Pred::NeverExecute, false);
    default:
-        UNIMPLEMENTED_MSG("Unimplemented condition code: {}", static_cast<u32>(cc));
+        UNIMPLEMENTED_MSG("Unimplemented condition code: {}", cc);
        return MakeNode<PredicateNode>(Pred::NeverExecute, false);
    }
 }
@@ -451,8 +452,8 @@ void ShaderIR::MarkAttributeUsage(Attribute::Index index, u64 element) {
 }
 std::size_t ShaderIR::DeclareAmend(Node new_amend) {
-    const std::size_t id = amend_code.size();
+    const auto id = amend_code.size();
-    amend_code.push_back(new_amend);
+    amend_code.push_back(std::move(new_amend));
    return id;
 }
diff --git a/src/video_core/shader/shader_ir.h b/src/video_core/shader/shader_ir.h
index 3a98b2104..6aae14e34 100644
--- a/src/video_core/shader/shader_ir.h
+++ b/src/video_core/shader/shader_ir.h
@@ -29,8 +29,8 @@ struct ShaderBlock;
 constexpr u32 MAX_PROGRAM_LENGTH = 0x1000;
 struct ConstBuffer {
-    constexpr explicit ConstBuffer(u32 max_offset, bool is_indirect)
+    constexpr explicit ConstBuffer(u32 max_offset_, bool is_indirect_)
-        : max_offset{max_offset}, is_indirect{is_indirect} {}
+        : max_offset{max_offset_}, is_indirect{is_indirect_} {}
    constexpr ConstBuffer() = default;
@@ -66,8 +66,8 @@ struct GlobalMemoryUsage {
 class ShaderIR final {
 public:
-    explicit ShaderIR(const ProgramCode& program_code, u32 main_offset, CompilerSettings settings,
+    explicit ShaderIR(const ProgramCode& program_code_, u32 main_offset_,
-                      Registry& registry);
+                      CompilerSettings settings_, Registry& registry_);
    ~ShaderIR();
    const std::map<u32, NodeBlock>& GetBasicBlocks() const {
diff --git a/src/video_core/surface.cpp b/src/video_core/surface.cpp
index 1688267bb..937e29d1e 100644
--- a/src/video_core/surface.cpp
+++ b/src/video_core/surface.cpp
@@ -28,7 +28,7 @@ SurfaceTarget SurfaceTargetFromTextureType(Tegra::Texture::TextureType texture_t
    case Tegra::Texture::TextureType::Texture2DArray:
        return SurfaceTarget::Texture2DArray;
    default:
-        LOG_CRITICAL(HW_GPU, "Unimplemented texture_type={}", static_cast<u32>(texture_type));
+        LOG_CRITICAL(HW_GPU, "Unimplemented texture_type={}", texture_type);
        UNREACHABLE();
        return SurfaceTarget::Texture2D;
    }
@@ -47,7 +47,7 @@ bool SurfaceTargetIsLayered(SurfaceTarget target) {
    case SurfaceTarget::TextureCubeArray:
        return true;
    default:
-        LOG_CRITICAL(HW_GPU, "Unimplemented surface_target={}", static_cast<u32>(target));
+        LOG_CRITICAL(HW_GPU, "Unimplemented surface_target={}", target);
        UNREACHABLE();
        return false;
    }
@@ -66,7 +66,7 @@ bool SurfaceTargetIsArray(SurfaceTarget target) {
    case SurfaceTarget::TextureCubeArray:
        return true;
    default:
-        LOG_CRITICAL(HW_GPU, "Unimplemented surface_target={}", static_cast<u32>(target));
+        LOG_CRITICAL(HW_GPU, "Unimplemented surface_target={}", target);
        UNREACHABLE();
        return false;
    }
@@ -85,7 +85,7 @@ PixelFormat PixelFormatFromDepthFormat(Tegra::DepthFormat format) {
    case Tegra::DepthFormat::D32_FLOAT_S8X24_UINT:
        return PixelFormat::D32_FLOAT_S8_UINT;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented format={}", static_cast<u32>(format));
+        UNIMPLEMENTED_MSG("Unimplemented format={}", format);
        return PixelFormat::S8_UINT_D24_UNORM;
    }
 }
@@ -183,7 +183,7 @@ PixelFormat PixelFormatFromRenderTargetFormat(Tegra::RenderTargetFormat format)
    case Tegra::RenderTargetFormat::R8_UINT:
        return PixelFormat::R8_UINT;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented format={}", static_cast<int>(format));
+        UNIMPLEMENTED_MSG("Unimplemented format={}", format);
        return PixelFormat::A8B8G8R8_UNORM;
    }
 }
@@ -197,7 +197,7 @@ PixelFormat PixelFormatFromGPUPixelFormat(Tegra::FramebufferConfig::PixelFormat
    case Tegra::FramebufferConfig::PixelFormat::B8G8R8A8_UNORM:
        return PixelFormat::B8G8R8A8_UNORM;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented format={}", static_cast<u32>(format));
+        UNIMPLEMENTED_MSG("Unimplemented format={}", format);
        return PixelFormat::A8B8G8R8_UNORM;
    }
 }
diff --git a/src/video_core/texture_cache/copy_params.h b/src/video_core/texture_cache/copy_params.h
index 9c21a0649..5b475fe06 100644
--- a/src/video_core/texture_cache/copy_params.h
+++ b/src/video_core/texture_cache/copy_params.h
@@ -9,16 +9,16 @@
 namespace VideoCommon {
 struct CopyParams {
-    constexpr CopyParams(u32 source_x, u32 source_y, u32 source_z, u32 dest_x, u32 dest_y,
+    constexpr CopyParams(u32 source_x_, u32 source_y_, u32 source_z_, u32 dest_x_, u32 dest_y_,
-                         u32 dest_z, u32 source_level, u32 dest_level, u32 width, u32 height,
+                         u32 dest_z_, u32 source_level_, u32 dest_level_, u32 width_, u32 height_,
-                         u32 depth)
+                         u32 depth_)
-        : source_x{source_x}, source_y{source_y}, source_z{source_z}, dest_x{dest_x},
+        : source_x{source_x_}, source_y{source_y_}, source_z{source_z_}, dest_x{dest_x_},
-          dest_y{dest_y}, dest_z{dest_z}, source_level{source_level},
+          dest_y{dest_y_}, dest_z{dest_z_}, source_level{source_level_},
-          dest_level{dest_level}, width{width}, height{height}, depth{depth} {}
+          dest_level{dest_level_}, width{width_}, height{height_}, depth{depth_} {}
-    constexpr CopyParams(u32 width, u32 height, u32 depth, u32 level)
+    constexpr CopyParams(u32 width_, u32 height_, u32 depth_, u32 level_)
-        : source_x{}, source_y{}, source_z{}, dest_x{}, dest_y{}, dest_z{}, source_level{level},
+        : source_x{}, source_y{}, source_z{}, dest_x{}, dest_y{}, dest_z{}, source_level{level_},
-          dest_level{level}, width{width}, height{height}, depth{depth} {}
+          dest_level{level_}, width{width_}, height{height_}, depth{depth_} {}
    u32 source_x;
    u32 source_y;
diff --git a/src/video_core/texture_cache/format_lookup_table.cpp b/src/video_core/texture_cache/format_lookup_table.cpp
index 7d5a75648..7938d71eb 100644
--- a/src/video_core/texture_cache/format_lookup_table.cpp
+++ b/src/video_core/texture_cache/format_lookup_table.cpp
@@ -24,12 +24,12 @@ constexpr bool C = false; // Normal color
 constexpr bool S = true;  // Srgb
 struct Table {
-    constexpr Table(TextureFormat texture_format, bool is_srgb, ComponentType red_component,
+    constexpr Table(TextureFormat texture_format_, bool is_srgb_, ComponentType red_component_,
-                    ComponentType green_component, ComponentType blue_component,
+                    ComponentType green_component_, ComponentType blue_component_,
-                    ComponentType alpha_component, PixelFormat pixel_format)
+                    ComponentType alpha_component_, PixelFormat pixel_format_)
-        : texture_format{texture_format}, pixel_format{pixel_format}, red_component{red_component},
+        : texture_format{texture_format_}, pixel_format{pixel_format_},
-          green_component{green_component}, blue_component{blue_component},
+          red_component{red_component_}, green_component{green_component_},
-          alpha_component{alpha_component}, is_srgb{is_srgb} {}
+          blue_component{blue_component_}, alpha_component{alpha_component_}, is_srgb{is_srgb_} {}
    TextureFormat texture_format;
    PixelFormat pixel_format;
diff --git a/src/video_core/texture_cache/surface_base.cpp b/src/video_core/texture_cache/surface_base.cpp
index b44c09d71..efbcf6723 100644
--- a/src/video_core/texture_cache/surface_base.cpp
+++ b/src/video_core/texture_cache/surface_base.cpp
@@ -25,11 +25,11 @@ StagingCache::StagingCache() = default;
 StagingCache::~StagingCache() = default;
-SurfaceBaseImpl::SurfaceBaseImpl(GPUVAddr gpu_addr, const SurfaceParams& params,
+SurfaceBaseImpl::SurfaceBaseImpl(GPUVAddr gpu_addr_, const SurfaceParams& params_,
-                                 bool is_astc_supported)
+                                 bool is_astc_supported_)
-    : params{params}, gpu_addr{gpu_addr}, mipmap_sizes(params.num_levels),
+    : params{params_}, gpu_addr{gpu_addr_}, mipmap_sizes(params_.num_levels),
      mipmap_offsets(params.num_levels) {
-    is_converted = IsPixelFormatASTC(params.pixel_format) && !is_astc_supported;
+    is_converted = IsPixelFormatASTC(params.pixel_format) && !is_astc_supported_;
    host_memory_size = params.GetHostSizeInBytes(is_converted);
    std::size_t offset = 0;
@@ -167,27 +167,28 @@ std::vector<CopyParams> SurfaceBaseImpl::BreakDownNonLayered(const SurfaceParams
    return result;
 }
-void SurfaceBaseImpl::SwizzleFunc(MortonSwizzleMode mode, u8* memory, const SurfaceParams& params,
+void SurfaceBaseImpl::SwizzleFunc(MortonSwizzleMode mode, u8* memory,
-                                  u8* buffer, u32 level) {
+                                  const SurfaceParams& surface_params, u8* buffer, u32 level) {
-    const u32 width{params.GetMipWidth(level)};
+    const u32 width{surface_params.GetMipWidth(level)};
-    const u32 height{params.GetMipHeight(level)};
+    const u32 height{surface_params.GetMipHeight(level)};
-    const u32 block_height{params.GetMipBlockHeight(level)};
+    const u32 block_height{surface_params.GetMipBlockHeight(level)};
-    const u32 block_depth{params.GetMipBlockDepth(level)};
+    const u32 block_depth{surface_params.GetMipBlockDepth(level)};
    std::size_t guest_offset{mipmap_offsets[level]};
-    if (params.is_layered) {
+    if (surface_params.is_layered) {
        std::size_t host_offset = 0;
        const std::size_t guest_stride = layer_size;
-        const std::size_t host_stride = params.GetHostLayerSize(level);
+        const std::size_t host_stride = surface_params.GetHostLayerSize(level);
-        for (u32 layer = 0; layer < params.depth; ++layer) {
+        for (u32 layer = 0; layer < surface_params.depth; ++layer) {
-            MortonSwizzle(mode, params.pixel_format, width, block_height, height, block_depth, 1,
+            MortonSwizzle(mode, surface_params.pixel_format, width, block_height, height,
-                          params.tile_width_spacing, buffer + host_offset, memory + guest_offset);
+                          block_depth, 1, surface_params.tile_width_spacing, buffer + host_offset,
+                          memory + guest_offset);
            guest_offset += guest_stride;
            host_offset += host_stride;
        }
    } else {
-        MortonSwizzle(mode, params.pixel_format, width, block_height, height, block_depth,
+        MortonSwizzle(mode, surface_params.pixel_format, width, block_height, height, block_depth,
-                      params.GetMipDepth(level), params.tile_width_spacing, buffer,
+                      surface_params.GetMipDepth(level), surface_params.tile_width_spacing, buffer,
                      memory + guest_offset);
    }
 }
diff --git a/src/video_core/texture_cache/surface_base.h b/src/video_core/texture_cache/surface_base.h
index 173f2edba..b57135fe4 100644
--- a/src/video_core/texture_cache/surface_base.h
+++ b/src/video_core/texture_cache/surface_base.h
@@ -148,8 +148,8 @@ public:
    }
 protected:
-    explicit SurfaceBaseImpl(GPUVAddr gpu_addr, const SurfaceParams& params,
+    explicit SurfaceBaseImpl(GPUVAddr gpu_addr_, const SurfaceParams& params_,
-                             bool is_astc_supported);
+                             bool is_astc_supported_);
    ~SurfaceBaseImpl() = default;
    virtual void DecorateSurfaceName() = 0;
@@ -167,8 +167,8 @@ protected:
    std::vector<std::size_t> mipmap_offsets;
 private:
-    void SwizzleFunc(MortonSwizzleMode mode, u8* memory, const SurfaceParams& params, u8* buffer,
+    void SwizzleFunc(MortonSwizzleMode mode, u8* memory, const SurfaceParams& surface_params,
-                     u32 level);
+                     u8* buffer, u32 level);
    std::vector<CopyParams> BreakDownLayered(const SurfaceParams& in_params) const;
@@ -297,9 +297,9 @@ public:
    }
 protected:
-    explicit SurfaceBase(const GPUVAddr gpu_addr, const SurfaceParams& params,
+    explicit SurfaceBase(const GPUVAddr gpu_addr_, const SurfaceParams& params_,
-                         bool is_astc_supported)
+                         bool is_astc_supported_)
-        : SurfaceBaseImpl(gpu_addr, params, is_astc_supported) {}
+        : SurfaceBaseImpl{gpu_addr_, params_, is_astc_supported_} {}
    ~SurfaceBase() = default;
diff --git a/src/video_core/texture_cache/surface_params.cpp b/src/video_core/texture_cache/surface_params.cpp
index 13dd16356..96f93246d 100644
--- a/src/video_core/texture_cache/surface_params.cpp
+++ b/src/video_core/texture_cache/surface_params.cpp
@@ -356,18 +356,18 @@ std::size_t SurfaceParams::GetLayerSize(bool as_host_size, bool uncompressed) co
 std::size_t SurfaceParams::GetInnerMipmapMemorySize(u32 level, bool as_host_size,
                                                    bool uncompressed) const {
-    const u32 width{GetMipmapSize(uncompressed, GetMipWidth(level), GetDefaultBlockWidth())};
+    const u32 mip_width{GetMipmapSize(uncompressed, GetMipWidth(level), GetDefaultBlockWidth())};
-    const u32 height{GetMipmapSize(uncompressed, GetMipHeight(level), GetDefaultBlockHeight())};
+    const u32 mip_height{GetMipmapSize(uncompressed, GetMipHeight(level), GetDefaultBlockHeight())};
-    const u32 depth{is_layered ? 1U : GetMipDepth(level)};
+    const u32 mip_depth{is_layered ? 1U : GetMipDepth(level)};
    if (is_tiled) {
-        return Tegra::Texture::CalculateSize(!as_host_size, GetBytesPerPixel(), width, height,
+        return Tegra::Texture::CalculateSize(!as_host_size, GetBytesPerPixel(), mip_width,
-                                             depth, GetMipBlockHeight(level),
+                                             mip_height, mip_depth, GetMipBlockHeight(level),
                                             GetMipBlockDepth(level));
    } else if (as_host_size || IsBuffer()) {
-        return GetBytesPerPixel() * width * height * depth;
+        return GetBytesPerPixel() * mip_width * mip_height * mip_depth;
    } else {
        // Linear Texture Case
-        return pitch * height * depth;
+        return pitch * mip_height * mip_depth;
    }
 }
@@ -398,9 +398,9 @@ std::string SurfaceParams::TargetName() const {
    case SurfaceTarget::TextureCubeArray:
        return "CubeArray";
    default:
-        LOG_CRITICAL(HW_GPU, "Unimplemented surface_target={}", static_cast<u32>(target));
+        LOG_CRITICAL(HW_GPU, "Unimplemented surface_target={}", target);
        UNREACHABLE();
-        return fmt::format("TUK({})", static_cast<u32>(target));
+        return fmt::format("TUK({})", target);
    }
 }
diff --git a/src/video_core/texture_cache/surface_view.h b/src/video_core/texture_cache/surface_view.h
index 90a8bb0ae..199f72732 100644
--- a/src/video_core/texture_cache/surface_view.h
+++ b/src/video_core/texture_cache/surface_view.h
@@ -13,10 +13,10 @@
 namespace VideoCommon {
 struct ViewParams {
-    constexpr explicit ViewParams(VideoCore::Surface::SurfaceTarget target, u32 base_layer,
+    constexpr explicit ViewParams(VideoCore::Surface::SurfaceTarget target_, u32 base_layer_,
-                                  u32 num_layers, u32 base_level, u32 num_levels)
+                                  u32 num_layers_, u32 base_level_, u32 num_levels_)
-        : target{target}, base_layer{base_layer}, num_layers{num_layers}, base_level{base_level},
+        : target{target_}, base_layer{base_layer_}, num_layers{num_layers_},
-          num_levels{num_levels} {}
+          base_level{base_level_}, num_levels{num_levels_} {}
    std::size_t Hash() const;
@@ -44,7 +44,7 @@ struct ViewParams {
 class ViewBase {
 public:
-    constexpr explicit ViewBase(const ViewParams& params) : params{params} {}
+    constexpr explicit ViewBase(const ViewParams& view_params) : params{view_params} {}
    constexpr const ViewParams& GetViewParams() const {
        return params;
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index ea835c59f..581d8dd5b 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -1191,9 +1191,8 @@ private:
        const SurfaceParams& src_params = src->GetSurfaceParams();
        const SurfaceParams& dst_params = dst->GetSurfaceParams();
        if (!format_compatibility.TestCopy(src_params.pixel_format, dst_params.pixel_format)) {
-            LOG_ERROR(HW_GPU, "Illegal copy between formats={{{}, {}}}",
+            LOG_ERROR(HW_GPU, "Illegal copy between formats={{{}, {}}}", dst_params.pixel_format,
-                      static_cast<int>(dst_params.pixel_format),
+                      src_params.pixel_format);
-                      static_cast<int>(src_params.pixel_format));
            return;
        }
        ImageCopy(src, dst, copy);
diff --git a/src/video_core/textures/convert.cpp b/src/video_core/textures/convert.cpp
index 962921483..bd1aebf02 100644
--- a/src/video_core/textures/convert.cpp
+++ b/src/video_core/textures/convert.cpp
@@ -82,7 +82,7 @@ void ConvertFromHostToGuest(u8* data, PixelFormat pixel_format, u32 width, u32 h
                            bool convert_astc, bool convert_s8z24) {
    if (convert_astc && IsPixelFormatASTC(pixel_format)) {
        LOG_CRITICAL(HW_GPU, "Conversion of format {} after texture flushing is not implemented",
-                     static_cast<u32>(pixel_format));
+                     pixel_format);
        UNREACHABLE();
    } else if (convert_s8z24 && pixel_format == PixelFormat::S8_UINT_D24_UNORM) {
diff --git a/src/video_core/textures/texture.h b/src/video_core/textures/texture.h
index 0574fef12..bbc7e3eaf 100644
--- a/src/video_core/textures/texture.h
+++ b/src/video_core/textures/texture.h
@@ -146,7 +146,7 @@ enum class MsaaMode : u32 {
 };
 union TextureHandle {
-    TextureHandle(u32 raw) : raw{raw} {}
+    /* implicit */ TextureHandle(u32 raw_) : raw{raw_} {}
    u32 raw;
    BitField<0, 20, u32> tic_id;
diff --git a/src/yuzu/applets/controller.cpp b/src/yuzu/applets/controller.cpp
index 6944478f3..a15e8ca2a 100644
--- a/src/yuzu/applets/controller.cpp
+++ b/src/yuzu/applets/controller.cpp
@@ -660,8 +660,8 @@ QtControllerSelector::QtControllerSelector(GMainWindow& parent) {
 QtControllerSelector::~QtControllerSelector() = default;
 void QtControllerSelector::ReconfigureControllers(
-    std::function<void()> callback, const Core::Frontend::ControllerParameters& parameters) const {
+    std::function<void()> callback_, const Core::Frontend::ControllerParameters& parameters) const {
-    this->callback = std::move(callback);
+    callback = std::move(callback_);
    emit MainWindowReconfigureControllers(parameters);
 }
diff --git a/src/yuzu/applets/controller.h b/src/yuzu/applets/controller.h
index 7a421d856..3518eed56 100644
--- a/src/yuzu/applets/controller.h
+++ b/src/yuzu/applets/controller.h
@@ -147,7 +147,7 @@ public:
    ~QtControllerSelector() override;
    void ReconfigureControllers(
-        std::function<void()> callback,
+        std::function<void()> callback_,
        const Core::Frontend::ControllerParameters& parameters) const override;
 signals:
diff --git a/src/yuzu/applets/error.cpp b/src/yuzu/applets/error.cpp
index 08ed57355..53a993cf6 100644
--- a/src/yuzu/applets/error.cpp
+++ b/src/yuzu/applets/error.cpp
@@ -17,7 +17,7 @@ QtErrorDisplay::QtErrorDisplay(GMainWindow& parent) {
 QtErrorDisplay::~QtErrorDisplay() = default;
 void QtErrorDisplay::ShowError(ResultCode error, std::function<void()> finished) const {
-    this->callback = std::move(finished);
+    callback = std::move(finished);
    emit MainWindowDisplayError(
        tr("An error has occured.\nPlease try again or contact the developer of the "
           "software.\n\nError Code: %1-%2 (0x%3)")
@@ -28,7 +28,7 @@ void QtErrorDisplay::ShowError(ResultCode error, std::function<void()> finished)
 void QtErrorDisplay::ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
                                            std::function<void()> finished) const {
-    this->callback = std::move(finished);
+    callback = std::move(finished);
    const QDateTime date_time = QDateTime::fromSecsSinceEpoch(time.count());
    emit MainWindowDisplayError(
@@ -44,7 +44,7 @@ void QtErrorDisplay::ShowErrorWithTimestamp(ResultCode error, std::chrono::secon
 void QtErrorDisplay::ShowCustomErrorText(ResultCode error, std::string dialog_text,
                                         std::string fullscreen_text,
                                         std::function<void()> finished) const {
-    this->callback = std::move(finished);
+    callback = std::move(finished);
    emit MainWindowDisplayError(
        tr("An error has occured.\nError Code: %1-%2 (0x%3)\n\n%4\n\n%5")
            .arg(static_cast<u32>(error.module.Value()) + 2000, 4, 10, QChar::fromLatin1('0'))
diff --git a/src/yuzu/applets/profile_select.cpp b/src/yuzu/applets/profile_select.cpp
index c9a2f8601..4bf2bfd40 100644
--- a/src/yuzu/applets/profile_select.cpp
+++ b/src/yuzu/applets/profile_select.cpp
@@ -150,8 +150,8 @@ QtProfileSelector::QtProfileSelector(GMainWindow& parent) {
 QtProfileSelector::~QtProfileSelector() = default;
 void QtProfileSelector::SelectProfile(
-    std::function<void(std::optional<Common::UUID>)> callback) const {
+    std::function<void(std::optional<Common::UUID>)> callback_) const {
-    this->callback = std::move(callback);
+    callback = std::move(callback_);
    emit MainWindowSelectProfile();
 }
diff --git a/src/yuzu/applets/profile_select.h b/src/yuzu/applets/profile_select.h
index 29c33cca0..4e9037488 100644
--- a/src/yuzu/applets/profile_select.h
+++ b/src/yuzu/applets/profile_select.h
@@ -60,7 +60,7 @@ public:
    explicit QtProfileSelector(GMainWindow& parent);
    ~QtProfileSelector() override;
-    void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const override;
+    void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback_) const override;
 signals:
    void MainWindowSelectProfile() const;
diff --git a/src/yuzu/applets/software_keyboard.cpp b/src/yuzu/applets/software_keyboard.cpp
index af36f07c6..ab8cfd8ee 100644
--- a/src/yuzu/applets/software_keyboard.cpp
+++ b/src/yuzu/applets/software_keyboard.cpp
@@ -135,8 +135,8 @@ void QtSoftwareKeyboard::RequestText(std::function<void(std::optional<std::u16st
 }
 void QtSoftwareKeyboard::SendTextCheckDialog(std::u16string error_message,
-                                             std::function<void()> finished_check) const {
+                                             std::function<void()> finished_check_) const {
-    this->finished_check = std::move(finished_check);
+    finished_check = std::move(finished_check_);
    emit MainWindowTextCheckDialog(error_message);
 }
diff --git a/src/yuzu/applets/software_keyboard.h b/src/yuzu/applets/software_keyboard.h
index 44bcece75..9e1094cce 100644
--- a/src/yuzu/applets/software_keyboard.h
+++ b/src/yuzu/applets/software_keyboard.h
@@ -61,7 +61,7 @@ public:
    void RequestText(std::function<void(std::optional<std::u16string>)> out,
                     Core::Frontend::SoftwareKeyboardParameters parameters) const override;
    void SendTextCheckDialog(std::u16string error_message,
-                             std::function<void()> finished_check) const override;
+                             std::function<void()> finished_check_) const override;
 signals:
    void MainWindowGetText(Core::Frontend::SoftwareKeyboardParameters parameters) const;
diff --git a/src/yuzu/applets/web_browser.cpp b/src/yuzu/applets/web_browser.cpp
index 33f1c385d..9fd8d6326 100644
--- a/src/yuzu/applets/web_browser.cpp
+++ b/src/yuzu/applets/web_browser.cpp
@@ -87,10 +87,10 @@ QtWebBrowser::QtWebBrowser(GMainWindow& main_window) {
 QtWebBrowser::~QtWebBrowser() = default;
-void QtWebBrowser::OpenPageLocal(std::string_view url, std::function<void()> unpack_romfs_callback,
+void QtWebBrowser::OpenPageLocal(std::string_view url, std::function<void()> unpack_romfs_callback_,
-                                 std::function<void()> finished_callback) {
+                                 std::function<void()> finished_callback_) {
-    this->unpack_romfs_callback = std::move(unpack_romfs_callback);
+    unpack_romfs_callback = std::move(unpack_romfs_callback_);
-    this->finished_callback = std::move(finished_callback);
+    finished_callback = std::move(finished_callback_);
    const auto index = url.find('?');
    if (index == std::string::npos) {
diff --git a/src/yuzu/applets/web_browser.h b/src/yuzu/applets/web_browser.h
index b38437e46..f801846cf 100644
--- a/src/yuzu/applets/web_browser.h
+++ b/src/yuzu/applets/web_browser.h
@@ -37,8 +37,8 @@ public:
    explicit QtWebBrowser(GMainWindow& main_window);
    ~QtWebBrowser() override;
-    void OpenPageLocal(std::string_view url, std::function<void()> unpack_romfs_callback,
+    void OpenPageLocal(std::string_view url, std::function<void()> unpack_romfs_callback_,
-                       std::function<void()> finished_callback) override;
+                       std::function<void()> finished_callback_) override;
 signals:
    void MainWindowOpenPage(std::string_view filename, std::string_view additional_args) const;
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index fcc38b3af..0ec5b861a 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -511,6 +511,9 @@ void Config::ReadControlValues() {
    ReadTouchscreenValues();
    ReadMotionTouchValues();
+    Settings::values.emulate_analog_keyboard =
+        ReadSetting(QStringLiteral("emulate_analog_keyboard"), false).toBool();
    ReadSettingGlobal(Settings::values.use_docked_mode, QStringLiteral("use_docked_mode"), false);
    ReadSettingGlobal(Settings::values.vibration_enabled, QStringLiteral("vibration_enabled"),
                      true);
@@ -1186,6 +1189,8 @@ void Config::SaveControlValues() {
                 QString::fromStdString(Settings::values.touch_device),
                 QStringLiteral("engine:emu_window"));
    WriteSetting(QStringLiteral("keyboard_enabled"), Settings::values.keyboard_enabled, false);
+    WriteSetting(QStringLiteral("emulate_analog_keyboard"),
+                 Settings::values.emulate_analog_keyboard, false);
    qt_config->endGroup();
 }
diff --git a/src/yuzu/configuration/configure_input_advanced.cpp b/src/yuzu/configuration/configure_input_advanced.cpp
index abaf03630..4e557bc6f 100644
--- a/src/yuzu/configuration/configure_input_advanced.cpp
+++ b/src/yuzu/configuration/configure_input_advanced.cpp
@@ -121,6 +121,7 @@ void ConfigureInputAdvanced::ApplyConfiguration() {
    Settings::values.debug_pad_enabled = ui->debug_enabled->isChecked();
    Settings::values.mouse_enabled = ui->mouse_enabled->isChecked();
    Settings::values.keyboard_enabled = ui->keyboard_enabled->isChecked();
+    Settings::values.emulate_analog_keyboard = ui->emulate_analog_keyboard->isChecked();
    Settings::values.touchscreen.enabled = ui->touchscreen_enabled->isChecked();
 }
@@ -147,6 +148,7 @@ void ConfigureInputAdvanced::LoadConfiguration() {
    ui->debug_enabled->setChecked(Settings::values.debug_pad_enabled);
    ui->mouse_enabled->setChecked(Settings::values.mouse_enabled);
    ui->keyboard_enabled->setChecked(Settings::values.keyboard_enabled);
+    ui->emulate_analog_keyboard->setChecked(Settings::values.emulate_analog_keyboard);
    ui->touchscreen_enabled->setChecked(Settings::values.touchscreen.enabled);
    UpdateUIEnabled();
diff --git a/src/yuzu/configuration/configure_input_advanced.ui b/src/yuzu/configuration/configure_input_advanced.ui
index a880a7c68..f207e5d3b 100644
--- a/src/yuzu/configuration/configure_input_advanced.ui
+++ b/src/yuzu/configuration/configure_input_advanced.ui
@@ -2546,14 +2546,27 @@
                 </property>
                </widget>
               </item>
-               <item row="4" column="2">
+               <item row="1" column="0">
+                 <widget class="QCheckBox" name="emulate_analog_keyboard">
+                   <property name="minimumSize">
+                     <size>
+                       <width>0</width>
+                       <height>23</height>
+                     </size>
+                   </property>
+                   <property name="text">
+                     <string>Emulate Analog with Keyboard Input</string>
+                   </property>
+                 </widget>
+               </item>
+               <item row="5" column="2">
                <widget class="QPushButton" name="touchscreen_advanced">
                 <property name="text">
                  <string>Advanced</string>
                 </property>
                </widget>
               </item>
-               <item row="1" column="1">
+               <item row="2" column="1">
                <spacer name="horizontalSpacer_8">
                 <property name="orientation">
                  <enum>Qt::Horizontal</enum>
@@ -2569,21 +2582,21 @@
                 </property>
                </spacer>
               </item>
-               <item row="1" column="2">
+               <item row="2" column="2">
                <widget class="QPushButton" name="mouse_advanced">
                 <property name="text">
                  <string>Advanced</string>
                 </property>
                </widget>
               </item>
-               <item row="4" column="0">
+               <item row="5" column="0">
                <widget class="QCheckBox" name="touchscreen_enabled">
                 <property name="text">
                  <string>Touchscreen</string>
                 </property>
                </widget>
               </item>
-               <item row="1" column="0">
+               <item row="2" column="0">
                <widget class="QCheckBox" name="mouse_enabled">
                 <property name="minimumSize">
                  <size>
@@ -2596,28 +2609,28 @@
                 </property>
                </widget>
               </item>
-               <item row="6" column="0">
+               <item row="7" column="0">
                <widget class="QLabel" name="motion_touch">
                 <property name="text">
                  <string>Motion / Touch</string>
                 </property>
                </widget>
               </item>
-               <item row="6" column="2">
+               <item row="7" column="2">
                <widget class="QPushButton" name="buttonMotionTouch">
                 <property name="text">
                  <string>Configure</string>
                 </property>
                </widget>
               </item>
-               <item row="5" column="0">
+               <item row="6" column="0">
                <widget class="QCheckBox" name="debug_enabled">
                 <property name="text">
                  <string>Debug Controller</string>
                 </property>
                </widget>
               </item>
-               <item row="5" column="2">
+               <item row="6" column="2">
                <widget class="QPushButton" name="debug_configure">
                 <property name="text">
                  <string>Configure</string>
diff --git a/src/yuzu/configuration/configure_motion_touch.cpp b/src/yuzu/configuration/configure_motion_touch.cpp
index 2afac591a..c2a7113da 100644
--- a/src/yuzu/configuration/configure_motion_touch.cpp
+++ b/src/yuzu/configuration/configure_motion_touch.cpp
@@ -183,8 +183,8 @@ void ConfigureMotionTouch::ConnectEvents() {
 }
 void ConfigureMotionTouch::OnUDPAddServer() {
-    QRegExp re(tr("^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?["
+    QRegExp re(tr(R"re(^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4]"
-                  "0-9][0-9]?)$")); // a valid ip address
+                  "[0-9]|[01]?[0-9][0-9]?)$)re")); // a valid ip address
    bool ok;
    QString port_text = ui->udp_port->text();
    QString server_text = ui->udp_server->text();
diff --git a/src/yuzu/game_list_p.h b/src/yuzu/game_list_p.h
index 248855aff..df935022d 100644
--- a/src/yuzu/game_list_p.h
+++ b/src/yuzu/game_list_p.h
@@ -174,7 +174,8 @@ public:
    }
    bool operator<(const QStandardItem& other) const override {
-        return data(CompatNumberRole) < other.data(CompatNumberRole);
+        return data(CompatNumberRole).value<QString>() <
+               other.data(CompatNumberRole).value<QString>();
    }
 };
diff --git a/src/yuzu_cmd/config.cpp b/src/yuzu_cmd/config.cpp
index 34c9673bc..b70f71a08 100644
--- a/src/yuzu_cmd/config.cpp
+++ b/src/yuzu_cmd/config.cpp
@@ -345,7 +345,6 @@ void Config::ReadValues() {
    // System
    Settings::values.use_docked_mode.SetValue(
        sdl2_config->GetBoolean("System", "use_docked_mode", false));
-    const auto size = sdl2_config->GetInteger("System", "users_size", 0);
    Settings::values.current_user = std::clamp<int>(
        sdl2_config->GetInteger("System", "current_user", 0), 0, Service::Account::MAX_USERS - 1);