JMSR allows you to cast media from any Jellyfin client (web, mobile, TV) to your desktop, where it plays in MPV with full support for your custom configurations, shaders, and scripts.

💡 Key Philosophy

JMSR does NOT embed libmpv. Instead, it spawns and controls a standalone MPV process via JSON IPC. This preserves your existing mpv.conf, shader packs (Anime4K, FSR, etc.), and all local customizations without compromise.

• Quick Connect - Login via code from another device
• Intro Skipper Integration - Auto-skip intros/credits
• Full-Featured Client UI - Browse libraries, manage media, and control playback like other Jellyfin clients
• Embedded Player - Optional built-in video player without external MPV dependency
• MPRIS Support - Linux media player integration for desktop controls

• Discord Rich Presence - Show current playback status on Discord profile
• Custom Shaders Manager - Easy toggle for Anime4K, FSR, and other MPV shaders
• SyncPlay Support - Watch together with friends via Jellyfin SyncPlay group

• Picture-in-Picture (PiP) - Floating mini-player mode
• Global Hotkeys - Customizable shortcuts that work in the background
• Offline Mode - Download media for offline playback

• Added saved-session route gating and automatic reconnect through the authenticated session access path.
• Added mute-state visibility to the Now Playing controls.
• Improved Player Bridge command handling, playback control sharing, and Jellyfin websocket ownership for more reliable external MPV control.

• Migrated login, diagnostics, settings, subtitle priorities, session dialog, and now playing controls to headless Ark UI Solid primitives while preserving JMSR Control Room styling and behavior.

• Added Arch Linux .pkg.tar.zst release packaging.

• Added Intro Skipper plugin support for automatic introduction and credit skips.
• Added a global Automation toggle to enable or disable Intro Skipper behavior.
• Added once-per-session skip semantics so manual seeks back into skipped ranges are respected.
• Added verification coverage for plugin failures, malformed ranges, disabled behavior, progress reporting, and existing track controls.

JMSR utilizes a robust three-actor architecture to ensure stability and separation of concerns.

graph LR
    subgraph JMSR[JMSR Desktop App]
        A[<b>Sentinel</b><br>Tauri GUI]
        B[<b>Bridge</b><br>Rust Backend]
        A <--> B
    end
    
    B <-->|JSON IPC| C[<b>Player</b><br>External MPV]
    B <-->|WebSocket + REST| D[<b>Jellyfin Server</b>]
    
    style A fill:#00a4dc,stroke:#333,color:white
    style B fill:#dea584,stroke:#333,color:black
    style C fill:#4c3c69,stroke:#333,color:white
    style D fill:#aa5cc3,stroke:#333,color:white

1. Sentinel (Tauri GUI): Handles UI, WebSocket connection to Jellyfin, and state management.
2. Bridge (Rust IPC): Translates commands and manages the external process.
3. Player (MPV): The standalone media player instance running your config.

• MPV installed and in PATH

Download the latest release for your platform from the Releases page:

Install the Arch Linux package from a release asset with:

sudo pacman -U jmsr-<version>-1-x86_64.pkg.tar.zst

# Clone the repository
git clone https://github.com/hewel/jmsr.git
cd jmsr

# Install dependencies
bun install

# Build production binaries
bunx tauri build

Binaries will be in src-tauri/target/release/bundle/.

1. Launch JMSR from your application menu or terminal.
2. Authenticate with Quick Connect or by entering your Jellyfin server URL and credentials.
3. Cast Media: JMSR will appear as "JMSR" in your Jellyfin client's cast menu.
4. Optional Intro Skipper: Install the Jellyfin Intro Skipper plugin and keep Operations Console > Automation > Automatic Intro Skip enabled to skip detected intros and credits.
5. Enjoy: Media plays in MPV on your desktop with full control syncing.

1. Authentication: User logs into Jellyfin and receives an access token.
2. Registration: JMSR posts capabilities to /Sessions/Capabilities/Full.
3. WebSocket: Connects to Jellyfin for real-time play state control.
4. Cast Event: When user casts, Jellyfin sends a Play command.
5. MPV Control: JMSR spawns MPV (if needed) and sends JSON IPC commands.
6. Progress: Event-driven progress reporting via MPV property observation.
7. Sync: Pause/seek/volume commands flow bidirectionally (Jellyfin ↔ MPV).
8. Auto-Play: Automatically fetches the next episode upon natural file end.

jmsr/
├── src/                    # Solid.js frontend
│   ├── index.tsx          # Entry point
│   ├── bindings.ts        # Auto-generated IPC bindings
│   └── components/        # UI components
├── src-tauri/             # Rust backend
│   ├── src/
│   │   ├── jellyfin/      # Jellyfin client implementation
│   │   └── mpv/           # MPV IPC driver logic
│   └── tauri.conf.json    # Tauri configuration
└── docs/PRD.md            # Product requirements

• TypeScript: Single quotes, Biome formatting.
• Rust: 2-space indent (standard rustfmt.toml).
• IPC: Always use typed commands.* from bindings, never raw invoke().
• Solid.js: Use createSignal, createResource — NOT React hooks.

1. Add function in src-tauri/src/command.rs with #[tauri::command] and #[specta].
2. Register in src-tauri/src/lib.rs inside collect_commands![].
3. Regenerate bindings by running bunx tauri dev.
4. Import from commands in your TypeScript file.

Contributions are welcome! Please follow these steps:

1. Fork the repository.
2. Create a feature branch.
3. Follow existing code conventions (Biome for TS, rustfmt for Rust).
4. Run bun run check before committing.
5. Submit a pull request.

MIT License - see LICENSE for details.

• jellyfin-mpv-shim - The original Python inspiration.
• Tauri - For the amazing desktop framework.
• MPV - The best media player in existence.