Where to Find Jellium-Desktop Documentation: The Complete In-Repository Guide

All official jellium-desktop documentation lives inside the andrewrabert/jellium-desktop GitHub repository; there is no external website or separate docs portal.

Jellium-Desktop is an unofficial desktop client for Jellyfin built on CEF (Chromium Embedded Framework) and mpv. Because the project is a Rust workspace with platform-specific crates, the maintainers treat the source tree itself as the primary source of truth. If you are looking for jellium-desktop documentation, you will find it distributed across the README, architecture guides, inline code comments, and the justfile build recipes.

Primary Documentation Files

The highest-level documentation is located in three files at the repository root.

README.md — Quick Start and Setup

The README.md serves as the front-page guide. It contains download links, quick-start steps, and an overview of the development environment. For anyone onboarding to the project, this is the first file to read.

CLAUDE.md — Architecture Overview

The CLAUDE.md file provides a high-level description of the multi-process layout. It explains how CEF communicates with Rust via IPC, how mpv is integrated into the stack, and how the platform-specific crates are organized. Read this for the system architecture before diving into the src/ tree.

justfile — Build and Packaging Commands

The justfile at the repository root is the canonical reference for all build, run, and packaging commands. Each recipe is documented inline and maps to helper scripts in src/xtask/. Key recipes include:

• just deps — Pulls submodules, CEF binaries, and platform packages.
• just build — Compiles the binary and stages a runnable tree in build/.
• just run — Executes the binary locally with environment variables set for CEF and mpv.
• just appimage build — Produces a portable Linux AppImage.

Source Code as Documentation

Because Jellium-Desktop is a Rust workspace, the codebase is intentionally self-documenting. Module-level comments and #[doc] attributes explain public APIs, while directory structure signals component boundaries.

The src/ Directory

The src/ directory contains the workspace manifest (src/Cargo.toml) and all crates. It is the authoritative reference for every component. Notable crates include:

• playback — Core playback engine (src/playback/src/lib.rs).
• mpv — Safe Rust wrapper around libmpv (src/mpv/src/lib.rs).
• macos, windows, linux — Platform-specific entry points.
• xtask — Build helper CLI invoked by just.

src/web/ — The UI Layer

The src/web/ directory holds the JavaScript and HTML rendered inside CEF. Front-end developers should inspect this folder for the native shim and overlay logic. The src/web/native-shim.js file registers callbacks that bridge UI actions to the Rust backend.

src/xtask/ — Build Helpers

The src/xtask/ crate contains the CLI driver that just invokes. The entry point, src/xtask/src/main.rs, parses arguments, downloads CEF, stages resources, and orchestrates platform-specific packaging. The actual build logic is further split into modules such as src/xtask/src/build.rs.

GitHub Actions Workflows

The .github/workflows/ directory hosts the CI pipelines. These YAML files document how maintainers build and release Linux AppImages, Flatpaks, macOS dmgs, and Windows installers. They are practical references for the full release process.

Practical Documentation Examples

Below are runnable examples taken directly from the repository documentation.

Install Dependencies and Build

# Install the just command runner

cargo install just

# Pull submodules, CEF binaries, and platform packages

just deps

# Build the binary and stage output in build/

just build

The build recipe references the helper in src/xtask/src/build.rs.

Run Locally with Debug Logging

# Run the application; logs are written to build/run.log

just run

The run recipe forwards arguments to the jellium-desktop binary and sets environment variables such as CEF_RESOURCES_DIR and mpv paths. See src/xtask/src/main.rs for the implementation.

Package a Linux AppImage

# Produce a portable AppImage for x86_64

just appimage build

The AppImage script lives under dev/linux/appimage and is invoked from the justfile.

Control mpv from Rust

use mpv::Mpv;

// Create a new mpv instance
let mut mpv = Mpv::new().unwrap();

// Load a file and start playback
mpv.command("loadfile", &["/path/to/video.mp4"]).unwrap();

The Mpv struct and its safe wrappers are defined in src/mpv/src/lib.rs.

Send Commands from the Web UI via CEF IPC

// In a web script (e.g., src/web/overlay.js)
function pauseVideo() {
  // Sends a process message named "pause" to the Rust side
  window.cefQuery({ request: JSON.stringify({ type: 'pause' }) });
}

The CEF ↔ Rust IPC handling is implemented in src/jfn_cef. The JavaScript shim forwarding UI actions lives in src/web/native-shim.js.

Key Source Files

Keep these paths bookmarked when navigating jellium-desktop documentation:

• src/Cargo.toml — Workspace manifest listing all crates (playback, mpv, macos, windows, linux, xtask).
• src/playback/src/lib.rs — Orchestrates mpv events and UI state.
• src/mpv/src/lib.rs — Safe wrapper around libmpv with property observation and command API.
• src/macos/src/lib.rs — macOS-specific CEF host setup and bundle signing.
• src/windows/src/lib.rs — Windows-specific entry point and CEF host setup.
• src/xtask/src/main.rs — CLI driver invoked by just; downloads CEF and stages resources.
• src/web/native-shim.js — JavaScript side of the CEF ↔ Rust bridge.
• CLAUDE.md — Architectural overview of the multi-process model.
• justfile — Central command runner for every development task.

Summary

• Jellium-Desktop documentation is maintained entirely inside the andrewrabert/jellium-desktop repository; there is no external docs site.
• Start with README.md for setup, CLAUDE.md for architecture, and the justfile for build commands.
• The src/ tree is the primary source of truth, with module-level comments and Rust docstrings serving as the API reference.
• Platform packaging logic is documented in .github/workflows/ and invoked through just recipes.
• Key integrations—such as the mpv Rust bindings and CEF IPC bridge—are explained in src/mpv/src/lib.rs and src/web/native-shim.js.

Frequently Asked Questions

Is there a separate docs website for jellium-desktop?

No. As implemented in andrewrabert/jellium-desktop, all documentation is kept in-repo. The README.md, CLAUDE.md, justfile, and self-documenting source code provide the complete reference.

Where can I find the architecture overview for jellium-desktop?

The CLAUDE.md file at the repository root contains the architecture overview. It explains the multi-process layout, CEF ↔ Rust IPC, mpv integration, and how platform-specific crates are structured.

How do I build jellium-desktop from source?

Install the just command runner, then run just deps followed by just build. The recipes are defined in the justfile, and the underlying staging logic is handled by src/xtask/src/main.rs and src/xtask/src/build.rs.

Where are the mpv Rust bindings documented?

The safe Rust wrapper for libmpv is located in src/mpv/src/lib.rs. It exposes the Mpv struct, property observation, and the command API, all documented with inline comments and #[doc] attributes.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}