UBOS

UBOS is a modular, self‑hosted ecosystem aimed at powering open social web applications. At its core it bundles a lightweight Linux distribution (UBOS Linux), a deployment engine (UBOS Gears), and a graph‑oriented middleware layer (UBOS PeerGraph). Together, these components enable developers to spin up fully functional social platforms that run on user‑controlled infrastructure, whether on bare metal or in virtualized environments.

Technical Stack

• Operating System: UBOS Linux, a curated Arch Linux derivative tailored for Gears. It provides minimal dependencies, ARM and x86_64 support, and a hardened package set.
• Deployment Engine: UBOS Gears orchestrates application lifecycles. Written in Go, it exposes a RESTful API and CLI for installing, updating, and scaling web services. Gears integrates with Docker‑like container runtimes (podman, cri-o) and supports systemd units for legacy workloads.
• Middleware: UBOS PeerGraph is a graph‑based middleware written in Rust. It offers an HTTP/JSON API and WebSocket support, enabling real‑time social graph queries. PeerGraph is designed to run as a microservice behind Gears, providing data aggregation for higher‑level apps.
• Database: PeerGraph ships with a built‑in key/value store (sled) for local graph persistence, but it can be configured to use PostgreSQL or MySQL for larger deployments. Gears supports multiple database backends via environment variables.

Core Capabilities

• App Management: Gears can deploy any containerized or systemd‑based web application. It handles health checks, rolling updates, and dependency resolution.
• Graph API: PeerGraph exposes CRUD operations on nodes, edges, and attributes. It supports Cypher‑style queries, subscription hooks for real‑time updates, and a federated model to merge multiple PeerGraph instances.
• Plugin Architecture: Both Gears and PeerGraph accept plugins written in Go or Rust. Plugins can extend the API surface, add authentication backends, or implement custom routing logic.
• Webhooks & Events: Gears emits lifecycle events (app installed, updated, removed) via HTTP webhooks. PeerGraph publishes graph mutation events that can be consumed by external services.
• Security: Built on Arch Linux’s SELinux‑like AppArmor profiles, Gears enforces namespace isolation. PeerGraph uses TLS by default and supports JWT authentication for API access.

Deployment & Infrastructure

• Self‑Hosting: UBOS is designed to run on any Linux host. Installation is a single binary plus the UBOS Linux image; no external package managers are required.
• Containerization: Gears natively manages OCI containers, making it trivial to deploy Docker images or build custom ones. It also supports rootless mode for unprivileged hosts.
• Scalability: PeerGraph can be replicated across nodes; Gears supports horizontal scaling via a shared datastore or Consul. Load balancing is handled by external reverse proxies (NGINX, Traefik) or by Gears’ built‑in HTTP router.
• ARM & x86_64: The UBOS Linux distribution is available for both architectures, enabling deployment on Raspberry Pi clusters or edge devices.

Integration & Extensibility

• API First: Both Gears and PeerGraph expose RESTful endpoints with OpenAPI specifications. This allows developers to integrate them into CI/CD pipelines or custom dashboards.
• SDKs: Official SDKs are available in Go, Rust, and JavaScript (Node.js), providing typed clients for the APIs.
• Custom Plugins: Developers can write Gears plugins to add new deployment strategies (e.g., Kubernetes), or PeerGraph plugins to integrate external graph databases.
• Webhook Hooks: External services can subscribe to app lifecycle events or graph mutations, enabling automated workflows (e.g., sending notifications when a new user node is created).

Developer Experience

• Documentation: The UBOS project hosts comprehensive docs covering installation, API references, and plugin development. Each component has its own section with example payloads.
• Community: The project maintains an active GitHub repository, a discussion forum, and regular blog posts. Issues are triaged quickly, and pull requests for plugins are merged with minimal friction.
• Configuration: All settings are exposed via environment variables or JSON/YAML config files, making it easy to inject values from CI pipelines or secret managers.

Use Cases

• Open Social Platforms: Build a federated microblogging or photo‑sharing service that runs entirely on user‑controlled servers.
• Enterprise Collaboration: Deploy a private social graph for internal knowledge management, with PeerGraph handling relationships and Gears managing microservices.
• Edge Computing: Run UBOS on Raspberry Pi clusters to provide local social networking for community hubs or disaster‑resilient communication.
• Educational Labs: Teach students about distributed systems by having them deploy and scale PeerGraph instances across multiple hosts.

Advantages

• Performance: PeerGraph’s Rust implementation delivers low‑latency graph queries, while Gears’ Go core ensures minimal overhead in container orchestration.
• Flexibility: The plugin system and open APIs allow developers to tailor the stack to specific needs without rewriting core components.
• Licensing: All UBOS components are released under permissive open‑source licenses, eliminating vendor lock‑in and enabling commercial use.
• Security & Isolation: Built‑in containerization, SELinux/AppArmor profiles, and TLS defaults provide