# Architecture of the wm_proxy Plugin: WebMAN MOD's XMB Integration Explained

> Discover the architecture of the wm_proxy plugin, WebMAN MOD's XMB integration solution. Learn how it embeds PS3 functionality into the native XMB using the wm:// scheme.

- Repository: [Aldo Vargas/webman-mod](https://github.com/aldostools/webman-mod)
- Tags: architecture
- Published: 2026-02-24

---

**The wm_proxy plugin serves as a low-level bridge that embeds WebMAN MOD's functionality directly into the PlayStation 3's native XMB interface by implementing the standard explore_plugin pattern and exposing virtual filesystem mounts via the `wm://` scheme.**

WebMAN MOD extends the PlayStation 3's capabilities through advanced homebrew tools, and its seamless integration with the system's native Cross-Media Bar (XMB) relies on a specialized kernel module called wm_proxy. According to the aldostools/webman-mod source code, this plugin follows the standard PS3 explore_plugin architecture to register custom callbacks, handle virtual filesystem mounts, and parse multi-disc cue files while operating within the constraints of the PS3's embedded environment.

## Core Architectural Components

The wm_proxy plugin is structured as a compact PRX module that combines system-level callback registration with virtual filesystem operations. Its design centers on six primary components that handle everything from low-level type translation to high-level XMB command execution.

### Entry Point and PRX Initialization

The plugin lifecycle begins in [`_Projects_/wm_proxy/main.c`](https://github.com/aldostools/webman-mod/blob/main/_Projects_/wm_proxy/main.c), where the `main()` function serves as the entry point for the PRX module loaded by the PS3 kernel. This initialization routine wraps C symbol exports using `EXTERN_BEGIN` and `EXTERN_END` macros to ensure proper symbol visibility for the PS3's runtime linker.

During startup, the code obtains the global `explore_interface` pointer defined in [`vsh/explore_plugin.h`](https://github.com/aldostools/webman-mod/blob/main/vsh/explore_plugin.h). This pointer provides access to the system's explore_plugin function table, which the XMB core uses to dispatch commands to registered plugins. The initialization sequence stores this interface pointer for later use when issuing XMB commands or responding to user interactions.

### Explore-Plugin Interface Implementation

The bridge between WebMAN MOD and the XMB relies on the `explore_plugin_interface` structure defined in [`vsh/explore_plugin.h`](https://github.com/aldostools/webman-mod/blob/main/vsh/explore_plugin.h). Through this interface, wm_proxy registers critical callback functions including `ExecXMBcommand` for general command execution and `DoUnk5` for issuing arbitrary XMB directives.

The `DoUnk5` function acts as the primary entry point for WebMAN MOD to trigger XMB actions such as opening lists, launching applications, or refreshing menu items. When the XMB core calls this function, it passes command strings that wm_proxy parses and forwards to the appropriate handlers within WebMAN MOD's core logic.

### Virtual Filesystem Mount Operations

To expose WebMAN MOD's content through the XMB's standard file browser, wm_proxy implements virtual filesystem mounting logic in [`_Projects_/wm_proxy/mount.h`](https://github.com/aldostools/webman-mod/blob/main/_Projects_/wm_proxy/mount.h). The `wm_mount()` routine creates PS3 VFS nodes that map the custom `wm://` URL scheme to the plugin's internal storage buffers.

When WebMAN MOD initializes, it requests that wm_proxy mount the virtual path (e.g., `wm://menu`). The mount handler registers these paths with the kernel's VFS layer, allowing the XMB to browse remote content, read configuration files, and launch titles as if they were local filesystem objects. This abstraction enables seamless integration of network-attached storage and custom firmware features into the native Sony interface.

### Cue-File Parsing for Multi-Disc Titles

Multi-disc PlayStation titles require special handling to present proper metadata to the XMB. The [`_Projects_/wm_proxy/cue_file.h`](https://github.com/aldostools/webman-mod/blob/main/_Projects_/wm_proxy/cue_file.h) header implements `parse_cue()`, which reads standard `.cue` file descriptors and extracts track metadata for XMB display and automatic disc switching.

When a user selects a multi-disc image, the parser extracts the necessary disc index information and passes it back to the XMB via the `explore_interface` callbacks. This allows WebMAN MOD to manage disc swapping for titles spanning multiple image files while maintaining compatibility with the PS3's native disc mounting protocols.

### OPD Table Translation for 64-bit/32-bit Boundaries

The PS3's heterogeneous architecture requires careful handling of function pointers across the 64-bit PPU and 32-bit environments. The [`_Projects_/wm_proxy/types.h`](https://github.com/aldostools/webman-mod/blob/main/_Projects_/wm_proxy/types.h) header defines the primitive types (`u8`, `u32`, `bool`) and OPD (Official Procedure Descriptor) table macros required for proper function resolution.

Critical macros like `OPD32(ptr)` and symbols including `opd64_start` and `opd32_start` enable the plugin to translate function pointers correctly at runtime. This translation layer ensures that callbacks registered with the 64-bit XMB core can properly invoke 32-bit plugin routines without address space corruption.

### Minimal C Runtime Environment

Because the PS3 kernel environment lacks a full standard C library, [`_Projects_/wm_proxy/libc.c`](https://github.com/aldostools/webman-mod/blob/main/_Projects_/wm_proxy/libc.c) provides a minimal runtime shim implementing only essential functions. This lightweight libc replacement includes `memset`, `memcpy`, and a simplified `printf` implementation that avoids the overhead of the system's full libc.

This selective implementation keeps the PRX module size minimal while providing the necessary memory manipulation and debugging capabilities required for kernel-level plugin operation.

## XMB Integration and Data Flow

The wm_proxy plugin operates as a bidirectional conduit between WebMAN MOD's core logic and the Sony XMB interface. Understanding the data flow reveals how user interactions translate into plugin actions.

### Initialization Sequence

1. The PS3 kernel loads wm_proxy as a PRX module and invokes `main()` from [`main.c`](https://github.com/aldostools/webman-mod/blob/main/main.c).

2. The initialization routine calls `EXTERN_BEGIN` to export necessary symbols.

3. The plugin obtains the `explore_interface` pointer from the system's global VSH exports.

4. Callback registration occurs through the interface table, binding `DoUnk5` and `ExecXMBcommand` to XMB event handlers.

5. WebMAN MOD requests a mount of the `wm://` virtual filesystem via `wm_mount()`.

### Command Execution Path

When a user selects a WebMAN MOD entry in the XMB, the system invokes the registered `DoUnk5` callback with a command structure. For example, selecting a menu item might trigger a command list such as:

```c
{"open_list","wm://menu",0}

```

The plugin forwards this to `ExecXMBcommand`, which resolves the virtual path through the mounted filesystem abstraction.

If the selected content represents a multi-disc title, the execution path calls `parse_cue()` from [`cue_file.h`](https://github.com/aldostools/webman-mod/blob/main/cue_file.h) to extract track information. The parser identifies the appropriate disc image segment and communicates the selection back to the XMB through the `explore_interface` callbacks, triggering the actual content launch.

## Summary

- The wm_proxy plugin implements the standard PS3 explore_plugin pattern to bridge WebMAN MOD with the native XMB interface.

- Entry point and callback registration occur in [`_Projects_/wm_proxy/main.c`](https://github.com/aldostools/webman-mod/blob/main/_Projects_/wm_proxy/main.c), which obtains the system `explore_interface` pointer from [`vsh/explore_plugin.h`](https://github.com/aldostools/webman-mod/blob/main/vsh/explore_plugin.h).

- Virtual filesystem operations in [`_Projects_/wm_proxy/mount.h`](https://github.com/aldostools/webman-mod/blob/main/_Projects_/wm_proxy/mount.h) expose the `wm://` scheme to the XMB, enabling browsing of WebMAN MOD content.

- Multi-disc support relies on [`_Projects_/wm_proxy/cue_file.h`](https://github.com/aldostools/webman-mod/blob/main/_Projects_/wm_proxy/cue_file.h) to parse `.cue` files and manage disc switching metadata.

- OPD translation macros in [`_Projects_/wm_proxy/types.h`](https://github.com/aldostools/webman-mod/blob/main/_Projects_/wm_proxy/types.h) handle 64-bit/32-bit function pointer boundaries critical for PS3 kernel stability.

- A minimal libc implementation in [`_Projects_/wm_proxy/libc.c`](https://github.com/aldostools/webman-mod/blob/main/_Projects_/wm_proxy/libc.c) provides essential runtime functions without bloating the PRX module size.

## Frequently Asked Questions

### What is the primary role of the wm_proxy plugin in WebMAN MOD?

The wm_proxy plugin acts as a kernel-level proxy that exposes WebMAN MOD's functionality through the PlayStation 3's native XMB interface. According to the aldostools/webman-mod source code, it implements the explore_plugin interface to register custom callbacks and mounts a virtual filesystem that allows the XMB to browse and launch homebrew content as if it were standard system data.

### How does wm_proxy communicate with the PS3 XMB?

Communication occurs through the `explore_interface` pointer obtained during initialization in [`main.c`](https://github.com/aldostools/webman-mod/blob/main/main.c). The plugin registers functions like `DoUnk5` and `ExecXMBcommand` with the XMB core, enabling WebMAN MOD to send arbitrary commands such as opening menus or launching applications. When users select WebMAN MOD items, the XMB dispatches calls through these registered callbacks.

### What is the significance of the `wm://` virtual filesystem scheme?

The `wm://` scheme represents a virtual mount point created by `wm_mount()` in [`mount.h`](https://github.com/aldostools/webman-mod/blob/main/mount.h) that abstracts WebMAN MOD's storage layer. This allows the XMB's standard file browser to navigate remote content, configuration files, and disc images without requiring modifications to the Sony system browser itself. The scheme functions as a bridge between the physical storage backend and the XMB's UI layer.

### Why does wm_proxy require OPD (Official Procedure Descriptor) translation?

The PS3 utilizes OPD tables to manage function calls across the boundary between 64-bit system interfaces and 32-bit plugin environments. The [`types.h`](https://github.com/aldostools/webman-mod/blob/main/types.h) header defines `OPD32` macros and related symbols that ensure function pointers resolve correctly at runtime, preventing crashes when the 64-bit XMB core invokes 32-bit plugin routines. This translation layer is essential for stable kernel-level plugin operation.