YarmiplayServerTV

Host your own Syncplay server and Jellyfin server from the system tray on Windows, macOS or Linux. It's the companion to YarmiplayTV: one app on your computer gives your friends a room to watch in sync and a media library to stream from.

Download YarmiplayServerTV, or on Windows get it from the Microsoft Store (Jellyfin built in, updated by the Store). For online guides, visit the Setup Guide and Internet Access Guide.

• A Syncplay 1.7.6-compatible server built in: rooms, passwords, chat, readiness, shared playlists, and encrypted connections (TLS) when a certificate is available. You can also admit only the YarmiplayTV devices you approve.
• Extras for YarmiplayTV on the same port: a file relay, so everyone in a room can play the file one person has, and one-tap access to your Jellyfin for the people on your Syncplay server. Official Syncplay clients see a normal server, and Vanilla Syncplay mode turns the extras off entirely.
• Jellyfin, downloaded and set up for you. The first-run setup and library management happen in the control panel, so you don't need Jellyfin's own setup wizard.
• Works with your own Plex Media Server: manage its libraries from the control panel and share it with the people on your Syncplay server. You install Plex yourself from plex.tv; the app never installs or runs it.
• Optional UPnP port forwarding, so friends outside your home network can connect. It's off by default.
• Optional free HTTPS: a DuckDNS name that follows your home IP, or a domain of your own, with a Let's Encrypt certificate that is renewed automatically.
• You choose the ports. Every server can be switched on and off from the control panel or the tray menu.

The control panel is only reachable from your own computer: in the app window, or in a browser through Open in Browser in the tray menu. Browser access listens on 127.0.0.1:8097 only, needs the one-time sign-in link that menu item opens, and can be switched off on the Dashboard, so nobody else on the network or internet can change your settings.

Getting started

1. Install YarmiplayServerTV from the download page (on Windows, the Microsoft Store works too) and start it. It lives in the system tray; closing the window keeps the servers running. Use Quit in the tray menu to stop everything.
2. On the Dashboard, switch on the Syncplay server, the Jellyfin server, or both.
3. Give your friends the addresses shown on the dashboard. On your network works at home; Over the internet needs the steps in the Internet access guide (or see below).

Start with system (Dashboard, or the tray menu) starts the app minimized to the tray when you log in.

Install on Linux

• Snap Store: sudo snap install yarmiplayservertv
• Debian and Ubuntu: the .deb from the download page, sudo apt install ./YarmiplayServerTV.deb
• Anything else: the AppImage from the download page, chmod +x YarmiplayServerTV.AppImage and run it

The Snap Store keeps the snap up to date and it has Jellyfin built in. It can reach your home folder and removable drives for Jellyfin libraries, and keeps tokens in an owner-only file unless you allow it into your keyring with sudo snap connect yarmiplayservertv:password-manager-service. On GNOME, the AppIndicator extension is needed to see the tray icon.

Updates

Copies from the Microsoft Store or the Snap Store are updated by those stores and don't show these controls.

Check for updates (Dashboard, or the tray menu) looks for a newer release here on GitHub and downloads it; Install then restarts the app into the new version. Switch on Automatic updates on the Dashboard to check on a schedule (every 30 minutes unless you pick another) and install new versions while nobody is using Syncplay. Jellyfin libraries refresh on that same schedule, and a library whose folders are empty is removed. That refresh does not delete media files. Copies installed with the .msi or .deb package need administrator permission to update, so for those the new version is downloaded and waits for you to click Install. Every update is checked against the app's update signing key before it installs. Versions before 1.1.0 can't update themselves; install 1.1.0 or later from the download page once.

Syncplay

The default port is 8999. On the Syncplay page you choose who can join, and set a welcome message (Syncplay clients show it when they join, up to 2000 characters), isolated rooms (users only see their own room), and switch off chat or readiness. Changing the port restarts the server and disconnects everyone. The server reports itself as Syncplay 1.7.6.

Who can join:

• Anyone who has the address.
• Password only: every client needs the server password, including YarmiplayTV devices you approved. Switching to this mode disconnects anyone who got in with an approved device instead of the password.
• Password or approved devices: clients need the server password, except YarmiplayTV devices you approved. Approve devices that join with the password (on by default) adds a YarmiplayTV device to that list when it joins with the password, so it can join without the password next time.
• Approved devices only: only YarmiplayTV devices you approved. Official Syncplay clients are turned away with a message saying so. Switching to this mode disconnects everyone who isn't on an approved device.

When a YarmiplayTV device asks to join, it appears under Devices on the Syncplay page (and the Dashboard says so) with its name, username, address and a code such as 3F2A-91BC-04DE-7710. YarmiplayTV shows the same code; compare them, then Approve or Deny. The device waits up to 10 minutes. Approved devices stay approved until you Remove them, which also disconnects them. Each device keeps a key for this server only, so your LAN address and DuckDNS name share one approval and other servers can't recognize the device.

Managed rooms (on by default) work as on the official server. In a Syncplay client, Room → Create managed room moves you to a room named like +movie:1A2B3C4D5E6F and makes you its operator. Only operators can play, pause, seek or change the playlist; everyone else follows. Others become operators with Identify as room operator and the room's password. You can also make a managed room on the Syncplay page: type a name and Create shows the room name and password to share. The Rooms list marks managed rooms with a lock and shows their operators. Room names and passwords keep working after restarts and updates; Reset all managed-room passwords makes every one made so far stop working. Switching managed rooms off makes them ordinary rooms again.

Connect from YarmiplayTV or any Syncplay client with address:port, for example 192.168.1.20:8999. When DuckDNS and HTTPS are set up, connect with the DuckDNS name (myname.duckdns.org:8999) so clients can verify the certificate and use an encrypted connection.

YarmiplayTV extras

YarmiplayTV clients announce themselves when they join and get a few extras. Other Syncplay clients never see them. All of it runs on the Syncplay port: no extra port to forward.

• File relay (on by default): when someone in the room has the file that's playing and you don't, YarmiplayTV streams it from them through this computer. Each part is cached on this computer's disk, so it is sent only once however many people watch, and people who join later are served from the cache. Set the cache size on the Syncplay page (10 GB by default; at least 2 GB of the disk always stays free). The cache is emptied when the app starts, files unused for a day are dropped, and Clear cache empties it now. The Rooms list shows what's being relayed.
• Jellyfin sharing (off by default, on the Jellyfin page): YarmiplayTV users on the Syncplay server can add your Jellyfin with one tap. The app signs them in through Quick Connect as a hidden "Syncplay guests" account that can watch but can't delete or manage anything, and Jellyfin is reachable through the Syncplay port too. Switching sharing off disables that account, which signs every guest out. Set "Who can join" to a password option or approved devices only before you share, or anyone who finds the server can watch your libraries.
• Plex sharing (off by default, on the Plex page): YarmiplayTV users on the Syncplay server can ask for your Plex. Each one gets a normal Plex friend invite, to the libraries you pick, for their own plex.tv account; the app never sees their password or token. They reach Plex directly, not through the Syncplay port, so Plex needs its own port forward (Plex's Remote Access, or UPnP for Plex here) and Plex's rules for streaming outside your home apply as usual. The Plex page lists the people invited this way, and switching sharing off removes those invites (friends you added in Plex yourself are never touched).
• Vanilla Syncplay mode makes the server behave exactly like the official one for everyone: no file relay, no Jellyfin or Plex sharing, no device approvals (approved devices need the password like everyone else), and nothing but Syncplay on its port. It can't be combined with Approved devices only. Switching it on takes effect right away.

The protocol is described in docs/client-integration-prompt.md, docs/yarmiplaytv-device-access-prompt.md, docs/yarmiplaytv-plex-sharing-prompt.md, docs/yarmiplaytv-managed-rooms-prompt.md and docs/yarmiplaytv-home-network-prompt.md.

Jellyfin

The first time you switch Jellyfin on, the app downloads Jellyfin (about 150–250 MB, checked against pinned SHA-256 checksums) from repo.jellyfin.org. The download includes ffmpeg for transcoding. The Microsoft Store and Snap copies come with that same Jellyfin built in and download nothing.

When Jellyfin is running, the Jellyfin page asks you to create the administrator account. That's the whole first-run setup: the app configures the language, remote access and Quick Connect for you. Then add libraries: give each one a name, pick the kind of content (movies, shows, music…) and choose a folder. You can add more folders, remove libraries, and Refresh libraries to scan them for new files. The same page browses shows and movies with their Jellyfin artwork, then seasons and episodes. Deleting a show, a season, an episode or a file asks you to confirm the name, then uses Jellyfin's own delete so the files and the library stay in step. Refresh also removes a library whose folders are missing or empty. It removes only that library entry, never the files in those folders.

Sort into shows: episodes lying loose in a library folder show up in Jellyfin as unrelated videos with no episode numbers. The button on each folder moves them into a folder per show, and per season when the name gives one (Frieren/Season 02/), after showing what it will do. It reads fansub names ([Group] Show - 05 (1080p).mkv), Show.S01E05 and Show Ep 5. Files keep their names, so Syncplay rooms still find them, and subtitles with the same name come along. Existing show folders are reused, nothing is overwritten, and the last sort can be undone. Keep sorted does the same for new episodes every few minutes, leaving files alone until they've stopped changing for two minutes.

To change other Jellyfin settings, open Jellyfin (This PC → Open) and sign in with the administrator account.

Default ports: 8096 for HTTP, 8920 for HTTPS (served by the app once a certificate is ready).

Plex

Plex Media Server isn't part of this app: Plex's terms don't allow it to be bundled, so install it yourself from plex.tv and keep it updated through Plex. The app works the same with every copy (download page, Microsoft Store and Snap) and only ever talks to Plex over HTTP on this computer, so it never changes Plex's own files.

1. Switch on Plex Media Server on the Plex page. The page tells you if Plex isn't installed or isn't running, and checks again on its own once it is.
2. If Plex is new, finish its own setup first: Finish setup in Plex opens it in your browser to sign in to your Plex account and name the server.
3. Link your Plex account: the app shows a code to enter at plex.tv/link, the same way Plex apps on a TV sign in. Link the account that owns the server.
4. Add libraries: a name, the kind of content (movies, TV shows, music, photos, other videos) and a folder. Plex has to be able to read the folder; on Linux, Plex runs as its own plex user.

Plex listens on port 32400. If you changed it in Plex, change it on the Plex page too. To reach Plex from outside your network, use either Plex's own Remote Access setting or UPnP for Plex here, not both. Streaming from outside your home network follows Plex's own rules (a Plex Pass or Remote Watch Pass may be needed); sharing through this app doesn't change that.

Internet access

At home, friends can always connect with the LAN address (unencrypted; see "Connecting from home" below for encryption). For friends elsewhere, your router has to forward the server ports to your computer.

Port forwarding

Either forward the ports yourself in your router's settings (TCP, to this computer's LAN address shown on the Network page), or switch on UPnP for Syncplay, Jellyfin and/or Plex on the Network page. With UPnP the app asks the router to add the forwards, checks them every 10 minutes, and removes them again when you switch UPnP off or quit. A forward you already made by hand is detected and left alone.

If the Network page reports double NAT, your router sits behind another router or your provider uses carrier-grade NAT. Forwards on your own router then can't be reached from the internet; ask your provider for a public IP, or forward the ports on the outer router too.

DuckDNS (or your own domain) and HTTPS

1. Sign in at duckdns.org and create a subdomain, for example myname.
2. On the Network page, switch on Use a domain and HTTPS, keep Domain type on DuckDNS, enter the domain (myname or myname.duckdns.org) and save, then paste the token from the DuckDNS page and choose Save token. The token is stored in your system's credential store (Windows Credential Manager, macOS Keychain or the Secret Service on Linux) and never shown again.
3. The app points the name at your public IP (and keeps it updated every 5 minutes), then gets a Let's Encrypt certificate using a DNS challenge. This takes about a minute and works without any open port.

Your own domain instead. Choose My own domain under Domain type and enter the name, for example tv.example.com. No DuckDNS token is needed, but you look after the domain's DNS:

1. At your domain's DNS provider, point the name at your home: an A record with your public IP (the Network page shows it), or, if your IP changes, a CNAME to a DuckDNS name that follows it.
2. Let's Encrypt checks the domain over HTTP on port 80, so port 80 must reach this computer. With UPnP on for any server, the app forwards port 80 along with the servers' ports; otherwise forward it on the router. The app only listens on port 80 while it gets or renews the certificate. Some ISPs block port 80 on home connections; then this option can't work, and DuckDNS (which needs no open port) still does.
3. On Linux, ports below 1024 need permission: sudo setcap cap_net_bind_service=+ep <path to the app>, or sudo sysctl net.ipv4.ip_unprivileged_port_start=80.

The Network page shows where the domain points and warns when that isn't your public IP. The LAN name for browsers and Publish IPv6 too are DuckDNS features and don't apply to an own domain.

The certificate is renewed automatically halfway through its lifetime, and both servers use a renewed one right away. Jellyfin's HTTPS port is served by the app, with the same full certificate chain as the Syncplay port (Let's Encrypt's chain including the cross-signed root), so older devices that only trust ISRG Root X1 connect to both; Jellyfin itself only speaks HTTP behind it.

Test certificates (Let's Encrypt staging) is useful while trying things out: staging has much higher rate limits, but browsers and clients don't trust those certificates. Let's Encrypt allows 5 identical certificates per week, so switch staging off once everything works.

Connecting from home. The DuckDNS name points at your router's public address. Many routers don't loop a connection from inside your network back to it (NAT loopback), so at home the name can fail even though it works from outside. The app works around this on its own:

• YarmiplayTV finds this computer on your network (the app answers a discovery request on the Syncplay port number, over UDP) and connects to its home address. It still checks the certificate against the DuckDNS name, so the connection is just as encrypted and verified.
• Publish IPv6 too (on by default) also points the name at this computer's public IPv6 address, when your network has one. IPv6 has no NAT, so any client with IPv6, including official Syncplay, reaches the computer by name directly at home. Whether it also works from outside depends on your router's IPv6 firewall; clients fall back to IPv4 if it doesn't. The Syncplay server listens on IPv6 as well as IPv4.
• Other clients on IPv4 only need a router that supports NAT loopback, or can connect to the LAN address without encryption.

Watch in a browser

With DuckDNS and HTTPS set up (and vanilla mode off), friends can join from a browser at tv.yarmiplay.com/watch: the Network page shows a link for a room. The browser connects straight to this server over a secure WebSocket on the Syncplay port, with the same approvals and passwords as any device, and streams through the file relay.

• LAN name for browsers (optional, on the Network page): a second DuckDNS name on the same account, for example myname-lan. The app keeps it pointed at this computer's address on your network and puts it on the same certificate, so browsers at home connect locally instead of through the internet. Test checks that the name resolves to this computer here; some routers block DNS answers with private addresses ("DNS rebinding protection") and need an exception for the name.
• Web pages allowed to connect (advanced, on the Syncplay page): only these pages may use the server from a browser. The defaults are the YarmiplayTV web app and localhost:5173 for developing it.
• MyAnimeList sign-in in the browser goes through the server too (/yarmiplay/mal), since MyAnimeList doesn't accept requests from web pages.

Where things are stored

Settings, approved Syncplay devices and the secret managed-room names are made from (syncplay-devices.json), the ACME account, certificates, Jellyfin (program, database, cache and logs) and the file relay cache (relay-cache) are kept in the per-user app-data folder; Open data folder on the dashboard opens it.

• Windows: %APPDATA%\Yarmiplay\YarmiplayServerTV (settings) and %LOCALAPPDATA%\Yarmiplay\YarmiplayServerTV (data)
• Windows, Microsoft Store copy: %LOCALAPPDATA%\Packages\Yarmiplay.YarmiplayServerTV_<id>\LocalState, which Windows deletes when you uninstall it. It doesn't share settings with a copy from the download page; don't run both at once, since they would want the same ports.
• macOS: ~/Library/Application Support/com.Yarmiplay.YarmiplayServerTV
• Linux: ~/.config/yarmiplayservertv and ~/.local/share/yarmiplayservertv
• Linux, Snap: the same two under ~/snap/yarmiplayservertv/current/

Plex keeps its own settings and data where its installer put them; the app stores only its settings for Plex.

Tokens and passwords never appear in the logs; the Logs page shows the app's activity and Jellyfin's warnings.

Uninstalling

1. If you switched on Start with system, switch it off first, so no login entry is left behind.
2. Choose Quit in the tray menu. This stops Jellyfin and removes any UPnP port forwards the app made.
3. Remove the app:
   • Windows: Settings > Apps > Installed apps, then YarmiplayServerTV > Uninstall.
   • macOS: move YarmiplayServerTV from Applications to the Trash.
   • Linux: sudo apt remove yarmiplay-server-tv, or delete the AppImage. The snap: sudo snap remove yarmiplayservertv.
4. To remove your settings, certificates and Jellyfin (with its library database) too, delete the folders listed in Where things are stored (the Microsoft Store copy's folder is deleted with the app). The DuckDNS token and the Jellyfin and Plex sign-ins are kept in the system credential store under YarmiplayServerTV; Remove next to the DuckDNS token on the Network page and Sign out on the Jellyfin and Plex pages delete them, or remove them in Windows Credential Manager, Keychain Access (macOS) or your Linux keyring app.

Your media folders are never changed or deleted. Plex Media Server stays installed; remove it separately if you want to.

Building from source

You need Node.js 22, Rust (stable) and the Tauri prerequisites for your OS. On Debian/Ubuntu:

sudo apt install libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev libdbus-1-dev libxdo-dev libssl-dev build-essential

Then:

git clone https://github.com/Yarmiplay/YarmiplayServerTV
cd YarmiplayServerTV
npm install
npx tauri dev      # run with hot reload
npx tauri build    # installers in src-tauri/target/release/bundle

Tests: cd src-tauri && cargo test for the Rust side (Syncplay protocol and rooms, access modes and approved devices, the YarmiplayTV extensions and file relay, UPnP, ACME, Jellyfin installer, configuration and sharing), npm run check for the UI. CI also runs scripted clients (scripts/fake_peer.py) against the built-in server: two plain Syncplay clients, and a seeder and a viewer (--yarmiplay) that pass a file through the relay.

YARMIPLAYSERVERTV_HOME=<folder> keeps all settings and data in another folder, which is handy for testing. The Jellyfin version and checksums are pinned in src-tauri/jellyfin-manifest.json; regenerate it with python scripts/update_jellyfin_manifest.py.

Project layout

• src-tauri/src/syncplay/: the Syncplay server (protocol, rooms, TCP/STARTTLS listener), the YarmiplayTV extensions (ext.rs), approved devices (devices.rs) and the first-byte switch that serves HTTP on the same port (mux.rs).
• src-tauri/src/relay/: the file relay (offers, chunk cache, scheduler, HTTP endpoints).
• src-tauri/src/jellyfin/: Jellyfin download, process supervision, network.xml, the REST API client, and sharing with Syncplay users (guest account).
• src-tauri/src/plex/: watching the user's own Plex Media Server, its local API, plex.tv (account linking and friend invites) and sharing with Syncplay users.
• src-tauri/src/net/: UPnP port mapping, DuckDNS and ACME, and the reverse proxy that serves Jellyfin on the Syncplay port.
• src-tauri/src/orchestrator.rs: keeps every service in line with the settings.
• ui/: the control panel (Svelte).

Releases

Bump the version with python scripts/bump-version.py 1.3.0 --note "What changed.", which writes it into src-tauri/tauri.conf.json, Cargo.toml, package.json, the lock files and a new release entry in the AppStream metainfo (packaging/linux/com.yarmiplay.servertv.metainfo.xml, shown by the Snap Store). Commit, then push a matching tag:

git tag v1.3.0 && git push origin v1.3.0

With the repository variable AUTO_TAG set to true and a RELEASE_TAG_TOKEN secret (a fine-grained token with Contents read and write on this repository), .github/workflows/tag-on-version-bump.yml pushes that tag itself once the Build of a version bump on main is green.

.github/workflows/release.yml builds the installers for Windows, macOS and Linux and attaches them to the tag's GitHub release together with latest.json, which installed copies read to update themselves (scripts/updater_manifest.py writes it). Updates are signed with the updater key in the secrets TAURI_SIGNING_PRIVATE_KEY and TAURI_SIGNING_PRIVATE_KEY_PASSWORD; its public half is plugins.updater.pubkey in src-tauri/tauri.conf.json. Keep a backup of that key: without it, installed copies can't receive updates anymore.

The app is YarmiplayServerTV on the Microsoft Store (Store ID 9P6B9C1KXFFQ). The same run builds the Store package (scripts/make-msix.ps1, an unsigned .msix that the Store signs, with Jellyfin built in) as the windows-store-msix-<version> artifact. Upload it in Partner Center as described in docs/store/README.md, which also has the listing text. The app notices when it runs from that package: it leaves updates to the Store, keeps its data in the package's LocalState folder and uses the package's startup task for Start with system. ./scripts/make-msix.ps1 -Register installs the package locally for a test (needs Developer Mode).

After the GitHub release, the same workflow's snap job builds the snap from the release's .deb (snap/snapcraft.yaml, with the metainfo and desktop file from packaging/linux/), checks that it starts, and uploads it to the Snap Store. It does nothing until the repository variable SNAP_NAME is yarmiplayservertv, and needs the secret SNAPCRAFT_STORE_CREDENTIALS; the optional variable SNAP_CHANNEL picks the channel (default stable). See packaging/README.md for a local build and the one-time setup. The Linux packages workflow builds, installs and starts the snap whenever its files change. To redo a store for the latest release, run the Release workflow by hand with only that store's box ticked.

Privacy

This program will not transfer any information to other networked systems unless specifically requested by the user or the person installing or operating it. There is no telemetry or account. Every server stays off until you switch it on. Voice chat is part of Syncplay and is on unless you switch it off. Each feature only talks to what it needs:

• Updates: only when you click Check for updates or switch on Automatic updates, the app downloads latest.json and then the new installer from this project's GitHub releases. GitHub sees your IP address, as with any download.
• Jellyfin: downloads Jellyfin and ffmpeg from repo.jellyfin.org the first time you switch it on. Jellyfin then runs on your computer as its own program; see Jellyfin's documentation for what it does.
• UPnP: asks your router on the local network to add and remove port forwards.
• DuckDNS and HTTPS: sends your DuckDNS token and public IP address to DuckDNS (not with your own domain), requests certificates from Let's Encrypt (with the contact email if you enter one), and checks the DNS record through Google Public DNS and Cloudflare DNS.
• Syncplay server: people you give the address to connect to it. File names, playback and chat are passed between them and not stored; the app's log on your computer notes who joined and left which room.
• Voice chat: audio from people in a room is relayed through this computer and not recorded. The app does not use a microphone. See the privacy policy for the detail.
• Approved devices: for each YarmiplayTV device you approve, the app keeps its public key, the name it sent, when it was approved and last seen, and the username it last used, on your computer only. Requests you haven't answered are kept in memory, with the device's IP address, and forgotten after a day or when the app quits.
• File relay: relayed video files pass through your computer and are cached on its disk until they go unused for a day, and never past a restart.
• Jellyfin sharing: when you switch it on, Syncplay users can sign in to your Jellyfin as a guest.
• Plex: talks to your Plex Media Server on this computer. Linking your Plex account, and sharing, talk to plex.tv on your account's behalf: when someone on your Syncplay server asks for your Plex, their plex.tv username is sent to plex.tv to invite them.

The full privacy policy is docs/privacy.md, published at https://servertv.yarmiplay.com/privacy/.

License

GPL-3.0-or-later. Syncplay and Jellyfin are separate projects by their respective authors; this app speaks the Syncplay protocol and downloads unmodified Jellyfin releases. Plex is a trademark of Plex, Inc.; this app works with a Plex Media Server you install yourself and isn't made or endorsed by Plex.