Plugin SDK Architecture and ABI Concept

Overview

As part of Phase 2 (Real Plugin SDK), Octanium introduces the capability for third-party developers to create and distribute standalone applications. These applications, referred to as "plugins," integrate seamlessly with the shell and host environments without modifying the core system repository.

Plugin Types

1. Frontend-Only Plugins (Web Apps): Primarily built using web technologies (HTML, CSS, JS) and executed within a webview wrapper, communicating with the system via a limited IPC subset.
2. Native Plugins (WASM / ABI): High-performance plugins compiled to WebAssembly (WASM) or a stable binary interface, allowing deeper integration and system-level operations via the Rust core.

Plugin Manifest

Every plugin must include a manifest.json describing its metadata, permissions, and entry points.

{
  "id": "com.developer.myapp",
  "name": "My App",
  "version": "1.0.0",
  "description": "An example plugin application.",
  "entrypoint": "index.html", // or "plugin.wasm"
  "icon": "icon.png",
  "permissions": [
    "fs:read:workspace",
    "notifications:show"
  ]
}

Storage and Loading

Plugins will be stored in a dedicated directory: ~/.octanium/plugins/. The system will:

1. Scan this directory on startup.
2. Read the manifest.json of each subfolder.
3. Register the valid plugins in the AppRegistry.
4. Expose the list to the Launcher and Taskbar.

IPC Interface and ABI

The core system (Tauri Rust backend) exposes a standardized API for plugins.

Communication Channel

Plugins communicate with the host via an event-bus or direct invoke mechanism, wrapped in a developer SDK.

Standard APIs

• os.fs.read(path): Bounded filesystem read.
• os.window.spawn(config): Create a new window instance.
• os.notifications.send(title, body): Trigger a system notification.
• os.state.get(key): Access shared plugin state.

Security and Isolation

• Plugins are strictly sandboxed.
• Filesystem access is limited to the workspace and the plugin's own data folder.
• Processes cannot be spawned arbitrarily; they must be declared in permissions and routed through os.process.spawn.

Next Steps for Implementation

1. Registry Update: Modify src-tauri/src/core/registry.rs to load dynamically from the ~/.octanium/plugins/ directory.
2. SDK Repository: Create a separate TypeScript package octanium-sdk for frontend developers.
3. WASM Host (Optional): Evaluate wasmtime for executing native plugins safely in the Rust backend.