A Plugin-Driven Desktop Application Platform

Overview

Orbis is a modern, extensible desktop application platform built with Rust and React. It enables developers to create powerful applications using a declarative JSON-based UI schema system, with WASM-sandboxed plugins for secure extensibility.

Key Highlights

• 🔌 No React Required: Build UI with JSON schemas - plugins don't ship React code
• 🦀 Tauri Desktop App: Native performance with Rust backend, React frontend
• 🔒 WASM Sandboxing: Secure plugin isolation with configurable permissions
• 📊 35+ Components: Rich component library including forms, tables, charts, and more
• ⚡ Reactive State: Zustand-powered state management with expression interpolation
• 🎨 shadcn/ui: Beautiful, accessible components out of the box
• 🔄 Two Modes: Standalone (SQLite) or Client-Server (PostgreSQL)

---

Features

Core Platform Features

Feature	Description
Cross-Platform Server	High-performance Rust/Axum backend that runs on Windows, Linux, and macOS
Schema-Driven UI	35+ UI components rendered from JSON schemas with shadcn/ui
CLI Configuration	Full configuration via command line arguments and environment variables
Multi-Database Support	PostgreSQL and SQLite backends with automatic migrations
HTTPS/TLS Support	Optional TLS encryption with rustls
JSON API	RESTful API for communication and integration with existing tools

Plugin System

Feature	Description
WASM Plugins	Secure, sandboxed WebAssembly plugins with wasmtime
Plugin Routes	Plugins can define custom API endpoints
Plugin Pages	Plugins define UI via JSON schemas (no React code needed)
Action System	16 action types for interactive behaviors and state management
Plugin Registry	Hot-loading/unloading of plugins at runtime

UI System

Feature	Description
Component Library	35+ built-in components (Button, Form, Table, Chart, etc.)
State Management	Zustand + Immer for reactive state with page-level stores
Expression System	Dynamic value interpolation with {{state.field}} syntax
Error Boundaries	Plugin and page-level error isolation
Lifecycle Hooks	onMount and onUnmount hooks for pages
Toast Notifications	Sonner integration for user feedback

Security

Feature	Description
JWT Authentication	Secure token-based authentication
Argon2 Password Hashing	Industry-standard password security
Session Management	Secure session handling with refresh tokens
WASM Sandboxing	Plugins run in secure sandboxed environment

Modes

Mode	Description
Standalone	Local database with embedded server (single user)
Client-Server	Connect to remote Orbis server (multi-user)

Architecture Overview

Orbis uses a schema-driven architecture where plugins define UI through JSON instead of code:

flowchart LR
    A["Plugin (WASM)"] --> B["JSON Schema"] --> C["SchemaRenderer (React)"] --> D["UI Components"]

Loading

Key architectural decisions:

1. No React in Plugins: Plugins ship JSON schemas, not React code - the core SchemaRenderer interprets schemas and renders shadcn/ui components
2. WASM Sandboxing: All plugins run in isolated wasmtime environments with configurable permissions
3. Action-Based Interactivity: Instead of callbacks, plugins use action definitions (updateState, callApi, etc.) that the core executes
4. Page-Level State: Each plugin page has its own Zustand store (no global state pollution)
5. Expression Interpolation: Dynamic values use {{state.field}} syntax for reactive updates

Communication flow:

flowchart TD
    UI["User Interaction"]
    EV["Event"]
    AE["Action Executor"]
    SU["State Update"]
    RR["Re-render"]
    TC["Tauri Commands"]
    RB["Rust Backend"]
    DB["Database"]
    PR["Plugin Runtime (WASM)"]

    UI --> EV --> AE --> SU --> RR
    EV --> TC
    TC <--> RB
    RB --> DB
    TC --> PR

Loading

Crate Structure

crates/
├── orbis-core/        # Shared types, errors, and utilities
├── orbis-config/      # CLI and environment configuration
├── orbis-db/          # Database layer (SQLx, migrations)
├── orbis-auth/        # Authentication (JWT, Argon2, sessions)
├── orbis-plugin/      # Plugin system (WASM, manifest, UI schema)
└── orbis-server/      # Axum HTTP/HTTPS server

orbis/
├── src/               # React frontend
└── src-tauri/         # Tauri desktop application

Quick Start

Prerequisites

• Rust 1.91.0+ (nightly for Edition 2024)
• Node.js 18+ (bun recommended)
• PostgreSQL 15+ (optional, for client-server mode)

Development Setup

# Clone the repository
git clone https://github.com/cyberpath-HQ/orbis
cd orbis

# Install frontend dependencies
cd orbis && bun install

# Run the Tauri desktop app in dev mode
bun run tauri dev

The app will start with hot reload enabled for both frontend and backend changes.

Build for Production

cd orbis
bun run tauri build

Outputs platform-specific installers in src-tauri/target/release/bundle/.

Configuration

All configuration can be set via CLI arguments or environment variables:

# Run in standalone mode with SQLite
ORBIS_MODE=standalone \
ORBIS_DATABASE_BACKEND=sqlite \
ORBIS_DATABASE_PATH=./orbis.db \
cargo run

# Run as server with PostgreSQL
ORBIS_MODE=client-server \
ORBIS_RUN_MODE=server \
ORBIS_DATABASE_URL=postgres://user:pass@localhost/orbis \
ORBIS_JWT_SECRET=your-secret-key \
ORBIS_SERVER_HOST=0.0.0.0 \
ORBIS_SERVER_PORT=8080 \
cargo run

# Enable HTTPS
ORBIS_TLS_ENABLED=true \
ORBIS_TLS_CERT_PATH=./cert.pem \
ORBIS_TLS_KEY_PATH=./key.pem \
cargo run

CLI Options

orbis --help

# Examples:
orbis serve --mode standalone --db-backend sqlite --db-path ./data.db
orbis serve --mode client-server --run-mode server --db-url postgres://...
orbis profile list
orbis profile switch production
orbis db migrate
orbis plugin list

📋 Environment Variables

Variable	Default	Description
ORBIS_MODE	standalone	standalone or client-server
ORBIS_RUN_MODE	client	server or client (for client-server mode)
ORBIS_SERVER_HOST	127.0.0.1	Server bind address
ORBIS_SERVER_PORT	8080	Server port
ORBIS_DATABASE_BACKEND	postgres	postgres or sqlite
ORBIS_DATABASE_URL	-	PostgreSQL connection URL
ORBIS_DATABASE_PATH	-	SQLite database file path
ORBIS_DATABASE_RUN_MIGRATIONS	true	Auto-run migrations on startup
ORBIS_JWT_SECRET	-	JWT signing secret (required for client-server)
ORBIS_JWT_EXPIRY_SECONDS	3600	JWT token expiry
ORBIS_TLS_ENABLED	false	Enable HTTPS
ORBIS_TLS_CERT_PATH	-	TLS certificate path
ORBIS_TLS_KEY_PATH	-	TLS private key path
ORBIS_PLUGINS_DIR	./plugins	Plugins directory
ORBIS_LOG_LEVEL	info	Log level (trace, debug, info, warn, error)
ORBIS_LOG_JSON	false	Output logs as JSON

🛠️ Development

# Install dependencies
cd orbis && bun install

# Run development server
bun run tauri dev

# Build for production
bun run tauri build

Documentation

For comprehensive guides, API reference, and tutorials, visit the full documentation.

Roadmap

View our development roadmap and planned features at docs/src/docs/roadmap.mdx.

The roadmap includes:

• Priority levels - High, Medium, and Low priority features
• Live links - Direct links to related issues and pull requests
• Comprehensive coverage - All planned features across all categories

Community

• Report Issues: GitHub Issues
• Contributing Guide: CONTRIBUTING.md
• Discord community: DISCORD
• Star us: GitHub Repository

📄 License

Apache 2.0 License - see LICENSE for details.