From 524c5dc42d24c9c79dfbf1bdd4a25e151c931b74 Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Thu, 8 Jan 2026 19:32:59 +0100
Subject: [PATCH 01/22] libSceRudp

---
 src/common/logging/filter.cpp    |   1 +
 src/common/logging/types.h       |   1 +
 src/core/libraries/libs.cpp      |   1 +
 src/core/libraries/rudp/rudp.cpp | 230 +++++++++++++++++++++++++++++++
 src/core/libraries/rudp/rudp.h   |  52 +++++++
 5 files changed, 285 insertions(+)
 create mode 100644 src/core/libraries/rudp/rudp.cpp
 create mode 100644 src/core/libraries/rudp/rudp.h

diff --git a/src/common/logging/filter.cpp b/src/common/logging/filter.cpp
index fd8386aff..da683d9d1 100644
--- a/src/common/logging/filter.cpp
+++ b/src/common/logging/filter.cpp
@@ -115,6 +115,7 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
     SUB(Lib, LibCInternal)                                                                         \
     SUB(Lib, AppContent)                                                                           \
     SUB(Lib, Rtc)                                                                                  \
+    SUB(Lib, Rudp)                                                                                 \
     SUB(Lib, DiscMap)                                                                              \
     SUB(Lib, Png)                                                                                  \
     SUB(Lib, Jpeg)                                                                                 \
diff --git a/src/common/logging/types.h b/src/common/logging/types.h
index 82db477ed..513ca4535 100644
--- a/src/common/logging/types.h
+++ b/src/common/logging/types.h
@@ -82,6 +82,7 @@ enum class Class : u8 {
     Lib_LibCInternal,        ///< The LibCInternal implementation.
     Lib_AppContent,          ///< The LibSceAppContent implementation.
     Lib_Rtc,                 ///< The LibSceRtc implementation.
+    Lib_Rudp,                ///< The LibSceRudp implementation.
     Lib_DiscMap,             ///< The LibSceDiscMap implementation.
     Lib_Png,                 ///< The LibScePng implementation.
     Lib_Jpeg,                ///< The LibSceJpeg implementation.
diff --git a/src/core/libraries/libs.cpp b/src/core/libraries/libs.cpp
index 1f7ecb75e..aa354a4dc 100644
--- a/src/core/libraries/libs.cpp
+++ b/src/core/libraries/libs.cpp
@@ -48,6 +48,7 @@
 #include "core/libraries/razor_cpu/razor_cpu.h"
 #include "core/libraries/remote_play/remoteplay.h"
 #include "core/libraries/rtc/rtc.h"
+#include "core/libraries/rudp/rudp.h"
 #include "core/libraries/save_data/dialog/savedatadialog.h"
 #include "core/libraries/save_data/savedata.h"
 #include "core/libraries/screenshot/screenshot.h"
diff --git a/src/core/libraries/rudp/rudp.cpp b/src/core/libraries/rudp/rudp.cpp
new file mode 100644
index 000000000..96cc6bbac
--- /dev/null
+++ b/src/core/libraries/rudp/rudp.cpp
@@ -0,0 +1,230 @@
+// SPDX-FileCopyrightText: Copyright 2025 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/rudp/rudp.h"
+
+namespace Libraries::Rudp {
+
+s32 PS4_SYSV_ABI module_start() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI module_stop() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpAccept() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpActivate() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpBind() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpCreateContext() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread2() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpEnd() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpFlush() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpGetContextStatus() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpGetLocalInfo() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpGetMaxSegmentSize() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpGetNumberOfPacketsToRead() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpGetOption() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpGetRemoteInfo() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpGetSizeReadable() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpGetSizeWritable() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpGetStatus() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpInit() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpInitiate() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpListen() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpNetFlush() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpNetReceived() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpPollCancel() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpPollControl() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpPollCreate() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpPollDestroy() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpPollWait() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpProcessEvents() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpRead() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpSetEventHandler() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpSetMaxSegmentSize() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpSetOption() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpTerminate() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRudpWrite() {
+    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterLib(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("BaOKcng8g88", "libkernel", 1, "libSceRudp", module_start);
+    LIB_FUNCTION("KpDMrPHvt3Q", "libkernel", 1, "libSceRudp", module_stop);
+    LIB_FUNCTION("uQiK7fjU6y8", "libSceRudp", 1, "libSceRudp", sceRudpAccept);
+    LIB_FUNCTION("J-6d0WTjzMc", "libSceRudp", 1, "libSceRudp", sceRudpActivate);
+    LIB_FUNCTION("l4SLBpKUDK4", "libSceRudp", 1, "libSceRudp", sceRudpBind);
+    LIB_FUNCTION("CAbbX6BuQZ0", "libSceRudp", 1, "libSceRudp", sceRudpCreateContext);
+    LIB_FUNCTION("6PBNpsgyaxw", "libSceRudp", 1, "libSceRudp", sceRudpEnableInternalIOThread);
+    LIB_FUNCTION("fJ51weR1WAI", "libSceRudp", 1, "libSceRudp", sceRudpEnableInternalIOThread2);
+    LIB_FUNCTION("3hBvwqEwqj8", "libSceRudp", 1, "libSceRudp", sceRudpEnd);
+    LIB_FUNCTION("Ms0cLK8sTtE", "libSceRudp", 1, "libSceRudp", sceRudpFlush);
+    LIB_FUNCTION("wIJsiqY+BMk", "libSceRudp", 1, "libSceRudp", sceRudpGetContextStatus);
+    LIB_FUNCTION("2G7-vVz9SIg", "libSceRudp", 1, "libSceRudp", sceRudpGetLocalInfo);
+    LIB_FUNCTION("vfrL8gPlm2Y", "libSceRudp", 1, "libSceRudp", sceRudpGetMaxSegmentSize);
+    LIB_FUNCTION("Px0miD2LuW0", "libSceRudp", 1, "libSceRudp", sceRudpGetNumberOfPacketsToRead);
+    LIB_FUNCTION("mCQIhSmCP6o", "libSceRudp", 1, "libSceRudp", sceRudpGetOption);
+    LIB_FUNCTION("Qignjmfgha0", "libSceRudp", 1, "libSceRudp", sceRudpGetRemoteInfo);
+    LIB_FUNCTION("sAZqO2+5Qqo", "libSceRudp", 1, "libSceRudp", sceRudpGetSizeReadable);
+    LIB_FUNCTION("fRc1ahQppR4", "libSceRudp", 1, "libSceRudp", sceRudpGetSizeWritable);
+    LIB_FUNCTION("i3STzxuwPx0", "libSceRudp", 1, "libSceRudp", sceRudpGetStatus);
+    LIB_FUNCTION("amuBfI-AQc4", "libSceRudp", 1, "libSceRudp", sceRudpInit);
+    LIB_FUNCTION("szEVu+edXV4", "libSceRudp", 1, "libSceRudp", sceRudpInitiate);
+    LIB_FUNCTION("tYVWcWDnctE", "libSceRudp", 1, "libSceRudp", sceRudpListen);
+    LIB_FUNCTION("+BJ9svDmjYs", "libSceRudp", 1, "libSceRudp", sceRudpNetFlush);
+    LIB_FUNCTION("vPzJldDSxXc", "libSceRudp", 1, "libSceRudp", sceRudpNetReceived);
+    LIB_FUNCTION("yzeXuww-UWg", "libSceRudp", 1, "libSceRudp", sceRudpPollCancel);
+    LIB_FUNCTION("haMpc7TFx0A", "libSceRudp", 1, "libSceRudp", sceRudpPollControl);
+    LIB_FUNCTION("MVbmLASjn5M", "libSceRudp", 1, "libSceRudp", sceRudpPollCreate);
+    LIB_FUNCTION("LjwbHpEeW0A", "libSceRudp", 1, "libSceRudp", sceRudpPollDestroy);
+    LIB_FUNCTION("M6ggviwXpLs", "libSceRudp", 1, "libSceRudp", sceRudpPollWait);
+    LIB_FUNCTION("9U9m1YH0ScQ", "libSceRudp", 1, "libSceRudp", sceRudpProcessEvents);
+    LIB_FUNCTION("rZqWV3eXgOA", "libSceRudp", 1, "libSceRudp", sceRudpRead);
+    LIB_FUNCTION("SUEVes8gvmw", "libSceRudp", 1, "libSceRudp", sceRudpSetEventHandler);
+    LIB_FUNCTION("beAsSTVWVPQ", "libSceRudp", 1, "libSceRudp", sceRudpSetMaxSegmentSize);
+    LIB_FUNCTION("0yzYdZf0IwE", "libSceRudp", 1, "libSceRudp", sceRudpSetOption);
+    LIB_FUNCTION("OMYRTU0uc4w", "libSceRudp", 1, "libSceRudp", sceRudpTerminate);
+    LIB_FUNCTION("KaPL3fbTLCA", "libSceRudp", 1, "libSceRudp", sceRudpWrite);
+};
+
+} // namespace Libraries::Rudp
\ No newline at end of file
diff --git a/src/core/libraries/rudp/rudp.h b/src/core/libraries/rudp/rudp.h
new file mode 100644
index 000000000..72986b58c
--- /dev/null
+++ b/src/core/libraries/rudp/rudp.h
@@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: Copyright 2025 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/types.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
+
+namespace Libraries::Rudp {
+
+s32 PS4_SYSV_ABI module_start();
+s32 PS4_SYSV_ABI module_stop();
+s32 PS4_SYSV_ABI sceRudpAccept();
+s32 PS4_SYSV_ABI sceRudpActivate();
+s32 PS4_SYSV_ABI sceRudpBind();
+s32 PS4_SYSV_ABI sceRudpCreateContext();
+s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread();
+s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread2();
+s32 PS4_SYSV_ABI sceRudpEnd();
+s32 PS4_SYSV_ABI sceRudpFlush();
+s32 PS4_SYSV_ABI sceRudpGetContextStatus();
+s32 PS4_SYSV_ABI sceRudpGetLocalInfo();
+s32 PS4_SYSV_ABI sceRudpGetMaxSegmentSize();
+s32 PS4_SYSV_ABI sceRudpGetNumberOfPacketsToRead();
+s32 PS4_SYSV_ABI sceRudpGetOption();
+s32 PS4_SYSV_ABI sceRudpGetRemoteInfo();
+s32 PS4_SYSV_ABI sceRudpGetSizeReadable();
+s32 PS4_SYSV_ABI sceRudpGetSizeWritable();
+s32 PS4_SYSV_ABI sceRudpGetStatus();
+s32 PS4_SYSV_ABI sceRudpInit();
+s32 PS4_SYSV_ABI sceRudpInitiate();
+s32 PS4_SYSV_ABI sceRudpListen();
+s32 PS4_SYSV_ABI sceRudpNetFlush();
+s32 PS4_SYSV_ABI sceRudpNetReceived();
+s32 PS4_SYSV_ABI sceRudpPollCancel();
+s32 PS4_SYSV_ABI sceRudpPollControl();
+s32 PS4_SYSV_ABI sceRudpPollCreate();
+s32 PS4_SYSV_ABI sceRudpPollDestroy();
+s32 PS4_SYSV_ABI sceRudpPollWait();
+s32 PS4_SYSV_ABI sceRudpProcessEvents();
+s32 PS4_SYSV_ABI sceRudpRead();
+s32 PS4_SYSV_ABI sceRudpSetEventHandler();
+s32 PS4_SYSV_ABI sceRudpSetMaxSegmentSize();
+s32 PS4_SYSV_ABI sceRudpSetOption();
+s32 PS4_SYSV_ABI sceRudpTerminate();
+s32 PS4_SYSV_ABI sceRudpWrite();
+
+void RegisterLib(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::Rudp
\ No newline at end of file

From 3f7f9124ad5a3d738a9fa1a8509f95e5ff60165f Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Thu, 8 Jan 2026 19:33:18 +0100
Subject: [PATCH 02/22] use newer glslang

---
 CMakeLists.txt | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 99aca5268..db6e229f8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -223,7 +223,7 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 find_package(Boost 1.84.0 CONFIG)
 find_package(FFmpeg 5.1.2 MODULE)
 find_package(fmt 10.2.0 CONFIG)
-find_package(glslang 15 CONFIG)
+find_package(glslang 16 CONFIG)
 find_package(half 1.12.0 MODULE)
 find_package(magic_enum 0.9.7 CONFIG)
 find_package(PNG 1.6 MODULE)
@@ -424,6 +424,8 @@ set(SYSTEM_LIBS src/core/libraries/system/commondialog.cpp
                 src/core/libraries/rtc/rtc.cpp
                 src/core/libraries/rtc/rtc.h
                 src/core/libraries/rtc/rtc_error.h
+                src/core/libraries/rudp/rudp.cpp
+                src/core/libraries/rudp/rudp.h
                 src/core/libraries/disc_map/disc_map.cpp
                 src/core/libraries/disc_map/disc_map.h
                 src/core/libraries/disc_map/disc_map_codes.h

From 4a67584ae8189d6204c4b612a5fcdc8c21371c4d Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Thu, 8 Jan 2026 19:36:48 +0100
Subject: [PATCH 03/22] remove module start/stop

---
 src/core/libraries/rudp/rudp.cpp | 10 ----------
 src/core/libraries/rudp/rudp.h   |  2 --
 2 files changed, 12 deletions(-)

diff --git a/src/core/libraries/rudp/rudp.cpp b/src/core/libraries/rudp/rudp.cpp
index 96cc6bbac..b7ebc0b80 100644
--- a/src/core/libraries/rudp/rudp.cpp
+++ b/src/core/libraries/rudp/rudp.cpp
@@ -8,16 +8,6 @@
 
 namespace Libraries::Rudp {
 
-s32 PS4_SYSV_ABI module_start() {
-    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
-    return ORBIS_OK;
-}
-
-s32 PS4_SYSV_ABI module_stop() {
-    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
-    return ORBIS_OK;
-}
-
 s32 PS4_SYSV_ABI sceRudpAccept() {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
diff --git a/src/core/libraries/rudp/rudp.h b/src/core/libraries/rudp/rudp.h
index 72986b58c..ed72f5e71 100644
--- a/src/core/libraries/rudp/rudp.h
+++ b/src/core/libraries/rudp/rudp.h
@@ -11,8 +11,6 @@ class SymbolsResolver;
 
 namespace Libraries::Rudp {
 
-s32 PS4_SYSV_ABI module_start();
-s32 PS4_SYSV_ABI module_stop();
 s32 PS4_SYSV_ABI sceRudpAccept();
 s32 PS4_SYSV_ABI sceRudpActivate();
 s32 PS4_SYSV_ABI sceRudpBind();

From 039fa17425808eab15e4bafe367f3a9f914853d0 Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Thu, 8 Jan 2026 19:42:07 +0100
Subject: [PATCH 04/22] register lib, revert glslang upgrade

---
 CMakeLists.txt              | 2 +-
 src/core/libraries/libs.cpp | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index db6e229f8..e3ac31f17 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -223,7 +223,7 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 find_package(Boost 1.84.0 CONFIG)
 find_package(FFmpeg 5.1.2 MODULE)
 find_package(fmt 10.2.0 CONFIG)
-find_package(glslang 16 CONFIG)
+find_package(glslang 15 CONFIG)
 find_package(half 1.12.0 MODULE)
 find_package(magic_enum 0.9.7 CONFIG)
 find_package(PNG 1.6 MODULE)
diff --git a/src/core/libraries/libs.cpp b/src/core/libraries/libs.cpp
index aa354a4dc..4ac8532db 100644
--- a/src/core/libraries/libs.cpp
+++ b/src/core/libraries/libs.cpp
@@ -142,6 +142,7 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) {
     Libraries::CompanionUtil::RegisterLib(sym);
     Libraries::Voice::RegisterLib(sym);
     Libraries::Rtc::RegisterLib(sym);
+    Libraries::Rudp::RegisterLib(sym);
     Libraries::VrTracker::RegisterLib(sym);
 
     // Loading libSceSsl is locked behind a title workaround that currently applies to nothing.

From 4278510996f63995127cf0ab83218963f02aa04d Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Thu, 8 Jan 2026 19:44:09 +0100
Subject: [PATCH 05/22] 2026

---
 src/core/libraries/rudp/rudp.cpp | 2 +-
 src/core/libraries/rudp/rudp.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/core/libraries/rudp/rudp.cpp b/src/core/libraries/rudp/rudp.cpp
index b7ebc0b80..ccc11e341 100644
--- a/src/core/libraries/rudp/rudp.cpp
+++ b/src/core/libraries/rudp/rudp.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 shadPS4 Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 shadPS4 Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/logging/log.h"
diff --git a/src/core/libraries/rudp/rudp.h b/src/core/libraries/rudp/rudp.h
index ed72f5e71..22d2576a2 100644
--- a/src/core/libraries/rudp/rudp.h
+++ b/src/core/libraries/rudp/rudp.h
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 shadPS4 Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 shadPS4 Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once

From 05d77da944b8ff7781715815ba9b4cd796a41ff8 Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Thu, 8 Jan 2026 20:04:36 +0100
Subject: [PATCH 06/22] remove default funcions

---
 src/core/libraries/rudp/rudp.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/core/libraries/rudp/rudp.cpp b/src/core/libraries/rudp/rudp.cpp
index ccc11e341..2dfb66f64 100644
--- a/src/core/libraries/rudp/rudp.cpp
+++ b/src/core/libraries/rudp/rudp.cpp
@@ -179,8 +179,6 @@ s32 PS4_SYSV_ABI sceRudpWrite() {
 }
 
 void RegisterLib(Core::Loader::SymbolsResolver* sym) {
-    LIB_FUNCTION("BaOKcng8g88", "libkernel", 1, "libSceRudp", module_start);
-    LIB_FUNCTION("KpDMrPHvt3Q", "libkernel", 1, "libSceRudp", module_stop);
     LIB_FUNCTION("uQiK7fjU6y8", "libSceRudp", 1, "libSceRudp", sceRudpAccept);
     LIB_FUNCTION("J-6d0WTjzMc", "libSceRudp", 1, "libSceRudp", sceRudpActivate);
     LIB_FUNCTION("l4SLBpKUDK4", "libSceRudp", 1, "libSceRudp", sceRudpBind);

From 22e805d215d9cab2990ad9ed426957befb27e4a3 Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Fri, 9 Jan 2026 16:55:18 +0100
Subject: [PATCH 07/22] rudp status

---
 src/core/libraries/rudp/rudp.cpp     | 49 +++++++++++++++++++-
 src/core/libraries/rudp/rudp.h       | 68 +++++++++++++++++++++++++++-
 src/core/libraries/rudp/rudp_error.h |  9 ++++
 3 files changed, 123 insertions(+), 3 deletions(-)
 create mode 100644 src/core/libraries/rudp/rudp_error.h

diff --git a/src/core/libraries/rudp/rudp.cpp b/src/core/libraries/rudp/rudp.cpp
index 2dfb66f64..a06795519 100644
--- a/src/core/libraries/rudp/rudp.cpp
+++ b/src/core/libraries/rudp/rudp.cpp
@@ -1,13 +1,33 @@
 // SPDX-FileCopyrightText: Copyright 2026 shadPS4 Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <atomic>
+#include <cstring>
+#include <mutex>
 #include "common/logging/log.h"
 #include "core/libraries/error_codes.h"
 #include "core/libraries/libs.h"
 #include "core/libraries/rudp/rudp.h"
+#include "core/libraries/rudp/rudp_error.h"
 
 namespace Libraries::Rudp {
 
+static OrbisRudpStatus g_rudpStatusInternal = {0};
+
+void* g_RudpContext = nullptr;
+
+struct RudpInternalState {
+    std::atomic<s32> current_contexts{0};
+    std::atomic<s32> allocs{0};
+    std::atomic<s32> frees{0};
+    std::atomic<s32> mem_current{0};
+    std::atomic<s32> mem_peak{0};
+};
+static RudpInternalState g_state;
+
+std::recursive_mutex g_RudpMutex;
+bool g_isRudpInitialized = false;
+
 s32 PS4_SYSV_ABI sceRudpAccept() {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
@@ -88,8 +108,33 @@ s32 PS4_SYSV_ABI sceRudpGetSizeWritable() {
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetStatus() {
-    LOG_ERROR(Lib_Rudp, "(STUBBED) called");
+s32 Rudp_GetActiveContexts() {
+    return g_state.current_contexts.load();
+}
+
+void Rudp_GetMemoryStats(s32* allocs, s32* frees, s32* memCurr, s32* memPeak) {
+    *allocs = g_state.allocs.load();
+    *frees = g_state.frees.load();
+    *memCurr = g_state.mem_current.load();
+    *memPeak = g_state.mem_peak.load();
+}
+
+s32 PS4_SYSV_ABI sceRudpGetStatus(OrbisRudpStatus* status, size_t statusSize) {
+    std::lock_guard lock(g_RudpMutex);
+
+    if (!g_isRudpInitialized) {
+        return ORBIS_RUDP_ERROR_UNINITIALIZED;
+    }
+
+    if (status == nullptr || (statusSize - 1) >= sizeof(OrbisRudpStatus)) {
+        return ORBIS_RUDP_ERROR_INVALID_ARGUMENT;
+    }
+
+    std::memcpy(status, &g_rudpStatusInternal, statusSize);
+
+    status->currentContexts = Rudp_GetActiveContexts();
+    Rudp_GetMemoryStats(&status->allocs, &status->frees, &status->memCurrent, &status->memPeak);
+
     return ORBIS_OK;
 }
 
diff --git a/src/core/libraries/rudp/rudp.h b/src/core/libraries/rudp/rudp.h
index 22d2576a2..84cc05c22 100644
--- a/src/core/libraries/rudp/rudp.h
+++ b/src/core/libraries/rudp/rudp.h
@@ -4,12 +4,78 @@
 #pragma once
 
 #include "common/types.h"
+#include <sys/types.h>
+#include <cstddef>
 
 namespace Core::Loader {
 class SymbolsResolver;
 }
 
 namespace Libraries::Rudp {
+struct OrbisRudpStatus {
+    s64 sentUdpBytes;
+    s64 rcvdUdpBytes;
+    s32 sentUdpPackets;
+    s32 rcvdUdpPackets;
+
+    s64 sentUserBytes;
+    s32 sentUserPackets;
+    s32 sentLatencyCriticalPackets;
+
+    s64 rcvdUserBytes;
+    s32 rcvdUserPackets;
+    s32 rcvdLatencyCriticalPackets;
+
+    s32 sentSynPackets;
+    s32 rcvdSynPackets;
+    s32 sentUsrPackets;
+    s32 rcvdUsrPackets;
+    s32 sentPrbPackets;
+    s32 rcvdPrbPackets;
+    s32 sentRstPackets;
+    s32 rcvdRstPackets;
+
+    s32 lostPackets;
+    s32 retransmittedPackets;
+    s32 reorderedPackets;
+
+    s32 currentContexts;
+
+    s64 sentQualityLevel1Bytes;
+    s64 rcvdQualityLevel1Bytes;
+    s32 sentQualityLevel1Packets;
+    s32 rcvdQualityLevel1Packets;
+
+    s64 sentQualityLevel2Bytes;
+    s64 rcvdQualityLevel2Bytes;
+    s32 sentQualityLevel2Packets;
+    s32 rcvdQualityLevel2Packets;
+
+    s64 sentQualityLevel3Bytes;
+    s64 rcvdQualityLevel3Bytes;
+    s32 sentQualityLevel3Packets;
+    s32 rcvdQualityLevel3Packets;
+
+    s64 sentQualityLevel4Bytes;
+    s64 rcvdQualityLevel4Bytes;
+    s32 sentQualityLevel4Packets;
+    s32 rcvdQualityLevel4Packets;
+
+    s32 allocs;
+    s32 frees;
+    s32 memCurrent;
+    s32 memPeak;
+
+    s32 establishedConnections;
+    s32 failedConnections;
+
+    s32 failedConnectionsReset;
+    s32 failedConnectionsRefused;
+    s32 failedConnectionsTimeout;
+    s32 failedConnectionsVersionMismatch;
+    s32 failedConnectionsTransportTypeMismatch;
+    s32 failedConnectionsQualityLevelMismatch;
+};
 
 s32 PS4_SYSV_ABI sceRudpAccept();
 s32 PS4_SYSV_ABI sceRudpActivate();
@@ -27,7 +93,7 @@ s32 PS4_SYSV_ABI sceRudpGetOption();
 s32 PS4_SYSV_ABI sceRudpGetRemoteInfo();
 s32 PS4_SYSV_ABI sceRudpGetSizeReadable();
 s32 PS4_SYSV_ABI sceRudpGetSizeWritable();
-s32 PS4_SYSV_ABI sceRudpGetStatus();
+s32 PS4_SYSV_ABI sceRudpGetStatus(OrbisRudpStatus* status, size_t statusSize);
 s32 PS4_SYSV_ABI sceRudpInit();
 s32 PS4_SYSV_ABI sceRudpInitiate();
 s32 PS4_SYSV_ABI sceRudpListen();
diff --git a/src/core/libraries/rudp/rudp_error.h b/src/core/libraries/rudp/rudp_error.h
new file mode 100644
index 000000000..52b3ebf1e
--- /dev/null
+++ b/src/core/libraries/rudp/rudp_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_RUDP_ERROR_UNINITIALIZED = 0x80770001;
+constexpr int ORBIS_RUDP_ERROR_INVALID_ARGUMENT = 0x80770004;

From 3437b715c1fc127852c777d3d304423841e1508b Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Fri, 9 Jan 2026 23:30:45 +0100
Subject: [PATCH 08/22] show failed first instruction

---
 src/shader_recompiler/recompiler.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/shader_recompiler/recompiler.cpp b/src/shader_recompiler/recompiler.cpp
index 4764ddbec..4bc141bd3 100644
--- a/src/shader_recompiler/recompiler.cpp
+++ b/src/shader_recompiler/recompiler.cpp
@@ -34,7 +34,7 @@ IR::Program TranslateProgram(const std::span<const u32>& code, Pools& pools, Inf
     // Ensure first instruction is expected.
     constexpr u32 token_mov_vcchi = 0xBEEB03FF;
     if (code[0] != token_mov_vcchi) {
-        LOG_WARNING(Render_Recompiler, "First instruction is not s_mov_b32 vcc_hi, #imm");
+        LOG_WARNING(Render_Recompiler,"First instruction is 0x{:08x}, not s_mov_b32 vcc_hi, #imm",code[0]);
     }
 
     Gcn::GcnCodeSlice slice(code.data(), code.data() + code.size());

From d95c2c3ca6718c602512bd7e77425a7862a54009 Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Sat, 10 Jan 2026 01:45:01 +0100
Subject: [PATCH 09/22] stops spam

---
 src/core/libraries/np/np_error.h     | 1 +
 src/core/libraries/np/np_manager.cpp | 3 +++
 2 files changed, 4 insertions(+)

diff --git a/src/core/libraries/np/np_error.h b/src/core/libraries/np/np_error.h
index cf2014148..5ab1ec904 100644
--- a/src/core/libraries/np/np_error.h
+++ b/src/core/libraries/np/np_error.h
@@ -6,6 +6,7 @@
 #include "core/libraries/error_codes.h"
 
 // For error codes shared between multiple Np libraries.
+constexpr int ORBIS_NP_ERROR_UNINITIALIZED = 0x80550002;
 constexpr int ORBIS_NP_ERROR_INVALID_ARGUMENT = 0x80550003;
 constexpr int ORBIS_NP_ERROR_SIGNED_OUT = 0x80550006;
 constexpr int ORBIS_NP_ERROR_USER_NOT_FOUND = 0x80550007;
diff --git a/src/core/libraries/np/np_manager.cpp b/src/core/libraries/np/np_manager.cpp
index ebc940bf3..bc6890eb5 100644
--- a/src/core/libraries/np/np_manager.cpp
+++ b/src/core/libraries/np/np_manager.cpp
@@ -683,6 +683,9 @@ struct NpStateCallbackForNpToolkit {
 NpStateCallbackForNpToolkit NpStateCbForNp;
 
 s32 PS4_SYSV_ABI sceNpCheckCallback() {
+    if (!g_signed_in) {
+        return ORBIS_NP_ERROR_UNINITIALIZED;
+    }
     LOG_DEBUG(Lib_NpManager, "(STUBBED) called");
     return ORBIS_OK;
 }

From 17b9aedec5a6451e7772a30a2f3257fcfb8f3cf9 Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Mon, 12 Jan 2026 15:01:42 +0100
Subject: [PATCH 10/22] implement function def implement error codes

---
 src/core/libraries/rudp/rudp.cpp     | 100 +++++++++-------
 src/core/libraries/rudp/rudp.h       | 165 ++++++++++++++++++++++-----
 src/core/libraries/rudp/rudp_error.h |  28 ++++-
 3 files changed, 216 insertions(+), 77 deletions(-)

diff --git a/src/core/libraries/rudp/rudp.cpp b/src/core/libraries/rudp/rudp.cpp
index a06795519..53298e3bc 100644
--- a/src/core/libraries/rudp/rudp.cpp
+++ b/src/core/libraries/rudp/rudp.cpp
@@ -7,6 +7,7 @@
 #include "common/logging/log.h"
 #include "core/libraries/error_codes.h"
 #include "core/libraries/libs.h"
+#include "core/libraries/network/net.h"
 #include "core/libraries/rudp/rudp.h"
 #include "core/libraries/rudp/rudp_error.h"
 
@@ -20,9 +21,10 @@ struct RudpInternalState {
     std::atomic<s32> current_contexts{0};
     std::atomic<s32> allocs{0};
     std::atomic<s32> frees{0};
-    std::atomic<s32> mem_current{0};
-    std::atomic<s32> mem_peak{0};
+    std::atomic<s32> rcvdQualityLevel4Packets{0};
+    std::atomic<s32> sentQualityLevel4Packets{0};
 };
+
 static RudpInternalState g_state;
 
 std::recursive_mutex g_RudpMutex;
@@ -33,27 +35,30 @@ s32 PS4_SYSV_ABI sceRudpAccept() {
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpActivate() {
+s32 PS4_SYSV_ABI sceRudpActivate(int contextId, Net::OrbisNetSockaddr* to,
+                                 OrbisNetSocklen_t toLen) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpBind() {
+s32 PS4_SYSV_ABI sceRudpBind(int contextId, int soc, u16 virtualPort, u8 muxMode) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpCreateContext() {
+s32 PS4_SYSV_ABI pCreateContext(OrbisRudpContextEventHandler handler, void* arg,
+                                ContextEventId* contextId) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread() {
+s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread(u32 stackSize, u32 priority) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread2() {
+s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread2(u32 stackSize, u32 priority,
+                                                SceKernelCpumask affinityMask) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
@@ -63,47 +68,50 @@ s32 PS4_SYSV_ABI sceRudpEnd() {
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpFlush() {
+s32 PS4_SYSV_ABI sceRudpFlush(int contextId) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetContextStatus() {
+s32 PS4_SYSV_ABI sceRudpGetContextStatus(int contextId, OrbisRudpContextStatus* status,
+                                         size_t statusSize) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetLocalInfo() {
+s32 PS4_SYSV_ABI sceRudpGetLocalInfo(int contextId, int* soc, Net::OrbisNetSockaddr* addr,
+                                     SceNetSocklen_t* addrLen, u16* virtualPort, u8* muxMode) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetMaxSegmentSize() {
+s32 PS4_SYSV_ABI sceRudpGetMaxSegmentSize(u16* mss) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetNumberOfPacketsToRead() {
+s32 PS4_SYSV_ABI sceRudpGetNumberOfPacketsToRead(int contextId) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetOption() {
+s32 PS4_SYSV_ABI sceRudpGetOption(int contextId, Option option, void* optVal, size_t optLen) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetRemoteInfo() {
+s32 PS4_SYSV_ABI sceRudpGetRemoteInfo(int contextId, Net::OrbisNetSockaddr* addr,
+                                      SceNetSocklen_t* addrLen, u16* virtualPort) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetSizeReadable() {
+s32 PS4_SYSV_ABI sceRudpGetSizeReadable(int contextId) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetSizeWritable() {
+s32 PS4_SYSV_ABI sceRudpGetSizeWritable(int contextId) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
@@ -112,11 +120,12 @@ s32 Rudp_GetActiveContexts() {
     return g_state.current_contexts.load();
 }
 
-void Rudp_GetMemoryStats(s32* allocs, s32* frees, s32* memCurr, s32* memPeak) {
+void Rudp_GetMemoryStats(s32* sentQualityLevel4Packets, s32* rcvdQualityLevel4Packets, s32* allocs,
+                         s32* frees) {
     *allocs = g_state.allocs.load();
     *frees = g_state.frees.load();
-    *memCurr = g_state.mem_current.load();
-    *memPeak = g_state.mem_peak.load();
+    *sentQualityLevel4Packets = g_state.sentQualityLevel4Packets.load();
+    *rcvdQualityLevel4Packets = g_state.rcvdQualityLevel4Packets.load();
 }
 
 s32 PS4_SYSV_ABI sceRudpGetStatus(OrbisRudpStatus* status, size_t statusSize) {
@@ -126,24 +135,26 @@ s32 PS4_SYSV_ABI sceRudpGetStatus(OrbisRudpStatus* status, size_t statusSize) {
         return ORBIS_RUDP_ERROR_UNINITIALIZED;
     }
 
-    if (status == nullptr || (statusSize - 1) >= sizeof(OrbisRudpStatus)) {
-        return ORBIS_RUDP_ERROR_INVALID_ARGUMENT;
+    int result = ORBIS_RUDP_ERROR_INVALID_ARGUMENT;
+    if (status != (OrbisRudpStatus*)nullptr && statusSize - 1 < 0xf8) {
+        std::memcpy(status, &g_rudpStatusInternal, statusSize);
+
+        status->currentContexts = Rudp_GetActiveContexts();
+        Rudp_GetMemoryStats(&status->sentQualityLevel4Packets, &status->rcvdQualityLevel4Packets,
+                            &status->allocs, &status->frees);
+
+        return ORBIS_OK;
     }
-
-    std::memcpy(status, &g_rudpStatusInternal, statusSize);
-
-    status->currentContexts = Rudp_GetActiveContexts();
-    Rudp_GetMemoryStats(&status->allocs, &status->frees, &status->memCurrent, &status->memPeak);
-
-    return ORBIS_OK;
+    return result;
 }
 
-s32 PS4_SYSV_ABI sceRudpInit() {
+s32 PS4_SYSV_ABI sceRudpInit(void* memPool, int memPoolSize) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpInitiate() {
+s32 PS4_SYSV_ABI sceRudpInitiate(int contextId, Net::OrbisNetSockaddr* to, SceNetSocklen_t toLen,
+                                 u16 virtualPort) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
@@ -158,67 +169,70 @@ s32 PS4_SYSV_ABI sceRudpNetFlush() {
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpNetReceived() {
+s32 PS4_SYSV_ABI sceRudpNetReceived(int soc, u8* data, size_t dataLen, Net::OrbisNetSockaddr* from,
+                                    SceNetSocklen_t fromLen) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpPollCancel() {
+s32 PS4_SYSV_ABI sceRudpPollCancel(PollEvent poll) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpPollControl() {
+s32 PS4_SYSV_ABI sceRudpPollControl(PollEvent poll, PollOp op, int contextId, PollEvent events) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpPollCreate() {
+s32 PS4_SYSV_ABI sceRudpPollCreate(size_t size) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpPollDestroy() {
+s32 PS4_SYSV_ABI sceRudpPollDestroy(PollEvent poll) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpPollWait() {
+s32 PS4_SYSV_ABI sceRudpPollWait(PollEvent poll, OrbisRudpPollEvent* events, size_t eventLen,
+                                 OrbisRudpUsec timeout) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpProcessEvents() {
+s32 PS4_SYSV_ABI sceRudpProcessEvents(OrbisRudpUsec timeout) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpRead() {
+s32 PS4_SYSV_ABI sceRudpRead(int contextId, void* data, size_t len, Message msg,
+                             OrbisRudpReadInfo* info) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpSetEventHandler() {
+s32 PS4_SYSV_ABI sceRudpSetEventHandler(OrbisRudpEventHandler handler, void* arg) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpSetMaxSegmentSize() {
+s32 PS4_SYSV_ABI sceRudpSetMaxSegmentSize(u16 mss) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpSetOption() {
+s32 PS4_SYSV_ABI sceRudpSetOption(int contextId, Option option, void* optVal, size_t optLen) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpTerminate() {
+s32 PS4_SYSV_ABI sceRudpTerminate(int contextId) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpWrite() {
+s32 PS4_SYSV_ABI sceRudpWrite(int contextId, void* data, size_t len, Message msg) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
diff --git a/src/core/libraries/rudp/rudp.h b/src/core/libraries/rudp/rudp.h
index 84cc05c22..81921ca24 100644
--- a/src/core/libraries/rudp/rudp.h
+++ b/src/core/libraries/rudp/rudp.h
@@ -4,14 +4,71 @@
 #pragma once
 
 #include "common/types.h"
-#include <sys/types.h>
-#include <cstddef>
 
 namespace Core::Loader {
 class SymbolsResolver;
 }
 
 namespace Libraries::Rudp {
+
+enum class State : int {
+    IDLE = 0,
+    CLOSED = 1,
+    SYN_SENT = 2,
+    SYN_RCVD = 3,
+    ESTABLISHED = 4,
+    CLOSE_WAIT = 5,
+};
+
+enum class Event : int {
+    SEND = 1,
+    SOCKET_RELEASED = 2,
+    DIAGNOSTIC_SENT = 100,
+    DIAGNOSTIC_RCVD = 101,
+};
+
+enum class ContextEvent : int {
+    CLOSED = 1,
+    ESTABLISHED = 2,
+    ERROR = 3,
+    WRITEABLE = 4,
+    READABLE = 5,
+    FLUSHED = 6
+};
+
+enum class PollOp : int { ADD = 1, MODIFY = 2, REMOVE = 3 };
+
+enum class PollEvent : int { READ = 0x0001, WRITE = 0x0002, FLUSH = 0x0004, ERROR = 0x0008 };
+
+enum class Option : int {
+    MAX_PAYLOAD = 1,
+    OPTION_SEND_BUFFER_SIZE = 2,
+    OPTION_RECEIVE_BUFFER_SIZE = 3,
+    OPTION_NO_DELAY = 4,
+    OPTION_CRITICAL_DELIVERY = 5,
+    OPTION_CRITICAL_ORDER = 6,
+    OPTION_NONBLOCK = 7,
+    STREAM = 8,
+    CONN_TIMEOUT = 9,
+    CLOSE_WAIT_TIMEOUT = 10,
+    AGGREGATION_TIMEOUT = 11,
+    LAST_ERROR = 14,
+    READ_TIMEOUT = 15,
+    WRITE_TIMEOUT = 16,
+    FLUSH_TIMEOUT = 17,
+    KEEPALIVE_INTERVAL = 18,
+    KEEPALIVE_TIMEOUT = 19,
+    AGGREGATION_BUFFER = 20,
+};
+
+enum class Message : int {
+    DONTWAIT = 0x01,
+    LATENCY_CRITICAL = 0x08,
+    ALIGN32 = 0x10,
+    ALIGN64 = 0x20,
+    WITH_TIMESTAMP = 0x40,
+};
+
 struct OrbisRudpStatus {
     s64 sentUdpBytes;
     s64 rcvdUdpBytes;
@@ -77,40 +134,86 @@ struct OrbisRudpStatus {
     s32 failedConnectionsQualityLevelMismatch;
 };
 
+struct OrbisRudpContextStatus {
+    State state;
+    int parentId;
+    u32 children;
+    u32 lostPackets;
+    u32 sentPackets;
+    u32 rcvdPackets;
+    u64 sentBytes;
+    u64 rcvdBytes;
+    u32 retransmissions;
+    u32 rtt;
+};
+
+struct OrbisRudpPollEvent {
+    int ctxId;
+    u16 reqEvents;
+    u16 rtnEvents;
+};
+
+struct OrbisRudpReadInfo {
+    u8 size;
+    u8 retransmissionCount;
+    u16 retransmissionDelay;
+    u8 retransmissionDelay2;
+    u8 flags;
+    u16 sequenceNumber;
+    u32 timestamp;
+};
+
+typedef void (*OrbisRudpContextEventHandler)(int contextId, ContextEvent event, int errorCode,
+                                             void* arg);
+
+typedef u64 OrbisRudpUsec;
+
+typedef int (*OrbisRudpEventHandler)(Event event, int soc, u8 const* data, size_t dataLen,
+                                     Net::OrbisNetSockaddr const* addr, SceNetSocklen_t addrLen,
+                                     void* arg);
+
 s32 PS4_SYSV_ABI sceRudpAccept();
-s32 PS4_SYSV_ABI sceRudpActivate();
-s32 PS4_SYSV_ABI sceRudpBind();
+s32 PS4_SYSV_ABI sceRudpActivate(int contextId, Net::OrbisNetSockaddr* to, SceNetSocklen_t toLen);
+s32 PS4_SYSV_ABI sceRudpBind(int contextId, int soc, u16 vport, u8 muxMode);
 s32 PS4_SYSV_ABI sceRudpCreateContext();
-s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread();
-s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread2();
+s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread(u32 stackSize, u32 priority);
+s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread2(u32 stackSize, u32 priority,
+                                                SceKernelCpumask affinityMask);
 s32 PS4_SYSV_ABI sceRudpEnd();
-s32 PS4_SYSV_ABI sceRudpFlush();
-s32 PS4_SYSV_ABI sceRudpGetContextStatus();
-s32 PS4_SYSV_ABI sceRudpGetLocalInfo();
-s32 PS4_SYSV_ABI sceRudpGetMaxSegmentSize();
-s32 PS4_SYSV_ABI sceRudpGetNumberOfPacketsToRead();
-s32 PS4_SYSV_ABI sceRudpGetOption();
-s32 PS4_SYSV_ABI sceRudpGetRemoteInfo();
-s32 PS4_SYSV_ABI sceRudpGetSizeReadable();
-s32 PS4_SYSV_ABI sceRudpGetSizeWritable();
+s32 PS4_SYSV_ABI sceRudpFlush(int contextId);
+s32 PS4_SYSV_ABI sceRudpGetContextStatus(int contextId, OrbisRudpContextStatus* status,
+                                         size_t statusSize);
+s32 PS4_SYSV_ABI sceRudpGetLocalInfo(int contextId, int* soc, Net::OrbisNetSockaddr* addr,
+                                     SceNetSocklen_t* addrLen, u16* vport, u8* muxMode);
+s32 PS4_SYSV_ABI sceRudpGetMaxSegmentSize(u16* mss);
+s32 PS4_SYSV_ABI sceRudpGetNumberOfPacketsToRead(int contextId);
+s32 PS4_SYSV_ABI sceRudpGetOption(int contextId, Option option, void* optVal, size_t optLen);
+s32 PS4_SYSV_ABI sceRudpGetRemoteInfo(int contextId, Net::OrbisNetSockaddr* addr,
+                                      SceNetSocklen_t* addrLen, u16* vport);
+s32 PS4_SYSV_ABI sceRudpGetSizeReadable(int contextId);
+s32 PS4_SYSV_ABI sceRudpGetSizeWritable(int contextId);
 s32 PS4_SYSV_ABI sceRudpGetStatus(OrbisRudpStatus* status, size_t statusSize);
-s32 PS4_SYSV_ABI sceRudpInit();
-s32 PS4_SYSV_ABI sceRudpInitiate();
-s32 PS4_SYSV_ABI sceRudpListen();
+s32 PS4_SYSV_ABI sceRudpInit(void* memPool, int memPoolSize);
+s32 PS4_SYSV_ABI sceRudpInitiate(int contextId, Net::OrbisNetSockaddr* to, SceNetSocklen_t toLen,
+                                 u16 vport);
+s32 PS4_SYSV_ABI sceRudpListen(int param_1, int param_2);
 s32 PS4_SYSV_ABI sceRudpNetFlush();
-s32 PS4_SYSV_ABI sceRudpNetReceived();
-s32 PS4_SYSV_ABI sceRudpPollCancel();
-s32 PS4_SYSV_ABI sceRudpPollControl();
-s32 PS4_SYSV_ABI sceRudpPollCreate();
-s32 PS4_SYSV_ABI sceRudpPollDestroy();
-s32 PS4_SYSV_ABI sceRudpPollWait();
-s32 PS4_SYSV_ABI sceRudpProcessEvents();
-s32 PS4_SYSV_ABI sceRudpRead();
-s32 PS4_SYSV_ABI sceRudpSetEventHandler();
-s32 PS4_SYSV_ABI sceRudpSetMaxSegmentSize();
-s32 PS4_SYSV_ABI sceRudpSetOption();
-s32 PS4_SYSV_ABI sceRudpTerminate();
-s32 PS4_SYSV_ABI sceRudpWrite();
+s32 PS4_SYSV_ABI sceRudpNetReceived(int soc, u8* data, size_t dataLen, Net::OrbisNetSockaddr* from,
+                                    SceNetSocklen_t fromLen);
+s32 PS4_SYSV_ABI sceRudpPollCancel(int pollId);
+s32 PS4_SYSV_ABI sceRudpPollControl(int pollId, int op, int contextId, u16 events);
+s32 PS4_SYSV_ABI sceRudpPollCreate(size_t size);
+s32 PS4_SYSV_ABI sceRudpPollDestroy(int pollId);
+s32 PS4_SYSV_ABI sceRudpPollWait(int pollId, OrbisRudpPollEvent* events, size_t eventLen,
+                                 OrbisRudpUsec timeout);
+s32 PS4_SYSV_ABI sceRudpProcessEvents(OrbisRudpUsec timeout);
+s32 PS4_SYSV_ABI sceRudpRead(int contextId, void* data, size_t len, u8 flags,
+                             OrbisRudpReadInfo* info);
+s32 PS4_SYSV_ABI sceRudpSetEventHandler(OrbisRudpEventHandler handler, void* arg);
+s32 PS4_SYSV_ABI sceRudpSetMaxSegmentSize(u16 mss);
+s32 PS4_SYSV_ABI sceRudpSetOption(int contextId, int option, void* optVal, size_t optLen);
+s32 PS4_SYSV_ABI sceRudpTerminate(int contextId);
+s32 PS4_SYSV_ABI sceRudpWrite(int contextId, void* data, size_t len, u8 flags);
 
 void RegisterLib(Core::Loader::SymbolsResolver* sym);
 } // namespace Libraries::Rudp
\ No newline at end of file
diff --git a/src/core/libraries/rudp/rudp_error.h b/src/core/libraries/rudp/rudp_error.h
index 52b3ebf1e..e7ae0bf72 100644
--- a/src/core/libraries/rudp/rudp_error.h
+++ b/src/core/libraries/rudp/rudp_error.h
@@ -3,7 +3,29 @@
 
 #pragma once
 
-#include "core/libraries/error_codes.h"
-
-constexpr int ORBIS_RUDP_ERROR_UNINITIALIZED = 0x80770001;
+constexpr int ORBIS_RUDP_ERROR_NOT_INITIALIZED = 0x80770001;
 constexpr int ORBIS_RUDP_ERROR_INVALID_ARGUMENT = 0x80770004;
+constexpr int ORBIS_RUDP_ERROR_INVALID_CONTEXT_ID = 0x80770003;
+constexpr int ORBIS_RUDP_ERROR_INVALID_POLL_ID = 0x8077001f;
+constexpr int ORBIS_RUDP_ERROR_TOO_MANY_CONTEXTS = 0;
+constexpr int ORBIS_RUDP_ERROR_CANCELLED = 0x80770014;
+constexpr int ORBIS_RUDP_ERROR_ALREADY_INITIALIZED = 0x80770002;
+constexpr int ORBIS_RUDP_ERROR_MEMORY = 0x80770007;
+constexpr int ORBIS_RUDP_ERROR_NOT_ACCEPTABLE = 0x80770011;
+constexpr int ORBIS_RUDP_ERROR_THREAD_IN_USE = 0;
+constexpr int ORBIS_RUDP_ERROR_THREAD = 0;
+constexpr int ORBIS_RUDP_ERROR_INVALID_SOCKET = 0;
+constexpr int ORBIS_RUDP_ERROR_NO_EVENT_HANDLER = 0;
+constexpr int ORBIS_RUDP_ERROR_INVALID_MUXMODE = 0;
+constexpr int ORBIS_RUDP_ERROR_INVALID_VPORT = 0;
+constexpr int ORBIS_RUDP_ERROR_VPORT_EXHAUSTED = 0;
+constexpr int ORBIS_RUDP_ERROR_CONN_TIMEOUT = 0;
+constexpr int ORBIS_RUDP_ERROR_NOT_BOUND = 0;
+constexpr int ORBIS_RUDP_ERROR_ADDR_IN_USE = 0;
+constexpr int ORBIS_RUDP_ERROR_IN_PROGRESS = 0;
+constexpr int ORBIS_RUDP_ERROR_WOULDBLOCK = 0;
+constexpr int ORBIS_RUDP_ERROR_MSG_TOO_LARGE = 0;
+constexpr int ORBIS_RUDP_ERROR_BUFFER_TOO_SMALL = 0;
+constexpr int ORBIS_RUDP_ERROR_END_OF_DATA = 0;
+constexpr int ORBIS_RUDP_ERROR_MSG_MALFORMED = 0;
+constexpr int ORBIS_RUDP_ERROR_INVALID_OPTION = 0;
\ No newline at end of file

From 06a89318bb1f808633aab5e57d70df8cdab2c671 Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Mon, 12 Jan 2026 18:20:42 +0100
Subject: [PATCH 11/22] fix function params

---
 src/core/libraries/rudp/rudp.cpp | 20 +++++++++----------
 src/core/libraries/rudp/rudp.h   | 34 ++++++++++++++++++--------------
 2 files changed, 29 insertions(+), 25 deletions(-)

diff --git a/src/core/libraries/rudp/rudp.cpp b/src/core/libraries/rudp/rudp.cpp
index 53298e3bc..a5a97290e 100644
--- a/src/core/libraries/rudp/rudp.cpp
+++ b/src/core/libraries/rudp/rudp.cpp
@@ -46,8 +46,8 @@ s32 PS4_SYSV_ABI sceRudpBind(int contextId, int soc, u16 virtualPort, u8 muxMode
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI pCreateContext(OrbisRudpContextEventHandler handler, void* arg,
-                                ContextEventId* contextId) {
+s32 PS4_SYSV_ABI sceRudpCreateContext(OrbisRudpContextEventHandler handler, void* arg,
+                                      int* contextId) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
@@ -58,7 +58,7 @@ s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread(u32 stackSize, u32 priority) {
 }
 
 s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread2(u32 stackSize, u32 priority,
-                                                SceKernelCpumask affinityMask) {
+                                                OrbisKernelCpumask affinityMask) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
@@ -80,7 +80,7 @@ s32 PS4_SYSV_ABI sceRudpGetContextStatus(int contextId, OrbisRudpContextStatus*
 }
 
 s32 PS4_SYSV_ABI sceRudpGetLocalInfo(int contextId, int* soc, Net::OrbisNetSockaddr* addr,
-                                     SceNetSocklen_t* addrLen, u16* virtualPort, u8* muxMode) {
+                                     u32* addrlen, u16* virtualPort, u8* muxMode) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
@@ -100,8 +100,8 @@ s32 PS4_SYSV_ABI sceRudpGetOption(int contextId, Option option, void* optVal, si
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetRemoteInfo(int contextId, Net::OrbisNetSockaddr* addr,
-                                      SceNetSocklen_t* addrLen, u16* virtualPort) {
+s32 PS4_SYSV_ABI sceRudpGetRemoteInfo(int contextId, Net::OrbisNetSockaddr* addr, u32* addrlen,
+                                      u16* virtualPort) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
@@ -132,7 +132,7 @@ s32 PS4_SYSV_ABI sceRudpGetStatus(OrbisRudpStatus* status, size_t statusSize) {
     std::lock_guard lock(g_RudpMutex);
 
     if (!g_isRudpInitialized) {
-        return ORBIS_RUDP_ERROR_UNINITIALIZED;
+        return ORBIS_RUDP_ERROR_NOT_INITIALIZED;
     }
 
     int result = ORBIS_RUDP_ERROR_INVALID_ARGUMENT;
@@ -153,7 +153,7 @@ s32 PS4_SYSV_ABI sceRudpInit(void* memPool, int memPoolSize) {
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpInitiate(int contextId, Net::OrbisNetSockaddr* to, SceNetSocklen_t toLen,
+s32 PS4_SYSV_ABI sceRudpInitiate(int contextId, Net::OrbisNetSockaddr* to, OrbisNetSocklen_t toLen,
                                  u16 virtualPort) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
@@ -170,7 +170,7 @@ s32 PS4_SYSV_ABI sceRudpNetFlush() {
 }
 
 s32 PS4_SYSV_ABI sceRudpNetReceived(int soc, u8* data, size_t dataLen, Net::OrbisNetSockaddr* from,
-                                    SceNetSocklen_t fromLen) {
+                                    OrbisNetSocklen_t fromLen) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
@@ -206,7 +206,7 @@ s32 PS4_SYSV_ABI sceRudpProcessEvents(OrbisRudpUsec timeout) {
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpRead(int contextId, void* data, size_t len, Message msg,
+s32 PS4_SYSV_ABI sceRudpRead(int contextId, void* data, size_t len, u8 flags,
                              OrbisRudpReadInfo* info) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
diff --git a/src/core/libraries/rudp/rudp.h b/src/core/libraries/rudp/rudp.h
index 81921ca24..9ee000b22 100644
--- a/src/core/libraries/rudp/rudp.h
+++ b/src/core/libraries/rudp/rudp.h
@@ -162,6 +162,9 @@ struct OrbisRudpReadInfo {
     u16 sequenceNumber;
     u32 timestamp;
 };
+typedef s32 OrbisKernelCpumask;
+
+typedef uint32_t OrbisNetSocklen_t;
 
 typedef void (*OrbisRudpContextEventHandler)(int contextId, ContextEvent event, int errorCode,
                                              void* arg);
@@ -169,51 +172,52 @@ typedef void (*OrbisRudpContextEventHandler)(int contextId, ContextEvent event,
 typedef u64 OrbisRudpUsec;
 
 typedef int (*OrbisRudpEventHandler)(Event event, int soc, u8 const* data, size_t dataLen,
-                                     Net::OrbisNetSockaddr const* addr, SceNetSocklen_t addrLen,
+                                     Net::OrbisNetSockaddr const* addr, OrbisNetSocklen_t addrLen,
                                      void* arg);
 
 s32 PS4_SYSV_ABI sceRudpAccept();
-s32 PS4_SYSV_ABI sceRudpActivate(int contextId, Net::OrbisNetSockaddr* to, SceNetSocklen_t toLen);
+s32 PS4_SYSV_ABI sceRudpActivate(int contextId, Net::OrbisNetSockaddr* to, OrbisNetSocklen_t toLen);
 s32 PS4_SYSV_ABI sceRudpBind(int contextId, int soc, u16 vport, u8 muxMode);
-s32 PS4_SYSV_ABI sceRudpCreateContext();
+s32 PS4_SYSV_ABI sceRudpCreateContext(OrbisRudpContextEventHandler handler, void* arg,
+                                      int* contextId);
 s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread(u32 stackSize, u32 priority);
 s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread2(u32 stackSize, u32 priority,
-                                                SceKernelCpumask affinityMask);
+                                                OrbisKernelCpumask affinityMask);
 s32 PS4_SYSV_ABI sceRudpEnd();
 s32 PS4_SYSV_ABI sceRudpFlush(int contextId);
 s32 PS4_SYSV_ABI sceRudpGetContextStatus(int contextId, OrbisRudpContextStatus* status,
                                          size_t statusSize);
 s32 PS4_SYSV_ABI sceRudpGetLocalInfo(int contextId, int* soc, Net::OrbisNetSockaddr* addr,
-                                     SceNetSocklen_t* addrLen, u16* vport, u8* muxMode);
+                                     OrbisNetSocklen_t* addrLen, u16* vport, u8* muxMode);
 s32 PS4_SYSV_ABI sceRudpGetMaxSegmentSize(u16* mss);
 s32 PS4_SYSV_ABI sceRudpGetNumberOfPacketsToRead(int contextId);
 s32 PS4_SYSV_ABI sceRudpGetOption(int contextId, Option option, void* optVal, size_t optLen);
 s32 PS4_SYSV_ABI sceRudpGetRemoteInfo(int contextId, Net::OrbisNetSockaddr* addr,
-                                      SceNetSocklen_t* addrLen, u16* vport);
+                                      OrbisNetSocklen_t* addrLen, u16* vport);
 s32 PS4_SYSV_ABI sceRudpGetSizeReadable(int contextId);
 s32 PS4_SYSV_ABI sceRudpGetSizeWritable(int contextId);
 s32 PS4_SYSV_ABI sceRudpGetStatus(OrbisRudpStatus* status, size_t statusSize);
 s32 PS4_SYSV_ABI sceRudpInit(void* memPool, int memPoolSize);
-s32 PS4_SYSV_ABI sceRudpInitiate(int contextId, Net::OrbisNetSockaddr* to, SceNetSocklen_t toLen,
+s32 PS4_SYSV_ABI sceRudpInitiate(int contextId, Net::OrbisNetSockaddr* to, OrbisNetSocklen_t toLen,
                                  u16 vport);
-s32 PS4_SYSV_ABI sceRudpListen(int param_1, int param_2);
+s32 PS4_SYSV_ABI sceRudpListen();
 s32 PS4_SYSV_ABI sceRudpNetFlush();
 s32 PS4_SYSV_ABI sceRudpNetReceived(int soc, u8* data, size_t dataLen, Net::OrbisNetSockaddr* from,
-                                    SceNetSocklen_t fromLen);
-s32 PS4_SYSV_ABI sceRudpPollCancel(int pollId);
-s32 PS4_SYSV_ABI sceRudpPollControl(int pollId, int op, int contextId, u16 events);
+                                    OrbisNetSocklen_t fromLen);
+s32 PS4_SYSV_ABI sceRudpPollCancel(PollEvent poll);
+s32 PS4_SYSV_ABI sceRudpPollControl(PollEvent poll, PollOp op, int contextId, PollEvent events);
 s32 PS4_SYSV_ABI sceRudpPollCreate(size_t size);
-s32 PS4_SYSV_ABI sceRudpPollDestroy(int pollId);
-s32 PS4_SYSV_ABI sceRudpPollWait(int pollId, OrbisRudpPollEvent* events, size_t eventLen,
+s32 PS4_SYSV_ABI sceRudpPollDestroy(PollEvent poll);
+s32 PS4_SYSV_ABI sceRudpPollWait(PollEvent poll, OrbisRudpPollEvent* events, size_t eventLen,
                                  OrbisRudpUsec timeout);
 s32 PS4_SYSV_ABI sceRudpProcessEvents(OrbisRudpUsec timeout);
 s32 PS4_SYSV_ABI sceRudpRead(int contextId, void* data, size_t len, u8 flags,
                              OrbisRudpReadInfo* info);
 s32 PS4_SYSV_ABI sceRudpSetEventHandler(OrbisRudpEventHandler handler, void* arg);
 s32 PS4_SYSV_ABI sceRudpSetMaxSegmentSize(u16 mss);
-s32 PS4_SYSV_ABI sceRudpSetOption(int contextId, int option, void* optVal, size_t optLen);
+s32 PS4_SYSV_ABI sceRudpSetOption(int contextId, Option option, void* optVal, size_t optLen);
 s32 PS4_SYSV_ABI sceRudpTerminate(int contextId);
-s32 PS4_SYSV_ABI sceRudpWrite(int contextId, void* data, size_t len, u8 flags);
+s32 PS4_SYSV_ABI sceRudpWrite(int contextId, void* data, size_t len, Message msg);
 
 void RegisterLib(Core::Loader::SymbolsResolver* sym);
 } // namespace Libraries::Rudp
\ No newline at end of file

From d06524012a90936df7b896151009cc4d680556c9 Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Tue, 13 Jan 2026 11:26:35 +0100
Subject: [PATCH 12/22] fix error codes

---
 src/core/libraries/rudp/rudp_error.h | 58 +++++++++++++++++-----------
 1 file changed, 36 insertions(+), 22 deletions(-)

diff --git a/src/core/libraries/rudp/rudp_error.h b/src/core/libraries/rudp/rudp_error.h
index e7ae0bf72..5c83fb626 100644
--- a/src/core/libraries/rudp/rudp_error.h
+++ b/src/core/libraries/rudp/rudp_error.h
@@ -4,28 +4,42 @@
 #pragma once
 
 constexpr int ORBIS_RUDP_ERROR_NOT_INITIALIZED = 0x80770001;
-constexpr int ORBIS_RUDP_ERROR_INVALID_ARGUMENT = 0x80770004;
-constexpr int ORBIS_RUDP_ERROR_INVALID_CONTEXT_ID = 0x80770003;
-constexpr int ORBIS_RUDP_ERROR_INVALID_POLL_ID = 0x8077001f;
-constexpr int ORBIS_RUDP_ERROR_TOO_MANY_CONTEXTS = 0;
-constexpr int ORBIS_RUDP_ERROR_CANCELLED = 0x80770014;
 constexpr int ORBIS_RUDP_ERROR_ALREADY_INITIALIZED = 0x80770002;
+constexpr int ORBIS_RUDP_ERROR_INVALID_CONTEXT_ID = 0x80770003;
+constexpr int ORBIS_RUDP_ERROR_INVALID_ARGUMENT = 0x80770004;
+constexpr int ORBIS_RUDP_ERROR_INVALID_OPTION = 0x80770005;
+constexpr int ORBIS_RUDP_ERROR_INVALID_MUXMODE = 0x80770006;
 constexpr int ORBIS_RUDP_ERROR_MEMORY = 0x80770007;
+constexpr int ORBIS_RUDP_ERROR_INTERNAL = 0x80770008;
+constexpr int ORBIS_RUDP_ERROR_CONN_RESET = 0x80770009;
+constexpr int ORBIS_RUDP_ERROR_CONN_REFUSED = 0x8077000A;
+constexpr int ORBIS_RUDP_ERROR_CONN_TIMEOUT = 0x8077000B;
+constexpr int ORBIS_RUDP_ERROR_CONN_VERSION_MISMATCH = 0x8077000C;
+constexpr int ORBIS_RUDP_ERROR_CONN_TRANSPORT_TYPE_MISMATCH = 0x8077000D;
+constexpr int ORBIS_RUDP_ERROR_CONN_QUALITY_LEVEL_MISMATCH = 0x8077000E;
+constexpr int ORBIS_RUDP_ERROR_THREAD = 0x8077000F;
+constexpr int ORBIS_RUDP_ERROR_THREAD_IN_USE = 0x80770010;
 constexpr int ORBIS_RUDP_ERROR_NOT_ACCEPTABLE = 0x80770011;
-constexpr int ORBIS_RUDP_ERROR_THREAD_IN_USE = 0;
-constexpr int ORBIS_RUDP_ERROR_THREAD = 0;
-constexpr int ORBIS_RUDP_ERROR_INVALID_SOCKET = 0;
-constexpr int ORBIS_RUDP_ERROR_NO_EVENT_HANDLER = 0;
-constexpr int ORBIS_RUDP_ERROR_INVALID_MUXMODE = 0;
-constexpr int ORBIS_RUDP_ERROR_INVALID_VPORT = 0;
-constexpr int ORBIS_RUDP_ERROR_VPORT_EXHAUSTED = 0;
-constexpr int ORBIS_RUDP_ERROR_CONN_TIMEOUT = 0;
-constexpr int ORBIS_RUDP_ERROR_NOT_BOUND = 0;
-constexpr int ORBIS_RUDP_ERROR_ADDR_IN_USE = 0;
-constexpr int ORBIS_RUDP_ERROR_IN_PROGRESS = 0;
-constexpr int ORBIS_RUDP_ERROR_WOULDBLOCK = 0;
-constexpr int ORBIS_RUDP_ERROR_MSG_TOO_LARGE = 0;
-constexpr int ORBIS_RUDP_ERROR_BUFFER_TOO_SMALL = 0;
-constexpr int ORBIS_RUDP_ERROR_END_OF_DATA = 0;
-constexpr int ORBIS_RUDP_ERROR_MSG_MALFORMED = 0;
-constexpr int ORBIS_RUDP_ERROR_INVALID_OPTION = 0;
\ No newline at end of file
+constexpr int ORBIS_RUDP_ERROR_MSG_TOO_LARGE = 0x80770012;
+constexpr int ORBIS_RUDP_ERROR_NOT_BOUND = 0x80770013;
+constexpr int ORBIS_RUDP_ERROR_CANCELLED = 0x80770014;
+constexpr int ORBIS_RUDP_ERROR_INVALID_VPORT = 0x80770015;
+constexpr int ORBIS_RUDP_ERROR_WOULDBLOCK = 0x80770016;
+constexpr int ORBIS_RUDP_ERROR_VPORT_IN_USE = 0x80770017;
+constexpr int ORBIS_RUDP_ERROR_VPORT_EXHAUSTED = 0x80770018;
+constexpr int ORBIS_RUDP_ERROR_INVALID_SOCKET = 0x80770019;
+constexpr int ORBIS_RUDP_ERROR_BUFFER_TOO_SMALL = 0x8077001A;
+constexpr int ORBIS_RUDP_ERROR_MSG_MALFORMED = 0x8077001B;
+constexpr int ORBIS_RUDP_ERROR_ADDR_IN_USE = 0x8077001C;
+constexpr int ORBIS_RUDP_ERROR_ALREADY_BOUND = 0x8077001D;
+constexpr int ORBIS_RUDP_ERROR_ALREADY_EXISTS = 0x8077001E;
+constexpr int ORBIS_RUDP_ERROR_INVALID_POLL_ID = 0x8077001F;
+constexpr int ORBIS_RUDP_ERROR_TOO_MANY_CONTEXTS = 0x80770020;
+constexpr int ORBIS_RUDP_ERROR_IN_PROGRESS = 0x80770021;
+constexpr int ORBIS_RUDP_ERROR_NO_EVENT_HANDLER = 0x80770022;
+constexpr int ORBIS_RUDP_ERROR_PAYLOAD_TOO_LARGE = 0x80770023;
+constexpr int ORBIS_RUDP_ERROR_END_OF_DATA = 0x80770024;
+constexpr int ORBIS_RUDP_ERROR_ALREADY_ESTABLISHED = 0x80770025;
+constexpr int ORBIS_RUDP_ERROR_KEEP_ALIVE_FAILURE = 0x80770026;
+constexpr int ORBIS_RUDP_ERROR_MEMLEAK = 0x807700FF;
+

From 2297f599b0cb03842b998dd30c47e4db0405bf5b Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Tue, 13 Jan 2026 11:29:09 +0100
Subject: [PATCH 13/22] fix copyright year

---
 src/core/libraries/rudp/rudp_error.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/libraries/rudp/rudp_error.h b/src/core/libraries/rudp/rudp_error.h
index 5c83fb626..f5c34568a 100644
--- a/src/core/libraries/rudp/rudp_error.h
+++ b/src/core/libraries/rudp/rudp_error.h
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 shadPS4 Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once

From efcb44b9dc76ed02822bf3f789e5ac5024c1f9e0 Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Tue, 13 Jan 2026 12:52:05 +0100
Subject: [PATCH 14/22] fix error name

---
 src/core/libraries/np/np_error.h     | 2 +-
 src/core/libraries/np/np_manager.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/core/libraries/np/np_error.h b/src/core/libraries/np/np_error.h
index 5ab1ec904..444625559 100644
--- a/src/core/libraries/np/np_error.h
+++ b/src/core/libraries/np/np_error.h
@@ -6,7 +6,7 @@
 #include "core/libraries/error_codes.h"
 
 // For error codes shared between multiple Np libraries.
-constexpr int ORBIS_NP_ERROR_UNINITIALIZED = 0x80550002;
+constexpr int ORBIS_NP_ERROR_NOT_INITIALIZED = 0x80550002;
 constexpr int ORBIS_NP_ERROR_INVALID_ARGUMENT = 0x80550003;
 constexpr int ORBIS_NP_ERROR_SIGNED_OUT = 0x80550006;
 constexpr int ORBIS_NP_ERROR_USER_NOT_FOUND = 0x80550007;
diff --git a/src/core/libraries/np/np_manager.cpp b/src/core/libraries/np/np_manager.cpp
index bc6890eb5..9bfe26fa7 100644
--- a/src/core/libraries/np/np_manager.cpp
+++ b/src/core/libraries/np/np_manager.cpp
@@ -684,7 +684,7 @@ NpStateCallbackForNpToolkit NpStateCbForNp;
 
 s32 PS4_SYSV_ABI sceNpCheckCallback() {
     if (!g_signed_in) {
-        return ORBIS_NP_ERROR_UNINITIALIZED;
+        return ORBIS_NP_ERROR_NOT_INITIALIZED;
     }
     LOG_DEBUG(Lib_NpManager, "(STUBBED) called");
     return ORBIS_OK;

From 2b0bd624d0bd2f72a2bf8bd645b3eee91f6e8530 Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Tue, 13 Jan 2026 15:05:48 +0100
Subject: [PATCH 15/22] fixing libs.cpp

---
 src/core/libraries/libs.cpp | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/src/core/libraries/libs.cpp b/src/core/libraries/libs.cpp
index 4ac8532db..6cf2b1a6c 100644
--- a/src/core/libraries/libs.cpp
+++ b/src/core/libraries/libs.cpp
@@ -41,13 +41,13 @@
 #include "core/libraries/np/np_sns_facebook_dialog.h"
 #include "core/libraries/np/np_trophy.h"
 #include "core/libraries/np/np_web_api.h"
+#include "core/libraries/np/np_web_api2.h"
 #include "core/libraries/pad/pad.h"
 #include "core/libraries/playgo/playgo.h"
 #include "core/libraries/playgo/playgo_dialog.h"
 #include "core/libraries/random/random.h"
 #include "core/libraries/razor_cpu/razor_cpu.h"
 #include "core/libraries/remote_play/remoteplay.h"
-#include "core/libraries/rtc/rtc.h"
 #include "core/libraries/rudp/rudp.h"
 #include "core/libraries/save_data/dialog/savedatadialog.h"
 #include "core/libraries/save_data/savedata.h"
@@ -71,7 +71,6 @@
 #include "core/libraries/web_browser_dialog/webbrowserdialog.h"
 #include "core/libraries/zlib/zlib_sce.h"
 #include "fiber/fiber.h"
-#include "jpeg/jpegenc.h"
 
 namespace Libraries {
 
@@ -101,6 +100,7 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) {
     Libraries::Np::NpScore::RegisterLib(sym);
     Libraries::Np::NpTrophy::RegisterLib(sym);
     Libraries::Np::NpWebApi::RegisterLib(sym);
+    Libraries::Np::NpWebApi2::RegisterLib(sym);
     Libraries::Np::NpProfileDialog::RegisterLib(sym);
     Libraries::Np::NpSnsFacebookDialog::RegisterLib(sym);
     Libraries::Np::NpAuth::RegisterLib(sym);
@@ -118,17 +118,16 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) {
     Libraries::ErrorDialog::RegisterLib(sym);
     Libraries::ImeDialog::RegisterLib(sym);
     Libraries::AvPlayer::RegisterLib(sym);
-    Libraries::Vdec2::RegisterLib(sym);
+    Libraries::Videodec::RegisterLib(sym);
+    Libraries::Videodec2::RegisterLib(sym);
     Libraries::Audio3d::RegisterLib(sym);
     Libraries::Ime::RegisterLib(sym);
     Libraries::GameLiveStreaming::RegisterLib(sym);
     Libraries::SharePlay::RegisterLib(sym);
     Libraries::Remoteplay::RegisterLib(sym);
-    Libraries::Videodec::RegisterLib(sym);
     Libraries::RazorCpu::RegisterLib(sym);
     Libraries::Move::RegisterLib(sym);
     Libraries::Fiber::RegisterLib(sym);
-    Libraries::JpegEnc::RegisterLib(sym);
     Libraries::Mouse::RegisterLib(sym);
     Libraries::WebBrowserDialog::RegisterLib(sym);
     Libraries::Zlib::RegisterLib(sym);
@@ -141,7 +140,6 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) {
     Libraries::CompanionHttpd::RegisterLib(sym);
     Libraries::CompanionUtil::RegisterLib(sym);
     Libraries::Voice::RegisterLib(sym);
-    Libraries::Rtc::RegisterLib(sym);
     Libraries::Rudp::RegisterLib(sym);
     Libraries::VrTracker::RegisterLib(sym);
 
@@ -149,4 +147,4 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) {
     // Libraries::Ssl::RegisterLib(sym);
 }
 
-} // namespace Libraries
+} // namespace Libraries
\ No newline at end of file

From f27d23a6cb499da020350cb3d12a980527ef920e Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Sun, 8 Feb 2026 12:53:52 +0100
Subject: [PATCH 16/22] var names

---
 src/core/libraries/rudp/rudp.cpp | 48 +++++++++++++++-----------------
 src/core/libraries/rudp/rudp.h   | 40 +++++++++++++-------------
 2 files changed, 42 insertions(+), 46 deletions(-)

diff --git a/src/core/libraries/rudp/rudp.cpp b/src/core/libraries/rudp/rudp.cpp
index a5a97290e..0834373db 100644
--- a/src/core/libraries/rudp/rudp.cpp
+++ b/src/core/libraries/rudp/rudp.cpp
@@ -35,19 +35,19 @@ s32 PS4_SYSV_ABI sceRudpAccept() {
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpActivate(int contextId, Net::OrbisNetSockaddr* to,
+s32 PS4_SYSV_ABI sceRudpActivate(int context_id, Net::OrbisNetSockaddr* to,
                                  OrbisNetSocklen_t toLen) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpBind(int contextId, int soc, u16 virtualPort, u8 muxMode) {
+s32 PS4_SYSV_ABI sceRudpBind(int context_id, int soc, u16 virtualPort, u8 muxMode) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
 s32 PS4_SYSV_ABI sceRudpCreateContext(OrbisRudpContextEventHandler handler, void* arg,
-                                      int* contextId) {
+                                      int* context_id) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
@@ -68,18 +68,18 @@ s32 PS4_SYSV_ABI sceRudpEnd() {
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpFlush(int contextId) {
+s32 PS4_SYSV_ABI sceRudpFlush(int context_id) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetContextStatus(int contextId, OrbisRudpContextStatus* status,
+s32 PS4_SYSV_ABI sceRudpGetContextStatus(int context_id, OrbisRudpContextStatus* status,
                                          size_t statusSize) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetLocalInfo(int contextId, int* soc, Net::OrbisNetSockaddr* addr,
+s32 PS4_SYSV_ABI sceRudpGetLocalInfo(int context_id, int* soc, Net::OrbisNetSockaddr* addr,
                                      u32* addrlen, u16* virtualPort, u8* muxMode) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
@@ -90,44 +90,40 @@ s32 PS4_SYSV_ABI sceRudpGetMaxSegmentSize(u16* mss) {
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetNumberOfPacketsToRead(int contextId) {
+s32 PS4_SYSV_ABI sceRudpGetNumberOfPacketsToRead(int context_id) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetOption(int contextId, Option option, void* optVal, size_t optLen) {
+s32 PS4_SYSV_ABI sceRudpGetOption(int context_id, Option option, void* optVal, size_t optLen) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetRemoteInfo(int contextId, Net::OrbisNetSockaddr* addr, u32* addrlen,
+s32 PS4_SYSV_ABI sceRudpGetRemoteInfo(int context_id, Net::OrbisNetSockaddr* addr, u32* addrlen,
                                       u16* virtualPort) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetSizeReadable(int contextId) {
+s32 PS4_SYSV_ABI sceRudpGetSizeReadable(int context_id) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpGetSizeWritable(int contextId) {
+s32 PS4_SYSV_ABI sceRudpGetSizeWritable(int context_id) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 Rudp_GetActiveContexts() {
-    return g_state.current_contexts.load();
+u32 PS4_SYSV_ABI Func_01014df0(const u32* internalStructPointer) {
+    return *internalStructPointer;
 }
 
-void Rudp_GetMemoryStats(s32* sentQualityLevel4Packets, s32* rcvdQualityLevel4Packets, s32* allocs,
-                         s32* frees) {
-    *allocs = g_state.allocs.load();
-    *frees = g_state.frees.load();
-    *sentQualityLevel4Packets = g_state.sentQualityLevel4Packets.load();
-    *rcvdQualityLevel4Packets = g_state.rcvdQualityLevel4Packets.load();
+u32 PS4_SYSV_ABI Func_0100d870(u32 globalContextListPtr) {
+    u32 count = Func_01014df0((globalContextListPtr + 8));
+    return (count & 0xFFFFFFFF);
 }
-
 s32 PS4_SYSV_ABI sceRudpGetStatus(OrbisRudpStatus* status, size_t statusSize) {
     std::lock_guard lock(g_RudpMutex);
 
@@ -153,7 +149,7 @@ s32 PS4_SYSV_ABI sceRudpInit(void* memPool, int memPoolSize) {
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpInitiate(int contextId, Net::OrbisNetSockaddr* to, OrbisNetSocklen_t toLen,
+s32 PS4_SYSV_ABI sceRudpInitiate(int context_id, Net::OrbisNetSockaddr* to, OrbisNetSocklen_t toLen,
                                  u16 virtualPort) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
@@ -180,7 +176,7 @@ s32 PS4_SYSV_ABI sceRudpPollCancel(PollEvent poll) {
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpPollControl(PollEvent poll, PollOp op, int contextId, PollEvent events) {
+s32 PS4_SYSV_ABI sceRudpPollControl(PollEvent poll, PollOp op, int context_id, PollEvent events) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
@@ -206,7 +202,7 @@ s32 PS4_SYSV_ABI sceRudpProcessEvents(OrbisRudpUsec timeout) {
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpRead(int contextId, void* data, size_t len, u8 flags,
+s32 PS4_SYSV_ABI sceRudpRead(int context_id, void* data, size_t len, u8 flags,
                              OrbisRudpReadInfo* info) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
@@ -222,17 +218,17 @@ s32 PS4_SYSV_ABI sceRudpSetMaxSegmentSize(u16 mss) {
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpSetOption(int contextId, Option option, void* optVal, size_t optLen) {
+s32 PS4_SYSV_ABI sceRudpSetOption(int context_id, Option option, void* optVal, size_t optLen) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpTerminate(int contextId) {
+s32 PS4_SYSV_ABI sceRudpTerminate(int context_id) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceRudpWrite(int contextId, void* data, size_t len, Message msg) {
+s32 PS4_SYSV_ABI sceRudpWrite(int context_id, void* data, size_t len, Message msg) {
     LOG_ERROR(Lib_Rudp, "(STUBBED) called");
     return ORBIS_OK;
 }
diff --git a/src/core/libraries/rudp/rudp.h b/src/core/libraries/rudp/rudp.h
index 9ee000b22..2b8f499a3 100644
--- a/src/core/libraries/rudp/rudp.h
+++ b/src/core/libraries/rudp/rudp.h
@@ -164,60 +164,60 @@ struct OrbisRudpReadInfo {
 };
 typedef s32 OrbisKernelCpumask;
 
-typedef uint32_t OrbisNetSocklen_t;
+typedef u32 OrbisNetSocklen_t;
 
-typedef void (*OrbisRudpContextEventHandler)(int contextId, ContextEvent event, int errorCode,
+typedef void (*OrbisRudpContextEventHandler)(int context_id, ContextEvent event_id, int errorCode,
                                              void* arg);
 
 typedef u64 OrbisRudpUsec;
 
-typedef int (*OrbisRudpEventHandler)(Event event, int soc, u8 const* data, size_t dataLen,
+typedef int (*OrbisRudpEventHandler)(Event event_id, int soc, u8 const* data, size_t dataLen,
                                      Net::OrbisNetSockaddr const* addr, OrbisNetSocklen_t addrLen,
                                      void* arg);
 
 s32 PS4_SYSV_ABI sceRudpAccept();
-s32 PS4_SYSV_ABI sceRudpActivate(int contextId, Net::OrbisNetSockaddr* to, OrbisNetSocklen_t toLen);
-s32 PS4_SYSV_ABI sceRudpBind(int contextId, int soc, u16 vport, u8 muxMode);
+s32 PS4_SYSV_ABI sceRudpActivate(int context_id, Net::OrbisNetSockaddr* to, OrbisNetSocklen_t toLen);
+s32 PS4_SYSV_ABI sceRudpBind(int context_id, int soc, u16 vport, u8 muxMode);
 s32 PS4_SYSV_ABI sceRudpCreateContext(OrbisRudpContextEventHandler handler, void* arg,
-                                      int* contextId);
+                                      int* context_id);
 s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread(u32 stackSize, u32 priority);
 s32 PS4_SYSV_ABI sceRudpEnableInternalIOThread2(u32 stackSize, u32 priority,
                                                 OrbisKernelCpumask affinityMask);
 s32 PS4_SYSV_ABI sceRudpEnd();
-s32 PS4_SYSV_ABI sceRudpFlush(int contextId);
-s32 PS4_SYSV_ABI sceRudpGetContextStatus(int contextId, OrbisRudpContextStatus* status,
+s32 PS4_SYSV_ABI sceRudpFlush(int context_id);
+s32 PS4_SYSV_ABI sceRudpGetContextStatus(int context_id, OrbisRudpContextStatus* status,
                                          size_t statusSize);
-s32 PS4_SYSV_ABI sceRudpGetLocalInfo(int contextId, int* soc, Net::OrbisNetSockaddr* addr,
+s32 PS4_SYSV_ABI sceRudpGetLocalInfo(int context_id, int* soc, Net::OrbisNetSockaddr* addr,
                                      OrbisNetSocklen_t* addrLen, u16* vport, u8* muxMode);
 s32 PS4_SYSV_ABI sceRudpGetMaxSegmentSize(u16* mss);
-s32 PS4_SYSV_ABI sceRudpGetNumberOfPacketsToRead(int contextId);
-s32 PS4_SYSV_ABI sceRudpGetOption(int contextId, Option option, void* optVal, size_t optLen);
-s32 PS4_SYSV_ABI sceRudpGetRemoteInfo(int contextId, Net::OrbisNetSockaddr* addr,
+s32 PS4_SYSV_ABI sceRudpGetNumberOfPacketsToRead(int context_id);
+s32 PS4_SYSV_ABI sceRudpGetOption(int context_id, Option option, void* optVal, size_t optLen);
+s32 PS4_SYSV_ABI sceRudpGetRemoteInfo(int context_id, Net::OrbisNetSockaddr* addr,
                                       OrbisNetSocklen_t* addrLen, u16* vport);
-s32 PS4_SYSV_ABI sceRudpGetSizeReadable(int contextId);
-s32 PS4_SYSV_ABI sceRudpGetSizeWritable(int contextId);
+s32 PS4_SYSV_ABI sceRudpGetSizeReadable(int context_id);
+s32 PS4_SYSV_ABI sceRudpGetSizeWritable(int context_id);
 s32 PS4_SYSV_ABI sceRudpGetStatus(OrbisRudpStatus* status, size_t statusSize);
 s32 PS4_SYSV_ABI sceRudpInit(void* memPool, int memPoolSize);
-s32 PS4_SYSV_ABI sceRudpInitiate(int contextId, Net::OrbisNetSockaddr* to, OrbisNetSocklen_t toLen,
+s32 PS4_SYSV_ABI sceRudpInitiate(int context_id, Net::OrbisNetSockaddr* to, OrbisNetSocklen_t toLen,
                                  u16 vport);
 s32 PS4_SYSV_ABI sceRudpListen();
 s32 PS4_SYSV_ABI sceRudpNetFlush();
 s32 PS4_SYSV_ABI sceRudpNetReceived(int soc, u8* data, size_t dataLen, Net::OrbisNetSockaddr* from,
                                     OrbisNetSocklen_t fromLen);
 s32 PS4_SYSV_ABI sceRudpPollCancel(PollEvent poll);
-s32 PS4_SYSV_ABI sceRudpPollControl(PollEvent poll, PollOp op, int contextId, PollEvent events);
+s32 PS4_SYSV_ABI sceRudpPollControl(PollEvent poll, PollOp op, int context_id, PollEvent events);
 s32 PS4_SYSV_ABI sceRudpPollCreate(size_t size);
 s32 PS4_SYSV_ABI sceRudpPollDestroy(PollEvent poll);
 s32 PS4_SYSV_ABI sceRudpPollWait(PollEvent poll, OrbisRudpPollEvent* events, size_t eventLen,
                                  OrbisRudpUsec timeout);
 s32 PS4_SYSV_ABI sceRudpProcessEvents(OrbisRudpUsec timeout);
-s32 PS4_SYSV_ABI sceRudpRead(int contextId, void* data, size_t len, u8 flags,
+s32 PS4_SYSV_ABI sceRudpRead(int context_id, void* data, size_t len, u8 flags,
                              OrbisRudpReadInfo* info);
 s32 PS4_SYSV_ABI sceRudpSetEventHandler(OrbisRudpEventHandler handler, void* arg);
 s32 PS4_SYSV_ABI sceRudpSetMaxSegmentSize(u16 mss);
-s32 PS4_SYSV_ABI sceRudpSetOption(int contextId, Option option, void* optVal, size_t optLen);
-s32 PS4_SYSV_ABI sceRudpTerminate(int contextId);
-s32 PS4_SYSV_ABI sceRudpWrite(int contextId, void* data, size_t len, Message msg);
+s32 PS4_SYSV_ABI sceRudpSetOption(int context_id, Option option, void* optVal, size_t optLen);
+s32 PS4_SYSV_ABI sceRudpTerminate(int context_id);
+s32 PS4_SYSV_ABI sceRudpWrite(int context_id, void* data, size_t len, Message msg);
 
 void RegisterLib(Core::Loader::SymbolsResolver* sym);
 } // namespace Libraries::Rudp
\ No newline at end of file

From d678d1ce6c4567e886f57e8a35b6ba8d53f1da2b Mon Sep 17 00:00:00 2001
From: TheThunderTurner <64212185+thethunderturner@users.noreply.github.com>
Date: Wed, 11 Feb 2026 09:22:32 +0100
Subject: [PATCH 17/22] Revert recompiler log warning

---
 src/shader_recompiler/recompiler.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/shader_recompiler/recompiler.cpp b/src/shader_recompiler/recompiler.cpp
index 4bc141bd3..4764ddbec 100644
--- a/src/shader_recompiler/recompiler.cpp
+++ b/src/shader_recompiler/recompiler.cpp
@@ -34,7 +34,7 @@ IR::Program TranslateProgram(const std::span<const u32>& code, Pools& pools, Inf
     // Ensure first instruction is expected.
     constexpr u32 token_mov_vcchi = 0xBEEB03FF;
     if (code[0] != token_mov_vcchi) {
-        LOG_WARNING(Render_Recompiler,"First instruction is 0x{:08x}, not s_mov_b32 vcc_hi, #imm",code[0]);
+        LOG_WARNING(Render_Recompiler, "First instruction is not s_mov_b32 vcc_hi, #imm");
     }
 
     Gcn::GcnCodeSlice slice(code.data(), code.data() + code.size());

From bd91508a6284d0feafeb14260617a58f6998b49b Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Wed, 11 Feb 2026 16:01:22 +0100
Subject: [PATCH 18/22] function names

---
 src/core/libraries/rudp/rudp.cpp | 25 +++++++++++++++++--------
 1 file changed, 17 insertions(+), 8 deletions(-)

diff --git a/src/core/libraries/rudp/rudp.cpp b/src/core/libraries/rudp/rudp.cpp
index 0834373db..f5d3ca709 100644
--- a/src/core/libraries/rudp/rudp.cpp
+++ b/src/core/libraries/rudp/rudp.cpp
@@ -116,14 +116,23 @@ s32 PS4_SYSV_ABI sceRudpGetSizeWritable(int context_id) {
     return ORBIS_OK;
 }
 
-u32 PS4_SYSV_ABI Func_01014df0(const u32* internalStructPointer) {
-    return *internalStructPointer;
+u32 Func_0100d870(uintptr_t globalContextListPtr) {
+    if (globalContextListPtr == 0) {
+        return 0;
+    }
+
+    u32* countPtr = reinterpret_cast<u32*>(globalContextListPtr + 8);
+    return *countPtr;
 }
 
-u32 PS4_SYSV_ABI Func_0100d870(u32 globalContextListPtr) {
-    u32 count = Func_01014df0((globalContextListPtr + 8));
-    return (count & 0xFFFFFFFF);
+void Func_0101a5e0(s32* sentQualityLevel4Packets, s32* rcvdQualityLevel4Packets, s32* allocs,
+                   s32* frees) {
+    if (sentQualityLevel4Packets) *sentQualityLevel4Packets = g_state.sentQualityLevel4Packets.load();
+    if (rcvdQualityLevel4Packets) *rcvdQualityLevel4Packets = g_state.rcvdQualityLevel4Packets.load();
+    if (allocs) *allocs = g_state.allocs.load();
+    if (frees)  *frees = g_state.frees.load();
 }
+
 s32 PS4_SYSV_ABI sceRudpGetStatus(OrbisRudpStatus* status, size_t statusSize) {
     std::lock_guard lock(g_RudpMutex);
 
@@ -135,9 +144,9 @@ s32 PS4_SYSV_ABI sceRudpGetStatus(OrbisRudpStatus* status, size_t statusSize) {
     if (status != (OrbisRudpStatus*)nullptr && statusSize - 1 < 0xf8) {
         std::memcpy(status, &g_rudpStatusInternal, statusSize);
 
-        status->currentContexts = Rudp_GetActiveContexts();
-        Rudp_GetMemoryStats(&status->sentQualityLevel4Packets, &status->rcvdQualityLevel4Packets,
-                            &status->allocs, &status->frees);
+        status->currentContexts = g_state.current_contexts.load();
+        Func_0101a5e0(&status->sentQualityLevel4Packets, &status->rcvdQualityLevel4Packets,
+                      &status->allocs, &status->frees);
 
         return ORBIS_OK;
     }

From feece1963cdc6eb035f2c9e183a2cb0f7c5880e2 Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Wed, 11 Feb 2026 16:18:55 +0100
Subject: [PATCH 19/22] clang

---
 src/core/libraries/rudp/rudp.cpp     | 12 ++++++++----
 src/core/libraries/rudp/rudp.h       |  3 ++-
 src/core/libraries/rudp/rudp_error.h |  1 -
 3 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/core/libraries/rudp/rudp.cpp b/src/core/libraries/rudp/rudp.cpp
index f5d3ca709..ed9a8065a 100644
--- a/src/core/libraries/rudp/rudp.cpp
+++ b/src/core/libraries/rudp/rudp.cpp
@@ -127,10 +127,14 @@ u32 Func_0100d870(uintptr_t globalContextListPtr) {
 
 void Func_0101a5e0(s32* sentQualityLevel4Packets, s32* rcvdQualityLevel4Packets, s32* allocs,
                    s32* frees) {
-    if (sentQualityLevel4Packets) *sentQualityLevel4Packets = g_state.sentQualityLevel4Packets.load();
-    if (rcvdQualityLevel4Packets) *rcvdQualityLevel4Packets = g_state.rcvdQualityLevel4Packets.load();
-    if (allocs) *allocs = g_state.allocs.load();
-    if (frees)  *frees = g_state.frees.load();
+    if (sentQualityLevel4Packets)
+        *sentQualityLevel4Packets = g_state.sentQualityLevel4Packets.load();
+    if (rcvdQualityLevel4Packets)
+        *rcvdQualityLevel4Packets = g_state.rcvdQualityLevel4Packets.load();
+    if (allocs)
+        *allocs = g_state.allocs.load();
+    if (frees)
+        *frees = g_state.frees.load();
 }
 
 s32 PS4_SYSV_ABI sceRudpGetStatus(OrbisRudpStatus* status, size_t statusSize) {
diff --git a/src/core/libraries/rudp/rudp.h b/src/core/libraries/rudp/rudp.h
index 2b8f499a3..71bdf9873 100644
--- a/src/core/libraries/rudp/rudp.h
+++ b/src/core/libraries/rudp/rudp.h
@@ -176,7 +176,8 @@ typedef int (*OrbisRudpEventHandler)(Event event_id, int soc, u8 const* data, si
                                      void* arg);
 
 s32 PS4_SYSV_ABI sceRudpAccept();
-s32 PS4_SYSV_ABI sceRudpActivate(int context_id, Net::OrbisNetSockaddr* to, OrbisNetSocklen_t toLen);
+s32 PS4_SYSV_ABI sceRudpActivate(int context_id, Net::OrbisNetSockaddr* to,
+                                 OrbisNetSocklen_t toLen);
 s32 PS4_SYSV_ABI sceRudpBind(int context_id, int soc, u16 vport, u8 muxMode);
 s32 PS4_SYSV_ABI sceRudpCreateContext(OrbisRudpContextEventHandler handler, void* arg,
                                       int* context_id);
diff --git a/src/core/libraries/rudp/rudp_error.h b/src/core/libraries/rudp/rudp_error.h
index f5c34568a..e6127a101 100644
--- a/src/core/libraries/rudp/rudp_error.h
+++ b/src/core/libraries/rudp/rudp_error.h
@@ -42,4 +42,3 @@ constexpr int ORBIS_RUDP_ERROR_END_OF_DATA = 0x80770024;
 constexpr int ORBIS_RUDP_ERROR_ALREADY_ESTABLISHED = 0x80770025;
 constexpr int ORBIS_RUDP_ERROR_KEEP_ALIVE_FAILURE = 0x80770026;
 constexpr int ORBIS_RUDP_ERROR_MEMLEAK = 0x807700FF;
-

From 9614687b6a4c9c9a3a29dfeb1d2322791addaf82 Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Wed, 11 Feb 2026 16:49:17 +0100
Subject: [PATCH 20/22] submitting to windows fixing collisions with windows

---
 src/core/libraries/rudp/rudp.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/core/libraries/rudp/rudp.h b/src/core/libraries/rudp/rudp.h
index 71bdf9873..1aad7ce71 100644
--- a/src/core/libraries/rudp/rudp.h
+++ b/src/core/libraries/rudp/rudp.h
@@ -30,7 +30,7 @@ enum class Event : int {
 enum class ContextEvent : int {
     CLOSED = 1,
     ESTABLISHED = 2,
-    ERROR = 3,
+    CONTEXT_ERROR = 3,
     WRITEABLE = 4,
     READABLE = 5,
     FLUSHED = 6
@@ -38,7 +38,7 @@ enum class ContextEvent : int {
 
 enum class PollOp : int { ADD = 1, MODIFY = 2, REMOVE = 3 };
 
-enum class PollEvent : int { READ = 0x0001, WRITE = 0x0002, FLUSH = 0x0004, ERROR = 0x0008 };
+enum class PollEvent : int { READ = 0x0001, WRITE = 0x0002, FLUSH = 0x0004, POLL_ERROR = 0x0008 };
 
 enum class Option : int {
     MAX_PAYLOAD = 1,

From a08b298a5b427b857db8cba60cdcd07431c227c9 Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Wed, 11 Feb 2026 17:30:25 +0100
Subject: [PATCH 21/22] nitpicks

---
 src/core/libraries/rudp/rudp.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/core/libraries/rudp/rudp.cpp b/src/core/libraries/rudp/rudp.cpp
index ed9a8065a..f9ada8eb4 100644
--- a/src/core/libraries/rudp/rudp.cpp
+++ b/src/core/libraries/rudp/rudp.cpp
@@ -116,7 +116,7 @@ s32 PS4_SYSV_ABI sceRudpGetSizeWritable(int context_id) {
     return ORBIS_OK;
 }
 
-u32 Func_0100d870(uintptr_t globalContextListPtr) {
+u32 RudpGetContextCount(uintptr_t globalContextListPtr) {
     if (globalContextListPtr == 0) {
         return 0;
     }
@@ -125,7 +125,7 @@ u32 Func_0100d870(uintptr_t globalContextListPtr) {
     return *countPtr;
 }
 
-void Func_0101a5e0(s32* sentQualityLevel4Packets, s32* rcvdQualityLevel4Packets, s32* allocs,
+void RudpFillStatusCounters(s32* sentQualityLevel4Packets, s32* rcvdQualityLevel4Packets, s32* allocs,
                    s32* frees) {
     if (sentQualityLevel4Packets)
         *sentQualityLevel4Packets = g_state.sentQualityLevel4Packets.load();
@@ -145,11 +145,11 @@ s32 PS4_SYSV_ABI sceRudpGetStatus(OrbisRudpStatus* status, size_t statusSize) {
     }
 
     int result = ORBIS_RUDP_ERROR_INVALID_ARGUMENT;
-    if (status != (OrbisRudpStatus*)nullptr && statusSize - 1 < 0xf8) {
+    if ((status != (OrbisRudpStatus *)0x0) && (statusSize - 1 < 0xf8)) {
         std::memcpy(status, &g_rudpStatusInternal, statusSize);
 
-        status->currentContexts = g_state.current_contexts.load();
-        Func_0101a5e0(&status->sentQualityLevel4Packets, &status->rcvdQualityLevel4Packets,
+        status->currentContexts = static_cast<s32>(RudpGetContextCount(reinterpret_cast<uintptr_t>(g_RudpContext)));
+        RudpFillStatusCounters(&status->sentQualityLevel4Packets, &status->rcvdQualityLevel4Packets,
                       &status->allocs, &status->frees);
 
         return ORBIS_OK;

From 4da1b3a4a9360f08a47f86390ca1368afa5fabb5 Mon Sep 17 00:00:00 2001
From: Matthew Biskas <matthewbiskas@gmail.com>
Date: Wed, 11 Feb 2026 18:11:21 +0100
Subject: [PATCH 22/22] nullptr to 0

---
 src/core/libraries/rudp/rudp.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/libraries/rudp/rudp.cpp b/src/core/libraries/rudp/rudp.cpp
index f9ada8eb4..648f23108 100644
--- a/src/core/libraries/rudp/rudp.cpp
+++ b/src/core/libraries/rudp/rudp.cpp
@@ -145,7 +145,7 @@ s32 PS4_SYSV_ABI sceRudpGetStatus(OrbisRudpStatus* status, size_t statusSize) {
     }
 
     int result = ORBIS_RUDP_ERROR_INVALID_ARGUMENT;
-    if ((status != (OrbisRudpStatus *)0x0) && (statusSize - 1 < 0xf8)) {
+    if ((status != (OrbisRudpStatus *)0) && (statusSize - 1 < 0xf8)) {
         std::memcpy(status, &g_rudpStatusInternal, statusSize);
 
         status->currentContexts = static_cast<s32>(RudpGetContextCount(reinterpret_cast<uintptr_t>(g_RudpContext)));