initial setup

2024-10-07 03:43:54 +00:00 · 2024-02-27 19:51:39 +01:00 · 2024-02-27 19:51:39 +01:00 · 4ce37db625
commit 4ce37db625
parent a5fe4cde30
450 changed files with 543736 additions and 0 deletions
--- a/.clang-format
+++ b/.clang-format
@ -0,0 +1,184 @@
+---
+Language: Cpp
+BasedOnStyle:  LLVM
+AccessModifierOffset: -4
+AlignAfterOpenBracket: Align
+AlignConsecutiveMacros: Consecutive
+AlignConsecutiveAssignments: Consecutive
+AlignConsecutiveBitFields: Consecutive
+AlignConsecutiveDeclarations: Consecutive
+AlignEscapedNewlines: Right
+AlignOperands:   Align
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: true
+AllowAllConstructorInitializersOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortEnumsOnASingleLine: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: WithoutElse
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: Yes
+AttributeMacros:
+  - __capability
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterCaseLabel:  true
+  AfterClass:      true
+  AfterControlStatement: Always
+  AfterEnum:       true
+  AfterFunction:   true
+  AfterNamespace:  false
+  AfterObjCDeclaration: true
+  AfterStruct:     true
+  AfterUnion:      true
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  BeforeLambdaBody: true
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: true
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     160
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DeriveLineEnding: true
+DerivePointerAlignment: false
+DisableFormat:   false
+EmptyLineBeforeAccessModifier: LogicalBlock
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+  - FOR
+  - FOR_HASH
+StatementAttributeLikeMacros:
+  - Q_EMIT
+IncludeBlocks:   Regroup
+IncludeCategories:
+  - Regex:           '^"(Kyty)/'
+    Priority:        1
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^"(Emulator)/'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^"(gtest)/'
+    Priority:        4
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^<Q'
+    Priority:        5
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '"ui_'
+    Priority:        6
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^<'
+    Priority:        7
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '.*'
+    Priority:        3
+    SortPriority:    0
+    CaseSensitive:   false
+IncludeIsMainRegex: '$'
+IncludeIsMainSourceRegex: ''
+IndentCaseLabels: true
+IndentCaseBlocks: false
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentExternBlock: AfterExternBlock
+IndentRequires:  false
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+InsertTrailingCommas: None
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PenaltyIndentedWhitespace: 0
+PointerAlignment: Left
+ReflowComments:  true
+SortIncludes:    true
+SortJavaStaticImport: Before
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: true
+SpaceBeforeCtorInitializerColon: false
+SpaceBeforeInheritanceColon: false
+SpaceBeforeParens: ControlStatements
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeRangeBasedForLoopColon: false
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+BitFieldColonSpacing: Both
+Standard:        Latest
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        4
+UseCRLF:         true
+UseTab:          Never
+WhitespaceSensitiveMacros:
+  - STRINGIZE
+  - PP_STRINGIZE
+  - BOOST_PP_STRINGIZE
+  - NS_SWIFT_NAME
+  - CF_SWIFT_NAME
+...
+
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,4 @@
+_*/
+.*/
+out/
+!.vscode
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@ -0,0 +1,12 @@
+{
+    "ccls.misc.compilationDatabaseDirectory": "_Build/_Release",
+    "ccls.clang.excludeArgsIsWhitelist": true,
+    "ccls.clang.excludeArgs": ["-I*", "-isystem*", "-x*", "-D*", "/std*", "-std:*", "-f*"],
+    "ccls.clang.extraArgs": ["-fexceptions"],
+    "ccls.index.threads": 0,
+
+    "asciidoc.use_kroki": true,
+    "asciidoc.preview.useEditorStyle": false,
+    "asciidoc.use_asciidoctorpdf": true,
+    "editor.tabSize": 2,
+}
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@ -0,0 +1,86 @@
+{
+  "version": "2.0.0",
+  "windows": {
+    "options": {
+      "env": {
+        "CXXFLAGS": "-m64 -fdiagnostics-absolute-paths",
+        "CFLAGS": "-m64 -fdiagnostics-absolute-paths"
+      },
+      "shell": {
+        "executable": "cmd.exe",
+        "args": [
+          "/C",
+          "\"C:/PROGRA~2/MICROS~1/2019/Community/VC/Auxiliary/Build/vcvars64.bat\"",
+          "&&"
+        ]
+      }
+    }
+  },
+  "tasks": [
+    {
+      "label": "Config",
+      "type": "shell",
+      "command": "cmake.exe",
+      "args": [
+        "-S${workspaceFolder}",
+        "-B_build/_Release",
+        "-GNinja",
+        "-DEMULATOR_DEV_ROOT=D:/tmpSdk/development",
+        "-DCMAKE_BUILD_TYPE=Release",
+        "-DCMAKE_INSTALL_PREFIX=_build/_Install",
+        "-DCMAKE_C_COMPILER=clang-cl.exe",
+        "-DCMAKE_CXX_COMPILER=clang-cl.exe",
+        "-DCMAKE_EXPORT_COMPILE_COMMANDS=1",
+      ],
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      },
+      "presentation": {},
+    },
+    {
+      "label": "Build",
+      "type": "shell",
+      "command": "cmake.exe",
+      "args": [
+        "--build",
+        "_build/_Release",
+        "-j8"
+      ],
+      "group": {
+        "kind": "build",
+      },
+      "presentation": {},
+    },
+    {
+      "label": "install",
+      "type": "shell",
+      "command": "cmake.exe",
+      "args": [
+        "--install",
+        "_build/_Release"
+      ],
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      },
+      "presentation": {},
+    },
+    {
+      "label": "clean",
+      "type": "shell",
+      "command": "cmake.exe",
+      "args": [
+        "--build",
+        "_build/_Release",
+        "--target",
+        "clean"
+      ],
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      },
+      "presentation": {},
+    }
+  ]
+}
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -0,0 +1,44 @@
+cmake_minimum_required(VERSION 3.24)
+
+set(ProjectName psOff_${CMAKE_BUILD_TYPE})
+project(${ProjectName} VERSION 0.0.1)
+
+unset(CMAKE_IMPORT_LIBRARY_SUFFIX)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_CXX_FLAGS_RELEASE "/MD /EHa /Zi /GS- /GF /Gy /GR /Oi -Ofast -fno-strict-aliasing")
+
+set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+set(CMAKE_WINDOWS_SYMBOL_VISIBILITY_IN_STATIC_LIBRARIES OFF)
+
+find_package(Vulkan 1.3 REQUIRED)
+message("Vulkan Libs: ${Vulkan_LIBRARIES}")
+message("Vulkan Include: ${Vulkan_INCLUDE_DIRS}")
+
+get_filename_component(VulkanPath ${Vulkan_LIBRARY} DIRECTORY)
+message("Vulkan Path: ${VulkanPath}")
+
+
+if( NOT EMULATOR_DEV_ROOT)
+  message(FATAL_ERROR "EMULATOR_DEV_ROOT not defined")
+endif()
+
+include_directories(BEFORE
+  ${EMULATOR_ROOT}/include
+  ${CMAKE_SOURCE_DIR}/modules_include
+  ${CMAKE_SOURCE_DIR}
+)
+
+link_directories(BEFORE
+  ${EMULATOR_ROOT}/lib
+)
+
+link_libraries(
+  psOff_utility
+  logging
+)
+
+add_definitions("-D__APICALL_IMPORT")
+add_subdirectory(third_party/portAudio)
+add_subdirectory(modules)
--- a/docs/chapters/ModulesOverview.adoc
+++ b/docs/chapters/ModulesOverview.adoc
@ -0,0 +1,26 @@
+== Overview Modules
+
+A brief overview of the modules.
+
+[plantuml, softwareArchoverview-class, png]
+----
+include::../uml/ModulesOverview.puml[]
+----
+
+Each target library is created seperatly as a shared library in the *modules* folder. This allows NIDs generation at build time and a clean code seperation.
+
+New modules can be created by:
+
+. copying the *template* folder
+. replace the name of the folder with the *identical* name of the target library.
+. inside CMakeLists.txt, replace template inside "set(libName template)" with the library name
+. inside entry.cpp, replace "libSce" both in LOG_DEFINE_MODULE() and MODULE_NAME = ""
+
+All exported function are placed inside the provided extern "C" scope and should start with "EXPORT SYSV_ABI", since those functions are  called directly by the emulated application (linux).
+
+[TIP]
+The template only contains a dependency to the logging library as a bare minimum. To access the interfaces from the emulator, add the following line: +
+target_link_libraries(${libName} PRIVATE emulator.lib)
+
+After a new cmake config, the new library should be picked up and built.
+Libraries are only loaded on demand.
--- a/docs/resource/AMD_Southern_Islands_Instruction_Set_Architecture.pdf
+++ b/docs/resource/AMD_Southern_Islands_Instruction_Set_Architecture.pdf
--- a/docs/resource/GLSLangSpec.4.60.pdf
+++ b/docs/resource/GLSLangSpec.4.60.pdf
--- a/docs/resource/R6xx_R7xx_3D.pdf
+++ b/docs/resource/R6xx_R7xx_3D.pdf
--- a/docs/resource/Vega_Shader_ISA_28July2017.pdf
+++ b/docs/resource/Vega_Shader_ISA_28July2017.pdf
--- a/docs/resource/si_programming_guide_v2.pdf
+++ b/docs/resource/si_programming_guide_v2.pdf
--- a/docs/top.adoc
+++ b/docs/top.adoc
@ -0,0 +1,11 @@
+= psOff - PS4 exe
+05.07.2022
+:sectnums:
+:toc:
+:toc-title: Contents
+:description: psOff Software Documentation
+:keywords: AsciiDoc
+:imagesdir: ./img
+
+include::chapters/ModulesOverview.adoc[]
+
--- a/docs/uml/ModulesOverview.puml
+++ b/docs/uml/ModulesOverview.puml
@ -0,0 +1,17 @@
+@startuml
+skinparam classAttributeIconSize 0
+
+package "Modules" {}
+
+class "psOff Emulator"{
+  +accessRuntimeLinker()
+  +accessInitParams()
+  +accessTimer()
+  +accessVideoOut()
+  +accessFileManager()
+  +accessGpuMemory()
+  +accessSystemContent()
+}
+
+Modules -> "psOff Emulator"
+@enduml
--- a/modules/CMakeLists.txt
+++ b/modules/CMakeLists.txt
@ -0,0 +1,21 @@
+MACRO(SUBDIRLIST result curdir)
+  FILE(GLOB children RELATIVE ${curdir} ${curdir}/*)
+  SET(dirlist "")
+
+  FOREACH(child ${children})
+    IF(IS_DIRECTORY ${curdir}/${child} AND NOT child STREQUAL "template")
+      LIST(APPEND dirlist ${child})
+    ENDIF()
+  ENDFOREACH()
+
+  SET(${result} ${dirlist})
+ENDMACRO()
+
+SUBDIRLIST(SUBDIRS ${CMAKE_CURRENT_SOURCE_DIR})
+
+FOREACH(subdir ${SUBDIRS})
+  ADD_SUBDIRECTORY(${subdir})
+ENDFOREACH()
+
+install(TARGETS ${SUBDIRS}
+  LIBRARY DESTINATION modules)
--- a/modules/libSceAjm/CMakeLists.txt
+++ b/modules/libSceAjm/CMakeLists.txt
@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceAjm)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp)
+
+setupModule(${libName})
--- a/modules/libSceAjm/codes.h
+++ b/modules/libSceAjm/codes.h
@ -0,0 +1,4 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {} // namespace Err
--- a/modules/libSceAjm/entry.cpp
+++ b/modules/libSceAjm/entry.cpp
@ -0,0 +1,47 @@
+#include "common.h"
+#include "types.h"
+
+#include <logging.h>
+
+LOG_DEFINE_MODULE(libSceAjm);
+
+namespace {} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceAjm";
+
+EXPORT SYSV_ABI int32_t sceAjmInitialize(int64_t iReserved, SceAjmContextId* const pContext) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAjmFinalize(const SceAjmContextId uiContext) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAjmMemoryRegister(const SceAjmContextId uiContext, void* const pRegion, const size_t szNumPages) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAjmMemoryUnregister(const SceAjmContextId uiContext, void* const pRegion) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAjmModuleRegister(const SceAjmContextId uiContext, const SceAjmCodecType uiCodec, int64_t iReserved) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAjmModuleUnregister(const SceAjmContextId uiContext, const SceAjmCodecType uiCodec) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAjmInstanceCreate(const SceAjmContextId uiContext, const SceAjmCodecType uiCodec, const uint64_t uiFlags,
+                                             SceAjmInstanceId* const pInstance) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAjmInstanceExtend(const SceAjmContextId uiContext, const SceAjmCodecType uiCodec, const uint64_t uiFlags,
+                                             SceAjmInstanceId uiInstance) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAjmInstanceSwitch(const SceAjmContextId uiContext, const SceAjmCodecType uiCodec, const uint64_t uiFlags,
+                                             const SceAjmInstanceId uiInstance) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAjmInstanceDestroy(const SceAjmContextId uiContext, const SceAjmInstanceId uiInstance) {
+  return Ok;
+}
+}
--- a/modules/libSceAjm/types.h
+++ b/modules/libSceAjm/types.h
@ -0,0 +1,7 @@
+#pragma once
+#include "codes.h"
+
+typedef unsigned int SceAjmContextId;
+typedef unsigned int SceAjmCodecType;
+typedef unsigned int SceAjmInstanceId;
+typedef unsigned int SceAjmBatchId;
--- a/modules/libSceAppContent/CMakeLists.txt
+++ b/modules/libSceAppContent/CMakeLists.txt
@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceAppContent)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp)
+
+target_include_directories(${libName} PRIVATE
+  ${CMAKE_SOURCE_DIR}/runtime/system
+)
+
+target_link_libraries(${libName} PRIVATE emulator.lib)
+
+setupModule(${libName})
--- a/modules/libSceAppContent/codes.h
+++ b/modules/libSceAppContent/codes.h
@ -0,0 +1,30 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {
+constexpr int32_t NOT_INITIALIZED       = -2133262335; /* 0x80D90001 */
+constexpr int32_t PARAMETER             = -2133262334; /* 0x80D90002 */
+constexpr int32_t BUSY                  = -2133262333; /* 0x80D90003 */
+constexpr int32_t NOT_MOUNTED           = -2133262332; /* 0x80D90004 */
+constexpr int32_t NOT_FOUND             = -2133262331; /* 0x80D90005 */
+constexpr int32_t MOUNT_FULL            = -2133262330; /* 0x80D90006 */
+constexpr int32_t DRM_NO_ENTITLEMENT    = -2133262329; /* 0x80D90007 */
+constexpr int32_t NO_SPACE              = -2133262328; /* 0x80D90008 */
+constexpr int32_t NOT_SUPPORTED         = -2133262327; /* 0x80D90009 */
+constexpr int32_t INTERNAL              = -2133262326; /* 0x80D9000A */
+constexpr int32_t DOWNLOAD_ENTRY_FULL   = -2133262325; /* 0x80D9000B */
+constexpr int32_t INVALID_PKG           = -2133262324; /* 0x80D9000C */
+constexpr int32_t OTHER_APPLICATION_PKG = -2133262323; /* 0x80D9000D */
+constexpr int32_t CREATE_FULL           = -2133262322; /* 0x80D9000E */
+constexpr int32_t MOUNT_OTHER_APP       = -2133262321; /* 0x80D9000F */
+constexpr int32_t OF_MEMORY             = -2133262320; /* 0x80D90010 */
+constexpr int32_t ADDCONT_SHRANK        = -2133262319; /* 0x80D90011 */
+constexpr int32_t ADDCONT_NO_IN_QUEUE   = -2133262318; /* 0x80D90012 */
+constexpr int32_t NETWORK               = -2133262317; /* 0x80D90013 */
+constexpr int32_t SIGNED_OUT            = -2133262316; /* 0x80D90014 */
+} // namespace Err
+
+constexpr uint32_t MOUNTPOINT_DATA_MAXSIZE = 16;
+constexpr uint32_t ADDCONT_MOUNT_MAXNUM    = 64;
+constexpr uint32_t ENTITLEMENT_KEY_SIZE    = 16;
+constexpr uint32_t INFO_LIST_MAX_SIZE      = 2500;
--- a/modules/libSceAppContent/entry.cpp
+++ b/modules/libSceAppContent/entry.cpp
@ -0,0 +1,123 @@
+#include "common.h"
+#include "../libSceNpManager/types.h"
+
+#include <fileManager.h>
+#include <systemContent.h>
+
+
+#include <logging.h>
+#include "types.h"
+
+#include <filesystem>
+#include <optional>
+
+LOG_DEFINE_MODULE(libSceAppContent);
+
+namespace {} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceAppContentUtil";
+
+EXPORT SYSV_ABI int32_t sceAppContentInitialize(SceAppContentInitParam* initParam, SceAppContentBootParam* bootParam) {
+  bootParam->attr = 0;
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAppContentAppParamGetInt(SceAppContentAppParamId paramId, int32_t* value) {
+  LOG_USE_MODULE(libSceAppContent);
+
+  *value = 0;
+  std::optional<uint32_t> retValue;
+
+  switch (paramId) {
+    case 0: retValue = 3; break;
+    case 1: retValue = accessSystemContent().getInt("USER_DEFINED_PARAM_1"); break;
+    case 2: retValue = accessSystemContent().getInt("USER_DEFINED_PARAM_2"); break;
+    case 3: retValue = accessSystemContent().getInt("USER_DEFINED_PARAM_3"); break;
+    case 4: retValue = accessSystemContent().getInt("USER_DEFINED_PARAM_4"); break;
+    default: LOG_CRIT(L"unknown param_id:%u", paramId);
+  }
+
+  if (retValue) *value = (int32_t)retValue.value();
+  LOG_TRACE(L"paramId:%u value:%d [%S]", paramId, *value, retValue.has_value() ? "found" : "not found");
+
+  return retValue.has_value() ? Ok : Err::PARAMETER;
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAppContentGetAddcontInfoList(SceNpServiceLabel serviceLabel, SceAppContentAddcontInfo* list, uint32_t listNum, uint32_t* hitNum) {
+  LOG_USE_MODULE(libSceAppContent);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  *hitNum = 0;
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAppContentGetAddcontInfo(SceNpServiceLabel serviceLabel, const SceNpUnifiedEntitlementLabel* entitlementLabel,
+                                                    SceAppContentAddcontInfo* info) {
+  LOG_USE_MODULE(libSceAppContent);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAppContentAddcontMount(SceNpServiceLabel serviceLabel, const SceNpUnifiedEntitlementLabel* entitlementLabel,
+                                                  SceAppContentMountPoint* mountPoint) {
+  LOG_USE_MODULE(libSceAppContent);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAppContentAddcontUnmount(const SceAppContentMountPoint* mountPoint) {
+  LOG_USE_MODULE(libSceAppContent);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAppContentAddcontEnqueueDownload(SceNpServiceLabel serviceLabel, const SceNpUnifiedEntitlementLabel* entitlementLabel) {
+  LOG_USE_MODULE(libSceAppContent);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAppContentGetEntitlementKey(SceNpServiceLabel serviceLabel, const SceNpUnifiedEntitlementLabel* entitlementLabel,
+                                                       SceAppContentEntitlementKey* key) {
+  LOG_USE_MODULE(libSceAppContent);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAppContentTemporaryDataMount2(SceAppContentTemporaryDataOption option, SceAppContentMountPoint* mountPoint) {
+  auto tempFolder = accessFileManager().getMountPoint(MountType::Temp, MOUNT_POINT_TEMP.data());
+  if ((option & 1) > 0) {
+    std::filesystem::remove_all(tempFolder);
+  }
+
+  auto const count        = MOUNT_POINT_TEMP.copy(mountPoint->data, MOUNTPOINT_DATA_MAXSIZE - 1);
+  mountPoint->data[count] = '\0';
+
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAppContentTemporaryDataUnmount(const SceAppContentMountPoint* mountPoint) {
+  LOG_USE_MODULE(libSceAppContent);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAppContentTemporaryDataFormat(const SceAppContentMountPoint* mountPoint) {
+  LOG_USE_MODULE(libSceAppContent);
+  auto tempFolder = accessFileManager().getMappedPath(mountPoint->data);
+  if (tempFolder) {
+    std::filesystem::remove_all(*tempFolder);
+  } else {
+    LOG_ERR(L"unknown temp folder: %s", tempFolder->c_str());
+  }
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAppContentDownloadDataFormat(const SceAppContentMountPoint* mountPoint) {
+  LOG_USE_MODULE(libSceAppContent);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAppContentAddcontDelete(SceNpServiceLabel serviceLabel, const SceNpUnifiedEntitlementLabel* entitlementLabel) {
+  LOG_USE_MODULE(libSceAppContent);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAppContentGetAddcontDownloadProgress(SceNpServiceLabel serviceLabel, const SceNpUnifiedEntitlementLabel* entitlementLabel,
+                                                                SceAppContentAddcontDownloadProgress* progress) {
+  LOG_USE_MODULE(libSceAppContent);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+}
--- a/modules/libSceAppContent/types.h
+++ b/modules/libSceAppContent/types.h
@ -0,0 +1,46 @@
+#pragma once
+#include "../libSceNpManager/types.h"
+#include "codes.h"
+
+
+typedef uint32_t SceAppContentMediaType;
+typedef uint32_t SceAppContentBootAttribute;
+typedef uint32_t SceAppContentAppParamId;
+typedef uint32_t SceAppContentAddcontDownloadStatus;
+typedef uint32_t SceAppContentTemporaryDataOption;
+
+enum class AppParamId : uint32_t { SKU_FLAG = 0, USER_DEFINED_PARAM_1 = 1, USER_DEFINED_PARAM_2 = 2, USER_DEFINED_PARAM_3 = 3, USER_DEFINED_PARAM_4 = 4 };
+
+enum class SkuFlag : uint32_t { TRIAL = 1, FULL = 3 };
+
+enum class AddContDownloadStatus : uint32_t { NO_EXTRA_DATA = 0, NO_IN_QUEUE = 1, DOWNLOADING = 2, DOWNLOAD_SUSPENDED = 3, INSTALLED = 4 };
+
+enum class TemporaryDataOption : uint32_t { NONE = 0, FORMAT = (1 << 0) };
+
+struct SceAppContentInitParam {
+  char reserved[32];
+};
+
+struct SceAppContentBootParam {
+  char                       reserved1[4];
+  SceAppContentBootAttribute attr;
+  char                       reserved2[32];
+};
+
+struct SceAppContentAddcontInfo {
+  SceNpUnifiedEntitlementLabel       entitlementLabel;
+  SceAppContentAddcontDownloadStatus status;
+};
+
+struct SceAppContentMountPoint {
+  char data[MOUNTPOINT_DATA_MAXSIZE];
+};
+
+struct SceAppContentEntitlementKey {
+  char data[ENTITLEMENT_KEY_SIZE];
+};
+
+struct SceAppContentAddcontDownloadProgress {
+  uint64_t dataSize;
+  uint64_t downloadedSize;
+};
--- a/modules/libSceAudioIn/CMakeLists.txt
+++ b/modules/libSceAudioIn/CMakeLists.txt
@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceAudioIn)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp)
+
+target_link_directories(${libName} PRIVATE
+  ${CMAKE_BINARY_DIR}/third_party/install/lib
+)
+
+setupModule(${libName})
--- a/modules/libSceAudioIn/codes.h
+++ b/modules/libSceAudioIn/codes.h
@ -0,0 +1,24 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {
+constexpr int32_t FATAL           = -2144993024;
+constexpr int32_t INVALID_HANDLE  = -2144993023;
+constexpr int32_t INVALID_SIZE    = -2144993022;
+constexpr int32_t INVALID_FREQ    = -2144993021;
+constexpr int32_t INVALID_TYPE    = -2144993020;
+constexpr int32_t INVALID_POINTER = -2144993019;
+constexpr int32_t INVALID_PARAM   = -2144993018;
+constexpr int32_t PORT_FULL       = -2144993017;
+constexpr int32_t OUT_OF_MEMORY   = -2144993016;
+constexpr int32_t NOT_OPENED      = -2144993015;
+constexpr int32_t BUSY            = -2144993014;
+constexpr int32_t SYSTEM_MEMORY   = -2144993013;
+constexpr int32_t SYSTEM_IPC      = -2144993012;
+} // namespace Err
+
+constexpr uint32_t SCE_AUDIO_IN_FREQ_DEFAULT   = 16000;
+constexpr uint32_t SCE_AUDIO_IN_GRAIN_DEFAULT  = 256;
+constexpr uint32_t SCE_AUDIO_IN_FREQ_HQ        = 48000;
+constexpr uint32_t SCE_AUDIO_IN_TIME_SAMPLE_HQ = 128;
+constexpr uint32_t SCE_AUDIO_IN_GRAIN_MAX_HQ   = (SCE_AUDIO_IN_TIME_SAMPLE_HQ * 3);
--- a/modules/libSceAudioIn/entry.cpp
+++ b/modules/libSceAudioIn/entry.cpp
@ -0,0 +1,29 @@
+#include "common.h"
+#include "types.h"
+
+#include <logging.h>
+
+LOG_DEFINE_MODULE(libSceAudioIn);
+
+namespace {} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceAudioIn";
+
+EXPORT SYSV_ABI int32_t sceAudioInOpen(int32_t userId, int32_t type, int32_t index, uint32_t len, uint32_t freq, uint32_t param) {
+  return Err::PORT_FULL;
+}
+EXPORT SYSV_ABI int32_t sceAudioInClose(int32_t handle) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAudioInInput(int32_t handle, void* dest) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAudioInGetSilentState(int32_t handle) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAudioInHqOpen(int32_t userId, int32_t type, int32_t index, uint32_t timeLen, uint32_t freq, uint32_t param) {
+  return Ok;
+}
+}
--- a/modules/libSceAudioIn/types.h
+++ b/modules/libSceAudioIn/types.h
@ -0,0 +1,12 @@
+#pragma once
+#include "codes.h"
+
+enum class SceAudioInParamFormat : unsigned int {
+  S16_MONO   = 0, // monaural
+  S16_STEREO = 2  // stereo
+
+};
+
+enum class SceAudioInSilentState { DEVICE_NONE = 0x00000001, PRIORITY_LOW = 0x00000002, USER_SETTING = 0x00000004, UNABLE_FORMAT = 0x00000008 };
+
+enum class SceAudioInType { VOICE_CHAT = 0, GENERAL = 1, VOICE_RECOGNITION = 5 };
--- a/modules/libSceAudioOut/CMakeLists.txt
+++ b/modules/libSceAudioOut/CMakeLists.txt
@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceAudioOut)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp)
+target_include_directories(${libName} PRIVATE
+  ${CMAKE_SOURCE_DIR}/third_party/portAudio/include
+)
+
+add_dependencies(${libName} portaudio)
+target_link_libraries(${libName} PRIVATE
+  ${CMAKE_BINARY_DIR}/third_party/portAudio/portaudio_static_x64.lib
+)
+
+setupModule(${libName})
--- a/modules/libSceAudioOut/codes.h
+++ b/modules/libSceAudioOut/codes.h
@ -0,0 +1,102 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {
+
+constexpr int32_t NOT_OPENED          = -2144993279;
+constexpr int32_t BUSY                = -2144993278;
+constexpr int32_t INVALID_PORT        = -2144993277;
+constexpr int32_t INVALID_POINTER     = -2144993276;
+constexpr int32_t PORT_FULL           = -2144993275;
+constexpr int32_t INVALID_SIZE        = -2144993274;
+constexpr int32_t INVALID_FORMAT      = -2144993273;
+constexpr int32_t INVALID_SAMPLE_FREQ = -2144993272;
+constexpr int32_t INVALID_VOLUME      = -2144993271;
+constexpr int32_t INVALID_PORT_TYPE   = -2144993270;
+constexpr int32_t INVALID_CONF_TYPE   = -2144993268;
+constexpr int32_t OUT_OF_MEMORY       = -2144993267;
+constexpr int32_t ALREADY_INIT        = -2144993266;
+constexpr int32_t NOT_INIT            = -2144993265;
+constexpr int32_t MEMORY              = -2144993264;
+constexpr int32_t SYSTEM_RESOURCE     = -2144993263;
+constexpr int32_t TRANS_EVENT         = -2144993262;
+constexpr int32_t INVALID_FLAG        = -2144993261;
+constexpr int32_t INVALID_MIXLEVEL    = -2144993260;
+constexpr int32_t INVALID_ARG         = -2144993259;
+constexpr int32_t INVALID_PARAM       = -2144993258;
+} // namespace Err
+
+constexpr int        PORT_OUT_MAX = 6;
+static constexpr int PORT_IN_MAX  = 8;
+
+#define SCE_AUDIO_MIN_LEN                256u
+#define SCE_AUDIO_MAX_LEN                (256u * 8)
+#define SCE_AUDIO_OUT_PARAM_FORMAT_MASK  (0x000000FF)
+#define SCE_AUDIO_OUT_PARAM_FORMAT_SHIFT (0)
+
+// sceAudioOutOpen()の引数 paramのattributeの値とマスク値
+#define SCE_AUDIO_OUT_PARAM_ATTR_RESTRICTED  (0x00010000)
+#define SCE_AUDIO_OUT_PARAM_ATTR_MIX_TO_MAIN (0x00020000)
+
+#define SCE_AUDIO_OUT_PARAM_ATTR_MASK  (0x000F0000)
+#define SCE_AUDIO_OUT_PARAM_ATTR_SHIFT (16)
+
+#define SCE_AUDIO_VOLUME_SHIFT     15
+#define SCE_AUDIO_OUT_VOLUME_SHIFT SCE_AUDIO_VOLUME_SHIFT
+#define SCE_AUDIO_VOLUME_0DB       (1 << SCE_AUDIO_VOLUME_SHIFT)
+#define SCE_AUDIO_VOLUME_0dB       SCE_AUDIO_VOLUME_0DB
+#define SCE_AUDIO_OUT_VOLUME_0DB   SCE_AUDIO_VOLUME_0DB
+#define SCE_AUDIO_OUT_VOLUME_0dB   SCE_AUDIO_VOLUME_0dB
+
+/*J 引数 'flag' に設定する値 */
+/*E Value set for the argument 'flag' */
+#define SCE_AUDIO_VOLUME_FLAG_L_CH      (1 << 0)
+#define SCE_AUDIO_VOLUME_FLAG_FL_CH     SCE_AUDIO_VOLUME_FLAG_L_CH
+#define SCE_AUDIO_OUT_VOLUME_FLAG_L_CH  SCE_AUDIO_VOLUME_FLAG_L_CH
+#define SCE_AUDIO_OUT_VOLUME_FLAG_FL_CH SCE_AUDIO_VOLUME_FLAG_L_CH
+
+#define SCE_AUDIO_VOLUME_FLAG_R_CH      (1 << 1)
+#define SCE_AUDIO_VOLUME_FLAG_FR_CH     SCE_AUDIO_VOLUME_FLAG_R_CH
+#define SCE_AUDIO_OUT_VOLUME_FLAG_R_CH  SCE_AUDIO_VOLUME_FLAG_R_CH
+#define SCE_AUDIO_OUT_VOLUME_FLAG_FR_CH SCE_AUDIO_VOLUME_FLAG_R_CH
+
+#define SCE_AUDIO_VOLUME_FLAG_C_CH       (1 << 2)
+#define SCE_AUDIO_VOLUME_FLAG_FC_CH      SCE_AUDIO_VOLUME_FLAG_C_CH
+#define SCE_AUDIO_VOLUME_FLAG_CNT_CH     SCE_AUDIO_VOLUME_FLAG_C_CH
+#define SCE_AUDIO_OUT_VOLUME_FLAG_C_CH   SCE_AUDIO_VOLUME_FLAG_C_CH
+#define SCE_AUDIO_OUT_VOLUME_FLAG_FC_CH  SCE_AUDIO_VOLUME_FLAG_C_CH
+#define SCE_AUDIO_OUT_VOLUME_FLAG_CNT_CH SCE_AUDIO_VOLUME_FLAG_C_CH
+
+#define SCE_AUDIO_VOLUME_FLAG_LFE_CH     (1 << 3)
+#define SCE_AUDIO_OUT_VOLUME_FLAG_LFE_CH SCE_AUDIO_VOLUME_FLAG_LFE_CH
+
+#define SCE_AUDIO_VOLUME_FLAG_LS_CH     (1 << 4)
+#define SCE_AUDIO_VOLUME_FLAG_RL_CH     SCE_AUDIO_VOLUME_FLAG_LS_CH
+#define SCE_AUDIO_OUT_VOLUME_FLAG_LS_CH SCE_AUDIO_VOLUME_FLAG_LS_CH
+#define SCE_AUDIO_OUT_VOLUME_FLAG_RL_CH SCE_AUDIO_VOLUME_FLAG_LS_CH
+
+#define SCE_AUDIO_VOLUME_FLAG_RS_CH     (1 << 5)
+#define SCE_AUDIO_VOLUME_FLAG_RR_CH     SCE_AUDIO_VOLUME_FLAG_RS_CH
+#define SCE_AUDIO_OUT_VOLUME_FLAG_RS_CH SCE_AUDIO_VOLUME_FLAG_RS_CH
+#define SCE_AUDIO_OUT_VOLUME_FLAG_RR_CH SCE_AUDIO_VOLUME_FLAG_RS_CH
+
+#define SCE_AUDIO_VOLUME_FLAG_LE_CH     (1 << 6)
+#define SCE_AUDIO_VOLUME_FLAG_BL_CH     SCE_AUDIO_VOLUME_FLAG_LE_CH
+#define SCE_AUDIO_OUT_VOLUME_FLAG_LE_CH SCE_AUDIO_VOLUME_FLAG_LE_CH
+#define SCE_AUDIO_OUT_VOLUME_FLAG_BL_CH SCE_AUDIO_VOLUME_FLAG_LE_CH
+
+#define SCE_AUDIO_VOLUME_FLAG_RE_CH     (1 << 7)
+#define SCE_AUDIO_VOLUME_FLAG_BR_CH     SCE_AUDIO_VOLUME_FLAG_RE_CH
+#define SCE_AUDIO_OUT_VOLUME_FLAG_RE_CH SCE_AUDIO_VOLUME_FLAG_RE_CH
+#define SCE_AUDIO_OUT_VOLUME_FLAG_BR_CH SCE_AUDIO_VOLUME_FLAG_RE_CH
+
+#define SCE_AUDIO_MIXLEVEL_PADSPK_SHIFT     15
+#define SCE_AUDIO_OUT_MIXLEVEL_PADSPK_SHIFT SCE_AUDIO_MIXLEVEL_PADSPK_SHIFT
+#define SCE_AUDIO_MIXLEVEL_PADSPK_0DB       (1 << SCE_AUDIO_MIXLEVEL_PADSPK_SHIFT)
+#define SCE_AUDIO_MIXLEVEL_PADSPK_0dB       SCE_AUDIO_MIXLEVEL_PADSPK_0DB
+#define SCE_AUDIO_OUT_MIXLEVEL_PADSPK_0DB   SCE_AUDIO_MIXLEVEL_PADSPK_0DB
+#define SCE_AUDIO_OUT_MIXLEVEL_PADSPK_0dB   SCE_AUDIO_MIXLEVEL_PADSPK_0dB
+
+/*J 引数 'mixLevel' に設定する値の初期値 -9dB */
+/*E Defult value set for the argument 'mixLevel' -9dB */
+#define SCE_AUDIO_OUT_MIXLEVEL_PADSPK_DEFAULT (11626)
--- a/modules/libSceAudioOut/entry.cpp
+++ b/modules/libSceAudioOut/entry.cpp
@ -0,0 +1,222 @@
+#include "common.h"
+#include <logging.h>
+#include "portaudio.h"
+#include "types.h"
+
+#include <array>
+#include <chrono>
+#include <mutex>
+
+LOG_DEFINE_MODULE(libSceAudioOut);
+
+namespace {
+struct PortOut {
+  bool                   open           = false;
+  int                    userId         = 0;
+  SceAudioOutPortType    type           = SceAudioOutPortType::MAIN;
+  uint32_t               samplesNum     = 0;
+  uint32_t               freq           = 0;
+  SceAudioOutParamFormat format         = SceAudioOutParamFormat::FLOAT_MONO;
+  uint64_t               lastOutputTime = 0;
+  int                    channelsNum    = 0;
+  int                    volume[8]      = {};
+  PaStream*              stream         = nullptr;
+};
+
+struct Pimpl {
+  std::mutex                        mutexInt;
+  std::array<PortOut, PORT_OUT_MAX> portsOut;
+  Pimpl() = default;
+};
+
+Pimpl* getData() {
+  static Pimpl obj;
+  return &obj;
+}
+
+PaError writeOut(Pimpl* pimpl, int32_t handle, const void* ptr) {
+  auto& port = pimpl->portsOut[handle - 1];
+  if (!port.open) return 0;
+
+  port.lastOutputTime = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+  if (Pa_IsStreamActive(port.stream) != 1) Pa_StartStream(port.stream);
+  return Pa_WriteStream(port.stream, ptr, port.samplesNum);
+}
+} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceAudioOut";
+
+EXPORT SYSV_ABI int32_t sceAudioOutInit(void) {
+  (void)getData();
+  Pa_Initialize();
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAudioOutOpen(int32_t userId, SceAudioOutPortType type, int32_t index, uint32_t len, uint32_t freq, SceAudioOutParamFormat format) {
+  LOG_USE_MODULE(libSceAudioOut);
+  LOG_TRACE(L"%S", __FUNCTION__);
+  auto pimpl = getData();
+
+  std::unique_lock const lock(pimpl->mutexInt);
+
+  for (int id = 0; id < pimpl->portsOut.size(); id++) {
+    auto& port = pimpl->portsOut[id];
+    if (port.open) continue;
+
+    port.userId         = userId;
+    port.open           = true;
+    port.type           = type;
+    port.samplesNum     = len;
+    port.freq           = freq;
+    port.format         = format;
+    port.lastOutputTime = 0;
+
+    PaSampleFormat sampleFormat;
+    switch (format) {
+      case SceAudioOutParamFormat::S16_MONO:
+        sampleFormat     = paInt16;
+        port.channelsNum = 1;
+        break;
+      case SceAudioOutParamFormat::FLOAT_MONO:
+        sampleFormat     = paFloat32;
+        port.channelsNum = 1;
+        break;
+      case SceAudioOutParamFormat::S16_STEREO:
+        sampleFormat     = paInt16;
+        port.channelsNum = 2;
+        break;
+      case SceAudioOutParamFormat::FLOAT_STEREO:
+        sampleFormat     = paFloat32;
+        port.channelsNum = 2;
+        break;
+      case SceAudioOutParamFormat::S16_8CH:
+        sampleFormat     = paInt16;
+        port.channelsNum = 8;
+        break;
+      case SceAudioOutParamFormat::FLOAT_8CH:
+        sampleFormat     = paFloat32;
+        port.channelsNum = 8;
+        break;
+      case SceAudioOutParamFormat::S16_8CH_STD:
+        sampleFormat     = paInt16;
+        port.channelsNum = 8;
+        break;
+      case SceAudioOutParamFormat::FLOAT_8CH_STD:
+        sampleFormat     = paFloat32;
+        port.channelsNum = 8;
+        break;
+    }
+
+    for (int i = 0; i < port.channelsNum; i++) {
+      port.volume[i] = 32768;
+    }
+
+    PaStreamParameters const outParams {
+        .device                    = Pa_GetDefaultOutputDevice(), /* default output device */
+        .channelCount              = port.channelsNum,
+        .sampleFormat              = sampleFormat,
+        .suggestedLatency          = Pa_GetDeviceInfo(outParams.device)->defaultLowOutputLatency,
+        .hostApiSpecificStreamInfo = NULL,
+    };
+
+    if (auto err = Pa_OpenStream(&port.stream, NULL, &outParams, freq, port.samplesNum, paNoFlag, NULL, NULL); err != Ok) {
+      return err;
+    }
+
+    return id + 1;
+  }
+  return Err::PORT_FULL;
+}
+EXPORT SYSV_ABI int32_t sceAudioOutClose(int32_t handle) {
+  LOG_USE_MODULE(libSceAudioOut);
+  LOG_TRACE(L"%S", __FUNCTION__);
+  auto pimpl = getData();
+
+  std::unique_lock const lock(pimpl->mutexInt);
+
+  auto& port = pimpl->portsOut[handle - 1];
+  if (port.open) {
+    port.open = false;
+    if (Pa_IsStreamActive(port.stream) == 1) {
+      Pa_CloseStream(port.stream);
+    }
+  }
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAudioOutOutput(int32_t handle, const void* ptr) {
+  auto pimpl = getData();
+
+  // std::unique_lock const lock(pimpl->mutexInt);
+  return writeOut(pimpl, handle, ptr);
+}
+EXPORT SYSV_ABI int32_t sceAudioOutSetVolume(int32_t handle, int32_t flag, int32_t* vol) {
+  LOG_USE_MODULE(libSceAudioOut);
+  auto pimpl = getData();
+
+  std::unique_lock const lock(pimpl->mutexInt);
+
+  auto& port = pimpl->portsOut[handle - 1];
+  if (!port.open) return Err::INVALID_PORT;
+
+  for (int i = 0; i < port.channelsNum; i++, flag >>= 1u) {
+    bool const bit = flag & 0x1u;
+    if (!bit) continue;
+
+    int srcIndex = i;
+    if (port.format == SceAudioOutParamFormat::FLOAT_8CH_STD || port.format == SceAudioOutParamFormat::S16_8CH_STD) {
+      switch (i) {
+        case 4: srcIndex = 6; break;
+        case 5: srcIndex = 7; break;
+        case 6: srcIndex = 4; break;
+        case 7: srcIndex = 5; break;
+        default:;
+      }
+    }
+    port.volume[i] = vol[srcIndex];
+    LOG_DEBUG(L"port.volume[%d] volume[%d] (%d)", i, srcIndex, vol[srcIndex]);
+  }
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAudioOutOutputs(SceAudioOutOutputParam* param, uint32_t num) {
+  auto pimpl = getData();
+
+  // std::unique_lock const lock(pimpl->mutexInt); // dont block, causes audio artifacts
+  for (uint32_t i = 0; i < num; i++) {
+    if (auto err = writeOut(pimpl, param[i].handle, param[i].ptr); err != paNoError) return err;
+  }
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAudioOutGetLastOutputTime(int32_t handle, uint64_t* outputTime) {
+  auto pimpl = getData();
+
+  std::unique_lock const lock(pimpl->mutexInt);
+
+  auto& port = pimpl->portsOut[handle - 1];
+  if (!port.open) return Err::INVALID_PORT;
+  *outputTime = port.lastOutputTime;
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAudioOutSetMixLevelPadSpk(int32_t handle, int32_t mixLevel) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAudioOutGetPortState(int32_t handle, SceAudioOutPortState* state) {
+  auto pimpl = getData();
+
+  std::unique_lock const lock(pimpl->mutexInt);
+
+  auto& port = pimpl->portsOut[handle - 1];
+
+  state->channel = port.channelsNum;
+  state->volume  = 127;
+  state->output  = (uint16_t)SceAudioOutStateOutput::CONNECTED_PRIMARY;
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAudioOutGetSystemState(SceAudioOutSystemState* state) {
+  state->loudness = -70.0f;
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAudioOutSetSystemDebugState(SceAudioOutSystemDebugStateElement elem, SceAudioOutSystemDebugStateParam* param) {
+  return Ok;
+}
+}
--- a/modules/libSceAudioOut/types.h
+++ b/modules/libSceAudioOut/types.h
@ -0,0 +1,79 @@
+#pragma once
+#include "codes.h"
+
+enum class SceAudioOutChannel { L = 0, R, C, LFE, LS, RS, LE, RE, MAX };
+
+enum class SceAudioOutChannelOrderStd { L = 0, R, C, LFE, LE, RE, LS, RS, MAX };
+
+struct SceAudioOutOutputParam {
+  int32_t     handle;
+  const void* ptr;
+};
+
+enum class SceAudioOutPortType {
+  MAIN     = 0,  // Main Audio
+  BGM      = 1,  // Background Music
+  VOICE    = 2,  // Voice
+  PERSONAL = 3,  // Personal Audio
+  PADSPK   = 4,  // Pad Speaker
+  AUX      = 127 // Auxiliary Audio
+
+};
+
+enum class SceAudioOutParamFormat : unsigned int {
+  S16_MONO      = 0,
+  S16_STEREO    = 1,
+  S16_8CH       = 2,
+  FLOAT_MONO    = 3,
+  FLOAT_STEREO  = 4,
+  FLOAT_8CH     = 5,
+  S16_8CH_STD   = 6,
+  FLOAT_8CH_STD = 7
+
+};
+
+enum class SceAudioOutStateOutput {
+  UNKNOWN             = 0,
+  CONNECTED_PRIMARY   = (1 << 0),
+  CONNECTED_SECONDARY = (1 << 1),
+  CONNECTED_TERTIARY  = (1 << 2),
+  CONNECTED_HEADPHONE = (1 << 6),
+  CONNECTED_EXTERNAL  = (1 << 7),
+};
+
+enum class SceAudioOutStateChannel {
+  CHANNEL_UNKNOWN      = 0,
+  CHANNEL_DISCONNECTED = 0,
+  CHANNEL_1            = 1,
+  CHANNEL_2            = 2,
+  CHANNEL_6            = 6,
+  CHANNEL_8            = 8,
+};
+
+enum class SceAudioOutStateFlag {
+  NONE = 0,
+};
+
+struct SceAudioOutPortState {
+  uint16_t output;         // SceAudioOutStateOutput (bitwise OR)
+  uint8_t  channel;        // SceAudioOutStateChannel
+  uint8_t  reserved8_1[1]; // reserved
+  int16_t  volume;
+  uint16_t rerouteCounter;
+  uint64_t flag; // SceAudioOutStateFlag (bitwise OR)
+};
+
+struct SceAudioOutSystemState {
+  float    loudness;
+  uint8_t  reserved8[4];
+  uint64_t reserved64[3];
+};
+
+enum class SceAudioOutSystemDebugStateElement { NULL_ = 0, LOUDNESS, MAX };
+
+enum SceAudioOutSystemDebugStateLoudness { LOUDNESS_STOP = 0, LOUDNESS_START, LOUDNESS_START_QUIET, LOUDNESS_MAX };
+
+typedef struct SceAudioOutSystemDebugStateParam {
+  uint32_t value;
+  uint32_t reserved[3]; // reserved
+} SceAudioOutSystemDebugStateParam;
--- a/modules/libSceAvPlayer/CMakeLists.txt
+++ b/modules/libSceAvPlayer/CMakeLists.txt
@ -0,0 +1,32 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceAvPlayer)
+project(${libName})
+set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+set(CMAKE_WINDOWS_SYMBOL_VISIBILITY_IN_STATIC_LIBRARIES OFF)
+
+add_library(${libName} SHARED
+  entry.cpp entryEx.cpp avplayer.cpp
+)
+
+target_link_directories(${libName} PRIVATE
+  ${CMAKE_SOURCE_DIR}/third_party/ffmpeg/lib
+)
+
+target_include_directories(${libName} PRIVATE
+  ${CMAKE_SOURCE_DIR}/third_party/ffmpeg/include
+  ${Vulkan_INCLUDE_DIRS}
+)
+
+set(FFMPEG_LIBS
+  avformat
+  avcodec
+  avutil
+  swscale
+  swresample
+)
+
+target_link_libraries(${libName} PUBLIC emulator.lib ${FFMPEG_LIBS})
+
+setupModule(${libName})
--- a/modules/libSceAvPlayer/avplayer.cpp
+++ b/modules/libSceAvPlayer/avplayer.cpp
@ -0,0 +1,550 @@
+#include "avplayer.h"
+
+#include "typesEx.h"
+
+#include <fileManager.h>
+#include <gpuMemoryManagerExports.h>
+#include <logging.h>
+
+extern "C" {
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavutil/imgutils.h>
+#include <libavutil/samplefmt.h>
+#include <libavutil/time.h>
+#include <libavutil/timestamp.h>
+#include <libswresample/swresample.h>
+#include <libswscale/swscale.h>
+}
+
+#include <queue>
+
+#include <condition_variable>
+#include <mutex>
+
+LOG_DEFINE_MODULE(AvPlayer);
+
+namespace {
+
+bool openCodecContext(int* stream_idx, AVFormatContext* fmt_ctx, enum AVMediaType type, AVCodecContext** outCodecContext) {
+  LOG_USE_MODULE(AvPlayer);
+
+  AVCodec const* codec;
+  *stream_idx = av_find_best_stream(fmt_ctx, type, -1, -1, &codec, 0);
+  if (*stream_idx < 0) {
+    LOG_ERR(L"openCodecContext: no %S stream", av_get_media_type_string(type));
+    return false;
+  }
+  LOG_DEBUG(L"using codec: %S [%S]", codec->name, codec->long_name);
+
+  AVCodecParameters* codecParams = fmt_ctx->streams[*stream_idx]->codecpar;
+
+  *outCodecContext = avcodec_alloc_context3(codec);
+  if (avcodec_parameters_to_context(*outCodecContext, codecParams) != 0) {
+    LOG_ERR(L"avcodec_parameters_to_context %S", av_get_media_type_string(type));
+    return false;
+  }
+
+  // Setup multithreading
+  if (codec->capabilities | AV_CODEC_CAP_FRAME_THREADS)
+    (*outCodecContext)->thread_type = FF_THREAD_FRAME;
+  else if (codec->capabilities | AV_CODEC_CAP_SLICE_THREADS)
+    (*outCodecContext)->thread_type = FF_THREAD_SLICE;
+  else
+    (*outCodecContext)->thread_count = 1; // don't use multithreading
+  // -
+
+  if (avcodec_open2(*outCodecContext, codec, NULL) < 0) {
+    LOG_ERR(L"avcodec_open2: %S codec", av_get_media_type_string(type));
+    avcodec_free_context(outCodecContext);
+    return false;
+  }
+
+  return true;
+}
+} // namespace
+
+class Avplayer: public IAvplayer {
+  std::mutex m_mutex_int;
+
+  SceAvPlayerMemAllocator m_memAlloc;
+  std::filesystem::path   m_filename;
+
+  bool m_isLoop        = false;
+  bool m_isVideoActive = false, m_isAudioActive = false;
+
+  void*                m_videoBuffer = nullptr;
+  std::vector<uint8_t> m_audioBuffer;
+
+  std::array<int, 4>   m_videoStride;
+  std::array<void*, 4> m_videoPlane;
+
+  int64_t m_startTime = 0;
+
+  // Avplayer Data
+  AVFormatContext* m_pFmtCtx = nullptr;
+  SwsContext*      m_swsCtx  = nullptr;
+  SwrContext*      m_swrCtx  = nullptr;
+
+  // Decode Thread Vars
+  std::mutex m_mutexDecode;
+
+  bool m_isStop = false;
+
+  std::unique_ptr<std::thread> m_decodeThread;
+  std::condition_variable      m_condDecode; // Notify Decoding Thread
+  // - Decode Thread
+
+  struct DataBase {
+    int             streamIndex  = -1;
+    AVCodecContext* codecContext = nullptr;
+    AVStream*       stream       = nullptr;
+    AVFrame*        frame        = nullptr;
+
+    bool getNewFrame = true;
+
+    bool                    pending = false;
+    std::queue<AVPacket*>   decodeQueue;
+    std::condition_variable m_cond; // Notify Client for new data
+
+    void destroy() {
+      if (codecContext != nullptr) avcodec_free_context(&codecContext);
+      if (frame != nullptr) av_frame_free(&frame);
+    }
+  } m_video, m_audio;
+
+  void destroyAVData() {
+    if (m_pFmtCtx != nullptr) {
+      avformat_close_input(&m_pFmtCtx);
+    }
+    if (m_swsCtx != nullptr) {
+      sws_freeContext(m_swsCtx);
+    }
+    if (m_swrCtx != nullptr) {
+      swr_free(&m_swrCtx);
+    }
+
+    m_video.destroy();
+    m_audio.destroy();
+
+    m_isStop = true;
+    m_condDecode.notify_one();
+    if (m_decodeThread) m_decodeThread->join();
+  }
+
+  std::unique_ptr<std::thread> threadFunc();
+
+  public:
+  Avplayer(SceAvPlayerMemAllocator const& initData): m_memAlloc(initData) {}
+
+  virtual ~Avplayer() {
+    LOG_USE_MODULE(AvPlayer);
+    LOG_DEBUG(L"destruct");
+    destroyAVData();
+  };
+
+  bool setFile(const char* filename) final;
+  void setLoop(bool isLoop) final {
+    std::unique_lock const lock(m_mutex_int);
+    m_isLoop = isLoop;
+  }
+
+  bool getVideoData(void* videoInfo, bool isEx) final;
+  bool getAudioData(SceAvPlayerFrameInfo* videoInfo) final;
+
+  bool isPlaying() final {
+    LOG_USE_MODULE(AvPlayer);
+    std::unique_lock lock(m_mutexDecode);
+
+    LOG_TRACE(L"isPlaying:%u", m_isVideoActive | m_isAudioActive);
+    return m_isVideoActive | m_isAudioActive;
+  }
+
+  void stop() final {
+    LOG_USE_MODULE(AvPlayer);
+    LOG_DEBUG(L"stop");
+
+    m_isStop = true;
+    m_video.m_cond.notify_one();
+    m_audio.m_cond.notify_one();
+
+    if (m_videoBuffer != nullptr) m_memAlloc.deallocateTexture(m_memAlloc.objectPointer, m_videoBuffer);
+    m_videoBuffer = nullptr;
+  }
+};
+
+std::unique_ptr<IAvplayer> createAvPlayer(SceAvPlayerMemAllocator const& initData) {
+  auto inst = std::make_unique<Avplayer>(initData);
+
+  return inst;
+}
+
+bool Avplayer::setFile(const char* filename) {
+  LOG_USE_MODULE(AvPlayer);
+
+  std::unique_lock lock(m_mutex_int);
+
+  auto mapped = accessFileManager().getMappedPath(std::string(filename));
+  if (!mapped) {
+    return false;
+  }
+  m_filename = mapped.value();
+
+  if (!std::filesystem::exists(m_filename)) {
+    LOG_ERR(L"File doesn't exist:%S -> mapped:%s", filename, m_filename.c_str());
+    return false;
+  }
+
+  // Init ffmpeg
+  if (avformat_open_input(&m_pFmtCtx, m_filename.string().c_str(), NULL, NULL) < 0) {
+    LOG_ERR(L"avformat_open_input %s", filename, m_filename.c_str());
+    return false;
+  }
+
+  if (avformat_find_stream_info(m_pFmtCtx, NULL) < 0) {
+    LOG_ERR(L"avformat_find_stream_info %s", filename, m_filename.c_str());
+    avformat_close_input(&m_pFmtCtx);
+    return false;
+  }
+
+  m_isVideoActive = false;
+  m_isAudioActive = false;
+  if (openCodecContext(&m_video.streamIndex, m_pFmtCtx, AVMEDIA_TYPE_VIDEO, &m_video.codecContext)) {
+    m_isVideoActive = true;
+    m_startTime     = 0;
+
+    m_video.frame = av_frame_alloc();
+
+    m_video.stream = m_pFmtCtx->streams[m_video.streamIndex];
+    LOG_DEBUG(L"video stream: %u:%u rate:%f", m_video.codecContext->width, m_video.codecContext->height, av_q2d(m_video.codecContext->framerate));
+
+    auto const videobufferSize = av_image_get_buffer_size(AV_PIX_FMT_NV12, m_video.codecContext->width, m_video.codecContext->height, 1);
+    if (videobufferSize < 0) {
+      LOG_ERR(L"av_image_get_buffer_size %s", m_filename.c_str());
+      destroyAVData();
+      return false;
+    }
+
+    uint64_t const alignment = getImageAlignment(VK_FORMAT_R8G8_UNORM, VkExtent3D {1920, 1080, 1}); // image size doesn't matter
+    m_videoBuffer            = (void*)((uint64_t)m_memAlloc.allocateTexture(m_memAlloc.objectPointer, alignment, videobufferSize));
+
+    m_videoStride = std::array<int, 4> {m_video.codecContext->width, m_video.codecContext->width, 0, 0};
+    m_videoPlane  = std::array<void*, 4> {m_videoBuffer, (uint8_t*)m_videoBuffer + m_video.codecContext->width * m_video.codecContext->height, 0, 0};
+  }
+
+  if (openCodecContext(&m_audio.streamIndex, m_pFmtCtx, AVMEDIA_TYPE_AUDIO, &m_audio.codecContext)) {
+    m_isAudioActive = true;
+    if (swr_alloc_set_opts2(&m_swrCtx, &m_audio.codecContext->ch_layout, AVSampleFormat::AV_SAMPLE_FMT_S16, m_audio.codecContext->sample_rate,
+                            &m_audio.codecContext->ch_layout, m_audio.codecContext->sample_fmt, m_audio.codecContext->sample_rate, 0, NULL)) {
+      LOG_ERR(L"Couldn't alloc swr");
+    }
+    swr_init(m_swrCtx);
+
+    m_audio.frame  = av_frame_alloc();
+    m_audio.stream = m_pFmtCtx->streams[m_audio.streamIndex];
+    LOG_DEBUG(L"audio stream: rate:%d channels:%d", m_audio.codecContext->sample_rate, m_audio.codecContext->ch_layout.nb_channels);
+
+    m_audioBuffer.clear();
+  }
+  // -ffmpeg
+
+  LOG_INFO(L"added:%S -> mapped:%s", filename, m_filename.c_str());
+
+  m_decodeThread = threadFunc();
+  return true;
+}
+
+bool Avplayer::getVideoData(void* info, bool isEx) {
+  LOG_USE_MODULE(AvPlayer);
+
+  if (m_isVideoActive == false) return false;
+
+  // Get Frame from decoder
+  while (m_video.getNewFrame) {
+    std::unique_lock lock(m_mutexDecode);
+
+    auto const retRecv = avcodec_receive_frame(m_video.codecContext, m_video.frame);
+    if (retRecv < 0) {
+      if (retRecv == AVERROR(EAGAIN)) {
+        if (!m_isStop) {
+          m_video.m_cond.wait(lock);
+          continue;
+        }
+      } else if (retRecv != AVERROR_EOF) {
+        LOG_ERR(L"avcodec_receive_frame:%d", retRecv);
+      }
+      LOG_INFO(L"Video EOF");
+      m_isVideoActive = false; // End of file
+
+      m_video.getNewFrame = false;
+      m_video.pending     = false;
+      m_condDecode.notify_one();
+      return false;
+    }
+
+    m_video.getNewFrame = false;
+  }
+  // -frame
+
+  // set startTime if first call
+  if (m_startTime == 0) {
+    // if audio is available -> audio sets first timestamp
+    if (m_isAudioActive) return false;
+
+    m_startTime = av_gettime();
+  }
+  // - start time
+
+  auto const timestamp = (int64_t)(1000.0 * av_q2d(m_video.stream->time_base) * m_video.frame->best_effort_timestamp); // timestamp[seconds] to [ms]
+
+  auto const curTime = (av_gettime() - m_startTime) / 1000; // [us] to [ms]
+  if (timestamp > curTime) {
+    return false;
+  }
+
+  LOG_DEBUG(L"Received video frame, timestamp:%lld", m_video.frame->pts);
+  m_video.getNewFrame = true;
+
+  //  Convert and copy to texture
+
+  m_swsCtx = sws_getCachedContext(m_swsCtx, m_video.frame->width, m_video.frame->height, m_video.codecContext->pix_fmt, m_video.frame->width,
+                                  m_video.frame->height, AV_PIX_FMT_NV12, NULL, NULL, NULL, NULL);
+  sws_scale(m_swsCtx, m_video.frame->data, m_video.frame->linesize, 0, m_video.frame->height, (uint8_t**)m_videoPlane.data(), m_videoStride.data());
+  // -
+
+  av_frame_unref(m_video.frame);
+
+  {
+    std::unique_lock lock(m_mutexDecode);
+    if (m_video.pending) {
+      m_video.pending = false;
+      LOG_DEBUG(L"getAudioData: notfiy decoder");
+      lock.unlock();
+      m_condDecode.notify_one();
+    }
+  }
+
+  // Set Info
+  if (isEx) {
+    auto* pInfo      = (SceAvPlayerFrameInfoEx*)info;
+    pInfo->timeStamp = timestamp;
+    pInfo->pData     = m_videoBuffer;
+
+    pInfo->details.video.width           = m_video.codecContext->width;
+    pInfo->details.video.height          = m_video.codecContext->height;
+    pInfo->details.video.aspectRatio     = av_q2d(m_video.codecContext->sample_aspect_ratio);
+    pInfo->details.video.languageCode[0] = 'e';
+    pInfo->details.video.languageCode[1] = 'n';
+    pInfo->details.video.languageCode[2] = 'g';
+    pInfo->details.video.languageCode[3] = '\0';
+
+    pInfo->details.video.framerate          = av_q2d(m_video.codecContext->framerate);
+    pInfo->details.video.cropLeftOffset     = 0;
+    pInfo->details.video.cropRightOffset    = 0;
+    pInfo->details.video.cropTopOffset      = 0;
+    pInfo->details.video.cropBottomOffset   = 0;
+    pInfo->details.video.pitch              = m_video.codecContext->width;
+    pInfo->details.video.lumaBitDepth       = 8;
+    pInfo->details.video.chromaBitDepth     = 8;
+    pInfo->details.video.videoFullRangeFlag = 0;
+  } else {
+    auto* pInfo      = (SceAvPlayerFrameInfo*)info;
+    pInfo->timeStamp = timestamp;
+    pInfo->pData     = (uint8_t*)m_videoBuffer;
+
+    pInfo->details.video.width           = m_video.codecContext->width;
+    pInfo->details.video.height          = m_video.codecContext->height;
+    pInfo->details.video.aspectRatio     = av_q2d(m_video.codecContext->sample_aspect_ratio);
+    pInfo->details.video.languageCode[0] = 'e';
+    pInfo->details.video.languageCode[1] = 'n';
+    pInfo->details.video.languageCode[2] = 'g';
+    pInfo->details.video.languageCode[3] = '\0';
+  }
+  // -info
+  return true;
+}
+
+bool Avplayer::getAudioData(SceAvPlayerFrameInfo* info) {
+  LOG_USE_MODULE(AvPlayer);
+  if (m_isAudioActive == false) return false;
+
+  // Get Frame from decoder
+  while (true) {
+    std::unique_lock lock(m_mutexDecode);
+
+    auto const retRecv = avcodec_receive_frame(m_audio.codecContext, m_audio.frame);
+    if (retRecv < 0) {
+      if (retRecv == AVERROR(EAGAIN)) {
+        if (!m_isStop) {
+          m_audio.m_cond.wait(lock);
+          continue;
+        }
+      } else if (retRecv != AVERROR_EOF) {
+        LOG_ERR(L"avcodec_receive_frame:%d", retRecv);
+      }
+      LOG_INFO(L"Audio EOF");
+      m_isAudioActive = false; // End of file
+
+      m_audio.pending = false;
+      m_condDecode.notify_one();
+      return false;
+    }
+    break;
+  }
+  // -Frame
+
+  LOG_DEBUG(L"Received audio frame %lld", m_audio.frame->pts);
+
+  if (m_startTime == 0) {
+    // audio sets first timestamp
+    m_startTime = av_gettime();
+  }
+
+  auto const timestamp = (int64_t)(1000.0 * av_q2d(m_audio.stream->time_base) * m_audio.frame->best_effort_timestamp); // timestamp[seconds] to [ms]
+
+  //  Convert and copy
+  int const outNumSamples = swr_get_out_samples(m_swrCtx, m_audio.frame->nb_samples);
+  if (m_audioBuffer.size() == 0) {
+    auto const bufferSize = m_audio.frame->ch_layout.nb_channels * outNumSamples * av_get_bytes_per_sample((AVSampleFormat)m_audio.frame->format);
+    m_audioBuffer.resize(bufferSize);
+  }
+
+  uint8_t* audioBuffers[1] = {m_audioBuffer.data()};
+  if (swr_convert(m_swrCtx, audioBuffers, outNumSamples, (uint8_t const**)m_audio.frame->extended_data, m_audio.frame->nb_samples) < 0) {
+    LOG_ERR(L"swr_convert");
+  }
+  // -
+
+  av_frame_unref(m_audio.frame);
+  {
+    std::unique_lock lock(m_mutexDecode);
+    if (m_audio.pending) {
+      m_audio.pending = false;
+      LOG_DEBUG(L"getAudioData: notfiy decoder");
+      lock.unlock();
+      m_condDecode.notify_one();
+    }
+  }
+
+  info->timeStamp = timestamp;
+  info->pData     = m_audioBuffer.data();
+
+  info->details.audio.channelCount    = m_audio.codecContext->ch_layout.nb_channels;
+  info->details.audio.sampleRate      = m_audio.codecContext->sample_rate;
+  info->details.audio.size            = m_audioBuffer.size();
+  info->details.audio.languageCode[0] = 'e';
+  info->details.audio.languageCode[1] = 'n';
+  info->details.audio.languageCode[2] = 'g';
+  info->details.audio.languageCode[3] = '\0';
+  return true;
+}
+
+std::unique_ptr<std::thread> Avplayer::threadFunc() {
+  m_isStop = false;
+
+  return std::make_unique<std::thread>([this] {
+    LOG_USE_MODULE(AvPlayer);
+    util::setThreadName("AvPlayer Decoder");
+
+    m_video.pending = false;
+    m_audio.pending = false;
+
+    AVPacket* packet = nullptr;
+
+    bool isEOF = false;
+
+    std::deque<AVPacket*> packetQueue;
+    size_t                countPackets = 0;
+
+    auto sendFunc = [&packetQueue, this](DataBase& curData) {
+      LOG_USE_MODULE(AvPlayer);
+
+      if (curData.pending) return; // Wait on client
+
+      while (!curData.decodeQueue.empty()) {
+        auto packet = curData.decodeQueue.front();
+        {
+          std::unique_lock lock(m_mutexDecode);
+          if (int ret = avcodec_send_packet(curData.codecContext, packet); ret < 0) {
+            if (ret == AVERROR(EAGAIN)) {
+              curData.pending = true;
+              LOG_DEBUG(L"avcodec_send_packet: decoder full");
+            } else {
+              LOG_ERR(L"avcodec_send_packet");
+            }
+            return;
+          }
+        }
+        curData.m_cond.notify_one(); // Notify client
+        curData.decodeQueue.pop();
+
+        LOG_DEBUG(L"##Send Packet %d queue:%llu time:%lld", packet->stream_index, curData.decodeQueue.size(), packet->pts);
+        av_packet_unref(packet);
+        packetQueue.push_back(packet);
+      }
+    };
+
+    while (!m_isStop) {
+      // Get New Frames
+
+      if (!isEOF) {
+        if (packetQueue.empty()) {
+          packet = av_packet_alloc();
+          ++countPackets;
+        } else {
+          packet = packetQueue.front();
+          packetQueue.pop_front();
+        }
+        LOG_DEBUG(L"Read new Frame: queue:%llu total:%llu", packetQueue.size(), countPackets);
+
+        int state = av_read_frame(m_pFmtCtx, packet);
+        if (state < 0) {
+          if (state != AVERROR_EOF) {
+            LOG_ERR(L"av_read_frame error %d", state);
+            break;
+          } else {
+            if (m_isLoop) {
+              LOG_ERR(L"todo video loop");
+            }
+            isEOF = true;
+            LOG_INFO(L"av_read_frame eof");
+          }
+        }
+        if (packet->stream_index == m_video.streamIndex) {
+          m_video.decodeQueue.push(packet);
+          LOG_DEBUG(L"Queue Video Packet: numItems:%llu pts:%lld", m_video.decodeQueue.size(), packet->pts);
+        } else if (packet->stream_index == m_audio.streamIndex) {
+          m_audio.decodeQueue.push(packet);
+          LOG_DEBUG(L"Queue Video Packet: numItems:%llu pts:%lld", m_video.decodeQueue.size(), packet->pts);
+        } else
+          continue;
+      }
+      // - new frames
+
+      // Decode Frame
+      while (true) {
+        sendFunc(m_video);
+        sendFunc(m_audio);
+
+        std::unique_lock lock(m_mutexDecode);
+        if (m_video.pending && !m_video.decodeQueue.empty() && m_audio.pending && !m_audio.decodeQueue.empty()) {
+          m_condDecode.wait(lock, [&] { return m_video.pending; });
+          continue;
+        }
+        break;
+      }
+
+      if (isEOF && m_video.decodeQueue.empty() && m_audio.decodeQueue.empty()) {
+        m_isStop = true;
+        m_video.m_cond.notify_one();
+        m_audio.m_cond.notify_one();
+        break;
+      }
+    }
+
+    LOG_INFO(L"Decoder exit: packets:%llu", packetQueue.size());
+    for (auto item: packetQueue) {
+      av_packet_free(&packet);
+    }
+  });
+}
--- a/modules/libSceAvPlayer/avplayer.h
+++ b/modules/libSceAvPlayer/avplayer.h
@ -0,0 +1,26 @@
+#pragma once
+#include "utility/utility.h"
+
+struct SceAvPlayerFrameInfo;
+struct SceAvPlayerMemAllocator;
+
+class IAvplayer {
+  CLASS_NO_COPY(IAvplayer);
+
+  protected:
+  IAvplayer() = default;
+
+  public:
+  virtual bool setFile(const char* filename) = 0;
+  virtual void setLoop(bool isLoop)          = 0;
+
+  virtual bool getVideoData(void* videoInfo, bool isEx)      = 0;
+  virtual bool getAudioData(SceAvPlayerFrameInfo* videoInfo) = 0;
+
+  virtual bool isPlaying() = 0;
+  virtual void stop()      = 0;
+
+  virtual ~IAvplayer() = default;
+};
+
+std::unique_ptr<IAvplayer> createAvPlayer(SceAvPlayerMemAllocator const& initData);
--- a/modules/libSceAvPlayer/codes.h
+++ b/modules/libSceAvPlayer/codes.h
@ -0,0 +1,16 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {
+constexpr int32_t INVALID_PARAMS          = -2140536831; /* 0x806A0001 */
+constexpr int32_t OPERATION_FAILED        = -2140536830; /* 0x806A0002 */
+constexpr int32_t NO_MEMORY               = -2140536829; /* 0x806A0003 */
+constexpr int32_t NOT_SUPPORTED           = -2140536828; /* 0x806A0004 */
+constexpr int32_t WAR_FILE_NONINTERLEAVED = -2140536672; /* 0x806A00A0 */
+constexpr int32_t WAR_LOOPING_BACK        = -2140536671; /* 0x806A00A1 */
+constexpr int32_t WAR_JUMP_COMPLETE       = -2140536669; /* 0x806A00A3 */
+constexpr int32_t INFO_MARLIN_ENCRY       = -2140536656; /* 0x806A00B0 */
+constexpr int32_t INFO_PLAYREADY_ENCRY    = -2140536652; /* 0x806A00B4 */
+constexpr int32_t INFO_AES_ENCRY          = -2140536651; /* 0x806A00B5 */
+constexpr int32_t INFO_OTHER_ENCRY        = -2140536641; /* 0x806A00BF */
+} // namespace Err
--- a/modules/libSceAvPlayer/entry.cpp
+++ b/modules/libSceAvPlayer/entry.cpp
@ -0,0 +1,95 @@
+#include "avplayer.h"
+#include "common.h"
+#include "types.h"
+
+#include <logging.h>
+LOG_DEFINE_MODULE(libSceAvPlayer);
+
+namespace {} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceAvPlayer";
+
+EXPORT SYSV_ABI SceAvPlayerHandle sceAvPlayerInit(SceAvPlayerInitData* pInit) {
+  auto inst = createAvPlayer(pInit->memoryReplacement);
+  return inst.release();
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerPostInit(IAvplayer* avPlayer, SceAvPlayerPostInitData* pPostInit) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerClose(IAvplayer* avPlayer) {
+  delete avPlayer;
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerAddSource(IAvplayer* avPlayer, const char* filename) {
+  if (avPlayer->setFile(filename)) return Ok;
+  return Err::INVALID_PARAMS;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerStreamCount(IAvplayer* avPlayer) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerGetStreamInfo(IAvplayer* avPlayer, uint32_t argStreamID, SceAvPlayerStreamInfo* argInfo) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerEnableStream(IAvplayer* avPlayer, uint32_t argStreamID) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerDisableStream(IAvplayer* avPlayer, uint32_t argStreamID) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerChangeStream(IAvplayer* avPlayer, uint32_t argOldStreamID, uint32_t argNewStreamID) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerStart(IAvplayer* avPlayer) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerStop(IAvplayer* avPlayer) {
+  avPlayer->stop();
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerPause(IAvplayer* avPlayer) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerResume(IAvplayer* avPlayer) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerSetLooping(IAvplayer* avPlayer, bool loopFlag) {
+  avPlayer->setLoop(loopFlag);
+  return Ok;
+}
+EXPORT SYSV_ABI bool sceAvPlayerIsActive(IAvplayer* avPlayer) {
+  if (avPlayer != nullptr) return avPlayer->isPlaying();
+  return false;
+}
+EXPORT SYSV_ABI bool sceAvPlayerGetAudioData(IAvplayer* avPlayer, SceAvPlayerFrameInfo* audioInfo) {
+  return avPlayer->getAudioData(audioInfo);
+}
+EXPORT SYSV_ABI bool sceAvPlayerGetVideoData(IAvplayer* avPlayer, SceAvPlayerFrameInfo* videoInfo) {
+  return avPlayer->getVideoData(videoInfo, false);
+}
+EXPORT SYSV_ABI uint64_t sceAvPlayerCurrentTime(IAvplayer* avPlayer) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerJumpToTime(IAvplayer* avPlayer, uint64_t argJumpTimeMsec) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerSetTrickSpeed(IAvplayer* avPlayer, int32_t argTrickSpeed) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerSetAvSyncMode(IAvplayer* avPlayer, SceAvPlayerAvSyncMode argSyncMode) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerSetLogCallback(SceAvPlayerLogCallback logCb, void* userData) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerPrintf(const char* format, ...) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerVprintf(const char* str, va_list args) {
+  LOG_USE_MODULE(libSceAvPlayer);
+  std::string format(str);
+  LOG_DEBUG(std::wstring(format.begin(), format.end()).c_str(), args);
+  return Ok;
+}
+}
--- a/modules/libSceAvPlayer/entryEx.cpp
+++ b/modules/libSceAvPlayer/entryEx.cpp
@ -0,0 +1,23 @@
+#include "avplayer.h"
+#include "common.h"
+#include "typesEx.h"
+
+#include <logging.h>
+
+namespace {} // namespace
+
+extern "C" {
+EXPORT SYSV_ABI int32_t sceAvPlayerInitEx(const SceAvPlayerInitDataEx* initDataEx, IAvplayer** avPlayer) {
+  auto inst = createAvPlayer(initDataEx->memoryReplacement);
+  *avPlayer = inst.release();
+
+  return Ok;
+}
+EXPORT SYSV_ABI bool sceAvPlayerGetVideoDataEx(IAvplayer* avPlayer, SceAvPlayerFrameInfoEx* videoInfo) {
+  return avPlayer->getVideoData(videoInfo, true);
+}
+EXPORT SYSV_ABI int32_t sceAvPlayerAddSourceEx(IAvplayer* avPlayer, SceAvPlayerUriType uriType, SceAvPlayerSourceDetails* sourceDetails) {
+  if (avPlayer->setFile(sourceDetails->uri.name)) return Ok;
+  return Err::INVALID_PARAMS;
+}
+}
--- a/modules/libSceAvPlayer/types.h
+++ b/modules/libSceAvPlayer/types.h
@ -0,0 +1,184 @@
+#pragma once
+#include "codes.h"
+#include "utility/utility.h"
+typedef void* SceAvPlayerHandle;
+
+using SceAvPlayerLogCallback       = SYSV_ABI int (*)(void* userData, const char* format, va_list args);
+using SceAvPlayerAllocate          = SYSV_ABI void* (*)(void* argP, uint32_t argAlignment, uint32_t argSize);
+using SceAvPlayerDeallocate        = SYSV_ABI void (*)(void* argP, void* argMemory);
+using SceAvPlayerAllocateTexture   = SYSV_ABI void* (*)(void* argP, uint32_t argAlignment, uint32_t argSize);
+using SceAvPlayerDeallocateTexture = SYSV_ABI void (*)(void* argP, void* argMemory);
+using SceAvPlayerOpenFile          = SYSV_ABI int (*)(void* argP, const char* argFilename);
+using SceAvPlayerCloseFile         = SYSV_ABI int (*)(void* argP);
+using SceAvPlayerReadOffsetFile    = SYSV_ABI int (*)(void* argP, uint8_t* argBuffer, uint64_t argPosition, uint32_t argLength);
+using SceAvPlayerEventCallback     = SYSV_ABI void (*)(void* p, int32_t argEventId, int32_t argSourceId, void* argEventData);
+using SceAvPlayerSizeFile          = SYSV_ABI uint64_t (*)(void* argP);
+
+enum class SceAvPlayerVideoDecoderType { DEFAULT = 0, RESERVED1, RESERVED2, SOFTWARE2 };
+
+enum class SceAvPlayerAudioDecoderType { DEFAULT = 0, RESERVED1, RESERVED2 };
+
+enum class SceAvPlayerAudioChannelOrder { DEFAULT = 0, EXTL_EXTR_LS_RS, LS_RS_EXTL_EXTR };
+
+enum SceAvPlayerStreamType { VIDEO, AUDIO, TIMEDTEXT, UNKNOWN };
+
+enum class SceAvPlayerEvents {
+  STATE_STOP      = 0x01,
+  STATE_READY     = 0x02,
+  STATE_PLAY      = 0x03,
+  STATE_PAUSE     = 0x04,
+  STATE_BUFFERING = 0x05,
+
+  TIMED_TEXT_DELIVERY = 0x10,
+  WARNING_ID          = 0x20,
+  ENCRYPTION          = 0x30,
+  DRM_ERROR           = 0x40
+};
+
+enum class SceAvPlayerTrickSpeeds { NORMAL = 100, FF_4X = 400, FF_8X = 800, FF_16X = 1600, FF_MAX = 3200, RW_8X = -800, RW_16X = -1600, RW_MAX = -3200 };
+
+enum class SceAvPlayerAvSyncMode {
+  DEFAULT = 0,
+
+  NONE
+};
+
+enum class SceAvPlayerDebuglevels { NONE, INFO, WARNINGS, ALL };
+
+enum class SceAvPlayerDRMType { MARLIN, PLAYREADY };
+
+struct SceAvPlayerDecoderInit {
+  union {
+    SceAvPlayerVideoDecoderType videoType;
+    SceAvPlayerAudioDecoderType audioType;
+    uint8_t                     reserved[4];
+  } decoderType;
+  union {
+    struct {
+      int32_t cpuAffinityMask;
+
+      int32_t cpuThreadPriority;
+
+      uint8_t decodePipelineDepth;
+
+      uint8_t computePipeId;
+      uint8_t computeQueueId;
+      uint8_t enableInterlaced;
+
+      uint8_t reserved[16];
+    } avcSw2;
+    struct {
+      uint8_t audioChannelOrder;
+      uint8_t reserved[27];
+    } aac;
+    uint8_t reserved[28];
+  } decoderParams;
+};
+
+struct SceAvPlayerHTTPCtx {
+  uint32_t httpCtxId;
+  uint32_t sslCtxId;
+};
+
+struct SceAvPlayerPostInitData {
+  uint32_t               demuxVideoBufferSize;
+  SceAvPlayerDecoderInit videoDecoderInit;
+  SceAvPlayerDecoderInit audioDecoderInit;
+  SceAvPlayerHTTPCtx     httpCtx;
+};
+
+struct SceAvPlayerDRMError {
+  SceAvPlayerDRMType type;
+  int32_t            errorCode;
+};
+
+struct SceAvPlayerAudio {
+  uint16_t channelCount;
+  uint8_t  reserved1[2];
+  uint32_t sampleRate;
+  uint32_t size;
+
+  uint8_t languageCode[4];
+};
+
+struct SceAvPlayerVideo {
+  uint32_t width;
+  uint32_t height;
+  float    aspectRatio;
+  uint8_t  languageCode[4];
+};
+
+struct SceAvPlayerTextPosition {
+  uint16_t top;
+  uint16_t left;
+  uint16_t bottom;
+  uint16_t right;
+};
+
+struct SceAvPlayerTimedText {
+  uint8_t                 languageCode[4];
+  uint16_t                textSize;
+  uint16_t                fontSize;
+  SceAvPlayerTextPosition position;
+};
+
+union SceAvPlayerStreamDetails {
+  uint8_t              reserved[16];
+  SceAvPlayerAudio     audio;
+  SceAvPlayerVideo     video;
+  SceAvPlayerTimedText subs;
+};
+
+struct SceAvPlayerStreamInfo {
+  uint32_t                 type;
+  uint8_t                  reserved[4];
+  SceAvPlayerStreamDetails details;
+  uint64_t                 duration;
+  uint64_t                 startTime;
+};
+
+struct SceAvPlayerFrameInfo {
+  uint8_t*                 pData;
+  uint8_t                  reserved[4];
+  uint64_t                 timeStamp;
+  SceAvPlayerStreamDetails details;
+};
+
+struct SceAvPlayerMemAllocator {
+  void* objectPointer;
+
+  SceAvPlayerAllocate          allocate;
+  SceAvPlayerDeallocate        deallocate;
+  SceAvPlayerAllocateTexture   allocateTexture;
+  SceAvPlayerDeallocateTexture deallocateTexture;
+};
+
+struct SceAvPlayerFileReplacement {
+  void* objectPointer;
+
+  SceAvPlayerOpenFile       open;
+  SceAvPlayerCloseFile      close;
+  SceAvPlayerReadOffsetFile readOffset;
+  SceAvPlayerSizeFile       size;
+};
+
+struct SceAvPlayerEventReplacement {
+  void* objectPointer;
+
+  SceAvPlayerEventCallback eventCallback;
+};
+
+struct SceAvPlayerInitData {
+  SceAvPlayerMemAllocator memoryReplacement;
+
+  SceAvPlayerFileReplacement  fileReplacement;
+  SceAvPlayerEventReplacement eventReplacement;
+  SceAvPlayerDebuglevels      debugLevel;
+  uint32_t                    basePriority;
+
+  int32_t numOutputVideoFrameBuffers;
+
+  bool        autoStart;
+  uint8_t     reserved[3];
+  const char* defaultLanguage;
+};
--- a/modules/libSceAvPlayer/typesEx.h
+++ b/modules/libSceAvPlayer/typesEx.h
@ -0,0 +1,124 @@
+#pragma once
+#include "types.h"
+
+enum class SceAvPlayerUriType { SOURCE = 0 };
+
+enum class SceAvPlayerSourceType { UNKNOWN = 0, FILE_MP4 = 1, HLS = 8 };
+
+enum class SceAvPlayerPriorityType {
+  INHERIT               = (0),
+  SYSTEM_DEFAULT        = 700,
+  OFFSET_DEMUX          = (2),
+  OFFSET_VIDEO_DECODER  = (5),
+  OFFSET_AUDIO_DECODER  = (6),
+  OFFSET_CONTROLLER     = (9),
+  OFFSET_HTTP_STREAMING = (10),
+  OFFSET_FILE_STREAMING = (15)
+};
+
+enum class SceAvPlayerAffinityType {
+  AFFINITY_INHERIT               = (0),
+  AFFINITY_1                     = (1),
+  AFFINITY_2                     = (1 << 1),
+  AFFINITY_3                     = (1 << 2),
+  AFFINITY_4                     = (1 << 3),
+  AFFINITY_5                     = (1 << 4),
+  AFFINITY_6                     = (1 << 5),
+  AFFINITY_SYSTEM_7_CPU          = (1 << 6),
+  AFFINITY_SYSTEM_DEFAULT        = (1) | (1 << 1) | (1 << 2) | (1 << 3),
+  AFFINITY_SYSTEM_FIRST_CLUSTER  = (1) | (1 << 1) | (1 << 2) | (1 << 3),
+  AFFINITY_SYSTEM_SECOND_CLUSTER = (1 << 4) | (1 << 5),
+  AFFINITY_SYSTEM_ALL_CLUSTER    = (1) | (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5),
+};
+
+struct SceAvPlayerAudioEx {
+  uint16_t channelCount;
+  uint8_t  reserved[2];
+  uint32_t sampleRate;
+  uint32_t size;
+  uint8_t  languageCode[4];
+  uint8_t  reserved1[64];
+};
+
+struct SceAvPlayerVideoEx {
+  uint32_t width;
+  uint32_t height;
+  float    aspectRatio;
+  uint8_t  languageCode[4];
+  uint32_t framerate;
+  uint32_t cropLeftOffset;
+  uint32_t cropRightOffset;
+  uint32_t cropTopOffset;
+  uint32_t cropBottomOffset;
+  uint32_t pitch;
+  uint8_t  lumaBitDepth;
+  uint8_t  chromaBitDepth;
+  bool     videoFullRangeFlag;
+
+  uint8_t reserved1[37];
+};
+struct SceAvPlayerTimedTextEx {
+  uint8_t languageCode[4];
+  uint8_t reserved[12];
+  uint8_t reserved1[64];
+};
+
+union SceAvPlayerStreamDetailsEx {
+  SceAvPlayerAudioEx     audio;
+  SceAvPlayerVideoEx     video;
+  SceAvPlayerTimedTextEx subs;
+};
+
+struct SceAvPlayerFrameInfoEx {
+  void*                      pData;
+  uint8_t                    reserved[4];
+  uint64_t                   timeStamp;
+  SceAvPlayerStreamDetailsEx details;
+};
+
+struct SceAvPlayerUri {
+  const char* name;
+  uint32_t    length;
+};
+
+struct SceAvPlayerSourceDetails {
+  SceAvPlayerUri        uri;
+  uint8_t               reserved[64];
+  SceAvPlayerSourceType sourceType;
+};
+
+struct SceAvPlayerInitDataEx {
+  size_t                      thisSize;
+  SceAvPlayerMemAllocator     memoryReplacement;
+  SceAvPlayerFileReplacement  fileReplacement;
+  SceAvPlayerEventReplacement eventReplacement;
+  const char*                 defaultLanguage;
+
+  SceAvPlayerDebuglevels debugLevel;
+  uint32_t               audioDecoderPriority;
+  uint32_t               audioDecoderAffinity;
+  uint32_t               videoDecoderPriority;
+
+  uint32_t videoDecoderAffinity;
+
+  uint32_t demuxerPriority;
+  uint32_t demuxerAffinity;
+  uint32_t controllerPriority;
+  uint32_t controllerAffinity;
+  uint32_t httpStreamingPriority;
+  uint32_t httpStreamingAffinity;
+  uint32_t fileStreamingPriority;
+  uint32_t fileStreamingAffinity;
+  int32_t  numOutputVideoFrameBuffers;
+
+  bool    autoStart;
+  uint8_t reserved[3];
+
+  uint32_t audioDecoderStackSize;
+  uint32_t videoDecoderStackSize;
+  uint32_t demuxerStackSize;
+  uint32_t controllerStackSize;
+  uint32_t httpStreamingStackSize;
+
+  uint32_t fileStreamingStackSize;
+};
--- a/modules/libSceCommonDialog/CMakeLists.txt
+++ b/modules/libSceCommonDialog/CMakeLists.txt
@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceCommonDialog)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp)
+
+setupModule(${libName})
--- a/modules/libSceCommonDialog/entry.cpp
+++ b/modules/libSceCommonDialog/entry.cpp
@ -0,0 +1,27 @@
+#include "common.h"
+#include "errorcodes.h"
+
+#include <logging.h>
+
+LOG_DEFINE_MODULE(libSceCommonDialog);
+
+namespace {} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceCommonDialog";
+
+EXPORT SYSV_ABI int32_t sceCommonDialogInitialize() {
+  LOG_USE_MODULE(libSceCommonDialog);
+  LOG_TRACE(L"%S", __FUNCTION__);
+
+  return Ok;
+}
+
+EXPORT SYSV_ABI bool sceCommonDialogIsUsed() {
+  LOG_USE_MODULE(libSceCommonDialog);
+  LOG_TRACE(L"%S", __FUNCTION__);
+
+  return false;
+}
+}
--- a/modules/libSceCommonDialog/errorcodes.h
+++ b/modules/libSceCommonDialog/errorcodes.h
@ -0,0 +1,20 @@
+#pragma once
+
+namespace Err {
+#define ERROR_NOT_SYSTEM_INITIALIZED     -2135425023 /* 0x80B80001 */
+#define ERROR_ALREADY_SYSTEM_INITIALIZED -2135425022 /* 0x80B80002 */
+#define ERROR_NOT_INITIALIZED            -2135425021 /* 0x80B80003 */
+#define ERROR_ALREADY_INITIALIZED        -2135425020 /* 0x80B80004 */
+#define ERROR_NOT_FINISHED               -2135425019 /* 0x80B80005 */
+#define ERROR_INVALID_STATE              -2135425018 /* 0x80B80006 */
+#define ERROR_RESULT_NONE                -2135425017 /* 0x80B80007 */
+#define ERROR_BUSY                       -2135425016 /* 0x80B80008 */
+#define ERROR_OUT_OF_MEMORY              -2135425015 /* 0x80B80009 */
+#define ERROR_PARAM_INVALID              -2135425014 /* 0x80B8000A */
+#define ERROR_NOT_RUNNING                -2135425013 /* 0x80B8000B */
+#define ERROR_ALREADY_CLOSE              -2135425012 /* 0x80B8000C */
+#define ERROR_ARG_NULL                   -2135425011 /* 0x80B8000D */
+#define ERROR_UNEXPECTED_FATAL           -2135425010 /* 0x80B8000E */
+#define ERROR_NOT_SUPPORTED              -2135425009 /* 0x80B8000F */
+#define ERROR_INHIBIT_SHAREPLAY_CLIENT   -2135425008 /* 0x80B80010 */
+} // namespace Err
--- a/modules/libSceCommonDialog/types.h
+++ b/modules/libSceCommonDialog/types.h
@ -0,0 +1,17 @@
+#pragma once
+#include <stdint.h>
+
+enum class SceCommonDialogStatus { NONE = 0, INITIALIZED = 1, RUNNING = 2, FINISHED = 3 };
+
+enum class SceCommonDialogResult {
+  OK            = 0,
+  USER_CANCELED = 1,
+};
+
+struct alignas(8) SceCommonDialogBaseParam {
+  size_t   size;
+  uint8_t  reserved[36];
+  uint32_t magic;
+};
+
+constexpr uint32_t SCE_COMMON_DIALOG_MAGIC_NUMBER = 0xC0D1A109;
--- a/modules/libSceCoredump/CMakeLists.txt
+++ b/modules/libSceCoredump/CMakeLists.txt
@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceCoredump)
+project(${libName})
+
+add_library(${libName} SHARED
+  entry.cpp
+)
+
+
+target_compile_definitions(${libName} PRIVATE BOOST_ALL_NO_LIB)
+target_link_libraries(${libName} PRIVATE
+  libboost_thread)
+
+setupModule(${libName})
--- a/modules/libSceCoredump/codes.h
+++ b/modules/libSceCoredump/codes.h
@ -0,0 +1,4 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {} // namespace Err
--- a/modules/libSceCoredump/entry.cpp
+++ b/modules/libSceCoredump/entry.cpp
@ -0,0 +1,112 @@
+#include "common.h"
+#include "types.h"
+
+#include <boost/thread.hpp>
+#include <logging.h>
+#include <memory>
+#include <utility/utility.h>
+LOG_DEFINE_MODULE(libSceCoredump);
+
+namespace {
+
+typedef SYSV_ABI int (*SceCoredumpHandler)(void* pCommon);
+
+auto getPthread() {
+  static boost::thread* g_coreDumHandler = nullptr;
+  return g_coreDumHandler;
+}
+
+static SceCoredumpHandler g_threadHandler;
+
+void* dummyTask(void* pCommon) {
+  util::setThreadName("CoreDumpHandler");
+  return (void*)(uint64_t)g_threadHandler(pCommon);
+}
+} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libkernel";
+
+EXPORT SYSV_ABI int32_t sceCoredumpRegisterCoredumpHandler(SceCoredumpHandler handler, size_t stackSize, void* pCommon) {
+  LOG_USE_MODULE(libSceCoredump);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+
+  g_threadHandler = handler;
+
+  auto threadPriv = getPthread();
+
+  boost::thread::attributes attr;
+  attr.set_stack_size(stackSize);
+
+  threadPriv = std::make_unique<boost::thread>(attr, boost::bind(dummyTask, pCommon)).release();
+
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceCoredumpUnregisterCoredumpHandler(void) {
+  LOG_USE_MODULE(libSceCoredump);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+
+  auto thread = getPthread();
+  thread->interrupt();
+  thread->join();
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceCoredumpSetUserDataType(int type) {
+  LOG_USE_MODULE(libSceCoredump);
+  LOG_ERR(L"todo %S type:%d", __FUNCTION__, type);
+  return Ok;
+}
+EXPORT SYSV_ABI size_t sceCoredumpWriteUserData(const void* data, size_t size) {
+  LOG_USE_MODULE(libSceCoredump);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI void sceCoredumpDebugTextOut(const char* str, int len) {
+  LOG_USE_MODULE(libSceCoredump);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+}
+EXPORT SYSV_ABI int32_t sceCoredumpAttachUserFile(uint32_t user_value, const char* path) {
+  LOG_USE_MODULE(libSceCoredump);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceCoredumpAttachMemoryRegionAsUserFile(uint32_t user_value, const void* mem, size_t size, const char* name) {
+  LOG_USE_MODULE(libSceCoredump);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceCoredumpAttachMemoryRegion(uint32_t user_value, const void* mem, size_t size) {
+  LOG_USE_MODULE(libSceCoredump);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceCoredumpAttachUserMemoryFile(uint32_t user_value, const void* mem, size_t size) {
+  LOG_USE_MODULE(libSceCoredump);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceCoredumpGetStopInfoCpu(SceCoredumpStopInfoCpu* info, size_t size) {
+  LOG_USE_MODULE(libSceCoredump);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceCoredumpGetStopInfoGpu(SceCoredumpStopInfoGpu* info, size_t size) {
+  LOG_USE_MODULE(libSceCoredump);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceCoredumpGetThreadContextInfo(SceCoredumpThreadContextInfo* threadContextInfo, size_t threadContextInfoSize) {
+  LOG_USE_MODULE(libSceCoredump);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI void sceCoredumpDebugTriggerCoredump(void) {
+  LOG_USE_MODULE(libSceCoredump);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+}
+EXPORT SYSV_ABI void sceCoredumpDebugForceCoredumpOnAppClose(void) {
+  LOG_USE_MODULE(libSceCoredump);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+}
+}
--- a/modules/libSceCoredump/types.h
+++ b/modules/libSceCoredump/types.h
@ -0,0 +1,32 @@
+#pragma once
+#include "codes.h"
+
+struct SceCoredumpStopInfoCpu {
+  void* thread;
+  int   reason_code;
+};
+
+struct SceCoredumpStopInfoGpu {
+  uint64_t timestamp;
+};
+
+struct SceCoredumpThreadContextInfo {
+  uint64_t rdi;
+  uint64_t rsi;
+  uint64_t rdx;
+  uint64_t rcx;
+  uint64_t r8;
+  uint64_t r9;
+  uint64_t rax;
+  uint64_t rbx;
+  uint64_t rbp;
+  uint64_t r10;
+  uint64_t r11;
+  uint64_t r12;
+  uint64_t r13;
+  uint64_t r14;
+  uint64_t r15;
+  uint64_t rip;
+  uint64_t rflags;
+  uint64_t rsp;
+};
--- a/modules/libSceGraphicsDriver/CMakeLists.txt
+++ b/modules/libSceGraphicsDriver/CMakeLists.txt
@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceGraphicsDriver)
+project(${libName})
+
+add_library(${libName} SHARED
+  entry.cpp
+)
+
+target_include_directories(${libName} PRIVATE
+  ${Vulkan_INCLUDE_DIRS}
+  ${CMAKE_SOURCE_DIR}/tools/sb2spirv/lib/include
+)
+
+target_link_libraries(${libName} PRIVATE emulator.lib)
+
+setupModule(${libName})
--- a/modules/libSceGraphicsDriver/codes.h
+++ b/modules/libSceGraphicsDriver/codes.h
@ -0,0 +1,7 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {
+constexpr int VALIDATION_NOT_ENABLED = 0x80D13FFF;
+constexpr int FAILURE                = 0x800EEEFF;
+} // namespace Err
--- a/modules/libSceGraphicsDriver/entry.cpp
+++ b/modules/libSceGraphicsDriver/entry.cpp
@ -0,0 +1,493 @@
+#include "common.h"
+#include "types.h"
+
+#include <eventqueue_types.h>
+#include <igraphics.h>
+#include <logging.h>
+#include <pm4_custom.h>
+#include <timer.h>
+#include <videoOut.h>
+
+LOG_DEFINE_MODULE(libSceGraphicsDriver);
+
+namespace {
+void event_trigger_func(Kernel::EventQueue::KernelEqueueEvent* event, void* trigger_data) {
+  event->triggered = true;
+  event->event.fflags++;
+  event->event.data = reinterpret_cast<intptr_t>(trigger_data);
+}
+
+void event_reset_func(Kernel::EventQueue::KernelEqueueEvent* event) {
+  event->triggered    = false;
+  event->event.fflags = 0;
+  event->event.data   = 0;
+}
+
+void event_delete_func(Kernel::EventQueue::KernelEqueue* eq, Kernel::EventQueue::KernelEqueueEvent* event) {
+  accessVideoOut().getGraphics()->removeEvent(eq, event->event.ident);
+}
+} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceGraphicsDriver";
+
+int SYSV_ABI sceGnmSetVsShader(uint32_t* cmdOut, uint64_t size, const uint32_t* vs_regs, uint32_t shader_modifier) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S 0x%08llx", __FUNCTION__, (uint64_t)cmdOut);
+
+  cmdOut[0] = Pm4::create(size, Pm4::R_VS);
+  cmdOut[1] = shader_modifier;
+  memcpy(&cmdOut[2], vs_regs, size - 1);
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + size);
+  return Ok;
+}
+
+int SYSV_ABI sceGnmUpdateVsShader(uint32_t* cmdOut, uint64_t size, const uint32_t* vs_regs, uint32_t shader_modifier) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S 0x%08llx", __FUNCTION__, (uint64_t)cmdOut);
+
+  cmdOut[0] = Pm4::create(size, Pm4::R_VS_UPDATE);
+  cmdOut[1] = shader_modifier;
+  memcpy(&cmdOut[2], vs_regs, size - 1);
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + size);
+  return Ok;
+}
+
+int SYSV_ABI sceGnmSetPsShader(uint32_t* cmdOut, uint64_t size, const uint32_t* ps_regs) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S 0x%08llx", __FUNCTION__, (uint64_t)cmdOut);
+  if (ps_regs == nullptr) {
+    cmdOut[0] = Pm4::create(size, Pm4::R_PS_EMBEDDED);
+    cmdOut[1] = 0;
+  } else {
+    cmdOut[0] = Pm4::create(size, Pm4::R_PS);
+    memcpy(&cmdOut[1], ps_regs, 8 + size);
+  }
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + size);
+  return Ok;
+}
+
+int SYSV_ABI sceGnmSetPsShader350(uint32_t* cmdOut, uint64_t size, const uint32_t* ps_regs) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S 0x%08llx", __FUNCTION__, (uint64_t)cmdOut);
+  if (ps_regs == nullptr) {
+    cmdOut[0] = Pm4::create(size, Pm4::R_PS_EMBEDDED);
+    cmdOut[1] = 0;
+  } else {
+    cmdOut[0] = Pm4::create(size, Pm4::R_PS);
+    memcpy(&cmdOut[1], ps_regs, 8 + size);
+  }
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + size);
+  return Ok;
+}
+
+int SYSV_ABI sceGnmUpdatePsShader(uint32_t* cmdOut, uint64_t size, const uint32_t* ps_regs) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S 0x%08llx", __FUNCTION__, (uint64_t)cmdOut);
+
+  cmdOut[0] = Pm4::create(size, Pm4::R_PS_UPDATE);
+  memcpy(&cmdOut[1], ps_regs, 8 + size);
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + size);
+  return Ok;
+}
+
+int SYSV_ABI sceGnmUpdatePsShader350(uint32_t* cmdOut, uint64_t size, const uint32_t* ps_regs) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S 0x%08llx", __FUNCTION__, (uint64_t)cmdOut);
+  cmdOut[0] = Pm4::create(size, Pm4::R_PS_UPDATE);
+  memcpy(&cmdOut[1], ps_regs, 8 + size);
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + size);
+  return Ok;
+}
+
+int SYSV_ABI sceGnmSetCsShader(uint32_t* cmdOut, uint64_t size, const uint32_t* cs_regs) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S 0x%08llx", __FUNCTION__, (uint64_t)cmdOut);
+  cmdOut[0] = Pm4::create(size, Pm4::R_CS);
+  cmdOut[1] = 0;
+  memcpy(&cmdOut[2], cs_regs, size);
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + size);
+  return Ok;
+}
+
+int SYSV_ABI sceGnmSetCsShaderWithModifier(uint32_t* cmdOut, uint64_t size, const uint32_t* cs_regs, uint32_t shader_modifier) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S 0x%08llx", __FUNCTION__, (uint64_t)cmdOut);
+  cmdOut[0] = Pm4::create(size, Pm4::R_CS);
+  cmdOut[1] = shader_modifier;
+  memcpy(&cmdOut[2], cs_regs, size);
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + size);
+  return Ok;
+}
+
+int SYSV_ABI sceGnmSetEmbeddedVsShader(uint32_t* cmdOut, uint64_t size, uint32_t id, uint32_t shader_modifier) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S 0x%08llx", __FUNCTION__, (uint64_t)cmdOut);
+
+  cmdOut[0] = Pm4::create(size, Pm4::R_VS_EMBEDDED);
+  cmdOut[1] = shader_modifier;
+  cmdOut[2] = id;
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + size);
+  return Ok;
+}
+
+int SYSV_ABI sceGnmDrawIndex(uint32_t* cmdOut, uint64_t size, uint32_t index_count, const void* index_addr, uint32_t flags, uint32_t type) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S 0x%08llx", __FUNCTION__, (uint64_t)cmdOut);
+
+  cmdOut[0] = Pm4::create(size, Pm4::R_DRAW_INDEX);
+  cmdOut[1] = index_count;
+  cmdOut[2] = static_cast<uint32_t>(reinterpret_cast<uint64_t>(index_addr) & 0xffffffffu);
+  cmdOut[3] = static_cast<uint32_t>((reinterpret_cast<uint64_t>(index_addr) >> 32u) & 0xffffffffu);
+  cmdOut[4] = flags;
+  cmdOut[5] = type;
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + size);
+  return Ok;
+}
+
+int SYSV_ABI sceGnmDrawIndexAuto(uint32_t* cmdOut, uint64_t size, uint32_t index_count, uint32_t flags) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S 0x%08llx", __FUNCTION__, (uint64_t)cmdOut);
+
+  cmdOut[0] = Pm4::create(size, Pm4::R_DRAW_INDEX_AUTO);
+  cmdOut[1] = index_count;
+  cmdOut[2] = flags;
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + size);
+  return Ok;
+}
+
+int32_t SYSV_ABI sceGnmValidateDrawCommandBuffers(uint32_t count, void* dcbGpuAddrs[], uint32_t* dcbSizesInBytes, void* ccbGpuAddrs[],
+                                                  uint32_t* ccbSizesInBytes) {
+#if DEBUG
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  for (uint32_t n = 0; n < count; ++n) {
+    if (dcbGpuAddrs != nullptr) LOG_DEBUG(L"Validate DCB[%d] 0x%08llx(0x%u)", n, (uint64_t)dcbGpuAddrs[n], dcbSizesInBytes[n]);
+    if (ccbGpuAddrs != nullptr) LOG_DEBUG(L"Validate CCB[%d] 0x%08llx(0x%u)", n, (uint64_t)ccbGpuAddrs[n], ccbSizesInBytes[n]);
+  }
+#endif
+  return Err::VALIDATION_NOT_ENABLED;
+}
+
+int SYSV_ABI sceGnmSubmitCommandBuffers(uint32_t count, void** dcb_gpu_addrs, const uint32_t* dcb_sizes_in_bytes, void** ccb_gpu_addrs,
+                                        const uint32_t* ccb_sizes_in_bytes) {
+  accessVideoOut().getGraphics()->submitCmdBuffer(count, (uint32_t const**)dcb_gpu_addrs, dcb_sizes_in_bytes, (uint32_t const**)ccb_gpu_addrs,
+                                                  ccb_sizes_in_bytes, 0, 0, 0, 0, false);
+  return Ok;
+}
+
+int SYSV_ABI sceGnmSubmitCommandBuffersForWorkload(uint64_t workload, uint32_t count, void** dcb_gpu_addrs, const uint32_t* dcb_sizes_in_bytes,
+                                                   void** ccb_gpu_addrs, const uint32_t* ccb_sizes_in_bytes) {
+  accessVideoOut().getGraphics()->submitCmdBuffer(count, (uint32_t const**)dcb_gpu_addrs, dcb_sizes_in_bytes, (uint32_t const**)ccb_gpu_addrs,
+                                                  ccb_sizes_in_bytes, 0, 0, 0, 0, false);
+  return Ok;
+}
+
+int SYSV_ABI sceGnmSubmitAndFlipCommandBuffers(uint32_t count, void** dcb_gpu_addrs, const uint32_t* dcb_sizes_in_bytes, void** ccb_gpu_addrs,
+                                               const uint32_t* ccb_sizes_in_bytes, int handle, int index, int flip_mode, int64_t flip_arg) {
+  accessVideoOut().getGraphics()->submitCmdBuffer(count, (uint32_t const**)dcb_gpu_addrs, dcb_sizes_in_bytes, (uint32_t const**)ccb_gpu_addrs,
+                                                  ccb_sizes_in_bytes, handle, index, flip_mode, flip_arg, true);
+  return Ok;
+}
+int SYSV_ABI sceGnmSubmitAndFlipCommandBuffersForWorkload(uint64_t workload, uint32_t count, void** dcb_gpu_addrs, const uint32_t* dcb_sizes_in_bytes,
+                                                          void** ccb_gpu_addrs, const uint32_t* ccb_sizes_in_bytes, int handle, int index, int flip_mode,
+                                                          int64_t flip_arg) {
+  accessVideoOut().getGraphics()->submitCmdBuffer(count, (uint32_t const**)dcb_gpu_addrs, dcb_sizes_in_bytes, (uint32_t const**)ccb_gpu_addrs,
+                                                  ccb_sizes_in_bytes, handle, index, flip_mode, flip_arg, true);
+  return Ok;
+}
+
+int SYSV_ABI sceGnmSubmitDone() {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S", __FUNCTION__);
+  accessVideoOut().getGraphics()->waitSubmitDone();
+  return Ok;
+}
+
+int SYSV_ABI sceGnmAreSubmitsAllowed() {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S", __FUNCTION__);
+
+  return accessVideoOut().getGraphics()->isRunning();
+}
+
+void SYSV_ABI sceGnmFlushGarlic() {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S", __FUNCTION__);
+}
+
+int SYSV_ABI sceGnmSetVgtControl(uint32_t* cmdOut, uint64_t size, uint32_t primGroupSizeMinusOne, uint32_t partialVsWaveMode, uint32_t wdSwitchOnlyOnEopMode) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S", __FUNCTION__);
+
+  if (size == 3 && primGroupSizeMinusOne < 0x100 && ((wdSwitchOnlyOnEopMode | partialVsWaveMode) < 2)) {
+    cmdOut[0] = Pm4::create(size, Pm4::R_VGT_CONTROL);
+    cmdOut[1] = 0x2aa;
+    cmdOut[2] = ((partialVsWaveMode & 1) << 16) or (primGroupSizeMinusOne & 0xffff);
+
+    accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + size);
+    return Ok;
+  }
+  return -1;
+}
+int SYSV_ABI sceGnmResetVgtControl(uint32_t* cmdOut, int32_t param) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S", __FUNCTION__);
+
+  if (param == 3) {
+    cmdOut[0] = Pm4::create(3, Pm4::R_VGT_CONTROL);
+    cmdOut[1] = 0x2aa;
+    cmdOut[2] = 0xff;
+
+    accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + 3);
+    return Ok;
+  }
+  return -1;
+}
+
+uint32_t SYSV_ABI sceGnmDrawInitDefaultHardwareState(uint32_t* cmdOut, uint64_t size) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_DEBUG(L"%S", __FUNCTION__);
+
+  cmdOut[0] = Pm4::create(2, Pm4::R_DRAW_RESET);
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut[2]) + 2);
+  return 2;
+}
+
+uint32_t SYSV_ABI sceGnmDrawInitDefaultHardwareState175(uint32_t* cmdOut, uint64_t size) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_DEBUG(L"%S", __FUNCTION__);
+
+  cmdOut[0] = Pm4::create(2, Pm4::R_DRAW_RESET);
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + 2);
+  return 2;
+}
+
+uint32_t SYSV_ABI sceGnmDrawInitDefaultHardwareState200(uint32_t* cmdOut, uint64_t size) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_DEBUG(L"%S", __FUNCTION__);
+
+  cmdOut[0] = Pm4::create(2, Pm4::R_DRAW_RESET);
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + 2);
+  return 2;
+}
+
+uint32_t SYSV_ABI sceGnmDrawInitDefaultHardwareState350(uint32_t* cmdOut, uint64_t size) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_DEBUG(L"%S", __FUNCTION__);
+
+  cmdOut[0] = Pm4::create(2, Pm4::R_DRAW_RESET);
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + 2);
+  return 2;
+}
+
+uint32_t SYSV_ABI sceGnmDispatchInitDefaultHardwareState(uint32_t* cmdOut, uint64_t size) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_DEBUG(L"%S", __FUNCTION__);
+
+  cmdOut[0] = Pm4::create(2, Pm4::R_DISPATCH_RESET);
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + 2);
+  return 2;
+}
+
+int SYSV_ABI sceGnmInsertWaitFlipDone(uint32_t* cmdOut, uint64_t size, uint32_t video_out_handle, uint32_t display_buffer_index) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S", __FUNCTION__);
+
+  cmdOut[0] = Pm4::create(size, Pm4::R_WAIT_FLIP_DONE);
+  cmdOut[1] = video_out_handle;
+  cmdOut[2] = display_buffer_index;
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + size);
+  return Ok;
+}
+
+int SYSV_ABI sceGnmDispatchDirect(uint32_t* cmdOut, uint64_t size, uint32_t thread_group_x, uint32_t thread_group_y, uint32_t thread_group_z, uint32_t mode) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S", __FUNCTION__);
+
+  cmdOut[0] = Pm4::create(size, Pm4::R_DISPATCH_DIRECT);
+  cmdOut[1] = thread_group_x;
+  cmdOut[2] = thread_group_y;
+  cmdOut[3] = thread_group_z;
+  cmdOut[4] = mode;
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + size);
+  return Ok;
+}
+
+uint32_t SYSV_ABI sceGnmMapComputeQueue(uint32_t pipe_id, uint32_t queue_id, uint32_t* ring_addr, uint32_t ring_size_dw, uint32_t* read_ptr_addr) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S", __FUNCTION__);
+
+  // todo compute queue (8 commandprocessors with 8 compute rings (total 64))
+  uint32_t const v = pipe_id * 8 + queue_id;
+  *read_ptr_addr   = 0;
+  return v + 1;
+}
+
+int SYSV_ABI sceGnmComputeWaitOnAddress(uint32_t* cmdOut, uint64_t size, uint32_t* gpu_addr, uint32_t mask, uint32_t func, uint32_t ref) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S", __FUNCTION__);
+
+  cmdOut[0] = Pm4::create(size, Pm4::R_DISPATCH_WAIT_MEM);
+  cmdOut[1] = static_cast<uint32_t>(reinterpret_cast<uint64_t>(gpu_addr) & 0xffffffffu);
+  cmdOut[2] = static_cast<uint32_t>((reinterpret_cast<uint64_t>(gpu_addr) >> 32u) & 0xffffffffu);
+  cmdOut[3] = mask;
+  cmdOut[4] = func;
+  cmdOut[5] = ref;
+  return Ok;
+}
+
+void SYSV_ABI sceGnmDingDong(uint32_t ring_id, uint32_t offset_dw) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S", __FUNCTION__);
+
+  // todo dingdong (cumpute ring)
+}
+
+void SYSV_ABI sceGnmUnmapComputeQueue(uint32_t id) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S", __FUNCTION__);
+
+  // todo unmap (abort?)
+}
+
+int SYSV_ABI sceGnmInsertPushMarker(uint32_t* cmdOut, uint64_t size, const char* str) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S", __FUNCTION__);
+
+  auto const len = strlen(str) + 1;
+  cmdOut[0]      = Pm4::create(size, Pm4::R_PUSH_MARKER);
+  // memcpy(cmdOut + 1, str, len);
+
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + size);
+  return Ok;
+}
+
+int SYSV_ABI sceGnmInsertPopMarker(uint32_t* cmdOut, uint64_t size) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S", __FUNCTION__);
+
+  cmdOut[0] = Pm4::create(size, Pm4::R_POP_MARKER);
+  accessVideoOut().getGraphics()->updateCmdBuffer(((uint64_t)cmdOut) + size);
+  return Ok;
+}
+
+uint64_t SYSV_ABI sceGnmGetGpuCoreClockFrequency() {
+  return 0x800000000;
+}
+
+int SYSV_ABI sceGnmIsUserPaEnabled() {
+  return 0;
+}
+
+void* SYSV_ABI sceGnmGetTheTessellationFactorRingBufferBaseAddress() {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S", __FUNCTION__);
+
+  return 0; // Maps/allocates it afterwards anyway
+}
+
+// ####   Only used for tracing ########
+// #####################################
+
+int SYSV_ABI sceGnmRegisterOwner(uint32_t* owner_handle, const char* name) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S", __FUNCTION__);
+
+  // Objects::GpuMemoryRegisterOwner(owner_handle, name);
+  return Ok;
+}
+
+int SYSV_ABI sceGnmRegisterResource(uint32_t* resource_handle, uint32_t owner_handle, const void* memory, size_t size, const char* name, uint32_t type,
+                                    uint64_t user_data) {
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_TRACE(L"%S", __FUNCTION__);
+  uint32_t rhandle = 0;
+  // Objects::GpuMemoryRegisterResource(&rhandle, owner_handle, memory, size, name, type, user_data);
+  if (resource_handle != nullptr) {
+    *resource_handle = rhandle;
+  }
+
+  return Err::FAILURE;
+}
+
+int SYSV_ABI sceGnmUnregisterAllResourcesForOwner(uint32_t owner_handle) {
+  return Ok;
+}
+
+int SYSV_ABI sceGnmUnregisterOwnerAndResources(uint32_t owner_handle) {
+  return Ok;
+}
+
+int SYSV_ABI sceGnmUnregisterResource(uint32_t resource_handle) {
+  return Ok;
+}
+// - tracing
+// #####################################
+
+int SYSV_ABI sceGnmAddEqEvent(Kernel::EventQueue::KernelEqueue* eq, int id, void* udata) {
+  Kernel::EventQueue::KernelEqueueEvent event = {.triggered = false,
+                                                 .event =
+                                                     {
+                                                         .ident  = id,
+                                                         .filter = Kernel::EventQueue::KERNEL_EVFILT_GRAPHICS,
+                                                         .flags  = Kernel::EventQueue::EventFlags::EV_CLEAR,
+                                                         .fflags = 0,
+                                                         .data   = 0,
+                                                         .udata  = udata,
+
+                                                     },
+                                                 .filter {
+                                                     .data              = nullptr,
+                                                     .trigger_func      = event_trigger_func,
+                                                     .reset_func        = event_reset_func,
+                                                     .delete_event_func = event_delete_func,
+                                                 }};
+
+  return accessVideoOut().getGraphics()->addEvent(event, eq);
+}
+
+int SYSV_ABI sceGnmDeleteEqEvent(Kernel::EventQueue::KernelEqueue* eq, int id) {
+  accessVideoOut().getGraphics()->removeEvent(eq, id);
+  return Ok;
+}
+
+void SYSV_ABI sceGnmInsertSetMarker(const char* debugString) {}
+void SYSV_ABI sceGnmInsertSetColorMarker(const char* debugString, uint32_t argbColor) {}
+
+SceWorkloadStatus SYSV_ABI sceGnmCreateWorkloadStream(const char* name, SceWorkloadStream* stream) {
+  static int32_t count = 0;
+  *stream              = ++count;
+  LOG_USE_MODULE(libSceGraphicsDriver);
+  LOG_DEBUG(L"+workloadstream %S -> id:%d", name, *stream);
+  return SceWorkloadStatus::StatusOk;
+}
+
+SceWorkloadStatus SYSV_ABI sceGnmBeginWorkload(SceWorkloadStream stream, uint64_t* workload) {
+  static int32_t count = 0;
+  *workload            = ++count;
+  return SceWorkloadStatus::StatusOk;
+}
+SceWorkloadStatus SYSV_ABI sceGnmEndWorkload(uint64_t workload) {
+  return SceWorkloadStatus::StatusOk;
+}
+SceWorkloadStatus SYSV_ABI sceGnmDestroyWorkloadStream(SceWorkloadStream workloadStream) {
+  return SceWorkloadStatus::StatusOk;
+}
+}
--- a/modules/libSceGraphicsDriver/types.h
+++ b/modules/libSceGraphicsDriver/types.h
@ -0,0 +1,15 @@
+#pragma once
+#include "codes.h"
+
+enum class SceWorkloadStatus : uint32_t {
+  StatusOk                 = 0, ///< The operation was performed successfully.
+  StatusInvalidStream      = 1, ///< The stream parameter was invalid.
+  StatusInvalidWorkload    = 2, ///< The workload parameter was invalid.
+  StatusInvalidPointer     = 3, ///< The required pointer argument was not set.
+  StatusTooManyStreams     = 4, ///< The maximum number of streams has already been allocated.
+  StatusTooManyWorkloads   = 5, ///< The maximum number of active workloads for a stream has been reached.
+  StatusStreamNotAllocated = 6, ///< The stream to be destroyed was not created.
+  StatusInternalError      = 7, ///< The system was unable to perform the work.
+};
+
+typedef uint32_t SceWorkloadStream;
--- a/modules/libSceHttp/CMakeLists.txt
+++ b/modules/libSceHttp/CMakeLists.txt
@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceHttp)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp)
+
+setupModule(${libName})
--- a/modules/libSceHttp/codes.h
+++ b/modules/libSceHttp/codes.h
@ -0,0 +1,21 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {
+constexpr int32_t RESOLVER_TIMEOUT    = (0);
+constexpr int32_t RESOLVER_RETRY      = (0);
+constexpr int32_t CONNECT_TIMEOUT     = (30 * 1000 * 1000U);
+constexpr int32_t SEND_TIMEOUT        = (120 * 1000 * 1000U);
+constexpr int32_t RECV_TIMEOUT        = (120 * 1000 * 1000U);
+constexpr int32_t RECV_BLOCK_SIZE     = (1500U);
+constexpr int32_t RESPONSE_HEADER_MAX = (5000U);
+constexpr int32_t REDIRECT_MAX        = (6U);
+constexpr int32_t TRY_AUTH_MAX        = (6U);
+} // namespace Err
+
+constexpr uint32_t SCE_HTTP_TRUE              = (int)(1);
+constexpr uint32_t SCE_HTTP_FALSE             = (int)(0);
+constexpr uint32_t SCE_HTTP_ENABLE            = SCE_HTTP_TRUE;
+constexpr uint32_t SCE_HTTP_DISABLE           = SCE_HTTP_FALSE;
+constexpr uint32_t SCE_HTTP_USERNAME_MAX_SIZE = 256;
+constexpr uint32_t SCE_HTTP_PASSWORD_MAX_SIZE = 256;
--- a/modules/libSceHttp/entry.cpp
+++ b/modules/libSceHttp/entry.cpp
@ -0,0 +1,207 @@
+#include "../libSceSsl/types.h"
+#include "common.h"
+#include "httpsTypes.h"
+#include "types.h"
+#include "utility/utility.h"
+
+#include <logging.h>
+
+LOG_DEFINE_MODULE(libSceHttp);
+
+namespace {
+using SceHttpsCallback = SYSV_ABI int (*)(int libsslCtxId, unsigned int verifyErr, SceSslCert* const sslCert[], int certNum, void* userArg);
+
+} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceHttp";
+
+EXPORT SYSV_ABI int sceHttpInit(int libnetMemId, int libsslCtxId, size_t poolSize) {
+  static int id = 0;
+  return ++id;
+}
+EXPORT SYSV_ABI int sceHttpTerm(int libhttpCtxId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpGetMemoryPoolStats(int libhttpCtxId, SceHttpMemoryPoolStats* currentStat) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpCreateTemplate(int libhttpCtxId, const char* userAgent, int httpVer, int isAutoProxyConf) {
+  static int id = 0;
+  return ++id;
+}
+EXPORT SYSV_ABI int sceHttpDeleteTemplate(int tmplId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpCreateConnection(int tmplId, const char* serverName, const char* scheme, uint16_t port, int isEnableKeepalive) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpCreateConnectionWithURL(int tmplId, const char* url, int isEnableKeepalive) {
+  static int id = 0;
+  // return ++id;
+  return Err::CONNECT_TIMEOUT;
+}
+EXPORT SYSV_ABI int sceHttpDeleteConnection(int connId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpCreateRequest(int connId, int method, const char* path, uint64_t contentLength) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpCreateRequest2(int connId, const char* method, const char* path, uint64_t contentLength) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpCreateRequestWithURL(int connId, int method, const char* url, uint64_t contentLength) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpCreateRequestWithURL2(int connId, const char* method, const char* url, uint64_t contentLength) {
+  return Err::SEND_TIMEOUT;
+}
+EXPORT SYSV_ABI int sceHttpDeleteRequest(int reqId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpSetRequestContentLength(int id, uint64_t contentLength) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpSetChunkedTransferEnabled(int id, int isEnable) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpSetInflateGZIPEnabled(int id, int isEnable) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpSendRequest(int reqId, const void* postData, size_t size) {
+  return Err::SEND_TIMEOUT;
+}
+EXPORT SYSV_ABI int sceHttpAbortRequest(int reqId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpGetResponseContentLength(int reqId, int* result, uint64_t* contentLength) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpGetStatusCode(int reqId, int* statusCode) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpGetAllResponseHeaders(int reqId, char** header, size_t* headerSize) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpReadData(int reqId, void* data, size_t size) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpAddRequestHeader(int id, const char* name, const char* value, uint32_t mode) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpRemoveRequestHeader(int id, const char* name) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpParseResponseHeader(const char* header, size_t headerLen, const char* fieldStr, const char** fieldValue, size_t* valueLen) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpParseStatusLine(const char* statusLine, size_t lineLen, int* httpMajorVer, int* httpMinorVer, int* responseCode,
+                                           const char** reasonPhrase, size_t* phraseLen) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpSetResponseHeaderMaxSize(int id, size_t headerSize) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpSetAuthInfoCallback(int id, SceHttpAuthInfoCallback cbfunc, void* userArg) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpSetAuthEnabled(int id, int isEnable) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpGetAuthEnabled(int id, int* isEnable) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpAuthCacheFlush(int libhttpCtxId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpSetRedirectCallback(int id, SceHttpRedirectCallback cbfunc, void* userArg) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpSetAutoRedirect(int id, int isEnable) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpGetAutoRedirect(int id, int* isEnable) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpRedirectCacheFlush(int libhttpCtxId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpSetResolveTimeOut(int id, uint32_t usec) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpSetResolveRetry(int id, int retry) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpSetConnectTimeOut(int id, uint32_t usec) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpSetSendTimeOut(int id, uint32_t usec) {
+  return Err::SEND_TIMEOUT;
+}
+EXPORT SYSV_ABI int sceHttpSetRecvTimeOut(int id, uint32_t usec) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpSetRequestStatusCallback(int id, SceHttpRequestStatusCallback cbfunc, void* userArg) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpGetLastErrno(int reqId, int* errNum) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpSetNonblock(int id, int isEnable) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpGetNonblock(int id, int* isEnable) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpTrySetNonblock(int id, int isEnable) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpTryGetNonblock(int id, int* isEnable) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpCreateEpoll(int libhttpCtxId, SceHttpEpollHandle* eh) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpSetEpoll(int id, SceHttpEpollHandle eh, void* userArg) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpUnsetEpoll(int id) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpGetEpoll(int id, SceHttpEpollHandle* eh, void** userArg) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpDestroyEpoll(int libhttpCtxId, SceHttpEpollHandle eh) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpWaitRequest(SceHttpEpollHandle eh, SceHttpNBEvent* nbev, int maxevents, int timeout) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpAbortWaitRequest(SceHttpEpollHandle eh) {
+  return Ok;
+}
+
+// HTTPS
+EXPORT SYSV_ABI int sceHttpsLoadCert(int libhttpCtxId, int caCertNum, const SceSslData** caList, const SceSslData* cert, const SceSslData* privKey) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpsUnloadCert(int libhttpCtxId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpsEnableOption(int id, uint32_t sslFlags) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpsDisableOption(int id, uint32_t sslFlags) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpsGetSslError(int id, int* errNum, uint32_t* detail) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpsSetSslCallback(int id, SceHttpsCallback cbfunc, void* userArg) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceHttpsSetSslVersion(int id, SceSslVersion version) {
+  return Ok;
+}
+}
--- a/modules/libSceHttp/httpsTypes.h
+++ b/modules/libSceHttp/httpsTypes.h
@ -0,0 +1,15 @@
+#pragma once
+
+enum class SceHttpsFlags : unsigned int {
+  SERVER_VERIFY    = 0x01U, // Server Certificate Verify
+  CLIENT_VERIFY    = 0x02U, // Client Certificate Verify
+  CN_CHECK         = 0x04U, // Common Name Check
+  NOT_AFTER_CHECK  = 0x08U, // Not Valid After Check
+  NOT_BEFORE_CHECK = 0x10U, // Not Valid Before Check
+  KNOWN_CA_CHECK   = 0x20U, // Known CA Check
+  SESSION_REUSE    = 0x40U, // Session Reuse
+  SNI              = 0x80U  // Server Name Indication (SNI)
+
+};
+
+enum class SceHttpSslVersion { SSLV23, SSLV2, SSLV3, TLSV1 };
--- a/modules/libSceHttp/types.h
+++ b/modules/libSceHttp/types.h
@ -0,0 +1,60 @@
+#pragma once
+#include "codes.h"
+#include "utility/utility.h"
+
+enum class SceHttpEvent : unsigned int {
+  NB_EVENT_IN           = 0x00000001, // IN
+  NB_EVENT_OUT          = 0x00000002, // OUT
+  NB_EVENT_SOCK_ERR     = 0x00000008, // SOCK_ERROR
+  NB_EVENT_HUP          = 0x00000010, // HUP
+  NB_EVENT_ICM          = 0x00000020, // ICM Event
+  NB_EVENT_RESOLVED     = 0x00010000, // Resolved
+  NB_EVENT_RESOLVER_ERR = 0x00020000, // Resolver Error
+
+};
+
+enum classSceHttpHttpVersion { SCE_HTTP_VERSION_1_0 = 1, SCE_HTTP_VERSION_1_1 };
+
+enum classSceHttpProxyMode { SCE_HTTP_PROXY_AUTO, SCE_HTTP_PROXY_MANUAL };
+
+enum classSceHttpAddHeaderMode { SCE_HTTP_HEADER_OVERWRITE, SCE_HTTP_HEADER_ADD };
+
+enum class SceHttpAuthType { SCE_HTTP_AUTH_BASIC, SCE_HTTP_AUTH_DIGEST, SCE_HTTP_AUTH_RESERVED0, SCE_HTTP_AUTH_RESERVED1, SCE_HTTP_AUTH_RESERVED2 };
+
+enum class SceHttpContentLengthType { SCE_HTTP_CONTENTLEN_EXIST, SCE_HTTP_CONTENTLEN_NOT_FOUND, SCE_HTTP_CONTENTLEN_CHUNK_ENC };
+
+enum class SceHttpRequestStatus {
+  SCE_HTTP_REQUEST_STATUS_CONNECTION_RESERVED,
+  SCE_HTTP_REQUEST_STATUS_RESOLVING_NAME,
+  SCE_HTTP_REQUEST_STATUS_NAME_RESOLVED,
+  SCE_HTTP_REQUEST_STATUS_CONNECTING,
+  SCE_HTTP_REQUEST_STATUS_CONNECTED,
+  SCE_HTTP_REQUEST_STATUS_TLS_CONNECTING,
+  SCE_HTTP_REQUEST_STATUS_TLS_CONNECTED,
+  SCE_HTTP_REQUEST_STATUS_SENDING_REQUEST,
+  SCE_HTTP_REQUEST_STATUS_REQUEST_SENT,
+  SCE_HTTP_REQUEST_STATUS_RECEIVING_HEADER,
+  SCE_HTTP_REQUEST_STATUS_HEADER_RECEIVED,
+};
+
+using SceHttpAuthInfoCallback = SYSV_ABI int (*)(int request, SceHttpAuthType authType, const char* realm, char* username, char* password, int isNeedEntity,
+                                                 uint8_t** entityBody, size_t* entitySize, int* isSave, void* userArg);
+
+using SceHttpRedirectCallback = SYSV_ABI int (*)(int request, int32_t statusCode, int32_t* method, const char* location, void* userArg);
+
+using SceHttpRequestStatusCallback = SYSV_ABI void (*)(int request, SceHttpRequestStatus requestStatus, void* userArg);
+
+typedef void* SceHttpEpollHandle;
+
+struct SceHttpMemoryPoolStats {
+  size_t poolSize;
+  size_t maxInuseSize;
+  size_t currentInuseSize;
+};
+
+struct SceHttpNBEvent {
+  uint32_t events;
+  uint32_t eventDetail;
+  int      id;
+  void*    userArg;
+};
--- a/modules/libSceIme/CMakeLists.txt
+++ b/modules/libSceIme/CMakeLists.txt
@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceIme)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp)
+
+setupModule(${libName})
--- a/modules/libSceIme/codes.h
+++ b/modules/libSceIme/codes.h
@ -0,0 +1,52 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {
+constexpr int32_t BUSY                         = -2135162879;
+constexpr int32_t NOT_OPENED                   = -2135162878;
+constexpr int32_t NO_MEMORY                    = -2135162877;
+constexpr int32_t CONNECTION_FAILED            = -2135162876;
+constexpr int32_t TOO_MANY_REQUESTS            = -2135162875;
+constexpr int32_t INVALID_TEXT                 = -2135162874;
+constexpr int32_t EVENT_OVERFLOW               = -2135162873;
+constexpr int32_t NOT_ACTIVE                   = -2135162872;
+constexpr int32_t IME_SUSPENDING               = -2135162871;
+constexpr int32_t DEVICE_IN_USE                = -2135162870;
+constexpr int32_t INVALID_USER_ID              = -2135162864;
+constexpr int32_t INVALID_TYPE                 = -2135162863;
+constexpr int32_t INVALID_SUPPORTED_LANGUAGES  = -2135162862;
+constexpr int32_t INVALID_ENTER_LABEL          = -2135162861;
+constexpr int32_t INVALID_INPUT_METHOD         = -2135162860;
+constexpr int32_t INVALID_OPTION               = -2135162859;
+constexpr int32_t INVALID_MAX_TEXT_LENGTH      = -2135162858;
+constexpr int32_t INVALID_INPUT_TEXT_BUFFER    = -2135162857;
+constexpr int32_t INVALID_POSX                 = -2135162856;
+constexpr int32_t INVALID_POSY                 = -2135162855;
+constexpr int32_t INVALID_HORIZONTAL_ALIGNMENT = -2135162854;
+constexpr int32_t INVALID_VERTICAL_ALIGNMENT   = -2135162853;
+constexpr int32_t INVALID_EXTENDED             = -2135162852;
+constexpr int32_t INVALID_KEYBOARD_TYPE        = -2135162851;
+constexpr int32_t INVALID_WORK                 = -2135162848;
+constexpr int32_t INVALID_ARG                  = -2135162847;
+constexpr int32_t INVALID_HANDLER              = -2135162846;
+constexpr int32_t NO_RESOURCE_ID               = -2135162845;
+constexpr int32_t INVALID_MODE                 = -2135162844;
+constexpr int32_t INVALID_PARAM                = -2135162832;
+constexpr int32_t INVALID_ADDRESS              = -2135162831;
+constexpr int32_t INVALID_RESERVED             = -2135162830;
+constexpr int32_t INVALID_TIMING               = -2135162829;
+constexpr int32_t INTERNAL                     = -2135162625;
+} // namespace Err
+
+constexpr uint32_t SCE_IME_OSK_DISPLAY_SIZE_WIDTH          = 1920;
+constexpr uint32_t SCE_IME_OSK_DISPLAY_SIZE_HEIGHT         = 1080;
+constexpr uint32_t SCE_IME_OSK_OVER_2K_DISPLAY_SIZE_WIDTH  = 3840;
+constexpr uint32_t SCE_IME_OSK_OVER_2K_DISPLAY_SIZE_HEIGHT = 2160;
+constexpr uint32_t SCE_IME_MAX_PREEDIT_LENGTH              = 30;
+constexpr uint32_t SCE_IME_MAX_EXPANDED_PREEDIT_LENGTH     = 120;
+constexpr uint32_t SCE_IME_MAX_TEXT_LENGTH                 = 2048;
+constexpr uint32_t SCE_IME_MAX_TEXT_AREA                   = 4;
+constexpr uint32_t SCE_IME_MAX_CANDIDATE_WORD_LENGTH       = 55;
+constexpr uint32_t SCE_IME_MAX_CANDIDATE_LIST_SIZE         = 100;
+constexpr uint32_t SCE_IME_WORK_BUFFER_SIZE                = 20 * 1024;
+constexpr uint32_t SCE_IME_KEYBOARD_MAX_NUMBER             = 5;
--- a/modules/libSceIme/entry.cpp
+++ b/modules/libSceIme/entry.cpp
@ -0,0 +1,70 @@
+#include "common.h"
+#include "types.h"
+
+#include <logging.h>
+
+LOG_DEFINE_MODULE(libSceIme);
+
+namespace {} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceIme";
+
+EXPORT SYSV_ABI int sceImeOpen(const SceImeParam* param, const SceImeParamExtended* extParam) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceImeUpdate(SceImeEventHandler handler) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceImeSetText(const wchar_t* text, uint32_t length) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceImeSetCaret(const SceImeCaret* caret) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceImeSetTextGeometry(SceImeTextAreaMode mode, const SceImeTextGeometry* geometry) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceImeGetPanelSize(const SceImeParam* param, uint32_t* width, uint32_t* height) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceImeClose(void) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceImeGetPanelPositionAndForm(SceImePositionAndForm* posForm) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceImeSetCandidateIndex(int32_t index) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceImeConfirmCandidate(int32_t index) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceImeDisableController(void) {
+  return Ok;
+}
+EXPORT SYSV_ABI void sceImeParamInit(SceImeParam* param) {}
+EXPORT SYSV_ABI int  sceImeKeyboardOpen(SceUserServiceUserId userId, const SceImeKeyboardParam* param) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceImeKeyboardClose(SceUserServiceUserId userId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceImeKeyboardGetResourceId(SceUserServiceUserId userId, SceImeKeyboardResourceIdArray* resourceIdArray) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceImeKeyboardGetInfo(uint32_t resourceId, SceImeKeyboardInfo* info) {
+  info->userId      = -1;
+  info->device      = SceImeKeyboardDeviceType::KEYBOARD;
+  info->type        = SceImeKeyboardType::ENGLISH_US;
+  info->repeatDelay = 1;
+  info->repeatRate  = 1;
+  info->status      = SceImeKeyboardStatus::DISCONNECTED;
+
+  return Ok;
+}
+EXPORT SYSV_ABI int sceImeKeyboardSetMode(SceUserServiceUserId userId, uint32_t mode) {
+  return Ok;
+}
+}
--- a/modules/libSceIme/types.h
+++ b/modules/libSceIme/types.h
@ -0,0 +1,447 @@
+#pragma once
+#include "common.h"
+#include "codes.h"
+
+enum class SCE_IME_MAX {
+  PREEDIT_LENGTH          = 30,
+  EXPANDED_PREEDIT_LENGTH = 120,
+  TEXT_LENGTH             = 2048,
+  TEXT_AREA               = 4,
+  CANDIDATE_WORD_LENGTH   = 55,
+  CANDIDATE_LIST_SIZE     = 100,
+};
+
+enum class SCE_IME_LANGUAGE : uint64_t {
+  DANISH              = 0x0000000000000001ULL,
+  GERMAN              = 0x0000000000000002ULL,
+  ENGLISH_US          = 0x0000000000000004ULL,
+  SPANISH             = 0x0000000000000008ULL,
+  FRENCH              = 0x0000000000000010ULL,
+  ITALIAN             = 0x0000000000000020ULL,
+  DUTCH               = 0x0000000000000040ULL,
+  NORWEGIAN           = 0x0000000000000080ULL,
+  POLISH              = 0x0000000000000100ULL,
+  PORTUGUESE_PT       = 0x0000000000000200ULL,
+  RUSSIAN             = 0x0000000000000400ULL,
+  FINNISH             = 0x0000000000000800ULL,
+  SWEDISH             = 0x0000000000001000ULL,
+  JAPANESE            = 0x0000000000002000ULL,
+  KOREAN              = 0x0000000000004000ULL,
+  SIMPLIFIED_CHINESE  = 0x0000000000008000ULL,
+  TRADITIONAL_CHINESE = 0x0000000000010000ULL,
+  PORTUGUESE_BR       = 0x0000000000020000ULL,
+  ENGLISH_GB          = 0x0000000000040000ULL,
+  TURKISH             = 0x0000000000080000ULL,
+  SPANISH_LA          = 0x0000000000100000ULL,
+  ARABIC              = 0x0000000001000000ULL,
+  FRENCH_CA           = 0x0000000002000000ULL,
+  THAI                = 0x0000000004000000ULL,
+  CZECH               = 0x0000000008000000ULL,
+  GREEK               = 0x0000000010000000ULL,
+  INDONESIAN          = 0x0000000020000000ULL,
+  VIETNAMESE          = 0x0000000040000000ULL,
+  ROMANIAN            = 0x0000000080000000ULL,
+  HUNGARIAN           = 0x0000000100000000ULL,
+};
+
+enum class SCE_IME_OPTION : uint32_t {
+  DEFAULT                            = 0x00000000,
+  MULTILINE                          = 0x00000001,
+  NO_AUTO_CAPITALIZATION             = 0x00000002,
+  PASSWORD                           = 0x00000004,
+  LANGUAGES_FORCED                   = 0x00000008,
+  EXT_KEYBOARD                       = 0x00000010,
+  NO_LEARNING                        = 0x00000020,
+  FIXED_POSITION                     = 0x00000040,
+  DISABLE_COPY_PASTE                 = 0x00000080,
+  DISABLE_RESUME                     = 0x00000100,
+  DISABLE_AUTO_SPACE                 = 0x00000200,
+  DISABLE_POSITION_ADJUSTMENT        = 0x00000800,
+  EXPANDED_PREEDIT_BUFFER            = 0x00001000,
+  USE_JAPANESE_EISUU_KEY_AS_CAPSLOCK = 0x00002000,
+  USE_OVER_2K_COORDINATES            = 0x00004000,
+};
+
+enum class SCE_IME_EXT_OPTION : uint32_t {
+  OPTION_DEFAULT                             = 0x00000000,
+  OPTION_SET_COLOR                           = 0x00000001,
+  OPTION_SET_PRIORITY                        = 0x00000002,
+  OPTION_PRIORITY_SHIFT                      = 0x00000004,
+  OPTION_PRIORITY_FULL_WIDTH                 = 0x00000008,
+  OPTION_PRIORITY_FIXED_PANEL                = 0x00000010,
+  OPTION_DISABLE_POINTER                     = 0x00000040,
+  OPTION_ENABLE_ADDITIONAL_DICTIONARY        = 0x00000080,
+  OPTION_DISABLE_STARTUP_SE                  = 0x00000100,
+  OPTION_DISABLE_LIST_FOR_EXT_KEYBOARD       = 0x00000200,
+  OPTION_HIDE_KEYPANEL_IF_EXT_KEYBOARD       = 0x00000400,
+  OPTION_INIT_EXT_KEYBOARD_MODE              = 0x00000800,
+  OPTION_ENABLE_ACCESSIBILITY                = 0x00001000,
+  OPTION_ACCESSIBILITY_PANEL_FORCED          = 0x00002000,
+  OPTION_ADDITIONAL_DICTIONARY_PRIORITY_MODE = 0x00004000,
+};
+
+enum class SceImeDisableDevice : uint32_t {
+  DEFAULT      = 0x00000000,
+  CONTROLLER   = 0x00000001,
+  EXT_KEYBOARD = 0x00000002,
+  REMOTE_OSK   = 0x00000004,
+};
+
+enum class SceImeInputMethod : uint32_t {
+  DEFAULT          = 0,
+  STATE_PREEDIT    = 0x01000000,
+  STATE_SELECTED   = 0x02000000,
+  STATE_NATIVE     = 0x04000000,
+  STATE_NATIVE2    = 0x08000000,
+  STATE_FULL_WIDTH = 0x10000000,
+};
+
+enum class SceImeEventId {
+  EVENT_OPEN                      = 0,
+  EVENT_UPDATE_TEXT               = 1,
+  EVENT_UPDATE_CARET              = 2,
+  EVENT_CHANGE_SIZE               = 3,
+  EVENT_PRESS_CLOSE               = 4,
+  EVENT_PRESS_ENTER               = 5,
+  EVENT_ABORT                     = 6,
+  EVENT_CANDIDATE_LIST_START      = 7,
+  EVENT_CANDIDATE_LIST_END        = 8,
+  EVENT_CANDIDATE_WORD            = 9,
+  EVENT_CANDIDATE_INDEX           = 10,
+  EVENT_CANDIDATE_DONE            = 11,
+  EVENT_CANDIDATE_CANCEL          = 12,
+  EVENT_CHANGE_DEVICE             = 14,
+  EVENT_JUMP_TO_NEXT_OBJECT       = 15,
+  EVENT_JUMP_TO_BEFORE_OBJECT     = 16,
+  EVENT_CHANGE_WINDOW_TYPE        = 17,
+  EVENT_CHANGE_INPUT_METHOD_STATE = 18,
+  KEYBOARD_EVENT_OPEN             = 256,
+  KEYBOARD_EVENT_KEYCODE_DOWN     = 257,
+  KEYBOARD_EVENT_KEYCODE_UP       = 258,
+  KEYBOARD_EVENT_KEYCODE_REPEAT   = 259,
+  KEYBOARD_EVENT_CONNECTION       = 260,
+  KEYBOARD_EVENT_DISCONNECTION    = 261,
+  KEYBOARD_EVENT_ABORT            = 262,
+};
+
+enum class SceImeHorizontalAlignment {
+  LEFT   = 0,
+  CENTER = 1,
+  RIGHT  = 2,
+};
+
+enum class SceImeVerticalAlignment {
+  TOP    = 0,
+  CENTER = 1,
+  BOTTOM = 2,
+};
+
+enum class SceImeEnterLabel {
+  DEFAULT = 0,
+  SEND    = 1,
+  SEARCH  = 2,
+  GO      = 3,
+};
+
+enum class SceImeType {
+  DEFAULT     = 0,
+  BASIC_LATIN = 1,
+  URL         = 2,
+  MAIL        = 3,
+  NUMBER      = 4,
+};
+
+enum class SceImePanelPriority {
+  DEFAULT  = 0,
+  ALPHABET = 1,
+  SYMBOL   = 2,
+  ACCENT   = 3,
+};
+
+typedef enum SceImeCaretMovementDirection {
+  MOVE_STILL     = 0,
+  MOVE_LEFT      = 1,
+  MOVE_RIGHT     = 2,
+  MOVE_UP        = 3,
+  MOVE_DOWN      = 4,
+  MOVE_HOME      = 5,
+  MOVE_END       = 6,
+  MOVE_PAGE_UP   = 7,
+  MOVE_PAGE_DOWN = 8,
+  MOVE_TOP       = 9,
+  MOVE_BOTTOM    = 10,
+} SceImeCaretMovementDirection;
+
+enum class SceImeTextAreaMode {
+  DISABLE = 0,
+  EDIT    = 1,
+  PREEDIT = 2,
+  SELECT  = 3,
+};
+
+enum class sceImeKeyboardState : uint32_t {
+  KEYCODE_VALID      = 0x00000001,
+  CHARACTER_VALID    = 0x00000002,
+  WITH_IME           = 0x00000004,
+  FROM_OSK           = 0x00000008,
+  FROM_OSK_SHORTCUT  = 0x00000010,
+  FROM_IME_OPERATION = 0x00000020,
+  REPLACE_CHARACTER  = 0x00000040,
+  CONTINUOUS_EVENT   = 0x00000080,
+  MODIFIER_L_CTRL    = 0x00000100,
+  MODIFIER_L_SHIFT   = 0x00000200,
+  MODIFIER_L_ALT     = 0x00000400,
+  MODIFIER_L_GUI     = 0x00000800,
+  MODIFIER_R_CTRL    = 0x00001000,
+  MODIFIER_R_SHIFT   = 0x00002000,
+  MODIFIER_R_ALT     = 0x00004000,
+  MODIFIER_R_GUI     = 0x00008000,
+  LED_NUM_LOCK       = 0x00010000,
+  LED_CAPS_LOCK      = 0x00020000,
+  LED_SCROLL_LOCK    = 0x00040000,
+  RESERVED1          = 0x00080000,
+  RESERVED2          = 0x00100000,
+  FROM_IME_INPUT     = 0x00200000,
+};
+
+enum class sceImeKeyboardOption : uint32_t {
+  DEFAULT                        = 0x00000000,
+  REPEAT                         = 0x00000001,
+  REPEAT_EACH_KEY                = 0x00000002,
+  ADD_OSK                        = 0x00000004,
+  EFFECTIVE_WITH_IME             = 0x00000008,
+  DISABLE_RESUME                 = 0x00000010,
+  DISABLE_CAPSLOCK_WITHOUT_SHIFT = 0x00000020,
+};
+
+enum class sceImeKeyboardMode : uint32_t {
+  AUTO                      = 0x00000000,
+  MANUAL                    = 0x00000001,
+  ALPHABET                  = 0x00000000,
+  NATIVE                    = 0x00000002,
+  PART                      = 0x00000004,
+  KATAKANA                  = 0x00000008,
+  HKANA                     = 0x00000010,
+  ARABIC_INDIC_NUMERALS     = 0x00000020,
+  DISABLE_FORMAT_CHARACTERS = 0x00000040,
+};
+
+enum class sceImeKeyboardResourceId : uint32_t {
+  ID_INVALID = 0x00000000,
+  ID_OSK     = 0x00000001,
+};
+
+enum class SceImeKeyboardStatus { DISCONNECTED = 0, CONNECTED = 1 };
+
+enum class SceImeKeyboardType {
+  NONE             = 0,
+  DANISH           = 1,
+  GERMAN           = 2,
+  GERMAN_SW        = 3,
+  ENGLISH_US       = 4,
+  ENGLISH_GB       = 5,
+  SPANISH          = 6,
+  SPANISH_LA       = 7,
+  FINNISH          = 8,
+  FRENCH           = 9,
+  FRENCH_BR        = 10,
+  FRENCH_CA        = 11,
+  FRENCH_SW        = 12,
+  ITALIAN          = 13,
+  DUTCH            = 14,
+  NORWEGIAN        = 15,
+  POLISH           = 16,
+  PORTUGUESE_BR    = 17,
+  PORTUGUESE_PT    = 18,
+  RUSSIAN          = 19,
+  SWEDISH          = 20,
+  TURKISH          = 21,
+  JAPANESE_ROMAN   = 22,
+  JAPANESE_KANA    = 23,
+  KOREAN           = 24,
+  SM_CHINESE       = 25,
+  TR_CHINESE_ZY    = 26,
+  TR_CHINESE_PY_HK = 27,
+  TR_CHINESE_PY_TW = 28,
+  TR_CHINESE_CG    = 29,
+  ARABIC_AR        = 30,
+  THAI             = 31,
+  CZECH            = 32,
+  GREEK            = 33,
+  INDONESIAN       = 34,
+  VIETNAMESE       = 35,
+  ROMANIAN         = 36,
+  HUNGARIAN        = 37,
+};
+
+enum class SceImeKeyboardDeviceType {
+  KEYBOARD = 0,
+  OSK      = 1,
+};
+
+enum class SceImePanelType {
+  HIDE               = 0,
+  OSK                = 1,
+  DIALOG             = 2,
+  CANDIDATE          = 3,
+  EDIT               = 4,
+  EDIT_AND_CANDIDATE = 5,
+  ACCESSIBILITY      = 6,
+};
+
+enum class SceImeDeviceType {
+  NONE         = 0,
+  CONTROLLER   = 1,
+  EXT_KEYBOARD = 2,
+  REMOTE_OSK   = 3,
+};
+
+struct SceImeTextAreaProperty {
+  SceImeTextAreaMode mode;
+  uint32_t           index;
+  int32_t            length;
+};
+
+struct SceImeEditText {
+  wchar_t*               str;
+  uint32_t               caretIndex;
+  uint32_t               areaNum;
+  SceImeTextAreaProperty textArea[SCE_IME_MAX_TEXT_AREA];
+};
+
+struct SceImePositionAndForm {
+  SceImePanelType           type;
+  float                     posx;
+  float                     posy;
+  SceImeHorizontalAlignment horizontalAlignment;
+  SceImeVerticalAlignment   verticalAlignment;
+  uint32_t                  width;
+  uint32_t                  height;
+};
+
+struct SceImeRect {
+  float    x;
+  float    y;
+  uint32_t width;
+  uint32_t height;
+};
+
+struct SceImeTextGeometry {
+  float    x;
+  float    y;
+  uint32_t width;
+  uint32_t height;
+};
+
+struct SceImeCaret {
+  float    x;
+  float    y;
+  uint32_t height;
+  uint32_t index;
+};
+
+struct SceImeColor {
+  uint8_t r;
+  uint8_t g;
+  uint8_t b;
+  uint8_t a;
+};
+
+struct SceImeKeyboardInfo {
+  SceUserServiceUserId     userId;
+  SceImeKeyboardDeviceType device;
+  SceImeKeyboardType       type;
+  uint32_t                 repeatDelay;
+  uint32_t                 repeatRate;
+  SceImeKeyboardStatus     status;
+  int8_t                   reserved[12];
+};
+
+struct SceImeKeyboardResourceIdArray {
+  SceUserServiceUserId userId;
+  uint32_t             resourceId[SCE_IME_KEYBOARD_MAX_NUMBER];
+};
+
+struct SceImeKeycode {
+  uint16_t             keycode;
+  wchar_t              character;
+  uint32_t             status;
+  SceImeKeyboardType   type;
+  SceUserServiceUserId userId;
+  uint32_t             resourceId;
+  SceRtcTick           timestamp;
+};
+
+union SceImeEventParam {
+  SceImeRect                    rect;
+  SceImeEditText                text;
+  SceImeCaretMovementDirection  caretMove;
+  SceImeKeycode                 keycode;
+  SceImeKeyboardResourceIdArray resourceIdArray;
+  wchar_t*                      candidateWord;
+  int32_t                       candidateIndex;
+  SceImeDeviceType              deviceType;
+  SceImePanelType               panelType;
+  uint32_t                      inputMethodState;
+  int8_t                        reserved[64];
+};
+
+struct SceImeEvent {
+  SceImeEventId    id;
+  SceImeEventParam param;
+};
+
+typedef void (*SceImeEventHandler)(void* arg, const SceImeEvent* e);
+typedef int32_t (*SceImeTextFilter)(wchar_t* outText, uint32_t* outTextLength, const wchar_t* srcText, uint32_t srcTextLength);
+typedef int (*SceImeExtKeyboardFilter)(const SceImeKeycode* srcKeycode, uint16_t* outKeycode, uint32_t* outStatus, void* reserved);
+
+struct SceImeParam {
+  SceUserServiceUserId      userId;
+  SceImeType                type;
+  uint64_t                  supportedLanguages;
+  SceImeEnterLabel          enterLabel;
+  SceImeInputMethod         inputMethod;
+  SceImeTextFilter          filter;
+  uint32_t                  option;
+  uint32_t                  maxTextLength;
+  wchar_t*                  inputTextBuffer;
+  float                     posx;
+  float                     posy;
+  SceImeHorizontalAlignment horizontalAlignment;
+  SceImeVerticalAlignment   verticalAlignment;
+  void*                     work;
+  void*                     arg;
+  SceImeEventHandler        handler;
+  int8_t                    reserved[8];
+};
+
+struct SceImeParamExtended {
+  uint32_t                option;
+  SceImeColor             colorBase;
+  SceImeColor             colorLine;
+  SceImeColor             colorTextField;
+  SceImeColor             colorPreedit;
+  SceImeColor             colorButtonDefault;
+  SceImeColor             colorButtonFunction;
+  SceImeColor             colorButtonSymbol;
+  SceImeColor             colorText;
+  SceImeColor             colorSpecial;
+  SceImePanelPriority     priority;
+  const char*             additionalDictionaryPath;
+  SceImeExtKeyboardFilter extKeyboardFilter;
+  uint32_t                disableDevice;
+  uint32_t                extKeyboardMode;
+  int8_t                  reserved[60];
+};
+struct SceImeKeyboardParam {
+  uint32_t           option;
+  int8_t             reserved1[4];
+  void*              arg;
+  SceImeEventHandler handler;
+  int8_t             reserved2[8];
+};
+
+struct SceImeKeyboardResourceId {
+  SceUserServiceUserId userId;
+  uint32_t             resourceId[SCE_IME_KEYBOARD_MAX_NUMBER];
+};
--- a/modules/libSceMouse/CMakeLists.txt
+++ b/modules/libSceMouse/CMakeLists.txt
@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceMouse)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp)
+
+setupModule(${libName})
--- a/modules/libSceMouse/codes.h
+++ b/modules/libSceMouse/codes.h
@ -0,0 +1,15 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {
+constexpr int32_t ERROR_INVALID_ARG          = -2132869119;
+constexpr int32_t ERROR_INVALID_PORT         = -2132869118;
+constexpr int32_t ERROR_INVALID_HANDLE       = -2132869117;
+constexpr int32_t ERROR_ALREADY_OPENED       = -2132869116;
+constexpr int32_t ERROR_NOT_INITIALIZED      = -2132869115;
+constexpr int32_t ERROR_DEVICE_NOT_CONNECTED = -2132869113;
+constexpr int32_t ERROR_FATAL                = -2132868865;
+} // namespace Err
+
+constexpr uint8_t SCE_MOUSE_PORT_TYPE_STANDARD      = 0; /* standard mouse */
+constexpr uint8_t SCE_MOUSE_MAX_STANDARD_PORT_INDEX = 2; /* max index of standard mouse */
--- a/modules/libSceMouse/entry.cpp
+++ b/modules/libSceMouse/entry.cpp
@ -0,0 +1,27 @@
+#include "common.h"
+#include "types.h"
+
+#include <logging.h>
+
+LOG_DEFINE_MODULE(libSceMouse);
+
+namespace {} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceMouse";
+
+EXPORT SYSV_ABI int sceMouseInit(void) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceMouseOpen(SceUserServiceUserId userId, int32_t type, int32_t index, const SceMouseOpenParam* pParam) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceMouseClose(int32_t handle) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceMouseRead(int32_t handle, SceMouseData* pData, int32_t num) {
+  pData[0] = SceMouseData();
+  return 1;
+}
+}
--- a/modules/libSceMouse/types.h
+++ b/modules/libSceMouse/types.h
@ -0,0 +1,28 @@
+#pragma once
+#include "codes.h"
+
+enum class MouseButton : uint32_t {
+  PRIMARY     = 0x00000001,
+  SECONDARY   = 0x00000002,
+  OPTIONAL    = 0x00000004,
+  OPTIONAL2   = 0x00000008,
+  OPTIONAL3   = 0x00000010,
+  INTERCEPTED = 0x80000000
+
+};
+
+typedef struct SceMouseData {
+  uint64_t timestamp = 0;     /*E System timestamp of this data(micro seconds). */
+  bool     connected = false; /*E Mouse connection status. true:connected  false:removed */
+  uint32_t buttons   = 0;     /*E Mouse buttons information */
+  int32_t  xAxis     = 0;     /*E Amount of movement in the x direction */
+  int32_t  yAxis     = 0;     /*E Amount of movement in the y direction */
+  int32_t  wheel     = 0;     /*E Amount of wheel movement */
+  int32_t  tilt      = 0;     /*E Amount of tilt movement (only for a mouse that supports a tilt wheel) */
+  uint8_t  reserve[8];        /*E Reserved */
+} SceMouseData;
+
+typedef struct SceMouseOpenParam {
+  uint8_t behaviorFlag; /*E Behavior flag */
+  uint8_t reserve[7];   /*E Reserved */
+} SceMouseOpenParam;
--- a/modules/libSceMove/CMakeLists.txt
+++ b/modules/libSceMove/CMakeLists.txt
@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceMove)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp)
+
+setupModule(${libName})
--- a/modules/libSceMove/codes.h
+++ b/modules/libSceMove/codes.h
@ -0,0 +1,16 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {
+constexpr int32_t ERROR_NOT_INIT                 = -2131886079; // 0x80EE0001
+constexpr int32_t ERROR_ALREADY_INIT             = -2131886078; // 0x80EE0002
+constexpr int32_t ERROR_INVALID_ARG              = -2131886077; // 0x80EE0003
+constexpr int32_t ERROR_INVALID_HANDLE           = -2131886076; // 0x80EE0004
+constexpr int32_t ERROR_MAX_CONTROLLERS_EXCEEDED = -2131886075; // 0x80EE0005
+constexpr int32_t ERROR_INVALID_PORT             = -2131886074; // 0x80EE0006
+constexpr int32_t ERROR_ALREADY_OPENED           = -2131886073; // 0x80EE0007
+constexpr int32_t ERROR_FATAL                    = -2131885825; // 0x80EE00FF
+} // namespace Err
+
+constexpr uint8_t SCE_MOVE_MAX_CONTROLLERS            = 4; ///< Maximum number of motion controllers.
+constexpr uint8_t SCE_MOVE_MAX_CONTROLLERS_PER_PLAYER = 2; ///< Maximum number of motion controllers that can be bound to a player.
--- a/modules/libSceMove/entry.cpp
+++ b/modules/libSceMove/entry.cpp
@ -0,0 +1,50 @@
+#include "common.h"
+#include "types.h"
+
+#include <logging.h>
+
+LOG_DEFINE_MODULE(libSceMove);
+
+namespace {} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceMove";
+
+EXPORT SYSV_ABI int sceMoveInit(void) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceMoveTerm(void) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceMoveOpen(SceUserServiceUserId userId, int32_t type, int32_t index) {
+  LOG_USE_MODULE(libSceMove);
+  LOG_DEBUG(L"open userId:%d type:%d index:%d", userId, type, index);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceMoveClose(int32_t handle) {
+  return Ok;
+}
+EXPORT SYSV_ABI RetValues sceMoveReadStateRecent(int32_t handle, int64_t timestamp, SceMoveData* pData, int32_t* pNum) {
+  *pData = SceMoveData();
+  *pNum  = 0;
+  return RetValues::NO_CONTROLLER_CONNECTED;
+}
+EXPORT SYSV_ABI RetValues sceMoveReadStateLatest(int32_t handle, SceMoveData* pData) {
+  *pData = SceMoveData();
+  return RetValues::NO_CONTROLLER_CONNECTED;
+}
+EXPORT SYSV_ABI int sceMoveSetLightSphere(int32_t handle, uint8_t r, uint8_t g, uint8_t b) {
+  return Ok;
+}
+EXPORT SYSV_ABI RetValues sceMoveSetVibration(int32_t handle, uint8_t motor) {
+  return RetValues::NO_CONTROLLER_CONNECTED;
+}
+EXPORT SYSV_ABI RetValues sceMoveGetDeviceInfo(int32_t handle, SceMoveDeviceInfo* pInfo) {
+  *pInfo = SceMoveDeviceInfo();
+  return RetValues::NO_CONTROLLER_CONNECTED;
+}
+EXPORT SYSV_ABI int sceMoveResetLightSphere(int32_t handle) {
+  return Ok;
+}
+}
--- a/modules/libSceMove/types.h
+++ b/modules/libSceMove/types.h
@ -0,0 +1,54 @@
+#pragma once
+#include "codes.h"
+
+enum class MoveButton : uint32_t {
+  SQUARE      = 1 << 7, // Square button.
+  CROSS       = 1 << 6, // Cross button.
+  CIRCLE      = 1 << 5, // Circle button.
+  TRIANGLE    = 1 << 4, // Triangle button.
+  MOVE        = 1 << 2, // Move button.
+  T           = 1 << 1, // T button.
+  START       = 1 << 3, // START button.
+  SELECT      = 1 << 0, // SELECT button.
+  INTERCEPTED = 1 << 15 // System has intercepted button presses.
+};
+
+/**
+ * @brief Success values for
+ * sceMoveGetDeviceInfo(), sceMoveReadStateRecent(), sceMoveReadStateLatest(), sceMoveSetLightSphere(),
+ *  and sceMoveSetVibration()
+ *
+ */
+enum class RetValues : int { NO_CONTROLLER_CONNECTED = 1, NO_EXTERNAL_PORT_DEVICE = 9, TYPE_STANDARD = 0, MAX_STATE_NUM = 32 };
+
+struct SceMoveDeviceInfo {
+  float sphereRadius           = 0.f;             ///< Radius of the physical sphere (in mm).
+  float accelToSphereOffset[3] = {0.f, 0.f, 0.f}; ///< Offset of accelerometer location relative to sphere center in device coordinates.
+};
+
+struct SceMoveButtonData {
+  uint16_t digitalButtons = 0; ///< State of each of the button controls. See #SCE_MOVE_BUTTON_CIRCLE, #SCE_MOVE_BUTTON_CROSS, #SCE_MOVE_BUTTON_MOVE,
+                               ///< #SCE_MOVE_BUTTON_SELECT, #SCE_MOVE_BUTTON_SQUARE, #SCE_MOVE_BUTTON_START, #SCE_MOVE_BUTTON_T, and #SCE_MOVE_BUTTON_TRIANGLE.
+  uint16_t analogT = 0;        ///< Analog value of T button.
+};
+
+struct SceMoveExtensionPortData {
+  uint16_t      status       = 0;
+  uint16_t      digital1     = 0;
+  uint16_t      digital2     = 0;
+  uint16_t      analogRightX = 0;
+  uint16_t      analogRightY = 0;
+  uint16_t      analogLeftX  = 0;
+  uint16_t      analogLeftY  = 0;
+  unsigned char custom[5]    = {0, 0, 0, 0, 0};
+};
+
+struct SceMoveData {
+  float                    accelerometer[3] = {0.f, 0.f, 0.f}; ///< Accelerometer readings in sensor coordinates (G units).
+  float                    gyro[3]          = {0.f, 0.f, 0.f}; ///< Gyro readings in sensor coordinates (radians/s).
+  SceMoveButtonData        pad {};                             ///< State of the motion controller buttons.
+  SceMoveExtensionPortData ext {};                             ///< Reserved.
+  int64_t                  timestamp   = 0;                    ///< System timestamp of this data (microseconds).
+  int                      counter     = 0;                    ///< Numbers the sensor data sequentially.
+  float                    temperature = 0.f;                  ///< The temperature of the sensor (used internally).
+};
--- a/modules/libSceNet/CMakeLists.txt
+++ b/modules/libSceNet/CMakeLists.txt
@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceNet)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp epoll.cpp socket.cpp)
+
+setupModule(${libName})
--- a/modules/libSceNet/codes.h
+++ b/modules/libSceNet/codes.h
@ -0,0 +1,128 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {
+constexpr int32_t ERROR_EPERM                    = -2143223551;
+constexpr int32_t ERROR_ENOENT                   = -2143223550;
+constexpr int32_t ERROR_ESRCH                    = -2143223549;
+constexpr int32_t ERROR_EINTR                    = -2143223548;
+constexpr int32_t ERROR_EIO                      = -2143223547;
+constexpr int32_t ERROR_ENXIO                    = -2143223546;
+constexpr int32_t ERROR_E2BIG                    = -2143223545;
+constexpr int32_t ERROR_ENOEXEC                  = -2143223544;
+constexpr int32_t ERROR_EBADF                    = -2143223543;
+constexpr int32_t ERROR_ECHILD                   = -2143223542;
+constexpr int32_t ERROR_EDEADLK                  = -2143223541;
+constexpr int32_t ERROR_ENOMEM                   = -2143223540;
+constexpr int32_t ERROR_EACCES                   = -2143223539;
+constexpr int32_t ERROR_EFAULT                   = -2143223538;
+constexpr int32_t ERROR_ENOTBLK                  = -2143223537;
+constexpr int32_t ERROR_EBUSY                    = -2143223536;
+constexpr int32_t ERROR_EEXIST                   = -2143223535;
+constexpr int32_t ERROR_EXDEV                    = -2143223534;
+constexpr int32_t ERROR_ENODEV                   = -2143223533;
+constexpr int32_t ERROR_ENOTDIR                  = -2143223532;
+constexpr int32_t ERROR_EISDIR                   = -2143223531;
+constexpr int32_t ERROR_EINVAL                   = -2143223530;
+constexpr int32_t ERROR_ENFILE                   = -2143223529;
+constexpr int32_t ERROR_EMFILE                   = -2143223528;
+constexpr int32_t ERROR_ENOTTY                   = -2143223527;
+constexpr int32_t ERROR_ETXTBSY                  = -2143223526;
+constexpr int32_t ERROR_EFBIG                    = -2143223525;
+constexpr int32_t ERROR_ENOSPC                   = -2143223524;
+constexpr int32_t ERROR_ESPIPE                   = -2143223523;
+constexpr int32_t ERROR_EROFS                    = -2143223522;
+constexpr int32_t ERROR_EMLINK                   = -2143223521;
+constexpr int32_t ERROR_EPIPE                    = -2143223520;
+constexpr int32_t ERROR_EDOM                     = -2143223519;
+constexpr int32_t ERROR_ERANGE                   = -2143223518;
+constexpr int32_t ERROR_EAGAIN                   = -2143223517;
+constexpr int32_t ERROR_EWOULDBLOCK              = -2143223517;
+constexpr int32_t ERROR_EINPROGRESS              = -2143223516;
+constexpr int32_t ERROR_EALREADY                 = -2143223515;
+constexpr int32_t ERROR_ENOTSOCK                 = -2143223514;
+constexpr int32_t ERROR_EDESTADDRREQ             = -2143223513;
+constexpr int32_t ERROR_EMSGSIZE                 = -2143223512;
+constexpr int32_t ERROR_EPROTOTYPE               = -2143223511;
+constexpr int32_t ERROR_ENOPROTOOPT              = -2143223510;
+constexpr int32_t ERROR_EPROTONOSUPPORT          = -2143223509;
+constexpr int32_t ERROR_ESOCKTNOSUPPORT          = -2143223508;
+constexpr int32_t ERROR_EOPNOTSUPP               = -2143223507;
+constexpr int32_t ERROR_ENOTSUP                  = -2143223507;
+constexpr int32_t ERROR_EPFNOSUPPORT             = -2143223506;
+constexpr int32_t ERROR_EAFNOSUPPORT             = -2143223505;
+constexpr int32_t ERROR_EADDRINUSE               = -2143223504;
+constexpr int32_t ERROR_EADDRNOTAVAIL            = -2143223503;
+constexpr int32_t ERROR_ENETDOWN                 = -2143223502;
+constexpr int32_t ERROR_ENETUNREACH              = -2143223501;
+constexpr int32_t ERROR_ENETRESET                = -2143223500;
+constexpr int32_t ERROR_ECONNABORTED             = -2143223499;
+constexpr int32_t ERROR_ECONNRESET               = -2143223498;
+constexpr int32_t ERROR_ENOBUFS                  = -2143223497;
+constexpr int32_t ERROR_EISCONN                  = -2143223496;
+constexpr int32_t ERROR_ENOTCONN                 = -2143223495;
+constexpr int32_t ERROR_ESHUTDOWN                = -2143223494;
+constexpr int32_t ERROR_ETOOMANYREFS             = -2143223493;
+constexpr int32_t ERROR_ETIMEDOUT                = -2143223492;
+constexpr int32_t ERROR_ECONNREFUSED             = -2143223491;
+constexpr int32_t ERROR_ELOOP                    = -2143223490;
+constexpr int32_t ERROR_ENAMETOOLONG             = -2143223489;
+constexpr int32_t ERROR_EHOSTDOWN                = -2143223488;
+constexpr int32_t ERROR_EHOSTUNREACH             = -2143223487;
+constexpr int32_t ERROR_ENOTEMPTY                = -2143223486;
+constexpr int32_t ERROR_EPROCLIM                 = -2143223485;
+constexpr int32_t ERROR_EUSERS                   = -2143223484;
+constexpr int32_t ERROR_EDQUOT                   = -2143223483;
+constexpr int32_t ERROR_ESTALE                   = -2143223482;
+constexpr int32_t ERROR_EREMOTE                  = -2143223481;
+constexpr int32_t ERROR_EBADRPC                  = -2143223480;
+constexpr int32_t ERROR_ERPCMISMATCH             = -2143223479;
+constexpr int32_t ERROR_EPROGUNAVAIL             = -2143223478;
+constexpr int32_t ERROR_EPROGMISMATCH            = -2143223477;
+constexpr int32_t ERROR_EPROCUNAVAIL             = -2143223476;
+constexpr int32_t ERROR_ENOLCK                   = -2143223475;
+constexpr int32_t ERROR_ENOSYS                   = -2143223474;
+constexpr int32_t ERROR_EFTYPE                   = -2143223473;
+constexpr int32_t ERROR_EAUTH                    = -2143223472;
+constexpr int32_t ERROR_ENEEDAUTH                = -2143223471;
+constexpr int32_t ERROR_EIDRM                    = -2143223470;
+constexpr int32_t ERROR_ENOMS                    = -2143223469;
+constexpr int32_t ERROR_EOVERFLOW                = -2143223468;
+constexpr int32_t ERROR_ECANCELED                = -2143223467;
+constexpr int32_t ERROR_EPROTO                   = -2143223460;
+constexpr int32_t ERROR_EADHOC                   = -2143223392;
+constexpr int32_t ERROR_ERESERVED161             = -2143223391;
+constexpr int32_t ERROR_ERESERVED162             = -2143223390;
+constexpr int32_t ERROR_EINACTIVEDISABLED        = -2143223389;
+constexpr int32_t ERROR_ENODATA                  = -2143223388;
+constexpr int32_t ERROR_EDESC                    = -2143223387;
+constexpr int32_t ERROR_EDESCTIMEDOUT            = -2143223386;
+constexpr int32_t ERROR_ENETINTR                 = -2143223385;
+constexpr int32_t ERROR_ENOTINIT                 = -2143223352;
+constexpr int32_t ERROR_ENOLIBMEM                = -2143223351;
+constexpr int32_t ERROR_ERESERVED202             = -2143223350;
+constexpr int32_t ERROR_ECALLBACK                = -2143223349;
+constexpr int32_t ERROR_EINTERNAL                = -2143223348;
+constexpr int32_t ERROR_ERETURN                  = -2143223347;
+constexpr int32_t ERROR_ENOALLOCMEM              = -2143223346;
+constexpr int32_t ERROR_RESOLVER_EINTERNAL       = -2143223332;
+constexpr int32_t ERROR_RESOLVER_EBUSY           = -2143223331;
+constexpr int32_t ERROR_RESOLVER_ENOSPACE        = -2143223330;
+constexpr int32_t ERROR_RESOLVER_EPACKET         = -2143223329;
+constexpr int32_t ERROR_RESOLVER_ERESERVED224    = -2143223328;
+constexpr int32_t ERROR_RESOLVER_ENODNS          = -2143223327;
+constexpr int32_t ERROR_RESOLVER_ETIMEDOUT       = -2143223326;
+constexpr int32_t ERROR_RESOLVER_ENOSUPPORT      = -2143223325;
+constexpr int32_t ERROR_RESOLVER_EFORMAT         = -2143223324;
+constexpr int32_t ERROR_RESOLVER_ESERVERFAILURE  = -2143223323;
+constexpr int32_t ERROR_RESOLVER_ENOHOST         = -2143223322;
+constexpr int32_t ERROR_RESOLVER_ENOTIMPLEMENTED = -2143223321;
+constexpr int32_t ERROR_RESOLVER_ESERVERREFUSED  = -2143223320;
+constexpr int32_t ERROR_RESOLVER_ENORECORD       = -2143223319;
+constexpr int32_t ERROR_RESOLVER_EALIGNMENT      = -2143223318;
+constexpr int32_t ERROR_RESOLVER_ENOTFOUND       = -2143223317;
+constexpr int32_t ERROR_RESOLVER_ENOTINIT        = -2143223316;
+} // namespace Err
+
+constexpr size_t SCE_NET_ETHER_ADDR_LEN   = 6;
+constexpr size_t SCE_NET_ETHER_ADDRSTRLEN = 18;
--- a/modules/libSceNet/entry.cpp
+++ b/modules/libSceNet/entry.cpp
@ -0,0 +1,99 @@
+#include "common.h"
+#include "types.h"
+
+#include <logging.h>
+
+LOG_DEFINE_MODULE(libSceNet);
+
+namespace {
+static thread_local int g_net_errno = 0;
+
+} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceNet";
+
+EXPORT SYSV_ABI int* sceNetErrnoLoc() {
+  return &g_net_errno;
+}
+
+EXPORT SYSV_ABI int sceNetInit(void) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetTerm(void) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetPoolCreate(const char* name, int size, int flags) {
+  static int id = 0;
+  return ++id;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetPoolDestroy(int memid) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetGetMemoryPoolStats(int memid, SceNetMemoryPoolStats* stat) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetShowIfconfig(void) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetShowIfconfigWithMemory(int memid) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetShowRoute(void) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetShowRouteWithMemory(int memid) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetShowNetstat(void) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetShowNetstatWithMemory(int memid) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetShowPolicy(void) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetShowPolicyWithMemory(int memid) {
+  return Ok;
+}
+
+const char*         sceNetInetNtop(int af, const void* src, char* dst, size_t size);
+EXPORT SYSV_ABI int sceNetInetPton(int af, const char* src, void* dst) {
+  *static_cast<uint32_t*>(dst) = 0x7f000001;
+  return Ok;
+}
+EXPORT SYSV_ABI uint64_t sceNetHtonll(uint64_t host64) {
+  return Ok;
+}
+EXPORT SYSV_ABI uint32_t sceNetHtonl(uint32_t host32) {
+  return Ok;
+}
+EXPORT SYSV_ABI uint16_t sceNetHtons(uint16_t host16) {
+  return Ok;
+}
+EXPORT SYSV_ABI uint64_t sceNetNtohll(uint64_t net64) {
+  return Ok;
+}
+EXPORT SYSV_ABI uint32_t sceNetNtohl(uint32_t net32) {
+  return Ok;
+}
+EXPORT SYSV_ABI uint16_t sceNetNtohs(uint16_t net16) {
+  return Ok;
+}
+
+EXPORT SYSV_ABI int sceNetEtherStrton(const char* str, SceNetEtherAddr* n) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetEtherNtostr(const SceNetEtherAddr* n, char* str, size_t len) {
+  auto const count = std::string("00:00:00:00:00:00").copy(str, len);
+  str[count]       = '\0';
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetGetMacAddress(SceNetEtherAddr* addr, int flags) {
+  memset(addr->data, 0, sizeof(addr->data));
+  return Ok;
+}
+}
--- a/modules/libSceNet/epoll.cpp
+++ b/modules/libSceNet/epoll.cpp
@ -0,0 +1,54 @@
+#include "common.h"
+#include "types.h"
+
+#include <logging.h>
+
+LOG_DEFINE_MODULE(libSceNet);
+
+namespace {
+union SceNetEpollData {
+  void*    ptr;
+  uint32_t u32;
+};
+
+enum class SCE_NET_EpollEvent : int {
+  EPOLLIN     = 0x00000001,
+  EPOLLOUT    = 0x00000002,
+  EPOLLERR    = 0x00000008,
+  EPOLLHUP    = 0x00000010,
+  EPOLLDESCID = 0x00010000,
+
+};
+
+struct SceNetEpollEvent {
+  uint32_t        events;
+  uint32_t        reserved;
+  uint64_t        ident; /* OUT */
+  SceNetEpollData data;
+};
+
+constexpr int SCE_NET_EPOLL_CTL_ADD = 1;
+constexpr int SCE_NET_EPOLL_CTL_MOD = 2;
+constexpr int SCE_NET_EPOLL_CTL_DEL = 3;
+
+constexpr int SCE_NET_EPOLL_ABORT_FLAG_PRESERVATION = 0x00000001;
+} // namespace
+
+extern "C" {
+EXPORT SYSV_ABI SceNetId sceNetEpollCreate(const char* name, int flags) {
+  static int id = 0;
+  return ++id;
+}
+EXPORT SYSV_ABI int sceNetEpollControl(SceNetId eid, int op, SceNetId id, SceNetEpollEvent* event) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetEpollWait(SceNetId eid, SceNetEpollEvent* events, int maxevents, int timeout) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetEpollDestroy(SceNetId eid) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetEpollAbort(SceNetId eid, int flags) {
+  return Ok;
+}
+}
--- a/modules/libSceNet/socket.cpp
+++ b/modules/libSceNet/socket.cpp
@ -0,0 +1,72 @@
+#include "common.h"
+#include "socketTypes.h"
+
+#include <logging.h>
+LOG_DEFINE_MODULE(libSceNet);
+
+namespace {} // namespace
+
+extern "C" {
+
+EXPORT SYSV_ABI SceNetId sceNetSocket(const char* name, int domain, int type, int protocol) {
+  return Ok;
+}
+EXPORT SYSV_ABI SceNetId sceNetAccept(SceNetId s, SceNetSockaddr* addr, SceNetSocklen_t* addrlen) {
+  if (addr != nullptr)
+    *addr = SceNetSockaddr {
+        sizeof(SceNetSockaddr),
+        2,
+        {80, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0},
+    };
+
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetBind(SceNetId s, const SceNetSockaddr* addr, SceNetSocklen_t addrlen) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetConnect(SceNetId s, const SceNetSockaddr* name, SceNetSocklen_t namelen) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetGetpeername(SceNetId s, SceNetSockaddr* name, SceNetSocklen_t* namelen) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetGetsockname(SceNetId s, SceNetSockaddr* name, SceNetSocklen_t* namelen) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetGetsockopt(SceNetId s, int level, int optname, void* optval, SceNetSocklen_t* optlen) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetListen(SceNetId s, int backlog) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetRecv(SceNetId s, void* buf, size_t len, int flags) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetRecvfrom(SceNetId s, void* buf, size_t len, int flags, SceNetSockaddr* from, SceNetSocklen_t* fromlen) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetRecvmsg(SceNetId s, SceNetMsghdr* msg, int flags) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetSend(SceNetId s, const void* msg, size_t len, int flags) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetSendto(SceNetId s, const void* msg, size_t len, int flags, const SceNetSockaddr* to, SceNetSocklen_t tolen) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetSendmsg(SceNetId s, const SceNetMsghdr* msg, int flags) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetSetsockopt(SceNetId s, int level, int optname, const void* optval, SceNetSocklen_t optlen) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetShutdown(SceNetId s, int how) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetSocketClose(SceNetId s) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetSocketAbort(SceNetId s, int flags) {
+  return Ok;
+}
+}
--- a/modules/libSceNet/socketTypes.h
+++ b/modules/libSceNet/socketTypes.h
@ -0,0 +1,52 @@
+#pragma once
+#include "types.h"
+
+constexpr int SCE_NET_MSG_PEEK         = 0x00000002;
+constexpr int SCE_NET_MSG_WAITALL      = 0x00000040;
+constexpr int SCE_NET_MSG_DONTWAIT     = 0x00000080;
+constexpr int SCE_NET_MSG_USECRYPTO    = 0x00100000;
+constexpr int SCE_NET_MSG_USESIGNATURE = 0x00200000;
+constexpr int SCE_NET_MSG_PEEKLEN      = (0x00400000 | SCE_NET_MSG_PEEK);
+
+constexpr int SCE_NET_SHUT_RD   = 0;
+constexpr int SCE_NET_SHUT_WR   = 1;
+constexpr int SCE_NET_SHUT_RDWR = 2;
+
+constexpr int SCE_NET_SOCKET_ABORT_FLAG_RCV_PRESERVATION       = 0x00000001;
+constexpr int SCE_NET_SOCKET_ABORT_FLAG_SND_PRESERVATION       = 0x00000002;
+constexpr int SCE_NET_SOCKET_ABORT_FLAG_SND_PRESERVATION_AGAIN = 0x00000004;
+
+struct SceNetLinger {
+  int l_onoff;  /* on/off */
+  int l_linger; /* linger time [sec] */
+};
+
+struct SceNetSockaddr {
+  uint8_t          sa_len;
+  SceNetSaFamily_t sa_family;
+  char             sa_data[14];
+};
+
+struct SceNetIovec {
+  void*  iov_base;
+  size_t iov_len;
+};
+
+struct SceNetMsghdr {
+  void*           msg_name;
+  SceNetSocklen_t msg_namelen;
+  SceNetIovec*    msg_iov;
+  int             msg_iovlen;
+  void*           msg_control;
+  SceNetSocklen_t msg_controllen;
+  int             msg_flags;
+};
+
+typedef struct SceNetUdpSndOnSuspend {
+  int             onoff;
+  SceNetSockaddr* addr;
+  SceNetSocklen_t addrlen;
+#define SCE_NET_UDP_SND_ON_SUSPEND_DATALEN_MAX (512)
+  void*           data;
+  SceNetSocklen_t datalen;
+} SceNetUdpSndOnSuspend;
--- a/modules/libSceNet/types.h
+++ b/modules/libSceNet/types.h
@ -0,0 +1,112 @@
+#pragma once
+#include "codes.h"
+
+typedef uint32_t SceNetInAddr_t;
+typedef uint16_t SceNetInPort_t;
+typedef uint8_t  SceNetSaFamily_t;
+typedef uint32_t SceNetSocklen_t;
+
+typedef int SceNetId;
+
+enum class SceStunCheckResult {
+  Unchecked = 0,
+  Failed    = 1,
+  Ok        = 2
+
+};
+
+enum class SceNatType {
+  Type1 = 1,
+  Type2 = 2,
+  Type3 = 3
+
+};
+
+enum class SceIpConfig {
+  Dhcp   = 0,
+  Static = 1,
+  Pppoe  = 2
+
+};
+
+enum class SceHttpProxyConfig {
+  Off = 0,
+  On  = 1
+
+};
+
+enum class SceNetworkState {
+  Disconnected = 0,
+  Connecting   = 1,
+  Ipobtaining  = 2,
+  Ipobtained   = 3
+
+};
+
+enum class SceEventType {
+  Disconnected          = 1,
+  DisconnectReqFinished = 2,
+  Ipobtained            = 3
+
+};
+
+enum class SceInfoCode {
+  Device          = 1,
+  EtherAddr       = 2,
+  Mtu             = 3,
+  Link            = 4,
+  Bssid           = 5,
+  Ssid            = 6,
+  WiFiSecurity    = 7,
+  RssiDbm         = 8,
+  RssiPercentage  = 9,
+  Channel         = 10,
+  IPConfig        = 11,
+  DhcpHostname    = 12,
+  PppoeAuthName   = 13,
+  IPAddress       = 14,
+  Netmask         = 15,
+  DefaultRoute    = 16,
+  PrimaryDNS      = 17,
+  SecondaryDNS    = 18,
+  HttpProxyConfig = 19,
+  HttpProxyServer = 20,
+  HttpProxyPort   = 21,
+  Reserved1       = 22,
+  Reserved2       = 23
+
+};
+
+enum class SceDevice {
+  Wired    = 0,
+  Wireless = 1
+
+};
+
+enum class SceLink {
+  Disconnected = 0,
+  Connected    = 1
+
+};
+
+enum class SceWiFiSecurity {
+  Noauth        = 0,
+  Wep           = 1,
+  WPAPSKWPA2PSK = 2,
+  WPAPSKTKIP    = 3,
+  WPAPSKAES     = 4,
+  WPA2PSKTKIP   = 5,
+  WPA2PSKAES    = 6,
+  Unsupported   = 7
+
+};
+
+struct SceNetMemoryPoolStats {
+  size_t poolSize;
+  size_t maxInuseSize;
+  size_t currentInuseSize;
+};
+
+typedef struct SceNetEtherAddr {
+  uint8_t data[SCE_NET_ETHER_ADDR_LEN];
+} SceNetEtherAddr;
--- a/modules/libSceNetCtl/CMakeLists.txt
+++ b/modules/libSceNetCtl/CMakeLists.txt
@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceNetCtl)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp)
+
+setupModule(${libName})
--- a/modules/libSceNetCtl/codes.h
+++ b/modules/libSceNetCtl/codes.h
@ -0,0 +1,29 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {
+namespace Ctl {
+constexpr int32_t NOT_INITIALIZED  = -2143215359;
+constexpr int32_t CALLBACK_MAX     = -2143215357;
+constexpr int32_t ID_NOT_FOUND     = -2143215356;
+constexpr int32_t INVALID_ID       = -2143215355;
+constexpr int32_t INVALID_CODE     = -2143215354;
+constexpr int32_t INVALID_ADDR     = -2143215353;
+constexpr int32_t NOT_CONNECTED    = -2143215352;
+constexpr int32_t NOT_AVAIL        = -2143215351;
+constexpr int32_t NETWORK_DISABLED = -2143215347;
+constexpr int32_t DISCONNECT_REQ   = -2143215346;
+constexpr int32_t INVALID_TYPE     = -2143215345;
+constexpr int32_t INVALID_SIZE     = -2143215343;
+constexpr int32_t ETHERNET_PLUGOUT = -2143215339;
+constexpr int32_t WIFI_DEAUTHED    = -2143215338;
+constexpr int32_t WIFI_BEACON_LOST = -2143215337;
+} // namespace Ctl
+} // namespace Err
+
+constexpr size_t SCE_NET_CTL_SSID_LEN              = 33;
+constexpr size_t SCE_NET_CTL_WIFI_SECURITY_KEY_LEN = 65;
+constexpr size_t SCE_NET_CTL_AUTH_NAME_LEN         = 128;
+constexpr size_t SCE_NET_CTL_AUTH_KEY_LEN          = 128;
+constexpr size_t SCE_NET_CTL_HOSTNAME_LEN          = 256;
+constexpr size_t SCE_NET_CTL_IPV4_ADDR_STR_LEN     = 16;
--- a/modules/libSceNetCtl/entry.cpp
+++ b/modules/libSceNetCtl/entry.cpp
@ -0,0 +1,59 @@
+#include "common.h"
+#include "types.h"
+
+#include <logging.h>
+
+LOG_DEFINE_MODULE(libSceNetCtl);
+
+namespace {} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceNetCtl";
+
+EXPORT SYSV_ABI int sceNetCtlInit(void) {
+  return Ok;
+}
+EXPORT SYSV_ABI void sceNetCtlTerm(void) {}
+EXPORT SYSV_ABI int  sceNetCtlCheckCallback(void) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetCtlRegisterCallback(SceNetCtlCallback func, void* arg, int* cid) {
+  *cid = 1;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetCtlUnregisterCallback(int cid) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetCtlGetResult(int eventType, int* errorCode) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetCtlGetState(int* state) {
+  *state = 0;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetCtlGetInfo(int code, SceNetCtlInfo* info) {
+  LOG_USE_MODULE(libSceNetCtl);
+
+  switch (code) {
+    case 2: memset(info->ether_addr.data, 0, sizeof(info->ether_addr.data)); break;
+    case 11: info->ip_config = 0; break;
+    case 14: {
+      auto const count = std::string("127.0.0.1").copy(info->ip_address, 16);
+
+      info->ip_address[count] = '\0';
+    } break;
+    default: LOG_CRIT(L"unknown code: %d", code);
+  }
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetCtlGetIfStat(SceNetCtlIfStat* ifStat) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNetCtlGetNatInfo(SceNetCtlNatInfo* natInfo) {
+  natInfo->stunStatus = 1;
+  natInfo->natType    = 3;
+  natInfo->mappedAddr = 0x7f000001;
+  return Ok;
+}
+}
--- a/modules/libSceNetCtl/types.h
+++ b/modules/libSceNetCtl/types.h
@ -0,0 +1,43 @@
+#pragma once
+#include "../libSceNet/types.h"
+#include "codes.h"
+#include "utility/utility.h"
+
+union SceNetCtlInfo {
+  uint32_t        device;
+  SceNetEtherAddr ether_addr;
+  uint32_t        mtu;
+  uint32_t        link;
+  SceNetEtherAddr bssid;
+  char            ssid[32 + 1];
+  uint32_t        wifi_security;
+  uint8_t         rssi_dbm;
+  uint8_t         rssi_percentage;
+  uint8_t         channel;
+  uint32_t        ip_config;
+  char            dhcp_hostname[255 + 1];
+  char            pppoe_auth_name[127 + 1];
+  char            ip_address[16];
+  char            netmask[16];
+  char            default_route[16];
+  char            primary_dns[16];
+  char            secondary_dns[16];
+  uint32_t        http_proxy_config;
+  char            http_proxy_server[255 + 1];
+  uint16_t        http_proxy_port;
+};
+
+struct SceNetCtlNatInfo {
+  unsigned int size;
+  int          stunStatus;
+  int          natType;
+  uint32_t     mappedAddr;
+};
+
+using SceNetCtlCallback = SYSV_ABI void (*)(int eventType, void* arg);
+
+struct SceNetCtlIfStat {
+  uint32_t device;
+  uint64_t txBytes;
+  uint64_t rxBytes;
+};
--- a/modules/libSceNpManager/CMakeLists.txt
+++ b/modules/libSceNpManager/CMakeLists.txt
@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceNpManager)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp)
+
+setupModule(${libName})
--- a/modules/libSceNpManager/codes.h
+++ b/modules/libSceNpManager/codes.h
@ -0,0 +1,29 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {} // namespace Err
+
+constexpr uint32_t SCE_NP_SESSION_INVITATION_EVENT_FLAG_INVITATION = (0x01);
+constexpr uint32_t SCE_NP_SESSION_ID_MAX_SIZE                      = (45);
+constexpr uint32_t SCE_NP_INVITATION_ID_MAX_SIZE                   = (60);
+constexpr uint32_t SCE_NP_MAX_REQUEST_NUM                          = (32);
+constexpr uint32_t SCE_NP_TIMEOUT_NO_EFFECT                        = (0);
+constexpr uint32_t SCE_NP_POLL_ASYNC_RET_FINISHED                  = (0);
+constexpr uint32_t SCE_NP_POLL_ASYNC_RET_RUNNING                   = (1);
+constexpr uint32_t SCE_NP_TITLE_ID_LEN                             = (12);
+constexpr uint32_t SCE_NP_TITLE_SECRET_SIZE                        = (128);
+constexpr uint32_t SCE_NP_CLIENT_ID_MAX_LEN                        = (128);
+constexpr uint32_t SCE_NP_CLIENT_SECRET_MAX_LEN                    = (256);
+constexpr uint32_t SCE_NP_DEFAULT_SERVICE_LABEL                    = (0x00000000);
+constexpr uint32_t SCE_NP_INVALID_SERVICE_LABEL                    = (0xFFFFFFFF);
+constexpr uint32_t SCE_NP_AUTHORIZATION_CODE_MAX_LEN               = (128);
+constexpr uint32_t SCE_NP_ID_TOKEN_MAX_LEN                         = (4096);
+constexpr uint32_t SCE_NP_COMMUNICATION_PASSPHRASE_SIZE            = (128);
+constexpr uint32_t SCE_NP_PORT                                     = (3658);
+constexpr uint32_t SCE_NP_UNIFIED_ENTITLEMENT_LABEL_SIZE           = (17);
+constexpr uint32_t SCE_NP_INVALID_ACCOUNT_ID                       = (0);
+constexpr uint32_t SCE_NP_LANGUAGE_CODE_MAX_LEN                    = (5);
+constexpr uint32_t SCE_NP_COUNTRY_CODE_LENGTH                      = (2);
+constexpr uint32_t SCE_NP_NO_AGE_RESTRICTION                       = (0);
+constexpr uint32_t SCE_NP_PLUS_FEATURE_REALTIME_MULTIPLAY          = (0x1);
+constexpr uint32_t SCE_NP_PLUS_EVENT_RECHECK_NEEDED                = (0x1);
--- a/modules/libSceNpManager/entry.cpp
+++ b/modules/libSceNpManager/entry.cpp
@ -0,0 +1,289 @@
+#include "common.h"
+#include "types.h"
+
+#include <logging.h>
+#include <utility/utility.h>
+
+LOG_DEFINE_MODULE(libSceNpManager);
+
+namespace {
+using SceNpStateCallbackA            = SYSV_ABI void (*)(int32_t userId, SceNpState state, void* userdata);
+using SceNpReachabilityStateCallback = SYSV_ABI void (*)(int32_t userId, SceNpReachabilityState state, void* userdata);
+using SceNpGamePresenceCallbackA     = SYSV_ABI void (*)(int32_t userId, SceNpGamePresenceStatus status, void* userdata);
+using SceNpPlusEventCallback         = SYSV_ABI void (*)(int32_t userId, SceNpPlusEventType event, void* userdata);
+} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceNpManager";
+
+EXPORT SYSV_ABI int sceNpSetNpTitleId(const SceNpTitleId* titleId, const SceNpTitleSecret* titleSecret) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpSetContentRestriction(const SceNpContentRestriction* pRestriction) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpCheckCallback(void) {
+  // todo iterate callbacks
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetState(int32_t userId, SceNpState* state) {
+  *state = SceNpState::SIGNED_OUT;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpRegisterStateCallback(SceNpStateCallbackA callback, void* userdata) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpUnregisterStateCallback(int callbackId) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpRegisterStateCallbackA(SceNpStateCallbackA callback, void* userdata) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpUnregisterStateCallbackA(int callbackId) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetNpReachabilityState(int32_t userId, SceNpReachabilityState* state) {
+  *state = SceNpReachabilityState::UNAVAILABLE;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpRegisterNpReachabilityStateCallback(SceNpReachabilityStateCallback callback, void* userdata) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpUnregisterNpReachabilityStateCallback(void) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpHasSignedUp(int32_t userId, bool* hasSignedUp) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  *hasSignedUp = true;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetAccountId(int32_t userId, SceNpAccountId* accountId) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  *accountId = 1;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetAccountIdA(int32_t userId, SceNpAccountId* accountId) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  *accountId = 1;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetUserIdByAccountId(SceNpAccountId accountId, int32_t* userId) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  *userId = 1;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetOnlineId(int32_t userId, SceNpOnlineId* onlineId) {
+  auto const count      = std::string("onlineId").copy(onlineId->data, 15);
+  onlineId->data[count] = '\0';
+  onlineId->term        = 0;
+
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S, userId:%d", __FUNCTION__, userId);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetNpId(int32_t userId, SceNpId* npId) {
+  auto const count         = std::string("NpIdName").copy(npId->handle.data, 15);
+  npId->handle.data[count] = '\0';
+  npId->handle.term        = 0;
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_DEBUG(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetPlatformType(const SceNpId* npId) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return (int)SceNpPlatformType::TYPE_PS4;
+}
+EXPORT SYSV_ABI int sceNpSetPlatformType(SceNpId* npId, SceNpPlatformType platformType) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetAccountCountry(int32_t userId, SceNpCountryCode* countryCode) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetAccountDateOfBirth(int32_t userId, SceNpDate* dateOfBirth) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+
+  dateOfBirth->year  = 1990;
+  dateOfBirth->month = 1;
+  dateOfBirth->day   = 1;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpRegisterGamePresenceCallback(SceNpGamePresenceCallbackA callback, void* userdata) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpUnregisterGamePresenceCallback(int callbackId) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetGamePresenceStatus(int32_t userId, SceNpGamePresenceStatus* status) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  *status = SceNpGamePresenceStatus::OFFLINE;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetAccountCountryA(int32_t userId, SceNpCountryCode* countryCode) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetAccountDateOfBirthA(int32_t userId, SceNpDate* dateOfBirth) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpRegisterGamePresenceCallbackA(SceNpGamePresenceCallbackA callback, void* userdata) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpUnregisterGamePresenceCallbackA(int callbackId) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetGamePresenceStatusA(int32_t userId, SceNpGamePresenceStatus* status) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  *status = SceNpGamePresenceStatus::OFFLINE;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpCreateRequest(void) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  static int32_t id = 0;
+  return ++id;
+}
+EXPORT SYSV_ABI int sceNpCreateAsyncRequest(const SceNpCreateAsyncRequestParameter* param) {
+
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  static int32_t id = 0;
+  return ++id;
+}
+EXPORT SYSV_ABI int sceNpDeleteRequest(int reqId) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpAbortRequest(int reqId) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpSetTimeout(int reqId, int32_t resolveRetry, uint32_t resolveTimeout, uint32_t connTimeout, uint32_t sendTimeout,
+                                    uint32_t recvTimeout) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpWaitAsync(int reqId, int* result) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpPollAsync(int reqId, int* result) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  *result = 0;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetAccountLanguage(int reqId, int32_t userId, SceNpLanguageCode* langCode) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetParentalControlInfo(int reqId, int32_t userId, int8_t* age, SceNpParentalControlInfo* info) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpCheckNpAvailability(int reqId, int32_t userId) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpCheckNpReachability(int reqId, int32_t userId) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpSetGamePresenceOnline(int reqId, int32_t userId, uint32_t timeout, void* pReserved) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetAccountLanguageA(int reqId, int32_t userId, SceNpLanguageCode* langCode) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpGetParentalControlInfoA(int reqId, int32_t userId, int8_t* age, SceNpParentalControlInfo* info) {
+  info->chatRestriction    = false;
+  info->contentRestriction = false;
+  info->ugcRestriction     = false;
+  *age                     = 18;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpCheckNpAvailabilityA(int reqId, int32_t userId) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpSetGamePresenceOnlineA(int reqId, int32_t userId, uint32_t timeout, void* pReserved) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpCheckPlus(int reqId, const SceNpCheckPlusParameter* param, SceNpCheckPlusResult* pResult) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  pResult->authorized = false;
+
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpRegisterPlusEventCallback(SceNpPlusEventCallback callback, void* userdata) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpUnregisterPlusEventCallback(void) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpNotifyPlusFeature(const SceNpNotifyPlusFeatureParameter* param) {
+  LOG_USE_MODULE(libSceNpManager);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+}
--- a/modules/libSceNpManager/onlineId.h
+++ b/modules/libSceNpManager/onlineId.h
@ -0,0 +1,19 @@
+#pragma once
+#include <stdint.h>
+
+constexpr uint32_t SCE_NP_ONLINEID_MIN_LENGTH = 3;
+constexpr uint32_t SCE_NP_ONLINEID_MAX_LENGTH = 16;
+
+/* Online ID */
+typedef struct SceNpOnlineId {
+  char data[SCE_NP_ONLINEID_MAX_LENGTH];
+  char term;
+  char dummy[3];
+} SceNpOnlineId;
+
+/* NP ID */
+typedef struct SceNpId {
+  SceNpOnlineId handle;
+  uint8_t       opt[8];
+  uint8_t       reserved[8];
+} SceNpId;
--- a/modules/libSceNpManager/types.h
+++ b/modules/libSceNpManager/types.h
@ -0,0 +1,154 @@
+#pragma once
+#include "codes.h"
+#include "onlineId.h"
+
+typedef uint64_t SceNpGameCustomDataId;
+typedef int32_t  SceNpSessionInvitationEventFlag;
+
+typedef int32_t SceNpPlusEventType;
+
+typedef uint64_t SceNpAccountId;
+
+enum class SceNpPlatformType : int {
+  TYPE_NONE  = 0,
+  TYPE_PS3   = 1,
+  TYPE_VITA  = 2,
+  TYPE_PS4   = 3,
+  TYPE_ORBIS = 3 /* for compatibility */
+};
+
+enum class SceNpState { UNKNOWN = 0, SIGNED_OUT, SIGNED_IN };
+enum class SceNpGamePresenceStatus { OFFLINE, ONLINE };
+enum class SceNpReachabilityState { UNAVAILABLE = 0, AVAILABLE, REACHABLE };
+
+enum class SceNpServiceLabel : uint32_t { DEFAULT = 0x00000000, INVALID = 0xFFFFFFFF };
+struct SceNpTitleId {
+  char id[SCE_NP_TITLE_ID_LEN + 1];
+};
+
+struct SceNpTitleSecret {
+  uint8_t data[SCE_NP_TITLE_SECRET_SIZE];
+};
+
+struct SceNpClientId {
+  char id[SCE_NP_CLIENT_ID_MAX_LEN + 1];
+};
+
+struct SceNpClientSecret {
+  char secret[SCE_NP_CLIENT_SECRET_MAX_LEN + 1];
+};
+
+struct SceNpAuthorizationCode {
+  char code[SCE_NP_AUTHORIZATION_CODE_MAX_LEN + 1];
+};
+
+struct SceNpIdToken {
+  char token[SCE_NP_ID_TOKEN_MAX_LEN + 1];
+};
+
+struct SceNpCommunicationId {
+  char    data[9];
+  char    term;
+  uint8_t num;
+  char    dummy;
+};
+
+struct SceNpCommunicationPassphrase {
+  uint8_t data[SCE_NP_COMMUNICATION_PASSPHRASE_SIZE];
+};
+
+struct SceNpUnifiedEntitlementLabel {
+  char data[SCE_NP_UNIFIED_ENTITLEMENT_LABEL_SIZE];
+};
+
+struct SceNpPeerAddressA {
+  SceNpAccountId    accountId;
+  SceNpPlatformType platform;
+};
+
+struct SceNpLanguageCode {
+  char code[SCE_NP_LANGUAGE_CODE_MAX_LEN + 1];
+};
+
+struct SceNpCountryCode {
+  char data[SCE_NP_COUNTRY_CODE_LENGTH];
+  char term;
+};
+
+struct SceNpDate {
+  uint16_t year;
+  uint8_t  month;
+  uint8_t  day;
+};
+
+struct SceNpAgeRestriction {
+  SceNpCountryCode countryCode;
+  int8_t           age;
+};
+
+struct SceNpContentRestriction {
+  size_t size;
+  int8_t defaultAgeRestriction;
+
+  char    padding[3];
+  int32_t ageRestrictionCount;
+
+  const SceNpAgeRestriction* ageRestriction;
+};
+
+struct SceNpParentalControlInfo {
+  bool contentRestriction;
+  bool chatRestriction;
+  bool ugcRestriction;
+};
+
+struct SceNpCheckPlusParameter {
+  size_t   size;
+  int32_t  userId;
+  char     padding[4];
+  uint64_t features;
+};
+
+struct SceNpCheckPlusResult {
+  bool authorized;
+};
+
+struct SceNpNotifyPlusFeatureParameter {
+  size_t   size;
+  int32_t  userId;
+  char     padding[4];
+  uint64_t features;
+};
+
+struct SceNpSessionId {
+  char data[SCE_NP_SESSION_ID_MAX_SIZE];
+  char term;
+};
+
+struct SceNpInvitationId {
+  char data[SCE_NP_INVITATION_ID_MAX_SIZE];
+  char term;
+};
+
+struct SceNpSessionInvitationEventParam {
+  SceNpSessionId                  sessionId;
+  SceNpInvitationId               invitationId;
+  SceNpSessionInvitationEventFlag flag;
+  char                            padding[4];
+  SceNpOnlineId                   onlineId;
+  int32_t                         userId;
+  SceNpOnlineId                   referralOnlineId;
+  SceNpAccountId                  referralAccountId;
+};
+
+struct SceNpGameCustomDataEventParam {
+  SceNpGameCustomDataId itemId;
+  SceNpOnlineId         onlineId;
+  int32_t               userId;
+};
+
+struct SceNpCreateAsyncRequestParameter {
+  size_t   size;
+  uint64_t cpuAffinityMask;
+  int      threadPriority;
+};
--- a/modules/libSceNpManagerForToolkit/CMakeLists.txt
+++ b/modules/libSceNpManagerForToolkit/CMakeLists.txt
@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceNpManagerForToolkit)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp)
+
+setupModule(${libName})
--- a/modules/libSceNpManagerForToolkit/codes.h
+++ b/modules/libSceNpManagerForToolkit/codes.h
@ -0,0 +1,4 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {} // namespace Err
--- a/modules/libSceNpManagerForToolkit/entry.cpp
+++ b/modules/libSceNpManagerForToolkit/entry.cpp
@ -0,0 +1,23 @@
+#include "common.h"
+#include "types.h"
+
+#include <logging.h>
+
+LOG_DEFINE_MODULE(libSceNpManagerForToolkit);
+
+namespace {} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceNpManager";
+
+EXPORT SYSV_ABI int sceNpCheckCallbackForLib() {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpRegisterStateCallbackForToolkit(void* /*callback*/, void* /*userdata*/) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpUnregisterStateCallbackForToolkit(void* /*callback*/, void* /*userdata*/) {
+  return Ok;
+}
+}
--- a/modules/libSceNpManagerForToolkit/types.h
+++ b/modules/libSceNpManagerForToolkit/types.h
@ -0,0 +1,2 @@
+#pragma once
+#include "codes.h"
--- a/modules/libSceNpScore/CMakeLists.txt
+++ b/modules/libSceNpScore/CMakeLists.txt
@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceNpScore)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp)
+
+setupModule(${libName})
--- a/modules/libSceNpScore/codes.h
+++ b/modules/libSceNpScore/codes.h
@ -0,0 +1,25 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {} // namespace Err
+
+constexpr size_t SCE_NP_SCORE_COMMENT_MAXLEN          = 63;
+constexpr size_t SCE_NP_SCORE_GAMEINFO_MAXSIZE        = 189;
+constexpr size_t SCE_NP_SCORE_CENSOR_COMMENT_MAXLEN   = 255;
+constexpr size_t SCE_NP_SCORE_SANITIZE_COMMENT_MAXLEN = 255;
+
+enum class NpScoreUpdateType { NORMAL, FORCE };
+
+enum class NpScoreOrderType { DESCENDING, ASCENDING };
+
+constexpr uint32_t SCE_NP_SCORE_MAX_RANGE_NUM_PER_REQUEST = 100;
+constexpr uint32_t SCE_NP_SCORE_MAX_ID_NUM_PER_REQUEST    = 101;
+constexpr uint32_t SCE_NP_SCORE_MAX_SELECTED_FRIENDS_NUM  = 100;
+
+constexpr uint32_t SCE_NP_SCORE_MAX_RANGE_NUM_PER_TRANS  = SCE_NP_SCORE_MAX_RANGE_NUM_PER_REQUEST;
+constexpr uint32_t SCE_NP_SCORE_MAX_NPID_NUM_PER_TRANS   = SCE_NP_SCORE_MAX_ID_NUM_PER_REQUEST;
+constexpr uint32_t SCE_NP_SCORE_MAX_NPID_NUM_PER_REQUEST = SCE_NP_SCORE_MAX_ID_NUM_PER_REQUEST;
+
+constexpr uint32_t SCE_NP_SCORE_MAX_CTX_NUM = 32;
+
+enum class NpScoreBindMode { ALL_FORBIDDEN = 0x0000, RDONLY = 0x0001, WRONLY = 0x0002, RDWR = (RDONLY | WRONLY), DEFAULT = RDWR };
--- a/modules/libSceNpScore/entry.cpp
+++ b/modules/libSceNpScore/entry.cpp
@ -0,0 +1,267 @@
+#include "types.h"
+
+#include <logging.h>
+
+LOG_DEFINE_MODULE(libSceNpScore);
+
+namespace {} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceNpScore";
+
+EXPORT SYSV_ABI int sceNpScoreCreateNpTitleCtxA(SceNpServiceLabel serviceLabel, SceUserServiceUserId selfId) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return 1;
+}
+EXPORT SYSV_ABI int sceNpScoreDeleteNpTitleCtx(int32_t titleCtxId) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreCreateRequest(int32_t titleCtxId) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreDeleteRequest(int32_t reqId) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreAbortRequest(int32_t reqId) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreSetTimeout(int32_t id, int32_t resolveRetry, int32_t resolveTimeout, int32_t connTimeout, int32_t sendTimeout,
+                                         int32_t recvTimeout) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreSetThreadParam(int32_t threadPriority, SceKernelCpumask cpuAffinityMask) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreSetPlayerCharacterId(int32_t id, SceNpScorePcId pcId) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetBoardInfo(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreBoardInfo* boardInfo, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreRecordScore(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreValue score, const SceNpScoreComment* scoreComment,
+                                          const SceNpScoreGameInfo* gameInfo, SceNpScoreRankNumber* tmpRank, const SceRtcTick* compareDate, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreRecordGameData(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreValue score, size_t totalSize, size_t sendSize,
+                                             const void* data, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetGameDataByAccountId(int32_t reqId, SceNpScoreBoardId boardId, SceNpAccountId accountId, size_t* totalSize, size_t recvSize,
+                                                     void* data, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetGameDataByAccountIdAsync(int32_t reqId, SceNpScoreBoardId boardId, SceNpAccountId accountId, size_t* totalSize,
+                                                          size_t recvSize, void* data, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountId(int32_t reqId, SceNpScoreBoardId boardId, const SceNpAccountId accountIdArray[], size_t accountIdArraySize,
+                                                    SceNpScorePlayerRankDataA* rankArray, size_t rankArraySize, SceNpScoreComment* commentArray,
+                                                    size_t commentArraySize, SceNpScoreGameInfo* infoArray, size_t infoArraySize, size_t arrayNum,
+                                                    SceRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdForCrossSave(int32_t reqId, SceNpScoreBoardId boardId, const SceNpAccountId accountIdArray[],
+                                                                size_t accountIdArraySize, SceNpScorePlayerRankDataForCrossSave* rankArray,
+                                                                size_t rankArraySize, SceNpScoreComment* commentArray, size_t commentArraySize,
+                                                                SceNpScoreGameInfo* infoArray, size_t infoArraySize, size_t arrayNum, SceRtcTick* lastSortDate,
+                                                                SceNpScoreRankNumber* totalRecord, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetRankingByRangeA(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank, SceNpScoreRankDataA* rankArray,
+                                                 size_t rankArraySize, SceNpScoreComment* commentArray, size_t commentArraySize, SceNpScoreGameInfo* infoArray,
+                                                 size_t infoArraySize, size_t arrayNum, SceRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord,
+                                                 void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetRankingByRangeForCrossSave(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank,
+                                                            SceNpScoreRankDataForCrossSave* rankArray, size_t rankArraySize, SceNpScoreComment* commentArray,
+                                                            size_t commentArraySize, SceNpScoreGameInfo* infoArray, size_t infoArraySize, size_t arrayNum,
+                                                            SceRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdPcId(int32_t reqId, SceNpScoreBoardId boardId, const SceNpScoreAccountIdPcId* idArray, size_t idArraySize,
+                                                        SceNpScorePlayerRankDataA* rankArray, size_t rankArraySize, SceNpScoreComment* commentArray,
+                                                        size_t commentArraySize, SceNpScoreGameInfo* infoArray, size_t infoArraySize, size_t arrayNum,
+                                                        SceRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdPcIdForCrossSave(int32_t reqId, SceNpScoreBoardId boardId, const SceNpScoreAccountIdPcId* idArray,
+                                                                    size_t idArraySize, SceNpScorePlayerRankDataForCrossSave* rankArray, size_t rankArraySize,
+                                                                    SceNpScoreComment* commentArray, size_t commentArraySize, SceNpScoreGameInfo* infoArray,
+                                                                    size_t infoArraySize, size_t arrayNum, SceRtcTick* lastSortDate,
+                                                                    SceNpScoreRankNumber* totalRecord, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreCensorComment(int32_t reqId, const char* comment, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreSanitizeComment(int32_t reqId, const char* comment, char* sanitizedComment, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreWaitAsync(int32_t id, int32_t* result) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScorePollAsync(int32_t reqId, int32_t* result) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetBoardInfoAsync(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreBoardInfo* boardInfo, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreRecordScoreAsync(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreValue score, const SceNpScoreComment* scoreComment,
+                                               const SceNpScoreGameInfo* gameInfo, SceNpScoreRankNumber* tmpRank, const SceRtcTick* compareDate, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreRecordGameDataAsync(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreValue score, size_t totalSize, size_t sendSize,
+                                                  const void* data, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdAsync(int32_t reqId, SceNpScoreBoardId boardId, const SceNpAccountId accountIdArray[],
+                                                         size_t accountIdArraySize, SceNpScorePlayerRankDataA* rankArray, size_t rankArraySize,
+                                                         SceNpScoreComment* commentArray, size_t commentArraySize, SceNpScoreGameInfo* infoArray,
+                                                         size_t infoArraySize, size_t arrayNum, SceRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord,
+                                                         void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdForCrossSaveAsync(int32_t reqId, SceNpScoreBoardId boardId, const SceNpAccountId accountIdArray[],
+                                                                     size_t accountIdArraySize, SceNpScorePlayerRankDataForCrossSave* rankArray,
+                                                                     size_t rankArraySize, SceNpScoreComment* commentArray, size_t commentArraySize,
+                                                                     SceNpScoreGameInfo* infoArray, size_t infoArraySize, size_t arrayNum,
+                                                                     SceRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetRankingByRangeAAsync(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank,
+                                                      SceNpScoreRankDataA* rankArray, size_t rankArraySize, SceNpScoreComment* commentArray,
+                                                      size_t commentArraySize, SceNpScoreGameInfo* infoArray, size_t infoArraySize, size_t arrayNum,
+                                                      SceRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetRankingByRangeForCrossSaveAsync(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank,
+                                                                 SceNpScoreRankDataForCrossSave* rankArray, size_t rankArraySize,
+                                                                 SceNpScoreComment* commentArray, size_t commentArraySize, SceNpScoreGameInfo* infoArray,
+                                                                 size_t infoArraySize, size_t arrayNum, SceRtcTick* lastSortDate,
+                                                                 SceNpScoreRankNumber* totalRecord, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdPcIdAsync(int32_t reqId, SceNpScoreBoardId boardId, const SceNpScoreAccountIdPcId* idArray,
+                                                             size_t idArraySize, SceNpScorePlayerRankDataA* rankArray, size_t rankArraySize,
+                                                             SceNpScoreComment* commentArray, size_t commentArraySize, SceNpScoreGameInfo* infoArray,
+                                                             size_t infoArraySize, size_t arrayNum, SceRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord,
+                                                             void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdPcIdForCrossSaveAsync(int32_t reqId, SceNpScoreBoardId boardId, const SceNpScoreAccountIdPcId* idArray,
+                                                                         size_t idArraySize, SceNpScorePlayerRankDataForCrossSave* rankArray,
+                                                                         size_t rankArraySize, SceNpScoreComment* commentArray, size_t commentArraySize,
+                                                                         SceNpScoreGameInfo* infoArray, size_t infoArraySize, size_t arrayNum,
+                                                                         SceRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetFriendsRankingA(int32_t reqId, SceNpScoreBoardId boardId, int32_t includeSelf, SceNpScoreRankDataA* rankArray,
+                                                 size_t rankArraySize, SceNpScoreComment* commentArray, size_t commentArraySize, SceNpScoreGameInfo* infoArray,
+                                                 size_t infoArraySize, size_t arrayNum, SceRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord,
+                                                 SceNpScoreGetFriendRankingOptParam* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetFriendsRankingAAsync(int32_t reqId, SceNpScoreBoardId boardId, int32_t includeSelf, SceNpScoreRankDataA* rankArray,
+                                                      size_t rankArraySize, SceNpScoreComment* commentArray, size_t commentArraySize,
+                                                      SceNpScoreGameInfo* infoArray, size_t infoArraySize, size_t arrayNum, SceRtcTick* lastSortDate,
+                                                      SceNpScoreRankNumber* totalRecord, SceNpScoreGetFriendRankingOptParam* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetFriendsRankingForCrossSave(int32_t reqId, SceNpScoreBoardId boardId, int32_t includeSelf,
+                                                            SceNpScoreRankDataForCrossSave* rankArray, size_t rankArraySize, SceNpScoreComment* commentArray,
+                                                            size_t commentArraySize, SceNpScoreGameInfo* infoArray, size_t infoArraySize, size_t arrayNum,
+                                                            SceRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord,
+                                                            SceNpScoreGetFriendRankingOptParam* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreGetFriendsRankingForCrossSaveAsync(int32_t reqId, SceNpScoreBoardId boardId, int32_t includeSelf,
+                                                                 SceNpScoreRankDataForCrossSave* rankArray, size_t rankArraySize,
+                                                                 SceNpScoreComment* commentArray, size_t commentArraySize, SceNpScoreGameInfo* infoArray,
+                                                                 size_t infoArraySize, size_t arrayNum, SceRtcTick* lastSortDate,
+                                                                 SceNpScoreRankNumber* totalRecord, SceNpScoreGetFriendRankingOptParam* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreCensorCommentAsync(int32_t reqId, const char* comment, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpScoreSanitizeCommentAsync(int32_t reqId, const char* comment, char* sanitizedComment, void* option) {
+  LOG_USE_MODULE(libSceNpScore);
+  LOG_ERR(L"todo %S", __FUNCTION__);
+  return Ok;
+}
+}
--- a/modules/libSceNpScore/types.h
+++ b/modules/libSceNpScore/types.h
@ -0,0 +1,84 @@
+#pragma once
+#include "codes.h"
+#include "common.h"
+#include "modules/libSceNpManager/types.h"
+
+typedef uint32_t SceNpScoreBoardId;
+typedef int64_t  SceNpScoreValue;
+typedef uint32_t SceNpScoreRankNumber;
+typedef int32_t  SceNpScorePcId;
+
+typedef struct SceNpScoreGameInfo {
+  size_t  infoSize;
+  uint8_t data[SCE_NP_SCORE_GAMEINFO_MAXSIZE];
+  uint8_t pad2[3];
+} SceNpScoreGameInfo;
+
+typedef struct SceNpScoreComment {
+  char utf8Comment[SCE_NP_SCORE_COMMENT_MAXLEN + 1];
+} SceNpScoreComment;
+
+typedef struct SceNpScoreRankDataA {
+  SceNpOnlineId        onlineId;
+  uint8_t              reserved0[16];
+  uint8_t              reserved[49];
+  uint8_t              pad0[3];
+  SceNpScorePcId       pcId;
+  SceNpScoreRankNumber serialRank;
+  SceNpScoreRankNumber rank;
+  SceNpScoreRankNumber highestRank;
+  int32_t              hasGameData;
+  uint8_t              pad1[4];
+  SceNpScoreValue      scoreValue;
+  SceRtcTick           recordDate;
+  SceNpAccountId       accountId;
+  uint8_t              pad2[8];
+} SceNpScoreRankDataA;
+
+typedef struct SceNpScoreRankDataForCrossSave {
+  SceNpId              npId;
+  uint8_t              reserved[49];
+  uint8_t              pad0[3];
+  SceNpScorePcId       pcId;
+  SceNpScoreRankNumber serialRank;
+  SceNpScoreRankNumber rank;
+  SceNpScoreRankNumber highestRank;
+  int32_t              hasGameData;
+  uint8_t              pad1[4];
+  SceNpScoreValue      scoreValue;
+  SceRtcTick           recordDate;
+  SceNpAccountId       accountId;
+  uint8_t              pad2[8];
+} SceNpScoreRankDataForCrossSave;
+
+typedef struct SceNpScorePlayerRankDataA {
+  int32_t             hasData;
+  uint8_t             pad0[4];
+  SceNpScoreRankDataA rankData;
+} SceNpScorePlayerRankDataA;
+
+typedef struct SceNpScorePlayerRankDataForCrossSave {
+  int32_t                        hasData;
+  uint8_t                        pad0[4];
+  SceNpScoreRankDataForCrossSave rankData;
+} SceNpScorePlayerRankDataForCrossSave;
+
+typedef struct SceNpScoreBoardInfo {
+  uint32_t             rankLimit;
+  uint32_t             updateMode;
+  uint32_t             sortMode;
+  SceNpScoreRankNumber uploadNumLimit;
+  size_t               uploadSizeLimit;
+} SceNpScoreBoardInfo;
+
+typedef struct SceNpScoreAccountIdPcId {
+  SceNpAccountId accountId;
+  SceNpScorePcId pcId;
+  uint8_t        pad[4];
+} SceNpScoreAccountIdPcId;
+
+typedef struct SceNpScoreGetFriendRankingOptParam {
+  size_t                size;
+  SceNpScoreRankNumber* startSerialRank;
+  SceNpScoreRankNumber* hits;
+} SceNpScoreGetFriendRankingOptParam;
--- a/modules/libSceNpTrophy/CMakeLists.txt
+++ b/modules/libSceNpTrophy/CMakeLists.txt
@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceNpTrophy)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp)
+
+setupModule(${libName})
--- a/modules/libSceNpTrophy/codes.h
+++ b/modules/libSceNpTrophy/codes.h
@ -0,0 +1,19 @@
+#pragma once
+#include <stdint.h>
+
+namespace Err {
+constexpr int32_t SCE_NP_TROPHY_INVALID_HANDLE     = (-1);
+constexpr int32_t SCE_NP_TROPHY_INVALID_CONTEXT    = (-1);
+constexpr int32_t SCE_NP_TROPHY_INVALID_TROPHY_ID  = (-1);
+constexpr int32_t SCE_NP_TROPHY_INVALID_GROUP_ID   = (-2);
+constexpr int32_t SCE_NP_TROPHY_BASE_GAME_GROUP_ID = (-1);
+} // namespace Err
+
+constexpr uint32_t SCE_NP_TROPHY_NUM_MAX                   = (128);
+constexpr uint32_t SCE_NP_TROPHY_SCREENSHOT_TARGET_NUM_MAX = (4);
+constexpr uint32_t SCE_NP_TROPHY_GAME_TITLE_MAX_SIZE       = (128);
+constexpr uint32_t SCE_NP_TROPHY_GAME_DESCR_MAX_SIZE       = (1024);
+constexpr uint32_t SCE_NP_TROPHY_GROUP_TITLE_MAX_SIZE      = (128);
+constexpr uint32_t SCE_NP_TROPHY_GROUP_DESCR_MAX_SIZE      = (1024);
+constexpr uint32_t SCE_NP_TROPHY_NAME_MAX_SIZE             = (128);
+constexpr uint32_t SCE_NP_TROPHY_DESCR_MAX_SIZE            = (1024);
--- a/modules/libSceNpTrophy/entry.cpp
+++ b/modules/libSceNpTrophy/entry.cpp
@ -0,0 +1,134 @@
+#include "../libSceNpManager/types.h"
+#include "common.h"
+#include "types.h"
+
+#include <logging.h>
+
+LOG_DEFINE_MODULE(libSceNpTrophy);
+
+namespace {} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceNpTrophy";
+
+EXPORT SYSV_ABI int sceNpTrophyCreateHandle(SceNpTrophyHandle* handle) {
+  *handle = 1;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpTrophyDestroyHandle(SceNpTrophyHandle handle) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpTrophyAbortHandle(SceNpTrophyHandle handle) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpTrophyCreateContext(SceNpTrophyContext* context, int32_t userId, SceNpServiceLabel serviceLabel, uint64_t options) {
+  *context = 1;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpTrophyDestroyContext(SceNpTrophyContext context) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpTrophyRegisterContext(SceNpTrophyContext context, SceNpTrophyHandle handle, uint64_t options) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpTrophyUnlockTrophy(SceNpTrophyContext context, SceNpTrophyHandle handle, SceNpTrophyId trophyId, SceNpTrophyId* platinumId) {
+  *platinumId = Err::SCE_NP_TROPHY_INVALID_TROPHY_ID;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpTrophyGetTrophyUnlockState(SceNpTrophyContext context, SceNpTrophyHandle handle, SceNpTrophyFlagArray* flags, uint32_t* count) {
+  flags->flagBits[0] = 0;
+  flags->flagBits[1] = 0;
+  flags->flagBits[2] = 0;
+  flags->flagBits[3] = 0;
+
+  *count = 2;
+
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpTrophyGetGameInfo(SceNpTrophyContext context, SceNpTrophyHandle handle, SceNpTrophyGameDetails* details, SceNpTrophyGameData* data) {
+  details->numGroups   = 0;
+  details->numTrophies = 1;
+  details->numPlatinum = 0;
+  details->numGold     = 0;
+  details->numSilver   = 0;
+  details->numBronze   = 1;
+
+  strcpy_s(details->title, "tropyName");
+  strcpy_s(details->description, "tropyDesc");
+
+  if (data != nullptr) {
+    data->unlockedTrophies   = 0;
+    data->unlockedPlatinum   = 0;
+    data->unlockedGold       = 0;
+    data->unlockedSilver     = 0;
+    data->unlockedBronze     = 0;
+    data->progressPercentage = 0;
+  }
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpTrophyGetGroupInfo(SceNpTrophyContext context, SceNpTrophyHandle handle, SceNpTrophyGroupId groupId, SceNpTrophyGroupDetails* details,
+                                            SceNpTrophyGroupData* data) {
+  if (details != nullptr) {
+    details->groupId     = groupId;
+    details->numTrophies = 0;
+    details->numPlatinum = 0;
+    details->numGold     = 0;
+    details->numSilver   = 0;
+    details->numBronze   = 0;
+
+    strcpy_s(details->title, "groupName");
+    strcpy_s(details->description, "groupDesc");
+  }
+
+  if (data != nullptr) {
+    data->groupId            = groupId;
+    data->unlockedTrophies   = 0;
+    data->unlockedPlatinum   = 0;
+    data->unlockedGold       = 0;
+    data->unlockedSilver     = 0;
+    data->unlockedBronze     = 0;
+    data->progressPercentage = 0;
+  }
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpTrophyGetTrophyInfo(SceNpTrophyContext context, SceNpTrophyHandle handle, SceNpTrophyId trophyId, SceNpTrophyDetails* details,
+                                             SceNpTrophyData* data) {
+  if (details != nullptr) {
+    details->trophyId    = trophyId;
+    details->trophyGrade = SceNpTrophyGrade::GRADE_BRONZE;
+    details->groupId     = -1;
+    details->hidden      = false;
+
+    strcpy_s(details->name, "tropyName");
+    strcpy_s(details->description, "tropyDesc");
+  }
+
+  if (data != nullptr) {
+    data->trophyId  = trophyId;
+    data->unlocked  = false;
+    data->timestamp = 0;
+  }
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpTrophyGetGameIcon(SceNpTrophyContext context, SceNpTrophyHandle handle, void* buffer, size_t* size) {
+  *size              = 8;
+  *(uint64_t*)buffer = 0;
+
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpTrophyGetGroupIcon(SceNpTrophyContext context, SceNpTrophyHandle handle, SceNpTrophyGroupId groupId, void* buffer, size_t* size) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpTrophyGetTrophyIcon(SceNpTrophyContext context, SceNpTrophyHandle handle, SceNpTrophyId trophyId, void* buffer, size_t* size) {
+  *size              = 8;
+  *(uint64_t*)buffer = 0;
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpTrophyShowTrophyList(SceNpTrophyContext context, SceNpTrophyHandle handle) {
+  return Ok;
+}
+EXPORT SYSV_ABI int sceNpTrophyCaptureScreenshot(SceNpTrophyHandle handle, const SceNpTrophyScreenshotTarget* targets, uint32_t numTargets) {
+  return Ok;
+}
+}
--- a/modules/libSceNpTrophy/types.h
+++ b/modules/libSceNpTrophy/types.h
@ -0,0 +1,117 @@
+#pragma once
+#include "codes.h"
+
+typedef int32_t SceNpTrophyHandle;
+typedef int32_t SceNpTrophyContext;
+typedef int32_t SceNpTrophyId;
+typedef int32_t SceNpTrophyGroupId;
+
+enum class SceNpTrophyGrade : unsigned int {
+  GRADE_PLATINUM = 1, // PLATINUM
+  GRADE_GOLD     = 2, // GOLD
+  GRADE_SILVER   = 3, // SILVER
+  GRADE_BRONZE   = 4, // BRONZE
+
+};
+
+typedef uint32_t SceNpTrophyFlagMask;
+/* trophy flag array */
+
+constexpr uint32_t SCE_NP_TROPHY_FLAG_SETSIZE    = (128);
+constexpr uint32_t SCE_NP_TROPHY_FLAG_BITS       = (sizeof(SceNpTrophyFlagMask) * 8);
+constexpr uint32_t SCE_NP_TROPHY_FLAG_BITS_ALL   = ((SceNpTrophyFlagMask)-1);
+constexpr uint32_t SCE_NP_TROPHY_FLAG_BITS_SHIFT = (5);
+constexpr uint32_t SCE_NP_TROPHY_FLAG_BITS_MASK  = (SCE_NP_TROPHY_FLAG_BITS - 1);
+constexpr uint32_t SCE_NP_TROPHY_FLAG_BITS_MAX   = (SCE_NP_TROPHY_FLAG_SETSIZE - 1);
+
+typedef struct SceNpTrophyFlagArray {
+  SceNpTrophyFlagMask flagBits[SCE_NP_TROPHY_FLAG_SETSIZE >> SCE_NP_TROPHY_FLAG_BITS_SHIFT];
+} SceNpTrophyFlagArray;
+
+#define SCE_NP_TROPHY_FLAG_SET(n, p)   ((p)->flagBits[(n) >> SCE_NP_TROPHY_FLAG_BITS_SHIFT] |= (1 << ((n)&SCE_NP_TROPHY_FLAG_BITS_MASK)))
+#define SCE_NP_TROPHY_FLAG_CLR(n, p)   ((p)->flagBits[(n) >> SCE_NP_TROPHY_FLAG_BITS_SHIFT] &= ~(1 << ((n)&SCE_NP_TROPHY_FLAG_BITS_MASK)))
+#define SCE_NP_TROPHY_FLAG_ISSET(n, p) ((p)->flagBits[(n) >> SCE_NP_TROPHY_FLAG_BITS_SHIFT] & (1 << ((n)&SCE_NP_TROPHY_FLAG_BITS_MASK)))
+#define SCE_NP_TROPHY_FLAG_ZERO(p)                                                                                                                             \
+  do {                                                                                                                                                         \
+    SceNpTrophyFlagArray* __fa = (p);                                                                                                                          \
+    SceNpTrophyFlagMask   __i;                                                                                                                                 \
+    for (__i = 0; __i < (SCE_NP_TROPHY_FLAG_SETSIZE >> SCE_NP_TROPHY_FLAG_BITS_SHIFT); __i++)                                                                  \
+      __fa->flagBits[__i] = 0;                                                                                                                                 \
+  } while (0)
+#define SCE_NP_TROPHY_FLAG_SET_ALL(p)                                                                                                                          \
+  do {                                                                                                                                                         \
+    SceNpTrophyFlagArray* __fa = (p);                                                                                                                          \
+    SceNpTrophyFlagMask   __i;                                                                                                                                 \
+    for (__i = 0; __i < (SCE_NP_TROPHY_FLAG_SETSIZE >> SCE_NP_TROPHY_FLAG_BITS_SHIFT); __i++)                                                                  \
+      __fa->flagBits[__i] = SCE_NP_TROPHY_FLAG_BITS_ALL;                                                                                                       \
+  } while (0)
+
+typedef struct SceNpTrophyGameDetails {
+  size_t   size;
+  uint32_t numGroups;
+  uint32_t numTrophies;
+  uint32_t numPlatinum;
+  uint32_t numGold;
+  uint32_t numSilver;
+  uint32_t numBronze;
+  char     title[SCE_NP_TROPHY_GAME_TITLE_MAX_SIZE];
+  char     description[SCE_NP_TROPHY_GAME_DESCR_MAX_SIZE];
+} SceNpTrophyGameDetails;
+
+typedef struct SceNpTrophyGameData {
+  size_t   size;
+  uint32_t unlockedTrophies;
+  uint32_t unlockedPlatinum;
+  uint32_t unlockedGold;
+  uint32_t unlockedSilver;
+  uint32_t unlockedBronze;
+  uint32_t progressPercentage;
+} SceNpTrophyGameData;
+
+typedef struct SceNpTrophyGroupDetails {
+  size_t             size;
+  SceNpTrophyGroupId groupId;
+  uint32_t           numTrophies;
+  uint32_t           numPlatinum;
+  uint32_t           numGold;
+  uint32_t           numSilver;
+  uint32_t           numBronze;
+  char               title[SCE_NP_TROPHY_GROUP_TITLE_MAX_SIZE];
+  char               description[SCE_NP_TROPHY_GROUP_DESCR_MAX_SIZE];
+} SceNpTrophyGroupDetails;
+
+typedef struct SceNpTrophyGroupData {
+  size_t             size;
+  SceNpTrophyGroupId groupId;
+  uint32_t           unlockedTrophies;
+  uint32_t           unlockedPlatinum;
+  uint32_t           unlockedGold;
+  uint32_t           unlockedSilver;
+  uint32_t           unlockedBronze;
+  uint32_t           progressPercentage;
+  uint8_t            reserved[4];
+} SceNpTrophyGroupData;
+
+typedef struct SceNpTrophyDetails {
+  size_t             size;
+  SceNpTrophyId      trophyId;
+  SceNpTrophyGrade   trophyGrade;
+  SceNpTrophyGroupId groupId;
+  bool               hidden;
+  uint8_t            reserved[3];
+  char               name[SCE_NP_TROPHY_NAME_MAX_SIZE];
+  char               description[SCE_NP_TROPHY_DESCR_MAX_SIZE];
+} SceNpTrophyDetails;
+
+typedef struct SceNpTrophyData {
+  size_t        size;
+  SceNpTrophyId trophyId;
+  bool          unlocked;
+  uint8_t       reserved[3];
+  uint64_t      timestamp;
+} SceNpTrophyData;
+
+typedef struct SceNpTrophyScreenshotTarget {
+  SceNpTrophyContext context;
+  SceNpTrophyId      trophyId;
+} SceNpTrophyScreenshotTarget;
--- a/modules/libSceNpWebApi/CMakeLists.txt
+++ b/modules/libSceNpWebApi/CMakeLists.txt
@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libSceNpWebApi)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp)
+
+setupModule(${libName})
--- a/modules/libSceNpWebApi/codes.h
+++ b/modules/libSceNpWebApi/codes.h
@ -0,0 +1,13 @@
+#pragma once
+#include <stdint.h>
+#include <string>
+
+namespace Err {} // namespace Err
+
+constexpr std::string_view SCE_NP_WEBAPI_CONTENT_TYPE_APPLICATION_JSON_UTF8 = "application/json; charset=utf-8";
+
+constexpr uint32_t SCE_NP_WEBAPI_DEFAULT_CONNECTION_NUM                = 1;
+constexpr uint32_t SCE_NP_WEBAPI_MAX_CONNECTION_NUM                    = 16;
+constexpr uint32_t SCE_NP_WEBAPI_PUSH_EVENT_DATA_TYPE_LEN_MAX          = 64;
+constexpr uint32_t SCE_NP_WEBAPI_EXTD_PUSH_EVENT_EXTD_DATA_KEY_LEN_MAX = 32;
+constexpr uint32_t SCE_NP_WEBAPI_NP_SERVICE_NAME_NONE                  = NULL;
--- a/modules/libSceNpWebApi/entry.cpp
+++ b/modules/libSceNpWebApi/entry.cpp
@ -0,0 +1,125 @@
+#include "../libSceNpManager/types.h"
+#include "common.h"
+#include "types.h"
+
+#include <logging.h>
+
+LOG_DEFINE_MODULE(libSceNpWebApi);
+
+namespace {
+using SceNpWebApiExtdPushEventCallbackA = SYSV_ABI void (*)(int32_t userCtxId, int32_t callbackId, const char* pNpServiceName, SceNpServiceLabel npServiceLabel,
+                                                            const SceNpPeerAddressA* pTo, const SceNpOnlineId* pToOnlineId, const SceNpPeerAddressA* pFrom,
+                                                            const SceNpOnlineId* pFromOnlineId, const SceNpWebApiPushEventDataType* pDataType,
+                                                            const char* pData, size_t dataLen, const SceNpWebApiExtdPushEventExtdData* pExtdData,
+                                                            size_t extdDataNum, void* pUserArg);
+
+} // namespace
+
+extern "C" {
+
+EXPORT const char* MODULE_NAME = "libSceNpWebApi";
+
+EXPORT SYSV_ABI int32_t sceNpWebApiCreateExtdPushEventFilter(int32_t libCtxId, int32_t handleId, const char* pNpServiceName, SceNpServiceLabel npServiceLabel,
+                                                             const SceNpWebApiExtdPushEventFilterParameter* pFilterParam, size_t filterParamNum) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiDeleteExtdPushEventFilter(int32_t libCtxId, int32_t filterId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiRegisterExtdPushEventCallbackA(int32_t userCtxId, int32_t filterId, SceNpWebApiExtdPushEventCallbackA cbFunc,
+                                                                  void* pUserArg) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiUnregisterExtdPushEventCallback(int32_t userCtxId, int32_t callbackId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiInitialize(int libHttpCtxId, size_t poolSize) {
+  static int id = 0;
+  return ++id;
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiTerminate(int32_t libCtxId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiCreateContextA(int32_t libCtxId, int32_t userId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiDeleteContext(int32_t titleUserCtxId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiCreateRequest(int32_t titleUserCtxId, const char* pApiGroup, const char* pPath, SceNpWebApiHttpMethod method,
+                                                 const SceNpWebApiContentParameter* pContentParameter, int64_t* pRequestId) {
+  *pRequestId = 0;
+  return -1;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiCreateMultipartRequest(int32_t titleUserCtxId, const char* pApiGroup, const char* pPath, SceNpWebApiHttpMethod method,
+                                                          int64_t* pRequestId) {
+  *pRequestId = 0;
+  return -1;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiDeleteRequest(int64_t requestId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiSendRequest2(int64_t requestId, const void* pData, size_t dataSize, SceNpWebApiResponseInformationOption* pRespInfoOption) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiSendMultipartRequest2(int64_t requestId, int32_t partIndex, const void* pData, size_t dataSize,
+                                                         SceNpWebApiResponseInformationOption* pRespInfoOption) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiReadData(int64_t requestId, void* pData, size_t size) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiSetMultipartContentType(int64_t requestId, const char* pTypeName, const char* pBoundary) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiAddMultipartPart(int64_t requestId, const SceNpWebApiMultipartPartParameter* pParam, int32_t* pIndex) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiAddHttpRequestHeader(int64_t requestId, const char* pFieldName, const char* pValue) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiGetHttpResponseHeaderValueLength(int64_t requestId, const char* pFieldName, size_t* pValueLength) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiGetHttpResponseHeaderValue(int64_t requestId, const char* pFieldName, char* pValue, size_t valueSize) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiAbortRequest(int64_t requestId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiCreateHandle(int32_t libCtxId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiDeleteHandle(int32_t libCtxId, int32_t handleId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiAbortHandle(int32_t libCtxId, int32_t handleId) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiGetMemoryPoolStats(int32_t libCtxId, SceNpWebApiMemoryPoolStats* pCurrentStat) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiSetMaxConnection(int32_t libCtxId, int32_t maxConnection) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiClearUnusedConnection(int32_t userCtxId, const char* pApiGroup, bool bRemainKeepAliveConnection) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiClearAllUnusedConnection(int32_t userCtxId, bool bRemainKeepAliveConnection) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiGetConnectionStats(int32_t userCtxId, const char* pApiGroup, SceNpWebApiConnectionStats* pStats) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiSetRequestTimeout(int64_t requestId, uint32_t timeout) {
+  return Ok;
+}
+EXPORT SYSV_ABI int32_t sceNpWebApiSetHandleTimeout(int32_t libCtxId, int32_t handleId, uint32_t timeout) {
+  return Ok;
+}
+EXPORT SYSV_ABI void    sceNpWebApiCheckTimeout(void) {}
+EXPORT SYSV_ABI int32_t sceNpWebApiUtilityParseNpId(const char* pJsonNpId, SceNpId* pNpId) {
+  return Ok;
+}
+}
--- a/modules/libSceNpWebApi/types.h
+++ b/modules/libSceNpWebApi/types.h
@ -0,0 +1,65 @@
+#pragma once
+#include "codes.h"
+
+enum class SceNpWebApiHttpMethod { GET, POST, PUT, DELETE };
+
+struct SceNpWebApiMemoryPoolStats {
+  size_t poolSize;         /*E Total memory size */
+  size_t maxInuseSize;     /*E Max memory usage */
+  size_t currentInuseSize; /*E Current memory usage */
+};
+
+struct SceNpWebApiResponseInformationOption {
+  int32_t httpStatus;
+  char*   pErrorObject;
+  size_t  errorObjectSize;
+  size_t  responseDataSize;
+};
+
+struct SceNpWebApiConnectionStats {
+  uint32_t max;
+  uint32_t used;
+  uint32_t unused;
+  uint32_t keepAlive;
+};
+
+struct SceNpWebApiContentParameter {
+  size_t      contentLength;
+  const char* pContentType;
+  uint8_t     reserved[16];
+};
+
+struct SceNpWebApiHttpHeader {
+  char* pName;
+  char* pValue;
+};
+
+struct SceNpWebApiMultipartPartParameter {
+  SceNpWebApiHttpHeader* pHeaders;
+  size_t                 headerNum;
+  size_t                 contentLength;
+};
+
+/*
+ * Extended Push Event
+ */
+
+struct SceNpWebApiPushEventDataType {
+  char val[SCE_NP_WEBAPI_PUSH_EVENT_DATA_TYPE_LEN_MAX + 1];
+};
+
+struct SceNpWebApiExtdPushEventExtdDataKey {
+  char val[SCE_NP_WEBAPI_EXTD_PUSH_EVENT_EXTD_DATA_KEY_LEN_MAX + 1];
+};
+
+struct SceNpWebApiExtdPushEventFilterParameter {
+  SceNpWebApiPushEventDataType         dataType;
+  SceNpWebApiExtdPushEventExtdDataKey* pExtdDataKey;
+  size_t                               extdDataKeyNum;
+};
+
+struct SceNpWebApiExtdPushEventExtdData {
+  SceNpWebApiExtdPushEventExtdDataKey extdDataKey;
+  char*                               pData;
+  size_t                              dataLen;
+};
--- a/modules/libScePad/CMakeLists.txt
+++ b/modules/libScePad/CMakeLists.txt
@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.24)
+include(../setupModule.cmake)
+
+set(libName libScePad)
+project(${libName})
+
+add_library(${libName} SHARED entry.cpp)
+
+target_link_libraries(${libName} PRIVATE glfw3 emulator.lib ${Vulkan_LIBRARIES})
+
+setupModule(${libName})
--- a/Show More
+++ b/Show More