Jellyfin Picture in Picture: which apps support it (2026)

Version numbers, feature claims and source-code references below come from each project's GitHub repository, App Store listing and official documentation, checked in September 2026.

What Picture in Picture actually is

Picture in Picture takes the video that is currently playing and puts it in a small window that stays on top of other apps or browser tabs, so you can keep watching while you do something else — read messages, browse the same app's library, or switch to another program entirely. It is a feature of the operating system or browser, not something each app builds from scratch: iOS, iPadOS and macOS provide it through Apple's AVKit framework, Android provides it as a system window mode any app can opt into, and Chrome, Firefox, Edge and Safari all implement a Picture-in-Picture Web API for <video> elements. Whether a given Jellyfin client uses that system feature is a choice each app's developers make, and, as the comparison below shows, not all of them have.

Comparison table

"—" means the client either does not exist for that platform or the claim was not found in an official source, not that it is confirmed absent.

iPhone and iPad

Four of the clients checked here support PiP on iPhone and iPad without any trade-off: Infuse, JellyTV, Streamyfin and Swiftly Player. Swiftfin is the one exception worth knowing in detail, because the limitation is not "no PiP" but "PiP only if you give something else up." The free Infuse alternatives comparison covers pricing and format support for these same apps if PiP is only one item on your list; the iPhone and iPad client landing page has the rest of what Swiftly Player does on those two devices.

Swiftfin ships two players, and its own player comparison document states the trade-off directly: Picture in Picture works with the Native (AVPlayer) player and not with VLC. VLC plays far more containers and subtitle formats, including MKV and SRT; the Native player, built on Apple's AVPlayer, plays a narrower set of formats but is the only one of the two that supports PiP. Picking VLC for a file's format support means giving up PiP for that same file; picking the Native player for PiP means losing some of what VLC would have played directly. The Swiftfin alternatives comparison and the iPad-specific client comparison both cover this trade-off against the other clients named here in more depth.

Streamyfin's PiP history shows how much this depends on which underlying player an app uses at any given time. Its App Store version history reports adding "Picture-in-picture support with an upgrade to VLC 4" in one release (0.26.1), then removing it in the next: "sadly removes PiP for now" (0.27.0), after reverting to VLC 3. The feature returned once the app moved to MPV as its player, per a later release note: "MPV Player with hardware decoding and PiP — a completely new player with a bunch of improvements." The lesson for any Jellyfin client, not just this one, is that PiP support tends to be tied to a specific player engine's own PiP hooks rather than being independent of which engine is currently in use.

Swiftly Player uses VLC (VLCKit) on iPhone and iPad and keeps PiP working with that same player, so there is no format-versus-PiP choice to make; its README lists Picture in Picture directly under "On your devices," footnoted as available on "iPhone, iPad, Android."

Mac

Mac support is the least consistently documented part of this comparison. Infuse's App Store listing includes Mac among its supported devices and lists "Split View & PIP" as a feature, but does not break the claim down device by device the way its iPhone and iPad support is described elsewhere. JellyTV and Streamyfin both ship Mac apps, per their own sites and App Store listings, but neither publishes a Mac-specific statement about PiP the way Swiftfin documents its two players. Swiftfin does not have a Mac app at all, so the question does not apply there. Swiftly Player's Mac app does not support Picture in Picture; its README limits that feature's footnote to iPhone, iPad and Android specifically, leaving Mac out.

If Mac PiP matters to you specifically, the safest approach is to test the app on your own Mac rather than rely on a platform list that groups Mac in with iPhone and iPad without a separate PiP claim. Swiftly Player's own README is explicit about the trade-off on its non-iOS desktop builds: on Mac, Windows and Linux, Picture in Picture is replaced by two other things — media keys that work like they do for any other player, and, in the README's words, "a small window stays on top while you do something else." That covers the same "keep watching while I do something else" need without an actual floating video window. See the Mac client overview for the rest of what runs there.

Android phone

Two Android clients have confirmed, source-level PiP support: the official Jellyfin app and Findroid.

The official Jellyfin for Android app is a WebView wrapper around the Jellyfin web client rather than a fully native player — its own README states plainly that it "connects to Jellyfin instances and integrates with the official web client." Its main activity's manifest entry declares android:supportsPictureInPicture="true", and its player code calls Android's enterPictureInPictureMode() directly in PlayerFragment.kt, so this is genuine system-level Android PiP, not just the browser's own floating-video behaviour carried over from the web client underneath.

Findroid is a native Android app, and its phone module implements PiP the same way: BasePlayerActivity.kt checks isInPictureInPictureMode to pause or keep playing correctly when the window shrinks. One open issue, #649, reports the wrong aspect ratio for anamorphic video specifically while in PiP — a real, narrow bug, not a sign the feature does not work generally.

Swiftly Player's Android app, currently in a closed Google Play test, lists Picture in Picture among the features carried over from the iPhone app, per its README: "On the phone it is the same app as on the iPhone: Direct Play through libVLC, downloads for offline viewing, continue on this device, several accounts, Seerr requests, skip intro, Picture in Picture and Quick Connect." Joining that test is covered on swiftlyplayer.com/android.

Android TV and Apple TV

Neither Android TV nor tvOS turned up a documented PiP claim in any client checked for this article. That is not really a gap in any one app; it reflects how those two TV operating systems work. A phone, tablet, Mac or desktop browser can show a small floating window on top of other things you are doing on the same screen, because you are expected to multitask on one device. A TV interface is built around one full-screen app at a time, controlled by a remote rather than a mouse or touchscreen, which is why none of the TV-focused clients in this comparison — the official Jellyfin for Android TV app, Findroid (which lists Android TV only as a planned, unreleased target per its own README), or Swiftfin and Infuse on tvOS — describe Picture in Picture as something you would use there. The Android TV client comparison and the Apple TV multiple-users article cover what those TV apps do offer instead. If a future release changes this for a specific client, check that client's own release notes rather than assuming it carries over from the phone or tablet version.

Desktop browsers

The Jellyfin web client's own source code settles this one directly, without needing to guess from marketing copy. Its video player, htmlVideoPlayer/plugin.js, checks for PiP support through three separate paths before offering the feature:

// Check non-standard Safari PiP support
typeof video.webkitSupportsPresentationMode === 'function'
    && video.webkitSupportsPresentationMode('picture-in-picture')
// Check non-standard Windows PiP support
|| (window.Windows && ...ApplicationViewMode.compactOverlay)
// Check standard PiP support
|| document.pictureInPictureEnabled

In plain terms: Safari gets its own, older webkitSetPresentationMode API, which Apple added to WebKit before the standard Picture-in-Picture Web API existed; Chrome, Firefox and Edge get the standard document.pictureInPictureEnabled / video.requestPictureInPicture() pair that is now part of the web platform; and a Windows-specific branch handles the compact-overlay window mode for Jellyfin's Windows app build, which is based on the same web client. Whichever path applies, the same setPictureInPictureEnabled() function in that file calls video.requestPictureInPicture() or video.webkitSetPresentationMode('picture-in-picture') to actually float the window. There is no separate opt-in setting to find in the interface beyond the player's own PiP button; it is offered automatically whenever the browser reports support.

How to use it

The exact gesture differs by platform, but the underlying idea is the same everywhere: start playback, then either tap a PiP icon in the player controls or trigger the system's own gesture for it.

• iPhone/iPad, apps that support it: start a video, then either tap the PiP icon in the player controls, or press the Home button / swipe up while a video is playing, which several apps' players treat as "start PiP" automatically.
• Android, apps that support it: press the Home button while a video is playing, or use the app's own PiP button if it has one; the system shrinks the current activity into a small window.
• Desktop browser: most browsers show a small PiP icon directly in the video's own control bar in Jellyfin's web player when document.pictureInPictureEnabled or Safari's presentation-mode API reports support, per the source referenced above. Right-clicking a playing <video> element in Chrome or Firefox also offers a "Picture in Picture" context-menu entry, independent of any button the site itself provides.

Limits worth knowing before you rely on it

Subtitles. Whether subtitles show up in the small PiP window depends on how the player draws them, not on PiP itself. Android's own developer guidance for implementing PiP says the floating window should show only the video: "PiP is intended for activities that play full-screen video. When switching your activity into PiP mode, avoid showing anything except video content" (Android developer documentation). Subtitles drawn onto the video image itself — burned in, or rendered by the player onto that same surface — carry over into PiP along with the picture. Subtitles drawn as a separate overlay on top of the full-screen player UI typically do not, because that surrounding UI is exactly what PiP hides. Test your own subtitle format in the app you actually use rather than assuming it behaves like the last one.

Background audio is a different feature. Hearing audio with no video window on screen at all uses a separate background-audio capability, not PiP; an app can support one without the other. Don't assume one implies the other — check each separately.

One window at a time. Every platform checked here shows one floating video window; none of these clients documents playing two videos in PiP at once, and the underlying OS APIs are all built around a single floating window per app or tab.

FAQ

Summary

Picture in Picture is a platform feature that each Jellyfin client either wires up or does not, and the details differ enough between apps that a blanket "Jellyfin supports PiP" answer is not useful. On iPhone and iPad, four of the five clients here support it without conditions; Swiftfin is the one that ties it to a specific, more limited player. Android's story is confirmed at the source level for the official app and for Findroid, both of which declare and trigger Android's own PiP mode directly. Neither Android TV nor tvOS has a documented PiP claim in any client checked, which lines up with how those two TV platforms are built. Desktop browsers get it for free through the Jellyfin web client's own use of the standard Picture-in-Picture Web API and Safari's older equivalent. Swiftly Player's own support sits on iPhone, iPad and Android, using the same VLC player throughout rather than switching players to get it.