Ryot

Ryot is a self‑hosted personal dashboard that aggregates data from media, fitness, and other lifestyle domains. Written in Rust for performance, it exposes a fully documented GraphQL API, making it an attractive choice for developers who need a lightweight yet feature‑rich backend that can be embedded in larger ecosystems. The application is available as both a free community edition and a commercial Pro tier, but the core source remains open‑source under GPLv3, encouraging contributions and custom extensions.

Key Features

• Cross‑domain tracking – Users can log books, movies, games, workouts, and more in a single unified schema.
• Import & integration – Built‑in connectors for Goodreads, Trakt, Strong App, Jellyfin, Kodi, Plex, Emby, Audiobookshelf, and others allow data to be pulled automatically.
• OpenID Connect – Auth is pluggable; developers can integrate any OIDC provider or fall back to local credentials.
• Notification hooks – Webhooks and native integrations (Discord, Ntfy, Apprise) enable real‑time alerts.
• PWA & UI – The frontend is a progressive web app, providing offline support and native‑app feel on mobile.

Technical Stack

The core Rust codebase is split into modular crates: ryot-core for business logic, ryot-api for GraphQL bindings, and ryot-web for the PWA. This separation allows developers to drop only the API layer into their own service if they already have a custom frontend.

Core Capabilities

• Schema‑driven data model – The GraphQL schema exposes entities such as MediaItem, WorkoutSession, and Collection. Mutations allow CRUD operations with strong type safety.
• Import pipelines – Each external source has a dedicated async worker that fetches data via REST or GraphQL, normalizes it, and persists to the database. Workers can be added as separate services.
• Event system – Internal events (MediaAdded, WorkoutLogged) trigger webhooks or push notifications, enabling real‑time dashboards.
• Extensibility – A plugin interface (currently in alpha) lets developers register custom resolvers or data sources without touching the core code.

Deployment & Infrastructure

• Self‑hosted – Runs on any Linux host with Docker or native binaries. No external SaaS required.
• Scalability – Stateless API servers can be horizontally scaled behind a load balancer. PostgreSQL handles concurrent writes; Redis provides fast pub‑sub.
• Observability – Exposes Prometheus metrics, structured logs (JSON), and health endpoints for integration with ELK or Grafana stacks.
• Backup – PostgreSQL dumps can be scheduled; the Docker image includes a lightweight backup helper script.

Integration & Extensibility

Developers can hook Ryot into their existing ecosystems via:

• GraphQL client libraries (e.g., Apollo, Relay) for web or mobile apps.
• Webhooks – Subscribe to events like mediaUpdated and trigger downstream workflows (e.g., update a personal blog).
• Custom connectors – Fork the import crate and implement a new data source; register it through the plugin API.
• OpenID Connect – Swap the OIDC provider or use a local database for quick prototyping.

Developer Experience

• Documentation – Comprehensive docs (docs.ryot.io) cover installation, configuration, API reference, and developer guides. The GraphQL playground (app.ryot.io/backend/graphql) provides live introspection.
• Community – Active Discord server, GitHub Discussions for feature requests, and a growing contributor base.
• Licensing – GPLv3 ensures freedom to modify and redistribute, while the Pro tier offers commercial support for enterprises.

Use Cases

Advantages

• Performance – Rust’s async runtime delivers low latency even under high query loads.
• Full control – Self‑hosted