Merge remote-tracking branch 'origin/main'

.github/workflows/build.yml

@@ -390,7 +390,7 @@ jobs:
     - name: Cache CMake Configuration
       uses: actions/cache@v4 
       env: 
-          cache-name: ${{ runner.os }}-sdl-cache-cmake-configuration
+          cache-name: ${{ runner.os }}-sdl-gcc-cache-cmake-configuration
       with: 
           path: |  
             ${{github.workspace}}/build 
@@ -401,7 +401,7 @@ jobs:
     - name: Cache CMake Build
       uses: hendrikmuhs/ccache-action@v1.2.14
       env:
-          cache-name: ${{ runner.os }}-sdl-cache-cmake-build
+          cache-name: ${{ runner.os }}-sdl-gcc-cache-cmake-build
       with:
         append-timestamp: false
         key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
@@ -426,7 +426,7 @@ jobs:
     - name: Cache CMake Configuration
       uses: actions/cache@v4 
       env: 
-          cache-name: ${{ runner.os }}-qt-cache-cmake-configuration
+          cache-name: ${{ runner.os }}-qt-gcc-cache-cmake-configuration
       with: 
           path: |  
             ${{github.workspace}}/build 
@@ -437,7 +437,7 @@ jobs:
     - name: Cache CMake Build
       uses: hendrikmuhs/ccache-action@v1.2.14
       env:
-          cache-name: ${{ runner.os }}-qt-cache-cmake-build
+          cache-name: ${{ runner.os }}-qt-gcc-cache-cmake-build
       with:
         append-timestamp: false
         key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}

CMakeLists.txt

@@ -250,10 +250,14 @@ set(KERNEL_LIB src/core/libraries/kernel/sync/mutex.cpp
                src/core/libraries/kernel/time.h
                src/core/libraries/kernel/orbis_error.h
                src/core/libraries/kernel/posix_error.h
+               src/core/libraries/kernel/aio.cpp
+               src/core/libraries/kernel/aio.h
 )
 
 set(NETWORK_LIBS src/core/libraries/network/http.cpp
                  src/core/libraries/network/http.h
+                 src/core/libraries/network/http2.cpp
+                 src/core/libraries/network/http2.h
                  src/core/libraries/network/net.cpp
                  src/core/libraries/network/netctl.cpp
                  src/core/libraries/network/netctl.h
@@ -263,6 +267,8 @@ set(NETWORK_LIBS src/core/libraries/network/http.cpp
                  src/core/libraries/network/net.h
                  src/core/libraries/network/ssl.cpp
                  src/core/libraries/network/ssl.h
+                 src/core/libraries/network/ssl2.cpp
+                 src/core/libraries/network/ssl2.h
 )
 
 set(AVPLAYER_LIB src/core/libraries/avplayer/avplayer_common.cpp
@@ -415,7 +421,9 @@ set(VDEC_LIB src/core/libraries/videodec/videodec2_impl.cpp
              src/core/libraries/videodec/videodec_impl.h
 )
 
-set(NP_LIBS src/core/libraries/np_manager/np_manager.cpp
+set(NP_LIBS src/core/libraries/np_common/np_common.cpp
+            src/core/libraries/np_common/np_common.h
+            src/core/libraries/np_manager/np_manager.cpp
             src/core/libraries/np_manager/np_manager.h
             src/core/libraries/np_score/np_score.cpp
             src/core/libraries/np_score/np_score.h
@@ -424,6 +432,8 @@ set(NP_LIBS src/core/libraries/np_manager/np_manager.cpp
             src/core/libraries/np_trophy/trophy_ui.cpp
             src/core/libraries/np_trophy/trophy_ui.h
             src/core/libraries/np_trophy/np_trophy_error.h
+            src/core/libraries/np_web_api/np_web_api.cpp
+            src/core/libraries/np_web_api/np_web_api.h
 )
 
 set(MISC_LIBS  src/core/libraries/screenshot/screenshot.cpp

dist/net.shadps4.shadPS4.metainfo.xml

@@ -26,7 +26,7 @@
     </screenshot>
     <screenshot>
       <image type="source" translate="no">https://cdn.jsdelivr.net/gh/shadps4-emu/shadps4@main/documents/Screenshots/3.png</image>
-      <caption>Yakuza Kiwami</caption>
+      <caption>Yakuza 0</caption>
     </screenshot>
     <screenshot>
       <image type="source" translate="no">https://cdn.jsdelivr.net/gh/shadps4-emu/shadps4@main/documents/Screenshots/4.png</image>

externals/sdl3

@@ -1 +1 @@
-Subproject commit 3a1d76d298db023f6cf37fb08ee766f20a4e12ab
+Subproject commit 22422f7748d5128135995ed34c8f8012861c7332

src/common/config.cpp

@@ -61,9 +61,10 @@ static u32 vblankDivider = 1;
 static bool vkValidation = false;
 static bool vkValidationSync = false;
 static bool vkValidationGpu = false;
-static bool rdocEnable = false;
-static bool vkMarkers = false;
 static bool vkCrashDiagnostic = false;
+static bool vkHostMarkers = false;
+static bool vkGuestMarkers = false;
+static bool rdocEnable = false;
 static s16 cursorState = HideCursorState::Idle;
 static int cursorHideTimeout = 5; // 5 seconds (default)
 static bool separateupdatefolder = false;
@@ -72,6 +73,7 @@ static bool checkCompatibilityOnStartup = false;
 static std::string trophyKey;
 
 // Gui
+static bool load_game_size = true;
 std::vector<std::filesystem::path> settings_install_dirs = {};
 std::filesystem::path settings_addon_install_dir = {};
 u32 main_window_geometry_x = 400;
@@ -102,6 +104,14 @@ void setTrophyKey(std::string key) {
     trophyKey = key;
 }
 
+bool GetLoadGameSizeEnabled() {
+    return load_game_size;
+}
+
+void setLoadGameSizeEnabled(bool enable) {
+    load_game_size = enable;
+}
+
 bool isNeoModeConsole() {
     return isNeo;
 }
@@ -218,10 +228,6 @@ bool isRdocEnabled() {
     return rdocEnable;
 }
 
-bool isMarkersEnabled() {
-    return vkMarkers;
-}
-
 u32 vblankDiv() {
     return vblankDivider;
 }
@@ -238,14 +244,20 @@ bool vkValidationGpuEnabled() {
     return vkValidationGpu;
 }
 
-bool vkMarkersEnabled() {
-    return vkMarkers || vkCrashDiagnostic; // Crash diagnostic forces markers on
-}
-
 bool vkCrashDiagnosticEnabled() {
     return vkCrashDiagnostic;
 }
 
+bool vkHostMarkersEnabled() {
+    // Forced on when crash diagnostic enabled.
+    return vkHostMarkers || vkCrashDiagnostic;
+}
+
+bool vkGuestMarkersEnabled() {
+    // Forced on when crash diagnostic enabled.
+    return vkGuestMarkers || vkCrashDiagnostic;
+}
+
 bool getSeparateUpdateEnabled() {
     return separateupdatefolder;
 }
@@ -635,9 +647,10 @@ void load(const std::filesystem::path& path) {
         vkValidation = toml::find_or<bool>(vk, "validation", false);
         vkValidationSync = toml::find_or<bool>(vk, "validation_sync", false);
         vkValidationGpu = toml::find_or<bool>(vk, "validation_gpu", true);
-        rdocEnable = toml::find_or<bool>(vk, "rdocEnable", false);
-        vkMarkers = toml::find_or<bool>(vk, "rdocMarkersEnable", false);
         vkCrashDiagnostic = toml::find_or<bool>(vk, "crashDiagnostic", false);
+        vkHostMarkers = toml::find_or<bool>(vk, "hostMarkers", false);
+        vkGuestMarkers = toml::find_or<bool>(vk, "guestMarkers", false);
+        rdocEnable = toml::find_or<bool>(vk, "rdocEnable", false);
     }
 
     if (data.contains("Debug")) {
@@ -650,6 +663,7 @@ void load(const std::filesystem::path& path) {
     if (data.contains("GUI")) {
         const toml::value& gui = data.at("GUI");
 
+        load_game_size = toml::find_or<bool>(gui, "loadGameSizeEnabled", true);
         m_icon_size = toml::find_or<int>(gui, "iconSize", 0);
         m_icon_size_grid = toml::find_or<int>(gui, "iconSizeGrid", 0);
         m_slider_pos = toml::find_or<int>(gui, "sliderPos", 0);
@@ -742,9 +756,10 @@ void save(const std::filesystem::path& path) {
     data["Vulkan"]["validation"] = vkValidation;
     data["Vulkan"]["validation_sync"] = vkValidationSync;
     data["Vulkan"]["validation_gpu"] = vkValidationGpu;
-    data["Vulkan"]["rdocEnable"] = rdocEnable;
-    data["Vulkan"]["rdocMarkersEnable"] = vkMarkers;
     data["Vulkan"]["crashDiagnostic"] = vkCrashDiagnostic;
+    data["Vulkan"]["hostMarkers"] = vkHostMarkers;
+    data["Vulkan"]["guestMarkers"] = vkGuestMarkers;
+    data["Vulkan"]["rdocEnable"] = rdocEnable;
     data["Debug"]["DebugDump"] = isDebugDump;
     data["Debug"]["CollectShader"] = isShaderDebug;
 
@@ -755,6 +770,7 @@ void save(const std::filesystem::path& path) {
         install_dirs.emplace_back(std::string{fmt::UTF(dirString.u8string()).data});
     }
     data["GUI"]["installDirs"] = install_dirs;
+    data["GUI"]["loadGameSizeEnabled"] = load_game_size;
 
     data["GUI"]["addonInstallDir"] =
         std::string{fmt::UTF(settings_addon_install_dir.u8string()).data};
@@ -841,9 +857,10 @@ void setDefaultValues() {
     vkValidation = false;
     vkValidationSync = false;
     vkValidationGpu = false;
-    rdocEnable = false;
-    vkMarkers = false;
     vkCrashDiagnostic = false;
+    vkHostMarkers = false;
+    vkGuestMarkers = false;
+    rdocEnable = false;
     emulator_language = "en";
     m_language = 1;
     gpuId = -1;

src/common/config.h

@@ -17,6 +17,8 @@ void saveMainWindow(const std::filesystem::path& path);
 
 std::string getTrophyKey();
 void setTrophyKey(std::string key);
+bool GetLoadGameSizeEnabled();
+void setLoadGameSizeEnabled(bool enable);
 bool getIsFullscreen();
 std::string getFullscreenMode();
 bool isNeoModeConsole();
@@ -98,8 +100,9 @@ void setRdocEnabled(bool enable);
 bool vkValidationEnabled();
 bool vkValidationSyncEnabled();
 bool vkValidationGpuEnabled();
-bool vkMarkersEnabled();
 bool vkCrashDiagnosticEnabled();
+bool vkHostMarkersEnabled();
+bool vkGuestMarkersEnabled();
 
 // Gui
 void setMainWindowGeometry(u32 x, u32 y, u32 w, u32 h);

src/common/logging/filter.cpp

@@ -95,12 +95,16 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
     SUB(Lib, SaveData)                                                                             \
     SUB(Lib, SaveDataDialog)                                                                       \
     SUB(Lib, Http)                                                                                 \
+    SUB(Lib, Http2)                                                                                \
     SUB(Lib, Ssl)                                                                                  \
+    SUB(Lib, Ssl2)                                                                                 \
     SUB(Lib, SysModule)                                                                            \
     SUB(Lib, Move)                                                                                 \
+    SUB(Lib, NpCommon)                                                                             \
     SUB(Lib, NpManager)                                                                            \
     SUB(Lib, NpScore)                                                                              \
     SUB(Lib, NpTrophy)                                                                             \
+    SUB(Lib, NpWebApi)                                                                             \
     SUB(Lib, Screenshot)                                                                           \
     SUB(Lib, LibCInternal)                                                                         \
     SUB(Lib, AppContent)                                                                           \

src/common/logging/types.h

@@ -63,11 +63,15 @@ enum class Class : u8 {
     Lib_SaveData,          ///< The LibSceSaveData implementation.
     Lib_SaveDataDialog,    ///< The LibSceSaveDataDialog implementation.
     Lib_Ssl,               ///< The LibSceSsl implementation.
+    Lib_Ssl2,              ///< The LibSceSsl2 implementation.
     Lib_Http,              ///< The LibSceHttp implementation.
+    Lib_Http2,             ///< The LibSceHttp2 implementation.
     Lib_SysModule,         ///< The LibSceSysModule implementation
+    Lib_NpCommon,          ///< The LibSceNpCommon implementation
     Lib_NpManager,         ///< The LibSceNpManager implementation
     Lib_NpScore,           ///< The LibSceNpScore implementation
     Lib_NpTrophy,          ///< The LibSceNpTrophy implementation
+    Lib_NpWebApi,          ///< The LibSceWebApi implementation
     Lib_Screenshot,        ///< The LibSceScreenshot implementation
     Lib_LibCInternal,      ///< The LibCInternal implementation.
     Lib_AppContent,        ///< The LibSceAppContent implementation.

src/common/thread.h

@@ -37,6 +37,10 @@ public:
     void Start();
 
     void End();
+
+    std::chrono::nanoseconds GetTotalWait() const {
+        return total_wait;
+    }
 };
 
 } // namespace Common

src/core/debug_state.h

@@ -131,6 +131,8 @@ class DebugStateImpl {
     friend class Core::Devtools::Widget::FrameGraph;
     friend class Core::Devtools::Widget::ShaderList;
 
+    bool showing_debug_menu_bar = false;
+
     std::queue<std::string> debug_message_popup;
 
     std::mutex guest_threads_mutex{};
@@ -153,6 +155,9 @@ class DebugStateImpl {
     std::vector<ShaderDump> shader_dump_list{};
 
 public:
+    float Framerate = 1.0f / 60.0f;
+    float FrameDeltaTime;
+
     void ShowDebugMessage(std::string message) {
         if (message.empty()) {
             return;
@@ -160,6 +165,10 @@ public:
         debug_message_popup.push(std::move(message));
     }
 
+    bool& IsShowingDebugMenuBar() {
+        return showing_debug_menu_bar;
+    }
+
     void AddCurrentThreadToGuestList();
 
     void RemoveCurrentThreadFromGuestList();

src/core/devtools/layer.cpp

@@ -28,7 +28,6 @@ static bool show_simple_fps = false;
 static bool visibility_toggled = false;
 
 static float fps_scale = 1.0f;
-static bool show_advanced_debug = false;
 static int dump_frame_count = 1;
 
 static Widget::FrameGraph frame_graph;
@@ -253,8 +252,8 @@ void L::DrawAdvanced() {
 }
 
 void L::DrawSimple() {
-    const auto io = GetIO();
+    const float frameRate = DebugState.Framerate;
-    Text("%.1f FPS (%.2f ms)", io.Framerate, 1000.0f / io.Framerate);
+    Text("%d FPS (%.1f ms)", static_cast<int>(std::round(frameRate)), 1000.0f / frameRate);
 }
 
 static void LoadSettings(const char* line) {
@@ -265,7 +264,7 @@ static void LoadSettings(const char* line) {
         return;
     }
     if (sscanf(line, "show_advanced_debug=%d", &i) == 1) {
-        show_advanced_debug = i != 0;
+        DebugState.IsShowingDebugMenuBar() = i != 0;
         return;
     }
     if (sscanf(line, "show_frame_graph=%d", &i) == 1) {
@@ -310,7 +309,7 @@ void L::SetupSettings() {
     handler.WriteAllFn = [](ImGuiContext*, ImGuiSettingsHandler* handler, ImGuiTextBuffer* buf) {
         buf->appendf("[%s][Data]\n", handler->TypeName);
         buf->appendf("fps_scale=%f\n", fps_scale);
-        buf->appendf("show_advanced_debug=%d\n", show_advanced_debug);
+        buf->appendf("show_advanced_debug=%d\n", DebugState.IsShowingDebugMenuBar());
         buf->appendf("show_frame_graph=%d\n", frame_graph.is_open);
         buf->appendf("dump_frame_count=%d\n", dump_frame_count);
         buf->append("\n");
@@ -336,12 +335,12 @@ void L::Draw() {
 
     if (!DebugState.IsGuestThreadsPaused()) {
         const auto fn = DebugState.flip_frame_count.load();
-        frame_graph.AddFrame(fn, io.DeltaTime);
+        frame_graph.AddFrame(fn, DebugState.FrameDeltaTime);
     }
 
     if (IsKeyPressed(ImGuiKey_F10, false)) {
         if (io.KeyCtrl) {
-            show_advanced_debug = !show_advanced_debug;
+            DebugState.IsShowingDebugMenuBar() ^= true;
         } else {
             show_simple_fps = !show_simple_fps;
         }
@@ -376,7 +375,7 @@ void L::Draw() {
         End();
     }
 
-    if (show_advanced_debug) {
+    if (DebugState.IsShowingDebugMenuBar()) {
         PushFont(io.Fonts->Fonts[IMGUI_FONT_MONO]);
         PushID("DevtoolsLayer");
         DrawAdvanced();

src/core/devtools/widget/frame_graph.cpp

@@ -83,15 +83,13 @@ void FrameGraph::Draw() {
 
         auto isSystemPaused = DebugState.IsGuestThreadsPaused();
 
-        static float deltaTime;
-        static float frameRate;
-
         if (!isSystemPaused) {
-            deltaTime = io.DeltaTime * 1000.0f;
+            deltaTime = DebugState.FrameDeltaTime * 1000.0f;
             frameRate = 1000.0f / deltaTime;
         }
 
         Text("Frame time: %.3f ms (%.1f FPS)", deltaTime, frameRate);
+        Text("Presenter time: %.3f ms (%.1f FPS)", io.DeltaTime * 1000.0f, 1.0f / io.DeltaTime);
         Text("Flip frame: %d Gnm submit frame: %d", DebugState.flip_frame_count.load(),
              DebugState.gnm_frame_count.load());
 

src/core/devtools/widget/frame_graph.h

@@ -16,6 +16,9 @@ class FrameGraph {
 
     std::array<FrameInfo, FRAME_BUFFER_SIZE> frame_list{};
 
+    float deltaTime{};
+    float frameRate{};
+
     void DrawFrameGraph();
 
 public:

src/core/devtools/widget/reg_popup.cpp

@@ -105,7 +105,8 @@ void RegPopup::DrawDepthBuffer(const DepthBuffer& depth_data) {
             "DEPTH_SLICE.TILE_MAX",           depth_buffer.depth_slice.tile_max,
             "Pitch()",                        depth_buffer.Pitch(),
             "Height()",                       depth_buffer.Height(),
-            "Address()",                      depth_buffer.Address(),
+            "DepthAddress()",                 depth_buffer.DepthAddress(),
+            "StencilAddress()",               depth_buffer.StencilAddress(),
             "NumSamples()",                   depth_buffer.NumSamples(),
             "NumBits()",                      depth_buffer.NumBits(),
             "GetDepthSliceSize()",            depth_buffer.GetDepthSliceSize()

src/core/devtools/widget/reg_view.cpp

@@ -155,7 +155,7 @@ void RegView::DrawGraphicsRegs() {
         TableNextColumn();
         TextUnformatted("Depth buffer");
         TableNextColumn();
-        if (regs.depth_buffer.Address() == 0 || !regs.depth_control.depth_enable) {
+        if (regs.depth_buffer.DepthAddress() == 0 || !regs.depth_control.depth_enable) {
             TextUnformatted("N/A");
         } else {
             const char* text = last_selected_cb == depth_id && default_reg_popup.open ? "x" : "->";
@@ -241,7 +241,7 @@ void RegView::SetData(DebugStateType::RegDump _data, const std::string& base_tit
             default_reg_popup.open = false;
             if (last_selected_cb == depth_id) {
                 const auto& has_depth =
-                    regs.depth_buffer.Address() != 0 && regs.depth_control.depth_enable;
+                    regs.depth_buffer.DepthAddress() != 0 && regs.depth_control.depth_enable;
                 if (has_depth) {
                     default_reg_popup.SetData(title, regs.depth_buffer, regs.depth_control);
                     default_reg_popup.open = true;

src/core/libraries/kernel/aio.cpp

@@ -0,0 +1,339 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <thread>
+
+#include "aio.h"
+#include "common/assert.h"
+#include "common/debug.h"
+#include "common/logging/log.h"
+#include "core/libraries/kernel/equeue.h"
+#include "core/libraries/kernel/orbis_error.h"
+#include "core/libraries/libs.h"
+#include "file_system.h"
+
+namespace Libraries::Kernel {
+
+#define MAX_QUEUE 512
+
+static s32* id_state;
+static s32 id_index;
+
+s32 sceKernelAioInitializeImpl(void* p, s32 size) {
+
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioDeleteRequest(OrbisKernelAioSubmitId id, s32* ret) {
+    if (ret == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    id_state[id] = ORBIS_KERNEL_AIO_STATE_ABORTED;
+    *ret = 0;
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioDeleteRequests(OrbisKernelAioSubmitId id[], s32 num, s32 ret[]) {
+    if (ret == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    for (s32 i = 0; i < num; i++) {
+        id_state[id[i]] = ORBIS_KERNEL_AIO_STATE_ABORTED;
+        ret[i] = 0;
+    }
+
+    return 0;
+}
+s32 PS4_SYSV_ABI sceKernelAioPollRequest(OrbisKernelAioSubmitId id, s32* state) {
+    if (state == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    *state = id_state[id];
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioPollRequests(OrbisKernelAioSubmitId id[], s32 num, s32 state[]) {
+    if (state == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    for (s32 i = 0; i < num; i++) {
+        state[i] = id_state[id[i]];
+    }
+
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioCancelRequest(OrbisKernelAioSubmitId id, s32* state) {
+    if (state == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    if (id) {
+        id_state[id] = ORBIS_KERNEL_AIO_STATE_ABORTED;
+        *state = ORBIS_KERNEL_AIO_STATE_ABORTED;
+    } else {
+        *state = ORBIS_KERNEL_AIO_STATE_PROCESSING;
+    }
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioCancelRequests(OrbisKernelAioSubmitId id[], s32 num, s32 state[]) {
+    if (state == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    for (s32 i = 0; i < num; i++) {
+        if (id[i]) {
+            id_state[id[i]] = ORBIS_KERNEL_AIO_STATE_ABORTED;
+            state[i] = ORBIS_KERNEL_AIO_STATE_ABORTED;
+        } else {
+            state[i] = ORBIS_KERNEL_AIO_STATE_PROCESSING;
+        }
+    }
+
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioWaitRequest(OrbisKernelAioSubmitId id, s32* state, u32* usec) {
+    if (state == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    u32 timer = 0;
+
+    s32 timeout = 0;
+
+    while (id_state[id] == ORBIS_KERNEL_AIO_STATE_PROCESSING) {
+        sceKernelUsleep(10);
+
+        timer += 10;
+        if (*usec) {
+            if (timer > *usec) {
+                timeout = 1;
+                break;
+            }
+        }
+    }
+
+    *state = id_state[id];
+
+    if (timeout)
+        return ORBIS_KERNEL_ERROR_ETIMEDOUT;
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioWaitRequests(OrbisKernelAioSubmitId id[], s32 num, s32 state[],
+                                          u32 mode, u32* usec) {
+    if (state == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    u32 timer = 0;
+    s32 timeout = 0;
+    s32 completion = 0;
+
+    for (s32 i = 0; i < num; i++) {
+        if (!completion && !timeout) {
+            while (id_state[id[i]] == ORBIS_KERNEL_AIO_STATE_PROCESSING) {
+                sceKernelUsleep(10);
+                timer += 10;
+
+                if (*usec) {
+                    if (timer > *usec) {
+                        timeout = 1;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (mode == 0x02) {
+            if (id_state[id[i]] == ORBIS_KERNEL_AIO_STATE_COMPLETED)
+                completion = 1;
+        }
+
+        state[i] = id_state[id[i]];
+    }
+
+    if (timeout)
+        return ORBIS_KERNEL_ERROR_ETIMEDOUT;
+
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioSubmitReadCommands(OrbisKernelAioRWRequest req[], s32 size, s32 prio,
+                                                OrbisKernelAioSubmitId* id) {
+    if (req == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    if (id == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    id_state[id_index] = ORBIS_KERNEL_AIO_STATE_PROCESSING;
+
+    for (s32 i = 0; i < size; i++) {
+
+        s64 ret = sceKernelPread(req[i].fd, req[i].buf, req[i].nbyte, req[i].offset);
+
+        if (ret < 0) {
+            req[i].result->state = ORBIS_KERNEL_AIO_STATE_ABORTED;
+            req[i].result->returnValue = ret;
+
+        } else {
+            req[i].result->state = ORBIS_KERNEL_AIO_STATE_COMPLETED;
+            req[i].result->returnValue = ret;
+        }
+    }
+
+    id_state[id_index] = ORBIS_KERNEL_AIO_STATE_COMPLETED;
+
+    *id = id_index;
+
+    id_index = (id_index + 1) % MAX_QUEUE;
+
+    if (!id_index)
+        id_index++;
+
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioSubmitReadCommandsMultiple(OrbisKernelAioRWRequest req[], s32 size,
+                                                        s32 prio, OrbisKernelAioSubmitId id[]) {
+    if (req == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    if (id == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    for (s32 i = 0; i < size; i++) {
+        id_state[id_index] = ORBIS_KERNEL_AIO_STATE_PROCESSING;
+
+        s64 ret = sceKernelPread(req[i].fd, req[i].buf, req[i].nbyte, req[i].offset);
+
+        if (ret < 0) {
+            req[i].result->state = ORBIS_KERNEL_AIO_STATE_ABORTED;
+            req[i].result->returnValue = ret;
+
+            id_state[id_index] = ORBIS_KERNEL_AIO_STATE_ABORTED;
+
+        } else {
+            req[i].result->state = ORBIS_KERNEL_AIO_STATE_COMPLETED;
+            req[i].result->returnValue = ret;
+
+            id_state[id_index] = ORBIS_KERNEL_AIO_STATE_COMPLETED;
+        }
+
+        id[i] = id_index;
+
+        id_index = (id_index + 1) % MAX_QUEUE;
+
+        if (!id_index)
+            id_index++;
+    }
+
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioSubmitWriteCommands(OrbisKernelAioRWRequest req[], s32 size, s32 prio,
+                                                 OrbisKernelAioSubmitId* id) {
+    if (req == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    if (id == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    for (s32 i = 0; i < size; i++) {
+        id_state[id_index] = ORBIS_KERNEL_AIO_STATE_PROCESSING;
+
+        s64 ret = sceKernelPwrite(req[i].fd, req[i].buf, req[i].nbyte, req[i].offset);
+
+        if (ret < 0) {
+            req[i].result->state = ORBIS_KERNEL_AIO_STATE_ABORTED;
+            req[i].result->returnValue = ret;
+
+            id_state[id_index] = ORBIS_KERNEL_AIO_STATE_ABORTED;
+
+        } else {
+            req[i].result->state = ORBIS_KERNEL_AIO_STATE_COMPLETED;
+            req[i].result->returnValue = ret;
+
+            id_state[id_index] = ORBIS_KERNEL_AIO_STATE_COMPLETED;
+        }
+    }
+
+    *id = id_index;
+
+    id_index = (id_index + 1) % MAX_QUEUE;
+
+    // skip id_index equals 0 , because sceKernelAioCancelRequest will submit id
+    // equal to 0
+    if (!id_index)
+        id_index++;
+
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioSubmitWriteCommandsMultiple(OrbisKernelAioRWRequest req[], s32 size,
+                                                         s32 prio, OrbisKernelAioSubmitId id[]) {
+    if (req == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    if (id == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    for (s32 i = 0; i < size; i++) {
+        id_state[id_index] = ORBIS_KERNEL_AIO_STATE_PROCESSING;
+        s64 ret = sceKernelPwrite(req[i].fd, req[i].buf, req[i].nbyte, req[i].offset);
+
+        if (ret < 0) {
+            req[i].result->state = ORBIS_KERNEL_AIO_STATE_ABORTED;
+            req[i].result->returnValue = ret;
+
+            id_state[id_index] = ORBIS_KERNEL_AIO_STATE_ABORTED;
+
+        } else {
+            req[i].result->state = ORBIS_KERNEL_AIO_STATE_COMPLETED;
+            req[i].result->returnValue = ret;
+            id_state[id_index] = ORBIS_KERNEL_AIO_STATE_COMPLETED;
+        }
+
+        id[i] = id_index;
+        id_index = (id_index + 1) % MAX_QUEUE;
+
+        if (!id_index)
+            id_index++;
+    }
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioSetParam() {
+    LOG_ERROR(Kernel, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioInitializeParam() {
+    LOG_ERROR(Kernel, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterAio(Core::Loader::SymbolsResolver* sym) {
+    id_index = 1;
+    id_state = (int*)malloc(sizeof(int) * MAX_QUEUE);
+    memset(id_state, 0, sizeof(sizeof(int) * MAX_QUEUE));
+
+    LIB_FUNCTION("fR521KIGgb8", "libkernel", 1, "libkernel", 1, 1, sceKernelAioCancelRequest);
+    LIB_FUNCTION("3Lca1XBrQdY", "libkernel", 1, "libkernel", 1, 1, sceKernelAioCancelRequests);
+    LIB_FUNCTION("5TgME6AYty4", "libkernel", 1, "libkernel", 1, 1, sceKernelAioDeleteRequest);
+    LIB_FUNCTION("Ft3EtsZzAoY", "libkernel", 1, "libkernel", 1, 1, sceKernelAioDeleteRequests);
+    LIB_FUNCTION("vYU8P9Td2Zo", "libkernel", 1, "libkernel", 1, 1, sceKernelAioInitializeImpl);
+    LIB_FUNCTION("nu4a0-arQis", "libkernel", 1, "libkernel", 1, 1, sceKernelAioInitializeParam);
+    LIB_FUNCTION("2pOuoWoCxdk", "libkernel", 1, "libkernel", 1, 1, sceKernelAioPollRequest);
+    LIB_FUNCTION("o7O4z3jwKzo", "libkernel", 1, "libkernel", 1, 1, sceKernelAioPollRequests);
+    LIB_FUNCTION("9WK-vhNXimw", "libkernel", 1, "libkernel", 1, 1, sceKernelAioSetParam);
+    LIB_FUNCTION("HgX7+AORI58", "libkernel", 1, "libkernel", 1, 1, sceKernelAioSubmitReadCommands);
+    LIB_FUNCTION("lXT0m3P-vs4", "libkernel", 1, "libkernel", 1, 1,
+                 sceKernelAioSubmitReadCommandsMultiple);
+    LIB_FUNCTION("XQ8C8y+de+E", "libkernel", 1, "libkernel", 1, 1, sceKernelAioSubmitWriteCommands);
+    LIB_FUNCTION("xT3Cpz0yh6Y", "libkernel", 1, "libkernel", 1, 1,
+                 sceKernelAioSubmitWriteCommandsMultiple);
+    LIB_FUNCTION("KOF-oJbQVvc", "libkernel", 1, "libkernel", 1, 1, sceKernelAioWaitRequest);
+    LIB_FUNCTION("lgK+oIWkJyA", "libkernel", 1, "libkernel", 1, 1, sceKernelAioWaitRequests);
+}
+
+} // namespace Libraries::Kernel

src/core/libraries/kernel/aio.h

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <condition_variable>
+#include <mutex>
+#include <string>
+#include <vector>
+#include <boost/asio/steady_timer.hpp>
+
+#include "common/types.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
+
+namespace Libraries::Kernel {
+
+enum AioState {
+    ORBIS_KERNEL_AIO_STATE_SUBMITTED = 1,
+    ORBIS_KERNEL_AIO_STATE_PROCESSING = 2,
+    ORBIS_KERNEL_AIO_STATE_COMPLETED = 3,
+    ORBIS_KERNEL_AIO_STATE_ABORTED = 4
+};
+
+struct OrbisKernelAioResult {
+    s64 returnValue;
+    u32 state;
+};
+
+typedef s32 OrbisKernelAioSubmitId;
+
+struct OrbisKernelAioRWRequest {
+    s64 offset;
+    s64 nbyte;
+    void* buf;
+    OrbisKernelAioResult* result;
+    s32 fd;
+};
+
+void RegisterAio(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::Kernel

src/core/libraries/kernel/file_system.h

@@ -67,7 +67,8 @@ constexpr int ORBIS_KERNEL_O_DIRECTORY = 0x00020000;
 
 s64 PS4_SYSV_ABI sceKernelWrite(int d, const void* buf, size_t nbytes);
 s64 PS4_SYSV_ABI sceKernelRead(int d, void* buf, size_t nbytes);
-
+s64 PS4_SYSV_ABI sceKernelPread(int d, void* buf, size_t nbytes, s64 offset);
+s64 PS4_SYSV_ABI sceKernelPwrite(int d, void* buf, size_t nbytes, s64 offset);
 void RegisterFileSystem(Core::Loader::SymbolsResolver* sym);
 
 } // namespace Libraries::Kernel

src/core/libraries/kernel/kernel.cpp

@@ -28,6 +28,7 @@
 #include <Rpc.h>
 #endif
 #include <common/singleton.h>
+#include "aio.h"
 
 namespace Libraries::Kernel {
 
@@ -218,6 +219,7 @@ void RegisterKernel(Core::Loader::SymbolsResolver* sym) {
     Libraries::Kernel::RegisterEventQueue(sym);
     Libraries::Kernel::RegisterProcess(sym);
     Libraries::Kernel::RegisterException(sym);
+    Libraries::Kernel::RegisterAio(sym);
 
     LIB_OBJ("f7uOxY9mM1U", "libkernel", 1, "libkernel", 1, 1, &g_stack_chk_guard);
     LIB_FUNCTION("PfccT7qURYE", "libkernel", 1, "libkernel", 1, 1, kernel_ioctl);

src/core/libraries/kernel/threads/condvar.cpp

@@ -339,6 +339,8 @@ int PS4_SYSV_ABI posix_pthread_condattr_setpshared(PthreadCondAttrT* attr, int p
 void RegisterCond(Core::Loader::SymbolsResolver* sym) {
     // Posix
     LIB_FUNCTION("mKoTx03HRWA", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_condattr_init);
+    LIB_FUNCTION("dJcuQVn6-Iw", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_condattr_destroy);
     LIB_FUNCTION("0TyVk4MSLt0", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_cond_init);
     LIB_FUNCTION("2MOy+rUfuhQ", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_cond_signal);
     LIB_FUNCTION("RXXqi4CtF8w", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_cond_destroy);
@@ -347,8 +349,11 @@ void RegisterCond(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("mkx2fVhNMsg", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_cond_broadcast);
 
     // Posix-Kernel
+    LIB_FUNCTION("0TyVk4MSLt0", "libkernel", 1, "libkernel", 1, 1, posix_pthread_cond_init);
     LIB_FUNCTION("Op8TBGY5KHg", "libkernel", 1, "libkernel", 1, 1, posix_pthread_cond_wait);
     LIB_FUNCTION("mkx2fVhNMsg", "libkernel", 1, "libkernel", 1, 1, posix_pthread_cond_broadcast);
+    LIB_FUNCTION("mKoTx03HRWA", "libkernel", 1, "libkernel", 1, 1, posix_pthread_condattr_init);
+    LIB_FUNCTION("dJcuQVn6-Iw", "libkernel", 1, "libkernel", 1, 1, posix_pthread_condattr_destroy);
 
     // Orbis
     LIB_FUNCTION("2Tb92quprl0", "libkernel", 1, "libkernel", 1, 1, ORBIS(scePthreadCondInit));

src/core/libraries/kernel/threads/exception.cpp

@@ -153,6 +153,11 @@ int PS4_SYSV_ABI sceKernelDebugRaiseException() {
     return 0;
 }
 
+int PS4_SYSV_ABI sceKernelDebugRaiseExceptionOnReleaseMode() {
+    UNREACHABLE();
+    return 0;
+}
+
 void RegisterException(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("il03nluKfMk", "libkernel_unity", 1, "libkernel", 1, 1, sceKernelRaiseException);
     LIB_FUNCTION("WkwEd3N7w0Y", "libkernel_unity", 1, "libkernel", 1, 1,
@@ -160,6 +165,8 @@ void RegisterException(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("Qhv5ARAoOEc", "libkernel_unity", 1, "libkernel", 1, 1,
                  sceKernelRemoveExceptionHandler)
     LIB_FUNCTION("OMDRKKAZ8I4", "libkernel", 1, "libkernel", 1, 1, sceKernelDebugRaiseException);
+    LIB_FUNCTION("zE-wXIZjLoM", "libkernel", 1, "libkernel", 1, 1,
+                 sceKernelDebugRaiseExceptionOnReleaseMode);
 }
 
 } // namespace Libraries::Kernel

src/core/libraries/kernel/threads/mutex.cpp

@@ -438,8 +438,11 @@ void RegisterMutex(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("K-jXhbt2gn4", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_mutex_trylock);
 
     // Posix-Kernel
+    LIB_FUNCTION("ttHNfU+qDBU", "libkernel", 1, "libkernel", 1, 1, posix_pthread_mutex_init);
     LIB_FUNCTION("7H0iTOciTLo", "libkernel", 1, "libkernel", 1, 1, posix_pthread_mutex_lock);
     LIB_FUNCTION("2Z+PpY6CaJg", "libkernel", 1, "libkernel", 1, 1, posix_pthread_mutex_unlock);
+    LIB_FUNCTION("dQHWEsJtoE4", "libkernel", 1, "libkernel", 1, 1, posix_pthread_mutexattr_init);
+    LIB_FUNCTION("mDmgMOGVUqg", "libkernel", 1, "libkernel", 1, 1, posix_pthread_mutexattr_settype);
 
     // Orbis
     LIB_FUNCTION("cmo1RIYva9o", "libkernel", 1, "libkernel", 1, 1, ORBIS(scePthreadMutexInit));

src/core/libraries/kernel/threads/pthread.cpp

@@ -386,6 +386,9 @@ int PS4_SYSV_ABI posix_sched_get_priority_min() {
 }
 
 int PS4_SYSV_ABI posix_pthread_rename_np(PthreadT thread, const char* name) {
+    if (thread == nullptr) {
+        return POSIX_EINVAL;
+    }
     LOG_INFO(Kernel_Pthread, "name = {}", name);
     Common::SetThreadName(reinterpret_cast<void*>(thread->native_thr.GetHandle()), name);
     thread->name = name;
@@ -535,6 +538,7 @@ void RegisterThread(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("6XG4B33N09g", "libScePosix", 1, "libkernel", 1, 1, sched_yield);
 
     // Posix-Kernel
+    LIB_FUNCTION("Z4QosVuAsA0", "libkernel", 1, "libkernel", 1, 1, posix_pthread_once);
     LIB_FUNCTION("EotR8a3ASf4", "libkernel", 1, "libkernel", 1, 1, posix_pthread_self);
     LIB_FUNCTION("OxhIB8LB-PQ", "libkernel", 1, "libkernel", 1, 1, posix_pthread_create);
 

src/core/libraries/kernel/time.h

@@ -82,6 +82,7 @@ int PS4_SYSV_ABI sceKernelConvertLocaltimeToUtc(time_t param_1, int64_t param_2,
 
 int PS4_SYSV_ABI sceKernelConvertUtcToLocaltime(time_t time, time_t* local_time, OrbisTimesec* st,
                                                 u64* dst_sec);
+int PS4_SYSV_ABI sceKernelUsleep(u32 microseconds);
 
 void RegisterTime(Core::Loader::SymbolsResolver* sym);
 

src/core/libraries/libs.cpp

@@ -21,12 +21,16 @@
 #include "core/libraries/mouse/mouse.h"
 #include "core/libraries/move/move.h"
 #include "core/libraries/network/http.h"
+#include "core/libraries/network/http2.h"
 #include "core/libraries/network/net.h"
 #include "core/libraries/network/netctl.h"
 #include "core/libraries/network/ssl.h"
+#include "core/libraries/network/ssl2.h"
+#include "core/libraries/np_common/np_common.h"
 #include "core/libraries/np_manager/np_manager.h"
 #include "core/libraries/np_score/np_score.h"
 #include "core/libraries/np_trophy/np_trophy.h"
+#include "core/libraries/np_web_api/np_web_api.h"
 #include "core/libraries/pad/pad.h"
 #include "core/libraries/playgo/playgo.h"
 #include "core/libraries/playgo/playgo_dialog.h"
@@ -64,17 +68,21 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) {
     Libraries::MsgDialog::RegisterlibSceMsgDialog(sym);
     Libraries::AudioOut::RegisterlibSceAudioOut(sym);
     Libraries::Http::RegisterlibSceHttp(sym);
+    Libraries::Http2::RegisterlibSceHttp2(sym);
     Libraries::Net::RegisterlibSceNet(sym);
     Libraries::NetCtl::RegisterlibSceNetCtl(sym);
     Libraries::SaveData::RegisterlibSceSaveData(sym);
     Libraries::SaveData::Dialog::RegisterlibSceSaveDataDialog(sym);
     Libraries::Ssl::RegisterlibSceSsl(sym);
+    Libraries::Ssl2::RegisterlibSceSsl2(sym);
     Libraries::SysModule::RegisterlibSceSysmodule(sym);
     Libraries::Posix::Registerlibsceposix(sym);
     Libraries::AudioIn::RegisterlibSceAudioIn(sym);
+    Libraries::NpCommon::RegisterlibSceNpCommon(sym);
     Libraries::NpManager::RegisterlibSceNpManager(sym);
     Libraries::NpScore::RegisterlibSceNpScore(sym);
     Libraries::NpTrophy::RegisterlibSceNpTrophy(sym);
+    Libraries::NpWebApi::RegisterlibSceNpWebApi(sym);
     Libraries::ScreenShot::RegisterlibSceScreenShot(sym);
     Libraries::AppContent::RegisterlibSceAppContent(sym);
     Libraries::PngDec::RegisterlibScePngDec(sym);

src/core/libraries/network/http2.cpp

@@ -0,0 +1,360 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/logging/log.h"
+#include "core/libraries/error_codes.h"
+#include "core/libraries/libs.h"
+#include "core/libraries/network/http2.h"
+
+namespace Libraries::Http2 {
+
+int PS4_SYSV_ABI _Z5dummyv() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2AbortRequest() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2AddCookie() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2AddRequestHeader() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2AuthCacheFlush() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2CookieExport() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2CookieFlush() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2CookieImport() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2CreateCookieBox() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2CreateRequestWithURL() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2CreateTemplate() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2DeleteCookieBox() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2DeleteRequest() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2DeleteTemplate() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2GetAllResponseHeaders() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2GetAuthEnabled() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2GetAutoRedirect() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2GetCookie() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2GetCookieBox() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2GetCookieStats() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2GetMemoryPoolStats() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2GetResponseContentLength() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2GetStatusCode() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2Init(int net_id, int ssl_id, size_t pool_size, int max_requests) {
+    LOG_ERROR(Lib_Http2, "(DUMMY) called");
+    static int id = 0;
+    return ++id;
+}
+
+int PS4_SYSV_ABI sceHttp2ReadData() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2ReadDataAsync() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2RedirectCacheFlush() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2RemoveRequestHeader() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SendRequest() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SendRequestAsync() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetAuthEnabled() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetAuthInfoCallback() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetAutoRedirect() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetConnectionWaitTimeOut() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetConnectTimeOut() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetCookieBox() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetCookieMaxNum() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetCookieMaxNumPerDomain() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetCookieMaxSize() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetCookieRecvCallback() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetCookieSendCallback() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetInflateGZIPEnabled() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetMinSslVersion() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetPreSendCallback() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetRecvTimeOut() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetRedirectCallback() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetRequestContentLength() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetResolveRetry() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetResolveTimeOut() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetSendTimeOut() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetSslCallback() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SetTimeOut() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SslDisableOption() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2SslEnableOption() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2Term() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttp2WaitAsync() {
+    LOG_ERROR(Lib_Http2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterlibSceHttp2(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("AS45QoYHjc4", "libSceHttp2", 1, "libSceHttp2", 1, 1, _Z5dummyv);
+    LIB_FUNCTION("IZ-qjhRqvjk", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2AbortRequest);
+    LIB_FUNCTION("flPxnowtvWY", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2AddCookie);
+    LIB_FUNCTION("nrPfOE8TQu0", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2AddRequestHeader);
+    LIB_FUNCTION("WeuDjj5m4YU", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2AuthCacheFlush);
+    LIB_FUNCTION("JlFGR4v50Kw", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2CookieExport);
+    LIB_FUNCTION("5VlQSzXW-SQ", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2CookieFlush);
+    LIB_FUNCTION("B5ibZI5UlzU", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2CookieImport);
+    LIB_FUNCTION("N4UfjvWJsMw", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2CreateCookieBox);
+    LIB_FUNCTION("mmyOCxQMVYQ", "libSceHttp2", 1, "libSceHttp2", 1, 1,
+                 sceHttp2CreateRequestWithURL);
+    LIB_FUNCTION("+wCt7fCijgk", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2CreateTemplate);
+    LIB_FUNCTION("O9ync3F-JVI", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2DeleteCookieBox);
+    LIB_FUNCTION("c8D9qIjo8EY", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2DeleteRequest);
+    LIB_FUNCTION("pDom5-078DA", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2DeleteTemplate);
+    LIB_FUNCTION("-rdXUi2XW90", "libSceHttp2", 1, "libSceHttp2", 1, 1,
+                 sceHttp2GetAllResponseHeaders);
+    LIB_FUNCTION("m-OL13q8AI8", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2GetAuthEnabled);
+    LIB_FUNCTION("od5QCZhZSfw", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2GetAutoRedirect);
+    LIB_FUNCTION("GQFGj0rYX+A", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2GetCookie);
+    LIB_FUNCTION("IX23slKvtQI", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2GetCookieBox);
+    LIB_FUNCTION("eij7UzkUqK8", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2GetCookieStats);
+    LIB_FUNCTION("otUQuZa-mv0", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2GetMemoryPoolStats);
+    LIB_FUNCTION("o0DBQpFE13o", "libSceHttp2", 1, "libSceHttp2", 1, 1,
+                 sceHttp2GetResponseContentLength);
+    LIB_FUNCTION("9XYJwCf3lEA", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2GetStatusCode);
+    LIB_FUNCTION("3JCe3lCbQ8A", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2Init);
+    LIB_FUNCTION("QygCNNmbGss", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2ReadData);
+    LIB_FUNCTION("bGN-6zbo7ms", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2ReadDataAsync);
+    LIB_FUNCTION("klwUy2Wg+q8", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2RedirectCacheFlush);
+    LIB_FUNCTION("jHdP0CS4ZlA", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2RemoveRequestHeader);
+    LIB_FUNCTION("rbqZig38AT8", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SendRequest);
+    LIB_FUNCTION("A+NVAFu4eCg", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SendRequestAsync);
+    LIB_FUNCTION("jjFahkBPCYs", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SetAuthEnabled);
+    LIB_FUNCTION("Wwj6HbB2mOo", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SetAuthInfoCallback);
+    LIB_FUNCTION("b9AvoIaOuHI", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SetAutoRedirect);
+    LIB_FUNCTION("n8hMLe31OPA", "libSceHttp2", 1, "libSceHttp2", 1, 1,
+                 sceHttp2SetConnectionWaitTimeOut);
+    LIB_FUNCTION("-HIO4VT87v8", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SetConnectTimeOut);
+    LIB_FUNCTION("jrVHsKCXA0g", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SetCookieBox);
+    LIB_FUNCTION("mPKVhQqh2Es", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SetCookieMaxNum);
+    LIB_FUNCTION("o7+WXe4WadE", "libSceHttp2", 1, "libSceHttp2", 1, 1,
+                 sceHttp2SetCookieMaxNumPerDomain);
+    LIB_FUNCTION("6a0N6GPD7RM", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SetCookieMaxSize);
+    LIB_FUNCTION("zdtXKn9X7no", "libSceHttp2", 1, "libSceHttp2", 1, 1,
+                 sceHttp2SetCookieRecvCallback);
+    LIB_FUNCTION("McYmUpQ3-DY", "libSceHttp2", 1, "libSceHttp2", 1, 1,
+                 sceHttp2SetCookieSendCallback);
+    LIB_FUNCTION("uRosf8GQbHQ", "libSceHttp2", 1, "libSceHttp2", 1, 1,
+                 sceHttp2SetInflateGZIPEnabled);
+    LIB_FUNCTION("09tk+kIA1Ns", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SetMinSslVersion);
+    LIB_FUNCTION("UL4Fviw+IAM", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SetPreSendCallback);
+    LIB_FUNCTION("izvHhqgDt44", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SetRecvTimeOut);
+    LIB_FUNCTION("BJgi0CH7al4", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SetRedirectCallback);
+    LIB_FUNCTION("FSAFOzi0FpM", "libSceHttp2", 1, "libSceHttp2", 1, 1,
+                 sceHttp2SetRequestContentLength);
+    LIB_FUNCTION("Gcjh+CisAZM", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SetResolveRetry);
+    LIB_FUNCTION("ACjtE27aErY", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SetResolveTimeOut);
+    LIB_FUNCTION("XPtW45xiLHk", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SetSendTimeOut);
+    LIB_FUNCTION("YrWX+DhPHQY", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SetSslCallback);
+    LIB_FUNCTION("VYMxTcBqSE0", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SetTimeOut);
+    LIB_FUNCTION("B37SruheQ5Y", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SslDisableOption);
+    LIB_FUNCTION("EWcwMpbr5F8", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2SslEnableOption);
+    LIB_FUNCTION("YiBUtz-pGkc", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2Term);
+    LIB_FUNCTION("MOp-AUhdfi8", "libSceHttp2", 1, "libSceHttp2", 1, 1, sceHttp2WaitAsync);
+};
+
+} // namespace Libraries::Http2

src/core/libraries/network/http2.h

@@ -0,0 +1,72 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/types.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
+
+namespace Libraries::Http2 {
+
+int PS4_SYSV_ABI _Z5dummyv();
+int PS4_SYSV_ABI sceHttp2AbortRequest();
+int PS4_SYSV_ABI sceHttp2AddCookie();
+int PS4_SYSV_ABI sceHttp2AddRequestHeader();
+int PS4_SYSV_ABI sceHttp2AuthCacheFlush();
+int PS4_SYSV_ABI sceHttp2CookieExport();
+int PS4_SYSV_ABI sceHttp2CookieFlush();
+int PS4_SYSV_ABI sceHttp2CookieImport();
+int PS4_SYSV_ABI sceHttp2CreateCookieBox();
+int PS4_SYSV_ABI sceHttp2CreateRequestWithURL();
+int PS4_SYSV_ABI sceHttp2CreateTemplate();
+int PS4_SYSV_ABI sceHttp2DeleteCookieBox();
+int PS4_SYSV_ABI sceHttp2DeleteRequest();
+int PS4_SYSV_ABI sceHttp2DeleteTemplate();
+int PS4_SYSV_ABI sceHttp2GetAllResponseHeaders();
+int PS4_SYSV_ABI sceHttp2GetAuthEnabled();
+int PS4_SYSV_ABI sceHttp2GetAutoRedirect();
+int PS4_SYSV_ABI sceHttp2GetCookie();
+int PS4_SYSV_ABI sceHttp2GetCookieBox();
+int PS4_SYSV_ABI sceHttp2GetCookieStats();
+int PS4_SYSV_ABI sceHttp2GetMemoryPoolStats();
+int PS4_SYSV_ABI sceHttp2GetResponseContentLength();
+int PS4_SYSV_ABI sceHttp2GetStatusCode();
+int PS4_SYSV_ABI sceHttp2Init(int net_id, int ssl_id, size_t pool_size, int max_requests);
+int PS4_SYSV_ABI sceHttp2ReadData();
+int PS4_SYSV_ABI sceHttp2ReadDataAsync();
+int PS4_SYSV_ABI sceHttp2RedirectCacheFlush();
+int PS4_SYSV_ABI sceHttp2RemoveRequestHeader();
+int PS4_SYSV_ABI sceHttp2SendRequest();
+int PS4_SYSV_ABI sceHttp2SendRequestAsync();
+int PS4_SYSV_ABI sceHttp2SetAuthEnabled();
+int PS4_SYSV_ABI sceHttp2SetAuthInfoCallback();
+int PS4_SYSV_ABI sceHttp2SetAutoRedirect();
+int PS4_SYSV_ABI sceHttp2SetConnectionWaitTimeOut();
+int PS4_SYSV_ABI sceHttp2SetConnectTimeOut();
+int PS4_SYSV_ABI sceHttp2SetCookieBox();
+int PS4_SYSV_ABI sceHttp2SetCookieMaxNum();
+int PS4_SYSV_ABI sceHttp2SetCookieMaxNumPerDomain();
+int PS4_SYSV_ABI sceHttp2SetCookieMaxSize();
+int PS4_SYSV_ABI sceHttp2SetCookieRecvCallback();
+int PS4_SYSV_ABI sceHttp2SetCookieSendCallback();
+int PS4_SYSV_ABI sceHttp2SetInflateGZIPEnabled();
+int PS4_SYSV_ABI sceHttp2SetMinSslVersion();
+int PS4_SYSV_ABI sceHttp2SetPreSendCallback();
+int PS4_SYSV_ABI sceHttp2SetRecvTimeOut();
+int PS4_SYSV_ABI sceHttp2SetRedirectCallback();
+int PS4_SYSV_ABI sceHttp2SetRequestContentLength();
+int PS4_SYSV_ABI sceHttp2SetResolveRetry();
+int PS4_SYSV_ABI sceHttp2SetResolveTimeOut();
+int PS4_SYSV_ABI sceHttp2SetSendTimeOut();
+int PS4_SYSV_ABI sceHttp2SetSslCallback();
+int PS4_SYSV_ABI sceHttp2SetTimeOut();
+int PS4_SYSV_ABI sceHttp2SslDisableOption();
+int PS4_SYSV_ABI sceHttp2SslEnableOption();
+int PS4_SYSV_ABI sceHttp2Term();
+int PS4_SYSV_ABI sceHttp2WaitAsync();
+
+void RegisterlibSceHttp2(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::Http2

src/core/libraries/network/netctl.cpp

@@ -93,7 +93,7 @@ int PS4_SYSV_ABI sceNetCtlUnregisterCallbackV6() {
 }
 
 int PS4_SYSV_ABI sceNetCtlCheckCallback() {
-    netctl.CheckCallback();
+    LOG_DEBUG(Lib_NetCtl, "(STUBBED) called");
     return ORBIS_OK;
 }
 
@@ -373,7 +373,7 @@ int PS4_SYSV_ABI Func_D8DCB6973537A3DC() {
 }
 
 int PS4_SYSV_ABI sceNetCtlCheckCallbackForNpToolkit() {
-    netctl.CheckNpToolkitCallback();
+    LOG_DEBUG(Lib_NetCtl, "(STUBBED) called");
     return ORBIS_OK;
 }
 

src/core/libraries/network/ssl2.cpp

@@ -0,0 +1,353 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/logging/log.h"
+#include "core/libraries/error_codes.h"
+#include "core/libraries/libs.h"
+#include "core/libraries/network/ssl2.h"
+
+namespace Libraries::Ssl2 {
+
+int PS4_SYSV_ABI CA_MGMT_extractKeyBlobEx() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI CA_MGMT_extractPublicKeyInfo() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI CA_MGMT_freeKeyBlob() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI CRYPTO_initAsymmetricKey() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI CRYPTO_uninitAsymmetricKey() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI RSA_verifySignature() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslCheckRecvPending() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslClose() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslConnect() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslCreateConnection() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslCreateSslConnection() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslDeleteConnection() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslDeleteSslConnection() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslDisableOption() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslDisableOptionInternal() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslDisableOptionInternalInsecure() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslDisableVerifyOption() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslEnableOption() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslEnableOptionInternal() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslEnableVerifyOption() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslFreeCaCerts() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslFreeCaList() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslFreeSslCertName() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslGetAlpnSelected() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslGetCaCerts() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslGetCaList() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslGetFingerprint() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslGetIssuerName() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslGetMemoryPoolStats() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslGetNameEntryCount() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslGetNameEntryInfo() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslGetNanoSSLModuleId() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslGetNotAfter() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslGetNotBefore() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslGetPeerCert() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslGetPem() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslGetSerialNumber() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslGetSslError() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslGetSubjectName() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslInit(std::size_t poolSize) {
+    LOG_ERROR(Lib_Ssl2, "(DUMMY) called poolSize = {}", poolSize);
+    // return a value >1
+    static int id = 0;
+    return ++id;
+}
+
+int PS4_SYSV_ABI sceSslLoadCert() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslLoadRootCACert() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslRead() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslRecv() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslReuseConnection() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslSend() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslSetAlpn() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslSetMinSslVersion() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslSetSslVersion() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslSetVerifyCallback() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslTerm() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslUnloadCert() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSslWrite() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI VLONG_freeVlongQueue() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_22E76E60BC0587D7() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_28F8791A771D39C7() {
+    LOG_ERROR(Lib_Ssl2, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterlibSceSsl2(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("Md+HYkCBZB4", "libSceSsl", 1, "libSceSsl", 2, 1, CA_MGMT_extractKeyBlobEx);
+    LIB_FUNCTION("9bKYzKP6kYU", "libSceSsl", 1, "libSceSsl", 2, 1, CA_MGMT_extractPublicKeyInfo);
+    LIB_FUNCTION("ipLIammTj2Q", "libSceSsl", 1, "libSceSsl", 2, 1, CA_MGMT_freeKeyBlob);
+    LIB_FUNCTION("PRWr3-ytpdg", "libSceSsl", 1, "libSceSsl", 2, 1, CRYPTO_initAsymmetricKey);
+    LIB_FUNCTION("cW7VCIMCh9A", "libSceSsl", 1, "libSceSsl", 2, 1, CRYPTO_uninitAsymmetricKey);
+    LIB_FUNCTION("pBwtarKd7eg", "libSceSsl", 1, "libSceSsl", 2, 1, RSA_verifySignature);
+    LIB_FUNCTION("1VM0h1JrUfA", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslCheckRecvPending);
+    LIB_FUNCTION("viRXSHZYd0c", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslClose);
+    LIB_FUNCTION("zXvd6iNyfgc", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslConnect);
+    LIB_FUNCTION("tuscfitnhEo", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslCreateConnection);
+    LIB_FUNCTION("P14ATpXc4J8", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslCreateSslConnection);
+    LIB_FUNCTION("HJ1n138CQ2g", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslDeleteConnection);
+    LIB_FUNCTION("hwrHV6Pprk4", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslDeleteSslConnection);
+    LIB_FUNCTION("iLKz4+ukLqk", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslDisableOption);
+    LIB_FUNCTION("-WqxBRAUVM4", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslDisableOptionInternal);
+    LIB_FUNCTION("w1+L-27nYas", "libSceSsl", 1, "libSceSsl", 2, 1,
+                 sceSslDisableOptionInternalInsecure);
+    LIB_FUNCTION("PwsHbErG+e8", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslDisableVerifyOption);
+    LIB_FUNCTION("m-zPyAsIpco", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslEnableOption);
+    LIB_FUNCTION("g-zCwUKstEQ", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslEnableOptionInternal);
+    LIB_FUNCTION("po1X86mgHDU", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslEnableVerifyOption);
+    LIB_FUNCTION("qIvLs0gYxi0", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslFreeCaCerts);
+    LIB_FUNCTION("+DzXseDVkeI", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslFreeCaList);
+    LIB_FUNCTION("RwXD8grHZHM", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslFreeSslCertName);
+    LIB_FUNCTION("4O7+bRkRUe8", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslGetAlpnSelected);
+    LIB_FUNCTION("TDfQqO-gMbY", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslGetCaCerts);
+    LIB_FUNCTION("qOn+wm28wmA", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslGetCaList);
+    LIB_FUNCTION("brRtwGBu4A8", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslGetFingerprint);
+    LIB_FUNCTION("7whYpYfHP74", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslGetIssuerName);
+    LIB_FUNCTION("-PoIzr3PEk0", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslGetMemoryPoolStats);
+    LIB_FUNCTION("R1ePzopYPYM", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslGetNameEntryCount);
+    LIB_FUNCTION("7RBSTKGrmDA", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslGetNameEntryInfo);
+    LIB_FUNCTION("AzUipl-DpIw", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslGetNanoSSLModuleId);
+    LIB_FUNCTION("xHpt6+2pGYk", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslGetNotAfter);
+    LIB_FUNCTION("Eo0S65Jy28Q", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslGetNotBefore);
+    LIB_FUNCTION("-TbZc8pwPNc", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslGetPeerCert);
+    LIB_FUNCTION("kLB5aGoUJXg", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslGetPem);
+    LIB_FUNCTION("DOwXL+FQMEY", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslGetSerialNumber);
+    LIB_FUNCTION("0XcZknp7-Wc", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslGetSslError);
+    LIB_FUNCTION("dQReuBX9sD8", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslGetSubjectName);
+    LIB_FUNCTION("hdpVEUDFW3s", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslInit);
+    LIB_FUNCTION("Ab7+DH+gYyM", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslLoadCert);
+    LIB_FUNCTION("3-643mGVFJo", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslLoadRootCACert);
+    LIB_FUNCTION("jltWpVKtetg", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslRead);
+    LIB_FUNCTION("hi0veU3L2pU", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslRecv);
+    LIB_FUNCTION("50R2xYaYZwE", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslReuseConnection);
+    LIB_FUNCTION("p5bM5PPufFY", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslSend);
+    LIB_FUNCTION("TL86glUrmUw", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslSetAlpn);
+    LIB_FUNCTION("QWSxBzf6lAg", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslSetMinSslVersion);
+    LIB_FUNCTION("bKaEtQnoUuQ", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslSetSslVersion);
+    LIB_FUNCTION("E4a-ahM57QQ", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslSetVerifyCallback);
+    LIB_FUNCTION("0K1yQ6Lv-Yc", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslTerm);
+    LIB_FUNCTION("UQ+3Qu7v3cA", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslUnloadCert);
+    LIB_FUNCTION("iNjkt9Poblw", "libSceSsl", 1, "libSceSsl", 2, 1, sceSslWrite);
+    LIB_FUNCTION("wcVuyTUr5ys", "libSceSsl", 1, "libSceSsl", 2, 1, VLONG_freeVlongQueue);
+    LIB_FUNCTION("IuduYLwFh9c", "libSceSsl", 1, "libSceSsl", 2, 1, Func_22E76E60BC0587D7);
+    LIB_FUNCTION("KPh5GncdOcc", "libSceSsl", 1, "libSceSsl", 2, 1, Func_28F8791A771D39C7);
+};
+
+} // namespace Libraries::Ssl2

src/core/libraries/network/ssl2.h

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/types.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
+
+namespace Libraries::Ssl2 {
+void RegisterlibSceSsl2(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::Ssl2

src/core/libraries/np_common/np_common_error.h

@@ -0,0 +1,9 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/libraries/error_codes.h"
+
+constexpr int ORBIS_NP_ERROR_INVALID_ARGUMENT = 0x80550003;
+constexpr int ORBIS_NP_UTIL_ERROR_NOT_MATCH = 0x80550609;

src/core/libraries/np_manager/np_manager.cpp

@@ -1,7 +1,6 @@
 // SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/config.h"
 #include "common/logging/log.h"
 #include "core/libraries/error_codes.h"
 #include "core/libraries/libs.h"
@@ -2510,7 +2509,7 @@ struct NpStateCallbackForNpToolkit {
 NpStateCallbackForNpToolkit NpStateCbForNp;
 
 int PS4_SYSV_ABI sceNpCheckCallbackForLib() {
-    Core::ExecuteGuest(NpStateCbForNp.func, 1, OrbisNpState::SignedOut, NpStateCbForNp.userdata);
+    LOG_DEBUG(Lib_NpManager, "(STUBBED) called");
     return ORBIS_OK;
 }
 

src/core/libraries/np_web_api/np_web_api.cpp

@@ -0,0 +1,692 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/logging/log.h"
+#include "core/libraries/error_codes.h"
+#include "core/libraries/libs.h"
+#include "core/libraries/np_web_api/np_web_api.h"
+
+namespace Libraries::NpWebApi {
+
+s32 PS4_SYSV_ABI sceNpWebApiCreateContext() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiCreatePushEventFilter() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiCreateServicePushEventFilter() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiDeletePushEventFilter() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiDeleteServicePushEventFilter() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiRegisterExtdPushEventCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiRegisterNotificationCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiRegisterPushEventCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiRegisterServicePushEventCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiUnregisterNotificationCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiUnregisterPushEventCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiUnregisterServicePushEventCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiAbortHandle() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiAbortRequest() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiAddHttpRequestHeader() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiAddMultipartPart() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiCheckTimeout() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiClearAllUnusedConnection() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiClearUnusedConnection() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiCreateContextA() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiCreateExtdPushEventFilter() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiCreateHandle() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiCreateMultipartRequest() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiCreateRequest() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiDeleteContext() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiDeleteExtdPushEventFilter() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiDeleteHandle() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiDeleteRequest() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiGetConnectionStats() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiGetErrorCode() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiGetHttpResponseHeaderValue() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiGetHttpResponseHeaderValueLength() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiGetHttpStatusCode() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiGetMemoryPoolStats() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiInitialize() {
+    LOG_ERROR(Lib_NpWebApi, "(DUMMY) called");
+    static s32 id = 0;
+    return ++id;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiInitializeForPresence() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiIntCreateCtxIndExtdPushEventFilter() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiIntCreateRequest() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiIntCreateServicePushEventFilter() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiIntInitialize() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiIntRegisterServicePushEventCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiIntRegisterServicePushEventCallbackA() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiReadData() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiRegisterExtdPushEventCallbackA() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiSendMultipartRequest() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiSendMultipartRequest2() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiSendRequest() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiSendRequest2() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiSetHandleTimeout() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiSetMaxConnection() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiSetMultipartContentType() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiSetRequestTimeout() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiTerminate() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiUnregisterExtdPushEventCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiUtilityParseNpId() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiVshInitialize() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_064C4ED1EDBEB9E8() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_0783955D4E9563DA() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_1A6D77F3FD8323A8() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_1E0693A26FE0F954() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_24A9B5F1D77000CF() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_24AAA6F50E4C2361() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_24D8853D6B47FC79() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_279B3E9C7C4A9DC5() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_28461E29E9F8D697() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_3C29624704FAB9E0() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_3F027804ED2EC11E() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_4066C94E782997CD() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_47C85356815DBE90() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_4FCE8065437E3B87() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_536280BE3DABB521() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_57A0E1BC724219F3() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_5819749C040B6637() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_6198D0C825E86319() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_61F2B9E8AB093743() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_6BC388E6113F0D44() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_7500F0C4F8DC2D16() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_75A03814C7E9039F() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_789D6026C521416E() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_7DED63D06399EFFF() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_7E55A2DCC03D395A() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_7E6C8F9FB86967F4() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_7F04B7D4A7D41E80() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_8E167252DFA5C957() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_95D0046E504E3B09() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_97284BFDA4F18FDF() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_99E32C1F4737EAB4() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_9CFF661EA0BCBF83() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_9EB0E1F467AC3B29() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_A2318FE6FBABFAA3() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_BA07A2E1BF7B3971() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_BD0803EEE0CC29A0() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_BE6F4E5524BB135F() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_C0D490EB481EA4D0() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_C175D392CA6D084A() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_CD0136AF165D2F2F() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_D1C0ADB7B52FEAB5() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_E324765D18EE4D12() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_E789F980D907B653() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_F9A32E8685627436() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterlibSceNpWebApi(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("x1Y7yiYSk7c", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateContext);
+    LIB_FUNCTION("y5Ta5JCzQHY", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreatePushEventFilter);
+    LIB_FUNCTION("sIFx734+xys", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateServicePushEventFilter);
+    LIB_FUNCTION("zE+R6Rcx3W0", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiDeletePushEventFilter);
+    LIB_FUNCTION("PfQ+f6ws764", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiDeleteServicePushEventFilter);
+    LIB_FUNCTION("vrM02A5Gy1M", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterExtdPushEventCallback);
+    LIB_FUNCTION("HVgWmGIOKdk", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterNotificationCallback);
+    LIB_FUNCTION("PfSTDCgNMgc", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterPushEventCallback);
+    LIB_FUNCTION("kJQJE0uKm5w", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterServicePushEventCallback);
+    LIB_FUNCTION("wjYEvo4xbcA", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiUnregisterNotificationCallback);
+    LIB_FUNCTION("qK4o2656W4w", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiUnregisterPushEventCallback);
+    LIB_FUNCTION("2edrkr0c-wg", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiUnregisterServicePushEventCallback);
+    LIB_FUNCTION("WKcm4PeyJww", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiAbortHandle);
+    LIB_FUNCTION("JzhYTP2fG18", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiAbortRequest);
+    LIB_FUNCTION("joRjtRXTFoc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiAddHttpRequestHeader);
+    LIB_FUNCTION("19KgfJXgM+U", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiAddMultipartPart);
+    LIB_FUNCTION("gVNNyxf-1Sg", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCheckTimeout);
+    LIB_FUNCTION("KQIkDGf80PQ", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiClearAllUnusedConnection);
+    LIB_FUNCTION("f-pgaNSd1zc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiClearUnusedConnection);
+    LIB_FUNCTION("x1Y7yiYSk7c", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateContext);
+    LIB_FUNCTION("zk6c65xoyO0", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateContextA);
+    LIB_FUNCTION("M2BUB+DNEGE", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateExtdPushEventFilter);
+    LIB_FUNCTION("79M-JqvvGo0", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateHandle);
+    LIB_FUNCTION("KBxgeNpoRIQ", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateMultipartRequest);
+    LIB_FUNCTION("y5Ta5JCzQHY", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreatePushEventFilter);
+    LIB_FUNCTION("rdgs5Z1MyFw", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateRequest);
+    LIB_FUNCTION("sIFx734+xys", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateServicePushEventFilter);
+    LIB_FUNCTION("XUjdsSTTZ3U", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiDeleteContext);
+    LIB_FUNCTION("pfaJtb7SQ80", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiDeleteExtdPushEventFilter);
+    LIB_FUNCTION("5Mn7TYwpl30", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiDeleteHandle);
+    LIB_FUNCTION("zE+R6Rcx3W0", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiDeletePushEventFilter);
+    LIB_FUNCTION("noQgleu+KLE", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiDeleteRequest);
+    LIB_FUNCTION("PfQ+f6ws764", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiDeleteServicePushEventFilter);
+    LIB_FUNCTION("UJ8H+7kVQUE", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiGetConnectionStats);
+    LIB_FUNCTION("2qSZ0DgwTsc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiGetErrorCode);
+    LIB_FUNCTION("VwJ5L0Higg0", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiGetHttpResponseHeaderValue);
+    LIB_FUNCTION("743ZzEBzlV8", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiGetHttpResponseHeaderValueLength);
+    LIB_FUNCTION("k210oKgP80Y", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiGetHttpStatusCode);
+    LIB_FUNCTION("3OnubUs02UM", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiGetMemoryPoolStats);
+    LIB_FUNCTION("G3AnLNdRBjE", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, sceNpWebApiInitialize);
+    LIB_FUNCTION("FkuwsD64zoQ", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiInitializeForPresence);
+    LIB_FUNCTION("c1pKoztonB8", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiIntCreateCtxIndExtdPushEventFilter);
+    LIB_FUNCTION("N2Jbx4tIaQ4", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiIntCreateRequest);
+    LIB_FUNCTION("TZSep4xB4EY", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiIntCreateServicePushEventFilter);
+    LIB_FUNCTION("8Vjplhyyc44", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiIntInitialize);
+    LIB_FUNCTION("VjVukb2EWPc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiIntRegisterServicePushEventCallback);
+    LIB_FUNCTION("sfq23ZVHVEw", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiIntRegisterServicePushEventCallbackA);
+    LIB_FUNCTION("CQtPRSF6Ds8", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, sceNpWebApiReadData);
+    LIB_FUNCTION("vrM02A5Gy1M", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterExtdPushEventCallback);
+    LIB_FUNCTION("jhXKGQJ4egI", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterExtdPushEventCallbackA);
+    LIB_FUNCTION("HVgWmGIOKdk", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterNotificationCallback);
+    LIB_FUNCTION("PfSTDCgNMgc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterPushEventCallback);
+    LIB_FUNCTION("kJQJE0uKm5w", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterServicePushEventCallback);
+    LIB_FUNCTION("KCItz6QkeGs", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiSendMultipartRequest);
+    LIB_FUNCTION("DsPOTEvSe7M", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiSendMultipartRequest2);
+    LIB_FUNCTION("kVbL4hL3K7w", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiSendRequest);
+    LIB_FUNCTION("KjNeZ-29ysQ", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiSendRequest2);
+    LIB_FUNCTION("6g6q-g1i4XU", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiSetHandleTimeout);
+    LIB_FUNCTION("gRiilVCvfAI", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiSetMaxConnection);
+    LIB_FUNCTION("i0dr6grIZyc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiSetMultipartContentType);
+    LIB_FUNCTION("qWcbJkBj1Lg", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiSetRequestTimeout);
+    LIB_FUNCTION("asz3TtIqGF8", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, sceNpWebApiTerminate);
+    LIB_FUNCTION("PqCY25FMzPs", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiUnregisterExtdPushEventCallback);
+    LIB_FUNCTION("wjYEvo4xbcA", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiUnregisterNotificationCallback);
+    LIB_FUNCTION("qK4o2656W4w", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiUnregisterPushEventCallback);
+    LIB_FUNCTION("2edrkr0c-wg", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiUnregisterServicePushEventCallback);
+    LIB_FUNCTION("or0e885BlXo", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiUtilityParseNpId);
+    LIB_FUNCTION("uRsskUhAfnM", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiVshInitialize);
+    LIB_FUNCTION("BkxO0e2+ueg", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_064C4ED1EDBEB9E8);
+    LIB_FUNCTION("B4OVXU6VY9o", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_0783955D4E9563DA);
+    LIB_FUNCTION("Gm138-2DI6g", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_1A6D77F3FD8323A8);
+    LIB_FUNCTION("HgaTom-g+VQ", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_1E0693A26FE0F954);
+    LIB_FUNCTION("JKm18ddwAM8", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_24A9B5F1D77000CF);
+    LIB_FUNCTION("JKqm9Q5MI2E", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_24AAA6F50E4C2361);
+    LIB_FUNCTION("JNiFPWtH-Hk", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_24D8853D6B47FC79);
+    LIB_FUNCTION("J5s+nHxKncU", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_279B3E9C7C4A9DC5);
+    LIB_FUNCTION("KEYeKen41pc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_28461E29E9F8D697);
+    LIB_FUNCTION("PCliRwT6ueA", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_3C29624704FAB9E0);
+    LIB_FUNCTION("PwJ4BO0uwR4", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_3F027804ED2EC11E);
+    LIB_FUNCTION("QGbJTngpl80", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_4066C94E782997CD);
+    LIB_FUNCTION("R8hTVoFdvpA", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_47C85356815DBE90);
+    LIB_FUNCTION("T86AZUN+O4c", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_4FCE8065437E3B87);
+    LIB_FUNCTION("U2KAvj2rtSE", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_536280BE3DABB521);
+    LIB_FUNCTION("V6DhvHJCGfM", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_57A0E1BC724219F3);
+    LIB_FUNCTION("WBl0nAQLZjc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_5819749C040B6637);
+    LIB_FUNCTION("YZjQyCXoYxk", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_6198D0C825E86319);
+    LIB_FUNCTION("YfK56KsJN0M", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_61F2B9E8AB093743);
+    LIB_FUNCTION("a8OI5hE-DUQ", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_6BC388E6113F0D44);
+    LIB_FUNCTION("dQDwxPjcLRY", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_7500F0C4F8DC2D16);
+    LIB_FUNCTION("daA4FMfpA58", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_75A03814C7E9039F);
+    LIB_FUNCTION("eJ1gJsUhQW4", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_789D6026C521416E);
+    LIB_FUNCTION("fe1j0GOZ7-8", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_7DED63D06399EFFF);
+    LIB_FUNCTION("flWi3MA9OVo", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_7E55A2DCC03D395A);
+    LIB_FUNCTION("fmyPn7hpZ-Q", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_7E6C8F9FB86967F4);
+    LIB_FUNCTION("fwS31KfUHoA", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_7F04B7D4A7D41E80);
+    LIB_FUNCTION("jhZyUt+lyVc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_8E167252DFA5C957);
+    LIB_FUNCTION("ldAEblBOOwk", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_95D0046E504E3B09);
+    LIB_FUNCTION("lyhL-aTxj98", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_97284BFDA4F18FDF);
+    LIB_FUNCTION("meMsH0c36rQ", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_99E32C1F4737EAB4);
+    LIB_FUNCTION("nP9mHqC8v4M", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_9CFF661EA0BCBF83);
+    LIB_FUNCTION("nrDh9GesOyk", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_9EB0E1F467AC3B29);
+    LIB_FUNCTION("ojGP5vur+qM", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_A2318FE6FBABFAA3);
+    LIB_FUNCTION("ugei4b97OXE", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_BA07A2E1BF7B3971);
+    LIB_FUNCTION("vQgD7uDMKaA", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_BD0803EEE0CC29A0);
+    LIB_FUNCTION("vm9OVSS7E18", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_BE6F4E5524BB135F);
+    LIB_FUNCTION("wNSQ60gepNA", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_C0D490EB481EA4D0);
+    LIB_FUNCTION("wXXTksptCEo", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_C175D392CA6D084A);
+    LIB_FUNCTION("zQE2rxZdLy8", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_CD0136AF165D2F2F);
+    LIB_FUNCTION("0cCtt7Uv6rU", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_D1C0ADB7B52FEAB5);
+    LIB_FUNCTION("4yR2XRjuTRI", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_E324765D18EE4D12);
+    LIB_FUNCTION("54n5gNkHtlM", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_E789F980D907B653);
+    LIB_FUNCTION("+aMuhoVidDY", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_F9A32E8685627436);
+};
+
+} // namespace Libraries::NpWebApi

src/core/libraries/np_web_api/np_web_api.h

@@ -0,0 +1,116 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/types.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
+
+namespace Libraries::NpWebApi {
+
+s32 PS4_SYSV_ABI sceNpWebApiCreateContext();
+s32 PS4_SYSV_ABI sceNpWebApiCreatePushEventFilter();
+s32 PS4_SYSV_ABI sceNpWebApiCreateServicePushEventFilter();
+s32 PS4_SYSV_ABI sceNpWebApiDeletePushEventFilter();
+s32 PS4_SYSV_ABI sceNpWebApiDeleteServicePushEventFilter();
+s32 PS4_SYSV_ABI sceNpWebApiRegisterExtdPushEventCallback();
+s32 PS4_SYSV_ABI sceNpWebApiRegisterNotificationCallback();
+s32 PS4_SYSV_ABI sceNpWebApiRegisterPushEventCallback();
+s32 PS4_SYSV_ABI sceNpWebApiRegisterServicePushEventCallback();
+s32 PS4_SYSV_ABI sceNpWebApiUnregisterNotificationCallback();
+s32 PS4_SYSV_ABI sceNpWebApiUnregisterPushEventCallback();
+s32 PS4_SYSV_ABI sceNpWebApiUnregisterServicePushEventCallback();
+s32 PS4_SYSV_ABI sceNpWebApiAbortHandle();
+s32 PS4_SYSV_ABI sceNpWebApiAbortRequest();
+s32 PS4_SYSV_ABI sceNpWebApiAddHttpRequestHeader();
+s32 PS4_SYSV_ABI sceNpWebApiAddMultipartPart();
+s32 PS4_SYSV_ABI sceNpWebApiCheckTimeout();
+s32 PS4_SYSV_ABI sceNpWebApiClearAllUnusedConnection();
+s32 PS4_SYSV_ABI sceNpWebApiClearUnusedConnection();
+s32 PS4_SYSV_ABI sceNpWebApiCreateContextA();
+s32 PS4_SYSV_ABI sceNpWebApiCreateExtdPushEventFilter();
+s32 PS4_SYSV_ABI sceNpWebApiCreateHandle();
+s32 PS4_SYSV_ABI sceNpWebApiCreateMultipartRequest();
+s32 PS4_SYSV_ABI sceNpWebApiCreateRequest();
+s32 PS4_SYSV_ABI sceNpWebApiDeleteContext();
+s32 PS4_SYSV_ABI sceNpWebApiDeleteExtdPushEventFilter();
+s32 PS4_SYSV_ABI sceNpWebApiDeleteHandle();
+s32 PS4_SYSV_ABI sceNpWebApiDeleteRequest();
+s32 PS4_SYSV_ABI sceNpWebApiGetConnectionStats();
+s32 PS4_SYSV_ABI sceNpWebApiGetErrorCode();
+s32 PS4_SYSV_ABI sceNpWebApiGetHttpResponseHeaderValue();
+s32 PS4_SYSV_ABI sceNpWebApiGetHttpResponseHeaderValueLength();
+s32 PS4_SYSV_ABI sceNpWebApiGetHttpStatusCode();
+s32 PS4_SYSV_ABI sceNpWebApiGetMemoryPoolStats();
+s32 PS4_SYSV_ABI sceNpWebApiInitialize();
+s32 PS4_SYSV_ABI sceNpWebApiInitializeForPresence();
+s32 PS4_SYSV_ABI sceNpWebApiIntCreateCtxIndExtdPushEventFilter();
+s32 PS4_SYSV_ABI sceNpWebApiIntCreateRequest();
+s32 PS4_SYSV_ABI sceNpWebApiIntCreateServicePushEventFilter();
+s32 PS4_SYSV_ABI sceNpWebApiIntInitialize();
+s32 PS4_SYSV_ABI sceNpWebApiIntRegisterServicePushEventCallback();
+s32 PS4_SYSV_ABI sceNpWebApiIntRegisterServicePushEventCallbackA();
+s32 PS4_SYSV_ABI sceNpWebApiReadData();
+s32 PS4_SYSV_ABI sceNpWebApiRegisterExtdPushEventCallbackA();
+s32 PS4_SYSV_ABI sceNpWebApiSendMultipartRequest();
+s32 PS4_SYSV_ABI sceNpWebApiSendMultipartRequest2();
+s32 PS4_SYSV_ABI sceNpWebApiSendRequest();
+s32 PS4_SYSV_ABI sceNpWebApiSendRequest2();
+s32 PS4_SYSV_ABI sceNpWebApiSetHandleTimeout();
+s32 PS4_SYSV_ABI sceNpWebApiSetMaxConnection();
+s32 PS4_SYSV_ABI sceNpWebApiSetMultipartContentType();
+s32 PS4_SYSV_ABI sceNpWebApiSetRequestTimeout();
+s32 PS4_SYSV_ABI sceNpWebApiTerminate();
+s32 PS4_SYSV_ABI sceNpWebApiUnregisterExtdPushEventCallback();
+s32 PS4_SYSV_ABI sceNpWebApiUtilityParseNpId();
+s32 PS4_SYSV_ABI sceNpWebApiVshInitialize();
+s32 PS4_SYSV_ABI Func_064C4ED1EDBEB9E8();
+s32 PS4_SYSV_ABI Func_0783955D4E9563DA();
+s32 PS4_SYSV_ABI Func_1A6D77F3FD8323A8();
+s32 PS4_SYSV_ABI Func_1E0693A26FE0F954();
+s32 PS4_SYSV_ABI Func_24A9B5F1D77000CF();
+s32 PS4_SYSV_ABI Func_24AAA6F50E4C2361();
+s32 PS4_SYSV_ABI Func_24D8853D6B47FC79();
+s32 PS4_SYSV_ABI Func_279B3E9C7C4A9DC5();
+s32 PS4_SYSV_ABI Func_28461E29E9F8D697();
+s32 PS4_SYSV_ABI Func_3C29624704FAB9E0();
+s32 PS4_SYSV_ABI Func_3F027804ED2EC11E();
+s32 PS4_SYSV_ABI Func_4066C94E782997CD();
+s32 PS4_SYSV_ABI Func_47C85356815DBE90();
+s32 PS4_SYSV_ABI Func_4FCE8065437E3B87();
+s32 PS4_SYSV_ABI Func_536280BE3DABB521();
+s32 PS4_SYSV_ABI Func_57A0E1BC724219F3();
+s32 PS4_SYSV_ABI Func_5819749C040B6637();
+s32 PS4_SYSV_ABI Func_6198D0C825E86319();
+s32 PS4_SYSV_ABI Func_61F2B9E8AB093743();
+s32 PS4_SYSV_ABI Func_6BC388E6113F0D44();
+s32 PS4_SYSV_ABI Func_7500F0C4F8DC2D16();
+s32 PS4_SYSV_ABI Func_75A03814C7E9039F();
+s32 PS4_SYSV_ABI Func_789D6026C521416E();
+s32 PS4_SYSV_ABI Func_7DED63D06399EFFF();
+s32 PS4_SYSV_ABI Func_7E55A2DCC03D395A();
+s32 PS4_SYSV_ABI Func_7E6C8F9FB86967F4();
+s32 PS4_SYSV_ABI Func_7F04B7D4A7D41E80();
+s32 PS4_SYSV_ABI Func_8E167252DFA5C957();
+s32 PS4_SYSV_ABI Func_95D0046E504E3B09();
+s32 PS4_SYSV_ABI Func_97284BFDA4F18FDF();
+s32 PS4_SYSV_ABI Func_99E32C1F4737EAB4();
+s32 PS4_SYSV_ABI Func_9CFF661EA0BCBF83();
+s32 PS4_SYSV_ABI Func_9EB0E1F467AC3B29();
+s32 PS4_SYSV_ABI Func_A2318FE6FBABFAA3();
+s32 PS4_SYSV_ABI Func_BA07A2E1BF7B3971();
+s32 PS4_SYSV_ABI Func_BD0803EEE0CC29A0();
+s32 PS4_SYSV_ABI Func_BE6F4E5524BB135F();
+s32 PS4_SYSV_ABI Func_C0D490EB481EA4D0();
+s32 PS4_SYSV_ABI Func_C175D392CA6D084A();
+s32 PS4_SYSV_ABI Func_CD0136AF165D2F2F();
+s32 PS4_SYSV_ABI Func_D1C0ADB7B52FEAB5();
+s32 PS4_SYSV_ABI Func_E324765D18EE4D12();
+s32 PS4_SYSV_ABI Func_E789F980D907B653();
+s32 PS4_SYSV_ABI Func_F9A32E8685627436();
+
+void RegisterlibSceNpWebApi(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::NpWebApi

src/core/libraries/videoout/driver.cpp

@@ -1,8 +1,6 @@
 // SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <imgui.h>
-
 #include "common/assert.h"
 #include "common/config.h"
 #include "common/debug.h"
@@ -11,6 +9,7 @@
 #include "core/libraries/kernel/time.h"
 #include "core/libraries/videoout/driver.h"
 #include "core/libraries/videoout/videoout_error.h"
+#include "imgui/renderer/imgui_core.h"
 #include "video_core/renderer_vulkan/vk_presenter.h"
 
 extern std::unique_ptr<Vulkan::Presenter> presenter;
@@ -207,6 +206,13 @@ void VideoOutDriver::DrawBlankFrame() {
     presenter->Present(empty_frame);
 }
 
+void VideoOutDriver::DrawLastFrame() {
+    const auto frame = presenter->PrepareLastFrame();
+    if (frame != nullptr) {
+        presenter->Present(frame, true);
+    }
+}
+
 bool VideoOutDriver::SubmitFlip(VideoOutPort* port, s32 index, s64 flip_arg,
                                 bool is_eop /*= false*/) {
     {
@@ -278,17 +284,26 @@ void VideoOutDriver::PresentThread(std::stop_token token) {
         return {};
     };
 
-    auto delay = std::chrono::microseconds{0};
     while (!token.stop_requested()) {
         timer.Start();
 
+        if (DebugState.IsGuestThreadsPaused()) {
+            DrawLastFrame();
+            timer.End();
+            continue;
+        }
+
         // Check if it's time to take a request.
         auto& vblank_status = main_port.vblank_status;
         if (vblank_status.count % (main_port.flip_rate + 1) == 0) {
             const auto request = receive_request();
             if (!request) {
-                if (!main_port.is_open || DebugState.IsGuestThreadsPaused()) {
+                if (timer.GetTotalWait().count() < 0) { // Dont draw too fast
-                    DrawBlankFrame();
+                    if (!main_port.is_open) {
+                        DrawBlankFrame();
+                    } else if (ImGui::Core::MustKeepDrawing()) {
+                        DrawLastFrame();
+                    }
                 }
             } else {
                 Flip(request);

src/core/libraries/videoout/driver.h

@@ -102,7 +102,8 @@ private:
     };
 
     void Flip(const Request& req);
-    void DrawBlankFrame(); // Used when there is no flip request to keep ImGui up to date
+    void DrawBlankFrame(); // Video port out not open
+    void DrawLastFrame();  // Used when there is no flip request
     void SubmitFlipInternal(VideoOutPort* port, s32 index, s64 flip_arg, bool is_eop = false);
     void PresentThread(std::stop_token token);
 

src/emulator.cpp

@@ -66,9 +66,10 @@ Emulator::Emulator() {
     LOG_INFO(Config, "Vulkan vkValidation: {}", Config::vkValidationEnabled());
     LOG_INFO(Config, "Vulkan vkValidationSync: {}", Config::vkValidationSyncEnabled());
     LOG_INFO(Config, "Vulkan vkValidationGpu: {}", Config::vkValidationGpuEnabled());
-    LOG_INFO(Config, "Vulkan rdocEnable: {}", Config::isRdocEnabled());
-    LOG_INFO(Config, "Vulkan rdocMarkersEnable: {}", Config::vkMarkersEnabled());
     LOG_INFO(Config, "Vulkan crashDiagnostics: {}", Config::vkCrashDiagnosticEnabled());
+    LOG_INFO(Config, "Vulkan hostMarkers: {}", Config::vkHostMarkersEnabled());
+    LOG_INFO(Config, "Vulkan guestMarkers: {}", Config::vkGuestMarkersEnabled());
+    LOG_INFO(Config, "Vulkan rdocEnable: {}", Config::isRdocEnabled());
 
     // Create stdin/stdout/stderr
     Common::Singleton<FileSys::HandleTable>::Instance()->CreateStdHandles();

src/imgui/imgui_config.h

@@ -30,6 +30,12 @@ extern void assert_fail_debug_msg(const char* msg);
 #define IM_VEC4_CLASS_EXTRA                                                                        \
     constexpr ImVec4(float _v) : x(_v), y(_v), z(_v), w(_v) {}
 
+namespace ImGui {
+struct Texture;
+}
+#define ImTextureID ImTextureID
+using ImTextureID = ::ImGui::Texture*;
+
 #ifdef IMGUI_USE_WCHAR32
 #error "This project uses 16 bits wchar standard like Orbis"
 #endif

src/imgui/renderer/imgui_core.cpp

@@ -6,6 +6,7 @@
 
 #include "common/config.h"
 #include "common/path_util.h"
+#include "core/debug_state.h"
 #include "core/devtools/layer.h"
 #include "imgui/imgui_layer.h"
 #include "imgui_core.h"
@@ -167,7 +168,7 @@ bool ProcessEvent(SDL_Event* event) {
     }
 }
 
-void NewFrame() {
+ImGuiID NewFrame(bool is_reusing_frame) {
     {
         std::scoped_lock lock{change_layers_mutex};
         while (!change_layers.empty()) {
@@ -182,24 +183,31 @@ void NewFrame() {
         }
     }
 
-    Sdl::NewFrame();
+    Sdl::NewFrame(is_reusing_frame);
     ImGui::NewFrame();
 
-    DockSpaceOverViewport(0, GetMainViewport(), ImGuiDockNodeFlags_PassthruCentralNode);
+    ImGuiWindowFlags flags = ImGuiDockNodeFlags_PassthruCentralNode;
+    if (!DebugState.IsShowingDebugMenuBar()) {
+        flags |= ImGuiDockNodeFlags_NoTabBar;
+    }
+    ImGuiID dockId = DockSpaceOverViewport(0, GetMainViewport(), flags);
 
     for (auto* layer : layers) {
         layer->Draw();
     }
+
+    return dockId;
 }
 
-void Render(const vk::CommandBuffer& cmdbuf, ::Vulkan::Frame* frame) {
+void Render(const vk::CommandBuffer& cmdbuf, const vk::ImageView& image_view,
+            const vk::Extent2D& extent) {
     ImGui::Render();
     ImDrawData* draw_data = GetDrawData();
     if (draw_data->CmdListsCount == 0) {
         return;
     }
 
-    if (Config::vkMarkersEnabled()) {
+    if (Config::vkHostMarkersEnabled()) {
         cmdbuf.beginDebugUtilsLabelEXT(vk::DebugUtilsLabelEXT{
             .pLabelName = "ImGui Render",
         });
@@ -207,16 +215,16 @@ void Render(const vk::CommandBuffer& cmdbuf, ::Vulkan::Frame* frame) {
 
     vk::RenderingAttachmentInfo color_attachments[1]{
         {
-            .imageView = frame->image_view,
+            .imageView = image_view,
             .imageLayout = vk::ImageLayout::eColorAttachmentOptimal,
-            .loadOp = vk::AttachmentLoadOp::eLoad,
+            .loadOp = vk::AttachmentLoadOp::eClear,
             .storeOp = vk::AttachmentStoreOp::eStore,
         },
     };
     vk::RenderingInfo render_info{};
     render_info.renderArea = vk::Rect2D{
         .offset = {0, 0},
-        .extent = {frame->width, frame->height},
+        .extent = extent,
     };
     render_info.layerCount = 1;
     render_info.colorAttachmentCount = 1;
@@ -224,11 +232,15 @@ void Render(const vk::CommandBuffer& cmdbuf, ::Vulkan::Frame* frame) {
     cmdbuf.beginRendering(render_info);
     Vulkan::RenderDrawData(*draw_data, cmdbuf);
     cmdbuf.endRendering();
-    if (Config::vkMarkersEnabled()) {
+    if (Config::vkHostMarkersEnabled()) {
         cmdbuf.endDebugUtilsLabelEXT();
     }
 }
 
+bool MustKeepDrawing() {
+    return layers.size() > 1 || DebugState.IsShowingDebugMenuBar();
+}
+
 } // namespace Core
 
 void Layer::AddLayer(Layer* layer) {

src/imgui/renderer/imgui_core.h

@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <imgui.h>
+
 #include "video_core/renderer_vulkan/vk_instance.h"
 #include "vulkan/vulkan_handles.hpp"
 
@@ -24,8 +26,11 @@ void Shutdown(const vk::Device& device);
 
 bool ProcessEvent(SDL_Event* event);
 
-void NewFrame();
+ImGuiID NewFrame(bool is_reusing_frame = false);
 
-void Render(const vk::CommandBuffer& cmdbuf, Vulkan::Frame* frame);
+void Render(const vk::CommandBuffer& cmdbuf, const vk::ImageView& image_view,
+            const vk::Extent2D& extent);
+
+bool MustKeepDrawing(); // Force the emulator redraw
 
 } // namespace ImGui::Core

src/imgui/renderer/imgui_impl_sdl3.cpp

@@ -5,13 +5,13 @@
 
 #include <imgui.h>
 #include "common/config.h"
+#include "core/debug_state.h"
 #include "imgui_impl_sdl3.h"
 
 // SDL
 #include <SDL3/SDL.h>
 #if defined(__APPLE__)
 #include <TargetConditionals.h>
-#include <dispatch/dispatch.h>
 #endif
 #ifdef _WIN32
 #ifndef WIN32_LEAN_AND_MEAN
@@ -27,6 +27,7 @@ struct SdlData {
     SDL_Window* window{};
     SDL_WindowID window_id{};
     Uint64 time{};
+    Uint64 nonReusedtime{};
     const char* clipboard_text_data{};
 
     // IME handling
@@ -45,6 +46,11 @@ struct SdlData {
     ImVector<SDL_Gamepad*> gamepads{};
     GamepadMode gamepad_mode{};
     bool want_update_gamepads_list{};
+
+    // Framerate counting (based on ImGui impl)
+    std::array<float, 60> framerateSecPerFrame;
+    int framerateSecPerFrameIdx{};
+    float framerateSecPerFrameAcc{};
 };
 
 // Backend data stored in io.BackendPlatformUserData to allow support for multiple Dear ImGui
@@ -72,33 +78,25 @@ static void PlatformSetImeData(ImGuiContext*, ImGuiViewport* viewport, ImGuiPlat
     auto window_id = (SDL_WindowID)(intptr_t)viewport->PlatformHandle;
     SDL_Window* window = SDL_GetWindowFromID(window_id);
     if ((!data->WantVisible || bd->ime_window != window) && bd->ime_window != nullptr) {
-        auto stop_input = [&bd] { SDL_StopTextInput(bd->ime_window); };
+        SDL_RunOnMainThread(
-#ifdef __APPLE__
+            [](void* userdata) { SDL_StopTextInput(static_cast<SDL_Window*>(userdata)); },
-        dispatch_sync(dispatch_get_main_queue(), ^{
+            bd->ime_window, true);
-          stop_input();
-        });
-#else
-        stop_input();
-#endif
         bd->ime_window = nullptr;
     }
     if (data->WantVisible) {
-        SDL_Rect r;
+        std::pair<SDL_Window*, SDL_Rect> usr_data;
-        r.x = (int)data->InputPos.x;
+        usr_data.first = window;
-        r.y = (int)data->InputPos.y;
+        usr_data.second.x = (int)data->InputPos.x;
-        r.w = 1;
+        usr_data.second.y = (int)data->InputPos.y;
-        r.h = (int)data->InputLineHeight;
+        usr_data.second.w = 1;
-        const auto start_input = [&window, &r] {
+        usr_data.second.h = (int)data->InputLineHeight;
-            SDL_SetTextInputArea(window, &r, 0);
+        SDL_RunOnMainThread(
-            SDL_StartTextInput(window);
+            [](void* userdata) {
-        };
+                auto* params = static_cast<std::pair<SDL_Window*, SDL_Rect>*>(userdata);
-#ifdef __APPLE__
+                SDL_SetTextInputArea(params->first, &params->second, 0);
-        dispatch_sync(dispatch_get_main_queue(), ^{
+                SDL_StartTextInput(params->first);
-          start_input();
+            },
-        });
+            &usr_data, true);
-#else
-        start_input();
-#endif
         bd->ime_window = window;
     }
 }
@@ -794,7 +792,7 @@ static void UpdateGamepads() {
                         +thumb_dead_zone, +32767);
 }
 
-void NewFrame() {
+void NewFrame(bool is_reusing_frame) {
     SdlData* bd = GetBackendData();
     IM_ASSERT(bd != nullptr && "No platform backend to shutdown, or already shutdown?");
     ImGuiIO& io = ImGui::GetIO();
@@ -807,9 +805,29 @@ void NewFrame() {
     if (current_time <= bd->time)
         current_time = bd->time + 1;
     io.DeltaTime = bd->time > 0 ? (float)((double)(current_time - bd->time) / (double)frequency)
-                                : (float)(1.0f / 60.0f);
+                                : 1.0f / 60.0f;
     bd->time = current_time;
 
+    if (!is_reusing_frame) {
+        if (current_time <= bd->nonReusedtime)
+            current_time = bd->nonReusedtime + 1;
+        float deltaTime =
+            bd->nonReusedtime > 0
+                ? (float)((double)(current_time - bd->nonReusedtime) / (double)frequency)
+                : 1.0f / 60.0f;
+        bd->nonReusedtime = current_time;
+        DebugState.FrameDeltaTime = deltaTime;
+
+        int& frameIdx = bd->framerateSecPerFrameIdx;
+        float& framerateSec = bd->framerateSecPerFrame[frameIdx];
+        float& acc = bd->framerateSecPerFrameAcc;
+        int count = bd->framerateSecPerFrame.size();
+        acc += deltaTime - framerateSec;
+        framerateSec = deltaTime;
+        frameIdx = (frameIdx + 1) % count;
+        DebugState.Framerate = acc > 0.0f ? 1.0f / (acc / (float)count) : FLT_MAX;
+    }
+
     if (bd->mouse_pending_leave_frame && bd->mouse_pending_leave_frame >= ImGui::GetFrameCount() &&
         bd->mouse_buttons_down == 0) {
         bd->mouse_window_id = 0;

src/imgui/renderer/imgui_impl_sdl3.h

@@ -14,7 +14,7 @@ namespace ImGui::Sdl {
 
 bool Init(SDL_Window* window);
 void Shutdown();
-void NewFrame();
+void NewFrame(bool is_reusing);
 bool ProcessEvent(const SDL_Event* event);
 void OnResize();
 

src/imgui/renderer/imgui_impl_vulkan.cpp

@@ -57,11 +57,12 @@ struct VkData {
     vk::DeviceMemory font_memory{};
     vk::Image font_image{};
     vk::ImageView font_view{};
-    vk::DescriptorSet font_descriptor_set{};
+    ImTextureID font_texture{};
     vk::CommandBuffer font_command_buffer{};
 
     // Render buffers
     WindowRenderBuffers render_buffers{};
+    bool enabled_blending{true};
 
     VkData(const InitInfo init_info) : init_info(init_info) {
         render_buffers.count = init_info.image_count;
@@ -252,8 +253,8 @@ void UploadTextureData::Destroy() {
     const InitInfo& v = bd->init_info;
 
     CheckVkErr(v.device.waitIdle());
-    RemoveTexture(descriptor_set);
+    RemoveTexture(im_texture);
-    descriptor_set = VK_NULL_HANDLE;
+    im_texture = nullptr;
 
     v.device.destroyImageView(image_view, v.allocator);
     image_view = VK_NULL_HANDLE;
@@ -264,8 +265,8 @@ void UploadTextureData::Destroy() {
 }
 
 // Register a texture
-vk::DescriptorSet AddTexture(vk::ImageView image_view, vk::ImageLayout image_layout,
+ImTextureID AddTexture(vk::ImageView image_view, vk::ImageLayout image_layout,
-                             vk::Sampler sampler) {
+                       vk::Sampler sampler) {
     VkData* bd = GetBackendData();
     const InitInfo& v = bd->init_info;
 
@@ -303,7 +304,9 @@ vk::DescriptorSet AddTexture(vk::ImageView image_view, vk::ImageLayout image_lay
         };
         v.device.updateDescriptorSets({write_desc}, {});
     }
-    return descriptor_set;
+    return new Texture{
+        .descriptor_set = descriptor_set,
+    };
 }
 UploadTextureData UploadTexture(const void* data, vk::Format format, u32 width, u32 height,
                                 size_t size) {
@@ -370,7 +373,7 @@ UploadTextureData UploadTexture(const void* data, vk::Format format, u32 width,
     }
 
     // Create descriptor set (ImTextureID)
-    info.descriptor_set = AddTexture(info.image_view, vk::ImageLayout::eShaderReadOnlyOptimal);
+    info.im_texture = AddTexture(info.image_view, vk::ImageLayout::eShaderReadOnlyOptimal);
 
     // Create Upload Buffer
     {
@@ -464,10 +467,12 @@ UploadTextureData UploadTexture(const void* data, vk::Format format, u32 width,
     return info;
 }
 
-void RemoveTexture(vk::DescriptorSet descriptor_set) {
+void RemoveTexture(ImTextureID texture) {
+    IM_ASSERT(texture != nullptr);
     VkData* bd = GetBackendData();
     const InitInfo& v = bd->init_info;
-    v.device.freeDescriptorSets(bd->descriptor_pool, {descriptor_set});
+    v.device.freeDescriptorSets(bd->descriptor_pool, {texture->descriptor_set});
+    delete texture;
 }
 
 static void CreateOrResizeBuffer(RenderBuffer& rb, size_t new_size, vk::BufferUsageFlagBits usage) {
@@ -679,13 +684,7 @@ void RenderDrawData(ImDrawData& draw_data, vk::CommandBuffer command_buffer,
                 command_buffer.setScissor(0, 1, &scissor);
 
                 // Bind DescriptorSet with font or user texture
-                vk::DescriptorSet desc_set[1]{(VkDescriptorSet)pcmd->TextureId};
+                vk::DescriptorSet desc_set[1]{pcmd->TextureId->descriptor_set};
-                if (sizeof(ImTextureID) < sizeof(ImU64)) {
-                    // We don't support texture switches if ImTextureID hasn't been redefined to be
-                    // 64-bit. Do a flaky check that other textures haven't been used.
-                    IM_ASSERT(pcmd->TextureId == (ImTextureID)bd->font_descriptor_set);
-                    desc_set[0] = bd->font_descriptor_set;
-                }
                 command_buffer.bindDescriptorSets(vk::PipelineBindPoint::eGraphics,
                                                   bd->pipeline_layout, 0, {desc_set}, {});
 
@@ -709,7 +708,7 @@ static bool CreateFontsTexture() {
     const InitInfo& v = bd->init_info;
 
     // Destroy existing texture (if any)
-    if (bd->font_view || bd->font_image || bd->font_memory || bd->font_descriptor_set) {
+    if (bd->font_view || bd->font_image || bd->font_memory || bd->font_texture) {
         CheckVkErr(v.queue.waitIdle());
         DestroyFontsTexture();
     }
@@ -782,7 +781,7 @@ static bool CreateFontsTexture() {
     }
 
     // Create the Descriptor Set:
-    bd->font_descriptor_set = AddTexture(bd->font_view, vk::ImageLayout::eShaderReadOnlyOptimal);
+    bd->font_texture = AddTexture(bd->font_view, vk::ImageLayout::eShaderReadOnlyOptimal);
 
     // Create the Upload Buffer:
     vk::DeviceMemory upload_buffer_memory{};
@@ -874,7 +873,7 @@ static bool CreateFontsTexture() {
     }
 
     // Store our identifier
-    io.Fonts->SetTexID(bd->font_descriptor_set);
+    io.Fonts->SetTexID(bd->font_texture);
 
     // End command buffer
     vk::SubmitInfo end_info = {};
@@ -898,9 +897,9 @@ static void DestroyFontsTexture() {
     VkData* bd = GetBackendData();
     const InitInfo& v = bd->init_info;
 
-    if (bd->font_descriptor_set) {
+    if (bd->font_texture) {
-        RemoveTexture(bd->font_descriptor_set);
+        RemoveTexture(bd->font_texture);
-        bd->font_descriptor_set = VK_NULL_HANDLE;
+        bd->font_texture = nullptr;
         io.Fonts->SetTexID(nullptr);
     }
 

src/imgui/renderer/imgui_impl_vulkan.h

@@ -10,6 +10,12 @@
 
 struct ImDrawData;
 
+namespace ImGui {
+struct Texture {
+    vk::DescriptorSet descriptor_set{nullptr};
+};
+} // namespace ImGui
+
 namespace ImGui::Vulkan {
 
 struct InitInfo {
@@ -34,29 +40,32 @@ struct InitInfo {
 struct UploadTextureData {
     vk::Image image;
     vk::ImageView image_view;
-    vk::DescriptorSet descriptor_set;
     vk::DeviceMemory image_memory;
 
     vk::CommandBuffer command_buffer; // Submit to the queue
     vk::Buffer upload_buffer;
     vk::DeviceMemory upload_buffer_memory;
 
+    ImTextureID im_texture;
+
     void Upload();
 
     void Destroy();
 };
 
-vk::DescriptorSet AddTexture(vk::ImageView image_view, vk::ImageLayout image_layout,
+ImTextureID AddTexture(vk::ImageView image_view, vk::ImageLayout image_layout,
-                             vk::Sampler sampler = VK_NULL_HANDLE);
+                       vk::Sampler sampler = VK_NULL_HANDLE);
 
 UploadTextureData UploadTexture(const void* data, vk::Format format, u32 width, u32 height,
                                 size_t size);
 
-void RemoveTexture(vk::DescriptorSet descriptor_set);
+void RemoveTexture(ImTextureID descriptor_set);
 
 bool Init(InitInfo info);
 void Shutdown();
 void RenderDrawData(ImDrawData& draw_data, vk::CommandBuffer command_buffer,
                     vk::Pipeline pipeline = VK_NULL_HANDLE);
 
+void SetBlendEnabled(bool enabled);
+
 } // namespace ImGui::Vulkan

src/imgui/renderer/texture_manager.cpp

@@ -4,6 +4,7 @@
 #include <deque>
 #include <utility>
 
+#include <imgui.h>
 #include "common/assert.h"
 #include "common/config.h"
 #include "common/io_file.h"
@@ -123,7 +124,7 @@ static std::deque<UploadJob> g_upload_list;
 namespace Core::TextureManager {
 
 Inner::~Inner() {
-    if (upload_data.descriptor_set != nullptr) {
+    if (upload_data.im_texture != nullptr) {
         std::unique_lock lk{g_upload_mtx};
         g_upload_list.emplace_back(UploadJob{
             .data = this->upload_data,
@@ -239,7 +240,7 @@ void Submit() {
     }
     if (upload.core != nullptr) {
         upload.core->upload_data.Upload();
-        upload.core->texture_id = upload.core->upload_data.descriptor_set;
+        upload.core->texture_id = upload.core->upload_data.im_texture;
         if (upload.core->count.fetch_sub(1) == 1) {
             delete upload.core;
         }

src/qt_gui/game_list_frame.cpp

@@ -106,6 +106,8 @@ void GameListFrame::PlayBackgroundMusic(QTableWidgetItem* item) {
 void GameListFrame::PopulateGameList() {
     // Do not show status column if it is not enabled
     this->setColumnHidden(2, !Config::getCompatibilityEnabled());
+    this->setColumnHidden(6, !Config::GetLoadGameSizeEnabled());
+
     this->setRowCount(m_game_info->m_games.size());
     ResizeIcons(icon_size);
 

src/qt_gui/game_list_utils.h

@@ -62,11 +62,46 @@ public:
         QDir dir(dirPath);
         QDirIterator it(dir.absolutePath(), QDirIterator::Subdirectories);
         qint64 total = 0;
+
+        if (!Config::GetLoadGameSizeEnabled()) {
+            game.size = FormatSize(0).toStdString();
+            return;
+        }
+
+        // Cache path
+        QFile size_cache_file(Common::FS::GetUserPath(Common::FS::PathType::MetaDataDir) /
+                              game.serial / "size_cache.txt");
+        QFileInfo cacheInfo(size_cache_file);
+        QFileInfo dirInfo(dirPath);
+
+        // Check if cache file exists and is valid
+        if (size_cache_file.exists() && cacheInfo.lastModified() >= dirInfo.lastModified()) {
+            if (size_cache_file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+                QTextStream in(&size_cache_file);
+                QString cachedSize = in.readLine();
+                size_cache_file.close();
+
+                if (!cachedSize.isEmpty()) {
+                    game.size = cachedSize.toStdString();
+                    return;
+                }
+            }
+        }
+
+        // Cache is invalid or does not exist; calculate size
         while (it.hasNext()) {
             it.next();
             total += it.fileInfo().size();
         }
+
         game.size = FormatSize(total).toStdString();
+
+        // Save new cache
+        if (size_cache_file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+            QTextStream out(&size_cache_file);
+            out << QString::fromStdString(game.size) << "\n";
+            size_cache_file.close();
+        }
     }
 
     static QString GetRegion(char region) {

src/qt_gui/settings_dialog.cpp

@@ -315,6 +315,7 @@ void SettingsDialog::LoadValuesFromConfig() {
         toml::find_or<std::string>(data, "General", "FullscreenMode", "Borderless")));
     ui->separateUpdatesCheckBox->setChecked(
         toml::find_or<bool>(data, "General", "separateUpdateEnabled", false));
+    ui->gameSizeCheckBox->setChecked(toml::find_or<bool>(data, "GUI", "loadGameSizeEnabled", true));
     ui->showSplashCheckBox->setChecked(toml::find_or<bool>(data, "General", "showSplash", false));
     ui->logTypeComboBox->setCurrentText(
         QString::fromStdString(toml::find_or<std::string>(data, "General", "logType", "async")));
@@ -568,6 +569,7 @@ void SettingsDialog::UpdateSettings() {
     Config::setDumpShaders(ui->dumpShadersCheckBox->isChecked());
     Config::setNullGpu(ui->nullGpuCheckBox->isChecked());
     Config::setSeparateUpdateEnabled(ui->separateUpdatesCheckBox->isChecked());
+    Config::setLoadGameSizeEnabled(ui->gameSizeCheckBox->isChecked());
     Config::setShowSplash(ui->showSplashCheckBox->isChecked());
     Config::setDebugDump(ui->debugDump->isChecked());
     Config::setVkValidation(ui->vkValidationCheckBox->isChecked());

src/qt_gui/settings_dialog.ui

@@ -68,7 +68,7 @@
          <x>0</x>
          <y>0</y>
          <width>946</width>
-         <height>536</height>
+         <height>586</height>
         </rect>
        </property>
        <layout class="QVBoxLayout" name="generalTabVLayout" stretch="0">
@@ -134,7 +134,7 @@
                    </property>
                   </widget>
                  </item>
-				 <item>
+                 <item>
                   <widget class="QGroupBox" name="fullscreenModeGroupBox">
                    <property name="title">
                     <string>Fullscreen Mode</string>
@@ -483,6 +483,13 @@
                <property name="bottomMargin">
                 <number>11</number>
                </property>
+               <item>
+                <widget class="QCheckBox" name="gameSizeCheckBox">
+                 <property name="text">
+                  <string>Show Game Size In List</string>
+                 </property>
+                </widget>
+               </item>
                <item>
                 <widget class="QCheckBox" name="playBGMCheckBox">
                  <property name="sizePolicy">
@@ -557,59 +564,59 @@
                    </property>
                   </widget>
                  </item>
+                </layout>
+               </item>
+               <item>
+                <layout class="QVBoxLayout" name="vLayoutTrophy">
+                 <property name="spacing">
+                  <number>6</number>
+                 </property>
+                 <property name="leftMargin">
+                  <number>0</number>
+                 </property>
+                 <property name="bottomMargin">
+                  <number>50</number>
+                 </property>
                  <item>
-                  <layout class="QVBoxLayout" name="vLayoutTrophy">
+                  <layout class="QHBoxLayout" name="hLayoutTrophy">
-                   <property name="spacing">
-                    <number>6</number>
-                   </property>
-                   <property name="leftMargin">
-                    <number>0</number>
-                   </property>
-                   <property name="bottomMargin">
-                    <number>80</number>
-                   </property>
                    <item>
-                    <layout class="QHBoxLayout" name="hLayoutTrophy">
+                    <widget class="QGroupBox" name="trophyGroupBox">
-                     <item>
+                     <property name="title">
-                      <widget class="QGroupBox" name="trophyGroupBox">
+                      <string>Trophy</string>
-                       <property name="title">
+                     </property>
-                        <string>Trophy</string>
+                     <layout class="QVBoxLayout" name="userNameLayout">
-                       </property>
+                      <item>
-                       <layout class="QVBoxLayout" name="userNameLayout">
+                       <widget class="QCheckBox" name="disableTrophycheckBox">
-                        <item>
+                        <property name="text">
-                         <widget class="QCheckBox" name="disableTrophycheckBox">
+                         <string>Disable Trophy Pop-ups</string>
-                          <property name="text">
+                        </property>
-                           <string>Disable Trophy Pop-ups</string>
+                       </widget>
-                          </property>
+                      </item>
-                         </widget>
+                      <item>
-                        </item>
+                       <widget class="QLabel" name="label_Trophy">
-                        <item>
+                        <property name="text">
-                         <widget class="QLabel" name="label_Trophy">
+                         <string>Trophy Key</string>
-                          <property name="text">
+                        </property>
-                           <string>Trophy Key</string>
+                       </widget>
-                          </property>
+                      </item>
-                         </widget>
+                      <item>
-                        </item>
+                       <widget class="QLineEdit" name="trophyKeyLineEdit">
-                        <item>
+                        <property name="minimumSize">
-                         <widget class="QLineEdit" name="trophyKeyLineEdit">
+                         <size>
-                          <property name="minimumSize">
+                          <width>0</width>
-                           <size>
+                          <height>0</height>
-                            <width>0</width>
+                         </size>
-                            <height>0</height>
+                        </property>
-                           </size>
+                        <property name="font">
-                          </property>
+                         <font>
-                          <property name="font">
+                          <pointsize>10</pointsize>
-                           <font>
+                          <bold>false</bold>
-                            <pointsize>10</pointsize>
+                         </font>
-                            <bold>false</bold>
+                        </property>
-                           </font>
+                       </widget>
-                          </property>
+                      </item>
-                         </widget>
+                     </layout>
-                        </item>
+                    </widget>
-                       </layout>
-                      </widget>
-                     </item>
-                    </layout>
                    </item>
                   </layout>
                  </item>
@@ -637,8 +644,8 @@
         <rect>
          <x>0</x>
          <y>0</y>
-         <width>926</width>
+         <width>946</width>
-         <height>536</height>
+         <height>586</height>
         </rect>
        </property>
        <layout class="QVBoxLayout" name="inputTabVLayout" stretch="0,0">
@@ -853,13 +860,13 @@
                  </layout>
                 </widget>
                </item>
-				  <item>
+               <item>
-					  <widget class="QCheckBox" name="motionControlsCheckBox"> 
+                <widget class="QCheckBox" name="motionControlsCheckBox">
-						  <property name="text">
+                 <property name="text">
-							  <string>Enable Motion Controls</string>
+                  <string>Enable Motion Controls</string>
-						  </property>
+                 </property>
-					  </widget>
+                </widget>
-				  </item>
+               </item>
                <item>
                 <widget class="QWidget" name="controllerWidgetSpacer" native="true">
                  <property name="enabled">
@@ -935,8 +942,8 @@
         <rect>
          <x>0</x>
          <y>0</y>
-         <width>926</width>
+         <width>946</width>
-         <height>536</height>
+         <height>586</height>
         </rect>
        </property>
        <layout class="QVBoxLayout" name="graphicsTabVLayout" stretch="0,0">
@@ -1186,8 +1193,8 @@
         <rect>
          <x>0</x>
          <y>0</y>
-         <width>926</width>
+         <width>946</width>
-         <height>536</height>
+         <height>586</height>
         </rect>
        </property>
        <layout class="QVBoxLayout" name="pathsTabLayout" stretch="0">
@@ -1259,8 +1266,8 @@
         <rect>
          <x>0</x>
          <y>0</y>
-         <width>926</width>
+         <width>946</width>
-         <height>536</height>
+         <height>586</height>
         </rect>
        </property>
        <layout class="QVBoxLayout" name="debugTabVLayout" stretch="0,1">

src/qt_gui/translations/ar.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Enable Separate Update Folder</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>عرض حجم اللعبة في القائمة</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>إظهار شاشة البداية</translation>

src/qt_gui/translations/da_DK.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Enable Separate Update Folder</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Vis vis spilstørrelse i listen</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Show Splash</translation>

src/qt_gui/translations/de.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Enable Separate Update Folder</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Zeigen Sie die Spielgröße in der Liste</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Startbildschirm anzeigen</translation>

src/qt_gui/translations/el.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Enable Separate Update Folder</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Εμφάνιση Μεγέθους Παιχνιδιού στη Λίστα</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Show Splash</translation>

src/qt_gui/translations/en.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Enable Separate Update Folder</translation>
 		</message>
+		<message>
+			<source>Show Game Size In List</source>
+			<translation>Show Game Size In List</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Show Splash</translation>

src/qt_gui/translations/es_ES.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Enable Separate Update Folder</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Mostrar Tamaño del Juego en la Lista</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Mostrar splash</translation>

src/qt_gui/translations/fa_IR.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>فعال‌سازی پوشه جداگانه برای به‌روزرسانی</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>نمایش اندازه بازی در لیست</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Splash نمایش</translation>

src/qt_gui/translations/fi.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Ota Käyttöön Erillinen Päivityshakemisto</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Näytä pelin koko luettelossa</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Näytä Aloitusnäyttö</translation>

src/qt_gui/translations/fr.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Dossier séparé pour les mises à jours</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Afficher la taille du jeu dans la liste</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Afficher l'image du jeu</translation>

src/qt_gui/translations/hu_HU.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Külön Frissítési Mappa Engedélyezése</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Játékméret megjelenítése a listában</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Indítóképernyő Mutatása</translation>

src/qt_gui/translations/id.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Enable Separate Update Folder</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Tampilkan Ukuran Game di Daftar</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Show Splash</translation>

src/qt_gui/translations/it.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Abilita Cartella Aggiornamenti Separata</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Mostra la dimensione del gioco nell'elenco</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Mostra Schermata Iniziale</translation>

src/qt_gui/translations/ja_JP.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Enable Separate Update Folder</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>ゲームサイズをリストに表示</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>スプラッシュを表示する</translation>

src/qt_gui/translations/ko_KR.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Enable Separate Update Folder</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>게임 크기를 목록에 표시</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Show Splash</translation>

src/qt_gui/translations/lt_LT.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Enable Separate Update Folder</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Rodyti žaidimo dydį sąraše</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Show Splash</translation>

src/qt_gui/translations/nb.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Aktiver seperat oppdateringsmappe</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Vis spillstørrelse i listen</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Vis velkomstbilde</translation>

src/qt_gui/translations/nl.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Enable Separate Update Folder</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Toon grootte van het spel in de lijst</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Show Splash</translation>

src/qt_gui/translations/pl_PL.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Enable Separate Update Folder</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Pokaż rozmiar gry na liście</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Pokaż ekran powitania</translation>

src/qt_gui/translations/pt_BR.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Habilitar pasta de atualização separada</translation>
 		</message>
+		<message>
+			<source>Show Game Size In List</source>
+			<translation>Mostrar Tamanho do Jogo na Lista</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Mostrar Splash Inicial</translation>

src/qt_gui/translations/ro_RO.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Enable Separate Update Folder</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Afișează dimensiunea jocului în listă</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Show Splash</translation>

src/qt_gui/translations/ru_RU.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Отдельная папка обновлений</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Показать размер игры в списке</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Показывать заставку</translation>

src/qt_gui/translations/sq.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Aktivizo dosjen e ndarë të përditësimit</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Shfaq madhësinë e lojës në listë</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Shfaq Pamjen e nisjes</translation>

src/qt_gui/translations/sv.ts

@@ -1032,6 +1032,10 @@
         <source>Enable Separate Update Folder</source>
         <translation>Aktivera separat uppdateringsmapp</translation>
     </message>
+    <message> 
+        <source>Show Game Size In List</source>
+        <translation>Visa spelstorlek i listan</translation>
+    </message>
     <message>
         <source>Show Splash</source>
         <translation>Visa startskärm</translation>

src/qt_gui/translations/tr_TR.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Enable Separate Update Folder</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Göster oyun boyutunu listede</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Başlangıç Ekranını Göster</translation>

src/qt_gui/translations/uk_UA.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Увімкнути окрему папку оновлень</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Показати розмір гри в списку</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Показувати заставку</translation>

src/qt_gui/translations/vi_VN.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Enable Separate Update Folder</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>Hiển thị Kích thước Game trong Danh sách</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Show Splash</translation>

src/qt_gui/translations/zh_CN.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>启用单独的更新目录</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>显示游戏大小在列表中</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>显示启动画面</translation>
@@ -558,11 +562,11 @@
 		</message>
 		<message>
 			<source>Trophy Key</source>
-			<translation>Trophy Key</translation>
+			<translation>奖杯密钥</translation>
 		</message>
 		<message>
 			<source>Trophy</source>
-			<translation>Trophy</translation>
+			<translation>奖杯</translation>
 		</message>
 		<message>
 			<source>Logger</source>
@@ -782,7 +786,7 @@
 		</message>
 		<message>
 			<source>TrophyKey</source>
-			<translation>Trophy Key:\nKey used to decrypt trophies. Must be obtained from your jailbroken console.\nMust contain only hex characters.</translation>
+			<translation>奖杯密钥：\n用于解密奖杯的密钥。必须从您的越狱主机中获得。\n仅包含十六进制字符。</translation>
 		</message>
 		<message>
 			<source>logTypeGroupBox</source>

src/qt_gui/translations/zh_TW.ts

@@ -540,6 +540,10 @@
 			<source>Enable Separate Update Folder</source>
 			<translation>Enable Separate Update Folder</translation>
 		</message>
+		<message> 
+			<source>Show Game Size In List</source>
+			<translation>顯示遊戲大小在列表中</translation>
+		</message>
 		<message>
 			<source>Show Splash</source>
 			<translation>Show Splash</translation>

src/sdl_window.cpp

@@ -184,7 +184,9 @@ void WindowSDL::InitTimers() {
 
 void WindowSDL::RequestKeyboard() {
     if (keyboard_grab == 0) {
-        SDL_StartTextInput(window);
+        SDL_RunOnMainThread(
+            [](void* userdata) { SDL_StartTextInput(static_cast<SDL_Window*>(userdata)); }, window,
+            true);
     }
     keyboard_grab++;
 }
@@ -193,7 +195,9 @@ void WindowSDL::ReleaseKeyboard() {
     ASSERT(keyboard_grab > 0);
     keyboard_grab--;
     if (keyboard_grab == 0) {
-        SDL_StopTextInput(window);
+        SDL_RunOnMainThread(
+            [](void* userdata) { SDL_StopTextInput(static_cast<SDL_Window*>(userdata)); }, window,
+            true);
     }
 }
 

src/shader_recompiler/backend/spirv/emit_spirv_image.cpp

@@ -255,14 +255,6 @@ void EmitImageWrite(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id
     ctx.OpImageWrite(image, coords, texel, operands.mask, operands.operands);
 }
 
-Id EmitCubeFaceCoord(EmitContext& ctx, IR::Inst* inst, Id cube_coords) {
-    if (ctx.profile.supports_native_cube_calc) {
-        return ctx.OpCubeFaceCoordAMD(ctx.F32[2], cube_coords);
-    } else {
-        UNREACHABLE_MSG("SPIR-V Instruction");
-    }
-}
-
 Id EmitCubeFaceIndex(EmitContext& ctx, IR::Inst* inst, Id cube_coords) {
     if (ctx.profile.supports_native_cube_calc) {
         return ctx.OpCubeFaceIndexAMD(ctx.F32[1], cube_coords);

src/shader_recompiler/backend/spirv/emit_spirv_instructions.h

@@ -439,7 +439,6 @@ Id EmitImageAtomicAnd32(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords,
 Id EmitImageAtomicOr32(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id value);
 Id EmitImageAtomicXor32(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id value);
 Id EmitImageAtomicExchange32(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id value);
-Id EmitCubeFaceCoord(EmitContext& ctx, IR::Inst* inst, Id cube_coords);
 Id EmitCubeFaceIndex(EmitContext& ctx, IR::Inst* inst, Id cube_coords);
 Id EmitLaneId(EmitContext& ctx);
 Id EmitWarpId(EmitContext& ctx);

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -395,7 +395,7 @@ void EmitContext::DefineInputs() {
             DefineVariable(U32[1], spv::BuiltIn::PatchVertices, spv::StorageClass::Input);
         primitive_id = DefineVariable(U32[1], spv::BuiltIn::PrimitiveId, spv::StorageClass::Input);
 
-        const u32 num_attrs = runtime_info.hs_info.ls_stride >> 4;
+        const u32 num_attrs = Common::AlignUp(runtime_info.hs_info.ls_stride, 16) >> 4;
         if (num_attrs > 0) {
             const Id per_vertex_type{TypeArray(F32[4], ConstU32(num_attrs))};
             // The input vertex count isn't statically known, so make length 32 (what glslang does)
@@ -409,7 +409,7 @@ void EmitContext::DefineInputs() {
         tess_coord = DefineInput(F32[3], std::nullopt, spv::BuiltIn::TessCoord);
         primitive_id = DefineVariable(U32[1], spv::BuiltIn::PrimitiveId, spv::StorageClass::Input);
 
-        const u32 num_attrs = runtime_info.vs_info.hs_output_cp_stride >> 4;
+        const u32 num_attrs = Common::AlignUp(runtime_info.vs_info.hs_output_cp_stride, 16) >> 4;
         if (num_attrs > 0) {
             const Id per_vertex_type{TypeArray(F32[4], ConstU32(num_attrs))};
             // The input vertex count isn't statically known, so make length 32 (what glslang does)
@@ -418,7 +418,7 @@ void EmitContext::DefineInputs() {
             Name(input_attr_array, "in_attrs");
         }
 
-        u32 patch_base_location = runtime_info.vs_info.hs_output_cp_stride >> 4;
+        const u32 patch_base_location = num_attrs;
         for (size_t index = 0; index < 30; ++index) {
             if (!(info.uses_patches & (1U << index))) {
                 continue;
@@ -453,7 +453,7 @@ void EmitContext::DefineOutputs() {
                 DefineVariable(type, spv::BuiltIn::CullDistance, spv::StorageClass::Output);
         }
         if (stage == Shader::Stage::Local && runtime_info.ls_info.links_with_tcs) {
-            const u32 num_attrs = runtime_info.ls_info.ls_stride >> 4;
+            const u32 num_attrs = Common::AlignUp(runtime_info.ls_info.ls_stride, 16) >> 4;
             if (num_attrs > 0) {
                 const Id type{TypeArray(F32[4], ConstU32(num_attrs))};
                 output_attr_array = DefineOutput(type, 0);
@@ -488,7 +488,7 @@ void EmitContext::DefineOutputs() {
             Decorate(output_tess_level_inner, spv::Decoration::Patch);
         }
 
-        const u32 num_attrs = runtime_info.hs_info.hs_output_cp_stride >> 4;
+        const u32 num_attrs = Common::AlignUp(runtime_info.hs_info.hs_output_cp_stride, 16) >> 4;
         if (num_attrs > 0) {
             const Id per_vertex_type{TypeArray(F32[4], ConstU32(num_attrs))};
             // The input vertex count isn't statically known, so make length 32 (what glslang does)
@@ -498,7 +498,7 @@ void EmitContext::DefineOutputs() {
             Name(output_attr_array, "out_attrs");
         }
 
-        u32 patch_base_location = runtime_info.hs_info.hs_output_cp_stride >> 4;
+        const u32 patch_base_location = num_attrs;
         for (size_t index = 0; index < 30; ++index) {
             if (!(info.uses_patches & (1U << index))) {
                 continue;

src/shader_recompiler/frontend/translate/vector_alu.cpp

@@ -844,7 +844,7 @@ void Translator::V_FREXP_MANT_F64(const GcnInst& inst) {
 }
 
 void Translator::V_FRACT_F64(const GcnInst& inst) {
-    const IR::F32 src0{GetSrc64<IR::F64>(inst.src[0])};
+    const IR::F64 src0{GetSrc64<IR::F64>(inst.src[0])};
     SetDst64(inst.dst[0], ir.FPFract(src0));
 }
 
@@ -1069,9 +1069,9 @@ void Translator::V_CUBEID_F32(const GcnInst& inst) {
         const auto x_neg_cond{ir.FPLessThan(x, ir.Imm32(0.f))};
         const auto y_neg_cond{ir.FPLessThan(y, ir.Imm32(0.f))};
         const auto z_neg_cond{ir.FPLessThan(z, ir.Imm32(0.f))};
-        const IR::F32 x_face{ir.Select(x_neg_cond, ir.Imm32(5.f), ir.Imm32(4.f))};
+        const IR::F32 x_face{ir.Select(x_neg_cond, ir.Imm32(1.f), ir.Imm32(0.f))};
         const IR::F32 y_face{ir.Select(y_neg_cond, ir.Imm32(3.f), ir.Imm32(2.f))};
-        const IR::F32 z_face{ir.Select(z_neg_cond, ir.Imm32(1.f), ir.Imm32(0.f))};
+        const IR::F32 z_face{ir.Select(z_neg_cond, ir.Imm32(5.f), ir.Imm32(4.f))};
 
         result = SelectCubeResult(x, y, z, x_face, y_face, z_face);
     }
@@ -1083,18 +1083,13 @@ void Translator::V_CUBESC_F32(const GcnInst& inst) {
     const auto y = GetSrc<IR::F32>(inst.src[1]);
     const auto z = GetSrc<IR::F32>(inst.src[2]);
 
-    IR::F32 result;
+    const auto x_neg_cond{ir.FPLessThan(x, ir.Imm32(0.f))};
-    if (profile.supports_native_cube_calc) {
+    const auto z_neg_cond{ir.FPLessThan(z, ir.Imm32(0.f))};
-        const auto coords{ir.CubeFaceCoord(ir.CompositeConstruct(x, y, z))};
+    const IR::F32 x_sc{ir.Select(x_neg_cond, z, ir.FPNeg(z))};
-        result = IR::F32{ir.CompositeExtract(coords, 0)};
+    const IR::F32 y_sc{x};
-    } else {
+    const IR::F32 z_sc{ir.Select(z_neg_cond, ir.FPNeg(x), x)};
-        const auto x_neg_cond{ir.FPLessThan(x, ir.Imm32(0.f))};
-        const auto z_neg_cond{ir.FPLessThan(z, ir.Imm32(0.f))};
-        const IR::F32 x_sc{ir.Select(x_neg_cond, ir.FPNeg(x), x)};
-        const IR::F32 z_sc{ir.Select(z_neg_cond, z, ir.FPNeg(z))};
 
-        result = SelectCubeResult(x, y, z, x_sc, x, z_sc);
+    const auto result{SelectCubeResult(x, y, z, x_sc, y_sc, z_sc)};
-    }
     SetDst(inst.dst[0], result);
 }
 
@@ -1103,17 +1098,11 @@ void Translator::V_CUBETC_F32(const GcnInst& inst) {
     const auto y = GetSrc<IR::F32>(inst.src[1]);
     const auto z = GetSrc<IR::F32>(inst.src[2]);
 
-    IR::F32 result;
+    const auto y_neg_cond{ir.FPLessThan(y, ir.Imm32(0.f))};
-    if (profile.supports_native_cube_calc) {
+    const IR::F32 x_z_tc{ir.FPNeg(y)};
-        const auto coords{ir.CubeFaceCoord(ir.CompositeConstruct(x, y, z))};
+    const IR::F32 y_tc{ir.Select(y_neg_cond, ir.FPNeg(z), z)};
-        result = IR::F32{ir.CompositeExtract(coords, 1)};
-    } else {
-        const auto y_neg_cond{ir.FPLessThan(y, ir.Imm32(0.f))};
-        const IR::F32 x_z_sc{ir.FPNeg(y)};
-        const IR::F32 y_sc{ir.Select(y_neg_cond, ir.FPNeg(z), z)};
 
-        result = SelectCubeResult(x, y, z, x_z_sc, y_sc, x_z_sc);
+    const auto result{SelectCubeResult(x, y, z, x_z_tc, y_tc, x_z_tc)};
-    }
     SetDst(inst.dst[0], result);
 }
 
@@ -1122,7 +1111,7 @@ void Translator::V_CUBEMA_F32(const GcnInst& inst) {
     const auto y = GetSrc<IR::F32>(inst.src[1]);
     const auto z = GetSrc<IR::F32>(inst.src[2]);
 
-    const auto two{ir.Imm32(4.f)};
+    const auto two{ir.Imm32(2.f)};
     const IR::F32 x_major_axis{ir.FPMul(x, two)};
     const IR::F32 y_major_axis{ir.FPMul(y, two)};
     const IR::F32 z_major_axis{ir.FPMul(z, two)};

src/shader_recompiler/frontend/translate/vector_memory.cpp

@@ -164,8 +164,8 @@ void Translator::EmitVectorMemory(const GcnInst& inst) {
 }
 
 void Translator::BUFFER_LOAD(u32 num_dwords, bool is_typed, const GcnInst& inst) {
-    const auto& mtbuf = inst.control.mtbuf;
+    const auto& mubuf = inst.control.mubuf;
-    const bool is_ring = mtbuf.glc && mtbuf.slc;
+    const bool is_ring = mubuf.glc && mubuf.slc;
     const IR::VectorReg vaddr{inst.src[0].code};
     const IR::ScalarReg sharp{inst.src[2].code * 4};
     const IR::Value soffset{GetSrc(inst.src[3])};
@@ -178,22 +178,23 @@ void Translator::BUFFER_LOAD(u32 num_dwords, bool is_typed, const GcnInst& inst)
         if (is_ring) {
             return ir.CompositeConstruct(ir.GetVectorReg(vaddr), soffset);
         }
-        if (mtbuf.idxen && mtbuf.offen) {
+        if (mubuf.idxen && mubuf.offen) {
             return ir.CompositeConstruct(ir.GetVectorReg(vaddr), ir.GetVectorReg(vaddr + 1));
         }
-        if (mtbuf.idxen || mtbuf.offen) {
+        if (mubuf.idxen || mubuf.offen) {
             return ir.GetVectorReg(vaddr);
         }
         return {};
     }();
 
     IR::BufferInstInfo buffer_info{};
-    buffer_info.index_enable.Assign(mtbuf.idxen);
+    buffer_info.index_enable.Assign(mubuf.idxen);
-    buffer_info.offset_enable.Assign(mtbuf.offen);
+    buffer_info.offset_enable.Assign(mubuf.offen);
-    buffer_info.inst_offset.Assign(mtbuf.offset);
+    buffer_info.inst_offset.Assign(mubuf.offset);
-    buffer_info.globally_coherent.Assign(mtbuf.glc);
+    buffer_info.globally_coherent.Assign(mubuf.glc);
-    buffer_info.system_coherent.Assign(mtbuf.slc);
+    buffer_info.system_coherent.Assign(mubuf.slc);
     if (is_typed) {
+        const auto& mtbuf = inst.control.mtbuf;
         const auto dmft = static_cast<AmdGpu::DataFormat>(mtbuf.dfmt);
         const auto nfmt = static_cast<AmdGpu::NumberFormat>(mtbuf.nfmt);
         ASSERT(nfmt == AmdGpu::NumberFormat::Float &&
@@ -220,9 +221,11 @@ void Translator::BUFFER_LOAD_FORMAT(u32 num_dwords, const GcnInst& inst) {
     const auto& mubuf = inst.control.mubuf;
     const IR::VectorReg vaddr{inst.src[0].code};
     const IR::ScalarReg sharp{inst.src[2].code * 4};
-    ASSERT_MSG(!mubuf.offen && mubuf.offset == 0, "Offsets for image buffers are not supported");
     const IR::Value address = [&] -> IR::Value {
-        if (mubuf.idxen) {
+        if (mubuf.idxen && mubuf.offen) {
+            return ir.CompositeConstruct(ir.GetVectorReg(vaddr), ir.GetVectorReg(vaddr + 1));
+        }
+        if (mubuf.idxen || mubuf.offen) {
             return ir.GetVectorReg(vaddr);
         }
         return {};
@@ -230,13 +233,17 @@ void Translator::BUFFER_LOAD_FORMAT(u32 num_dwords, const GcnInst& inst) {
     const IR::Value soffset{GetSrc(inst.src[3])};
     ASSERT_MSG(soffset.IsImmediate() && soffset.U32() == 0, "Non immediate offset not supported");
 
-    IR::BufferInstInfo info{};
+    IR::BufferInstInfo buffer_info{};
-    info.index_enable.Assign(mubuf.idxen);
+    buffer_info.index_enable.Assign(mubuf.idxen);
+    buffer_info.offset_enable.Assign(mubuf.offen);
+    buffer_info.inst_offset.Assign(mubuf.offset);
+    buffer_info.globally_coherent.Assign(mubuf.glc);
+    buffer_info.system_coherent.Assign(mubuf.slc);
 
     const IR::Value handle =
         ir.CompositeConstruct(ir.GetScalarReg(sharp), ir.GetScalarReg(sharp + 1),
                               ir.GetScalarReg(sharp + 2), ir.GetScalarReg(sharp + 3));
-    const IR::Value value = ir.LoadBufferFormat(handle, address, info);
+    const IR::Value value = ir.LoadBufferFormat(handle, address, buffer_info);
     const IR::VectorReg dst_reg{inst.src[1].code};
     for (u32 i = 0; i < num_dwords; i++) {
         ir.SetVectorReg(dst_reg + i, IR::F32{ir.CompositeExtract(value, i)});
@@ -244,8 +251,8 @@ void Translator::BUFFER_LOAD_FORMAT(u32 num_dwords, const GcnInst& inst) {
 }
 
 void Translator::BUFFER_STORE(u32 num_dwords, bool is_typed, const GcnInst& inst) {
-    const auto& mtbuf = inst.control.mtbuf;
+    const auto& mubuf = inst.control.mubuf;
-    const bool is_ring = mtbuf.glc && mtbuf.slc;
+    const bool is_ring = mubuf.glc && mubuf.slc;
     const IR::VectorReg vaddr{inst.src[0].code};
     const IR::ScalarReg sharp{inst.src[2].code * 4};
     const IR::Value soffset{GetSrc(inst.src[3])};
@@ -259,22 +266,23 @@ void Translator::BUFFER_STORE(u32 num_dwords, bool is_typed, const GcnInst& inst
         if (is_ring) {
             return ir.CompositeConstruct(ir.GetVectorReg(vaddr), soffset);
         }
-        if (mtbuf.idxen && mtbuf.offen) {
+        if (mubuf.idxen && mubuf.offen) {
             return ir.CompositeConstruct(ir.GetVectorReg(vaddr), ir.GetVectorReg(vaddr + 1));
         }
-        if (mtbuf.idxen || mtbuf.offen) {
+        if (mubuf.idxen || mubuf.offen) {
             return ir.GetVectorReg(vaddr);
         }
         return {};
     }();
 
     IR::BufferInstInfo buffer_info{};
-    buffer_info.index_enable.Assign(mtbuf.idxen);
+    buffer_info.index_enable.Assign(mubuf.idxen);
-    buffer_info.offset_enable.Assign(mtbuf.offen);
+    buffer_info.offset_enable.Assign(mubuf.offen);
-    buffer_info.inst_offset.Assign(mtbuf.offset);
+    buffer_info.inst_offset.Assign(mubuf.offset);
-    buffer_info.globally_coherent.Assign(mtbuf.glc);
+    buffer_info.globally_coherent.Assign(mubuf.glc);
-    buffer_info.system_coherent.Assign(mtbuf.slc);
+    buffer_info.system_coherent.Assign(mubuf.slc);
     if (is_typed) {
+        const auto& mtbuf = inst.control.mtbuf;
         const auto dmft = static_cast<AmdGpu::DataFormat>(mtbuf.dfmt);
         const auto nfmt = static_cast<AmdGpu::NumberFormat>(mtbuf.nfmt);
         ASSERT(nfmt == AmdGpu::NumberFormat::Float &&
@@ -321,8 +329,12 @@ void Translator::BUFFER_STORE_FORMAT(u32 num_dwords, const GcnInst& inst) {
     const IR::Value soffset{GetSrc(inst.src[3])};
     ASSERT_MSG(soffset.IsImmediate() && soffset.U32() == 0, "Non immediate offset not supported");
 
-    IR::BufferInstInfo info{};
+    IR::BufferInstInfo buffer_info{};
-    info.index_enable.Assign(mubuf.idxen);
+    buffer_info.index_enable.Assign(mubuf.idxen);
+    buffer_info.offset_enable.Assign(mubuf.offen);
+    buffer_info.inst_offset.Assign(mubuf.offset);
+    buffer_info.globally_coherent.Assign(mubuf.glc);
+    buffer_info.system_coherent.Assign(mubuf.slc);
 
     const IR::VectorReg src_reg{inst.src[1].code};
 
@@ -338,7 +350,7 @@ void Translator::BUFFER_STORE_FORMAT(u32 num_dwords, const GcnInst& inst) {
     const IR::Value handle =
         ir.CompositeConstruct(ir.GetScalarReg(sharp), ir.GetScalarReg(sharp + 1),
                               ir.GetScalarReg(sharp + 2), ir.GetScalarReg(sharp + 3));
-    ir.StoreBufferFormat(handle, address, value, info);
+    ir.StoreBufferFormat(handle, address, value, buffer_info);
 }
 
 void Translator::BUFFER_ATOMIC(AtomicOp op, const GcnInst& inst) {
@@ -358,10 +370,12 @@ void Translator::BUFFER_ATOMIC(AtomicOp op, const GcnInst& inst) {
     const IR::U32 soffset{GetSrc(inst.src[3])};
     ASSERT_MSG(soffset.IsImmediate() && soffset.U32() == 0, "Non immediate offset not supported");
 
-    IR::BufferInstInfo info{};
+    IR::BufferInstInfo buffer_info{};
-    info.index_enable.Assign(mubuf.idxen);
+    buffer_info.index_enable.Assign(mubuf.idxen);
-    info.inst_offset.Assign(mubuf.offset);
+    buffer_info.offset_enable.Assign(mubuf.offen);
-    info.offset_enable.Assign(mubuf.offen);
+    buffer_info.inst_offset.Assign(mubuf.offset);
+    buffer_info.globally_coherent.Assign(mubuf.glc);
+    buffer_info.system_coherent.Assign(mubuf.slc);
 
     IR::Value vdata_val = ir.GetVectorReg<Shader::IR::U32>(vdata);
     const IR::Value handle =
@@ -371,27 +385,27 @@ void Translator::BUFFER_ATOMIC(AtomicOp op, const GcnInst& inst) {
     const IR::Value original_val = [&] {
         switch (op) {
         case AtomicOp::Swap:
-            return ir.BufferAtomicSwap(handle, address, vdata_val, info);
+            return ir.BufferAtomicSwap(handle, address, vdata_val, buffer_info);
         case AtomicOp::Add:
-            return ir.BufferAtomicIAdd(handle, address, vdata_val, info);
+            return ir.BufferAtomicIAdd(handle, address, vdata_val, buffer_info);
         case AtomicOp::Smin:
-            return ir.BufferAtomicIMin(handle, address, vdata_val, true, info);
+            return ir.BufferAtomicIMin(handle, address, vdata_val, true, buffer_info);
         case AtomicOp::Umin:
-            return ir.BufferAtomicIMin(handle, address, vdata_val, false, info);
+            return ir.BufferAtomicIMin(handle, address, vdata_val, false, buffer_info);
         case AtomicOp::Smax:
-            return ir.BufferAtomicIMax(handle, address, vdata_val, true, info);
+            return ir.BufferAtomicIMax(handle, address, vdata_val, true, buffer_info);
         case AtomicOp::Umax:
-            return ir.BufferAtomicIMax(handle, address, vdata_val, false, info);
+            return ir.BufferAtomicIMax(handle, address, vdata_val, false, buffer_info);
         case AtomicOp::And:
-            return ir.BufferAtomicAnd(handle, address, vdata_val, info);
+            return ir.BufferAtomicAnd(handle, address, vdata_val, buffer_info);
         case AtomicOp::Or:
-            return ir.BufferAtomicOr(handle, address, vdata_val, info);
+            return ir.BufferAtomicOr(handle, address, vdata_val, buffer_info);
         case AtomicOp::Xor:
-            return ir.BufferAtomicXor(handle, address, vdata_val, info);
+            return ir.BufferAtomicXor(handle, address, vdata_val, buffer_info);
         case AtomicOp::Inc:
-            return ir.BufferAtomicInc(handle, address, vdata_val, info);
+            return ir.BufferAtomicInc(handle, address, vdata_val, buffer_info);
         case AtomicOp::Dec:
-            return ir.BufferAtomicDec(handle, address, vdata_val, info);
+            return ir.BufferAtomicDec(handle, address, vdata_val, buffer_info);
         default:
             UNREACHABLE();
         }

src/shader_recompiler/ir/ir_emitter.cpp

@@ -1758,10 +1758,6 @@ void IREmitter::ImageWrite(const Value& handle, const Value& coords, const U32&
     Inst(Opcode::ImageWrite, Flags{info}, handle, coords, lod, multisampling, color);
 }
 
-[[nodiscard]] Value IREmitter::CubeFaceCoord(const Value& cube_coords) {
-    return Inst(Opcode::CubeFaceCoord, cube_coords);
-}
-
 [[nodiscard]] F32 IREmitter::CubeFaceIndex(const Value& cube_coords) {
     return Inst<F32>(Opcode::CubeFaceIndex, cube_coords);
 }

src/shader_recompiler/ir/ir_emitter.h

@@ -342,7 +342,6 @@ public:
     void ImageWrite(const Value& handle, const Value& coords, const U32& lod,
                     const U32& multisampling, const Value& color, TextureInstInfo info);
 
-    [[nodiscard]] Value CubeFaceCoord(const Value& cube_coords);
     [[nodiscard]] F32 CubeFaceIndex(const Value& cube_coords);
 
     void EmitVertex();

src/shader_recompiler/ir/opcodes.inc

@@ -375,7 +375,6 @@ OPCODE(ImageAtomicXor32,                                    U32,            Opaq
 OPCODE(ImageAtomicExchange32,                               U32,            Opaque,         Opaque,         U32,                                            )
 
 // Cube operations - optional, usable if profile.supports_native_cube_calc
-OPCODE(CubeFaceCoord,                                       F32x2,          F32x3,                                                                          )
 OPCODE(CubeFaceIndex,                                       F32,            F32x3,                                                                          )
 
 // Warp operations

src/shader_recompiler/ir/passes/constant_propagation_pass.cpp

@@ -222,9 +222,15 @@ void FoldMul(IR::Block& block, IR::Inst& inst) {
         return;
     }
     const IR::Value rhs{inst.Arg(1)};
-    if (rhs.IsImmediate() && Arg<T>(rhs) == 0) {
+    if (rhs.IsImmediate()) {
-        inst.ReplaceUsesWithAndRemove(IR::Value(0u));
+        if (Arg<T>(rhs) == 0) {
-        return;
+            inst.ReplaceUsesWithAndRemove(IR::Value(0u));
+            return;
+        }
+        if (Arg<T>(rhs) == 1) {
+            inst.ReplaceUsesWithAndRemove(inst.Arg(0));
+            return;
+        }
     }
 }
 

src/shader_recompiler/ir/passes/hull_shader_transform.cpp

@@ -349,11 +349,11 @@ static IR::F32 ReadTessControlPointAttribute(IR::U32 addr, const u32 stride, IR:
         addr = ir.IAdd(addr, ir.Imm32(off_dw));
     }
     const IR::U32 control_point_index = ir.IDiv(addr, ir.Imm32(stride));
-    const IR::U32 addr_for_attrs = TryOptimizeAddressModulo(addr, stride, ir);
+    const IR::U32 opt_addr = TryOptimizeAddressModulo(addr, stride, ir);
-    const IR::U32 attr_index =
+    const IR::U32 offset = ir.IMod(opt_addr, ir.Imm32(stride));
-        ir.ShiftRightLogical(ir.IMod(addr_for_attrs, ir.Imm32(stride)), ir.Imm32(4u));
+    const IR::U32 attr_index = ir.ShiftRightLogical(offset, ir.Imm32(4u));
     const IR::U32 comp_index =
-        ir.ShiftRightLogical(ir.BitwiseAnd(addr_for_attrs, ir.Imm32(0xFU)), ir.Imm32(2u));
+        ir.ShiftRightLogical(ir.BitwiseAnd(offset, ir.Imm32(0xFU)), ir.Imm32(2u));
     if (is_output_read_in_tcs) {
         return ir.ReadTcsGenericOuputAttribute(control_point_index, attr_index, comp_index);
     } else {
@@ -452,13 +452,13 @@ void HullShaderTransform(IR::Program& program, RuntimeInfo& runtime_info) {
                         if (off_dw > 0) {
                             addr = ir.IAdd(addr, ir.Imm32(off_dw));
                         }
-                        u32 stride = runtime_info.hs_info.hs_output_cp_stride;
+                        const u32 stride = runtime_info.hs_info.hs_output_cp_stride;
                         // Invocation ID array index is implicit, handled by SPIRV backend
-                        const IR::U32 addr_for_attrs = TryOptimizeAddressModulo(addr, stride, ir);
+                        const IR::U32 opt_addr = TryOptimizeAddressModulo(addr, stride, ir);
-                        const IR::U32 attr_index = ir.ShiftRightLogical(
+                        const IR::U32 offset = ir.IMod(opt_addr, ir.Imm32(stride));
-                            ir.IMod(addr_for_attrs, ir.Imm32(stride)), ir.Imm32(4u));
+                        const IR::U32 attr_index = ir.ShiftRightLogical(offset, ir.Imm32(4u));
                         const IR::U32 comp_index = ir.ShiftRightLogical(
-                            ir.BitwiseAnd(addr_for_attrs, ir.Imm32(0xFU)), ir.Imm32(2u));
+                            ir.BitwiseAnd(offset, ir.Imm32(0xFU)), ir.Imm32(2u));
                         ir.SetTcsGenericAttribute(data_component, attr_index, comp_index);
                     } else {
                         ASSERT(output_kind == AttributeRegion::PatchConst);
@@ -535,8 +535,7 @@ void HullShaderTransform(IR::Program& program, RuntimeInfo& runtime_info) {
         // ...
         IR::IREmitter ir{*entry_block, it};
 
-        ASSERT(runtime_info.hs_info.ls_stride % 16 == 0);
+        u32 num_attributes = Common::AlignUp(runtime_info.hs_info.ls_stride, 16) >> 4;
-        u32 num_attributes = runtime_info.hs_info.ls_stride / 16;
         const auto invocation_id = ir.GetAttributeU32(IR::Attribute::InvocationId);
         for (u32 attr_no = 0; attr_no < num_attributes; attr_no++) {
             for (u32 comp = 0; comp < 4; comp++) {

src/shader_recompiler/ir/passes/resource_tracking_pass.cpp

@@ -164,6 +164,7 @@ public:
             return desc.sharp_idx == existing.sharp_idx && desc.is_array == existing.is_array;
         })};
         auto& image = image_resources[index];
+        image.is_atomic |= desc.is_atomic;
         image.is_written |= desc.is_written;
         return index;
     }
@@ -483,55 +484,73 @@ void PatchDataRingAccess(IR::Block& block, IR::Inst& inst, Info& info, Descripto
     inst.SetArg(1, ir.Imm32(binding));
 }
 
+IR::U32 CalculateBufferAddress(IR::IREmitter& ir, const IR::Inst& inst, const Info& info,
+                               const AmdGpu::Buffer& buffer, u32 stride) {
+    const auto inst_info = inst.Flags<IR::BufferInstInfo>();
+
+    // index = (inst_idxen ? vgpr_index : 0) + (const_add_tid_enable ? thread_id[5:0] : 0)
+    IR::U32 index = ir.Imm32(0U);
+    if (inst_info.index_enable) {
+        const IR::U32 vgpr_index{inst_info.offset_enable
+                                     ? IR::U32{ir.CompositeExtract(inst.Arg(1), 0)}
+                                     : IR::U32{inst.Arg(1)}};
+        index = ir.IAdd(index, vgpr_index);
+    }
+    if (buffer.add_tid_enable) {
+        ASSERT_MSG(info.l_stage == LogicalStage::Compute,
+                   "Thread ID buffer addressing is not supported outside of compute.");
+        const IR::U32 thread_id{ir.LaneId()};
+        index = ir.IAdd(index, thread_id);
+    }
+    // offset = (inst_offen ? vgpr_offset : 0) + inst_offset
+    IR::U32 offset = ir.Imm32(inst_info.inst_offset.Value());
+    if (inst_info.offset_enable) {
+        const IR::U32 vgpr_offset = inst_info.index_enable
+                                        ? IR::U32{ir.CompositeExtract(inst.Arg(1), 1)}
+                                        : IR::U32{inst.Arg(1)};
+        offset = ir.IAdd(offset, vgpr_offset);
+    }
+    const IR::U32 const_stride = ir.Imm32(stride);
+    IR::U32 buffer_offset;
+    if (buffer.swizzle_enable) {
+        const IR::U32 const_index_stride = ir.Imm32(buffer.GetIndexStride());
+        const IR::U32 const_element_size = ir.Imm32(buffer.GetElementSize());
+        // index_msb = index / const_index_stride
+        const IR::U32 index_msb{ir.IDiv(index, const_index_stride)};
+        // index_lsb = index % const_index_stride
+        const IR::U32 index_lsb{ir.IMod(index, const_index_stride)};
+        // offset_msb = offset / const_element_size
+        const IR::U32 offset_msb{ir.IDiv(offset, const_element_size)};
+        // offset_lsb = offset % const_element_size
+        const IR::U32 offset_lsb{ir.IMod(offset, const_element_size)};
+        // buffer_offset =
+        //     (index_msb * const_stride + offset_msb * const_element_size) * const_index_stride
+        //     + index_lsb * const_element_size + offset_lsb
+        const IR::U32 buffer_offset_msb = ir.IMul(
+            ir.IAdd(ir.IMul(index_msb, const_stride), ir.IMul(offset_msb, const_element_size)),
+            const_index_stride);
+        const IR::U32 buffer_offset_lsb =
+            ir.IAdd(ir.IMul(index_lsb, const_element_size), offset_lsb);
+        buffer_offset = ir.IAdd(buffer_offset_msb, buffer_offset_lsb);
+    } else {
+        // buffer_offset = index * const_stride + offset
+        buffer_offset = ir.IAdd(ir.IMul(index, const_stride), offset);
+    }
+    return buffer_offset;
+}
+
 void PatchBufferArgs(IR::Block& block, IR::Inst& inst, Info& info) {
     const auto handle = inst.Arg(0);
     const auto buffer_res = info.buffers[handle.U32()];
     const auto buffer = buffer_res.GetSharp(info);
 
-    ASSERT(!buffer.add_tid_enable);
-
     // Address of constant buffer reads can be calculated at IR emission time.
     if (inst.GetOpcode() == IR::Opcode::ReadConstBuffer) {
         return;
     }
 
     IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
-    const auto inst_info = inst.Flags<IR::BufferInstInfo>();
+    inst.SetArg(1, CalculateBufferAddress(ir, inst, info, buffer, buffer.stride));
-
-    const IR::U32 index_stride = ir.Imm32(buffer.index_stride);
-    const IR::U32 element_size = ir.Imm32(buffer.element_size);
-
-    // Compute address of the buffer using the stride.
-    IR::U32 address = ir.Imm32(inst_info.inst_offset.Value());
-    if (inst_info.index_enable) {
-        const IR::U32 index = inst_info.offset_enable ? IR::U32{ir.CompositeExtract(inst.Arg(1), 0)}
-                                                      : IR::U32{inst.Arg(1)};
-        if (buffer.swizzle_enable) {
-            const IR::U32 stride_index_stride =
-                ir.Imm32(static_cast<u32>(buffer.stride * buffer.index_stride));
-            const IR::U32 index_msb = ir.IDiv(index, index_stride);
-            const IR::U32 index_lsb = ir.IMod(index, index_stride);
-            address = ir.IAdd(address, ir.IAdd(ir.IMul(index_msb, stride_index_stride),
-                                               ir.IMul(index_lsb, element_size)));
-        } else {
-            address = ir.IAdd(address, ir.IMul(index, ir.Imm32(buffer.GetStride())));
-        }
-    }
-    if (inst_info.offset_enable) {
-        const IR::U32 offset = inst_info.index_enable ? IR::U32{ir.CompositeExtract(inst.Arg(1), 1)}
-                                                      : IR::U32{inst.Arg(1)};
-        if (buffer.swizzle_enable) {
-            const IR::U32 element_size_index_stride =
-                ir.Imm32(buffer.element_size * buffer.index_stride);
-            const IR::U32 offset_msb = ir.IDiv(offset, element_size);
-            const IR::U32 offset_lsb = ir.IMod(offset, element_size);
-            address = ir.IAdd(address,
-                              ir.IAdd(ir.IMul(offset_msb, element_size_index_stride), offset_lsb));
-        } else {
-            address = ir.IAdd(address, offset);
-        }
-    }
-    inst.SetArg(1, address);
 }
 
 void PatchTextureBufferArgs(IR::Block& block, IR::Inst& inst, Info& info) {
@@ -539,8 +558,15 @@ void PatchTextureBufferArgs(IR::Block& block, IR::Inst& inst, Info& info) {
     const auto buffer_res = info.texture_buffers[handle.U32()];
     const auto buffer = buffer_res.GetSharp(info);
 
-    ASSERT(!buffer.swizzle_enable && !buffer.add_tid_enable);
+    // Only linear addressing with index is supported currently, since we cannot yet
+    // address with sub-texel granularity.
+    const auto inst_info = inst.Flags<IR::BufferInstInfo>();
+    ASSERT_MSG(!buffer.swizzle_enable && !inst_info.offset_enable && inst_info.inst_offset == 0,
+               "Unsupported texture buffer address mode.");
+
     IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
+    // Stride of 1 to get an index into formatted data. See above addressing limitations.
+    inst.SetArg(1, CalculateBufferAddress(ir, inst, info, buffer, 1U));
 
     if (inst.GetOpcode() == IR::Opcode::StoreBufferFormatF32) {
         const auto swizzled = ApplySwizzle(ir, inst.Arg(2), buffer.DstSelect());

src/shader_recompiler/specialization.h

@@ -21,10 +21,16 @@ struct VsAttribSpecialization {
 struct BufferSpecialization {
     u16 stride : 14;
     u16 is_storage : 1;
+    u16 swizzle_enable : 1;
+    u8 index_stride : 2 = 0;
+    u8 element_size : 2 = 0;
     u32 size = 0;
 
     bool operator==(const BufferSpecialization& other) const {
         return stride == other.stride && is_storage == other.is_storage &&
+               swizzle_enable == other.swizzle_enable &&
+               (!swizzle_enable ||
+                (index_stride == other.index_stride && element_size == other.element_size)) &&
                (size >= other.is_storage || is_storage);
     }
 };
@@ -101,6 +107,11 @@ struct StageSpecialization {
                      [](auto& spec, const auto& desc, AmdGpu::Buffer sharp) {
                          spec.stride = sharp.GetStride();
                          spec.is_storage = desc.IsStorage(sharp);
+                         spec.swizzle_enable = sharp.swizzle_enable;
+                         if (spec.swizzle_enable) {
+                             spec.index_stride = sharp.index_stride;
+                             spec.element_size = sharp.element_size;
+                         }
                          if (!spec.is_storage) {
                              spec.size = sharp.GetSize();
                          }

src/video_core/amdgpu/liverpool.cpp

@@ -260,7 +260,7 @@ Liverpool::Task Liverpool::ProcessGraphics(std::span<const u32> dcb, std::span<c
                     const std::string_view label{reinterpret_cast<const char*>(&nop->data_block[1]),
                                                  marker_sz};
                     if (rasterizer) {
-                        rasterizer->ScopeMarkerBegin(label);
+                        rasterizer->ScopeMarkerBegin(label, true);
                     }
                     break;
                 }
@@ -271,13 +271,13 @@ Liverpool::Task Liverpool::ProcessGraphics(std::span<const u32> dcb, std::span<c
                     const u32 color = *reinterpret_cast<const u32*>(
                         reinterpret_cast<const u8*>(&nop->data_block[1]) + marker_sz);
                     if (rasterizer) {
-                        rasterizer->ScopedMarkerInsertColor(label, color);
+                        rasterizer->ScopedMarkerInsertColor(label, color, true);
                     }
                     break;
                 }
                 case PM4CmdNop::PayloadType::DebugMarkerPop: {
                     if (rasterizer) {
-                        rasterizer->ScopeMarkerEnd();
+                        rasterizer->ScopeMarkerEnd(true);
                     }
                     break;
                 }
@@ -412,7 +412,7 @@ Liverpool::Task Liverpool::ProcessGraphics(std::span<const u32> dcb, std::span<c
                 }
                 if (rasterizer) {
                     const auto cmd_address = reinterpret_cast<const void*>(header);
-                    rasterizer->ScopeMarkerBegin(fmt::format("dcb:{}:DrawIndex2", cmd_address));
+                    rasterizer->ScopeMarkerBegin(fmt::format("gfx:{}:DrawIndex2", cmd_address));
                     rasterizer->Draw(true);
                     rasterizer->ScopeMarkerEnd();
                 }
@@ -430,7 +430,7 @@ Liverpool::Task Liverpool::ProcessGraphics(std::span<const u32> dcb, std::span<c
                 if (rasterizer) {
                     const auto cmd_address = reinterpret_cast<const void*>(header);
                     rasterizer->ScopeMarkerBegin(
-                        fmt::format("dcb:{}:DrawIndexOffset2", cmd_address));
+                        fmt::format("gfx:{}:DrawIndexOffset2", cmd_address));
                     rasterizer->Draw(true, draw_index_off->index_offset);
                     rasterizer->ScopeMarkerEnd();
                 }
@@ -445,7 +445,7 @@ Liverpool::Task Liverpool::ProcessGraphics(std::span<const u32> dcb, std::span<c
                 }
                 if (rasterizer) {
                     const auto cmd_address = reinterpret_cast<const void*>(header);
-                    rasterizer->ScopeMarkerBegin(fmt::format("dcb:{}:DrawIndexAuto", cmd_address));
+                    rasterizer->ScopeMarkerBegin(fmt::format("gfx:{}:DrawIndexAuto", cmd_address));
                     rasterizer->Draw(false);
                     rasterizer->ScopeMarkerEnd();
                 }
@@ -460,7 +460,7 @@ Liverpool::Task Liverpool::ProcessGraphics(std::span<const u32> dcb, std::span<c
                 }
                 if (rasterizer) {
                     const auto cmd_address = reinterpret_cast<const void*>(header);
-                    rasterizer->ScopeMarkerBegin(fmt::format("dcb:{}:DrawIndirect", cmd_address));
+                    rasterizer->ScopeMarkerBegin(fmt::format("gfx:{}:DrawIndirect", cmd_address));
                     rasterizer->DrawIndirect(false, indirect_args_addr, offset, size, 1, 0);
                     rasterizer->ScopeMarkerEnd();
                 }
@@ -477,7 +477,7 @@ Liverpool::Task Liverpool::ProcessGraphics(std::span<const u32> dcb, std::span<c
                 if (rasterizer) {
                     const auto cmd_address = reinterpret_cast<const void*>(header);
                     rasterizer->ScopeMarkerBegin(
-                        fmt::format("dcb:{}:DrawIndexIndirect", cmd_address));
+                        fmt::format("gfx:{}:DrawIndexIndirect", cmd_address));
                     rasterizer->DrawIndirect(true, indirect_args_addr, offset, size, 1, 0);
                     rasterizer->ScopeMarkerEnd();
                 }
@@ -493,7 +493,7 @@ Liverpool::Task Liverpool::ProcessGraphics(std::span<const u32> dcb, std::span<c
                 if (rasterizer) {
                     const auto cmd_address = reinterpret_cast<const void*>(header);
                     rasterizer->ScopeMarkerBegin(
-                        fmt::format("dcb:{}:DrawIndexIndirectCountMulti", cmd_address));
+                        fmt::format("gfx:{}:DrawIndexIndirectCountMulti", cmd_address));
                     rasterizer->DrawIndirect(
                         true, indirect_args_addr, offset, draw_index_indirect->stride,
                         draw_index_indirect->count, draw_index_indirect->countAddr);
@@ -514,7 +514,7 @@ Liverpool::Task Liverpool::ProcessGraphics(std::span<const u32> dcb, std::span<c
                 }
                 if (rasterizer && (cs_program.dispatch_initiator & 1)) {
                     const auto cmd_address = reinterpret_cast<const void*>(header);
-                    rasterizer->ScopeMarkerBegin(fmt::format("dcb:{}:Dispatch", cmd_address));
+                    rasterizer->ScopeMarkerBegin(fmt::format("gfx:{}:DispatchDirect", cmd_address));
                     rasterizer->DispatchDirect();
                     rasterizer->ScopeMarkerEnd();
                 }
@@ -533,7 +533,7 @@ Liverpool::Task Liverpool::ProcessGraphics(std::span<const u32> dcb, std::span<c
                 if (rasterizer && (cs_program.dispatch_initiator & 1)) {
                     const auto cmd_address = reinterpret_cast<const void*>(header);
                     rasterizer->ScopeMarkerBegin(
-                        fmt::format("dcb:{}:DispatchIndirect", cmd_address));
+                        fmt::format("gfx:{}:DispatchIndirect", cmd_address));
                     rasterizer->DispatchIndirect(indirect_args_addr, offset, size);
                     rasterizer->ScopeMarkerEnd();
                 }
@@ -812,7 +812,7 @@ Liverpool::Task Liverpool::ProcessCompute(std::span<const u32> acb, u32 vqid) {
             if (rasterizer && (cs_program.dispatch_initiator & 1)) {
                 const auto cmd_address = reinterpret_cast<const void*>(header);
                 rasterizer->ScopeMarkerBegin(
-                    fmt::format("acb[{}]:{}:DispatchIndirect", vqid, cmd_address));
+                    fmt::format("asc[{}]:{}:DispatchDirect", vqid, cmd_address));
                 rasterizer->DispatchDirect();
                 rasterizer->ScopeMarkerEnd();
             }
@@ -830,7 +830,8 @@ Liverpool::Task Liverpool::ProcessCompute(std::span<const u32> acb, u32 vqid) {
             }
             if (rasterizer && (cs_program.dispatch_initiator & 1)) {
                 const auto cmd_address = reinterpret_cast<const void*>(header);
-                rasterizer->ScopeMarkerBegin(fmt::format("acb[{}]:{}:Dispatch", vqid, cmd_address));
+                rasterizer->ScopeMarkerBegin(
+                    fmt::format("asc[{}]:{}:DispatchIndirect", vqid, cmd_address));
                 rasterizer->DispatchIndirect(ib_address, 0, size);
                 rasterizer->ScopeMarkerEnd();
             }

src/video_core/amdgpu/liverpool.h

@@ -429,11 +429,19 @@ struct Liverpool {
         } depth_slice;
 
         bool DepthValid() const {
-            return Address() != 0 && z_info.format != ZFormat::Invalid;
+            return DepthAddress() != 0 && z_info.format != ZFormat::Invalid;
         }
 
         bool StencilValid() const {
-            return Address() != 0 && stencil_info.format != StencilFormat::Invalid;
+            return StencilAddress() != 0 && stencil_info.format != StencilFormat::Invalid;
+        }
+
+        bool DepthWriteValid() const {
+            return DepthWriteAddress() != 0 && z_info.format != ZFormat::Invalid;
+        }
+
+        bool StencilWriteValid() const {
+            return StencilWriteAddress() != 0 && stencil_info.format != StencilFormat::Invalid;
         }
 
         u32 Pitch() const {
@@ -444,7 +452,7 @@ struct Liverpool {
             return (depth_size.height_tile_max + 1) << 3;
         }
 
-        u64 Address() const {
+        u64 DepthAddress() const {
             return u64(z_read_base) << 8;
         }
 
@@ -452,6 +460,14 @@ struct Liverpool {
             return u64(stencil_read_base) << 8;
         }
 
+        u64 DepthWriteAddress() const {
+            return u64(z_write_base) << 8;
+        }
+
+        u64 StencilWriteAddress() const {
+            return u64(stencil_write_base) << 8;
+        }
+
         u32 NumSamples() const {
             return 1u << z_info.num_samples; // spec doesn't say it is a log2
         }
@@ -1008,6 +1024,46 @@ struct Liverpool {
         }
     };
 
+    enum class ForceEnable : u32 {
+        Off = 0,
+        Enable = 1,
+        Disable = 2,
+    };
+
+    enum class ForceSumm : u32 {
+        Off = 0,
+        MinZ = 1,
+        MaxZ = 2,
+        Both = 3,
+    };
+
+    union DepthRenderOverride {
+        u32 raw;
+        BitField<0, 2, ForceEnable> force_hiz_enable;
+        BitField<2, 2, ForceEnable> force_his_enable0;
+        BitField<4, 2, ForceEnable> force_his_enable1;
+        BitField<6, 1, u32> force_shader_z_order;
+        BitField<7, 1, u32> fast_z_disable;
+        BitField<8, 1, u32> fast_stencil_disable;
+        BitField<9, 1, u32> noop_cull_disable;
+        BitField<10, 1, u32> force_color_kill;
+        BitField<11, 1, u32> force_z_read;
+        BitField<12, 1, u32> force_stencil_read;
+        BitField<13, 2, ForceEnable> force_full_z_range;
+        BitField<15, 1, u32> force_qc_smask_conflict;
+        BitField<16, 1, u32> disable_viewport_clamp;
+        BitField<17, 1, u32> ignore_sc_zrange;
+        BitField<18, 1, u32> disable_fully_covered;
+        BitField<19, 2, ForceSumm> force_z_limit_summ;
+        BitField<21, 5, u32> max_tiles_in_dtt;
+        BitField<26, 1, u32> disable_tile_rate_tiles;
+        BitField<27, 1, u32> force_z_dirty;
+        BitField<28, 1, u32> force_stencil_dirty;
+        BitField<29, 1, u32> force_z_valid;
+        BitField<30, 1, u32> force_stencil_valid;
+        BitField<31, 1, u32> preserve_compression;
+    };
+
     union AaConfig {
         BitField<0, 3, u32> msaa_num_samples;
         BitField<4, 1, u32> aa_mask_centroid_dtmn;
@@ -1209,7 +1265,8 @@ struct Liverpool {
             DepthRenderControl depth_render_control;
             INSERT_PADDING_WORDS(1);
             DepthView depth_view;
-            INSERT_PADDING_WORDS(2);
+            DepthRenderOverride depth_render_override;
+            INSERT_PADDING_WORDS(1);
             Address depth_htile_data_base;
             INSERT_PADDING_WORDS(2);
             float depth_bounds_min;

src/video_core/amdgpu/resource.h

@@ -76,6 +76,16 @@ struct Buffer {
     u32 GetSize() const noexcept {
         return stride == 0 ? num_records : (stride * num_records);
     }
+
+    u32 GetIndexStride() const noexcept {
+        // Index stride is 2 bits, meaning 8, 16, 32, or 64.
+        return 8 << index_stride;
+    }
+
+    u32 GetElementSize() const noexcept {
+        // Element size is 2 bits, meaning 2, 4, 8, or 16.
+        return 2 << element_size;
+    }
 };
 static_assert(sizeof(Buffer) == 16); // 128bits
 
@@ -119,6 +129,7 @@ constexpr std::string_view NameOf(ImageType type) {
 enum class TilingMode : u32 {
     Depth_MacroTiled = 0u,
     Display_Linear = 0x8u,
+    Display_MicroTiled = 0x9u,
     Display_MacroTiled = 0xAu,
     Texture_MicroTiled = 0xDu,
     Texture_MacroTiled = 0xEu,
@@ -131,6 +142,8 @@ constexpr std::string_view NameOf(TilingMode type) {
         return "Depth_MacroTiled";
     case TilingMode::Display_Linear:
         return "Display_Linear";
+    case TilingMode::Display_MicroTiled:
+        return "Display_MicroTiled";
     case TilingMode::Display_MacroTiled:
         return "Display_MacroTiled";
     case TilingMode::Texture_MicroTiled:

src/video_core/buffer_cache/buffer.cpp

@@ -131,6 +131,8 @@ vk::BufferView Buffer::View(u32 offset, u32 size, bool is_written, AmdGpu::DataF
                vk::to_string(view_result));
     scheduler->DeferOperation(
         [view, device = instance->GetDevice()] { device.destroyBufferView(view); });
+    Vulkan::SetObjectName(instance->GetDevice(), view, "BufferView {:#x}:{:#x}", cpu_addr + offset,
+                          size);
     return view;
 }
 

src/video_core/host_shaders/CMakeLists.txt

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: GPL-2.0-or-later
 
 set(SHADER_FILES
+    detilers/display_micro_64bpp.comp
     detilers/macro_32bpp.comp
     detilers/macro_64bpp.comp
     detilers/macro_8bpp.comp

src/video_core/host_shaders/detilers/display_micro_64bpp.comp

@@ -0,0 +1,60 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 450
+
+layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
+
+layout(std430, binding = 0) buffer input_buf {
+    uint in_data[];
+};
+layout(std430, binding = 1) buffer output_buf {
+    uint out_data[];
+};
+
+layout(push_constant) uniform image_info {
+    uint num_levels;
+    uint pitch;
+    uint height;
+    uint c0;
+    uint c1;
+} info;
+
+const uint lut_64bpp[16] = {
+    0x05040100, 0x0d0c0908,
+    0x07060302, 0x0f0e0b0a,
+    0x15141110, 0x1d1c1918,
+    0x17161312, 0x1f1e1b1a,
+    0x25242120, 0x2d2c2928,
+    0x27262322, 0x2f2e2b2a,
+    0x35343130, 0x3d3c3938,
+    0x37363332, 0x3f3e3b3a,
+};
+
+#define MICRO_TILE_DIM      (8)
+#define MICRO_TILE_SZ       (512)
+#define TEXELS_PER_ELEMENT  (1)
+#define BPP                 (64)
+
+void main() {
+    uint x =  gl_GlobalInvocationID.x % info.pitch;
+    uint y = (gl_GlobalInvocationID.x / info.pitch) % info.height;
+    uint z =  gl_GlobalInvocationID.x / (info.pitch * info.height);
+
+    uint col = bitfieldExtract(x, 0, 3);
+    uint row = bitfieldExtract(y, 0, 3);
+    uint idx_dw = lut_64bpp[(col + row * MICRO_TILE_DIM) >> 2u];
+    uint byte_ofs = gl_LocalInvocationID.x & 3u;
+    uint idx = bitfieldExtract(idx_dw >> (8 * byte_ofs), 0, 8);
+
+    uint slice_offs = z * info.c1 * MICRO_TILE_SZ;
+    uint tile_row = y / MICRO_TILE_DIM;
+    uint tile_column = x / MICRO_TILE_DIM;
+    uint tile_offs = ((tile_row * info.c0) + tile_column) * MICRO_TILE_SZ;
+    uint offs = slice_offs + tile_offs + ((idx * BPP) / 8u);
+
+    uint p0 = in_data[(offs >> 2) + 0];
+    uint p1 = in_data[(offs >> 2) + 1];
+    out_data[2 * gl_GlobalInvocationID.x + 0] = p0;
+    out_data[2 * gl_GlobalInvocationID.x + 1] = p1;
+}

src/video_core/renderer_vulkan/liverpool_to_vk.h

@@ -71,8 +71,35 @@ vk::ClearValue ColorBufferClearValue(const AmdGpu::Liverpool::ColorBuffer& color
 
 vk::SampleCountFlagBits NumSamples(u32 num_samples, vk::SampleCountFlags supported_flags);
 
+static inline bool IsFormatDepthCompatible(vk::Format fmt) {
+    switch (fmt) {
+    // 32-bit float compatible
+    case vk::Format::eD32Sfloat:
+    case vk::Format::eR32Sfloat:
+    case vk::Format::eR32Uint:
+    // 16-bit unorm compatible
+    case vk::Format::eD16Unorm:
+    case vk::Format::eR16Unorm:
+        return true;
+    default:
+        return false;
+    }
+}
+
+static inline bool IsFormatStencilCompatible(vk::Format fmt) {
+    switch (fmt) {
+    // 8-bit uint compatible
+    case vk::Format::eS8Uint:
+    case vk::Format::eR8Uint:
+    case vk::Format::eR8Unorm:
+        return true;
+    default:
+        return false;
+    }
+}
+
 static inline vk::Format PromoteFormatToDepth(vk::Format fmt) {
-    if (fmt == vk::Format::eR32Sfloat) {
+    if (fmt == vk::Format::eR32Sfloat || fmt == vk::Format::eR32Uint) {
         return vk::Format::eD32Sfloat;
     } else if (fmt == vk::Format::eR16Unorm) {
         return vk::Format::eD16Unorm;

src/video_core/renderer_vulkan/vk_instance.cpp

@@ -92,15 +92,13 @@ std::string GetReadableVersion(u32 version) {
 Instance::Instance(bool enable_validation, bool enable_crash_diagnostic)
     : instance{CreateInstance(Frontend::WindowSystemType::Headless, enable_validation,
                               enable_crash_diagnostic)},
-      physical_devices{EnumeratePhysicalDevices(instance)},
+      physical_devices{EnumeratePhysicalDevices(instance)} {}
-      crash_diagnostic{enable_crash_diagnostic} {}
 
 Instance::Instance(Frontend::WindowSDL& window, s32 physical_device_index,
                    bool enable_validation /*= false*/, bool enable_crash_diagnostic /*= false*/)
     : instance{CreateInstance(window.GetWindowInfo().type, enable_validation,
                               enable_crash_diagnostic)},
-      physical_devices{EnumeratePhysicalDevices(instance)},
+      physical_devices{EnumeratePhysicalDevices(instance)} {
-      crash_diagnostic{enable_crash_diagnostic} {
     if (enable_validation) {
         debug_callback = CreateDebugCallback(*instance);
     }
@@ -272,6 +270,7 @@ bool Instance::CreateDevice() {
     legacy_vertex_attributes = add_extension(VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME);
     image_load_store_lod = add_extension(VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME);
     amd_gcn_shader = add_extension(VK_AMD_GCN_SHADER_EXTENSION_NAME);
+    add_extension(VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME);
 
     // These extensions are promoted by Vulkan 1.3, but for greater compatibility we use Vulkan 1.2
     // with extensions.
@@ -562,10 +561,7 @@ void Instance::CollectToolingInfo() {
         return;
     }
     for (const vk::PhysicalDeviceToolProperties& tool : tools) {
-        const std::string_view name = tool.name;
+        LOG_INFO(Render_Vulkan, "Attached debugging tool: {}", tool.name);
-        LOG_INFO(Render_Vulkan, "Attached debugging tool: {}", name);
-        has_renderdoc = has_renderdoc || name == "RenderDoc";
-        has_nsight_graphics = has_nsight_graphics || name == "NVIDIA Nsight Graphics";
     }
 }