Feishin: Desktop Music Player for Navidrome, Jellyfin, and OpenSubsonic

A Dedicated Front-End for Navidrome, Jellyfin, and OpenSubsonic

Self-hosted music servers like Navidrome and Jellyfin expose well-defined APIs, but the official web interfaces are built for general media management rather than focused music listening. Feishin solves that gap: it is a purpose-built music client that speaks the Navidrome, Jellyfin, and OpenSubsonic protocols, presenting a clean interface oriented around albums, artists, and queues.

Feishin is a rewrite of Sonixd, an earlier project by the same author. The technology stack is TypeScript, React, and Electron, which gives it a native window on Windows, macOS, and Linux while sharing a common codebase. The GPL-3.0 licence makes it freely redistributable under the same terms. Version 1.17.0 was released on 15 September 2026, with the last repository push on 24 September 2026, so the project is under active development.

The target user is someone who already operates a self-hosted media server and wants a dedicated listening client on a desktop machine or inside a home-lab Docker stack. It does not include a server component: you supply the server, Feishin supplies the front-end.

Two Playback Backends: MPV and Web

Feishin separates audio playback into two backends that serve different use cases.

The MPV backend relies on a locally installed MPV binary. MPV is a well-tested media player that handles a wide range of audio codecs and container formats. On first launch, the desktop app prompts for the path to the MPV binary; after entering it and restarting the app, MPV handles all audio output. The desktop client supports both the MPV and web backends.

The web backend uses the browser's native audio engine, which is lighter but restricted to formats the browser decodes natively. The web client hosted at feishin.vercel.app uses only the web backend, with no access to MPV.

Built-in lyrics fetching is a desktop-only feature. The desktop app retrieves synchronized and unsynchronized lyrics without requiring an external plugin. The web version does not include that fetching capability according to the README.

The MPV path is the primary reason the README calls the desktop client the recommended installation. Users who need bit-perfect audio or support for FLAC files in non-browser-friendly containers should use the desktop build with MPV.

Installing the Desktop Client on Linux, macOS, and Windows

The simplest route on any platform is to download the latest release from the GitHub releases page. Linux users have two additional managed options.

On Linux, Feishin is published to Flathub under the name `org.jeffvli.feishin`. The README also provides a shell installer for AppImage. The following command downloads the latest AppImage, makes it executable, fetches the required icons, and creates a `.desktop` file so the app appears in the application launcher:

dir=/your/application/directory
curl 'https://raw.githubusercontent.com/jeffvli/feishin/refs/heads/development/install-feishin-appimage' | sh -s -- "$dir"

To add experimental native Wayland support (marked as unsupported in the README because Electron's Wayland mode is not officially stable), pass the `wayland-native` flag:

dir=/your/application/directory
curl 'https://raw.githubusercontent.com/jeffvli/feishin/refs/heads/development/install-feishin-appimage' | sh -s -- "$dir" wayland-native

To remove the AppImage installation later, pass `remove` in place of `wayland-native`.

On macOS 12 (Monterey) and higher, the downloaded app must be removed from macOS quarantine before it will open. The README links to a GitHub issue comment with those instructions. Media key support requires granting Feishin the Trusted Accessibility Client permission in macOS System Settings; the README notes that Feishin must be restarted after granting that permission.

After installing, open the app, enter the MPV binary path, restart, then open the menu, choose "Manage servers", click "Add server", and enter the full server URL including protocol and port, for example `https://navidrome.my-server.com` or `http://192.168.0.1:4533`. For Navidrome, the README recommends selecting "Save password" and setting `SessionTimeout` to a value such as `72h` in the Navidrome configuration to avoid frequent session expiry. On Linux, the default password store uses `libsecret`; KWallet versions 4, 5, and 6 are supported but must be set manually in Settings under Window, Passwords/secret store.

Docker Deployment and Environment Variable Configuration

Feishin publishes a Docker image to GitHub Container Registry. The web build, served by nginx on port 9180, is the version that runs in a container. Running the image is one command:

docker run --name feishin -p 9180:9180 ghcr.io/jeffvli/feishin:latest

A Docker Compose file is included in the repository. The following snippet from that file shows the supported environment variables:

services:
    feishin:
        container_name: feishin
        image: 'ghcr.io/jeffvli/feishin:latest'
        restart: unless-stopped
        environment:
            - SERVER_NAME=jellyfin
            - SERVER_LOCK=false
            - SERVER_TYPE=jellyfin
            - SERVER_URL=http://localhost:8096
            - LEGACY_AUTHENTICATION=false
            - ANALYTICS_DISABLED=false
        ports:
            - 9180:9180

When `SERVER_LOCK` is set to `true` and `SERVER_NAME`, `SERVER_TYPE`, and `SERVER_URL` are all provided, users can only change the username and password fields. This is useful for shared or kiosk deployments where the server target must not be overridden. The `SERVER_TYPE` variable accepts `jellyfin`, `navidrome`, or `subsonic` (case-insensitive). `REMOTE_URL` handles the case where Navidrome uses a separate public-facing share URL that differs from the internal server address. Setting `ANALYTICS_DISABLED=true` prevents the Docker or web build from loading the Umami analytics script.

App settings such as the default theme and language can be pre-seeded using environment variables that start with `FS_`. The README gives `FS_GENERAL_THEME=defaultDark` and `FS_GENERAL_LANGUAGE` as examples. These overrides take effect on first run and do not overwrite settings the user has already changed.

Smart Playlists, Scrobbling, and Lyrics

Three features distinguish Feishin from basic Subsonic-compatible clients.

The smart playlist editor is available only when the connected server is Navidrome. It allows constructing rule-based playlists against the Navidrome database, which is a feature the generic OpenSubsonic API does not expose. Users connecting to Jellyfin or a plain Subsonic server do not have access to this editor.

Scrobbling sends playback data back to the connected server. For Navidrome this updates the play count and last-played metadata; for Jellyfin it feeds the playback reporting system. The README lists scrobble support in the feature checklist without specifying per-server limitations beyond what the server API supports.

Lyrics support covers both synchronized and unsynchronized formats. Synchronized lyrics display line-by-line in time with playback. Built-in fetching is a desktop feature; the web client can display lyrics stored on the server but the README does not document independent fetching in the browser build.

Where Feishin Is the Wrong Tool

Feishin has no mobile client. The related searches show demand for Android and iOS versions, but the README documents neither. Users who need playback on a phone must use a separate app such as Finamp (iOS and Android, Jellyfin-focused) or Symfonium (Android). Feishin does not fill that role.

Wayland native mode is experimental and unsupported on Linux. Electron's Wayland support is flagged as not official in the README, so X11 or XWayland is the reliable path on Linux desktops.

The smart playlist editor works only with Navidrome. Teams that run Jellyfin exclusively and want dynamic playlists must look at what Jellyfin's own interface provides, because Feishin's editor is not available against that API.

The web client lacks MPV. Any user who needs the audio quality benefits of MPV, including support for codecs not handled by browser audio APIs, must use the desktop build. The hosted version at feishin.vercel.app is convenient for quick access but is strictly limited to web-native audio.

Feishin requires a running music server. It is a client only. Setting up Navidrome or Jellyfin is a separate prerequisite, and without one, the application has nothing to connect to.

Feishin Compared to Finamp and Symfonium

The search data shows users comparing Feishin to Finamp, Symfonium, Sonixd, and Jellyfin's own interface.

Finamp is a mobile music client for Jellyfin, available on iOS and Android. It targets phone and tablet playback, with offline download support. Feishin targets desktop and browser; the two tools are complementary rather than competing, because one covers mobile and the other covers desktop.

Symfonium is a paid Android music app that supports multiple server backends including Subsonic and Jellyfin. It is a mobile-first product. Feishin is GPL-licensed and desktop-first. A household that wants both mobile and desktop coverage typically uses both, since neither replaces the other.

Feishin is a direct rewrite of Sonixd, its predecessor. The README states this relationship explicitly. Users migrating from Sonixd will find the configuration model and server-connection workflow familiar, though Feishin is a complete rewrite rather than an incremental update.

Jellyfin is a media server, not a music client. The question of whether Jellyfin is a music client reflects a common point of confusion: Jellyfin manages and serves media, while Feishin consumes it. Both are GPL-licensed and self-hosted, but they operate at different layers.

Editorial conclusion

Engineers running Navidrome or Jellyfin who want a polished desktop front-end with MPV-quality audio should use Feishin. Those needing mobile playback must choose a separate client: the README documents no Android or iOS support. Before installing the desktop build, verify that MPV is installed and that the server URL is accessible over http or https with the correct port.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes