game_list: Remove artificially caps to a certain number of directories

2019-04-23 22:43:55 +02:00
72 changed files with 452 additions and 1168 deletions
@@ -1,3 +1,3 @@
 #!/bin/bash -ex
 mkdir "$HOME/.ccache" || true
-docker run --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache yuzuemu/build-environments:linux-mingw /bin/bash -ex /yuzu/.travis/linux-mingw/docker.sh
+docker run --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache ubuntu:18.04 /bin/bash -ex /yuzu/.travis/linux-mingw/docker.sh
@@ -1,3 +1,3 @@
 #!/bin/sh -ex

-docker pull yuzuemu/build-environments:linux-mingw
+docker pull ubuntu:18.04
@@ -1,6 +1,16 @@
 #!/bin/bash -ex

 cd /yuzu
+MINGW_PACKAGES="sdl2-mingw-w64 qt5base-mingw-w64 qt5tools-mingw-w64 libsamplerate-mingw-w64 qt5multimedia-mingw-w64"
+apt-get update
+apt-get install -y gpg wget git python3-pip python ccache g++-mingw-w64-x86-64 gcc-mingw-w64-x86-64 mingw-w64-tools cmake
+echo 'deb http://ppa.launchpad.net/tobydox/mingw-w64/ubuntu bionic main ' > /etc/apt/sources.list.d/extras.list
+apt-key adv --keyserver keyserver.ubuntu.com --recv '72931B477E22FEFD47F8DECE02FE5F12ADDE29B2'
+apt-get update
+apt-get install -y ${MINGW_PACKAGES}
+
+# fix a problem in current MinGW headers
+wget -q https://raw.githubusercontent.com/Alexpux/mingw-w64/d0d7f784833bbb0b2d279310ddc6afb52fe47a46/mingw-w64-headers/crt/errno.h -O /usr/x86_64-w64-mingw32/include/errno.h
 # override Travis CI unreasonable ccache size
 echo 'max_size = 3.0G' > "$HOME/.ccache/ccache.conf"

@@ -1,4 +1,4 @@
 #!/bin/bash -ex

 mkdir -p "$HOME/.ccache"
-docker run -e ENABLE_COMPATIBILITY_REPORTING --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.travis/linux/docker.sh
+docker run -e ENABLE_COMPATIBILITY_REPORTING --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache ubuntu:18.04 /bin/bash /yuzu/.travis/linux/docker.sh
@@ -1,3 +1,3 @@
 #!/bin/sh -ex

-docker pull yuzuemu/build-environments:linux-fresh
+docker pull ubuntu:18.04
@@ -1,5 +1,8 @@
 #!/bin/bash -ex

+apt-get update
+apt-get install --no-install-recommends -y build-essential git libqt5opengl5-dev libsdl2-dev libssl-dev python qtbase5-dev qtwebengine5-dev wget cmake ninja-build ccache
+
 cd /yuzu

 mkdir build && cd build
@@ -19,6 +19,18 @@ $(brew --prefix)/opt/qt5/bin/macdeployqt "${REV_NAME}/yuzu.app" -executable="${R
 # move libs into folder for deployment
 macpack "${REV_NAME}/yuzu-cmd" -d "libs"

+# Make the yuzu.app application launch a debugging terminal.
+# Store away the actual binary
+mv ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu-bin
+
+cat > ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu <<EOL
+#!/usr/bin/env bash
+cd "\`dirname "\$0"\`"
+chmod +x yuzu-bin
+open yuzu-bin --args "\$@"
+EOL
+# Content that will serve as the launching script for yuzu (within the .app folder)
+
 # Make the launching script executable
 chmod +x ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu

@@ -19,7 +19,7 @@ set(BUILD_VERSION "0")
 if (BUILD_REPOSITORY)
  # regex capture the string nightly or canary into CMAKE_MATCH_1
  string(REGEX MATCH "yuzu-emu/yuzu-?(.*)" OUTVAR ${BUILD_REPOSITORY})
-  if ("${CMAKE_MATCH_COUNT}" GREATER 0)
+  if (${CMAKE_MATCH_COUNT} GREATER 0)
    # capitalize the first letter of each word in the repo name.
    string(REPLACE "-" ";" REPO_NAME_LIST ${CMAKE_MATCH_1})
    foreach(WORD ${REPO_NAME_LIST})
@@ -18,9 +18,6 @@ if (MSVC)
    # Avoid windows.h from including some usually unused libs like winsocks.h, since this might cause some redefinition errors.
    add_definitions(-DWIN32_LEAN_AND_MEAN)

-    # Ensure that projects build with Unicode support.
-    add_definitions(-DUNICODE -D_UNICODE)
-
    # /W3 - Level 3 warnings
    # /MP - Multi-threaded compilation
    # /Zi - Output debugging information
@@ -88,10 +88,6 @@ add_library(core STATIC
    file_sys/vfs_vector.h
    file_sys/xts_archive.cpp
    file_sys/xts_archive.h
-    frontend/applets/error.cpp
-    frontend/applets/error.h
-    frontend/applets/general_frontend.cpp
-    frontend/applets/general_frontend.h
    frontend/applets/profile_select.cpp
    frontend/applets/profile_select.h
    frontend/applets/software_keyboard.cpp
@@ -181,14 +177,12 @@ add_library(core STATIC
    hle/service/am/applet_oe.h
    hle/service/am/applets/applets.cpp
    hle/service/am/applets/applets.h
-    hle/service/am/applets/error.cpp
-    hle/service/am/applets/error.h
-    hle/service/am/applets/general_backend.cpp
-    hle/service/am/applets/general_backend.h
    hle/service/am/applets/profile_select.cpp
    hle/service/am/applets/profile_select.h
    hle/service/am/applets/software_keyboard.cpp
    hle/service/am/applets/software_keyboard.h
+    hle/service/am/applets/stub_applet.cpp
+    hle/service/am/applets/stub_applet.h
    hle/service/am/applets/web_browser.cpp
    hle/service/am/applets/web_browser.h
    hle/service/am/idle.cpp
@@ -18,18 +18,13 @@
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
-#include "core/frontend/applets/error.h"
-#include "core/frontend/applets/general_frontend.h"
-#include "core/frontend/applets/profile_select.h"
-#include "core/frontend/applets/software_keyboard.h"
-#include "core/frontend/applets/web_browser.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
-#include "core/hle/service/am/applets/applets.h"
+#include "core/hle/service/am/applets/software_keyboard.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
@@ -115,7 +110,12 @@ struct System::Impl {
            content_provider = std::make_unique<FileSys::ContentProviderUnion>();

        /// Create default implementations of applets if one is not provided.
-        applet_manager.SetDefaultAppletsIfMissing();
+        if (profile_selector == nullptr)
+            profile_selector = std::make_unique<Core::Frontend::DefaultProfileSelectApplet>();
+        if (software_keyboard == nullptr)
+            software_keyboard = std::make_unique<Core::Frontend::DefaultSoftwareKeyboardApplet>();
+        if (web_browser == nullptr)
+            web_browser = std::make_unique<Core::Frontend::DefaultWebBrowserApplet>();

        telemetry_session = std::make_unique<Core::TelemetrySession>();
        service_manager = std::make_shared<Service::SM::ServiceManager>();
@@ -223,7 +223,9 @@ struct System::Impl {
        app_loader.reset();

        // Clear all applets
-        applet_manager.ClearAll();
+        profile_selector.reset();
+        software_keyboard.reset();
+        web_browser.reset();

        LOG_DEBUG(Core, "Shutdown OK");
    }
@@ -262,7 +264,9 @@ struct System::Impl {
    std::unique_ptr<FileSys::CheatEngine> cheat_engine;

    /// Frontend applets
-    Service::AM::Applets::AppletManager applet_manager;
+    std::unique_ptr<Core::Frontend::ProfileSelectApplet> profile_selector;
+    std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> software_keyboard;
+    std::unique_ptr<Core::Frontend::WebBrowserApplet> web_browser;

    /// Service manager
    std::shared_ptr<Service::SM::ServiceManager> service_manager;
@@ -472,20 +476,20 @@ std::shared_ptr<FileSys::VfsFilesystem> System::GetFilesystem() const {
    return impl->virtual_filesystem;
 }

-void System::SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set) {
-    impl->applet_manager.SetAppletFrontendSet(std::move(set));
+void System::SetProfileSelector(std::unique_ptr<Frontend::ProfileSelectApplet> applet) {
+    impl->profile_selector = std::move(applet);
 }

-void System::SetDefaultAppletFrontendSet() {
-    impl->applet_manager.SetDefaultAppletFrontendSet();
+const Frontend::ProfileSelectApplet& System::GetProfileSelector() const {
+    return *impl->profile_selector;
 }

-Service::AM::Applets::AppletManager& System::GetAppletManager() {
-    return impl->applet_manager;
+void System::SetSoftwareKeyboard(std::unique_ptr<Frontend::SoftwareKeyboardApplet> applet) {
+    impl->software_keyboard = std::move(applet);
 }

-const Service::AM::Applets::AppletManager& System::GetAppletManager() const {
-    return impl->applet_manager;
+const Frontend::SoftwareKeyboardApplet& System::GetSoftwareKeyboard() const {
+    return *impl->software_keyboard;
 }

 void System::SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider) {
@@ -509,6 +513,18 @@ void System::ClearContentProvider(FileSys::ContentProviderUnionSlot slot) {
    impl->content_provider->ClearSlot(slot);
 }

+void System::SetWebBrowser(std::unique_ptr<Frontend::WebBrowserApplet> applet) {
+    impl->web_browser = std::move(applet);
+}
+
+Frontend::WebBrowserApplet& System::GetWebBrowser() {
+    return *impl->web_browser;
+}
+
+const Frontend::WebBrowserApplet& System::GetWebBrowser() const {
+    return *impl->web_browser;
+}
+
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
    return impl->Init(*this, emu_window);
 }
@@ -14,6 +14,9 @@

 namespace Core::Frontend {
 class EmuWindow;
+class ProfileSelectApplet;
+class SoftwareKeyboardApplet;
+class WebBrowserApplet;
 } // namespace Core::Frontend

 namespace FileSys {
@@ -35,18 +38,9 @@ class AppLoader;
 enum class ResultStatus : u16;
 } // namespace Loader

-namespace Service {
-
-namespace AM::Applets {
-struct AppletFrontendSet;
-class AppletManager;
-} // namespace AM::Applets
-
-namespace SM {
+namespace Service::SM {
 class ServiceManager;
-} // namespace SM
-
-} // namespace Service
+} // namespace Service::SM

 namespace Tegra {
 class DebugContext;
@@ -266,13 +260,18 @@ public:
    void RegisterCheatList(const std::vector<FileSys::CheatList>& list, const std::string& build_id,
                           VAddr code_region_start, VAddr code_region_end);

-    void SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set);
+    void SetProfileSelector(std::unique_ptr<Frontend::ProfileSelectApplet> applet);

-    void SetDefaultAppletFrontendSet();
+    const Frontend::ProfileSelectApplet& GetProfileSelector() const;

-    Service::AM::Applets::AppletManager& GetAppletManager();
+    void SetSoftwareKeyboard(std::unique_ptr<Frontend::SoftwareKeyboardApplet> applet);

-    const Service::AM::Applets::AppletManager& GetAppletManager() const;
+    const Frontend::SoftwareKeyboardApplet& GetSoftwareKeyboard() const;
+
+    void SetWebBrowser(std::unique_ptr<Frontend::WebBrowserApplet> applet);
+
+    Frontend::WebBrowserApplet& GetWebBrowser();
+    const Frontend::WebBrowserApplet& GetWebBrowser() const;

    void SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider);

@@ -1,34 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/frontend/applets/error.h"
-
-namespace Core::Frontend {
-
-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);
-}
-
-void DefaultErrorApplet::ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
-                                                std::function<void()> finished) const {
-    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());
-}
-
-void DefaultErrorApplet::ShowCustomErrorText(ResultCode error, std::string main_text,
-                                             std::string detail_text,
-                                             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);
-    LOG_CRITICAL(Service_Fatal, "    Main Text: {}", main_text);
-    LOG_CRITICAL(Service_Fatal, "    Detail Text: {}", detail_text);
-}
-
-} // namespace Core::Frontend
@@ -1,37 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <chrono>
-#include <functional>
-
-#include "core/hle/result.h"
-
-namespace Core::Frontend {
-
-class ErrorApplet {
-public:
-    virtual ~ErrorApplet();
-
-    virtual void ShowError(ResultCode error, std::function<void()> finished) const = 0;
-
-    virtual void ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
-                                        std::function<void()> finished) const = 0;
-
-    virtual void ShowCustomErrorText(ResultCode error, std::string dialog_text,
-                                     std::string fullscreen_text,
-                                     std::function<void()> finished) const = 0;
-};
-
-class DefaultErrorApplet final : public ErrorApplet {
-public:
-    void ShowError(ResultCode error, std::function<void()> finished) const override;
-    void ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
-                                std::function<void()> finished) const override;
-    void ShowCustomErrorText(ResultCode error, std::string main_text, std::string detail_text,
-                             std::function<void()> finished) const override;
-};
-
-} // namespace Core::Frontend
@@ -1,27 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/frontend/applets/general_frontend.h"
-
-namespace Core::Frontend {
-
-PhotoViewerApplet::~PhotoViewerApplet() = default;
-
-DefaultPhotoViewerApplet::~DefaultPhotoViewerApplet() {}
-
-void DefaultPhotoViewerApplet::ShowPhotosForApplication(u64 title_id,
-                                                        std::function<void()> finished) const {
-    LOG_INFO(Service_AM,
-             "Application requested frontend to display stored photos for title_id={:016X}",
-             title_id);
-    finished();
-}
-
-void DefaultPhotoViewerApplet::ShowAllPhotos(std::function<void()> finished) const {
-    LOG_INFO(Service_AM, "Application requested frontend to display all stored photos.");
-    finished();
-}
-
-} // namespace Core::Frontend
@@ -1,28 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <functional>
-#include "common/common_types.h"
-
-namespace Core::Frontend {
-
-class PhotoViewerApplet {
-public:
-    virtual ~PhotoViewerApplet();
-
-    virtual void ShowPhotosForApplication(u64 title_id, std::function<void()> finished) const = 0;
-    virtual void ShowAllPhotos(std::function<void()> finished) const = 0;
-};
-
-class DefaultPhotoViewerApplet final : public PhotoViewerApplet {
-public:
-    ~DefaultPhotoViewerApplet() override;
-
-    void ShowPhotosForApplication(u64 title_id, std::function<void()> finished) const override;
-    void ShowAllPhotos(std::function<void()> finished) const override;
-};
-
-} // namespace Core::Frontend
@@ -46,7 +46,8 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_

    bool resume = true;

-    if (thread->GetStatus() == ThreadStatus::WaitSynch ||
+    if (thread->GetStatus() == ThreadStatus::WaitSynchAny ||
+        thread->GetStatus() == ThreadStatus::WaitSynchAll ||
        thread->GetStatus() == ThreadStatus::WaitHLEEvent) {
        // Remove the thread from each of its waiting objects' waitlists
        for (const auto& object : thread->GetWaitObjects()) {
@@ -147,7 +147,8 @@ void Process::PrepareForTermination() {
                continue;

            // TODO(Subv): When are the other running/ready threads terminated?
-            ASSERT_MSG(thread->GetStatus() == ThreadStatus::WaitSynch,
+            ASSERT_MSG(thread->GetStatus() == ThreadStatus::WaitSynchAny ||
+                           thread->GetStatus() == ThreadStatus::WaitSynchAll,
                       "Exiting processes with non-waiting threads is currently unimplemented");

            thread->Stop();
@@ -241,8 +242,7 @@ void Process::LoadModule(CodeSet module_, VAddr base_addr) {
 }

 Process::Process(Core::System& system)
-    : WaitObject{system.Kernel()}, vm_manager{system},
-      address_arbiter{system}, mutex{system}, system{system} {}
+    : WaitObject{system.Kernel()}, address_arbiter{system}, mutex{system}, system{system} {}

 Process::~Process() = default;

@@ -424,7 +424,7 @@ static ResultCode GetProcessId(Core::System& system, u64* process_id, Handle han
 /// Default thread wakeup callback for WaitSynchronization
 static bool DefaultThreadWakeupCallback(ThreadWakeupReason reason, SharedPtr<Thread> thread,
                                        SharedPtr<WaitObject> object, std::size_t index) {
-    ASSERT(thread->GetStatus() == ThreadStatus::WaitSynch);
+    ASSERT(thread->GetStatus() == ThreadStatus::WaitSynchAny);

    if (reason == ThreadWakeupReason::Timeout) {
        thread->SetWaitSynchronizationResult(RESULT_TIMEOUT);
@@ -502,7 +502,7 @@ static ResultCode WaitSynchronization(Core::System& system, Handle* index, VAddr
    }

    thread->SetWaitObjects(std::move(objects));
-    thread->SetStatus(ThreadStatus::WaitSynch);
+    thread->SetStatus(ThreadStatus::WaitSynchAny);

    // Create an event to wake the thread up after the specified nanosecond delay has passed
    thread->WakeAfterDelay(nano_seconds);
@@ -518,14 +518,16 @@ static ResultCode CancelSynchronization(Core::System& system, Handle thread_hand
    LOG_TRACE(Kernel_SVC, "called thread=0x{:X}", thread_handle);

    const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
-    SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
    if (!thread) {
        LOG_ERROR(Kernel_SVC, "Thread handle does not exist, thread_handle=0x{:08X}",
                  thread_handle);
        return ERR_INVALID_HANDLE;
    }

-    thread->CancelWait();
+    ASSERT(thread->GetStatus() == ThreadStatus::WaitSynchAny);
+    thread->SetWaitSynchronizationResult(ERR_SYNCHRONIZATION_CANCELED);
+    thread->ResumeFromWait();
    return RESULT_SUCCESS;
 }

@@ -101,7 +101,8 @@ void Thread::ResumeFromWait() {
    ASSERT_MSG(wait_objects.empty(), "Thread is waking up while waiting for objects");

    switch (status) {
-    case ThreadStatus::WaitSynch:
+    case ThreadStatus::WaitSynchAll:
+    case ThreadStatus::WaitSynchAny:
    case ThreadStatus::WaitHLEEvent:
    case ThreadStatus::WaitSleep:
    case ThreadStatus::WaitIPC:
@@ -141,12 +142,6 @@ void Thread::ResumeFromWait() {
    ChangeScheduler();
 }

-void Thread::CancelWait() {
-    ASSERT(GetStatus() == ThreadStatus::WaitSynch);
-    SetWaitSynchronizationResult(ERR_SYNCHRONIZATION_CANCELED);
-    ResumeFromWait();
-}
-
 /**
 * Resets a thread context, making it ready to be scheduled and run by the CPU
 * @param context Thread context to reset
@@ -49,7 +49,8 @@ enum class ThreadStatus {
    WaitHLEEvent, ///< Waiting for hle event to finish
    WaitSleep,    ///< Waiting due to a SleepThread SVC
    WaitIPC,      ///< Waiting for the reply from an IPC request
-    WaitSynch,    ///< Waiting due to WaitSynchronization
+    WaitSynchAny, ///< Waiting due to WaitSynch1 or WaitSynchN with wait_all = false
+    WaitSynchAll, ///< Waiting due to WaitSynchronizationN with wait_all = true
    WaitMutex,    ///< Waiting due to an ArbitrateLock svc
    WaitCondVar,  ///< Waiting due to an WaitProcessWideKey svc
    WaitArb,      ///< Waiting due to a SignalToAddress/WaitForAddress svc
@@ -168,17 +169,11 @@ public:
        return tls_memory;
    }

-    /// Resumes a thread from waiting
+    /**
+     * Resumes a thread from waiting
+     */
    void ResumeFromWait();

-    /// Cancels a waiting operation that this thread may or may not be within.
-    ///
-    /// When the thread is within a waiting state, this will set the thread's
-    /// waiting result to signal a canceled wait. The function will then resume
-    /// this thread.
-    ///
-    void CancelWait();
-
    /**
     * Schedules an event to wake up the specified thread after the specified delay
     * @param nanoseconds The time this thread will be allowed to sleep for
@@ -189,27 +184,24 @@ public:
    void CancelWakeupTimer();

    /**
-     * Sets the result after the thread awakens (from svcWaitSynchronization)
+     * Sets the result after the thread awakens (from either WaitSynchronization SVC)
     * @param result Value to set to the returned result
     */
    void SetWaitSynchronizationResult(ResultCode result);

    /**
-     * Sets the output parameter value after the thread awakens (from svcWaitSynchronization)
+     * Sets the output parameter value after the thread awakens (from WaitSynchronizationN SVC only)
     * @param output Value to set to the output parameter
     */
    void SetWaitSynchronizationOutput(s32 output);

    /**
     * Retrieves the index that this particular object occupies in the list of objects
-     * that the thread passed to WaitSynchronization, starting the search from the last element.
-     *
-     * It is used to set the output index of WaitSynchronization when the thread is awakened.
-     *
+     * that the thread passed to WaitSynchronizationN, starting the search from the last element.
+     * It is used to set the output value of WaitSynchronizationN when the thread is awakened.
     * When a thread wakes up due to an object signal, the kernel will use the index of the last
     * matching object in the wait objects list in case of having multiple instances of the same
     * object in the list.
-     *
     * @param object Object to query the index of.
     */
    s32 GetWaitObjectIndex(const WaitObject* object) const;
@@ -246,9 +238,13 @@ public:
     */
    VAddr GetCommandBufferAddress() const;

-    /// Returns whether this thread is waiting on objects from a WaitSynchronization call.
-    bool IsSleepingOnWait() const {
-        return status == ThreadStatus::WaitSynch;
+    /**
+     * Returns whether this thread is waiting for all the objects in
+     * its wait list to become ready, as a result of a WaitSynchronizationN call
+     * with wait_all = true.
+     */
+    bool IsSleepingOnWaitAll() const {
+        return status == ThreadStatus::WaitSynchAll;
    }

    ThreadContext& GetContext() {
@@ -422,7 +418,7 @@ private:
    Process* owner_process;

    /// Objects that the thread is waiting on, in the same order as they were
-    /// passed to WaitSynchronization.
+    /// passed to WaitSynchronization1/N.
    ThreadWaitObjects wait_objects;

    /// List of threads that are waiting for a mutex that is held by this thread.
@@ -445,7 +441,7 @@ private:
    Handle callback_handle = 0;

    /// Callback that will be invoked when the thread is resumed from a waiting state. If the thread
-    /// was waiting via WaitSynchronization then the object will be the last object that became
+    /// was waiting via WaitSynchronizationN then the object will be the last object that became
    /// available. In case of a timeout, the object will be nullptr.
    WakeupCallback wakeup_callback;

@@ -62,7 +62,7 @@ bool VirtualMemoryArea::CanBeMergedWith(const VirtualMemoryArea& next) const {
    return true;
 }

-VMManager::VMManager(Core::System& system) : system{system} {
+VMManager::VMManager() {
    // Default to assuming a 39-bit address space. This way we have a sane
    // starting point with executables that don't provide metadata.
    Reset(FileSys::ProgramAddressSpaceType::Is39Bit);
@@ -111,6 +111,7 @@ ResultVal<VMManager::VMAHandle> VMManager::MapMemoryBlock(VAddr target,
    VirtualMemoryArea& final_vma = vma_handle->second;
    ASSERT(final_vma.size == size);

+    auto& system = Core::System::GetInstance();
    system.ArmInterface(0).MapBackingMemory(target, size, block->data() + offset,
                                            VMAPermission::ReadWriteExecute);
    system.ArmInterface(1).MapBackingMemory(target, size, block->data() + offset,
@@ -139,6 +140,7 @@ ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8* me
    VirtualMemoryArea& final_vma = vma_handle->second;
    ASSERT(final_vma.size == size);

+    auto& system = Core::System::GetInstance();
    system.ArmInterface(0).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
    system.ArmInterface(1).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
    system.ArmInterface(2).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
@@ -221,6 +223,7 @@ ResultCode VMManager::UnmapRange(VAddr target, u64 size) {

    ASSERT(FindVMA(target)->second.size >= size);

+    auto& system = Core::System::GetInstance();
    system.ArmInterface(0).UnmapMemory(target, size);
    system.ArmInterface(1).UnmapMemory(target, size);
    system.ArmInterface(2).UnmapMemory(target, size);
@@ -373,7 +376,7 @@ ResultCode VMManager::UnmapCodeMemory(VAddr dst_address, VAddr src_address, u64
    Reprotect(src_vma_iter, VMAPermission::ReadWrite);

    if (dst_memory_state == MemoryState::ModuleCode) {
-        system.InvalidateCpuInstructionCaches();
+        Core::System::GetInstance().InvalidateCpuInstructionCaches();
    }

    return unmap_result;
@@ -14,10 +14,6 @@
 #include "core/hle/result.h"
 #include "core/memory.h"

-namespace Core {
-class System;
-}
-
 namespace FileSys {
 enum class ProgramAddressSpaceType : u8;
 }
@@ -325,7 +321,7 @@ class VMManager final {
 public:
    using VMAHandle = VMAMap::const_iterator;

-    explicit VMManager(Core::System& system);
+    VMManager();
    ~VMManager();

    /// Clears the address space map, re-initializing with a single free area.
@@ -716,7 +712,5 @@ private:
    // The end of the currently allocated heap. This is not an inclusive
    // end of the range. This is essentially 'base_address + current_size'.
    VAddr heap_end = 0;
-
-    Core::System& system;
 };
 } // namespace Kernel
@@ -38,7 +38,8 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() const {
        const ThreadStatus thread_status = thread->GetStatus();

        // The list of waiting threads must not contain threads that are not waiting to be awakened.
-        ASSERT_MSG(thread_status == ThreadStatus::WaitSynch ||
+        ASSERT_MSG(thread_status == ThreadStatus::WaitSynchAny ||
+                       thread_status == ThreadStatus::WaitSynchAll ||
                       thread_status == ThreadStatus::WaitHLEEvent,
                   "Inconsistent thread statuses in waiting_threads");

@@ -48,10 +49,10 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() const {
        if (ShouldWait(thread.get()))
            continue;

-        // A thread is ready to run if it's either in ThreadStatus::WaitSynch
-        // and the rest of the objects it is waiting on are ready.
+        // A thread is ready to run if it's either in ThreadStatus::WaitSynchAny or
+        // in ThreadStatus::WaitSynchAll and the rest of the objects it is waiting on are ready.
        bool ready_to_run = true;
-        if (thread_status == ThreadStatus::WaitSynch) {
+        if (thread_status == ThreadStatus::WaitSynchAll) {
            ready_to_run = thread->AllWaitObjectsReady();
        }

@@ -67,35 +68,33 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() const {
 void WaitObject::WakeupWaitingThread(SharedPtr<Thread> thread) {
    ASSERT(!ShouldWait(thread.get()));

-    if (!thread) {
+    if (!thread)
        return;
-    }

-    if (thread->IsSleepingOnWait()) {
+    if (!thread->IsSleepingOnWaitAll()) {
+        Acquire(thread.get());
+    } else {
        for (const auto& object : thread->GetWaitObjects()) {
            ASSERT(!object->ShouldWait(thread.get()));
            object->Acquire(thread.get());
        }
-    } else {
-        Acquire(thread.get());
    }

    const std::size_t index = thread->GetWaitObjectIndex(this);

-    for (const auto& object : thread->GetWaitObjects()) {
+    for (const auto& object : thread->GetWaitObjects())
        object->RemoveWaitingThread(thread.get());
-    }
    thread->ClearWaitObjects();

    thread->CancelWakeupTimer();

    bool resume = true;
-    if (thread->HasWakeupCallback()) {
+
+    if (thread->HasWakeupCallback())
        resume = thread->InvokeWakeupCallback(ThreadWakeupReason::Signal, thread, this, index);
-    }
-    if (resume) {
+
+    if (resume)
        thread->ResumeFromWait();
-    }
 }

 void WaitObject::WakeupAllWaitingThreads() {
@@ -22,6 +22,7 @@
 #include "core/hle/service/am/applets/applets.h"
 #include "core/hle/service/am/applets/profile_select.h"
 #include "core/hle/service/am/applets/software_keyboard.h"
+#include "core/hle/service/am/applets/stub_applet.h"
 #include "core/hle/service/am/applets/web_browser.h"
 #include "core/hle/service/am/idle.h"
 #include "core/hle/service/am/omm.h"
@@ -41,6 +42,12 @@ constexpr ResultCode ERR_NO_DATA_IN_CHANNEL{ErrorModule::AM, 0x2};
 constexpr ResultCode ERR_NO_MESSAGES{ErrorModule::AM, 0x3};
 constexpr ResultCode ERR_SIZE_OUT_OF_BOUNDS{ErrorModule::AM, 0x1F7};

+enum class AppletId : u32 {
+    ProfileSelect = 0x10,
+    SoftwareKeyboard = 0x11,
+    LibAppletOff = 0x17,
+};
+
 constexpr u32 POP_LAUNCH_PARAMETER_MAGIC = 0xC79497CA;

 struct LaunchParameters {
@@ -879,16 +886,30 @@ ILibraryAppletCreator::ILibraryAppletCreator() : ServiceFramework("ILibraryApple

 ILibraryAppletCreator::~ILibraryAppletCreator() = default;

+static std::shared_ptr<Applets::Applet> GetAppletFromId(AppletId id) {
+    switch (id) {
+    case AppletId::ProfileSelect:
+        return std::make_shared<Applets::ProfileSelect>();
+    case AppletId::SoftwareKeyboard:
+        return std::make_shared<Applets::SoftwareKeyboard>();
+    case AppletId::LibAppletOff:
+        return std::make_shared<Applets::WebBrowser>();
+    default:
+        LOG_ERROR(Service_AM, "Unimplemented AppletId [{:08X}]! -- Falling back to stub!",
+                  static_cast<u32>(id));
+        return std::make_shared<Applets::StubApplet>();
+    }
+}
+
 void ILibraryAppletCreator::CreateLibraryApplet(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
-    const auto applet_id = rp.PopRaw<Applets::AppletId>();
+    const auto applet_id = rp.PopRaw<AppletId>();
    const auto applet_mode = rp.PopRaw<u32>();

    LOG_DEBUG(Service_AM, "called with applet_id={:08X}, applet_mode={:08X}",
              static_cast<u32>(applet_id), applet_mode);

-    const auto& applet_manager{Core::System::GetInstance().GetAppletManager()};
-    const auto applet = applet_manager.GetApplet(applet_id);
+    const auto applet = GetAppletFromId(applet_id);

    if (applet == nullptr) {
        LOG_ERROR(Service_AM, "Applet doesn't exist! applet_id={}", static_cast<u32>(applet_id));
@@ -5,21 +5,11 @@
 #include <cstring>
 #include "common/assert.h"
 #include "core/core.h"
-#include "core/frontend/applets/error.h"
-#include "core/frontend/applets/general_frontend.h"
-#include "core/frontend/applets/profile_select.h"
-#include "core/frontend/applets/software_keyboard.h"
-#include "core/frontend/applets/web_browser.h"
 #include "core/hle/kernel/readable_event.h"
 #include "core/hle/kernel/server_session.h"
 #include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/applets.h"
-#include "core/hle/service/am/applets/error.h"
-#include "core/hle/service/am/applets/general_backend.h"
-#include "core/hle/service/am/applets/profile_select.h"
-#include "core/hle/service/am/applets/software_keyboard.h"
-#include "core/hle/service/am/applets/web_browser.h"

 namespace Service::AM::Applets {

@@ -121,76 +111,4 @@ void Applet::Initialize() {
    initialized = true;
 }

-AppletManager::AppletManager() = default;
-
-AppletManager::~AppletManager() = default;
-
-void AppletManager::SetAppletFrontendSet(AppletFrontendSet set) {
-    if (set.error != nullptr)
-        frontend.error = std::move(set.error);
-    if (set.photo_viewer != nullptr)
-        frontend.photo_viewer = std::move(set.photo_viewer);
-    if (set.profile_select != nullptr)
-        frontend.profile_select = std::move(set.profile_select);
-    if (set.software_keyboard != nullptr)
-        frontend.software_keyboard = std::move(set.software_keyboard);
-    if (set.web_browser != nullptr)
-        frontend.web_browser = std::move(set.web_browser);
-}
-
-void AppletManager::SetDefaultAppletFrontendSet() {
-    frontend.error = std::make_unique<Core::Frontend::DefaultErrorApplet>();
-    frontend.photo_viewer = std::make_unique<Core::Frontend::DefaultPhotoViewerApplet>();
-    frontend.profile_select = std::make_unique<Core::Frontend::DefaultProfileSelectApplet>();
-    frontend.software_keyboard = std::make_unique<Core::Frontend::DefaultSoftwareKeyboardApplet>();
-    frontend.web_browser = std::make_unique<Core::Frontend::DefaultWebBrowserApplet>();
-}
-
-void AppletManager::SetDefaultAppletsIfMissing() {
-    if (frontend.error == nullptr) {
-        frontend.error = std::make_unique<Core::Frontend::DefaultErrorApplet>();
-    }
-
-    if (frontend.photo_viewer == nullptr) {
-        frontend.photo_viewer = std::make_unique<Core::Frontend::DefaultPhotoViewerApplet>();
-    }
-
-    if (frontend.profile_select == nullptr) {
-        frontend.profile_select = std::make_unique<Core::Frontend::DefaultProfileSelectApplet>();
-    }
-
-    if (frontend.software_keyboard == nullptr) {
-        frontend.software_keyboard =
-            std::make_unique<Core::Frontend::DefaultSoftwareKeyboardApplet>();
-    }
-
-    if (frontend.web_browser == nullptr) {
-        frontend.web_browser = std::make_unique<Core::Frontend::DefaultWebBrowserApplet>();
-    }
-}
-
-void AppletManager::ClearAll() {
-    frontend = {};
-}
-
-std::shared_ptr<Applet> AppletManager::GetApplet(AppletId id) const {
-    switch (id) {
-    case AppletId::Error:
-        return std::make_shared<Error>(*frontend.error);
-    case AppletId::ProfileSelect:
-        return std::make_shared<ProfileSelect>(*frontend.profile_select);
-    case AppletId::SoftwareKeyboard:
-        return std::make_shared<SoftwareKeyboard>(*frontend.software_keyboard);
-    case AppletId::PhotoViewer:
-        return std::make_shared<PhotoViewer>(*frontend.photo_viewer);
-    case AppletId::LibAppletOff:
-        return std::make_shared<WebBrowser>(*frontend.web_browser);
-    default:
-        UNIMPLEMENTED_MSG(
-            "No backend implementation exists for applet_id={:02X}! Falling back to stub applet.",
-            static_cast<u8>(id));
-        return std::make_shared<StubApplet>();
-    }
-}
-
 } // namespace Service::AM::Applets
@@ -12,43 +12,12 @@

 union ResultCode;

-namespace Core::Frontend {
-class ErrorApplet;
-class PhotoViewerApplet;
-class ProfileSelectApplet;
-class SoftwareKeyboardApplet;
-class WebBrowserApplet;
-} // namespace Core::Frontend
-
 namespace Service::AM {

 class IStorage;

 namespace Applets {

-enum class AppletId : u32 {
-    OverlayDisplay = 0x02,
-    QLaunch = 0x03,
-    Starter = 0x04,
-    Auth = 0x0A,
-    Cabinet = 0x0B,
-    Controller = 0x0C,
-    DataErase = 0x0D,
-    Error = 0x0E,
-    NetConnect = 0x0F,
-    ProfileSelect = 0x10,
-    SoftwareKeyboard = 0x11,
-    MiiEdit = 0x12,
-    LibAppletWeb = 0x13,
-    LibAppletShop = 0x14,
-    PhotoViewer = 0x15,
-    Settings = 0x16,
-    LibAppletOff = 0x17,
-    LibAppletWhitelisted = 0x18,
-    LibAppletAuth = 0x19,
-    MyPage = 0x1A,
-};
-
 class AppletDataBroker final {
 public:
    AppletDataBroker();
@@ -136,29 +105,5 @@ protected:
    bool initialized = false;
 };

-struct AppletFrontendSet {
-    std::unique_ptr<Core::Frontend::ErrorApplet> error;
-    std::unique_ptr<Core::Frontend::PhotoViewerApplet> photo_viewer;
-    std::unique_ptr<Core::Frontend::ProfileSelectApplet> profile_select;
-    std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> software_keyboard;
-    std::unique_ptr<Core::Frontend::WebBrowserApplet> web_browser;
-};
-
-class AppletManager {
-public:
-    AppletManager();
-    ~AppletManager();
-
-    void SetAppletFrontendSet(AppletFrontendSet set);
-    void SetDefaultAppletFrontendSet();
-    void SetDefaultAppletsIfMissing();
-    void ClearAll();
-
-    std::shared_ptr<Applet> GetApplet(AppletId id) const;
-
-private:
-    AppletFrontendSet frontend;
-};
-
 } // namespace Applets
 } // namespace Service::AM
@@ -1,182 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <array>
-#include <cstring>
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "common/string_util.h"
-#include "core/core.h"
-#include "core/frontend/applets/error.h"
-#include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applets/error.h"
-
-namespace Service::AM::Applets {
-
-#pragma pack(push, 4)
-struct ShowError {
-    u8 mode;
-    bool jump;
-    INSERT_PADDING_BYTES(4);
-    bool use_64bit_error_code;
-    INSERT_PADDING_BYTES(1);
-    u64 error_code_64;
-    u32 error_code_32;
-};
-static_assert(sizeof(ShowError) == 0x14, "ShowError has incorrect size.");
-#pragma pack(pop)
-
-struct ShowErrorRecord {
-    u8 mode;
-    bool jump;
-    INSERT_PADDING_BYTES(6);
-    u64 error_code_64;
-    u64 posix_time;
-};
-static_assert(sizeof(ShowErrorRecord) == 0x18, "ShowErrorRecord has incorrect size.");
-
-struct SystemErrorArg {
-    u8 mode;
-    bool jump;
-    INSERT_PADDING_BYTES(6);
-    u64 error_code_64;
-    std::array<char, 8> language_code;
-    std::array<char, 0x800> main_text;
-    std::array<char, 0x800> detail_text;
-};
-static_assert(sizeof(SystemErrorArg) == 0x1018, "SystemErrorArg has incorrect size.");
-
-struct ApplicationErrorArg {
-    u8 mode;
-    bool jump;
-    INSERT_PADDING_BYTES(6);
-    u32 error_code;
-    std::array<char, 8> language_code;
-    std::array<char, 0x800> main_text;
-    std::array<char, 0x800> detail_text;
-};
-static_assert(sizeof(ApplicationErrorArg) == 0x1014, "ApplicationErrorArg has incorrect size.");
-
-union Error::ErrorArguments {
-    ShowError error;
-    ShowErrorRecord error_record;
-    SystemErrorArg system_error;
-    ApplicationErrorArg application_error;
-};
-
-namespace {
-template <typename T>
-void CopyArgumentData(const std::vector<u8>& data, T& variable) {
-    ASSERT(data.size() >= sizeof(T));
-    std::memcpy(&variable, data.data(), sizeof(T));
-}
-
-ResultCode Decode64BitError(u64 error) {
-    const auto description = (error >> 32) & 0x1FFF;
-    auto module = error & 0x3FF;
-    if (module >= 2000)
-        module -= 2000;
-    module &= 0x1FF;
-    return {static_cast<ErrorModule>(module), static_cast<u32>(description)};
-}
-
-} // Anonymous namespace
-
-Error::Error(const Core::Frontend::ErrorApplet& frontend) : frontend(frontend) {}
-
-Error::~Error() = default;
-
-void Error::Initialize() {
-    Applet::Initialize();
-    args = std::make_unique<ErrorArguments>();
-    complete = false;
-
-    const auto storage = broker.PopNormalDataToApplet();
-    ASSERT(storage != nullptr);
-    const auto data = storage->GetData();
-
-    ASSERT(!data.empty());
-    std::memcpy(&mode, data.data(), sizeof(ErrorAppletMode));
-
-    switch (mode) {
-    case ErrorAppletMode::ShowError:
-        CopyArgumentData(data, args->error);
-        if (args->error.use_64bit_error_code) {
-            error_code = Decode64BitError(args->error.error_code_64);
-        } else {
-            error_code = ResultCode(args->error.error_code_32);
-        }
-        break;
-    case ErrorAppletMode::ShowSystemError:
-        CopyArgumentData(data, args->system_error);
-        error_code = ResultCode(Decode64BitError(args->system_error.error_code_64));
-        break;
-    case ErrorAppletMode::ShowApplicationError:
-        CopyArgumentData(data, args->application_error);
-        error_code = ResultCode(args->application_error.error_code);
-        break;
-    case ErrorAppletMode::ShowErrorRecord:
-        CopyArgumentData(data, args->error_record);
-        error_code = Decode64BitError(args->error_record.error_code_64);
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented LibAppletError mode={:02X}!", static_cast<u8>(mode));
-    }
-}
-
-bool Error::TransactionComplete() const {
-    return complete;
-}
-
-ResultCode Error::GetStatus() const {
-    return RESULT_SUCCESS;
-}
-
-void Error::ExecuteInteractive() {
-    UNREACHABLE_MSG("Unexpected interactive applet data!");
-}
-
-void Error::Execute() {
-    if (complete) {
-        return;
-    }
-
-    const auto callback = [this] { DisplayCompleted(); };
-
-    switch (mode) {
-    case ErrorAppletMode::ShowError:
-        frontend.ShowError(error_code, callback);
-        break;
-    case ErrorAppletMode::ShowSystemError:
-    case ErrorAppletMode::ShowApplicationError: {
-        const auto system = mode == ErrorAppletMode::ShowSystemError;
-        const auto& main_text =
-            system ? args->system_error.main_text : args->application_error.main_text;
-        const auto& detail_text =
-            system ? args->system_error.detail_text : args->application_error.detail_text;
-
-        frontend.ShowCustomErrorText(
-            error_code,
-            Common::StringFromFixedZeroTerminatedBuffer(main_text.data(), main_text.size()),
-            Common::StringFromFixedZeroTerminatedBuffer(detail_text.data(), detail_text.size()),
-            callback);
-        break;
-    }
-    case ErrorAppletMode::ShowErrorRecord:
-        frontend.ShowErrorWithTimestamp(
-            error_code, std::chrono::seconds{args->error_record.posix_time}, callback);
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented LibAppletError mode={:02X}!", static_cast<u8>(mode));
-        DisplayCompleted();
-    }
-}
-
-void Error::DisplayCompleted() {
-    complete = true;
-    broker.PushNormalDataFromApplet(IStorage{{}});
-    broker.SignalStateChanged();
-}
-
-} // namespace Service::AM::Applets
@@ -1,47 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/result.h"
-#include "core/hle/service/am/applets/applets.h"
-
-namespace Service::AM::Applets {
-
-enum class ErrorAppletMode : u8 {
-    ShowError = 0,
-    ShowSystemError = 1,
-    ShowApplicationError = 2,
-    ShowEula = 3,
-    ShowErrorPctl = 4,
-    ShowErrorRecord = 5,
-    ShowUpdateEula = 8,
-};
-
-class Error final : public Applet {
-public:
-    explicit Error(const Core::Frontend::ErrorApplet& frontend);
-    ~Error() override;
-
-    void Initialize() override;
-
-    bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
-    void ExecuteInteractive() override;
-    void Execute() override;
-
-    void DisplayCompleted();
-
-private:
-    union ErrorArguments;
-
-    const Core::Frontend::ErrorApplet& frontend;
-    ResultCode error_code = RESULT_SUCCESS;
-    ErrorAppletMode mode = ErrorAppletMode::ShowError;
-    std::unique_ptr<ErrorArguments> args;
-
-    bool complete = false;
-};
-
-} // namespace Service::AM::Applets
@@ -1,48 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/am/applets/applets.h"
-
-namespace Service::AM::Applets {
-
-enum class PhotoViewerAppletMode : u8 {
-    CurrentApp = 0,
-    AllApps = 1,
-};
-
-class PhotoViewer final : public Applet {
-public:
-    explicit PhotoViewer(const Core::Frontend::PhotoViewerApplet& frontend);
-    ~PhotoViewer() override;
-
-    void Initialize() override;
-    bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
-    void ExecuteInteractive() override;
-    void Execute() override;
-
-    void ViewFinished();
-
-private:
-    const Core::Frontend::PhotoViewerApplet& frontend;
-    bool complete = false;
-    PhotoViewerAppletMode mode = PhotoViewerAppletMode::CurrentApp;
-};
-
-class StubApplet final : public Applet {
-public:
-    StubApplet();
-    ~StubApplet() override;
-
-    void Initialize() override;
-
-    bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
-    void ExecuteInteractive() override;
-    void Execute() override;
-};
-
-} // namespace Service::AM::Applets
@@ -15,9 +15,7 @@ namespace Service::AM::Applets {

 constexpr ResultCode ERR_USER_CANCELLED_SELECTION{ErrorModule::Account, 1};

-ProfileSelect::ProfileSelect(const Core::Frontend::ProfileSelectApplet& frontend)
-    : frontend(frontend) {}
-
+ProfileSelect::ProfileSelect() = default;
 ProfileSelect::~ProfileSelect() = default;

 void ProfileSelect::Initialize() {
@@ -53,6 +51,8 @@ void ProfileSelect::Execute() {
        return;
    }

+    const auto& frontend{Core::System::GetInstance().GetProfileSelector()};
+
    frontend.SelectProfile([this](std::optional<Account::UUID> uuid) { SelectionComplete(uuid); });
 }

@@ -28,7 +28,7 @@ static_assert(sizeof(UserSelectionOutput) == 0x18, "UserSelectionOutput has inco

 class ProfileSelect final : public Applet {
 public:
-    explicit ProfileSelect(const Core::Frontend::ProfileSelectApplet& frontend);
+    ProfileSelect();
    ~ProfileSelect() override;

    void Initialize() override;
@@ -41,8 +41,6 @@ public:
    void SelectionComplete(std::optional<Account::UUID> uuid);

 private:
-    const Core::Frontend::ProfileSelectApplet& frontend;
-
    UserSelectionConfig config;
    bool complete = false;
    ResultCode status = RESULT_SUCCESS;
@@ -39,8 +39,7 @@ static Core::Frontend::SoftwareKeyboardParameters ConvertToFrontendParameters(
    return params;
 }

-SoftwareKeyboard::SoftwareKeyboard(const Core::Frontend::SoftwareKeyboardApplet& frontend)
-    : frontend(frontend) {}
+SoftwareKeyboard::SoftwareKeyboard() = default;

 SoftwareKeyboard::~SoftwareKeyboard() = default;

@@ -91,6 +90,8 @@ void SoftwareKeyboard::ExecuteInteractive() {
    if (status == INTERACTIVE_STATUS_OK) {
        complete = true;
    } else {
+        const auto& frontend{Core::System::GetInstance().GetSoftwareKeyboard()};
+
        std::array<char16_t, SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE / 2 - 2> string;
        std::memcpy(string.data(), data.data() + 4, string.size() * 2);
        frontend.SendTextCheckDialog(
@@ -105,6 +106,8 @@ void SoftwareKeyboard::Execute() {
        return;
    }

+    const auto& frontend{Core::System::GetInstance().GetSoftwareKeyboard()};
+
    const auto parameters = ConvertToFrontendParameters(config, initial_text);

    frontend.RequestText([this](std::optional<std::u16string> text) { WriteText(text); },
@@ -55,7 +55,7 @@ static_assert(sizeof(KeyboardConfig) == 0x3E0, "KeyboardConfig has incorrect siz

 class SoftwareKeyboard final : public Applet {
 public:
-    explicit SoftwareKeyboard(const Core::Frontend::SoftwareKeyboardApplet& frontend);
+    SoftwareKeyboard();
    ~SoftwareKeyboard() override;

    void Initialize() override;
@@ -68,8 +68,6 @@ public:
    void WriteText(std::optional<std::u16string> text);

 private:
-    const Core::Frontend::SoftwareKeyboardApplet& frontend;
-
    KeyboardConfig config;
    std::u16string initial_text;
    bool complete = false;
@@ -4,15 +4,11 @@

 #include <string>

-#include "common/assert.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
-#include "core/core.h"
-#include "core/frontend/applets/general_frontend.h"
-#include "core/hle/kernel/process.h"
 #include "core/hle/result.h"
 #include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applets/general_backend.h"
+#include "core/hle/service/am/applets/stub_applet.h"

 namespace Service::AM::Applets {

@@ -34,55 +30,6 @@ static void LogCurrentStorage(AppletDataBroker& broker, std::string prefix) {
    }
 }

-PhotoViewer::PhotoViewer(const Core::Frontend::PhotoViewerApplet& frontend) : frontend(frontend) {}
-
-PhotoViewer::~PhotoViewer() = default;
-
-void PhotoViewer::Initialize() {
-    Applet::Initialize();
-    complete = false;
-
-    const auto storage = broker.PopNormalDataToApplet();
-    ASSERT(storage != nullptr);
-    const auto data = storage->GetData();
-    ASSERT(!data.empty());
-    mode = static_cast<PhotoViewerAppletMode>(data[0]);
-}
-
-bool PhotoViewer::TransactionComplete() const {
-    return complete;
-}
-
-ResultCode PhotoViewer::GetStatus() const {
-    return RESULT_SUCCESS;
-}
-
-void PhotoViewer::ExecuteInteractive() {
-    UNREACHABLE_MSG("Unexpected interactive applet data.");
-}
-
-void PhotoViewer::Execute() {
-    if (complete)
-        return;
-
-    const auto callback = [this] { ViewFinished(); };
-    switch (mode) {
-    case PhotoViewerAppletMode::CurrentApp:
-        frontend.ShowPhotosForApplication(Core::CurrentProcess()->GetTitleID(), callback);
-        break;
-    case PhotoViewerAppletMode::AllApps:
-        frontend.ShowAllPhotos(callback);
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented PhotoViewer applet mode={:02X}!", static_cast<u8>(mode));
-    }
-}
-
-void PhotoViewer::ViewFinished() {
-    broker.PushNormalDataFromApplet(IStorage{{}});
-    broker.SignalStateChanged();
-}
-
 StubApplet::StubApplet() = default;

 StubApplet::~StubApplet() = default;
@@ -120,5 +67,4 @@ void StubApplet::Execute() {
    broker.PushInteractiveDataFromApplet(IStorage{std::vector<u8>(0x1000)});
    broker.SignalStateChanged();
 }
-
 } // namespace Service::AM::Applets
@@ -0,0 +1,24 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/service/am/applets/applets.h"
+
+namespace Service::AM::Applets {
+
+class StubApplet final : public Applet {
+public:
+    StubApplet();
+    ~StubApplet() override;
+
+    void Initialize() override;
+
+    bool TransactionComplete() const override;
+    ResultCode GetStatus() const override;
+    void ExecuteInteractive() override;
+    void Execute() override;
+};
+
+} // namespace Service::AM::Applets
@@ -95,7 +95,7 @@ static FileSys::VirtualFile GetManualRomFS() {
    return nullptr;
 }

-WebBrowser::WebBrowser(Core::Frontend::WebBrowserApplet& frontend) : frontend(frontend) {}
+WebBrowser::WebBrowser() = default;

 WebBrowser::~WebBrowser() = default;

@@ -152,6 +152,8 @@ void WebBrowser::Execute() {
        return;
    }

+    auto& frontend{Core::System::GetInstance().GetWebBrowser()};
+
    frontend.OpenPage(filename, [this] { UnpackRomFS(); }, [this] { Finalize(); });
 }

@@ -12,7 +12,7 @@ namespace Service::AM::Applets {

 class WebBrowser final : public Applet {
 public:
-    WebBrowser(Core::Frontend::WebBrowserApplet& frontend);
+    WebBrowser();
    ~WebBrowser() override;

    void Initialize() override;
@@ -32,8 +32,6 @@ public:
    void Finalize();

 private:
-    Core::Frontend::WebBrowserApplet& frontend;
-
    bool complete = false;
    bool unpacked = false;
    ResultCode status = RESULT_SUCCESS;
@@ -21,6 +21,8 @@
 #include "core/memory.h"
 #include "core/settings.h"

+#pragma optimize("", off)
+
 namespace Loader {
 namespace {
 struct MODHeader {
@@ -72,6 +72,15 @@ u8* GetPointer(VAddr vaddr);

 std::string ReadCString(VAddr vaddr, std::size_t max_length);

+enum class FlushMode {
+    /// Write back modified surfaces to RAM
+    Flush,
+    /// Remove region from the cache
+    Invalidate,
+    /// Write back modified surfaces to RAM, and also remove them from the cache
+    FlushAndInvalidate,
+};
+
 /**
 * Mark each page touching the region as cached.
 */
@@ -90,7 +90,6 @@ void LogSettings() {
    LogSetting("Renderer_UseResolutionFactor", Settings::values.resolution_factor);
    LogSetting("Renderer_UseFrameLimit", Settings::values.use_frame_limit);
    LogSetting("Renderer_FrameLimit", Settings::values.frame_limit);
-    LogSetting("Renderer_UseCompatibilityProfile", Settings::values.use_compatibility_profile);
    LogSetting("Renderer_UseDiskShaderCache", Settings::values.use_disk_shader_cache);
    LogSetting("Renderer_UseAccurateGpuEmulation", Settings::values.use_accurate_gpu_emulation);
    LogSetting("Renderer_UseAsynchronousGpuEmulation",
@@ -390,7 +390,6 @@ struct Values {
    float resolution_factor;
    bool use_frame_limit;
    u16 frame_limit;
-    bool use_compatibility_profile;
    bool use_disk_shader_cache;
    bool use_accurate_gpu_emulation;
    bool use_asynchronous_gpu_emulation;
@@ -105,8 +105,6 @@ bool DmaPusher::Step() {
                dma_state.non_incrementing = false;
                dma_increment_once = true;
                break;
-            default:
-                break;
            }
        }
    }
@@ -243,10 +243,9 @@ public:
                    return "10_10_10_2";
                case Size::Size_11_11_10:
                    return "11_11_10";
-                default:
-                    UNREACHABLE();
-                    return {};
                }
+                UNREACHABLE();
+                return {};
            }

            std::string TypeString() const {
@@ -305,8 +305,6 @@ void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {
            case Maxwell::ShaderProgram::Geometry:
                shader_program_manager->UseTrivialGeometryShader();
                break;
-            default:
-                break;
            }
            continue;
        }
@@ -363,10 +363,6 @@ void ShaderCacheOpenGL::LoadDiskCache(const std::atomic_bool& stop_loading,
    if (stop_loading)
        return;

-    // Track if precompiled cache was altered during loading to know if we have to serialize the
-    // virtual precompiled cache file back to the hard drive
-    bool precompiled_cache_altered = false;
-
    // Build shaders
    if (callback)
        callback(VideoCore::LoadCallbackStage::Build, 0, usages.size());
@@ -388,7 +384,6 @@ void ShaderCacheOpenGL::LoadDiskCache(const std::atomic_bool& stop_loading,
            if (!shader) {
                // Invalidate the precompiled cache if a shader dumped shader was rejected
                disk_cache.InvalidatePrecompiled();
-                precompiled_cache_altered = true;
                dumps.clear();
            }
        }
@@ -410,13 +405,8 @@ void ShaderCacheOpenGL::LoadDiskCache(const std::atomic_bool& stop_loading,
        if (dumps.find(usage) == dumps.end()) {
            const auto& program = precompiled_programs.at(usage);
            disk_cache.SaveDump(usage, program->handle);
-            precompiled_cache_altered = true;
        }
    }
-
-    if (precompiled_cache_altered) {
-        disk_cache.SaveVirtualPrecompiledFile();
-    }
 }

 CachedProgram ShaderCacheOpenGL::GeneratePrecompiledProgram(
@@ -104,8 +104,7 @@ bool ShaderDiskCacheRaw::Save(FileUtil::IOFile& file) const {
    return true;
 }

-ShaderDiskCacheOpenGL::ShaderDiskCacheOpenGL(Core::System& system)
-    : system{system}, precompiled_cache_virtual_file_offset{0} {}
+ShaderDiskCacheOpenGL::ShaderDiskCacheOpenGL(Core::System& system) : system{system} {}

 std::optional<std::pair<std::vector<ShaderDiskCacheRaw>, std::vector<ShaderDiskCacheUsage>>>
 ShaderDiskCacheOpenGL::LoadTransferable() {
@@ -178,7 +177,6 @@ ShaderDiskCacheOpenGL::LoadTransferable() {
            return {};
        }
    }
-
    return {{raws, usages}};
 }

@@ -210,64 +208,59 @@ ShaderDiskCacheOpenGL::LoadPrecompiled() {
 std::optional<std::pair<std::unordered_map<u64, ShaderDiskCacheDecompiled>,
                        std::unordered_map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>>
 ShaderDiskCacheOpenGL::LoadPrecompiledFile(FileUtil::IOFile& file) {
-    // Read compressed file from disk and decompress to virtual precompiled cache file
-    std::vector<u8> compressed(file.GetSize());
-    file.ReadBytes(compressed.data(), compressed.size());
-    const std::vector<u8> decompressed = Common::Compression::DecompressDataZSTD(compressed);
-    SaveArrayToPrecompiled(decompressed.data(), decompressed.size());
-    precompiled_cache_virtual_file_offset = 0;
-
    ShaderCacheVersionHash file_hash{};
-    if (!LoadArrayFromPrecompiled(file_hash.data(), file_hash.size())) {
-        precompiled_cache_virtual_file_offset = 0;
+    if (file.ReadArray(file_hash.data(), file_hash.size()) != file_hash.size()) {
        return {};
    }
    if (GetShaderCacheVersionHash() != file_hash) {
        LOG_INFO(Render_OpenGL, "Precompiled cache is from another version of the emulator");
-        precompiled_cache_virtual_file_offset = 0;
        return {};
    }

    std::unordered_map<u64, ShaderDiskCacheDecompiled> decompiled;
    std::unordered_map<ShaderDiskCacheUsage, ShaderDiskCacheDump> dumps;
-    while (precompiled_cache_virtual_file_offset < precompiled_cache_virtual_file.GetSize()) {
+    while (file.Tell() < file.GetSize()) {
        PrecompiledEntryKind kind{};
-        if (!LoadObjectFromPrecompiled(kind)) {
+        if (file.ReadBytes(&kind, sizeof(u32)) != sizeof(u32)) {
            return {};
        }

        switch (kind) {
        case PrecompiledEntryKind::Decompiled: {
            u64 unique_identifier{};
-            if (!LoadObjectFromPrecompiled(unique_identifier)) {
+            if (file.ReadBytes(&unique_identifier, sizeof(u64)) != sizeof(u64))
                return {};
-            }

-            const auto entry = LoadDecompiledEntry();
-            if (!entry) {
+            const auto entry = LoadDecompiledEntry(file);
+            if (!entry)
                return {};
-            }
            decompiled.insert({unique_identifier, std::move(*entry)});
            break;
        }
        case PrecompiledEntryKind::Dump: {
            ShaderDiskCacheUsage usage;
-            if (!LoadObjectFromPrecompiled(usage)) {
+            if (file.ReadBytes(&usage, sizeof(usage)) != sizeof(usage))
                return {};
-            }

            ShaderDiskCacheDump dump;
-            if (!LoadObjectFromPrecompiled(dump.binary_format)) {
+            if (file.ReadBytes(&dump.binary_format, sizeof(u32)) != sizeof(u32))
                return {};
-            }

            u32 binary_length{};
-            if (!LoadObjectFromPrecompiled(binary_length)) {
+            u32 compressed_size{};
+            if (file.ReadBytes(&binary_length, sizeof(u32)) != sizeof(u32) ||
+                file.ReadBytes(&compressed_size, sizeof(u32)) != sizeof(u32)) {
                return {};
            }

-            dump.binary.resize(binary_length);
-            if (!LoadArrayFromPrecompiled(dump.binary.data(), dump.binary.size())) {
+            std::vector<u8> compressed_binary(compressed_size);
+            if (file.ReadArray(compressed_binary.data(), compressed_binary.size()) !=
+                compressed_binary.size()) {
+                return {};
+            }
+
+            dump.binary = Common::Compression::DecompressDataZSTD(compressed_binary);
+            if (dump.binary.empty()) {
                return {};
            }

@@ -281,41 +274,45 @@ ShaderDiskCacheOpenGL::LoadPrecompiledFile(FileUtil::IOFile& file) {
    return {{decompiled, dumps}};
 }

-std::optional<ShaderDiskCacheDecompiled> ShaderDiskCacheOpenGL::LoadDecompiledEntry() {
+std::optional<ShaderDiskCacheDecompiled> ShaderDiskCacheOpenGL::LoadDecompiledEntry(
+    FileUtil::IOFile& file) {
    u32 code_size{};
-    if (!LoadObjectFromPrecompiled(code_size)) {
+    u32 compressed_code_size{};
+    if (file.ReadBytes(&code_size, sizeof(u32)) != sizeof(u32) ||
+        file.ReadBytes(&compressed_code_size, sizeof(u32)) != sizeof(u32)) {
        return {};
    }

-    std::vector<u8> code(code_size);
-    if (!LoadArrayFromPrecompiled(code.data(), code.size())) {
+    std::vector<u8> compressed_code(compressed_code_size);
+    if (file.ReadArray(compressed_code.data(), compressed_code.size()) != compressed_code.size()) {
        return {};
    }

+    const std::vector<u8> code = Common::Compression::DecompressDataZSTD(compressed_code);
+    if (code.empty()) {
+        return {};
+    }
    ShaderDiskCacheDecompiled entry;
    entry.code = std::string(reinterpret_cast<const char*>(code.data()), code_size);

    u32 const_buffers_count{};
-    if (!LoadObjectFromPrecompiled(const_buffers_count)) {
+    if (file.ReadBytes(&const_buffers_count, sizeof(u32)) != sizeof(u32))
        return {};
-    }
-
    for (u32 i = 0; i < const_buffers_count; ++i) {
        u32 max_offset{};
        u32 index{};
        u8 is_indirect{};
-        if (!LoadObjectFromPrecompiled(max_offset) || !LoadObjectFromPrecompiled(index) ||
-            !LoadObjectFromPrecompiled(is_indirect)) {
+        if (file.ReadBytes(&max_offset, sizeof(u32)) != sizeof(u32) ||
+            file.ReadBytes(&index, sizeof(u32)) != sizeof(u32) ||
+            file.ReadBytes(&is_indirect, sizeof(u8)) != sizeof(u8)) {
            return {};
        }
        entry.entries.const_buffers.emplace_back(max_offset, is_indirect != 0, index);
    }

    u32 samplers_count{};
-    if (!LoadObjectFromPrecompiled(samplers_count)) {
+    if (file.ReadBytes(&samplers_count, sizeof(u32)) != sizeof(u32))
        return {};
-    }
-
    for (u32 i = 0; i < samplers_count; ++i) {
        u64 offset{};
        u64 index{};
@@ -323,9 +320,12 @@ std::optional<ShaderDiskCacheDecompiled> ShaderDiskCacheOpenGL::LoadDecompiledEn
        u8 is_array{};
        u8 is_shadow{};
        u8 is_bindless{};
-        if (!LoadObjectFromPrecompiled(offset) || !LoadObjectFromPrecompiled(index) ||
-            !LoadObjectFromPrecompiled(type) || !LoadObjectFromPrecompiled(is_array) ||
-            !LoadObjectFromPrecompiled(is_shadow) || !LoadObjectFromPrecompiled(is_bindless)) {
+        if (file.ReadBytes(&offset, sizeof(u64)) != sizeof(u64) ||
+            file.ReadBytes(&index, sizeof(u64)) != sizeof(u64) ||
+            file.ReadBytes(&type, sizeof(u32)) != sizeof(u32) ||
+            file.ReadBytes(&is_array, sizeof(u8)) != sizeof(u8) ||
+            file.ReadBytes(&is_shadow, sizeof(u8)) != sizeof(u8) ||
+            file.ReadBytes(&is_bindless, sizeof(u8)) != sizeof(u8)) {
            return {};
        }
        entry.entries.samplers.emplace_back(static_cast<std::size_t>(offset),
@@ -335,17 +335,17 @@ std::optional<ShaderDiskCacheDecompiled> ShaderDiskCacheOpenGL::LoadDecompiledEn
    }

    u32 global_memory_count{};
-    if (!LoadObjectFromPrecompiled(global_memory_count)) {
+    if (file.ReadBytes(&global_memory_count, sizeof(u32)) != sizeof(u32))
        return {};
-    }
-
    for (u32 i = 0; i < global_memory_count; ++i) {
        u32 cbuf_index{};
        u32 cbuf_offset{};
        u8 is_read{};
        u8 is_written{};
-        if (!LoadObjectFromPrecompiled(cbuf_index) || !LoadObjectFromPrecompiled(cbuf_offset) ||
-            !LoadObjectFromPrecompiled(is_read) || !LoadObjectFromPrecompiled(is_written)) {
+        if (file.ReadBytes(&cbuf_index, sizeof(u32)) != sizeof(u32) ||
+            file.ReadBytes(&cbuf_offset, sizeof(u32)) != sizeof(u32) ||
+            file.ReadBytes(&is_read, sizeof(u8)) != sizeof(u8) ||
+            file.ReadBytes(&is_written, sizeof(u8)) != sizeof(u8)) {
            return {};
        }
        entry.entries.global_memory_entries.emplace_back(cbuf_index, cbuf_offset, is_read != 0,
@@ -354,81 +354,74 @@ std::optional<ShaderDiskCacheDecompiled> ShaderDiskCacheOpenGL::LoadDecompiledEn

    for (auto& clip_distance : entry.entries.clip_distances) {
        u8 clip_distance_raw{};
-        if (!LoadObjectFromPrecompiled(clip_distance_raw))
+        if (file.ReadBytes(&clip_distance_raw, sizeof(u8)) != sizeof(u8))
            return {};
        clip_distance = clip_distance_raw != 0;
    }

    u64 shader_length{};
-    if (!LoadObjectFromPrecompiled(shader_length)) {
+    if (file.ReadBytes(&shader_length, sizeof(u64)) != sizeof(u64))
        return {};
-    }
-
    entry.entries.shader_length = static_cast<std::size_t>(shader_length);

    return entry;
 }

-bool ShaderDiskCacheOpenGL::SaveDecompiledFile(u64 unique_identifier, const std::string& code,
+bool ShaderDiskCacheOpenGL::SaveDecompiledFile(FileUtil::IOFile& file, u64 unique_identifier,
+                                               const std::string& code,
+                                               const std::vector<u8>& compressed_code,
                                               const GLShader::ShaderEntries& entries) {
-    if (!SaveObjectToPrecompiled(static_cast<u32>(PrecompiledEntryKind::Decompiled)) ||
-        !SaveObjectToPrecompiled(unique_identifier) ||
-        !SaveObjectToPrecompiled(static_cast<u32>(code.size())) ||
-        !SaveArrayToPrecompiled(code.data(), code.size())) {
+    if (file.WriteObject(static_cast<u32>(PrecompiledEntryKind::Decompiled)) != 1 ||
+        file.WriteObject(unique_identifier) != 1 ||
+        file.WriteObject(static_cast<u32>(code.size())) != 1 ||
+        file.WriteObject(static_cast<u32>(compressed_code.size())) != 1 ||
+        file.WriteArray(compressed_code.data(), compressed_code.size()) != compressed_code.size()) {
        return false;
    }

-    if (!SaveObjectToPrecompiled(static_cast<u32>(entries.const_buffers.size()))) {
+    if (file.WriteObject(static_cast<u32>(entries.const_buffers.size())) != 1)
        return false;
-    }
    for (const auto& cbuf : entries.const_buffers) {
-        if (!SaveObjectToPrecompiled(static_cast<u32>(cbuf.GetMaxOffset())) ||
-            !SaveObjectToPrecompiled(static_cast<u32>(cbuf.GetIndex())) ||
-            !SaveObjectToPrecompiled(static_cast<u8>(cbuf.IsIndirect() ? 1 : 0))) {
+        if (file.WriteObject(static_cast<u32>(cbuf.GetMaxOffset())) != 1 ||
+            file.WriteObject(static_cast<u32>(cbuf.GetIndex())) != 1 ||
+            file.WriteObject(static_cast<u8>(cbuf.IsIndirect() ? 1 : 0)) != 1) {
            return false;
        }
    }

-    if (!SaveObjectToPrecompiled(static_cast<u32>(entries.samplers.size()))) {
+    if (file.WriteObject(static_cast<u32>(entries.samplers.size())) != 1)
        return false;
-    }
    for (const auto& sampler : entries.samplers) {
-        if (!SaveObjectToPrecompiled(static_cast<u64>(sampler.GetOffset())) ||
-            !SaveObjectToPrecompiled(static_cast<u64>(sampler.GetIndex())) ||
-            !SaveObjectToPrecompiled(static_cast<u32>(sampler.GetType())) ||
-            !SaveObjectToPrecompiled(static_cast<u8>(sampler.IsArray() ? 1 : 0)) ||
-            !SaveObjectToPrecompiled(static_cast<u8>(sampler.IsShadow() ? 1 : 0)) ||
-            !SaveObjectToPrecompiled(static_cast<u8>(sampler.IsBindless() ? 1 : 0))) {
+        if (file.WriteObject(static_cast<u64>(sampler.GetOffset())) != 1 ||
+            file.WriteObject(static_cast<u64>(sampler.GetIndex())) != 1 ||
+            file.WriteObject(static_cast<u32>(sampler.GetType())) != 1 ||
+            file.WriteObject(static_cast<u8>(sampler.IsArray() ? 1 : 0)) != 1 ||
+            file.WriteObject(static_cast<u8>(sampler.IsShadow() ? 1 : 0)) != 1 ||
+            file.WriteObject(static_cast<u8>(sampler.IsBindless() ? 1 : 0)) != 1) {
            return false;
        }
    }

-    if (!SaveObjectToPrecompiled(static_cast<u32>(entries.global_memory_entries.size()))) {
+    if (file.WriteObject(static_cast<u32>(entries.global_memory_entries.size())) != 1)
        return false;
-    }
    for (const auto& gmem : entries.global_memory_entries) {
-        if (!SaveObjectToPrecompiled(static_cast<u32>(gmem.GetCbufIndex())) ||
-            !SaveObjectToPrecompiled(static_cast<u32>(gmem.GetCbufOffset())) ||
-            !SaveObjectToPrecompiled(static_cast<u8>(gmem.IsRead() ? 1 : 0)) ||
-            !SaveObjectToPrecompiled(static_cast<u8>(gmem.IsWritten() ? 1 : 0))) {
+        if (file.WriteObject(static_cast<u32>(gmem.GetCbufIndex())) != 1 ||
+            file.WriteObject(static_cast<u32>(gmem.GetCbufOffset())) != 1 ||
+            file.WriteObject(static_cast<u8>(gmem.IsRead() ? 1 : 0)) != 1 ||
+            file.WriteObject(static_cast<u8>(gmem.IsWritten() ? 1 : 0)) != 1) {
            return false;
        }
    }

    for (const bool clip_distance : entries.clip_distances) {
-        if (!SaveObjectToPrecompiled(static_cast<u8>(clip_distance ? 1 : 0))) {
+        if (file.WriteObject(static_cast<u8>(clip_distance ? 1 : 0)) != 1)
            return false;
-        }
    }

-    if (!SaveObjectToPrecompiled(static_cast<u64>(entries.shader_length))) {
-        return false;
-    }
-
-    return true;
+    return file.WriteObject(static_cast<u64>(entries.shader_length)) == 1;
 }

-void ShaderDiskCacheOpenGL::InvalidateTransferable() {
+void ShaderDiskCacheOpenGL::InvalidateTransferable() const {
    if (!FileUtil::Delete(GetTransferablePath())) {
        LOG_ERROR(Render_OpenGL, "Failed to invalidate transferable file={}",
                  GetTransferablePath());
@@ -436,10 +429,7 @@ void ShaderDiskCacheOpenGL::InvalidateTransferable() {
    InvalidatePrecompiled();
 }

-void ShaderDiskCacheOpenGL::InvalidatePrecompiled() {
-    // Clear virtaul precompiled cache file
-    precompiled_cache_virtual_file.Resize(0);
-
+void ShaderDiskCacheOpenGL::InvalidatePrecompiled() const {
    if (!FileUtil::Delete(GetPrecompiledPath())) {
        LOG_ERROR(Render_OpenGL, "Failed to invalidate precompiled file={}", GetPrecompiledPath());
    }
@@ -495,13 +485,22 @@ void ShaderDiskCacheOpenGL::SaveDecompiled(u64 unique_identifier, const std::str
    if (!IsUsable())
        return;

-    if (precompiled_cache_virtual_file.GetSize() == 0) {
-        SavePrecompiledHeaderToVirtualPrecompiledCache();
+    const std::vector<u8> compressed_code{Common::Compression::CompressDataZSTDDefault(
+        reinterpret_cast<const u8*>(code.data()), code.size())};
+    if (compressed_code.empty()) {
+        LOG_ERROR(Render_OpenGL, "Failed to compress GLSL code - skipping shader {:016x}",
+                  unique_identifier);
+        return;
    }

-    if (!SaveDecompiledFile(unique_identifier, code, entries)) {
+    FileUtil::IOFile file = AppendPrecompiledFile();
+    if (!file.IsOpen())
+        return;
+
+    if (!SaveDecompiledFile(file, unique_identifier, code, compressed_code, entries)) {
        LOG_ERROR(Render_OpenGL,
                  "Failed to save decompiled entry to the precompiled file - removing");
+        file.Close();
        InvalidatePrecompiled();
    }
 }
@@ -517,13 +516,28 @@ void ShaderDiskCacheOpenGL::SaveDump(const ShaderDiskCacheUsage& usage, GLuint p
    std::vector<u8> binary(binary_length);
    glGetProgramBinary(program, binary_length, nullptr, &binary_format, binary.data());

-    if (!SaveObjectToPrecompiled(static_cast<u32>(PrecompiledEntryKind::Dump)) ||
-        !SaveObjectToPrecompiled(usage) ||
-        !SaveObjectToPrecompiled(static_cast<u32>(binary_format)) ||
-        !SaveObjectToPrecompiled(static_cast<u32>(binary_length)) ||
-        !SaveArrayToPrecompiled(binary.data(), binary.size())) {
+    const std::vector<u8> compressed_binary =
+        Common::Compression::CompressDataZSTDDefault(binary.data(), binary.size());
+
+    if (compressed_binary.empty()) {
+        LOG_ERROR(Render_OpenGL, "Failed to compress binary program in shader={:016x}",
+                  usage.unique_identifier);
+        return;
+    }
+
+    FileUtil::IOFile file = AppendPrecompiledFile();
+    if (!file.IsOpen())
+        return;
+
+    if (file.WriteObject(static_cast<u32>(PrecompiledEntryKind::Dump)) != 1 ||
+        file.WriteObject(usage) != 1 || file.WriteObject(static_cast<u32>(binary_format)) != 1 ||
+        file.WriteObject(static_cast<u32>(binary_length)) != 1 ||
+        file.WriteObject(static_cast<u32>(compressed_binary.size())) != 1 ||
+        file.WriteArray(compressed_binary.data(), compressed_binary.size()) !=
+            compressed_binary.size()) {
        LOG_ERROR(Render_OpenGL, "Failed to save binary program file in shader={:016x} - removing",
                  usage.unique_identifier);
+        file.Close();
        InvalidatePrecompiled();
        return;
    }
@@ -556,33 +570,28 @@ FileUtil::IOFile ShaderDiskCacheOpenGL::AppendTransferableFile() const {
    return file;
 }

-void ShaderDiskCacheOpenGL::SavePrecompiledHeaderToVirtualPrecompiledCache() {
-    const auto hash{GetShaderCacheVersionHash()};
-    if (!SaveArrayToPrecompiled(hash.data(), hash.size())) {
-        LOG_ERROR(
-            Render_OpenGL,
-            "Failed to write precompiled cache version hash to virtual precompiled cache file");
-    }
-}
-
-void ShaderDiskCacheOpenGL::SaveVirtualPrecompiledFile() {
-    precompiled_cache_virtual_file_offset = 0;
-    const std::vector<u8>& uncompressed = precompiled_cache_virtual_file.ReadAllBytes();
-    const std::vector<u8>& compressed =
-        Common::Compression::CompressDataZSTDDefault(uncompressed.data(), uncompressed.size());
+FileUtil::IOFile ShaderDiskCacheOpenGL::AppendPrecompiledFile() const {
+    if (!EnsureDirectories())
+        return {};

    const auto precompiled_path{GetPrecompiledPath()};
-    FileUtil::IOFile file(precompiled_path, "wb");
+    const bool existed = FileUtil::Exists(precompiled_path);

+    FileUtil::IOFile file(precompiled_path, "ab");
    if (!file.IsOpen()) {
        LOG_ERROR(Render_OpenGL, "Failed to open precompiled cache in path={}", precompiled_path);
-        return;
+        return {};
    }
-    if (file.WriteBytes(compressed.data(), compressed.size()) != compressed.size()) {
-        LOG_ERROR(Render_OpenGL, "Failed to write precompiled cache version in path={}",
-                  precompiled_path);
-        return;
+
+    if (!existed || file.GetSize() == 0) {
+        const auto hash{GetShaderCacheVersionHash()};
+        if (file.WriteArray(hash.data(), hash.size()) != hash.size()) {
+            LOG_ERROR(Render_OpenGL, "Failed to write precompiled cache version hash in path={}",
+                      precompiled_path);
+            return {};
+        }
    }
+    return file;
 }

 bool ShaderDiskCacheOpenGL::EnsureDirectories() const {
@@ -16,7 +16,6 @@

 #include "common/assert.h"
 #include "common/common_types.h"
-#include "core/file_sys/vfs_vector.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_opengl/gl_shader_gen.h"

@@ -173,10 +172,10 @@ public:
    LoadPrecompiled();

    /// Removes the transferable (and precompiled) cache file.
-    void InvalidateTransferable();
+    void InvalidateTransferable() const;

-    /// Removes the precompiled cache file and clears virtual precompiled cache file.
-    void InvalidatePrecompiled();
+    /// Removes the precompiled cache file.
+    void InvalidatePrecompiled() const;

    /// Saves a raw dump to the transferable file. Checks for collisions.
    void SaveRaw(const ShaderDiskCacheRaw& entry);
@@ -191,21 +190,18 @@ public:
    /// Saves a dump entry to the precompiled file. Does not check for collisions.
    void SaveDump(const ShaderDiskCacheUsage& usage, GLuint program);

-    /// Serializes virtual precompiled shader cache file to real file
-    void SaveVirtualPrecompiledFile();
-
 private:
    /// Loads the transferable cache. Returns empty on failure.
    std::optional<std::pair<std::unordered_map<u64, ShaderDiskCacheDecompiled>,
                            std::unordered_map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>>
    LoadPrecompiledFile(FileUtil::IOFile& file);

-    /// Loads a decompiled cache entry from m_precompiled_cache_virtual_file. Returns empty on
-    /// failure.
-    std::optional<ShaderDiskCacheDecompiled> LoadDecompiledEntry();
+    /// Loads a decompiled cache entry from the passed file. Returns empty on failure.
+    std::optional<ShaderDiskCacheDecompiled> LoadDecompiledEntry(FileUtil::IOFile& file);

    /// Saves a decompiled entry to the passed file. Returns true on success.
-    bool SaveDecompiledFile(u64 unique_identifier, const std::string& code,
+    bool SaveDecompiledFile(FileUtil::IOFile& file, u64 unique_identifier, const std::string& code,
+                            const std::vector<u8>& compressed_code,
                            const GLShader::ShaderEntries& entries);

    /// Returns if the cache can be used
@@ -214,8 +210,8 @@ private:
    /// Opens current game's transferable file and write it's header if it doesn't exist
    FileUtil::IOFile AppendTransferableFile() const;

-    /// Save precompiled header to precompiled_cache_in_memory
-    void SavePrecompiledHeaderToVirtualPrecompiledCache();
+    /// Opens current game's precompiled file and write it's header if it doesn't exist
+    FileUtil::IOFile AppendPrecompiledFile() const;

    /// Create shader disk cache directories. Returns true on success.
    bool EnsureDirectories() const;
@@ -238,42 +234,10 @@ private:
    /// Get current game's title id
    std::string GetTitleID() const;

-    template <typename T>
-    bool SaveArrayToPrecompiled(const T* data, std::size_t length) {
-        const std::size_t write_length = precompiled_cache_virtual_file.WriteArray(
-            data, length, precompiled_cache_virtual_file_offset);
-        precompiled_cache_virtual_file_offset += write_length;
-        return write_length == sizeof(T) * length;
-    }
-
-    template <typename T>
-    bool LoadArrayFromPrecompiled(T* data, std::size_t length) {
-        const std::size_t read_length = precompiled_cache_virtual_file.ReadArray(
-            data, length, precompiled_cache_virtual_file_offset);
-        precompiled_cache_virtual_file_offset += read_length;
-        return read_length == sizeof(T) * length;
-    }
-
-    template <typename T>
-    bool SaveObjectToPrecompiled(const T& object) {
-        return SaveArrayToPrecompiled(&object, 1);
-    }
-
-    template <typename T>
-    bool LoadObjectFromPrecompiled(T& object) {
-        return LoadArrayFromPrecompiled(&object, 1);
-    }
-
    // Copre system
    Core::System& system;
    // Stored transferable shaders
    std::map<u64, std::unordered_set<ShaderDiskCacheUsage>> transferable;
-    // Stores whole precompiled cache which will be read from or saved to the precompiled chache
-    // file
-    FileSys::VectorVfsFile precompiled_cache_virtual_file;
-    // Stores the current offset of the precompiled cache file for IO purposes
-    std::size_t precompiled_cache_virtual_file_offset;
-
    // The cache has been loaded at boot
    bool tried_to_load{};
 };
@@ -27,7 +27,8 @@ using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
    switch (attrib.type) {
    case Maxwell::VertexAttribute::Type::UnsignedInt:
-    case Maxwell::VertexAttribute::Type::UnsignedNorm:
+    case Maxwell::VertexAttribute::Type::UnsignedNorm: {
+
        switch (attrib.size) {
        case Maxwell::VertexAttribute::Size::Size_8:
        case Maxwell::VertexAttribute::Size::Size_8_8:
@@ -46,13 +47,16 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
            return GL_UNSIGNED_INT;
        case Maxwell::VertexAttribute::Size::Size_10_10_10_2:
            return GL_UNSIGNED_INT_2_10_10_10_REV;
-        default:
-            LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
-            UNREACHABLE();
-            return {};
        }
+
+        LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
+        UNREACHABLE();
+        return {};
+    }
+
    case Maxwell::VertexAttribute::Type::SignedInt:
-    case Maxwell::VertexAttribute::Type::SignedNorm:
+    case Maxwell::VertexAttribute::Type::SignedNorm: {
+
        switch (attrib.size) {
        case Maxwell::VertexAttribute::Size::Size_8:
        case Maxwell::VertexAttribute::Size::Size_8_8:
@@ -71,12 +75,14 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
            return GL_INT;
        case Maxwell::VertexAttribute::Size::Size_10_10_10_2:
            return GL_INT_2_10_10_10_REV;
-        default:
-            LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
-            UNREACHABLE();
-            return {};
        }
-    case Maxwell::VertexAttribute::Type::Float:
+
+        LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
+        UNREACHABLE();
+        return {};
+    }
+
+    case Maxwell::VertexAttribute::Type::Float: {
        switch (attrib.size) {
        case Maxwell::VertexAttribute::Size::Size_16:
        case Maxwell::VertexAttribute::Size::Size_16_16:
@@ -88,16 +94,13 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
        case Maxwell::VertexAttribute::Size::Size_32_32_32:
        case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
            return GL_FLOAT;
-        default:
-            LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
-            UNREACHABLE();
-            return {};
        }
-    default:
-        LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex type={}", attrib.TypeString());
-        UNREACHABLE();
-        return {};
    }
+    }
+
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex type={}", attrib.TypeString());
+    UNREACHABLE();
+    return {};
 }

 inline GLenum IndexFormat(Maxwell::IndexFormat index_format) {
@@ -126,11 +129,10 @@ inline GLenum PrimitiveTopology(Maxwell::PrimitiveTopology topology) {
        return GL_TRIANGLES;
    case Maxwell::PrimitiveTopology::TriangleStrip:
        return GL_TRIANGLE_STRIP;
-    default:
-        LOG_CRITICAL(Render_OpenGL, "Unimplemented topology={}", static_cast<u32>(topology));
-        UNREACHABLE();
-        return {};
    }
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented topology={}", static_cast<u32>(topology));
+    UNREACHABLE();
+    return {};
 }

 inline GLenum TextureFilterMode(Tegra::Texture::TextureFilter filter_mode,
@@ -184,10 +186,9 @@ inline GLenum WrapMode(Tegra::Texture::WrapMode wrap_mode) {
        } else {
            return GL_MIRROR_CLAMP_TO_EDGE;
        }
-    default:
-        LOG_ERROR(Render_OpenGL, "Unimplemented texture wrap mode={}", static_cast<u32>(wrap_mode));
-        return GL_REPEAT;
    }
+    LOG_ERROR(Render_OpenGL, "Unimplemented texture wrap mode={}", static_cast<u32>(wrap_mode));
+    return GL_REPEAT;
 }

 inline GLenum DepthCompareFunc(Tegra::Texture::DepthCompareFunc func) {
@@ -62,10 +62,9 @@ vk::SamplerAddressMode WrapMode(Tegra::Texture::WrapMode wrap_mode) {
    case Tegra::Texture::WrapMode::MirrorOnceBorder:
        UNIMPLEMENTED();
        return vk::SamplerAddressMode::eMirrorClampToEdge;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented wrap mode={}", static_cast<u32>(wrap_mode));
-        return {};
    }
+    UNIMPLEMENTED_MSG("Unimplemented wrap mode={}", static_cast<u32>(wrap_mode));
+    return {};
 }

 vk::CompareOp DepthCompareFunction(Tegra::Texture::DepthCompareFunc depth_compare_func) {
@@ -226,10 +225,9 @@ vk::PrimitiveTopology PrimitiveTopology(Maxwell::PrimitiveTopology topology) {
        return vk::PrimitiveTopology::eTriangleList;
    case Maxwell::PrimitiveTopology::TriangleStrip:
        return vk::PrimitiveTopology::eTriangleStrip;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented topology={}", static_cast<u32>(topology));
-        return {};
    }
+    UNIMPLEMENTED_MSG("Unimplemented topology={}", static_cast<u32>(topology));
+    return {};
 }

 vk::Format VertexFormat(Maxwell::VertexAttribute::Type type, Maxwell::VertexAttribute::Size size) {
@@ -116,8 +116,6 @@ ExitMethod ShaderIR::Scan(u32 begin, u32 end, std::set<u32>& labels) {
            // Continue scanning for an exit method.
            break;
        }
-        default:
-            break;
        }
    }
    return exit_method = ExitMethod::AlwaysReturn;
@@ -208,4 +206,4 @@ u32 ShaderIR::DecodeInstr(NodeBlock& bb, u32 pc) {
    return pc + 1;
 }

-} // namespace VideoCommon::Shader
+} // namespace VideoCommon::Shader
@@ -9,7 +9,6 @@

 namespace VideoCommon::Shader {

-using Tegra::Shader::HalfType;
 using Tegra::Shader::Instruction;
 using Tegra::Shader::OpCode;

@@ -23,6 +22,7 @@ u32 ShaderIR::DecodeArithmeticHalf(NodeBlock& bb, u32 pc) {
            LOG_WARNING(HW_GPU, "{} FTZ not implemented", opcode->get().GetName());
        }
    }
+    UNIMPLEMENTED_IF_MSG(instr.alu_half.saturate != 0, "Half float saturation not implemented");

    const bool negate_a =
        opcode->get().GetId() != OpCode::Id::HMUL2_R && instr.alu_half.negate_a != 0;
@@ -32,37 +32,35 @@ u32 ShaderIR::DecodeArithmeticHalf(NodeBlock& bb, u32 pc) {
    Node op_a = UnpackHalfFloat(GetRegister(instr.gpr8), instr.alu_half.type_a);
    op_a = GetOperandAbsNegHalf(op_a, instr.alu_half.abs_a, negate_a);

-    auto [type_b, op_b] = [&]() -> std::tuple<HalfType, Node> {
+    Node op_b = [&]() {
        switch (opcode->get().GetId()) {
        case OpCode::Id::HADD2_C:
        case OpCode::Id::HMUL2_C:
-            return {HalfType::F32, GetConstBuffer(instr.cbuf34.index, instr.cbuf34.GetOffset())};
+            return GetConstBuffer(instr.cbuf34.index, instr.cbuf34.GetOffset());
        case OpCode::Id::HADD2_R:
        case OpCode::Id::HMUL2_R:
-            return {instr.alu_half.type_b, GetRegister(instr.gpr20)};
+            return GetRegister(instr.gpr20);
        default:
            UNREACHABLE();
-            return {HalfType::F32, Immediate(0)};
+            return Immediate(0);
        }
    }();
-    op_b = UnpackHalfFloat(op_b, type_b);
-    // redeclaration to avoid a bug in clang with reusing local bindings in lambdas
-    Node op_b_alt = GetOperandAbsNegHalf(op_b, instr.alu_half.abs_b, negate_b);
+    op_b = UnpackHalfFloat(op_b, instr.alu_half.type_b);
+    op_b = GetOperandAbsNegHalf(op_b, instr.alu_half.abs_b, negate_b);

    Node value = [&]() {
        switch (opcode->get().GetId()) {
        case OpCode::Id::HADD2_C:
        case OpCode::Id::HADD2_R:
-            return Operation(OperationCode::HAdd, PRECISE, op_a, op_b_alt);
+            return Operation(OperationCode::HAdd, PRECISE, op_a, op_b);
        case OpCode::Id::HMUL2_C:
        case OpCode::Id::HMUL2_R:
-            return Operation(OperationCode::HMul, PRECISE, op_a, op_b_alt);
+            return Operation(OperationCode::HMul, PRECISE, op_a, op_b);
        default:
            UNIMPLEMENTED_MSG("Unhandled half float instruction: {}", opcode->get().GetName());
            return Immediate(0);
        }
    }();
-    value = GetSaturatedHalfFloat(value, instr.alu_half.saturate);
    value = HalfMerge(GetRegister(instr.gpr0), value, instr.alu_half.merge);

    SetRegister(bb, instr.gpr0, value);
@@ -70,4 +68,4 @@ u32 ShaderIR::DecodeArithmeticHalf(NodeBlock& bb, u32 pc) {
    return pc;
 }

-} // namespace VideoCommon::Shader
+} // namespace VideoCommon::Shader
@@ -120,11 +120,10 @@ u32 ShaderIR::DecodeConversion(NodeBlock& bb, u32 pc) {
                return Operation(OperationCode::FCeil, PRECISE, value);
            case Tegra::Shader::F2fRoundingOp::Trunc:
                return Operation(OperationCode::FTrunc, PRECISE, value);
-            default:
-                UNIMPLEMENTED_MSG("Unimplemented F2F rounding mode {}",
-                                  static_cast<u32>(instr.conversion.f2f.rounding.Value()));
-                return Immediate(0);
            }
+            UNIMPLEMENTED_MSG("Unimplemented F2F rounding mode {}",
+                              static_cast<u32>(instr.conversion.f2f.rounding.Value()));
+            return Immediate(0);
        }();
        value = GetSaturatedFloat(value, instr.alu.saturate_d);

@@ -34,14 +34,15 @@ u32 ShaderIR::DecodeHfma2(NodeBlock& bb, u32 pc) {
        case OpCode::Id::HFMA2_CR:
            neg_b = instr.hfma2.negate_b;
            neg_c = instr.hfma2.negate_c;
-            return {instr.hfma2.saturate, HalfType::F32,
+            return {instr.hfma2.saturate, instr.hfma2.type_b,
                    GetConstBuffer(instr.cbuf34.index, instr.cbuf34.GetOffset()),
                    instr.hfma2.type_reg39, GetRegister(instr.gpr39)};
        case OpCode::Id::HFMA2_RC:
            neg_b = instr.hfma2.negate_b;
            neg_c = instr.hfma2.negate_c;
            return {instr.hfma2.saturate, instr.hfma2.type_reg39, GetRegister(instr.gpr39),
-                    HalfType::F32, GetConstBuffer(instr.cbuf34.index, instr.cbuf34.GetOffset())};
+                    instr.hfma2.type_b,
+                    GetConstBuffer(instr.cbuf34.index, instr.cbuf34.GetOffset())};
        case OpCode::Id::HFMA2_RR:
            neg_b = instr.hfma2.rr.negate_b;
            neg_c = instr.hfma2.rr.negate_c;
@@ -55,13 +56,13 @@ u32 ShaderIR::DecodeHfma2(NodeBlock& bb, u32 pc) {
            return {false, identity, Immediate(0), identity, Immediate(0)};
        }
    }();
+    UNIMPLEMENTED_IF_MSG(saturate, "HFMA2 saturation is not implemented");

    const Node op_a = UnpackHalfFloat(GetRegister(instr.gpr8), instr.hfma2.type_a);
    op_b = GetOperandAbsNegHalf(UnpackHalfFloat(op_b, type_b), false, neg_b);
    op_c = GetOperandAbsNegHalf(UnpackHalfFloat(op_c, type_c), false, neg_c);

    Node value = Operation(OperationCode::HFma, PRECISE, op_a, op_b, op_c);
-    value = GetSaturatedHalfFloat(value, saturate);
    value = HalfMerge(GetRegister(instr.gpr0), value, instr.hfma2.merge);

    SetRegister(bb, instr.gpr0, value);
@@ -69,4 +70,4 @@ u32 ShaderIR::DecodeHfma2(NodeBlock& bb, u32 pc) {
    return pc;
 }

-} // namespace VideoCommon::Shader
+} // namespace VideoCommon::Shader
@@ -296,7 +296,7 @@ const Sampler& ShaderIR::GetBindlessSampler(const Tegra::Shader::Register& reg,
    ASSERT(cbuf_offset_imm != nullptr);
    const auto cbuf_offset = cbuf_offset_imm->GetValue();
    const auto cbuf_index = cbuf->GetIndex();
-    const auto cbuf_key = (static_cast<u64>(cbuf_index) << 32) | static_cast<u64>(cbuf_offset);
+    const u64 cbuf_key = (cbuf_index << 32) | cbuf_offset;

    // If this sampler has already been used, return the existing mapping.
    const auto itr =
@@ -56,10 +56,9 @@ u32 ShaderIR::DecodeXmad(NodeBlock& bb, u32 pc) {
                    instr.xmad.mode,
                    Immediate(static_cast<u32>(instr.xmad.imm20_16)),
                    GetRegister(instr.gpr39)};
-        default:
-            UNIMPLEMENTED_MSG("Unhandled XMAD instruction: {}", opcode->get().GetName());
-            return {false, false, false, Tegra::Shader::XmadMode::None, Immediate(0), Immediate(0)};
        }
+        UNIMPLEMENTED_MSG("Unhandled XMAD instruction: {}", opcode->get().GetName());
+        return {false, false, false, Tegra::Shader::XmadMode::None, Immediate(0), Immediate(0)};
    }();

    op_a = BitfieldExtract(op_a, instr.xmad.high_a ? 16 : 0, 16);
@@ -439,14 +439,11 @@ Node ShaderIR::BitfieldExtract(Node value, u32 offset, u32 bits) {
        return OperationCode::LogicalUGreaterEqual;
    case OperationCode::INegate:
        UNREACHABLE_MSG("Can't negate an unsigned integer");
-        return {};
    case OperationCode::IAbsolute:
        UNREACHABLE_MSG("Can't apply absolute to an unsigned integer");
-        return {};
-    default:
-        UNREACHABLE_MSG("Unknown signed operation with code={}", static_cast<u32>(operation_code));
-        return {};
    }
+    UNREACHABLE_MSG("Unknown signed operation with code={}", static_cast<u32>(operation_code));
+    return {};
 }

-} // namespace VideoCommon::Shader
+} // namespace VideoCommon::Shader
@@ -251,9 +251,8 @@ public:
    }

    bool operator<(const Sampler& rhs) const {
-        return std::tie(index, offset, type, is_array, is_shadow, is_bindless) <
-               std::tie(rhs.index, rhs.offset, rhs.type, rhs.is_array, rhs.is_shadow,
-                        rhs.is_bindless);
+        return std::tie(offset, index, type, is_array, is_shadow) <
+               std::tie(rhs.offset, rhs.index, rhs.type, rhs.is_array, rhs.is_shadow);
    }

 private:
@@ -178,44 +178,39 @@ PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
            return PixelFormat::ABGR8S;
        case Tegra::Texture::ComponentType::UINT:
            return PixelFormat::ABGR8UI;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::B5G6R5:
        switch (component_type) {
        case Tegra::Texture::ComponentType::UNORM:
            return PixelFormat::B5G6R5U;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::A2B10G10R10:
        switch (component_type) {
        case Tegra::Texture::ComponentType::UNORM:
            return PixelFormat::A2B10G10R10U;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::A1B5G5R5:
        switch (component_type) {
        case Tegra::Texture::ComponentType::UNORM:
            return PixelFormat::A1B5G5R5U;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::R8:
        switch (component_type) {
        case Tegra::Texture::ComponentType::UNORM:
            return PixelFormat::R8U;
        case Tegra::Texture::ComponentType::UINT:
            return PixelFormat::R8UI;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::G8R8:
        // TextureFormat::G8R8 is actually ordered red then green, as such we can use
        // PixelFormat::RG8U and PixelFormat::RG8S. This was tested with The Legend of Zelda: Breath
@@ -225,55 +220,50 @@ PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
            return PixelFormat::RG8U;
        case Tegra::Texture::ComponentType::SNORM:
            return PixelFormat::RG8S;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::R16_G16_B16_A16:
        switch (component_type) {
        case Tegra::Texture::ComponentType::UNORM:
            return PixelFormat::RGBA16U;
        case Tegra::Texture::ComponentType::FLOAT:
            return PixelFormat::RGBA16F;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::BF10GF11RF11:
        switch (component_type) {
        case Tegra::Texture::ComponentType::FLOAT:
            return PixelFormat::R11FG11FB10F;
-        default:
-            break;
        }
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::R32_G32_B32_A32:
        switch (component_type) {
        case Tegra::Texture::ComponentType::FLOAT:
            return PixelFormat::RGBA32F;
        case Tegra::Texture::ComponentType::UINT:
            return PixelFormat::RGBA32UI;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::R32_G32:
        switch (component_type) {
        case Tegra::Texture::ComponentType::FLOAT:
            return PixelFormat::RG32F;
        case Tegra::Texture::ComponentType::UINT:
            return PixelFormat::RG32UI;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::R32_G32_B32:
        switch (component_type) {
        case Tegra::Texture::ComponentType::FLOAT:
            return PixelFormat::RGB32F;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::R16:
        switch (component_type) {
        case Tegra::Texture::ComponentType::FLOAT:
@@ -286,20 +276,18 @@ PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
            return PixelFormat::R16UI;
        case Tegra::Texture::ComponentType::SINT:
            return PixelFormat::R16I;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::R32:
        switch (component_type) {
        case Tegra::Texture::ComponentType::FLOAT:
            return PixelFormat::R32F;
        case Tegra::Texture::ComponentType::UINT:
            return PixelFormat::R32UI;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::ZF32:
        return PixelFormat::Z32F;
    case Tegra::Texture::TextureFormat::Z16:
@@ -322,10 +310,9 @@ PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
            return PixelFormat::DXN2UNORM;
        case Tegra::Texture::ComponentType::SNORM:
            return PixelFormat::DXN2SNORM;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    case Tegra::Texture::TextureFormat::BC7U:
        return is_srgb ? PixelFormat::BC7U_SRGB : PixelFormat::BC7U;
    case Tegra::Texture::TextureFormat::BC6H_UF16:
@@ -356,17 +343,15 @@ PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
            return PixelFormat::RG16UI;
        case Tegra::Texture::ComponentType::SINT:
            return PixelFormat::RG16I;
-        default:
-            break;
        }
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
+        UNREACHABLE();
    default:
-        break;
+        LOG_CRITICAL(HW_GPU, "Unimplemented format={}, component_type={}", static_cast<u32>(format),
+                     static_cast<u32>(component_type));
+        UNREACHABLE();
+        return PixelFormat::ABGR8U;
    }
-    LOG_CRITICAL(HW_GPU, "Unimplemented format={}, component_type={}", static_cast<u32>(format),
-                 static_cast<u32>(component_type));
-    UNREACHABLE();
-    return PixelFormat::ABGR8U;
 }

 ComponentType ComponentTypeFromTexture(Tegra::Texture::ComponentType type) {
@@ -528,9 +513,8 @@ bool IsFormatBCn(PixelFormat format) {
    case PixelFormat::DXT45_SRGB:
    case PixelFormat::BC7U_SRGB:
        return true;
-    default:
-        return false;
    }
+    return false;
 }

 } // namespace VideoCore::Surface
@@ -7,8 +7,6 @@ add_executable(yuzu
    Info.plist
    about_dialog.cpp
    about_dialog.h
-    applets/error.cpp
-    applets/error.h
    applets/profile_select.cpp
    applets/profile_select.h
    applets/software_keyboard.cpp
@@ -1,59 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <QDateTime>
-#include "core/hle/lock.h"
-#include "yuzu/applets/error.h"
-#include "yuzu/main.h"
-
-QtErrorDisplay::QtErrorDisplay(GMainWindow& parent) {
-    connect(this, &QtErrorDisplay::MainWindowDisplayError, &parent,
-            &GMainWindow::ErrorDisplayDisplayError, Qt::QueuedConnection);
-    connect(&parent, &GMainWindow::ErrorDisplayFinished, this,
-            &QtErrorDisplay::MainWindowFinishedError, Qt::DirectConnection);
-}
-
-QtErrorDisplay::~QtErrorDisplay() = default;
-
-void QtErrorDisplay::ShowError(ResultCode error, std::function<void()> finished) const {
-    this->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)")
-            .arg(static_cast<u32>(error.module.Value()) + 2000, 4, 10, QChar::fromLatin1('0'))
-            .arg(error.description, 4, 10, QChar::fromLatin1('0'))
-            .arg(error.raw, 8, 16, QChar::fromLatin1('0')));
-}
-
-void QtErrorDisplay::ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
-                                            std::function<void()> finished) const {
-    this->callback = std::move(finished);
-    emit MainWindowDisplayError(
-        tr("An error occured on %1 at %2.\nPlease try again or contact the "
-           "developer of the software.\n\nError Code: %3-%4 (0x%5)")
-            .arg(QDateTime::fromSecsSinceEpoch(time.count()).toString("dddd, MMMM d, yyyy"))
-            .arg(QDateTime::fromSecsSinceEpoch(time.count()).toString("h:mm:ss A"))
-            .arg(static_cast<u32>(error.module.Value()) + 2000, 4, 10, QChar::fromLatin1('0'))
-            .arg(error.description, 4, 10, QChar::fromLatin1('0'))
-            .arg(error.raw, 8, 16, QChar::fromLatin1('0')));
-}
-
-void QtErrorDisplay::ShowCustomErrorText(ResultCode error, std::string dialog_text,
-                                         std::string fullscreen_text,
-                                         std::function<void()> finished) const {
-    this->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'))
-            .arg(error.description, 4, 10, QChar::fromLatin1('0'))
-            .arg(error.raw, 8, 16, QChar::fromLatin1('0'))
-            .arg(QString::fromStdString(dialog_text))
-            .arg(QString::fromStdString(fullscreen_text)));
-}
-
-void QtErrorDisplay::MainWindowFinishedError() {
-    // Acquire the HLE mutex
-    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
-    callback();
-}
@@ -1,33 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <QObject>
-
-#include "core/frontend/applets/error.h"
-
-class GMainWindow;
-
-class QtErrorDisplay final : public QObject, public Core::Frontend::ErrorApplet {
-    Q_OBJECT
-
-public:
-    explicit QtErrorDisplay(GMainWindow& parent);
-    ~QtErrorDisplay() override;
-
-    void ShowError(ResultCode error, std::function<void()> finished) const override;
-    void ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
-                                std::function<void()> finished) const override;
-    void ShowCustomErrorText(ResultCode error, std::string dialog_text, std::string fullscreen_text,
-                             std::function<void()> finished) const override;
-
-signals:
-    void MainWindowDisplayError(QString error) const;
-
-private:
-    void MainWindowFinishedError();
-
-    mutable std::function<void()> callback;
-};
@@ -377,11 +377,7 @@ void GRenderWindow::InitRenderTarget() {
    // WA_DontShowOnScreen, WA_DeleteOnClose
    QSurfaceFormat fmt;
    fmt.setVersion(4, 3);
-    if (Settings::values.use_compatibility_profile) {
-        fmt.setProfile(QSurfaceFormat::CompatibilityProfile);
-    } else {
-        fmt.setProfile(QSurfaceFormat::CoreProfile);
-    }
+    fmt.setProfile(QSurfaceFormat::CoreProfile);
    // TODO: expose a setting for buffer value (ie default/single/double/triple)
    fmt.setSwapBehavior(QSurfaceFormat::DefaultSwapBehavior);
    shared_context = std::make_unique<QOpenGLContext>();
@@ -389,8 +389,6 @@ void Config::ReadValues() {
    Settings::values.resolution_factor = ReadSetting("resolution_factor", 1.0).toFloat();
    Settings::values.use_frame_limit = ReadSetting("use_frame_limit", true).toBool();
    Settings::values.frame_limit = ReadSetting("frame_limit", 100).toInt();
-    Settings::values.use_compatibility_profile =
-        ReadSetting("use_compatibility_profile", true).toBool();
    Settings::values.use_disk_shader_cache = ReadSetting("use_disk_shader_cache", true).toBool();
    Settings::values.use_accurate_gpu_emulation =
        ReadSetting("use_accurate_gpu_emulation", false).toBool();
@@ -663,7 +661,6 @@ void Config::SaveValues() {
    WriteSetting("resolution_factor", (double)Settings::values.resolution_factor, 1.0);
    WriteSetting("use_frame_limit", Settings::values.use_frame_limit, true);
    WriteSetting("frame_limit", Settings::values.frame_limit, 100);
-    WriteSetting("use_compatibility_profile", Settings::values.use_compatibility_profile, true);
    WriteSetting("use_disk_shader_cache", Settings::values.use_disk_shader_cache, true);
    WriteSetting("use_accurate_gpu_emulation", Settings::values.use_accurate_gpu_emulation, false);
    WriteSetting("use_asynchronous_gpu_emulation", Settings::values.use_asynchronous_gpu_emulation,
@@ -73,7 +73,6 @@ void ConfigureGraphics::setConfiguration() {
        static_cast<int>(FromResolutionFactor(Settings::values.resolution_factor)));
    ui->toggle_frame_limit->setChecked(Settings::values.use_frame_limit);
    ui->frame_limit->setValue(Settings::values.frame_limit);
-    ui->use_compatibility_profile->setChecked(Settings::values.use_compatibility_profile);
    ui->use_disk_shader_cache->setChecked(Settings::values.use_disk_shader_cache);
    ui->use_accurate_gpu_emulation->setChecked(Settings::values.use_accurate_gpu_emulation);
    ui->use_asynchronous_gpu_emulation->setEnabled(!Core::System::GetInstance().IsPoweredOn());
@@ -89,7 +88,6 @@ void ConfigureGraphics::applyConfiguration() {
        ToResolutionFactor(static_cast<Resolution>(ui->resolution_factor_combobox->currentIndex()));
    Settings::values.use_frame_limit = ui->toggle_frame_limit->isChecked();
    Settings::values.frame_limit = ui->frame_limit->value();
-    Settings::values.use_compatibility_profile = ui->use_compatibility_profile->isChecked();
    Settings::values.use_disk_shader_cache = ui->use_disk_shader_cache->isChecked();
    Settings::values.use_accurate_gpu_emulation = ui->use_accurate_gpu_emulation->isChecked();
    Settings::values.use_asynchronous_gpu_emulation =
@@ -49,13 +49,6 @@
          </item>
         </layout>
        </item>
-        <item>
-         <widget class="QCheckBox" name="use_compatibility_profile">
-          <property name="text">
-           <string>Use OpenGL compatibility profile</string>
-          </property>
-         </widget>
-        </item>
        <item>
         <widget class="QCheckBox" name="use_disk_shader_cache">
          <property name="text">
@@ -227,7 +227,8 @@ QString WaitTreeThread::GetText() const {
    case Kernel::ThreadStatus::WaitIPC:
        status = tr("waiting for IPC reply");
        break;
-    case Kernel::ThreadStatus::WaitSynch:
+    case Kernel::ThreadStatus::WaitSynchAll:
+    case Kernel::ThreadStatus::WaitSynchAny:
        status = tr("waiting for objects");
        break;
    case Kernel::ThreadStatus::WaitMutex:
@@ -268,7 +269,8 @@ QColor WaitTreeThread::GetColor() const {
        return QColor(Qt::GlobalColor::darkRed);
    case Kernel::ThreadStatus::WaitSleep:
        return QColor(Qt::GlobalColor::darkYellow);
-    case Kernel::ThreadStatus::WaitSynch:
+    case Kernel::ThreadStatus::WaitSynchAll:
+    case Kernel::ThreadStatus::WaitSynchAny:
    case Kernel::ThreadStatus::WaitMutex:
    case Kernel::ThreadStatus::WaitCondVar:
    case Kernel::ThreadStatus::WaitArb:
@@ -323,9 +325,10 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const {
        list.push_back(std::make_unique<WaitTreeText>(tr("not waiting for mutex")));
    }

-    if (thread.GetStatus() == Kernel::ThreadStatus::WaitSynch) {
+    if (thread.GetStatus() == Kernel::ThreadStatus::WaitSynchAny ||
+        thread.GetStatus() == Kernel::ThreadStatus::WaitSynchAll) {
        list.push_back(std::make_unique<WaitTreeObjectList>(thread.GetWaitObjects(),
-                                                            thread.IsSleepingOnWait()));
+                                                            thread.IsSleepingOnWaitAll()));
    }

    list.push_back(std::make_unique<WaitTreeCallstack>(thread));
@@ -296,22 +296,19 @@ void GameList::ValidateEntry(const QModelIndex& item) {

 void GameList::DonePopulating(QStringList watch_list) {
    // Clear out the old directories to watch for changes and add the new ones
-    auto watch_dirs = watcher->directories();
+    const QStringList watch_dirs = watcher->directories();
    if (!watch_dirs.isEmpty()) {
        watcher->removePaths(watch_dirs);
    }
    // Workaround: Add the watch paths in chunks to allow the gui to refresh
    // This prevents the UI from stalling when a large number of watch paths are added
-    // Also artificially caps the watcher to a certain number of directories
-    constexpr int LIMIT_WATCH_DIRECTORIES = 5000;
-    constexpr int SLICE_SIZE = 25;
-    int len = std::min(watch_list.length(), LIMIT_WATCH_DIRECTORIES);
-    for (int i = 0; i < len; i += SLICE_SIZE) {
-        watcher->addPaths(watch_list.mid(i, i + SLICE_SIZE));
+    constexpr int slice_size = 25;
+    for (int i = 0; i < watch_list.length(); i += slice_size) {
+        watcher->addPaths(watch_list.mid(i, i + slice_size));
        QCoreApplication::processEvents();
    }
    tree_view->setEnabled(true);
-    int rowCount = tree_view->model()->rowCount();
+    const int rowCount = tree_view->model()->rowCount();
    search_field->setFilterResult(rowCount, rowCount);
    if (rowCount > 0) {
        search_field->setFocus();
@@ -8,7 +8,6 @@
 #include <thread>

 // VFS includes must be before glad as they will conflict with Windows file api, which uses defines.
-#include "applets/error.h"
 #include "applets/profile_select.h"
 #include "applets/software_keyboard.h"
 #include "applets/web_browser.h"
@@ -16,7 +15,6 @@
 #include "configuration/configure_per_general.h"
 #include "core/file_sys/vfs.h"
 #include "core/file_sys/vfs_real.h"
-#include "core/frontend/applets/general_frontend.h"
 #include "core/frontend/scope_acquire_window_context.h"
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/am/applets/applets.h"
@@ -797,13 +795,9 @@ bool GMainWindow::LoadROM(const QString& filename) {

    system.SetGPUDebugContext(debug_context);

-    system.SetAppletFrontendSet({
-        std::make_unique<QtErrorDisplay>(*this),
-        nullptr,
-        std::make_unique<QtProfileSelector>(*this),
-        std::make_unique<QtSoftwareKeyboard>(*this),
-        std::make_unique<QtWebBrowser>(*this),
-    });
+    system.SetProfileSelector(std::make_unique<QtProfileSelector>(*this));
+    system.SetSoftwareKeyboard(std::make_unique<QtSoftwareKeyboard>(*this));
+    system.SetWebBrowser(std::make_unique<QtWebBrowser>(*this));

    const Core::System::ResultStatus result{system.Load(*render_window, filename.toStdString())};

@@ -1589,11 +1583,6 @@ void GMainWindow::OnLoadComplete() {
    loading_screen->OnLoadComplete();
 }

-void GMainWindow::ErrorDisplayDisplayError(QString body) {
-    QMessageBox::critical(this, tr("Error Display"), body);
-    emit ErrorDisplayFinished();
-}
-
 void GMainWindow::OnMenuReportCompatibility() {
    if (!Settings::values.yuzu_token.empty() && !Settings::values.yuzu_username.empty()) {
        CompatDB compatdb{this};
@@ -102,8 +102,6 @@ signals:
    // Signal that tells widgets to update icons to use the current theme
    void UpdateThemedIcons();

-    void ErrorDisplayFinished();
-
    void ProfileSelectorFinishedSelection(std::optional<Service::Account::UUID> uuid);
    void SoftwareKeyboardFinishedText(std::optional<std::u16string> text);
    void SoftwareKeyboardFinishedCheckDialog();
@@ -113,7 +111,6 @@ signals:

 public slots:
    void OnLoadComplete();
-    void ErrorDisplayDisplayError(QString body);
    void ProfileSelectorSelectProfile();
    void SoftwareKeyboardGetText(const Core::Frontend::SoftwareKeyboardParameters& parameters);
    void SoftwareKeyboardInvokeCheckDialog(std::u16string error_message);
@@ -349,8 +349,6 @@ void Config::ReadValues() {
    Settings::values.use_frame_limit = sdl2_config->GetBoolean("Renderer", "use_frame_limit", true);
    Settings::values.frame_limit =
        static_cast<u16>(sdl2_config->GetInteger("Renderer", "frame_limit", 100));
-    Settings::values.use_compatibility_profile =
-        sdl2_config->GetBoolean("Renderer", "use_compatibility_profile", true);
    Settings::values.use_disk_shader_cache =
        sdl2_config->GetBoolean("Renderer", "use_disk_shader_cache", false);
    Settings::values.use_accurate_gpu_emulation =
@@ -32,7 +32,11 @@
 #include "yuzu_cmd/config.h"
 #include "yuzu_cmd/emu_window/emu_window_sdl2.h"

+#include <getopt.h>
 #include "core/file_sys/registered_cache.h"
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif

 #ifdef _WIN32
 // windows.h needs to be included before shellapi.h
@@ -41,12 +45,6 @@
 #include <shellapi.h>
 #endif

-#undef _UNICODE
-#include <getopt.h>
-#ifndef _MSC_VER
-#include <unistd.h>
-#endif
-
 #ifdef _WIN32
 extern "C" {
 // tells Nvidia and AMD drivers to use the dedicated GPU by default on laptops with switchable