diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3f3d7fcf..37021746 100755
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -282,6 +282,14 @@ set(SYSTEM_LIBS src/core/libraries/system/commondialog.cpp
                 src/core/libraries/audio3d/audio3d_error.h
                 src/core/libraries/audio3d/audio3d_impl.cpp
                 src/core/libraries/audio3d/audio3d_impl.h
+                src/core/libraries/ime/ime.cpp
+                src/core/libraries/ime/ime.h
+                src/core/libraries/game_live_streaming/gamelivestreaming.cpp
+                src/core/libraries/game_live_streaming/gamelivestreaming.h
+                src/core/libraries/remote_play/remoteplay.cpp
+                src/core/libraries/remote_play/remoteplay.h
+                src/core/libraries/share_play/shareplay.cpp
+                src/core/libraries/share_play/shareplay.h
 )
 
 set(VIDEOOUT_LIB src/core/libraries/videoout/buffer.h
diff --git a/src/common/logging/filter.cpp b/src/common/logging/filter.cpp
index 2ff2a900..051bbd79 100644
--- a/src/common/logging/filter.cpp
+++ b/src/common/logging/filter.cpp
@@ -114,6 +114,10 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
     SUB(Lib, AvPlayer)                                                                             \
     SUB(Lib, Ngs2)                                                                                 \
     SUB(Lib, Audio3d)                                                                              \
+    SUB(Lib, Ime)                                                                                  \
+    SUB(Lib, GameLiveStreaming)                                                                    \
+    SUB(Lib, Remoteplay)                                                                           \
+    SUB(Lib, SharePlay)                                                                            \
     SUB(Lib, Fiber)                                                                                \
     CLS(Frontend)                                                                                  \
     CLS(Render)                                                                                    \
diff --git a/src/common/logging/types.h b/src/common/logging/types.h
index 54388e59..39319d0d 100644
--- a/src/common/logging/types.h
+++ b/src/common/logging/types.h
@@ -29,68 +29,72 @@ enum class Level : u8 {
  * filter.cpp.
  */
 enum class Class : u8 {
-    Log,                ///< Messages about the log system itself
-    Common,             ///< Library routines
-    Common_Filesystem,  ///< Filesystem interface library
-    Common_Memory,      ///< Memory mapping and management functions
-    Core,               ///< LLE emulation core
-    Core_Linker,        ///< The module linker
-    Config,             ///< Emulator configuration (including commandline)
-    Debug,              ///< Debugging tools
-    Kernel,             ///< The HLE implementation of the PS4 kernel.
-    Kernel_Pthread,     ///< The pthread implementation of the kernel.
-    Kernel_Fs,          ///< The filesystem implementation of the kernel.
-    Kernel_Vmm,         ///< The virtual memory implementation of the kernel.
-    Kernel_Event,       ///< The event management implementation of the kernel.
-    Kernel_Sce,         ///< The sony specific interfaces provided by the kernel.
-    Lib,                ///< HLE implementation of system library. Each major library
-                        ///< should have its own subclass.
-    Lib_LibC,           ///< The LibC implementation.
-    Lib_Kernel,         ///< The LibKernel implementation.
-    Lib_Pad,            ///< The LibScePad implementation.
-    Lib_GnmDriver,      ///< The LibSceGnmDriver implementation.
-    Lib_SystemService,  ///< The LibSceSystemService implementation.
-    Lib_UserService,    ///< The LibSceUserService implementation.
-    Lib_VideoOut,       ///< The LibSceVideoOut implementation.
-    Lib_CommonDlg,      ///< The LibSceCommonDialog implementation.
-    Lib_MsgDlg,         ///< The LibSceMsgDialog implementation.
-    Lib_AudioOut,       ///< The LibSceAudioOut implementation.
-    Lib_AudioIn,        ///< The LibSceAudioIn implementation.
-    Lib_Net,            ///< The LibSceNet implementation.
-    Lib_NetCtl,         ///< The LibSecNetCtl implementation.
-    Lib_SaveData,       ///< The LibSceSaveData implementation.
-    Lib_SaveDataDialog, ///< The LibSceSaveDataDialog implementation.
-    Lib_Ssl,            ///< The LibSceSsl implementation.
-    Lib_Http,           ///< The LibSceHttp implementation.
-    Lib_SysModule,      ///< The LibSceSysModule implementation
-    Lib_NpManager,      ///< The LibSceNpManager implementation
-    Lib_NpScore,        ///< The LibSceNpScore implementation
-    Lib_NpTrophy,       ///< The LibSceNpTrophy implementation
-    Lib_Screenshot,     ///< The LibSceScreenshot implementation
-    Lib_LibCInternal,   ///< The LibCInternal implementation.
-    Lib_AppContent,     ///< The LibSceAppContent implementation.
-    Lib_Rtc,            ///< The LibSceRtc implementation.
-    Lib_DiscMap,        ///< The LibSceDiscMap implementation.
-    Lib_Png,            ///< The LibScePng implementation.
-    Lib_PlayGo,         ///< The LibScePlayGo implementation.
-    Lib_Random,         ///< The libSceRandom implementation.
-    Lib_Usbd,           ///< The LibSceUsbd implementation.
-    Lib_Ajm,            ///< The LibSceAjm implementation.
-    Lib_ErrorDialog,    ///< The LibSceErrorDialog implementation.
-    Lib_ImeDialog,      ///< The LibSceImeDialog implementation.
-    Lib_AvPlayer,       ///< The LibSceAvPlayer implementation.
-    Lib_Ngs2,           ///< The LibSceNgs2 implementation.
-    Lib_Audio3d,        ///< The LibSceAudio3d implementation.
-    Lib_Fiber,          ///< The LibSceFiber implementation.
-    Frontend,           ///< Emulator UI
-    Render,             ///< Video Core
-    Render_Vulkan,      ///< Vulkan backend
-    Render_Recompiler,  ///< Shader recompiler
-    ImGui,              ///< ImGui
-    Loader,             ///< ROM loader
-    Input,              ///< Input emulation
-    Tty,                ///< Debug output from emu
-    Count               ///< Total number of logging classes
+    Log,                   ///< Messages about the log system itself
+    Common,                ///< Library routines
+    Common_Filesystem,     ///< Filesystem interface library
+    Common_Memory,         ///< Memory mapping and management functions
+    Core,                  ///< LLE emulation core
+    Core_Linker,           ///< The module linker
+    Config,                ///< Emulator configuration (including commandline)
+    Debug,                 ///< Debugging tools
+    Kernel,                ///< The HLE implementation of the PS4 kernel.
+    Kernel_Pthread,        ///< The pthread implementation of the kernel.
+    Kernel_Fs,             ///< The filesystem implementation of the kernel.
+    Kernel_Vmm,            ///< The virtual memory implementation of the kernel.
+    Kernel_Event,          ///< The event management implementation of the kernel.
+    Kernel_Sce,            ///< The sony specific interfaces provided by the kernel.
+    Lib,                   ///< HLE implementation of system library. Each major library
+                           ///< should have its own subclass.
+    Lib_LibC,              ///< The LibC implementation.
+    Lib_Kernel,            ///< The LibKernel implementation.
+    Lib_Pad,               ///< The LibScePad implementation.
+    Lib_GnmDriver,         ///< The LibSceGnmDriver implementation.
+    Lib_SystemService,     ///< The LibSceSystemService implementation.
+    Lib_UserService,       ///< The LibSceUserService implementation.
+    Lib_VideoOut,          ///< The LibSceVideoOut implementation.
+    Lib_CommonDlg,         ///< The LibSceCommonDialog implementation.
+    Lib_MsgDlg,            ///< The LibSceMsgDialog implementation.
+    Lib_AudioOut,          ///< The LibSceAudioOut implementation.
+    Lib_AudioIn,           ///< The LibSceAudioIn implementation.
+    Lib_Net,               ///< The LibSceNet implementation.
+    Lib_NetCtl,            ///< The LibSecNetCtl implementation.
+    Lib_SaveData,          ///< The LibSceSaveData implementation.
+    Lib_SaveDataDialog,    ///< The LibSceSaveDataDialog implementation.
+    Lib_Ssl,               ///< The LibSceSsl implementation.
+    Lib_Http,              ///< The LibSceHttp implementation.
+    Lib_SysModule,         ///< The LibSceSysModule implementation
+    Lib_NpManager,         ///< The LibSceNpManager implementation
+    Lib_NpScore,           ///< The LibSceNpScore implementation
+    Lib_NpTrophy,          ///< The LibSceNpTrophy implementation
+    Lib_Screenshot,        ///< The LibSceScreenshot implementation
+    Lib_LibCInternal,      ///< The LibCInternal implementation.
+    Lib_AppContent,        ///< The LibSceAppContent implementation.
+    Lib_Rtc,               ///< The LibSceRtc implementation.
+    Lib_DiscMap,           ///< The LibSceDiscMap implementation.
+    Lib_Png,               ///< The LibScePng implementation.
+    Lib_PlayGo,            ///< The LibScePlayGo implementation.
+    Lib_Random,            ///< The libSceRandom implementation.
+    Lib_Usbd,              ///< The LibSceUsbd implementation.
+    Lib_Ajm,               ///< The LibSceAjm implementation.
+    Lib_ErrorDialog,       ///< The LibSceErrorDialog implementation.
+    Lib_ImeDialog,         ///< The LibSceImeDialog implementation.
+    Lib_AvPlayer,          ///< The LibSceAvPlayer implementation.
+    Lib_Ngs2,              ///< The LibSceNgs2 implementation.
+    Lib_Audio3d,           ///< The LibSceAudio3d implementation.
+    Lib_Ime,               ///< The LibSceIme implementation
+    Lib_GameLiveStreaming, ///< The LibSceGameLiveStreaming implementation
+    Lib_Remoteplay,        ///< The LibSceRemotePlay implementation
+    Lib_SharePlay,         ///< The LibSceSharePlay implemenation
+    Lib_Fiber,             ///< The LibSceFiber implementation.
+    Frontend,              ///< Emulator UI
+    Render,                ///< Video Core
+    Render_Vulkan,         ///< Vulkan backend
+    Render_Recompiler,     ///< Shader recompiler
+    ImGui,                 ///< ImGui
+    Loader,                ///< ROM loader
+    Input,                 ///< Input emulation
+    Tty,                   ///< Debug output from emu
+    Count                  ///< Total number of logging classes
 };
 
 } // namespace Common::Log
diff --git a/src/core/libraries/game_live_streaming/gamelivestreaming.cpp b/src/core/libraries/game_live_streaming/gamelivestreaming.cpp
new file mode 100644
index 00000000..a1ebddfb
--- /dev/null
+++ b/src/core/libraries/game_live_streaming/gamelivestreaming.cpp
@@ -0,0 +1,354 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "gamelivestreaming.h"
+
+#include "common/logging/log.h"
+#include "core/libraries/error_codes.h"
+#include "core/libraries/libs.h"
+
+namespace Libraries::GameLiveStreaming {
+
+int PS4_SYSV_ABI sceGameLiveStreamingStartDebugBroadcast() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingStopDebugBroadcast() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingApplySocialFeedbackMessageFilter() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingCheckCallback() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingClearPresetSocialFeedbackCommands() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingClearSocialFeedbackMessages() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingClearSpoilerTag() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingEnableLiveStreaming() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingEnableSocialFeedback() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingGetCurrentBroadcastScreenLayout() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingGetCurrentStatus(OrbisGameLiveStreamingStatus* status) {
+    memset(status, 0, sizeof(*status));
+    status->isOnAir = false;
+    LOG_DEBUG(Lib_GameLiveStreaming, "(STUBBED) called userid = {}", status->userId);
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingGetCurrentStatus2() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingGetProgramInfo() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingGetSocialFeedbackMessages() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingGetSocialFeedbackMessagesCount() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingInitialize() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingLaunchLiveViewer() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingLaunchLiveViewerA() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingPermitLiveStreaming() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingPermitServerSideRecording() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingPostSocialMessage() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingRegisterCallback() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingScreenCloseSeparateMode() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingScreenConfigureSeparateMode() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingScreenInitialize() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingScreenInitializeSeparateModeParameter() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingScreenOpenSeparateMode() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingScreenSetMode() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingScreenTerminate() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingSetCameraFrameSetting() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingSetDefaultServiceProviderPermission() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingSetGuardAreas() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingSetInvitationSessionId() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingSetLinkCommentPreset() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingSetMaxBitrate() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingSetMetadata() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingSetPresetSocialFeedbackCommands() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingSetPresetSocialFeedbackCommandsDescription() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingSetServiceProviderPermission() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingSetSpoilerTag() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingSetStandbyScreenResource() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingStartGenerateStandbyScreenResource() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingStartSocialFeedbackMessageFiltering() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingStopGenerateStandbyScreenResource() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingStopSocialFeedbackMessageFiltering() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingTerminate() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceGameLiveStreamingUnregisterCallback() {
+    LOG_ERROR(Lib_GameLiveStreaming, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterlibSceGameLiveStreaming(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("caqgDl+V9qA", "libSceGameLiveStreaming_debug", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingStartDebugBroadcast);
+    LIB_FUNCTION("0i8Lrllxwow", "libSceGameLiveStreaming_debug", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingStopDebugBroadcast);
+    LIB_FUNCTION("NqkTzemliC0", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingApplySocialFeedbackMessageFilter);
+    LIB_FUNCTION("PC4jq87+YQI", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingCheckCallback);
+    LIB_FUNCTION("FcHBfHjFXkA", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingClearPresetSocialFeedbackCommands);
+    LIB_FUNCTION("lZ2Sd0uEvpo", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingClearSocialFeedbackMessages);
+    LIB_FUNCTION("6c2zGtThFww", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingClearSpoilerTag);
+    LIB_FUNCTION("dWM80AX39o4", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingEnableLiveStreaming);
+    LIB_FUNCTION("wBOQWjbWMfU", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingEnableSocialFeedback);
+    LIB_FUNCTION("aRSQNqbats4", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingGetCurrentBroadcastScreenLayout);
+    LIB_FUNCTION("CoPMx369EqM", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingGetCurrentStatus);
+    LIB_FUNCTION("lK8dLBNp9OE", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingGetCurrentStatus2);
+    LIB_FUNCTION("OIIm19xu+NM", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingGetProgramInfo);
+    LIB_FUNCTION("PMx7N4WqNdo", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingGetSocialFeedbackMessages);
+    LIB_FUNCTION("yeQKjHETi40", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingGetSocialFeedbackMessagesCount);
+    LIB_FUNCTION("kvYEw2lBndk", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingInitialize);
+    LIB_FUNCTION("ysWfX5PPbfc", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingLaunchLiveViewer);
+    LIB_FUNCTION("cvRCb7DTAig", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingLaunchLiveViewerA);
+    LIB_FUNCTION("K0QxEbD7q+c", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingPermitLiveStreaming);
+    LIB_FUNCTION("-EHnU68gExU", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingPermitServerSideRecording);
+    LIB_FUNCTION("hggKhPySVgI", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingPostSocialMessage);
+    LIB_FUNCTION("nFP8qT9YXbo", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingRegisterCallback);
+    LIB_FUNCTION("b5RaMD2J0So", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingScreenCloseSeparateMode);
+    LIB_FUNCTION("hBdd8n6kuvE", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingScreenConfigureSeparateMode);
+    LIB_FUNCTION("uhCmn81s-mU", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingScreenInitialize);
+    LIB_FUNCTION("fo5B8RUaBxQ", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingScreenInitializeSeparateModeParameter);
+    LIB_FUNCTION("iorzW0pKOiA", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingScreenOpenSeparateMode);
+    LIB_FUNCTION("gDSvt78H3Oo", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingScreenSetMode);
+    LIB_FUNCTION("HE93dr-5rx4", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingScreenTerminate);
+    LIB_FUNCTION("3PSiwAzFISE", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingSetCameraFrameSetting);
+    LIB_FUNCTION("TwuUzTKKeek", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingSetDefaultServiceProviderPermission);
+    LIB_FUNCTION("Gw6S4oqlY7E", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingSetGuardAreas);
+    LIB_FUNCTION("QmQYwQ7OTJI", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingSetInvitationSessionId);
+    LIB_FUNCTION("Sb5bAXyUt5c", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingSetLinkCommentPreset);
+    LIB_FUNCTION("q-kxuaF7URU", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingSetMaxBitrate);
+    LIB_FUNCTION("hUY-mSOyGL0", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingSetMetadata);
+    LIB_FUNCTION("ycodiP2I0xo", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingSetPresetSocialFeedbackCommands);
+    LIB_FUNCTION("x6deXUpQbBo", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingSetPresetSocialFeedbackCommandsDescription);
+    LIB_FUNCTION("mCoz3k3zPmA", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingSetServiceProviderPermission);
+    LIB_FUNCTION("ZuX+zzz2DkA", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingSetSpoilerTag);
+    LIB_FUNCTION("MLvYI86FFAo", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingSetStandbyScreenResource);
+    LIB_FUNCTION("y0KkAydy9xE", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingStartGenerateStandbyScreenResource);
+    LIB_FUNCTION("Y1WxX7dPMCw", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingStartSocialFeedbackMessageFiltering);
+    LIB_FUNCTION("D7dg5QJ4FlE", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingStopGenerateStandbyScreenResource);
+    LIB_FUNCTION("bYuGUBuIsaY", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingStopSocialFeedbackMessageFiltering);
+    LIB_FUNCTION("9yK6Fk8mKOQ", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingTerminate);
+    LIB_FUNCTION("5XHaH3kL+bA", "libSceGameLiveStreaming", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingUnregisterCallback);
+    LIB_FUNCTION("caqgDl+V9qA", "libSceGameLiveStreaming_direct_streaming", 1,
+                 "libSceGameLiveStreaming", 1, 1, sceGameLiveStreamingStartDebugBroadcast);
+    LIB_FUNCTION("0i8Lrllxwow", "libSceGameLiveStreaming_direct_streaming", 1,
+                 "libSceGameLiveStreaming", 1, 1, sceGameLiveStreamingStopDebugBroadcast);
+    LIB_FUNCTION("CoPMx369EqM", "libSceGameLiveStreamingCompat", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingGetCurrentStatus);
+    LIB_FUNCTION("ysWfX5PPbfc", "libSceGameLiveStreamingCompat", 1, "libSceGameLiveStreaming", 1, 1,
+                 sceGameLiveStreamingLaunchLiveViewer);
+};
+
+} // namespace Libraries::GameLiveStreaming
\ No newline at end of file
diff --git a/src/core/libraries/game_live_streaming/gamelivestreaming.h b/src/core/libraries/game_live_streaming/gamelivestreaming.h
new file mode 100644
index 00000000..468750fd
--- /dev/null
+++ b/src/core/libraries/game_live_streaming/gamelivestreaming.h
@@ -0,0 +1,81 @@
+// 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::GameLiveStreaming {
+
+struct OrbisGameLiveStreamingStatus {
+    bool isOnAir;
+    u8 align[3];
+    u32 spectatorCounts;
+    s32 userId;
+    u8 reserved[60];
+};
+struct OrbisGameLiveStreamingStatus2 {
+    s32 userId;
+    bool isOnAir;
+    u8 align[3];
+    u32 spectatorCounts;
+    u32 textMessageCounts;
+    u32 commandMessageCounts;
+    u32 broadcastVideoResolution;
+    u8 reserved[48];
+};
+
+int PS4_SYSV_ABI sceGameLiveStreamingStartDebugBroadcast();
+int PS4_SYSV_ABI sceGameLiveStreamingStopDebugBroadcast();
+int PS4_SYSV_ABI sceGameLiveStreamingApplySocialFeedbackMessageFilter();
+int PS4_SYSV_ABI sceGameLiveStreamingCheckCallback();
+int PS4_SYSV_ABI sceGameLiveStreamingClearPresetSocialFeedbackCommands();
+int PS4_SYSV_ABI sceGameLiveStreamingClearSocialFeedbackMessages();
+int PS4_SYSV_ABI sceGameLiveStreamingClearSpoilerTag();
+int PS4_SYSV_ABI sceGameLiveStreamingEnableLiveStreaming();
+int PS4_SYSV_ABI sceGameLiveStreamingEnableSocialFeedback();
+int PS4_SYSV_ABI sceGameLiveStreamingGetCurrentBroadcastScreenLayout();
+int PS4_SYSV_ABI sceGameLiveStreamingGetCurrentStatus(OrbisGameLiveStreamingStatus* status);
+int PS4_SYSV_ABI sceGameLiveStreamingGetCurrentStatus2();
+int PS4_SYSV_ABI sceGameLiveStreamingGetProgramInfo();
+int PS4_SYSV_ABI sceGameLiveStreamingGetSocialFeedbackMessages();
+int PS4_SYSV_ABI sceGameLiveStreamingGetSocialFeedbackMessagesCount();
+int PS4_SYSV_ABI sceGameLiveStreamingInitialize();
+int PS4_SYSV_ABI sceGameLiveStreamingLaunchLiveViewer();
+int PS4_SYSV_ABI sceGameLiveStreamingLaunchLiveViewerA();
+int PS4_SYSV_ABI sceGameLiveStreamingPermitLiveStreaming();
+int PS4_SYSV_ABI sceGameLiveStreamingPermitServerSideRecording();
+int PS4_SYSV_ABI sceGameLiveStreamingPostSocialMessage();
+int PS4_SYSV_ABI sceGameLiveStreamingRegisterCallback();
+int PS4_SYSV_ABI sceGameLiveStreamingScreenCloseSeparateMode();
+int PS4_SYSV_ABI sceGameLiveStreamingScreenConfigureSeparateMode();
+int PS4_SYSV_ABI sceGameLiveStreamingScreenInitialize();
+int PS4_SYSV_ABI sceGameLiveStreamingScreenInitializeSeparateModeParameter();
+int PS4_SYSV_ABI sceGameLiveStreamingScreenOpenSeparateMode();
+int PS4_SYSV_ABI sceGameLiveStreamingScreenSetMode();
+int PS4_SYSV_ABI sceGameLiveStreamingScreenTerminate();
+int PS4_SYSV_ABI sceGameLiveStreamingSetCameraFrameSetting();
+int PS4_SYSV_ABI sceGameLiveStreamingSetDefaultServiceProviderPermission();
+int PS4_SYSV_ABI sceGameLiveStreamingSetGuardAreas();
+int PS4_SYSV_ABI sceGameLiveStreamingSetInvitationSessionId();
+int PS4_SYSV_ABI sceGameLiveStreamingSetLinkCommentPreset();
+int PS4_SYSV_ABI sceGameLiveStreamingSetMaxBitrate();
+int PS4_SYSV_ABI sceGameLiveStreamingSetMetadata();
+int PS4_SYSV_ABI sceGameLiveStreamingSetPresetSocialFeedbackCommands();
+int PS4_SYSV_ABI sceGameLiveStreamingSetPresetSocialFeedbackCommandsDescription();
+int PS4_SYSV_ABI sceGameLiveStreamingSetServiceProviderPermission();
+int PS4_SYSV_ABI sceGameLiveStreamingSetSpoilerTag();
+int PS4_SYSV_ABI sceGameLiveStreamingSetStandbyScreenResource();
+int PS4_SYSV_ABI sceGameLiveStreamingStartGenerateStandbyScreenResource();
+int PS4_SYSV_ABI sceGameLiveStreamingStartSocialFeedbackMessageFiltering();
+int PS4_SYSV_ABI sceGameLiveStreamingStopGenerateStandbyScreenResource();
+int PS4_SYSV_ABI sceGameLiveStreamingStopSocialFeedbackMessageFiltering();
+int PS4_SYSV_ABI sceGameLiveStreamingTerminate();
+int PS4_SYSV_ABI sceGameLiveStreamingUnregisterCallback();
+
+void RegisterlibSceGameLiveStreaming(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::GameLiveStreaming
\ No newline at end of file
diff --git a/src/core/libraries/ime/ime.cpp b/src/core/libraries/ime/ime.cpp
new file mode 100644
index 00000000..13a70acf
--- /dev/null
+++ b/src/core/libraries/ime/ime.cpp
@@ -0,0 +1,340 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "ime.h"
+
+#include "common/logging/log.h"
+#include "core/libraries/error_codes.h"
+#include "core/libraries/libs.h"
+
+namespace Libraries::Ime {
+
+int PS4_SYSV_ABI FinalizeImeModule() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI InitializeImeModule() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeCheckFilterText() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeCheckRemoteEventParam() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeCheckUpdateTextInfo() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeClose() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeConfigGet() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeConfigSet() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeConfirmCandidate() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeDicAddWord() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeDicDeleteLearnDics() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeDicDeleteUserDics() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeDicDeleteWord() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeDicGetWords() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeDicReplaceWord() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeDisableController() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeFilterText() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeForTestFunction() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeGetPanelPositionAndForm() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeGetPanelSize() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeKeyboardClose() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeKeyboardGetInfo() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeKeyboardGetResourceId() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeKeyboardOpen() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeKeyboardOpenInternal() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeKeyboardSetMode() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeKeyboardUpdate() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeOpen() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeOpenInternal() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeParamInit() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeSetCandidateIndex() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeSetCaret() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeSetText() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeSetTextGeometry() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeUpdate() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshClearPreedit() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshClose() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshConfirmPreedit() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshDisableController() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshGetPanelPositionAndForm() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshInformConfirmdString() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshInformConfirmdString2() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshOpen() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshSendTextInfo() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshSetCaretGeometry() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshSetCaretIndexInPreedit() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshSetPanelPosition() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshSetParam() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshSetPreeditGeometry() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshSetSelectGeometry() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshSetSelectionText() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshUpdate() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshUpdateContext() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceImeVshUpdateContext2() {
+    LOG_ERROR(Lib_Ime, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterlibSceIme(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("mN+ZoSN-8hQ", "libSceIme", 1, "libSceIme", 1, 1, FinalizeImeModule);
+    LIB_FUNCTION("uTW+63goeJs", "libSceIme", 1, "libSceIme", 1, 1, InitializeImeModule);
+    LIB_FUNCTION("Lf3DeGWC6xg", "libSceIme", 1, "libSceIme", 1, 1, sceImeCheckFilterText);
+    LIB_FUNCTION("zHuMUGb-AQI", "libSceIme", 1, "libSceIme", 1, 1, sceImeCheckRemoteEventParam);
+    LIB_FUNCTION("OTb0Mg+1i1k", "libSceIme", 1, "libSceIme", 1, 1, sceImeCheckUpdateTextInfo);
+    LIB_FUNCTION("TmVP8LzcFcY", "libSceIme", 1, "libSceIme", 1, 1, sceImeClose);
+    LIB_FUNCTION("Ho5NVQzpKHo", "libSceIme", 1, "libSceIme", 1, 1, sceImeConfigGet);
+    LIB_FUNCTION("P5dPeiLwm-M", "libSceIme", 1, "libSceIme", 1, 1, sceImeConfigSet);
+    LIB_FUNCTION("tKLmVIUkpyM", "libSceIme", 1, "libSceIme", 1, 1, sceImeConfirmCandidate);
+    LIB_FUNCTION("NYDsL9a0oEo", "libSceIme", 1, "libSceIme", 1, 1, sceImeDicAddWord);
+    LIB_FUNCTION("l01GKoyiQrY", "libSceIme", 1, "libSceIme", 1, 1, sceImeDicDeleteLearnDics);
+    LIB_FUNCTION("E2OcGgi-FPY", "libSceIme", 1, "libSceIme", 1, 1, sceImeDicDeleteUserDics);
+    LIB_FUNCTION("JAiMBkOTYKI", "libSceIme", 1, "libSceIme", 1, 1, sceImeDicDeleteWord);
+    LIB_FUNCTION("JoPdCUXOzMU", "libSceIme", 1, "libSceIme", 1, 1, sceImeDicGetWords);
+    LIB_FUNCTION("FuEl46uHDyo", "libSceIme", 1, "libSceIme", 1, 1, sceImeDicReplaceWord);
+    LIB_FUNCTION("E+f1n8e8DAw", "libSceIme", 1, "libSceIme", 1, 1, sceImeDisableController);
+    LIB_FUNCTION("evjOsE18yuI", "libSceIme", 1, "libSceIme", 1, 1, sceImeFilterText);
+    LIB_FUNCTION("wVkehxutK-U", "libSceIme", 1, "libSceIme", 1, 1, sceImeForTestFunction);
+    LIB_FUNCTION("T6FYjZXG93o", "libSceIme", 1, "libSceIme", 1, 1, sceImeGetPanelPositionAndForm);
+    LIB_FUNCTION("ziPDcIjO0Vk", "libSceIme", 1, "libSceIme", 1, 1, sceImeGetPanelSize);
+    LIB_FUNCTION("PMVehSlfZ94", "libSceIme", 1, "libSceIme", 1, 1, sceImeKeyboardClose);
+    LIB_FUNCTION("VkqLPArfFdc", "libSceIme", 1, "libSceIme", 1, 1, sceImeKeyboardGetInfo);
+    LIB_FUNCTION("dKadqZFgKKQ", "libSceIme", 1, "libSceIme", 1, 1, sceImeKeyboardGetResourceId);
+    LIB_FUNCTION("eaFXjfJv3xs", "libSceIme", 1, "libSceIme", 1, 1, sceImeKeyboardOpen);
+    LIB_FUNCTION("oYkJlMK51SA", "libSceIme", 1, "libSceIme", 1, 1, sceImeKeyboardOpenInternal);
+    LIB_FUNCTION("ua+13Hk9kKs", "libSceIme", 1, "libSceIme", 1, 1, sceImeKeyboardSetMode);
+    LIB_FUNCTION("3Hx2Uw9xnv8", "libSceIme", 1, "libSceIme", 1, 1, sceImeKeyboardUpdate);
+    LIB_FUNCTION("RPydv-Jr1bc", "libSceIme", 1, "libSceIme", 1, 1, sceImeOpen);
+    LIB_FUNCTION("16UI54cWRQk", "libSceIme", 1, "libSceIme", 1, 1, sceImeOpenInternal);
+    LIB_FUNCTION("WmYDzdC4EHI", "libSceIme", 1, "libSceIme", 1, 1, sceImeParamInit);
+    LIB_FUNCTION("TQaogSaqkEk", "libSceIme", 1, "libSceIme", 1, 1, sceImeSetCandidateIndex);
+    LIB_FUNCTION("WLxUN2WMim8", "libSceIme", 1, "libSceIme", 1, 1, sceImeSetCaret);
+    LIB_FUNCTION("ieCNrVrzKd4", "libSceIme", 1, "libSceIme", 1, 1, sceImeSetText);
+    LIB_FUNCTION("TXYHFRuL8UY", "libSceIme", 1, "libSceIme", 1, 1, sceImeSetTextGeometry);
+    LIB_FUNCTION("-4GCfYdNF1s", "libSceIme", 1, "libSceIme", 1, 1, sceImeUpdate);
+    LIB_FUNCTION("oOwl47ouxoM", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshClearPreedit);
+    LIB_FUNCTION("gtoTsGM9vEY", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshClose);
+    LIB_FUNCTION("wTKF4mUlSew", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshConfirmPreedit);
+    LIB_FUNCTION("rM-1hkuOhh0", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshDisableController);
+    LIB_FUNCTION("42xMaQ+GLeQ", "libSceIme", 1, "libSceIme", 1, 1,
+                 sceImeVshGetPanelPositionAndForm);
+    LIB_FUNCTION("ZmmV6iukhyo", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshInformConfirmdString);
+    LIB_FUNCTION("EQBusz6Uhp8", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshInformConfirmdString2);
+    LIB_FUNCTION("LBicRa-hj3A", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshOpen);
+    LIB_FUNCTION("-IAOwd2nO7g", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshSendTextInfo);
+    LIB_FUNCTION("qDagOjvJdNk", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshSetCaretGeometry);
+    LIB_FUNCTION("tNOlmxee-Nk", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshSetCaretIndexInPreedit);
+    LIB_FUNCTION("rASXozKkQ9g", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshSetPanelPosition);
+    LIB_FUNCTION("idvMaIu5H+k", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshSetParam);
+    LIB_FUNCTION("ga5GOgThbjo", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshSetPreeditGeometry);
+    LIB_FUNCTION("RuSca8rS6yA", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshSetSelectGeometry);
+    LIB_FUNCTION("J7COZrgSFRA", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshSetSelectionText);
+    LIB_FUNCTION("WqAayyok5p0", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshUpdate);
+    LIB_FUNCTION("O7Fdd+Oc-qQ", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshUpdateContext);
+    LIB_FUNCTION("fwcPR7+7Rks", "libSceIme", 1, "libSceIme", 1, 1, sceImeVshUpdateContext2);
+};
+
+} // namespace Libraries::Ime
\ No newline at end of file
diff --git a/src/core/libraries/ime/ime.h b/src/core/libraries/ime/ime.h
new file mode 100644
index 00000000..807616f1
--- /dev/null
+++ b/src/core/libraries/ime/ime.h
@@ -0,0 +1,70 @@
+// 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::Ime {
+
+int PS4_SYSV_ABI FinalizeImeModule();
+int PS4_SYSV_ABI InitializeImeModule();
+int PS4_SYSV_ABI sceImeCheckFilterText();
+int PS4_SYSV_ABI sceImeCheckRemoteEventParam();
+int PS4_SYSV_ABI sceImeCheckUpdateTextInfo();
+int PS4_SYSV_ABI sceImeClose();
+int PS4_SYSV_ABI sceImeConfigGet();
+int PS4_SYSV_ABI sceImeConfigSet();
+int PS4_SYSV_ABI sceImeConfirmCandidate();
+int PS4_SYSV_ABI sceImeDicAddWord();
+int PS4_SYSV_ABI sceImeDicDeleteLearnDics();
+int PS4_SYSV_ABI sceImeDicDeleteUserDics();
+int PS4_SYSV_ABI sceImeDicDeleteWord();
+int PS4_SYSV_ABI sceImeDicGetWords();
+int PS4_SYSV_ABI sceImeDicReplaceWord();
+int PS4_SYSV_ABI sceImeDisableController();
+int PS4_SYSV_ABI sceImeFilterText();
+int PS4_SYSV_ABI sceImeForTestFunction();
+int PS4_SYSV_ABI sceImeGetPanelPositionAndForm();
+int PS4_SYSV_ABI sceImeGetPanelSize();
+int PS4_SYSV_ABI sceImeKeyboardClose();
+int PS4_SYSV_ABI sceImeKeyboardGetInfo();
+int PS4_SYSV_ABI sceImeKeyboardGetResourceId();
+int PS4_SYSV_ABI sceImeKeyboardOpen();
+int PS4_SYSV_ABI sceImeKeyboardOpenInternal();
+int PS4_SYSV_ABI sceImeKeyboardSetMode();
+int PS4_SYSV_ABI sceImeKeyboardUpdate();
+int PS4_SYSV_ABI sceImeOpen();
+int PS4_SYSV_ABI sceImeOpenInternal();
+int PS4_SYSV_ABI sceImeParamInit();
+int PS4_SYSV_ABI sceImeSetCandidateIndex();
+int PS4_SYSV_ABI sceImeSetCaret();
+int PS4_SYSV_ABI sceImeSetText();
+int PS4_SYSV_ABI sceImeSetTextGeometry();
+int PS4_SYSV_ABI sceImeUpdate();
+int PS4_SYSV_ABI sceImeVshClearPreedit();
+int PS4_SYSV_ABI sceImeVshClose();
+int PS4_SYSV_ABI sceImeVshConfirmPreedit();
+int PS4_SYSV_ABI sceImeVshDisableController();
+int PS4_SYSV_ABI sceImeVshGetPanelPositionAndForm();
+int PS4_SYSV_ABI sceImeVshInformConfirmdString();
+int PS4_SYSV_ABI sceImeVshInformConfirmdString2();
+int PS4_SYSV_ABI sceImeVshOpen();
+int PS4_SYSV_ABI sceImeVshSendTextInfo();
+int PS4_SYSV_ABI sceImeVshSetCaretGeometry();
+int PS4_SYSV_ABI sceImeVshSetCaretIndexInPreedit();
+int PS4_SYSV_ABI sceImeVshSetPanelPosition();
+int PS4_SYSV_ABI sceImeVshSetParam();
+int PS4_SYSV_ABI sceImeVshSetPreeditGeometry();
+int PS4_SYSV_ABI sceImeVshSetSelectGeometry();
+int PS4_SYSV_ABI sceImeVshSetSelectionText();
+int PS4_SYSV_ABI sceImeVshUpdate();
+int PS4_SYSV_ABI sceImeVshUpdateContext();
+int PS4_SYSV_ABI sceImeVshUpdateContext2();
+
+void RegisterlibSceIme(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::Ime
\ No newline at end of file
diff --git a/src/core/libraries/libs.cpp b/src/core/libraries/libs.cpp
index fb771bc2..caa254fd 100644
--- a/src/core/libraries/libs.cpp
+++ b/src/core/libraries/libs.cpp
@@ -11,8 +11,9 @@
 #include "core/libraries/dialogs/error_dialog.h"
 #include "core/libraries/dialogs/ime_dialog.h"
 #include "core/libraries/disc_map/disc_map.h"
-#include "core/libraries/fiber/fiber.h"
+#include "core/libraries/game_live_streaming/gamelivestreaming.h"
 #include "core/libraries/gnmdriver/gnmdriver.h"
+#include "core/libraries/ime/ime.h"
 #include "core/libraries/kernel/libkernel.h"
 #include "core/libraries/libc_internal/libc_internal.h"
 #include "core/libraries/libpng/pngdec.h"
@@ -27,10 +28,12 @@
 #include "core/libraries/pad/pad.h"
 #include "core/libraries/playgo/playgo.h"
 #include "core/libraries/random/random.h"
+#include "core/libraries/remote_play/remoteplay.h"
 #include "core/libraries/rtc/rtc.h"
 #include "core/libraries/save_data/dialog/savedatadialog.h"
 #include "core/libraries/save_data/savedata.h"
 #include "core/libraries/screenshot/screenshot.h"
+#include "core/libraries/share_play/shareplay.h"
 #include "core/libraries/system/commondialog.h"
 #include "core/libraries/system/msgdialog.h"
 #include "core/libraries/system/posix.h"
@@ -78,6 +81,10 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) {
     Libraries::ImeDialog::RegisterlibSceImeDialog(sym);
     Libraries::AvPlayer::RegisterlibSceAvPlayer(sym);
     Libraries::Audio3d::RegisterlibSceAudio3d(sym);
+    Libraries::Ime::RegisterlibSceIme(sym);
+    Libraries::GameLiveStreaming::RegisterlibSceGameLiveStreaming(sym);
+    Libraries::SharePlay::RegisterlibSceSharePlay(sym);
+    Libraries::Remoteplay::RegisterlibSceRemoteplay(sym);
 }
 
 } // namespace Libraries
diff --git a/src/core/libraries/network/net.cpp b/src/core/libraries/network/net.cpp
index 35d5851e..161fc521 100644
--- a/src/core/libraries/network/net.cpp
+++ b/src/core/libraries/network/net.cpp
@@ -734,9 +734,16 @@ int PS4_SYSV_ABI sceNetInetNtopWithScopeId() {
     return ORBIS_OK;
 }
 
-int PS4_SYSV_ABI sceNetInetPton() {
-    LOG_ERROR(Lib_Net, "(STUBBED) called");
-    return ORBIS_OK;
+int PS4_SYSV_ABI sceNetInetPton(int af, const char* src, void* dst) {
+#ifdef WIN32
+    int res = InetPtonA(af, src, dst);
+#else
+    int res = inet_pton(af, src, dst);
+#endif
+    if (res < 0) {
+        UNREACHABLE();
+    }
+    return res;
 }
 
 int PS4_SYSV_ABI sceNetInetPtonEx() {
diff --git a/src/core/libraries/network/net.h b/src/core/libraries/network/net.h
index 3f010f68..beef38b5 100644
--- a/src/core/libraries/network/net.h
+++ b/src/core/libraries/network/net.h
@@ -169,7 +169,7 @@ u64 PS4_SYSV_ABI sceNetHtonll(u64 host64);
 u16 PS4_SYSV_ABI sceNetHtons(u16 host16);
 const char* PS4_SYSV_ABI sceNetInetNtop(int af, const void* src, char* dst, u32 size);
 int PS4_SYSV_ABI sceNetInetNtopWithScopeId();
-int PS4_SYSV_ABI sceNetInetPton();
+int PS4_SYSV_ABI sceNetInetPton(int af, const char* src, void* dst);
 int PS4_SYSV_ABI sceNetInetPtonEx();
 int PS4_SYSV_ABI sceNetInetPtonWithScopeId();
 int PS4_SYSV_ABI sceNetInfoDumpStart();
diff --git a/src/core/libraries/network/net_ctl_codes.h b/src/core/libraries/network/net_ctl_codes.h
index a38565c1..0dac4201 100644
--- a/src/core/libraries/network/net_ctl_codes.h
+++ b/src/core/libraries/network/net_ctl_codes.h
@@ -26,3 +26,11 @@ constexpr int ORBIS_NET_CTL_STATE_IPOBTAINED = 3;
 constexpr int ORBIS_NET_CTL_EVENT_TYPE_DISCONNECTED = 1;
 constexpr int ORBIS_SCE_NET_CTL_EVENT_TYPE_DISCONNECT_REQ_FINISHED = 2;
 constexpr int ORBIS_NET_CTL_EVENT_TYPE_IPOBTAINED = 3;
+
+// get info codes
+// device
+constexpr int ORBIS_NET_CTL_DEVICE_WIRED = 0;
+constexpr int ORBIS_NET_CTL_DEVICE_WIRELESS = 1;
+// link
+constexpr int ORBIS_NET_CTL_LINK_DISCONNECTED = 0;
+constexpr int ORBIS_NET_CTL_LINK_CONNECTED = 1;
diff --git a/src/core/libraries/network/net_obj.cpp b/src/core/libraries/network/net_obj.cpp
new file mode 100644
index 00000000..e69de29b
diff --git a/src/core/libraries/network/net_obj.h b/src/core/libraries/network/net_obj.h
new file mode 100644
index 00000000..e69de29b
diff --git a/src/core/libraries/network/netctl.cpp b/src/core/libraries/network/netctl.cpp
index 3ecdde77..e7a69611 100644
--- a/src/core/libraries/network/netctl.cpp
+++ b/src/core/libraries/network/netctl.cpp
@@ -1,6 +1,17 @@
 // SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#ifdef WIN32
+#define _WINSOCK_DEPRECATED_NO_WARNINGS
+#include <Ws2tcpip.h>
+#include <iphlpapi.h>
+#include <winsock2.h>
+#else
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <unistd.h>
+#endif
+
 #include "common/logging/log.h"
 #include "common/singleton.h"
 #include "core/libraries/error_codes.h"
@@ -149,15 +160,32 @@ int PS4_SYSV_ABI sceNetCtlGetIfStat() {
 int PS4_SYSV_ABI sceNetCtlGetInfo(int code, OrbisNetCtlInfo* info) {
     switch (code) {
     case ORBIS_NET_CTL_INFO_DEVICE:
-        info->device = 0;
+        info->device = ORBIS_NET_CTL_DEVICE_WIRED;
         break;
     case ORBIS_NET_CTL_INFO_LINK:
-        info->link = 0; // disconnected
+        info->link = ORBIS_NET_CTL_LINK_DISCONNECTED;
         break;
+    case ORBIS_NET_CTL_INFO_IP_ADDRESS: {
+        strcpy(info->ip_address,
+               "127.0.0.1"); // placeholder in case gethostbyname can't find another ip
+        char devname[80];
+        gethostname(devname, 80);
+        struct hostent* resolved = gethostbyname(devname);
+        for (int i = 0; resolved->h_addr_list[i] != nullptr; ++i) {
+            struct in_addr addrIn;
+            memcpy(&addrIn, resolved->h_addr_list[i], sizeof(u32));
+            char* addr = inet_ntoa(addrIn);
+            if (strcmp(addr, "127.0.0.1") != 0) {
+                strcpy(info->ip_address, addr);
+                break;
+            }
+        }
+        break;
+    }
     default:
         LOG_ERROR(Lib_NetCtl, "{} unsupported code", code);
     }
-    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    LOG_DEBUG(Lib_NetCtl, "(STUBBED) called");
     return ORBIS_OK;
 }
 
@@ -187,7 +215,10 @@ int PS4_SYSV_ABI sceNetCtlGetNetEvConfigInfoIpcInt() {
 }
 
 int PS4_SYSV_ABI sceNetCtlGetResult(int eventType, int* errorCode) {
-    LOG_ERROR(Lib_NetCtl, "(STUBBED) called eventType = {} ", eventType);
+    if (!errorCode) {
+        return ORBIS_NET_CTL_ERROR_INVALID_ADDR;
+    }
+    LOG_DEBUG(Lib_NetCtl, "(STUBBED) called eventType = {} ", eventType);
     *errorCode = 0;
     return ORBIS_OK;
 }
diff --git a/src/core/libraries/network/netctl.h b/src/core/libraries/network/netctl.h
index 850650f9..89ba34c3 100644
--- a/src/core/libraries/network/netctl.h
+++ b/src/core/libraries/network/netctl.h
@@ -50,6 +50,7 @@ typedef union OrbisNetCtlInfo {
 // GetInfo codes
 constexpr int ORBIS_NET_CTL_INFO_DEVICE = 1;
 constexpr int ORBIS_NET_CTL_INFO_LINK = 4;
+constexpr int ORBIS_NET_CTL_INFO_IP_ADDRESS = 14;
 
 int PS4_SYSV_ABI sceNetBweCheckCallbackIpcInt();
 int PS4_SYSV_ABI sceNetBweClearEventIpcInt();
diff --git a/src/core/libraries/pad/pad.cpp b/src/core/libraries/pad/pad.cpp
index b671e007..d786647c 100644
--- a/src/core/libraries/pad/pad.cpp
+++ b/src/core/libraries/pad/pad.cpp
@@ -88,7 +88,7 @@ int PS4_SYSV_ABI scePadGetCapability() {
 }
 
 int PS4_SYSV_ABI scePadGetControllerInformation(s32 handle, OrbisPadControllerInformation* pInfo) {
-    LOG_INFO(Lib_Pad, "called handle = {}", handle);
+    LOG_DEBUG(Lib_Pad, "called handle = {}", handle);
     if (handle < 0) {
         pInfo->touchPadInfo.pixelDensity = 1;
         pInfo->touchPadInfo.resolution.x = 1920;
diff --git a/src/core/libraries/remote_play/remoteplay.cpp b/src/core/libraries/remote_play/remoteplay.cpp
new file mode 100644
index 00000000..b7402173
--- /dev/null
+++ b/src/core/libraries/remote_play/remoteplay.cpp
@@ -0,0 +1,309 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "remoteplay.h"
+
+#include "common/logging/log.h"
+#include "core/libraries/error_codes.h"
+#include "core/libraries/libs.h"
+
+namespace Libraries::Remoteplay {
+
+int PS4_SYSV_ABI sceRemoteplayApprove() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayChangeEnterKey() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayClearAllRegistData() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayClearConnectHistory() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayConfirmDeviceRegist() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayDisconnect() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayGeneratePinCode() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayGetApMode() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayGetConnectHistory() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayGetConnectionStatus(s32 userId, int* pStatus) {
+    *pStatus = ORBIS_REMOTEPLAY_CONNECTION_STATUS_DISCONNECT;
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayGetConnectUserId() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayGetMbusDeviceInfo() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayGetOperationStatus() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayGetRemoteplayStatus() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayGetRpMode() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayImeClose() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayImeFilterResult() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayImeGetEvent() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayImeNotify() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayImeNotifyEventResult() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayImeOpen() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayImeSetCaret() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayImeSetText() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayInitialize() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayIsRemoteOskReady() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayIsRemotePlaying() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayNotifyMbusDeviceRegistComplete() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayNotifyNpPushWakeup() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayNotifyPinCodeError() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayNotifyUserDelete() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayPrintAllRegistData() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayProhibit() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayProhibitStreaming() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayServerLock() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayServerUnLock() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplaySetApMode() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplaySetLogLevel() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplaySetProhibition() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplaySetProhibitionForVsh() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplaySetRpMode() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRemoteplayTerminate() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_1D5EE365ED5FADB3() {
+    LOG_ERROR(Lib_Remoteplay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterlibSceRemoteplay(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("xQeIryTX7dY", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayApprove);
+    LIB_FUNCTION("IYZ+Mu+8tPo", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayChangeEnterKey);
+    LIB_FUNCTION("ZYUsJtcAnqA", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayClearAllRegistData);
+    LIB_FUNCTION("cCheyCbF7qw", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayClearConnectHistory);
+    LIB_FUNCTION("tPYT-kGbZh8", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayConfirmDeviceRegist);
+    LIB_FUNCTION("6Lg4BNleJWc", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayDisconnect);
+    LIB_FUNCTION("j98LdSGy4eY", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayGeneratePinCode);
+    LIB_FUNCTION("L+cL-M-DP3w", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayGetApMode);
+    LIB_FUNCTION("g4K51cY+PEw", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayGetConnectHistory);
+    LIB_FUNCTION("g3PNjYKWqnQ", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayGetConnectionStatus);
+    LIB_FUNCTION("3eBNV9A0BUM", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayGetConnectUserId);
+    LIB_FUNCTION("ufesWMVX6iU", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayGetMbusDeviceInfo);
+    LIB_FUNCTION("DxU4JGh4S2k", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayGetOperationStatus);
+    LIB_FUNCTION("n5OxFJEvPlc", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayGetRemoteplayStatus);
+    LIB_FUNCTION("Cekhs6LSHC0", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayGetRpMode);
+    LIB_FUNCTION("ig1ocbR7Ptw", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayImeClose);
+    LIB_FUNCTION("gV9-8cJPM3I", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayImeFilterResult);
+    LIB_FUNCTION("cMk57DZXe6c", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayImeGetEvent);
+    LIB_FUNCTION("-gwkQpOCl68", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayImeNotify);
+    LIB_FUNCTION("58v9tSlRxc8", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayImeNotifyEventResult);
+    LIB_FUNCTION("C3r2zT5ebMg", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayImeOpen);
+    LIB_FUNCTION("oB730zwoz0s", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayImeSetCaret);
+    LIB_FUNCTION("rOTg1Nljp8w", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayImeSetText);
+    LIB_FUNCTION("k1SwgkMSOM8", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayInitialize);
+    LIB_FUNCTION("R8RZC1ZIkzU", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayIsRemoteOskReady);
+    LIB_FUNCTION("uYhiELUtLgA", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayIsRemotePlaying);
+    LIB_FUNCTION("d-BBSEq1nfc", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayNotifyMbusDeviceRegistComplete);
+    LIB_FUNCTION("Yytq7NE38R8", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayNotifyNpPushWakeup);
+    LIB_FUNCTION("Wg-w8xjMZA4", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayNotifyPinCodeError);
+    LIB_FUNCTION("yheulqylKwI", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayNotifyUserDelete);
+    LIB_FUNCTION("t5ZvUiZ1hpE", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayPrintAllRegistData);
+    LIB_FUNCTION("mrNh78tBpmg", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayProhibit);
+    LIB_FUNCTION("7QLrixwVHcU", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayProhibitStreaming);
+    LIB_FUNCTION("-ThIlThsN80", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayServerLock);
+    LIB_FUNCTION("0Z-Pm5rZJOI", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayServerUnLock);
+    LIB_FUNCTION("xSrhtSLIjOc", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplaySetApMode);
+    LIB_FUNCTION("5-2agAeaE+c", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplaySetLogLevel);
+    LIB_FUNCTION("Rf0XMVR7xPw", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplaySetProhibition);
+    LIB_FUNCTION("n4l3FTZtNQM", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplaySetProhibitionForVsh);
+    LIB_FUNCTION("-BPcEQ1w8xc", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplaySetRpMode);
+    LIB_FUNCTION("BOwybKVa3Do", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 sceRemoteplayTerminate);
+    LIB_FUNCTION("HV7jZe1frbM", "libSceRemoteplay", 1, "libSceRemoteplay", 0, 0,
+                 Func_1D5EE365ED5FADB3);
+};
+
+} // namespace Libraries::Remoteplay
\ No newline at end of file
diff --git a/src/core/libraries/remote_play/remoteplay.h b/src/core/libraries/remote_play/remoteplay.h
new file mode 100644
index 00000000..979f73a9
--- /dev/null
+++ b/src/core/libraries/remote_play/remoteplay.h
@@ -0,0 +1,62 @@
+// 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;
+}
+
+// returning codes in sceRemoteplayGetConnectionStatus pstatus
+constexpr int ORBIS_REMOTEPLAY_CONNECTION_STATUS_DISCONNECT = 0;
+constexpr int ORBIS_REMOTEPLAY_CONNECTION_STATUS_CONNECT = 1;
+
+namespace Libraries::Remoteplay {
+
+int PS4_SYSV_ABI sceRemoteplayApprove();
+int PS4_SYSV_ABI sceRemoteplayChangeEnterKey();
+int PS4_SYSV_ABI sceRemoteplayClearAllRegistData();
+int PS4_SYSV_ABI sceRemoteplayClearConnectHistory();
+int PS4_SYSV_ABI sceRemoteplayConfirmDeviceRegist();
+int PS4_SYSV_ABI sceRemoteplayDisconnect();
+int PS4_SYSV_ABI sceRemoteplayGeneratePinCode();
+int PS4_SYSV_ABI sceRemoteplayGetApMode();
+int PS4_SYSV_ABI sceRemoteplayGetConnectHistory();
+int PS4_SYSV_ABI sceRemoteplayGetConnectionStatus(s32 userId, int* pStatus);
+int PS4_SYSV_ABI sceRemoteplayGetConnectUserId();
+int PS4_SYSV_ABI sceRemoteplayGetMbusDeviceInfo();
+int PS4_SYSV_ABI sceRemoteplayGetOperationStatus();
+int PS4_SYSV_ABI sceRemoteplayGetRemoteplayStatus();
+int PS4_SYSV_ABI sceRemoteplayGetRpMode();
+int PS4_SYSV_ABI sceRemoteplayImeClose();
+int PS4_SYSV_ABI sceRemoteplayImeFilterResult();
+int PS4_SYSV_ABI sceRemoteplayImeGetEvent();
+int PS4_SYSV_ABI sceRemoteplayImeNotify();
+int PS4_SYSV_ABI sceRemoteplayImeNotifyEventResult();
+int PS4_SYSV_ABI sceRemoteplayImeOpen();
+int PS4_SYSV_ABI sceRemoteplayImeSetCaret();
+int PS4_SYSV_ABI sceRemoteplayImeSetText();
+int PS4_SYSV_ABI sceRemoteplayInitialize();
+int PS4_SYSV_ABI sceRemoteplayIsRemoteOskReady();
+int PS4_SYSV_ABI sceRemoteplayIsRemotePlaying();
+int PS4_SYSV_ABI sceRemoteplayNotifyMbusDeviceRegistComplete();
+int PS4_SYSV_ABI sceRemoteplayNotifyNpPushWakeup();
+int PS4_SYSV_ABI sceRemoteplayNotifyPinCodeError();
+int PS4_SYSV_ABI sceRemoteplayNotifyUserDelete();
+int PS4_SYSV_ABI sceRemoteplayPrintAllRegistData();
+int PS4_SYSV_ABI sceRemoteplayProhibit();
+int PS4_SYSV_ABI sceRemoteplayProhibitStreaming();
+int PS4_SYSV_ABI sceRemoteplayServerLock();
+int PS4_SYSV_ABI sceRemoteplayServerUnLock();
+int PS4_SYSV_ABI sceRemoteplaySetApMode();
+int PS4_SYSV_ABI sceRemoteplaySetLogLevel();
+int PS4_SYSV_ABI sceRemoteplaySetProhibition();
+int PS4_SYSV_ABI sceRemoteplaySetProhibitionForVsh();
+int PS4_SYSV_ABI sceRemoteplaySetRpMode();
+int PS4_SYSV_ABI sceRemoteplayTerminate();
+int PS4_SYSV_ABI Func_1D5EE365ED5FADB3();
+
+void RegisterlibSceRemoteplay(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::Remoteplay
\ No newline at end of file
diff --git a/src/core/libraries/share_play/shareplay.cpp b/src/core/libraries/share_play/shareplay.cpp
new file mode 100644
index 00000000..8370438b
--- /dev/null
+++ b/src/core/libraries/share_play/shareplay.cpp
@@ -0,0 +1,186 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "shareplay.h"
+
+#include "common/logging/log.h"
+#include "core/libraries/error_codes.h"
+#include "core/libraries/libs.h"
+
+namespace Libraries::SharePlay {
+
+int PS4_SYSV_ABI sceSharePlayCrashDaemon() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlayGetCurrentConnectionInfo(OrbisSharePlayConnectionInfo* pInfo) {
+    memset(pInfo, 0, sizeof(*pInfo));
+    pInfo->status = ORBIS_SHARE_PLAY_CONNECTION_STATUS_DORMANT;
+    LOG_DEBUG(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlayGetCurrentConnectionInfoA() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlayGetCurrentInfo() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlayGetEvent() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlayInitialize() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlayNotifyDialogOpen() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlayNotifyForceCloseForCdlg() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlayNotifyOpenQuickMenu() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlayResumeScreenForCdlg() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlayServerLock() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlayServerUnLock() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlaySetMode() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlaySetProhibition() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlaySetProhibitionModeWithAppId() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlayStartStandby() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlayStartStreaming() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlayStopStandby() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlayStopStreaming() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSharePlayTerminate() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_2E93C0EA6A6B67C4() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_C1C236728D88E177() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_E9E80C474781F115() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_F3DD6199DA15ED44() {
+    LOG_ERROR(Lib_SharePlay, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterlibSceSharePlay(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("ggnCfalLU-8", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayCrashDaemon);
+    LIB_FUNCTION("OOrLKB0bSDs", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayGetCurrentConnectionInfo);
+    LIB_FUNCTION("+MCXJlWdi+s", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayGetCurrentConnectionInfoA);
+    LIB_FUNCTION("vUMkWXQff3w", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayGetCurrentInfo);
+    LIB_FUNCTION("Md7Mdkr8LBc", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayGetEvent);
+    LIB_FUNCTION("isruqthpYcw", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayInitialize);
+    LIB_FUNCTION("9zwJpai7jGc", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayNotifyDialogOpen);
+    LIB_FUNCTION("VUW2V9cUTP4", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayNotifyForceCloseForCdlg);
+    LIB_FUNCTION("XL0WwUJoQPg", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayNotifyOpenQuickMenu);
+    LIB_FUNCTION("6-1fKaa5HlY", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayResumeScreenForCdlg);
+    LIB_FUNCTION("U28jAuLHj6c", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayServerLock);
+    LIB_FUNCTION("3Oaux9ITEtY", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayServerUnLock);
+    LIB_FUNCTION("QZy+KmyqKPU", "libSceSharePlay", 1, "libSceSharePlay", 0, 0, sceSharePlaySetMode);
+    LIB_FUNCTION("co2NCj--pnc", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlaySetProhibition);
+    LIB_FUNCTION("KADsbjNCgPo", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlaySetProhibitionModeWithAppId);
+    LIB_FUNCTION("-F6NddfUsa4", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayStartStandby);
+    LIB_FUNCTION("rWVNHNnEx6g", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayStartStreaming);
+    LIB_FUNCTION("zEDkUWLVwFI", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayStopStandby);
+    LIB_FUNCTION("aGlema+JxUU", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayStopStreaming);
+    LIB_FUNCTION("UaLjloJinow", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayTerminate);
+    LIB_FUNCTION("LpPA6mprZ8Q", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 Func_2E93C0EA6A6B67C4);
+    LIB_FUNCTION("wcI2co2I4Xc", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 Func_C1C236728D88E177);
+    LIB_FUNCTION("6egMR0eB8RU", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 Func_E9E80C474781F115);
+    LIB_FUNCTION("891hmdoV7UQ", "libSceSharePlay", 1, "libSceSharePlay", 0, 0,
+                 Func_F3DD6199DA15ED44);
+    LIB_FUNCTION("OOrLKB0bSDs", "libSceSharePlayCompat", 1, "libSceSharePlay", 0, 0,
+                 sceSharePlayGetCurrentConnectionInfo);
+};
+
+} // namespace Libraries::SharePlay
\ No newline at end of file
diff --git a/src/core/libraries/share_play/shareplay.h b/src/core/libraries/share_play/shareplay.h
new file mode 100644
index 00000000..8b1ad5f4
--- /dev/null
+++ b/src/core/libraries/share_play/shareplay.h
@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <core/libraries/np_manager/np_manager.h>
+#include "common/types.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
+
+namespace Libraries::SharePlay {
+
+constexpr int ORBIS_SHARE_PLAY_CONNECTION_STATUS_DORMANT = 0x00;
+constexpr int ORBIS_SHARE_PLAY_CONNECTION_STATUS_READY = 0x01;
+constexpr int ORBIS_SHARE_PLAY_CONNECTION_STATUS_CONNECTED = 0x02;
+
+struct OrbisSharePlayConnectionInfo {
+    int status;
+    int mode;
+    Libraries::NpManager::OrbisNpOnlineId hostOnlineId;
+    Libraries::NpManager::OrbisNpOnlineId visitorOnlineId;
+    s32 hostUserId;
+    s32 visitorUserId;
+};
+
+int PS4_SYSV_ABI sceSharePlayCrashDaemon();
+int PS4_SYSV_ABI sceSharePlayGetCurrentConnectionInfo(OrbisSharePlayConnectionInfo* pInfo);
+int PS4_SYSV_ABI sceSharePlayGetCurrentConnectionInfoA();
+int PS4_SYSV_ABI sceSharePlayGetCurrentInfo();
+int PS4_SYSV_ABI sceSharePlayGetEvent();
+int PS4_SYSV_ABI sceSharePlayInitialize();
+int PS4_SYSV_ABI sceSharePlayNotifyDialogOpen();
+int PS4_SYSV_ABI sceSharePlayNotifyForceCloseForCdlg();
+int PS4_SYSV_ABI sceSharePlayNotifyOpenQuickMenu();
+int PS4_SYSV_ABI sceSharePlayResumeScreenForCdlg();
+int PS4_SYSV_ABI sceSharePlayServerLock();
+int PS4_SYSV_ABI sceSharePlayServerUnLock();
+int PS4_SYSV_ABI sceSharePlaySetMode();
+int PS4_SYSV_ABI sceSharePlaySetProhibition();
+int PS4_SYSV_ABI sceSharePlaySetProhibitionModeWithAppId();
+int PS4_SYSV_ABI sceSharePlayStartStandby();
+int PS4_SYSV_ABI sceSharePlayStartStreaming();
+int PS4_SYSV_ABI sceSharePlayStopStandby();
+int PS4_SYSV_ABI sceSharePlayStopStreaming();
+int PS4_SYSV_ABI sceSharePlayTerminate();
+int PS4_SYSV_ABI Func_2E93C0EA6A6B67C4();
+int PS4_SYSV_ABI Func_C1C236728D88E177();
+int PS4_SYSV_ABI Func_E9E80C474781F115();
+int PS4_SYSV_ABI Func_F3DD6199DA15ED44();
+
+void RegisterlibSceSharePlay(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::SharePlay
\ No newline at end of file
diff --git a/src/core/libraries/system/userservice.cpp b/src/core/libraries/system/userservice.cpp
index 56085547..140ca892 100644
--- a/src/core/libraries/system/userservice.cpp
+++ b/src/core/libraries/system/userservice.cpp
@@ -491,7 +491,7 @@ int PS4_SYSV_ABI sceUserServiceGetImeRunCount() {
 }
 
 s32 PS4_SYSV_ABI sceUserServiceGetInitialUser(int* user_id) {
-    LOG_INFO(Lib_UserService, "called");
+    LOG_DEBUG(Lib_UserService, "called");
     if (user_id == nullptr) {
         LOG_ERROR(Lib_UserService, "user_id is null");
         return ORBIS_USER_SERVICE_ERROR_INVALID_ARGUMENT;