This release marks another milestone in our journey to delivering the best media app on Android TV. Jellyfin 10.10 or newer is required. A complete list of changes, including their respective pull requests, can be found on GitHub. I've listed a subset of all changes below.

Skipping intros, outros and more with media segments​

Media segments are a new feature added in Jellyfin 10.10. A segment provides metadata for specific parts of a video or audio file. This can be used to mark an intro in your episode or the credits of a movie. The Android TV app can now use those segments to skip parts. By default, the app will ask to skip intros and outros, but you can fine-tune this to your liking within the app preferences. All media segment types are supported: intro, outro, preview, recap and commercial with three actions to choose from:

• Skip
  Immediately skips the playback forward to the end of the segment, or the next episode

• Ask to skip
  Shows a popup that the segment can be skipped by pressing the OK button on your remote and disappears after 8 seconds or when pressing the back button.

  

• Do nothing
  The segment will be ignored, with no skips or popups.

More actions and functionality related to media segments is already in the works for future releases, like a "mute" action that temporarily silences audio.

Revamped subtitles​

This release completely redesigns the way subtitles are loaded and shown on screen, resolving a large number of issues reported over the past few years.

Previously the app did not support embedded subtitles and forced the server to extract them from video files first. This is a resource-heavy process and often causes subtitles to not show up or with a big delay. A workaround for this was to use the "Subtitle Extract" plugin that will do this extraction ahead of time, this was cumbersome and is now no longer necessary.

Together with these loading changes, the app now reliably supports Presentation Graphic Stream (PGS) subtitles and positioning tags in the SubRip Subtitle Format (SRT), a much requested feature!

To make these changes happen, the preferences for subtitles have also slightly changed. It is now possible to choose your own background and outline colors.

Sing along with lyrics​

Not only did video playback improve, playing music has gotten some upgrades as well! The most exciting change here is support for lyrics. Whenever your song has lyrics available (added by a plugin or on your file system), they will be shown in the app. This works especially well when combined with our screensaver, which will show lyrics fullscreen.

Currently, 2 types of lyrics are supported: timed lyrics, which will highlight the current line of the vocal track, and untimed lyrics, which will automatically scroll based on the track duration.

In addition to the lyric changes, some bugs have been fixed where a music queue would never disappear when the last track ends and some text elements did not update properly.

Other changes​

In addition to the previously mentioned changes there's a lot more to enjoy. The video player will no longer randomly show its controls and they stay hidden when the video is loading for a smoother experience. An issue where sorting libraries by "last played" did not work for TV shows was fixed. And finally, a lot of improvements under the hood were made to make the app faster, easier to maintain, and more stable than ever.

There are as also two new experimental options for playback. The first one is related to decoding audio codecs, while normally the app will automatically fall back to using a different decoding approach using FFmpeg, this might not always work. You can now enable the "Prefer FFmpeg for audio playback" preference to force the fallback approach.

The second experimental option adds support for previews when scrubbing, once "Enable trickplay in video player" is checked you'll see image previews above the progress bar while scrubbing through your videos! There are some issues and annoyances with the current implementation which will be resolved before this feature will be enabled by default and marked non-experimental. Make sure the Trickplay feature is enabled on your libraries for the previews to show up.

Contributors​

Jellyfin is completely developed by volunteers, and couldn't be made without their great skills and dedication. Consider donating if you appreciate their work. A big shout-out to all contributors that made this release possible:

Jellyfin Team

• @nielsvanvelzen - Donate via GitHub sponsors

Other contributors

• @MichaelRUSF
• @JagerSprinkles
• @pascalwei
• @kabel2
• @starsep
• @rickysixx
• @ericleb010
• @reacocard

And finally a big thank you to everyone who contributed translations, reported bugs, provided feedback and participated in beta testing!

Helping out​

If you have experience with Android TV development or with Kotlin and are interested in contributing yourself, feel free to dive into the source code and open a pull request. Alternatively, you can help with translating the app into your own language on our Weblate instance.

Downloads​

Update your app now to check out all these changes! The app stores will auto-update your Jellyfin app if you're already using the app. For new users, you can find the app on the app store of your platform.

Direct downloads are available for sideloading at repo.jellyfin.org or in the GitHub release assets.

You can also join our beta program on Google Play and help test new versions before they're released to the public. Read more about our beta program.

Unstable users: we are planning to merge our pending EFCore conversion of library.db in the next couple of weeks. It is imperative that all unstable users understand what is going on, what the plan is, and how to mitigate issues that will inevitably arise from this. Stable (10.y.z) users require no action.

Unstable builds are currently paused for roughly 4 weeks post-release of 10.10.0, and during this time, we plan to merge these extensive database changes. There will be breakage - bugs, fixes, and database migrations - during this time. This is your fair warning to either (a) prepare yourself with a good backup and recovery strategy and disable automatic upgrades; or (b) move off of unstable onto 10.10.0 stable until the dust settles (but, please don't, as we need your help to test!)

Please read on for a more detailed overview if you are interested.

- Joshua

What is EFCore, and why are we migrating to it?​

EFCore is the C#/.NET database handling framework, which simplifies database query handling in the Jellyfin codebase.

Our original database code was written by Emby in a time long before .NET Core existed, when Mono ruled the world in terms of cross-platform C# compatibility. As such, it handled the database poorly: SQLite queries embedded directly in the code, and a fairly horrific schema with no migration capabilities. This has caused us a lot of problems over the years as we try to change and improve the codebase and add new features, and as such, the team began migrating to EFCore quite a while ago.

We were able to move many of the databases quickly, mostly due to the diligent work of @BarronPM; those have been live for several major releases now. But the Library database has remained as it was, due to its massive complexity and exceptionally poor schema. This has caused a lot of problems, for instance very slow search, problems adding new media types (or deprecating old ones), and lots of complexity inside the codebase around handling "non-standard" (i.e. not Movies/TV Shows/Music Albums) media types, resulting in bugs.

Now, thanks to @JPVenson, we finally have the library database EFCore implementation ready to go. But there is a big catch.

There Will Be Bugs​

Once we merge this massive change set, there will be bugs. This is certain. And these bugs may completely trash your library database. So first and foremost, it is incredibly important that everyone running the Unstable builds understands that this is coming and how to prepare yourself.

What we will be focusing on​

Our primary goal will be to ensure that stable-to-stable migrations between 10.10.x and 10.11.x will work without a hitch, as we want and need this transition to be as seamless as possible for the majority of users running stable builds when 10.11.0 drops.

But to do this, we need to both test the changes in unstable, and ensure that our migrations are valid for data coming from the 10.10.x stable.

The downside of this is, though, that we might not be able to cleanly implement unstable-to-unstable migrations in a way that will work properly. While we will try to do this, we cannot guarantee it.

Our timeline​

1. This blog post starts the process to provide the warning to all unstable users that this is coming. Note that as of posting, unstable builds are disabled due to the recent 10.10.0 release, and will remain off for a little while.

2. About 1-2 weeks after this blog post, we will merge the Library EFCore migration into our master branch and begin preliminary testing. If you want to help here, you will have to build Jellyfin from source, and the more people who can help here the better!

3. About 2 weeks after merging, assuming everything looks generally OK, we will re-enable unstable builds for the general public. At this point, all unstable builds will apply the initial migrations on startup. That will bring us to about 4 weeks (give or take a week) from the 10.10.0 release.

4. Over the following weeks, we will take bug reports and try to correct them. This is the possible sticking point: if it's not possible for us to implement a clean set of migrations, we may decide to only focus the migration on stable-to-unstable conversions, rather than unstable-to-unstable. If this happens, you may need to restore a previous version and apply the new migrations to it.

What this actually means for you​

First and foremost, if this is too much for you, this is your warning for the off-ramp. Switch away from unstable now before we restore the unstable builds in a few weeks.

Second, ensure you have a robust backup strategy based on our suggested backup process. Take backups regularly, and, to help us test, try to also have a backup of your last stable release so you can run that through the migrations as well. Take backups before applying the next unstable build, every time.

Third, ensure you disable automatic upgrades. We generally recommend this anyways, but if you're still doing this, now is the time to stop.

Fourth, if you run into trouble, please ensure you report the bug with a title containing [EFCore Library]. This will help us find and fix the bugs.

Fifth and finally, if you have a failing migration, restore an older database version first and try to re-run it. If it still fails, try your oldest (ideally, 10.9.11 or 10.10.0 stable) backup as well. If that one doesn't work, it's a new bug to report.

This major release brings several new features, improvements, and bugfixes to improve your Jellyfin experience. With our faster release cadence between 10.9.0 and 10.10.0, this release should be far less daunting, so please read on for a quick peek at what's new and some important-to-know breaking changes!

You may upgrade your Jellyfin instances at any time now. For those who were running Unstable builds for testing, we thank you immensely, and you may now switch back to the Stable repository and forcibly reinstall/repull the latest version. As always, ensure you back up your Jellyfin data and configuration directories before upgrading. With a major release, it's possible you will hit a bug and want to revert, and to do so, you will need to restore from a backup.

Happy watching!

- Joshua

Breaking Changes​

• Most clients should continue to work as-is without any issues or any forced upgrades, though this may change in the future. The sole exception is Jellyfin4Kodi, which currently has issues due to point 5 below, though a fix is hopefully forthcoming shortly.

• We have deprecated Raspberry Pi V4L2 hardware transcoding support, and are looking to deprecate 32-bit ARM support (i.e. armv7 or armhf) in general for 10.10.0 and later, with a goal to remove 32-bit ARM support in 10.11.0. Older, slow ARM systems have always been tricky platforms for us: they're popular but extremely poor in performance, and this has caused a lot of people a lot of headaches. With the RPi5 entirely removing a hardware acceleration engine, and most ARM single-board computers now supporting ARM64, we are taking this action now to ensure it's widely known. If you are running Jellyfin on old ARM hardware, now is the time to start looking at an upgrade. See PR #1148.

• We now use the system temporary storage engine (e.g. /tmp on Linux) for storing short-lived transient temporary files, to allow us to leverage temporary ramdisks and the like and avoid cluttering potentially slow storage. This may cause issues if you specifically depended on the previous behaviour. Note that this does not include transcoding temporary files. See PR #12226.

• The server will now refuse to start if ffmpeg cannot be found, is an incorrect version, or does not function properly (missing extensions, etc.). With how critical ffmpeg is to Jellyfin, this has become very important to avoid mis-reported issues. This can be explicitly bypassed if needed. See PR #12463.

• Network paths in libraries have been fully removed and will no longer work. This functionality has been deprecated for a long time, and most of it was removed in 10.9.0, but this removes the remainder. See PR #12446. Third-party clients relying on this functionality should be able to re-implement it as required.

• Systems with Trickplay enabled may see a relatively long migration occurring during the upgrade. If Jellyfin seems to hang starting up after upgrading, please observe the logs and wait for the migration to complete. This helps enable the functionality below.

Cool New Features​

Media Segments​

The Jellyfin server now supports the management of Media Segments. This means that we store some additional information for certain time-spans on a video that clients can then use to provide additional actions. For example, when there is a Media Segment of the type intro, a client may display a button to skip that particular segment. For 10.10, we only provide the general structure to store those Media Segments, and you will still require a plugin to create them. We have created one plugin that does this, based on the Chapter names of a movie or Episode, which you can find in the Plugin catalogue, and others may be implemented in the future. The Web interface fully supports skipping segments; other client support is pending.

Trickplay​

We have significantly improved extraction by implementing optional keyframe extraction, which can boost image generating time significantly (around 100x, depending on configuration) at the cost of some frame accuracy, which should be fine for most users with longer trickplay frame durations. This should mean no more multi-day Trickplay jobs! Note that this must be explicitly enabled in the Trickplay settings.

Playback/Transcoding​

Many major enhancements to transcoding and playback, including support for software tonemapping of HDR10, HLG and DoVi, preliminary support for DoVi Profile 10, support for Dolby AC-4 audio, more stereo downmixing algorithms, QSV device selection, and more! Our FFmpeg is also now based off the upstream FFmpeg 7.0 release for additional features and improvements there.

Metadata​

It is now possible to select which plugins can provide lyrics to your music libraries, similar to how you can select the plugins providing metadata. This will provide more variety to Lyrics support.

Audio tag scanning has been significantly improved, and will thus hopefully be much more reliable and consistent.

Home videos should also now keep their rotation metadata.

Web​

We have added support for CBT and CB7 books, client-side rendering of PGS subtitles, and auto-scrolling lyrics as well as a lyrics editor interface.

Full Changelogs​

Full changelogs are available on the various release pages:

• Server
• Web

The Next Version​

Our faster release cadence has generally been received fairly positively within the team, though lack of structure has been a bit of a problem. So right now, we are outlining the development roadmap for 10.11.0. This may change as time goes on, but this should give everyone an idea of roughly when 10.11.0 is coming.

Target 10.11.z development window: November 2024 to March 2025
Target feature freeze: second week of April 2025
Target release date: end April 2025

A more detailed roadmap will be published closer to the feature freeze date.

Final Thoughts​

We want to thank everyone who contributed to the 10.10.0 release; Jellyfin wouldn't be what it is without your help. We're really proud of this project we've built as a community, and hope to continue to be the go-to FLOSS media system solution for a long time to come. Happy watching!

We are pleased to announce that we are now beginning the process for the 10.10.0 release, with a planned release date of Saturday, October 26th (updated - see below), 2024! We said 6 months in our 10.9.0 release posts, and we're sticking by that! The feature freeze proper starts next week, with a soft "new PR freeze" today, so here's what you need to know about the timeline and a recap of how to help us test 10.10.0 before release. Remember, the more people who help test it out before release, the less bugs we're likely to find after release, so fire up those secondary servers and warn your users: 10.10.0 is coming!

Developers/contributors, and those users who want a bit more information, please read on!

- Joshua

The Release​

What's Different This Time?​

Not much at all! We're following the same general process as the 10.9.0 release, though with a slightly tweaked timeline and with more defined steps.

The Release Timeline​

• Monday, September 9th, 2024 (unstable 20240909): Feature PR last-call, first beta. Any new feature PRs should get in right now to avoid missing the feature freeze. This is your 1 week warning! Developers/contributors please keep on top of your PR review feedback or your PR may miss the following deadlines and have to wait until 10.11.0.
• Monday, September 16th, 2024 (unstable 20240916): Feature freeze, second beta. Any new feature PRs after this point must wait until 10.11.0 (in another ~6 months). In-flight feature PRs will likely make it assuming that all feedback is resolved before the API freeze. Again developers/contributors, please keep on top of your PR review feedback. New PRs should be bugfixes only after this point. Users should be safe to begin testing in earnest with this unstable.
• Monday, September 23rd, 2024 (unstable 20240923): API freeze, third beta. All feature PRs should be merged by this point. If they're not, they will be moved to the 10.11.0 project and only merged to master once 10.10.0 is released. API is now soft-frozen so that client developers can begin confidently working on any client support changes needed for 10.10.0.
• Monday, September 30th, 2024 (unstable 20240930): API lock, first release candidate. Major bugfix PRs should hopefully be either be merged or well in-flight by this point. Only non-API-changing bugfixes after this point. We should have a feature overview blog post in draft state by this point.
• Monday, October 7th, 2024 (unstable 20241007): Final planned unstable, second release candidate. The release should basically be ready to go, and any remaining bugfix PRs should be merged before this unstable.
• Saturday, October 12th, 2024: Release of 10.10.0!

Possible Timeline Changes​

EDIT 2024-10-12: We have opted to take the two week delay due to pending changes in Web that must get in. We are currently planning for a release on October 26th.

Since this is a much smaller and quicker release than 10.8.0 or 10.9.0 were, hopefully this is enough time to get everything sorted and ready to go. But if we find it's not, we reserve the right to add an extra week in one or both of the following places:

• After the Feature freeze, if we find that there are any outstanding major bugfixes that require additional time to merge before the API freeze.
• After the API lock, if we find that there are any outstanding non-API-breaking bugfixes that require additional time to merge before the final unstable.

If neither of those happen, the release will proceed as planned; otherwise, an extra step will be added into the timeline after the given points that matches the previous stage. This might push the final unstable back to either October 14th or October 21st, and the final release to either October 19th or October 26th. If this is relevant to your interests, please keep an eye on our Announcements Matrix channel for announcements.

Information for 3rd Party Clients​

After the API freeze, our API should ideally remain stable, though it's possible there might be minor changes up until the API lock step. Please feel free to begin testing compatibility and report any issues to us now, and keep an eye out on those dates for the final API specification.

Information for Contributors​

If you're contributing to Jellyfin and your feature PRs miss the deadline, please don't fret. We are committed to this shorter major release timeline going forward, so 10.11.0 is at most about 6 months away. Your feature should eventually make it in.

If you wish to help by submitting a bugfix, please do so as soon as you can, as we'd like to get as many fixes in and tested before the API lock as possible, to give at least 2 weeks of final testing before the release. Ensure you clearly specify that it is a bugfix, and ensure you keep your changes to an absolute minimum needed to fix the bug. Bugfix PRs will target the master branch until the final release, at which point they will target the release-10.10.z branch for upcoming point releases.

How You Can Test​

Testing this release should be very easy, identical to 10.9.0. Since our pre-releases are "just" our unstable releases here, that means that following our normal "unstable" installation process is all you need to do.

To find that, visit our main server downloads page, select the platform you require along the top centre, then on the top right, select "Unstable". The instructions and links will now be for the unstable release. You can also find additional testing documentation in the docs.

For Docker this simply means pulling the unstable tag on the image. For Debian and Ubuntu repositories, this means adding unstable to your existing jellyfin.sources entry. For other platforms, please review the provided instructions as not all platforms will support unstable.

Next, before installing an unstable release, ensure that you back up your existing server configuration. It is not possible to downgrade in-place as there are database changes. Just making a simple copy of your configuration directories with Jellyfin stopped is sufficient, and where those can be found depends on the platform.

Next, if you use plugins, install the unstable plugin repository. Due to compatibility issues, we distribute plugins for unstable in a separate manifest, so this must be added manually, and on first start all incompatible plugins (i.e. all existing plugins on an upgrade) will be upgraded. To add the repository, navigate to the Administration Dashboard, Advanced, Plugins, then click the Repositories tab at the top. Click the "+" Add button, and enter "Unstable" for the name and "https://repo.jellyfin.org/files/plugin-unstable/manifest.json" for the Repository URL. We also recommend that you disable/remove the Stable repository at this time, as it's possible they will conflict. After the initial update you may need to manually restart your Jellyfin instance one further time to ensure all plugins are activated properly.

Finally, install the unstable version and run it. The upgrade should happen seamlessly in the background, and you'll be able to log in to your Jellyfin instance normally after this point. Ensure you perform a hard refresh in your browser, and restart all clients.

Once 10.10.0 is fully released, you can switch back easily by reinstalling the new stable version, and changing back to the stable plugin manifest (URL "https://repo.jellyfin.org/files/plugin/manifest.json"). Unstable releases will be paused for at least 2 weeks after the release to give you plenty of time to switch.

How To Report Bugs​

While running the unstable prereleases, reporting bugs is important. After all, if we don't know about bugs, we can't work to fix them!

First, if you encounter a bug, ensure you're running the latest unstable version, and try to reproduce it a couple times. If you can't, it's always possible it was a one-off occurrence, but if it happens again, definitely report it!

Bugs can be reported on our GitHub issues page or on our Forums.

You'll want to include two important pieces of information in your bug report, beyond the standard asks. First, ensure you include the "Build Version" as shown in the main dashboard page. This reports the exact unstable build you're using to help narrow down what might have caused the issue. This is doubly important if you see a new bug turn up in a future unstable build. Second, please make clear that you are running the unstable builds and not stable builds, as well as if this is an upgrade or fresh install, as that can be an important piece of information.

Once your bug is reported, please check back diligently to see if any additional information has been requested, and we hope to get it fixed soon.

Thanks, and happy watching!

Notable changes​

This release comes with over 100 changes from 13 contributors. The complete list of changes, including their respective pull requests, can be found on GitHub. I've listed the most important/noticeable changes below.

Navigation​

It might seem like just one button, but it solves a significant issue. A new 'home' button in the top-right corner lets you return to the Jellyfin home screen easily, instead of pressing the back button repeatedly. Additionally, the layout of the item details has been slightly tweaked to fit more useful information.

Playback​

The current video player was improved by adding support for more audio codecs, including WAV, Vorbis and PCM. Additionally, timeouts for player errors were increased to give transcode and remux tasks more time to start. This improves playback for media stored on network drives and BDMV files that require unpacking.

Audio normalization support was added to automatically adjust volume levels for music playback. This feature prevents sudden volume changes between songs. To activate this feature, you'll need to enable the LUFS scan for your music library.

Screensaver​

The screensaver now includes a feature to filter items based on their age rating. By default, only items with an age rating up to 13 will be displayed, ensuring a family-friendly environment. Age rating options can be changed in the preferences under the customization tab.

Additionally, the screensaver has been enhanced to display a logo of the movie or series being shown.

Other changes​

Series and seasons now display their respective special features, which were previously available only for movies. Additionally, the search function has been improved to include results for Live TV channels, playlists, collections, photo albums, and individual photos.

Invisible but noteworthy, a significant amount of work was invested in reworking the communication between the app and the server. This has resulted in a faster and more reliable app, with improved performance and the groundwork laid for the development of exciting new features. As a consequence of these changes, the app now requires Jellyfin 10.9 or newer and older versions are no longer supported.

Contributors​

Jellyfin is completely developed by volunteers, and we couldn't do without their great skills and dedication. Consider donating if you appreciate their work. A big shout-out to all contributors that made this release possible:

Jellyfin Team

• @nielsvanvelzen - Sponsor via GitHub sponsors
• @Bond-009 - Sponsor via GitHub sponsors

Other contributors

• @pascalwei
• @haydenzeller
• @DoggoOfSpeed
• @bathompson
• @VizuaaLOG
• @3l0w
• @mnsrulz
• @MichaelRUSF
• @efreet7
• @ConnorS1110
• @cbeyls

We'd also like to thank everyone who reported bugs, provided feedback and participated in beta testing!

Helping out​

If you have experience with Android TV development or with Kotlin and are interested in contributing yourself, feel free to dive into the source code and open a pull request.

Alternatively, you can help with translating the app into your language on our Weblate instance.

Downloads​

Update your app now to check out all these changes! The app stores will auto-update your Jellyfin app if you're already using the app. For new users, you can find the app here:

Direct downloads are available for sideloading at repo.jellyfin.org or in the GitHub release assets.

You can also join our beta program on Google Play and help test new versions before they're released to the public.

This major release brings many new features, improvements, and bugfixes to improve your Jellyfin experience.

You may upgrade your Jellyfin instances at any time now, however please read on for a complete detailing of what's new and changed, including some very important release notes. For those who were running Unstable builds for testing, we thank you immensely, and you may now switch back to the Stable repository and forcibly reinstall/repull the latest version.

Happy watching!

- Joshua

Key Release Notes/Breaking Changes​

There are several key changes with 10.9.0 that administrative users should be aware of, before getting into the more specific changes.

• As always, ensure you back up your Jellyfin data and configuration directories before upgrading. With a major release, it's possible you will hit a bug and want to revert, and to do so, you will need to restore from a backup.

• Ubuntu users: We have dropped support for non-LTS Ubuntu releases with 10.9.0. That is, we have not built 10.9.0 packages for any releases except 20.04 LTS, 22.04 LTS, and 24.04 LTS, and we will not publish builds for any new non-LTS releases going forward. For an explanation of why, please see our previous blog post. If you use another release, please upgrade to 24.04 LTS or switch to the Docker container.

• Fedora/CentOS/RHEL/etc. users: We have dropped our official RPM packages and suggest switching to the 3rd-party RPMFusion repository or the Docker container. Support for RHEL-like distributions has been a major pain point for us for a very long time, and we feel that letting the community over at RPMFusion handle this is in our best interest going forward, similar to how Arch, Gentoo, etc. packages are handled. For more details, please see our previous blog post.

• Docker users: We now offer GitHub Container Registry (GHCR) as an alternative container registry in addition to Docker Hub. You can pull images from the new registry via URIs like ghcr.io/jellyfin/jellyfin:latest. Don't worry, we have no plans to drop Docker Hub as a container registry, but we feel providing both gives users more choice and flexibility.

• Docker users: If you encounter problems loading your homepage, you may need to remove the DOTNET_SYSTEM_GLOBALIZATION_INVARIANT environment variable from your container, as this is no longer valid in Jellyfin 10.9.0. For more details please see these issues.

• Nginx reverse proxy users: If you have a block in your nginx config that begins with location ~ ^/web/$ { and the comment # location block for /web - This is purely for aesthetics [...], please remove that block as it will cause occasional issues with 404's and/or slow performance on 10.9.z.

The Big Changes​

This release has been over two years in the making, so we're really glad to finally get it out to you. The long cycle does mean quite an extensive changelog however, with well over 1100 pull requests merged into our master branch since 10.8.0 first dropped back in 2022. This section will detail all the big changes, broken up by general function and area of the system. In addition to these big items, there are hundreds of smaller bugfixes, quality-of-life tweaks, and other minor changes that we won't touch on here, but if you want to see the full list, you can do so over on the GitHub releases for the core server and the Web UI.

General​

• We now support "trickplay" a.k.a. live video scrubbing. When scrubbing through a video with this enabled, you will be able to see a live preview of the video at that timestamp. Note that this requires explicit client support, which may require some time to become available depending on your client.

• Web redirections are now handled more reliably, reducing the likelihood of hitting dead or invalid pages in the UI. Please ensure you force-refresh or clear any browser cache for your Jellyfin instance to see the full benefits.

• DLNA support is now provided by a plugin and has been removed from the core server. This has several major benefits: first, it can be updated independently of the server to some degree; second, it will not be enabled for anyone unless they want it and explicitly install the plugin; and third, it reduces the potential of security holes around DLNA due to both previous benefits. If you wish to use (or continue to use) DLNA, please install the plugin after upgrading.

• We now support AVIF and WEBP images for Pictures libraries.

• Tags are now accounted for during searches, allowing one to search by tag.

• We now support multiple simultaneous subtitle tracks (maximum of two, a primary and secondary) in the web player.

• We've revamped the administrative dashboard UI to help improve usability and ease of finding options.

API & Security​

• All API endpoints now return proper return codes, ensuring that API endpoint results can be reliably interpreted without additional parsing.

• Parental ratings are significantly improved, with better enforcement, inheritable ratings, and more.

• LiveTV and Collection permissions are now discrete and configurable per-user.

• The EasyPassword (PIN) feature has been removed as this was a big security risk especially for administrator accounts; QuickConnect login is still supported however.

• User permission handling has been unified and numerous bugs fixed, ensuring a more secure server from untrusted users.

Core Server & Networking​

• The .NET version has been upgraded to version 8, the latest major and LTS release. This brings us many under-the-hood improvements and changes to help with our ongoing effort to streamline the codebase and improve overall performance.

• Our minimum FFmpeg version has been bumped from 4.0 to 4.4 to take advantage of many new features. For users of our Jellyfin FFmpeg build (Docker, .deb/Debuntu repo, and Windows installs), you're already on a newer version with FFmpeg 6.0.1, but this minimum change would affect any other platforms.

• The server now supports in-process restarting, and removes the old hacky restart.sh method. This should make things like installing plugins much more robust and ensure a consistent restart experience regardless of platform or install method.

• Uploaded images are now subject to much more verification, helping plug several security holes in this feature.

• The backend SQLite database now supports connection pooling, which should improve performance for database operations.

• Support for the HappyEyeballs engine improving dual-stack IPv4/IPV6 network support.

• Improved handling of IP binding to fully respect these settings (including DLNA and SSDP).

Packaging​

• The jellyfin service user is now automatically added to the render and video groups on Debian/Ubuntu systems for new installs, helping improve the onboarding for hardware acceleration.

• Packaging is now unified with a new CI system, as outlined in our previous blog post. As a normal user you should see no change here, but this helps massively improve the build process, and if you are building your own packages please reference the new packaging repository for the updated process.

Transcoding & FFmpeg​

• The --ffmpeg command-line flag is now the primary method of setting FFmpeg paths, and configuration of the FFmpeg paths via encoding.xml is now deprecated. All official packaging will revert to defaults unless explicitly set before upgrade.

• Several audio improvements: support for Opus, FLAC, and ALAC codecs in the HLS engine; improved support and handling for transcoding DTS and TrueHD audio streams; new codec enforcement; better bitrate calculations; new audio normalization features; and stereo downmixing algorithm selection.

• FFmpeg segments can now be automatically deleted after the client requests them, significantly reducing the space requirements of the transcoding temporary directory. This optional feature is disabled by default and can be enabled in the transcoding settings.

• Support for direct stream playback of DVD and Blu-ray data folders, preferred over ISOs.

• Support for AV1 hardware and software encoding.

• Support for RK3588 hardware acceleration via MPP.

• Support for Vulkan-based tonemapping with AMD VA-API.

• Support for complete hardware acceleration on Apple systems (both Apple Silicon and Intel; previously was partial).

• Support for Dolby Vision playback remuxing.

Scanning, Library & Playlist Management​

• Support for scanning and displaying local lyric files (embedded or external files; Internet lyric provider searching is planned for 10.10).

• Season names are now parsed from NFO files.

• The MusicBrainz interface has been improved to better handle music libraries.

• Support for hearing-impaired subtitles (sdh/hi./cc).

• The visibility of playlists can now be made private

  • User playlists are now private by default
  • We're working on playlist sharing for a future release

• Invalid items will be automatically removed from playlists.

Casting​

• Better local network detection
• Connectivity improvements
• Ability to self-host cast receiver

We're looking for contributors for our cast receiver. This is the application that loads on a TV when using the "Google Cast" feature. Please reach out if you're interested.

The Next Version​

With our continuous integrations improvements outlined previously, we're quite confident that this will be our last "very long" release cycle. Our plan is for the next major version (10.10.0) to be released at most 6 months from now, some time in October. We hope this increased cadence will help alleviate the problems with large releases such as a very long time-to-stable for new features, translations, etc. and help lower the number of major bugs at each major release, streamlining the upgrade process. But this needs everyone's help. Back in October 2023, we made a call for developers, and we've gotten a lot of interest, but this is not a one-and-done event. We need contributions now more than ever, especially around the web frontend to help implement our planned design changes. If this interests you, please reach out and we can help get you set up.

Final Thoughts​

We want to thank everyone who contributed to the 10.9.0 release. According to GitHub over 100 people contributed across both repositories, and Jellyfin wouldn't be what it is without your help. We're really proud of this project we've built as a community, and hope to continue to be the go-to FLOSS media system solution for a long time to come. Happy watching!

That also means it's time to start testing. As outlined in our last blog post, we're doing things a bit differently this release, so this post will provide the steps one would need to take to help us test the new release.

If you want to help out, please read on!

- Joshua

What's Different and The Release Plan​

First, a quick rundown on what's different from our previous releases. The last few major releases, we went back and forth between various versions of -beta and -rc tags, but ultimately due to the complexity of 10.8.0 nearly two years ago, we've decided to abandon that idea going forward. As nice as it is to publish pre-release tags, we feel that doing so is not worth the burden and headache during this period and after, when we already have a better solution in our weekly unstable builds.

So, in effect, our weekly unstable builds are now working double-duty as our beta/release candidate versions. Here's how they map over the coming weeks:

• 20240325: The first "beta". Feature freeze has begun.
• 20240401: The second "beta". One week of freeze.
• 20240408: The third "beta". Two weeks of freeze, and we hope to have most glaring bugs fixed by this point.
• 20240415: The first "release candidate". We hope that by this point everything is in good shape for a release, with only a few lingering bugs.
• 20240422: The second and, ideally, final "release candidate".
• 10.9.0: The actual release, during the weekend of April 26th-28th.

All of this, of course, assumes a smooth window, we we are fairly hopeful of, but any number of things could throw a wrench in this plan, so we are continuing to play things by ear and see how each week turns out.

How You Can Test​

Testing this release should be very easy, in a way that our previous releases weren't. Since our pre-releases are "just" our unstable releases here, that means that following our normal "unstable" install process is all you need to do.

To find that, visit our main server downloads page, select the platform you require along the top centre, then on the top right, select "Unstable". The instructions and links will now be for the unstable release. You can also find additional testing documentation in the docs.

For Docker this simply means pulling the unstable tag on the image. For Debian and Ubuntu repositories, this means adding unstable to your existing jellyfin.sources entry. For other platforms, please review the provided instructions as not all platforms will support unstable.

Next, before installing an unstable release, ensure that you back up your existing server configuration. It is not possible to downgrade as there are a significant number of database changes. Just making a simple copy of your configuration directories is sufficient, and where those can be found depends on the platform.

Next, if you use plugins, install the unstable plugin repository. Due to compatibility issues, we distribute plugins for unstable in a separate manifest, so this must be added manually, and on first start all incompatible plugins (i.e. all existing plugins on an upgrade) will be upgraded. To add the repository, navigate to the Administration Dashboard, Advanced, Plugins, then click the Repositories tab at the top. Click the "+" Add button, and enter "Unstable" for the name and "https://repo.jellyfin.org/files/plugin-unstable/manifest.json" for the Repository URL. We also recommend that you disable/remove the Stable repository at this time, as it's possible they will conflict, and under 10.9.0 the repository URL will change. After the initial update you may need to manually restart your Jellyfin instance one further time to ensure all plugins are activated properly.

Finally, install the unstable version and run it. The upgrade should happen seamlessly in the background, and you'll be able to log in to your Jellyfin instance normally after this point. Ensure you perform a hard refresh in your browser, and restart all clients.

Once 10.9.0 is fully released, you can switch back easily by reinstalling the new stable version, and changing back to the stable plugin manifest (URL "https://repo.jellyfin.org/files/plugin/manifest.json").

How To Report Bugs​

While running the unstable prereleases, reporting bugs is important. After all, if we don't know about bugs, we can't work to fix them!

First, if you encounter a bug, ensure you're running the latest version, and try to reproduce it. If you can't, it's always possible it was a one-off occurrence, but if it happens again, definitely report it!

Bugs can be reported on our GitHub issues page or on our Forums.

You'll want to include two important pieces of information in your bug report, beyond the standard asks. First, ensure you include the "Build Version" as shown in the main dashboard page. This reports the exact unstable build you're using to help narrow down what might have caused the issue. This is doubly important if you see a new bug turn up in a future unstable build. Second, please make clear that you are running the unstable builds and not stable builds as well as if this is an upgrade or fresh install, as that can be an important piece of information.

Once your bug is reported, please check back diligently to see if any additional information has been requested, and we hope to get it fixed soon.

Information for 3rd Party Clients​

At this point, with our feature freeze our APIs should be stable, though do please expect bugfixes to make minor changes over the next few weeks. Please feel free to begin testing compatibility and report any issues to us.

Information for Contributors​

If you're contributing to Jellyfin and your existing feature PRs have not yet been merged, please don't fret. 10.9.0 was an abnormally long release cycle and something we do not wish to repeat, so your changes will get in soon for 10.10.0, which we expect to happen in about 6 months at most.

If you wish to help by submitting a bugfix, please do so as soon as you can, as we'd like to get as many fixes in and tested within the next ~3 weeks as possible, to give at least 2 weeks of final testing before the release. Ensure you clearly specify that it is a bugfix, and ensure you keep your changes to an absolute minimum needed to fix the bug. Bugfix PRs will target the master branch until the final release at which point they will target the release-10.9.z branch for upcoming point releases.

The TL;DR​

1. We have a new repository browser UI along with a new file layout, on a new master repository machine, built by new CI, that will hopefully make it nicer to look around and get right to what you need. This has now been cut over into production, but is still a bit of a work in progress, so please report any bugs you find to us! Note that quite a number of paths will have changed (anything under /server especially), but some will remain the same. If you get a 404 and can't find it through the browser UI, best to check in. 3rd party packagers downloading files manually from us are advised to contact us if needed.

2. We are dropping non-LTS Ubuntu packages, dropping our own Fedora/CentOS packages in favour of RPMFusion builds, and adding GHCR as a container repository for our Docker images.

3. For 10.9.0, we will not be producing explicit "beta" releases. Instead, we will test using our new Weekly Unstable builds. Once the master branch is sufficiently stable and good, we will release 10.9.0 directly from there (via our standard release branch process).

4. The 10.9.0 feature freeze (bugfix PRs only after this) will tentatively begin on Monday, March 18th. The hope is that all of the above will be ready by then so that obtaining Unstable builds for testing will be easy.

5. The 10.9.0 release itself is tentatively planned for the last weekend in April. To all 3rd parties who build packages of our releases, please read until the end for an important note about this release.

Read on for more details.

- Joshua

Why build a new CI?​

Our old CI was assembled way back in 2019 by a few dedicated team members (mostly @EraYan) using Azure DevOps. While it was a major improvement over my self-built pure-BASH build system that we had used for the first year or so, it still had a number of drawbacks:

1. It was a little difficult to understand, and relied on an external system (Microsoft Azure).
2. It still relied on a very complex, convoluted, and error prone BASH script to finalize the builds, because...
3. It built the Server and Web components of Jellyfin independently, triggered independently off the different repository tag events, and then had to rely on a whole lot of shenanigans to combine the results into unified, user-friendly packages.

There was also, though not a flaw with the CI system itself, the matter of Unstable builds. For a long time, they've been built on every merged PR, which was good for quickly seeing if things worked, but were effectively unusable for normal people as they changed so often. This was also something we wanted to fix.

At the time, GitHub Actions did not yet exist, and while we got everything to work, the CI as a whole was clunky and prone to failure. Major releases would often take me over 20 man-hours to prepare for and execute, while point releases would take at least 4-6 hours. It was a huge burden as a release manager, and also very cumbersome to fix if things broke in obscure ways, especially after the tag, because all the CI was in the code repos.

All this meant that our release velocity was extremely slow, as there was never a clear flow between master being tested and preparing for the next release.

Rather than continue incremental tweaking of this setup, about 2 years ago a project was started by @ferferga and @h1dden-da3m0n (who has since moved on) to move to GitHub Actions. While they did lay a lot of groundwork, that project ultimately stalled out and was effectively abandoned. Earlier this year, I took up the mantle to finally get this done in preparation for 10.9.0, and was able to get it working well, in a much easier to understand and hopefully much more consistent way.

More Automation​

The next part, besides just the CI itself, is an automation bot. As mentioned, releases took a long time, but only a fraction of that was spent actually dealing with Azure. The rest was administrative work: building changelogs, ensuring repos were in sync, running bump-version scripts, creating release drafts, checking them 3 times and still missing something, writing a release post for our Forum, etc. All of this added up to a significant time investment that I was rarely eager to do, which in turn trashed our velocity.

No project should be so dependent on one person, but we were, for a very long time. Part of the goal with this CI improvement is to streamline all these aspects as well using another piece of automation, a private chatbot.

The goal here is for us to tell our chatbot that we're ready for a release, for it to prepare all the text automatically, and then after review, tell it that it's ready to ship. Not only does this ease the process for myself, but it can easily be performed by others. And with the more reliable CI, this will hopefully mean a "set and forget" release process that helps us massively increase velocity.

While the bot isn't completely finished yet, the scaffolding is all there, and we definitely expect it to be ready to go in time for the actual 10.9.0 release.

Unifying packages​

One big drawback we mentioned of the previous CI was how it treated the server and web components of Jellyfin separately. It did this because these two components are indeed separate on the code side, in separate GitHub repositories and with different groups leading them. The problem is, that's not how Jellyfin is actually consumed by users. Users want just one package, installer, or archive to install and run out of the box. So we had to do a lot of complex shenanigans to combine the packages together.

No longer. With the updated CI, all our packaging is unified together, and split off into its own dedicated repository. This repository handles the two code repos via submodules and a simple Python script to synchronize what version is checked out of each before a build. Then, another Python script handles the actual building, which itself is then called from GitHub actions. It is still a little convoluted, but this is unavoidable for how complex our software ultimately is to package, and the hope is that having this in Python (a robust but easy-to-understand language) will help ensure this process isn't nearly as opaque as it previously was.

What this means depends on the different packaging types. For Debian and Ubuntu, it means that there is now one Debian source package for the three resulting binary packages (metapackage, web, and server) and thus all 3 can be built at once using a single dpkg-buildpackage command. For archives, this means that both the server and web components are built in sequence and then combined into one archive at build time, rather than haphazardly later, a process that failed more times than we could count. For installers, this means that the process is now simpler and can be automated. And lastly, for Docker, it means that we now provide just a single image, jellyfin/jellyfin, that was built all at once and does not rely on two intermediate images, another very error-prone process.

Related to this, and as part of the unified builds, each version of Debian and Ubuntu now has its own distinct package, with version suffixes like -deb12 or -ubu2204. This will help ensure smooth dependency handling for shared libraries like LibSSL. This should only matter if you're downloading .deb packages from the repo directly: ensure you download the right one for your release.

As a normal end user, you shouldn't see anything different because of this: you'll still install the packages the same way as always through our repositories. But for anyone building their own versions, you are now advised to use the above repository, as all non-development packaging (e.g. the debian/ and fedora/ folders, the deployment/ folder, etc.) will be removed from the main repositories, leaving just a simple Dockerfile for building testing and development images quickly.

A new repository master for a new CI system​

One thing the ground-up CI and unified packages enables is a much cleaner repository structure. Our previous structure was based around the combining requirements, full of strange quirks and nested directories to try to make that simpler. With those out of the picture, we were able to settle on a much nicer layout, and thus, a brand new master server to house them for an easier transition.

Part of this also includes a revamped browser page to easily facilitate getting to the files you need, descending through the tree of the new layout in a much more user-friendly way.

The new browser and repository master is now live as of posting at https://repo.jellyfin.org for perusal, and still includes the stable release packages in the new layout for your convenience until 10.9.0 is released. So, as mentioned in the preamble, please test it out and let us know if you run into any trouble with it, any broken links, or similar issues.

Unstable Releases​

As mentioned a bit above, our previous "build things on every pull request merge" was quite cumbersome to use, as things would change very rapidly, and keeping testers up-to-date was nearly impossible during fast-moving days. Way back in the early days, we had experimented with daily builds before moving to this model, but even those felt a little too quick for both our current development pace, and for users to keep adequetly up-to-date.

Instead, going forward we are moving to a Weekly cycle for Unstable releases. The builds will occur on Monday mornings around midnight Eastern time (UTC-5/4-with-DST), a time chosen farily arbitrarily but ensuring each week starts with a fresh Unstable build. This process is completely automated, and the resulting builds will be available soon thereafter in all our normal places.

We hope that this slower pace will help ensure that users running our Unstable builds have more of a chance to actually test the current state of Jellyfin and not be overwhelmed by the speed of releases, while also providing fast enough movement for people to truly test the latest and greatest features and bugfixes.

One final note, mentioned in more detail below, is that these Unstable Weekly builds will act as our pre-release testing for 10.9.0: there will be no tagged "beta" or "rc" releases for this cycle. This is being done to avoid the major burden we found with 10.8.0 of trying to continually backport the fixes for the upcoming stable release back into master, while also forward-porting bugfixes in the other direction when they were accidentally mis-targeted.

Cleaning up what we build​

As mentioned in the TL;DR, we are making three major changes to what we build, both for the Unstable releases and the upcoming 10.9.0 release:

1. We are dropping all non-LTS Ubuntu releases from our official APT package repository.

   The reason is simple: it's a huge burden to keep up with Ubuntu's 6 month release schedule, just to support what are in practice minor versions with a 9 month lifespan. While we understand people might want to run Jellyfin on desktops or ensure their servers have "the latest" stuff, this just isn't tenable for us long term. So, going forward, our packages will only target the LTS releases, starting with 20.04 "Focal", and including 22.04 "Jammy" and the new 24.04 "Noble" due to release in April.

   If you are using a non-LTS version of Ubuntu, you still have options. First, you can always upgrade to 24.04 and use that going forward. However do note that 24.04 will be the latest release that we build for until 26.04 comes out. Alternatively, if you still want to keep your system on the 6-month update path, you can migrate to our Docker images instead, and these have the added benefit of additional long-term stability even as your base OS changes.

2. We are dropping our own "official" RPM builds for Fedora and CentOS(-like) distributions in favour of RPMFusion:

   These builds have always been a bit of a red-headed-stepchild for us. They were poorly maintained (despite some valiant efforts and community contributions), broke frequently, and this all came to a head when we started working on a combined spec.

   Luckily, a community member (@mooninite) has already been maintaning a stable combined RPMFusion build of Jellyfin. This seemed like a perfect time to switch to that, reducing another bit of packaging burden away from us, as well as (finally) providing a "real" repository for our RPM-based users. The RPMFusion build is now the official Fedora/CentOS build listed on our downloads page and will be going forward. We're also taking steps to get a packaged FFmpeg build provided there too, so stay tuned.

   Unstable users on Fedora/CentOS are recommended to stick with the Docker container instead, as this both bundles FFmpeg today and helps ensure speedy upgrades.

3. We are finaly adding GHCR (ghcr.io) support for our Docker images. This will help ensure that, even if something were to happen to Docker Hub, there is another source for our Docker images. If you wish to, you can use this source immediately for Unstable builds, and for 10.9.0 when it is released.

The 10.9.0 release cycle​

As we outlined over in this GitHub discussion, all these changes mean there will be some big changes for how we approach the 10.9.0 release cycle. To clarify things, the exact process will be as follows:

1. Starting now, and moving forward indefinitely for all future releases, the Weekly Unstable builds will act as the "beta" versions. That is to say, if you want to help us test, or just keep up with all the latest and greatest features, use the Unstable releases. The instructions found on our Downloads page still apply for enabling Unstable builds, as well as listing all of our supported Unstable platforms.

2. As we approach the planned release date, we will begin a feature freeze. While in the feature freeze, only bugfix PRs will be accepted. We expect this to last between 3 and 5 weeks. Currently, the tentative start is Monday, March 18th. During the freeze, the Unstable builds should be consistent and working, with only the minor fixes being merged.

3. As users, please be diligent about reporting bugs in the Unstable releases. Our Triage team has been very diligent these last few months at ensuring issues are triaged and looked at, so it is vitally important that anyone using the Unstable releases properly reports their bugs!

4. As we approach stability, i.e. after the 3-5 weeks of frozen bug-fixing, we will make the decision to cut the actual final release. I am personally hoping to get this done during the weekend of April 27-28, but that may change depending on how things go during the freeze.

5. The release will actually happen. We will cut a fresh release branch, tag the version, and - using the new CI above - perform the release. We do want to ensure that any 3rd parties who might trigger off of a Tag event on our repositories please turn this off for this release, as we fully expect to hit at least one or two roadblocks as we run through the process "for real". Once the dust settles, we can ensure that your releases get built, just in case we need to do anything drastic like re-tagging the release. Longer-term, we'll also come up with a better coordination process, so we'd like to ensure we work with any 3rd party maintainers to assist here - please reach out.

6. At that point, master will resume normal operation, and we will begin the stable point bugfix cycle for 10.9.0. We hope that with the improvements, 10.10.0 will not be a very long ways away after that, perhaps 3-6 months, after which this process will start anew.

We are very nearly there, over 2 years in the making, so we wanted to ensure we spread the word about this plan as far and wide as possible, especially to help get more people testing the new Unstable builds for bugs as we prepare for the final release!

Final thoughts​

That basically concludes my thoughts right now, both on the roadmap to 10.9.0 and the improvements we're making and have already made to the release process. Happy watching!

- Niels & Max

What's new​

The focus of this update is maintenance. We've fixed various bugs and made sure the app works on newer Android versions. Noticeable is the improved connection screen that now remembers your previously connected servers, making it a lot easier to switch between them.

Full release notes​

The complete list of changes for this release, including their respective pull requests, can be found on GitHub.

Contributors​

Jellyfin is developed by volunteer contributors, and we couldn't do without their great skills and dedication. They don't get paid by any organizations, so consider donating if you appreciate their work. A big shout-out to all contributors that made this release possible:

Jellyfin Team

• @Maxr1998 - Sponsor via GitHub sponsors
• @nielsvanvelzen - Sponsor via GitHub sponsors

Other contributors

• @timm0e
• @jmarcet

We'd also like to thank everyone who reported bugs, provided feedback and participated in beta testing! The feedback we received made this our most stable release to date.

Helping out​

If you have some experience with Android development or with Kotlin and are interested in contributing yourself, feel free to dive into the source code on GitHub and open pull requests.

Alternatively, you can help with translating the app into your language on our Weblate instance.

Downloads​

Update your app now to check out all these changes! The app stores will auto-update your Jellyfin app if you're already using the app. For new users, you can find the app here:

Direct downloads are available for sideloading at repo.jellyfin.org or in the GitHub release assets.

You can also join our beta program on Google Play and help test new versions before they're released to the public.

Read more to learn about some of the exciting new features.

- 1hitsong

👥 User Select Screen / Auto Login​

When launching the Jellyfin app, it now presents you with the list of public users and any private users with saved credentials for you to login as.

If you prefer to have the app automatically login as a specific user, simply login as them and enable the new global Remember Me setting. With this global setting enabled, the app will automatically login as this user at the start of the Jellyfin app without needing to select them or enter a password.

Note: Users upgrading from 1.6.6 will automatically have this global setting enabled and will automatically login as the last user logged in to the 1.6.6 app.

Additionaly the code behind the login form has been updated to remove several annoying bugs. Unlike before, access for all remembered users will continue to work even when other users log in and out. Also, the What's New popup will now appear for all users on their 1st login of a new app version.

🎥 On Screen Display (OSD)​

The new OSD provides quick access to the new chapter navigation functions, and is also the new way to access the playback info and subtitle section popups. This is only the start for the OSD. We have a lot of new and exciting functions we will be adding in the future!

To access the menu simply press either UP, DOWN, OK, or PAUSE while in the video player. Like we said, the menus you previously accessed by pressing UP or DOWN are now available from the OSD.

Note: The video position bar is not currently selectable from the OSD. It is informational only for now.

If you want to step through the video position, simply press LEFT or RIGHT when the OSD is not on the screen, just like it's always been before. Rewind and Fast Forward also operate the same way. Simply press the button on the remote when the OSD is not shown.

🎸 Music Video Support​

Support for Music Videos has been added. If the user has access to the Music Videos library, it will appear in the My Media section and the Latest videos will show on the home view.

🏎️ Quickplay Support Expanded To Entire App​

Stop wasting time and get your media playing ASAP!

Quickplay support is now across the entire app. Simply highlight an item and press play on your remote. The client will then queue up to 2000 items and start playing.

TV season? Check. Playlist? Check. Your favorite actor? Check. Your music library for a week long rager? Ya' better believe check.

📺 TV Show Season Extras Support​

You can now access TV show season extras in the Jellyfin Roku app. Simply navigate to a season of a TV show and if Jellyfin has found extras, a new button labeled Extras will appear on the left side of the screen under the Shuffle button. Clicking it will toggle between viewing a list of episodes and a list of extras. Simply click on an extra to start watching.

📺 TV Episode Version Support​

Have different versions of a TV episode? You can now select and watch the version you want. On the list of episodes, highlight the episode you want and press * on your remote. The option popup now provides not only audio options, but also version options.

Note: If one of the Videos has different audio options, the user must select the desired video version, exit options, then press * again to see the updated audio options.

Note: As of this writing, the only way to generate episode versions is in the Android app or using the API.

🔍 Search Honors Library Permissions​

Search in Roku now honors library access permissions. If a user doesn't have access to a library, items in that library are no longer returned in search results.

The screenshot above shows what search results look like if a user does not have access to the movie library.

🔢 Use Web Client's Home Section Arrangement Setting​

A new setting has been added under User Interface > General > Use Web Client's Home Section Arrangement. This setting causes the order of the home sections in the Roku app to match the order of the home sections as set in the server settings.

...and on, and on, and on​

• Native support for the AV1 codec (no more user setting)
• Boxsets now sorted by release date by default
• View your music library by Album Artists
• Custom subtitle support (required for CJK support) expanded
• Alpha menu now wraps from bottom to top & top to bottom
• When connecting to a new server, automatically attempt connection using default protocols and ports if not specified
• Updated loading spinner similar to the video player spinner
• Use TV show posters (if available) instead of channel posters for the "On Now" home section
• Device Profile has been rewritten and improved
• Improved "Next Episode" button logic
• Movie and music libraries now sorted A to Z by default
• Fixed several bugs that could crash the app
• Many (oh so many) bug fixes

There are simply too many amazing things in this release to name them all! To read the full list of changes, please read the full release notes.

👥 Contributors​

Jellyfin apps are developed by our great contributors and we couldn't do it without them. Everyone is a volunteer that doesn't get paid by any organizations, so consider donating if you appreciate their work. A big shout-out to all contributors that made this release possible:

Jellyfin Team

• @1hitsong - Sponsor via GitHub sponsors
• @cewert - Sponsor via GitHub sponsors
• @jimdogx
• @neilsb

Other contributors

• @alanazar
• @ApexArray
• @arturocuya
• @candry7731
• @iBicha
• @JarodTAerts
• @Klikini
• @matty-r
• @pau1h
• @photonconvergence
• @sevenrats
• @tharvik

💾 Downloads & Changelog​

Requires minimum server version of 10.8.1

The complete list of changes for this release, including all merged pull requests, can be found on GitHub.

Your installed Jellyfin channel should automatically update once available or you can install Jellyfin from the Roku store.

- Niels

Significant changes​

In this post I will focus on a few of the popular and significant changes. As always, a lot more changes were made both visible and invisible; check out the full changelog to discover the full extent of this release.

Music playback​

Playing media is the key feature of Jellyfin. Up until now the Android TV app had many issues playing every possible format. The code was also hard to work with making it challenging to fix the issues or implement new features. To counter this we decided to rewrite all playback code completely from scratch. In this release the initial results are ready for daily use and playing music will use the new playback code!

While a lot of this work is not directly noticable when using the app, some of it is. Crashes should now be uncommon, starting music is faster and the remote control now responds more reliably. We've also added media sessions, this allows you to play/pause from other applications on your TV or even your smartphone!

Improved codec detection should reduce transcoding and use direct play more often resulting in faster playback with less strain on the Jellyfin server. We already have plans to improve this even more and add preferences to fine-tune this for your specific devices. Other planned features include showing lyrics, enabling SyncPlay and gapless playback support.

Work has already started to rework video playback based on this new code so we can add all kinds of new features with ease in a shared code base for both video and audio playback.

Screensaver​

The screensaver has received some nice additions. It was redesigned to be faster, with better animations and a much nicer appearance. Alongside this redesign, new functionality was added. Music playback has been added to the screensaver, replacing the old screensaver from the 'now playing' screen. Additionally, the screensaver is now enabled by default when the app is open, eliminating the need to enable it system-wide.

And the best part: the screensaver now works when the video player is paused!

Search​

The search screen was partially rewritten to improve performance. It will now cancel any pending search requests while typing and use a different method for getting the results. With these changes, a search on a large server is now noticeably faster and no flickering occurs anymore.

Full release notes​

The complete list of changes (over one hundred!) for this release, including their respective pull requests, can be found on GitHub.

Contributors​

Jellyfin is developed by volunteer contributors, and we couldn't do without their great skills and dedication. They don't get paid by any organizations, so consider donating if you appreciate their work. A big shout-out to all contributors that made this release possible:

Jellyfin Team

• @nielsvanvelzen - Sponsor via GitHub sponsors
• @thornbill - Sponsor via GitHub sponsors
• @1337joe - Sponsor via GitHub sponsors

Other contributors

• @DoggoOfSpeed
• @DavidFair
• @Clubfan22
• @MWisBest
• @teobaranga
• @tim-vk
• @OctoNezd
• @polson
• @mohd-akram
• @horizon1250
• @reacocard

We'd also like to thank everyone who reported bugs, provided feedback and participated in beta testing! The feedback we received made this our most stable release to date.

Helping out​

If you have some experience with Android TV development or with Kotlin and are interested in contributing yourself, feel free to dive into the source code on GitHub and open pull requests.

Alternatively, you can help with translating the app into your language on our Weblate instance.

Downloads​

Update your app now to check out all these changes! The app stores will auto-update your Jellyfin app if you're already using the app. For new users, you can find the app here:

Direct downloads are available for sideloading at repo.jellyfin.org or in the GitHub release assets.

You can also join our beta program on Google Play and help test new versions before they're released to the public.

As part of this release, we have made a change to the behaviour of the "FFmpeg path" GUI configuration option in Jellyfin. Specifically, in version 10.8.13, this functionality has been disabled, and will be fully replaced in the next major version (10.9.0). Editing this value in the GUI in 10.8.13 or later will not change it. In the short term, those wishing to make further changes to their FFmpeg binary must do so by editing the encoding.xml configuration file instead of using the GUI, and the server must be restarted after making the change. Note too that the --ffmpeg flag may or may not change this for you, depending on what version you originally installed; while you should change it to match, you may still need to update the XML file as well.

This feature/option stems from Emby 3.5 and the very earliest days of Jellyfin, when user configuration of a custom FFmpeg was much more common and often required, especially to provide hardware acceleration or a newer version than the host operating system provided. However, at this point, it is our belief that this is a very uncommonly-used feature, with most servers using our default jellyfin-ffmpeg packages, and thus we believe the impact from this change is minimal. The change also does not affect existing installs or non-default configurations of this value; those are preserved, and only future changes in the GUI are blocked.

Thankfully for our users, this option has always required administrator privileges to the Jellyfin instance, and thus required an abusive administrator to leverage for nefarious purposes. We are aware that this change violates Semantic versioning standards, but after having several vulnerabilities in 10.8 that either include or potentially include this endpoint as a vector, we have decided to remove it now to avoid any potential further exposure for our users while we continue to work towards 10.9.0. While we have not completely decided how this functionality will be implemented there, it will similarly require reconfiguration outside of the application and a server restart to provide safety and security.

Lastly, we want to remind all users that granting administrator access to a Jellyfin server is, in many ways, tantamount to granting them shell access. An administrative user has the power to do many dangerous and destructive actions, such as deleting files or overwriting configurations, even with this feature removed; plugins may also grant even more access, including full shell access should the plugin decide to. Thus it is always best to be safe and avoid handing this privilege out except when absolutely required, and only grant administrator privileges to people you trust and to accounts with strong passwords. Further, we recommend that you do not use an administrative user for day-to-day usage, especially in any client applications, just in case of future vulnerabilities in these applications.

This year, DigitalOcean's Hacktoberfest is in it's 10th year. In previous years, we haven't made too much of it, but within our project, this is our most important year yet.

We'd like to call on you, the wider community, to help make Jellyfin better! We need contributors, fresh ideas and blood to help the project move past our current funk and into something more.

Will you join us?

We keep a close eye on the buzz about Jellyfin around Reddit and the Internet more broadly; in the last couple weeks we have seen a few major Plex-related kerfufles and the comments inevitably include the following exchange:

Person A: Use Jellyfin instead Person B: Jellyfin sucks, it lacks client X or feature Y Person C: Works for me Person D: It needs polish and more apps

Sometimes one of us will jump in, but I think it's high time for us to make a public request for something that's been on our minds as a team for quite a while.

For those who are not aware, Jellyfin is a bit unusual, even within the FLOSS world. We are explicitly anti-commercial. Our team is entirely composed of volunteers who contribute because they like what we're doing and can help out in whatever ways they can. This includes developers, translators, and community members who help moderate the community and assist others in troubleshooting and working through problems.

No one gets paid for Jellyfin work, by design. We're not backed by any company or "organization" with its own agenda. We have no "monetization plan" or anything of the sort, and actively avoid bug bounties. Jellyfin isn't a "product" in the commercial sense of the word. And while we do take donations, these only cover our infrastructure costs and the rare piece of developer client hardware as needed; we don't pay developers out of donations, and never will. Money is not an issue (for what we use it for), and that's not really what we need. This is a choice we've made from day 1 to avoid Jellyfin following in the footsteps of nearly every other player in this space, who start out as FLOSS, start adding user-hostile features in the name of money, and then go closed source. We want to be different. We want to be volunteer-only and work on this thing to help make media streaming available to everyone.

But, the team behind Jellyfin is under strain. We love what we do, and want to keep doing it. But our core contributor base is actually fairly small, at most about 30 active people, for everything - the core server, the webUI, and all of our clients. And it hasn't really grown in quite some time. Some of our developers have been with us since the early days, some joined later, but life sometimes gets in the way, and we've lost some over the years, so the number has been pretty flat for the last 3 years all together. For some parts of the project, especially individual apps, we have at most 1 or 2 people working on them, for free in their own time, because it "scratches their itch".

Some very-well-requested features/clients have gotten no traction at all, with no one coming in willing to start/help developing them. We've had to abandon some (like Chromecast for a while, though it's getting new life in the last few weeks) because of this.

We're aware that probably the biggest complaints about Jellyfin are about the lack of client support, and the rough edges/lack of polish. We do hear you. We do want this to improve this just as much as you do.

But we need people to help us do so. We need more volunteers who can help make the code better, write new code, document, and generally improve things. We need your help to push past what I call the Development Bystander Problem, get some new blood into the project, and especially, help to make it better!

So, this is our open call to the world: Jellyfin needs YOU!

Whether you're a developer, a writer, a UI/UX designer, a non-English-language speaker, or just an avid enthusiast willing to help out, no matter your experience level, we'd love the extra help.

We have some resources to help you get started, and our chat channels on Matrix/IRC/Discord and the Forum are quite active, with the team very happy to help new contributors.

Every little bit helps, from fixing a small bug to improving the documentation or working on a full client. We do have a "track", so to speak, for people to officially join the team as well: if this is something you want, it's absolutely possible after proving yourself with quality contributions of any kind and a willingness to participate.

We want to make Jellyfin better, and address our users' concerns, limitations, and bugs. We hope this post explains where we're at and helps inspire some new contributors to join the project and help us truly turn Jellyfin into the best streaming server it can be, free for everyone forever.

Thanks, and Happy Watching!

https://forum.jellyfin.org

You can see the welcome message here and the forum rules here, or you can jump right to registering here, using either native forum registration or using an account from Discord, GitHub, Google, Reddit, StackExchange, or Twitter.

As part of this, we have also decided to close our Reddit community presence permanently. Please see the message there for details.

If you just want to get registered and start posting, this is all you need. But if you're interested in our motivations, choices, and technical implementation, please read on!

Motivations​

The Jellyfin project did previously have a forum, based on the Discourse forum software, but it fell into disuse for numerous reasons. For starters, very few of the active team members enjoyed participating in it, and this was a period where we were not yet ready for the community to moderate itself. Further, many of us felt the software to be clunky to use and thus were hesitant to visit. Lastly, the result of these two issues was that the forum effectively turned into a graveyard of help requests that went unanswered. It was due to this that we finally shut it down back in 2021 and moved exclusively to Reddit as our "community forum".

However we were never truly satisfied with Reddit, nor with our other major discussion areas (Chat, GitHub), for the long-form and long-term discussions that are often required in a project of our size. So for quite some time, we had been considering bringing a forum back to provide another avenue for discussion.

Then, the recent issues surrounding Reddit as a platform became very apparent. This sudden and shockingly brazen attempt by that platform to kill its 3rd party clients, which most of the team make extensive use of, made us seriously reconsider its use as our primary social forum. As part of the site-wide protests we took the subreddit private, and after a week with no compromise from the Reddit side, have decided to permanently close but leave visible the subreddit (i.e. make it read-only going forward).

As a response to all of the above, we finally decided to take the step to set up a new forum, so that we can build a place for the Jellyfin community - for development, support, and camaraderie - that is not beholden to other platforms and their whims.

Choosing a Forum Software​

The first step of setting up a forum is, of course, to choose what software that forum will run on. After ruling out all proprietary options, we looked at several FLOSS forum tools, which basically boiled down into two categories: "modern" forums, and "traditional" forums.

Modern forums include Discourse, and have some advantages like better performance. But their drawbacks include a user interface that is far more "gamified" and similar to a social network than a traditional forum, and this is something we wanted to avoid. In particular, personally, I detested Discourse's UI and navigation, finding it very difficult to use, and this was a view shared by many on the team.

In contrast, traditional forums are the mainstay of the pre-"Platform" Internet. Anyone old enough to have been online in the 2000's through the mid 2010's remembers the traditional forum layout. And this is what we feel is best for usability. While there is some dissent, we think that this option will be the ideal choice for our community coupled with a modern and responsive theme.

Having decided on the type of forum, we then looked at the options. The main two were phpBB, a very old mainstay, and MyBB, a newer alternative. After trying to setup phpBB and finding its themes and plugins lacking, we went with myBB instead, and so far this has worked out well.

The last main aspect was theming. The theme makes the forum, from a UX and usability standpoint, and we wanted something that allowed some user customization (light and dark modes mostly), looked current, fit our branding, and was responsive and mobile-friendly. We settled on a theme called Emerald, which features both Light and Dark variants and a lot of customizability to fit our brand, well worth the $25 cost. We've already made plenty of tweaks to the colours, templates, and layout, and are still fixing some bugs, but we are very happy with the results so far.

We've also enabled an expansive number of plugins, for instance nice URLs, custom emojis/reactions, etc., to maximize usability and consistency.

User Layout and Permissions​

The lack of moderator buy-in from our original forum was, as mentioned, a big pain point. So for our new forum, we've introduced an expansive moderation team to help ensure the forum runs smoothly.

There are effectively 4 categories of users:

• The Jellyfin Leadership/Core team, who will act as global moderators and administrators of the forum.
• All other Jellyfin team members, who will act as moderators across all forums.
• A new subset, our Community Moderators, who have been chosen from among the wider community for their excellent reputation and work in helping users across various platforms, and will act as moderators across all forums with a more limited permission set.
• Finally, our users, will have a normal user permissions.

I'll collectively refer to the first 3 groups as "Moderators" going forward in this post for simplicity.

Forum Layout​

The forum layout is a big thing to consider. One issue we had with Reddit as a forum is its lack of organization. While flairs help a lot, it is still a jumbled feed of numerous categories of discussion, and this is something we definitely want to avoid with our forums.

The first main section is the "Announcements" category. This includes two forums: a "Forum Announcements" forum for the occasional forum announcement, rules thread, and welcome thread; and a "Release Announcements" forum where the team will announce the releases of our various projects (server, clients, plugins, etc.). By separating these out, this allows us to create organized discussions around each release and permit discussions while also acting as a source of "the latest news" for the community, in a way that the 2-sticky-limit of Reddit simply could not. Only Core members may post in the Forum Announcements forum, while all Moderators can make threads in the Release Announcements forum and all users may post in those threads.

The next section is the "Support" category. This includes 3 parent forums as well as several subforums: a "Guides, Walkthroughs & Tutorials" forum for helpful guides, from early stages all the way up to "good enough for the official docs" as living documents; a "Themes & Styles" forum for discussing styling and theming of Jellyfin (custom CSS, etc.); and a "Troubleshooting" forum for help with running Jellyfin.

Within "Troubleshooting", we still have not decided on a concrete forum structure, as we expect our needs here to change depending on how the community uses it. To start, we've left the main "Troubleshooting" forum to handle all primarily-Jellyfin related troubleshooting, and have included two subforums for known-common but not-exactly-Jellyfin categories of help: "Networking & Access" for help with VPNs, reverse proxies, networking, and the like; and "Scanning & Identifying" to help with issues related to media scanning, identification, etc.

Within each Troubleshooting forum is a stickied "Frequently Asked Questions" thread to act as a living document and list of common questions that are brought up and their solutions.

The next section is the "Development" category. This includes quite a number of forums dedicated to the development of Jellyfin, mostly of use to developers, including a large number of Client subforums. For end users, the main forum of interest is "Feature Requests", which is a forum for discussing the feature requests present on our Fider instance in a long-form way not really suited to Fider itself.

The final section is the "Off Topic" category. In here you can find, at least to start, 3 forums: "General Discussion" for all manner of off-topic discussions (but keep it SFW as per our rules!); "Self-hosting & Homelabs" for discussions about your self-hosted services, homelabs, etc.; and "Media" for discussing your favourite media (but not where to get it, again as per our rules!). We may add more depending on the community's needs and desires as time goes on, but we feel this is a good start.

Speeding it up!​

One thing we wanted to be sure of is that these forums could handle the load of our large community effectively. While we are somewhat limited in our ability to scale the core database and PHP backend, we were able to leverage our content delivery network for distributing the static assets, such as CSS, Javascript, and images, via more local servers across the globe. While that post has not been updated since it was made, we currently have a total of 9 mirror servers spread across 4 continents, one for each DigitalOcean datacenter, which will hopefully ensure speedy delivery of assets to everyone.

As the load picks up, we'll continue to evaluate our options, but we hope this will be sufficient enough for the first wave. But if the forums are down please don't fret, we'll get them fixed as soon as we can!

Version 2.5.0 again focuses on improvements to the integrated player, and brings various new features, many bug fixes and a lot of technical maintenance and rewrites.

Read on to learn more!

Integrated Player Improvements​

In this release, we finally introduce the highly requested bitrate selection so that you can transcode to lower resolutions to save your precious mobile data while on the go. The audio and subtitle track selection was reworked and improved multiple times and should be a lot more robust now. Thanks to everyone who reported bugs! The complicated nature of various playback methods, inconsistencies between the server and ExoPlayer and misconceptions about their inner workings caused countless edge cases that could only be discovered through a lot of trial and error.
The player interface itself now has a back button to close the player and a new playback option was added to pick between hardware and software decoding, if the default hardware decoder causes issues for the currently played video.

In the client settings (which you should make sure to check out) we added the option to pick the initial orientation for video playback and now allow choosing whether you want video with SSA subtitles to be transcoded (for full styling support) or not (to direct play with limited styling).
There's also a link to the operating system's subtitle customization settings, which the integrated player uses to style your subtitles. Note that the subtitle settings in the Jellyfin settings only apply to the web player due to technical reasons.
Talking subtitles, the player now supports the PGSSUB codec without transcoding.

Other Tweaks​

Thanks to @susonthapa, the app now shows a splash screen with the Jellyfin logo on start, instead of the previous, boring gray screen where you didn't see whether the app was actually doing anything.
While the app is connecting, there's now a cancel button so that you can quickly jump to the connect screen to select a different server if the current one isn't available at the moment. The connect screen itself was reworked and rewritten for a slightly cleaner design and easier maintenance.
We also added a monochrome icon so that Jellyfin will look great on your home screen on supported launchers on Android 13 and above.

Full Release Notes​

The complete list of changes for this release with all merged pull requests can be found on GitHub.

Contributors​

Jellyfin is developed by volunteer contributors, and we couldn't do without their great skills and dedication. They don't get paid by any organizations, so consider donating if you appreciate their work.
A big shout-out to all contributors that made this release possible:

Jellyfin Team

• @Maxr1998 - Sponsor via GitHub sponsors
• @nielsvanvelzen - Sponsor via GitHub sponsors

Other contributors

• @susonthapa
• @mingyech
• @colonelpopcorn
• @Irishsmurf
• @eglia
• @nalsai

We'd also like to thank everyone who reported bugs, provided feedback and participated in beta testing!

If you have some experience with Android development and are interested in contributing yourself, feel free to dive into the source code on GitHub and open pull requests.

Alternatively, you can help with translating the app into your language on our Weblate.

Download Now​

Direct downloads are available for sideloading at repo.jellyfin.org or in the GitHub release assets. You can also join our beta program on Google Play and help test new versions before they're released to the public.

- 1hitsong

Requires minimum server version of 10.8.1

🐛 Bug Fixes​

• Fix distorted TV episode posters. Add client-side progress bar and played indicator
• Fix option menu focus if opened while library still loading
• Only show next episode popup if web client setting is turned on
• Fix default view setting for movie genres
• Graceful episode playback failure
• Fix multiple client crashes identified by crashlogs

⚙️ New Settings​

• User defined maximum video bitrate
• Disable unwatched episode count
• Next episode button time

🆕 New Features​

• TV series & season shuffle
• Phase 1 CJK subtitle support (External files only)
• Phase 1 playlist support (Does not currently support CJK subtitles)
• The options button now closes the user settings menu
• New persondetails view
• Genres, parental ratings, and years as movie filters

⭐ Additional Updates​

• Improve settings menu, implement title hover and hide in griditem and musicartistgriditem
• Improve quality of album art on now playing view
• Make home view load faster
• Updated "OnNow" home row to default to channel images if program images are not availible
• Update CI ubuntu version and node version
• Install & configure unit test suite
• Add user policy to check if canDelete
• Loading spinner, Progress Dialog and movie details button animate
• Make title scrolling consistent in extras slider
• Add settings guidelines to devguide.md
• Add workflow to validate XML translation files
• Add json and markdown to lint workflow + add automation workflow
• Create global audio player
• Fix typo: trancoding -> transcoding
• Fix en_US translation file
• Make CI throw error for duplicate translation entries
• Add a production build workflow
• Show "Actor" when an actor has no role

👥 Contributors​

Jellyfin apps are developed by our great contributors and we couldn't do it without them. Everyone is a volunteer that doesn't get paid by any organizations, so consider donating if you appreciate their work. A big shout-out to all contributors that made this release possible:

• @RussianCow
• @1hitsong
• @cewert
• @jimdogx
• @jkim2492
• @sevenrats
• @candry7731
• @ApexArray

💾 Downloads & Changelog​

The complete list of changes for this release, including all merged pull requests, can be found on GitHub.

Your installed Jellyfin channel should automatically update once available or you can install Jellyfin from the Roku store.

• Fernando

Don't know what Jellyfin Vue is? Skip to What's Jellyfin Vue? section. What's below is a rather technical explanation

When we started working on this client, we used Nuxt and Vue 2, even when Vue 3 was right around the corner. Nuxt has been an amazing tool to scaffold our project, and get started into the Vue ecosystem. It even allowed us to play with SSR. However, it forced a really rigid structure on us, besides SSR turned out to be a burden. We had even to use some hacks to avoid killing playback while transitioning between pages.

As part of our Vue 3 migration, we switched to an standard Vue 3 project structure (Vue 3, Vite, TypeScript and, in the future, Vitest), which allowed us to remove many of the hacks and legacy code we used to overcome Vue and Nuxt 2 limitations. Beside that, Vue 3 only supports ES6-compatible browsers. We also use some syntax that's only compatible with ES2022. All of this means that, as part of this upgrade, we also deprecated all legacy support for outdated browsers. That include the majority of TVs. Chrome/Edge/Firefox/Safari, both in desktop and mobile platforms are still fully compatible. If the web browser of your device still gets updates, it'll likely have no issues running Jellyfin Vue.

Although the affected userbase will probably be small, I'm sorry for those who might be affected by this decision but, given our limited resources, looking forward is our only way to go if we want to provide the best alternative web client for Jellyfin. You can still run the pre-Vue3 version (go to Downloads & changelogs to know more), although it will not receive any support from us.

A note on privacy 🕵🏻​

I wrote an small disclaimer explaining how Jellyfin Vue (and Jellyfin Web) works, since I saw a lot of misconceptions about how our hosted instance works and how connections from Jellyfin apps to the Jellyfin server works.

Please, give it a read!

👥 Contributors​

Jellyfin apps are developed by our great contributors and we couldn't do it without them. Everyone is a volunteer that doesn't get paid by any organizations, so consider donating if you appreciate their work. A big shout-out to all contributors that made this possible:

Jellyfin Team

• @ferferga - Sponsor via GitHub sponsors
• @ThibaultNocchi

Other contributors

• @Janbong
• @aweebs

💾 Downloads & Changelog​

As part of this upgrade, we created 3 releases:

• v0.2.0: This is the last release powered by Vue 2.
• v0.3.0: This is the first release powered by Vue 3. This was tagged right after we merged the branch we've been working on these past months.
• v0.3.1: Same as v0.3.0, but after all the pending dependency updates have been merged.

What's Jellyfin Vue?

Jellyfin Vue is an alternative web client some of us started working on in 2020. Jellyfin Web had a lot of maintenability problems, so we thought it might be a good idea to start a new client with modern web development technologies in its stack and use it as a playground for testing some cool features that might not make the cut (or would've been impossible to make) in Jellyfin Web.

Head over our GitHub repo to know more about it and see how you can use it!

What's next?

We have a roadmap with what we want bring up next: a media-type driven design, where your media feels at home every time. The current approach of most Jellyfin clients is to be too generic in order to be suitable for all media types possible, but when you're listening to music you don't feel you're in a music player (like Spotify) or in Netflix when watching TV Shows and Movies

There's also an approximate schedule to better sort our priorities.

- 1hitsong

🐛 Bug Fixes​

• Fix TV season list crash when showing 27+ episodes
• Fix crash when viewing in progress recording
• Fix crash when options button pressed, but options are not available
• Fix crash when invalid deep link arguments are passed
• Show unwatched episode count on TV images
• Fix TV episode cursor focus issues
• Fix movie detail view lost cursor focus bug when going back from resume dialog

⚙️ New Settings​

• Go straight to episode listing (if only 1 season available)
• Disable community rating for episodes of TV shows
• Movie grid title display options
• Hide subtitles that might transcode

🆕 New Features​

• Added music grid view
• Updated TV library genre view
• Create "What's New" popup that tells users what's changed the first time they run a new version
• Toggle video playback when OK button is pressed
• Create movie grid view and new default setting
• Add resumable filter to movies
• Add played/unplayed status filter to movies & series
• Add artist presentation view & genre view to music library

⭐ Additional Updates​

• Set maximum bitrates values based on Roku guidelines
• Reorganize Roku settings
• Draw homepage continue watching percent complete bar instead of using image API
• Add new questions to GitHub bug template
• Create queue manager and use for music (step 1 for playlist support 🤘)

👥 Contributors​

Jellyfin apps are developed by our great contributors and we couldn't do it without them. Everyone is a volunteer that doesn't get paid by any organizations, so consider donating if you appreciate their work. A big shout-out to all contributors that made this release possible:

• @jimdogx
• @dezchai
• @1hitsong
• @ApexArray
• @sevenrats
• @neilsb
• @DJSweder
• @andibing
• @DaveSenn
• @Jac-Apex-Team
• @Muehli25
• @DesertCookie
• @wippy00
• @blaugrau3001
• @criscrafter

💾 Downloads & Changelog​

The complete list of changes for this release, including all merged pull requests, can be found on GitHub.

Your installed Jellyfin channel should automatically update once available or you can install Jellyfin from the Roku store.

- Anthony

What is Swiftfin?​

If you haven't seen it or tried it yet, Swiftfin is a Jellyfin video player app for Apple devices that has been written from the ground up using modern technologies like Swift UI, and VLCKit. Originally started as a summer project in 2021 by contributor Aiden (@acvigue), development has been carried on by other members of the team, most notably Ethan (@LePips).

It runs on all modern iOS, iPadOS, and tvOS devices, with a current minimum of iOS/iPadOS/tvOS 15.0 or later.

We've decided to release it on the App Store instead of continuing with TestFlight, as the beta program filled up (that's over 9,000 users!), and people still wanted to try it.

Swiftfin and Jellyfin Mobile​

What's important to note is that while Swiftin does run on an iPhone and iPad, it's not currently a full replacement for Jellyfin Mobile (or using the web browser). Jellyfin Mobile still contains access to the full web interface, allowing you to manage the server and use the standard interface. Right now, Swiftfin is also video only, so it does not handle Audiobooks, Photos, or Music. You'll want to keep using Jellyfin Mobile for those, or your other preferred client of choice.

Still in Beta​

Though the app is publicly available now, it's still in beta. There's a lot of things to fix, and many are still underway. We appreciate your patience with this - starting from the ground up has been a long and difficult road for the contributors that work on the app. If you or someone you know has an interest in Swift or Swift UI, we'd welcome you to come by and chat with us on how you can help with development.

Live TV Support on Apple TV!​

Now the one that a lot of people have been waiting for. With Swiftfin on an Apple TV, it's possible to watch your Jellyfin Live TV sources on the big screen. This feature is in Alpha, so it may not reliably work in some cases (or at all). It's something we're working on.

To enable this, do the following:

1. In the top menu bar, go to the "Settings" (⚙️) icon.
2. Scroll down to and choose "Experimental".
3. Scroll down to and enable "Live TV (Alpha)".

After you've enabled it, you can access it through the "Media" section of the App. There should be a new Library named "LiveTV".

Contributors​

Jellyfin apps are developed by our great contributors and we couldn't do it without them. Everyone is a volunteer that doesn't get paid by any organizations, so consider donating if you appreciate their work. A big shout-out to all contributors that made this release possible over the past year and a half:

Jellyfin Team

• @LePips
• @acvigue
• @PangMo5

Other contributors

• @jhays
• @stevebayatt10
• @daullmer

and many others contributing fixes or translations. You can see the whole list on GitHub.

Downloads​

- Niels

Highlights​

While you may not notice them directly, we have made numerous improvements to the underlying technology of the app in this release. These changes make the app more stable and easier to maintain. Some of these changes are being implemented in preparation for future updates, while others involve restructuring or updating older code. The app will crash less frequently as a result of these changes. Some other notable changes in this release include:

New picture viewer​

Jellyfin is a media server that not only supports audio and video, but also pictures. In this release, we have improved the picture viewer by adding on-screen controls. Previously, there were no controls displayed on the screen, which caused confusion for many users. The new controls make it easier to navigate between pictures and start/stop a slideshow.

Player changes​

We have added a few new features to the video player in this release. There is now a "previous" button that allows you to quickly go back to a previous episode or playlist item. Additionally, there is a new "quality" button that allows you to adjust the maximum bitrate during playback. Finally, there is a new option called "audio night mode" which normalizes the sound in a video. This option is turned off by default.

We have also enhanced the subtitle customization feature in this release to give you even more control over the appearance of your subtitles. In addition to being able to adjust the size and enabling a background, you can now also change the stroking width, position, and text color. This allows you to fine-tune the appearance of the subtitles to better match your preferences.

RTL support​

Previously the app could be difficult to understand or display incorrectly. By adding right-to-left (RTL) support, the app now displays UI elements in the correct direction, making it more accessible and user-friendly. The app automatically switches based on the used language.

Contributors​

Jellyfin apps are developed by our great contributors and we couldn't do it without them. Everyone is a volunteer that doesn't get paid by any organizations, so consider donating if you appreciate their work. A big shout-out to all contributors that made this release possible:

Jellyfin Team

• @nielsvanvelzen - Sponsor via GitHub sponsors
• @mueslimak3r - Sponsor via GitHub sponsors

Other contributors

• @teobaranga
• @hadicharara
• @robertduplock
• @sparky3387
• @zkhcohen
• @kevgrig
• @Andy2244
• @sunrisela
• @DenizenB
• @The-Randalorian

Downloads & changelog​

The complete list of changes for this release, including all merged pull requests, can be found on GitHub.

Direct downloads are available for sideloading at repo.jellyfin.org or in the GitHub release assets. You can also join our beta program on Google Play and help test new versions before they're released to the public.