StartOS

StartOS is an open‑source Linux distribution engineered for self‑hosted personal servers. It abstracts the complexity of service discovery, installation, network configuration, and health monitoring into a unified interface. From a developer’s perspective, StartOS acts as a container‑oriented platform that bundles services into services—self‑contained units with defined dependencies, resource limits, and lifecycle hooks. The OS itself is built on top of a minimal Debian‑based image with systemd for process supervision, but the real power comes from its service orchestration layer that leverages a lightweight API to manage service lifecycles and inter‑service communication.

• Core OS: Debian derivative with systemd, tuned for headless operation and low resource consumption.
• Service Engine: A custom Go runtime that exposes a RESTful API (/api/v1/services) for creating, updating, and deleting services. Each service runs in its own container (Docker or Podman) with isolated networking, storage, and CPU/memory quotas.
• Marketplace Integration: The engine pulls service manifests from a public registry (GitHub‑hosted YAML files) and resolves dependencies via a lightweight dependency graph.
• Configuration Store: Service configurations are persisted in a JSON‑based local database (boltdb) and optionally synced to a remote key‑value store for multi‑node setups.
• Web UI: A single‑page React application that communicates with the service engine over HTTPS, providing real‑time status dashboards and configuration editors.

• Service Lifecycle API: Create, start, stop, restart, and delete services with POST /api/v1/services.
• Dependency Management: Declarative manifests (startos.yaml) allow specifying requires: and provides: fields, enabling automatic ordering of service starts.
• Health Checks: Custom liveness and readiness probes are configurable per service, integrated with systemd timers.
• Network Isolation: Each service receives its own virtual network namespace; inter‑service communication is possible via named pipes or exposed ports, controlled by the service manifest.
• Backup & Restore: The OS exposes /api/v1/backup endpoints that snapshot service volumes and configuration, compatible with off‑site storage solutions.

StartOS is designed to run on commodity hardware (Raspberry Pi, Intel NUC, or any x86‑64 server). The OS image can be flashed to SSD or USB and booted directly, with no need for a hypervisor. For developers interested in containerization, the service engine supports Docker Compose‑style manifests, allowing multiple services to be defined in a single file. Scaling horizontally is possible by linking multiple StartOS nodes through a shared key‑value store and using the built‑in load‑balancing proxy, though this feature is still in beta.

• Plugin System: Developers can write custom service manifests that expose APIs, webhooks, or CLI tools. The marketplace accepts third‑party packages via signed manifests, ensuring integrity.
• Webhooks & Event Bus: Services can publish events to a central bus (/api/v1/events), which other services subscribe to via simple HTTP callbacks.
• Custom APIs: Each service can expose its own REST or gRPC endpoints; the OS injects TLS certificates automatically, simplifying secure inter‑service communication.
• CLI Extension: The startos CLI can be extended with plugins written in Go, allowing scripted automation of service lifecycle tasks.

The documentation is organized around the core concepts—services, manifests, and the API—and includes a comprehensive reference for each endpoint. The community is active on Matrix and Telegram, with dedicated developer channels that provide rapid feedback. Licensing is permissive (MIT), encouraging commercial or hobbyist use without vendor lock‑in. The build process is straightforward: make build produces a reproducible ISO, and the CI pipeline ensures every release passes integration tests.

• Personal Cloud: Deploy a private Nextcloud, Syncthing, or self‑hosted GitLab instance with a single click.
• Edge Computing: Run lightweight services (e.g., MQTT brokers, time‑series databases) on low‑power devices for IoT gateways.
• Educational Labs: Provide students with isolated service environments that can be reset quickly via the API.
• Enterprise SSO: Host a self‑managed identity provider (e.g., Keycloak) with automated backups and health monitoring.

• Performance: Native container runtime avoids hypervisor overhead, giving near‑bare‑metal speeds.
• Flexibility: Declarative manifests let developers ship services with all dependencies baked in, eliminating “works on my machine” headaches.
• Security: Automatic TLS provisioning and isolated networking reduce attack surface.
• Licensing & Openness: MIT license and open source code base remove vendor lock‑in, aligning with sovereign computing principles.

In summary, StartOS offers developers a robust, extensible platform for running and managing self‑hosted services with minimal friction, while preserving the full control and privacy that only a personal server can provide.