Orbis: Building a Modern Plugin-Driven Desktop Platform

Introduction

Desktop application development has traditionally required choosing between native performance and development velocity. Orbis represents a fresh approach to this challenge, combining Rust’s performance and safety with React’s developer experience while introducing a novel plugin architecture that prioritizes security and extensibility.

The platform emerged from practical needs in the cybersecurity tooling space, where teams require extensible applications that maintain security boundaries while providing rich user interfaces. Traditional approaches either sacrifice security through loose plugin systems or impose significant development overhead through restrictive APIs. Orbis addresses these challenges through its schema-driven architecture and WebAssembly sandboxing.

Architecture Overview

The Orbis architecture separates concerns through a well-defined layer structure. At its foundation, the Rust backend provides high-performance data processing, plugin management, and system integration. The Tauri layer bridges native functionality with web technologies, enabling secure IPC and window management. The React frontend renders user interfaces based on JSON schemas rather than hardcoded components, allowing plugins to define UI without shipping React code.

This layered approach enables several key capabilities. Plugins run in isolated WebAssembly environments with configurable permissions, preventing malicious or buggy code from compromising the host application. The schema-driven UI system allows plugins to define interfaces declaratively, eliminating the need to bundle UI frameworks and reducing plugin size significantly. Page-level state management ensures that plugins cannot interfere with each other’s state, maintaining clean boundaries between different functionality.

Schema-Driven UI System

The most distinctive aspect of Orbis is its schema-driven UI approach. Rather than requiring plugins to include React code and components, they simply provide JSON schemas describing the desired interface. The core SchemaRenderer interprets these schemas and renders appropriate shadcn/ui components dynamically.

1
{
2
  "type": "Form",
3
  "props": {
4
    "title": "User Configuration",
5
    "fields": [
6
      {
7
        "name": "username",
8
        "type": "text",
9
        "label": "Username",
10
        "required": true,
11
        "validation": {
12
          "minLength": 3,
13
          "pattern": "^[a-zA-Z0-9_-]+$"
14
        }
15
      },
16
      {
17
        "name": "role",
18
        "type": "select",
19
        "label": "User Role",
20
        "options": [
21
          { "value": "admin", "label": "Administrator" },
22
          { "value": "user", "label": "Standard User" },
23
          { "value": "guest", "label": "Guest" }
24
        ]
25
      }
26
    ],
27
    "actions": [
28
      {
29
        "type": "submit",
30
        "label": "Save Configuration",
31
        "onSubmit": {
32
          "action": "callApi",
33
          "endpoint": "/api/users",
34
          "method": "POST",
35
          "body": "{{state.formData}}"
36
        }
37
      }
38
    ]
39
  }
40
}

This approach delivers significant benefits. Plugins remain small because they don’t bundle UI frameworks or components. The core platform can update components and styling without requiring plugin updates. Schema validation ensures UI consistency across all plugins. Most importantly, the security boundary remains clear since plugins never execute code in the main UI context.

The expression interpolation system enables reactive updates through simple template syntax. Values like {{state.username}} automatically reflect the current state, updating the UI whenever the underlying data changes. This declarative approach reduces complexity while maintaining full functionality for interactive applications.

Plugin System Architecture

Orbis plugins execute in WebAssembly sandboxes managed by the wasmtime runtime. Each plugin declares required capabilities in its manifest, and the platform enforces these permissions at runtime. A plugin requesting network access receives a capability token that must accompany all network requests, preventing unauthorized network activity.

The action system provides plugins with controlled ways to interact with the platform. Rather than executing arbitrary code, plugins define actions that the core interprets and executes. Supported actions include updating state, calling APIs, navigating between pages, showing notifications, and opening external links. This design maintains security boundaries while providing rich functionality.

1
// Example plugin manifest
2
[package]
3
name = "security-scanner"
4
version = "1.0.0"
5

6
[plugin]
7
name = "Security Scanner"
8
description = "Automated security scanning tool"
9
author = "Security Team"
10
required_capabilities = ["network", "filesystem.read"]
11

12
[[plugin.pages]]
13
path = "/scanner"
14
title = "Security Scanner"
15
schema_file = "ui/scanner.json"
16

17
[[plugin.routes]]
18
method = "POST"
19
path = "/api/scan"
20
handler = "scan_endpoint"

Component Library

Orbis includes over 35 built-in components covering forms, data display, navigation, feedback, and data visualization. These components follow shadcn/ui design patterns, providing consistent styling and accessibility features. Plugins reference components by name in their schemas, and the SchemaRenderer handles instantiation and lifecycle management.

The component library includes essential form inputs like text fields, selects, checkboxes, and date pickers with built-in validation. Data display components include tables with sorting and filtering, cards for content organization, and various chart types for visualization. Navigation components enable multi-step forms, tab interfaces, and breadcrumb trails. Feedback components provide toast notifications, alert dialogs, and loading states.

State Management

State management in Orbis follows a page-level approach using Zustand with Immer for immutability. Each plugin page receives its own isolated state store, preventing one plugin from interfering with another’s data. The expression system provides reactive updates throughout the UI, automatically refreshing when underlying state changes.

The lifecycle system gives plugins hooks to initialize and clean up resources. The onMount hook executes when a page loads, perfect for fetching initial data or setting up subscriptions. The onUnmount hook runs before a page unloads, enabling cleanup of resources like timers or event listeners. These hooks use the same action system as other interactions, maintaining consistency and security boundaries.

1
// State definition example
2
interface PluginState {
3
  users: User[];
4
  selectedUser: User | null;
5
  loading: boolean;
6
  filter: {
7
    role: string;
8
    search: string;
9
  };
10
}
11

12
// Actions update state immutably
13
{
14
  "action": "updateState",
15
  "path": "users",
16
  "value": "{{response.data}}"
17
}
18

19
// Expression interpolation for reactive UI
20
{
21
  "type": "Text",
22
  "props": {
23
    "content": "Found {{state.users.length}} users"
24
  }
25
}

Deployment Modes

Orbis supports two distinct deployment modes addressing different use cases. Standalone mode targets single-user scenarios with an embedded SQLite database and local server. This mode suits personal tools, development environments, and offline applications. The entire stack runs locally with no external dependencies beyond the installed application.

Client-server mode enables multi-user deployments with a central PostgreSQL database and shared server. Clients connect to the server over the network, supporting team collaboration and centralized data management. This mode includes JWT-based authentication, session management, and optional TLS encryption. Organizations can deploy the server on their infrastructure while clients access it from multiple locations.

The flexibility between modes allows applications to start simple in standalone mode and scale to client-server when collaboration becomes necessary. The same plugin code works in both modes, with the platform handling the differences in data storage and synchronization.

Security Considerations

Security forms a core design principle throughout Orbis. WebAssembly sandboxing provides strong isolation between plugins and the host system. The capability system requires explicit permission grants before plugins can access sensitive operations. JWT-based authentication in client-server mode ensures only authorized users access the system.

Password hashing uses Argon2, providing resistance against brute-force attacks. Session management includes refresh tokens and configurable expiration times. Optional TLS encryption protects data in transit between clients and servers. Plugin schemas undergo validation before execution, preventing malformed definitions from causing errors or security issues.

Development Experience

The developer experience prioritizes rapid iteration and clear debugging. Hot reload works for both frontend and backend changes during development, providing immediate feedback. The Rust backend compiles with detailed error messages helping identify issues quickly. React DevTools integrate seamlessly for frontend debugging.

Plugin development uses standard Rust tooling and Cargo for dependency management. The plugin API crate provides types and utilities simplifying common operations. Schema validation during development catches errors before runtime. Documentation covers common patterns and includes example plugins demonstrating best practices.

1
# Development workflow
2
git clone https://github.com/cyberpath-HQ/orbis
3
cd orbis
4

5
# Install dependencies
6
cd orbis && bun install
7

8
# Run in development mode with hot reload
9
bun run tauri dev
10

11
# Build a plugin
12
cd plugins/my-plugin
13
cargo build --release --target wasm32-unknown-unknown
14

15
# Test the plugin
16
cargo test

Real-World Applications

Orbis particularly suits applications requiring extensibility with security boundaries. Security tooling platforms benefit from the plugin system allowing teams to add custom scanners or analysis tools without compromising the core system. Development tool integration platforms can host multiple tools with clean separation. Administrative dashboards can provide plugin-based modules for different departments while maintaining data isolation.

The schema-driven UI proves valuable when building applications that non-developers need to extend. Technical teams can create new plugins through schemas and WASM modules without requiring deep React knowledge. Business teams can request features that technical teams implement quickly through the declarative schema system.

Future Directions

The Orbis roadmap includes several ambitious features. A visual schema editor will enable building UIs through drag-and-drop interfaces rather than writing JSON. Plugin marketplace infrastructure will facilitate discovering and installing community plugins. Enhanced collaboration features will support real-time updates across multiple users. Mobile support through Tauri’s mobile capabilities will extend Orbis to iOS and Android platforms.

Performance optimization continues as a focus area, particularly for applications with numerous plugins. The team explores incremental compilation and caching strategies to improve load times. Enhanced monitoring and profiling tools will help developers identify and resolve performance bottlenecks in their plugins.

Conclusion

Orbis demonstrates that desktop applications can combine native performance, developer productivity, and strong security boundaries. The schema-driven UI system reduces complexity while maintaining flexibility. WebAssembly sandboxing provides real isolation without sacrificing functionality. The result is a platform enabling rapid development of extensible desktop applications suitable for security-sensitive environments.

For teams building desktop tools that require plugin ecosystems, Orbis offers a compelling alternative to traditional approaches. The combination of Rust’s safety and performance with React’s developer experience creates a productive development environment. The security-first design makes it suitable for professional and enterprise deployments where plugin boundaries matter.

Explore the project on GitHub at github.com/cyberpath-HQ/orbis, read the comprehensive documentation at orbis.cyberpath-hq.com, or join the community on Discord to discuss use cases and share experiences building plugins.