jellyfin/jellyfin.org
1
0
Fork 0
mirror of https://github.com/jellyfin/jellyfin.org.git synced 2026-09-03 04:00:06 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into docs-k8s-deployment

Browse Source
This commit is contained in:
Violet Caulfield
2026-01-29 05:50:24 -06:00
committed by GitHub
parent 6aaf167edc 5c0e23b5ee
commit 896127d37c
69 changed files with 3185 additions and 665 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.github/workflows/__build.yml
+48
View File
@@ -0,0 +1,48 @@
name: Build
on:
workflow_call:
inputs:
ref:
required: true
type: string
upload-pages-artifact:
required: false
type: boolean
default: false
jobs:
build:
name: Build
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
ref: ${{ inputs.ref }}
- uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 20
- name: Configure Pages
if: inputs.upload-pages-artifact
uses: actions/configure-pages@983d7736d9b0ae728b81ab479565c72886d7745b # v5.0.0
- name: Run build
run: |
npm ci --no-audit
npm run build
- name: Upload artifact
uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
with:
name: jellyfin-org__build
path: build
# Manual artifact creation because upload-pages-artifact v4 excludes dotfiles
# https://github.com/actions/upload-pages-artifact/issues/129
- name: Create pages artifact
if: inputs.upload-pages-artifact
run: tar --dereference --hard-dereference --directory build -cvf "$RUNNER_TEMP/artifact.tar" --exclude=.git --exclude=.github .
- name: Upload pages artifact
if: inputs.upload-pages-artifact
uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
with:
name: github-pages
path: ${{ runner.temp }}/artifact.tar
retention-days: 1
.github/workflows/build.yml
+9 -33
View File
@@ -9,44 +9,20 @@ on:
push:
branches: [master]
permissions:
contents: read
pages: write
id-token: write
jobs:
build:
name: Build
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
with:
ref: ${{ github.event.pull_request.head.sha || github.sha }}
- uses: actions/setup-node@2028fbc5c25fe9cf00d9f06a71cc4710d4507903 # v6.0.0
with:
cache: npm
node-version: 20
- name: Configure Pages
if: github.event_name == 'push' && github.repository == 'jellyfin/jellyfin.org'
uses: actions/configure-pages@983d7736d9b0ae728b81ab479565c72886d7745b # v5.0.0
- name: Run build
run: |
npm ci --no-audit
npm run build
- name: Upload artifact
uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
with:
name: jellyfin-org__build
path: build
- name: Upload pages artifact
if: github.event_name == 'push' && github.repository == 'jellyfin/jellyfin.org'
uses: actions/upload-pages-artifact@7b1f4a764d45c48632c6b24a0339c27f5614fb0b # v4.0.0
with:
path: build
uses: ./.github/workflows/__build.yml
permissions: {}
with:
ref: ${{ github.event.pull_request.head.sha || github.sha }}
upload-pages-artifact: ${{ github.event_name == 'push' && github.repository == 'jellyfin/jellyfin.org' }}
deploy:
if: github.event_name == 'push' && github.repository == 'jellyfin/jellyfin.org'
name: Deploy to GitHub Pages
permissions:
pages: write
id-token: write
concurrency: build-deploy-pages
environment:
name: github-pages
@@ -81,7 +57,7 @@ jobs:
comment-tag: CFPages-deployment
mode: recreate
- name: Download workflow artifact
uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
with:
name: jellyfin-org__build
path: build
.github/workflows/lint.yml
+30 -5
View File
@@ -12,10 +12,10 @@ jobs:
steps:
- name: Check out Git repository
uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
- name: Set up Node.js
uses: actions/setup-node@2028fbc5c25fe9cf00d9f06a71cc4710d4507903 # v6.0.0
uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 20
check-latest: true
@@ -27,13 +27,38 @@ jobs:
- name: Run eslint
run: npm run lint
lint:
markdownlint:
name: Lint Markdown
runs-on: ubuntu-latest
steps:
- name: Check out Git repository
uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
- name: Set up problem matcher
uses: xt0rted/markdownlint-problem-matcher@1a5fabfb577370cfdf5af944d418e4be3ea06f27 # v3.0.0
- name: Set up Node.js
uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 20
check-latest: true
cache: npm
- name: Install Node.js dependencies
run: npm ci --no-audit
- name: Run markdownlint
run: npx --package markdownlint-cli markdownlint '**/*.md' --ignore node_modules
run: npm run lint:markdown
cspell:
name: Check spelling
runs-on: ubuntu-latest
steps:
- name: Check out Git repository
uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
- name: Run cspell
uses: streetsidesoftware/cspell-action@d5d910b521ad408f1e7383c24609079f5a88bdca # v8.2.0
with:
config: ./cspell.json
.github/workflows/test.yml
+2 -2
View File
@@ -20,10 +20,10 @@ jobs:
steps:
- name: Check out Git repository
uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
- name: Set up Node.js
uses: actions/setup-node@2028fbc5c25fe9cf00d9f06a71cc4710d4507903 # v6.0.0
uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
with:
node-version: 20
check-latest: true
.markdownlint.yaml
+3
View File
@@ -17,3 +17,6 @@ MD026:
# MD028/no-blanks-blockquote
MD028: false
# MD060/table-column-style
MD060: false
blog/2020/06-21-packaging-updates.md
+6 -4
View File
@@ -1,11 +1,13 @@
---
title: "Packaging Updates for 10.6.0"
description: "Some backend packaging changes are here: what you should know"
title: 'Packaging Updates for 10.6.0'
description: 'Some backend packaging changes are here: what you should know'
authors: joshuaboniface
date: 2020-06-21
slug: packaging-updates
---
<!-- markdownlint-disable MD001 -->
Packaging and building binaries for releases and testing has long been an issue for us. From fighting with duct-tape-and-coat-hanger scripts, to testing breaking changes, to massaging official releases, how we were doing things for the last year-and-a-half needed some improvements.
Luckily, today they are all completed. In this post, I'll detail the changes as well as what the entail for our users.
@@ -24,7 +26,7 @@ The main difference is the naming - the `jellyfin-web` repository binaries are n
### Azure Pipelines builds
Our previous build infrastructure consisted of a veritable spaghetti factory of Bash, Python, and Docker scripts that were executed on our build server, a DigitalOcean droplet. For the most part, it worked, but the process was very fragile, opaque (I'm not even sure *I* understand how it all worked all the time, and I wrote it all!), and resource-intensive.
Our previous build infrastructure consisted of a veritable spaghetti factory of Bash, Python, and Docker scripts that were executed on our build server, a DigitalOcean droplet. For the most part, it worked, but the process was very fragile, opaque (I'm not even sure _I_ understand how it all worked all the time, and I wrote it all!), and resource-intensive.
As we've moved more and more functions to Azure for testing, verification, linting, etc. in the various repositories, it became obvious that Azure Pipelines had a lot of flexibility, and would be able to perform nearly all of our build steps for us. This eliminated at least 2/3 of the build server, and gives us another cool option - unstable builds, which I'll touch on shortly.
@@ -48,7 +50,7 @@ For the remaining platforms, including the archive packages for Windows, MacOS,
One of the cool things that this new setup enables is "unstable" builds. For quite a while now, we've been providing (when not broken) "nightly" builds, which as their name implies are build every night if there were merged PRs from the previous day. However, these had a number of drawbacks. First, they broke a lot; second, on a busy day it would be possible for there to be up to a dozen separate PRs that made up the nightly changeset; third, they could often be totally messed up in terms of contents, for instance if the unsplit build grabbed the wrong version of Web.
The new split builds, Azure builds, and metapackages/metaimages instead let us do something far superior: build "unstable" releases for *every merged PR*. We don't have to worry about resource usage (Azure provides this), disk space, or other aspects of the build process. We can know immediately if something breaks. And most importantly, it lets anyone test our master branch in a very clear way, knowing *exactly* what version of the repository you are using and what the last merged PR was if something goes wrong.
The new split builds, Azure builds, and metapackages/metaimages instead let us do something far superior: build "unstable" releases for _every merged PR_. We don't have to worry about resource usage (Azure provides this), disk space, or other aspects of the build process. We can know immediately if something breaks. And most importantly, it lets anyone test our master branch in a very clear way, knowing _exactly_ what version of the repository you are using and what the last merged PR was if something goes wrong.
Unstable builds are versioned based on the Azure build ID, which is in the format "[date].[id]", for example "20200620.12" for the 12th build on June 20th 2020. Thus this version string will tell you exactly which Azure build generated the binary, and thus which PR in which repository triggered it. For those binaries with changelogs (`.deb` and `.rpm` packages only for now), the changelog data includes the PR ID explicitly as well.
blog/2020/10-05-android-next.md
+2
View File
@@ -6,6 +6,8 @@ date: 2020-10-05
slug: android-next
---
<!-- markdownlint-disable MD001 -->
This will be a net benefit for users and developers alike!
<!-- truncate -->
blog/2026/01-06-state-of-the-fin/index.mdx
+150
View File
@@ -0,0 +1,150 @@
---
title: State of the Fin 2026-01-06
authors:
- thornbill
slug: state-of-the-fin-2026-01-06
tags: [state-of-the-fin]
---
Happy New Year and welcome to the State of the Fin!
This new blog series will regularly basis highlight the ongoing development of Jellyfin and our official clients.
We aim to keep our community informed and engaged, so feel free to share your feedback or thoughts on our progress!
{/* truncate */}
## Project Updates
### Jellyfin Turns 7
December marked Jellyfin's 7th anniversary!
A lot has changed in 7 years, but we remain steadfast in our commitment to Open Source and to being the best personal media server out there.
Special thanks to our developers, testers, moderators, and supporters for your invaluable contributions!
Here's to many more years of collaboration and streaming!
### Versioning
We received a substantial amount of feedback regarding our versioning scheme following the 10.11 release, particularly concerning the stability of what are perceived as 'minor' version updates.
This has prompted internal discussions about potentially revising our versioning scheme in the next major release.
While nothing has been finalized yet, we are considering 'dropping' the major version 10, which would make the next release 12.0.
Stay tuned for further updates as we navigate this feedback!
## Development Updates
### 10.11 Release Status
Jellyfin 10.11 introduced a major [EF Core refactor](https://jellyfin.org/posts/efcore-refactoring-incoming/), consolidating the legacy `library.db` into a single unified `jellyfin.db`.
Following more than six months of development and an additional six months of release candidate testing, version [10.11.0](https://jellyfin.org/posts/jellyfin-release-10.11.0/) was released last year.
This extended testing period allowed us to mitigate most [refactoring](https://github.com/jellyfin/jellyfin/issues/13047) and [RC](https://github.com/jellyfin/jellyfin/issues/14350)-related issues prior to release.
Even with this level of testing, issues were expected given the scale of the database change and the limited number of users reporting bugs.
These issues are currently being tracked on GitHub across three categories:
1. [General bugs](https://github.com/jellyfin/jellyfin/issues/15045)
2. [Performance bugs](https://github.com/jellyfin/jellyfin/issues/15685)
3. [Migration and database bugs](https://github.com/jellyfin/jellyfin/issues/15686)
We have been moving quickly to address these issues, delivering four additional point releases with over [100 changes](https://github.com/jellyfin/jellyfin/compare/v10.11.0...v10.11.5) since the initial 10.11.0 release.
To date, most point releases have focused on resolving general and migration-related issues.
The remaining migration issues are largely isolated, one-off cases and are unlikely to be resolved.
Most general issues have already been fixed, and the next bug-fix release is expected to include additional fixes for music metadata display issues and for watched status not being preserved when media is replaced or renamed.
We are continuing to investigate ways to mitigate performance issues caused by client-side enumeration and filtering of large datasets.
### Jellyfin Web vNext (aka 10.12 / 12.0)
- **Default 'Experimental' Layout**: The 'Experimental' layout is now enabled by default for all non-TV devices, introducing a new navigation layout and updated UI components.
- **Theming Support Overhaul**: We are improving theming support by enabling easier runtime customization of default themes through CSS variables and simplifying the process for creating new bundled themes.
- **Community Acknowledgment**: Huge thanks to those reviewing, testing, and providing feedback on web pull requests. Your contributions are immensely helpful, as the review burden largely falls on me alone!
\- [thornbill](https://github.com/thornbill)
## Client Corner
### Jellyfin Desktop
We're rebranding the desktop application from Jellyfin Media Player to Jellyfin Desktop.
The most noteworthy change is the migration from Qt 5 to Qt 6.
This seems to have improved overall performance, though we're still working out issues regarding memory leaks due to the migration.
Apart from the Qt migration, other noteworthy updates.
- Saved servers and settings will not be migrated from Jellyfin Media Player.
- We've laid the foundation for switching servers with the addition of profiles CLI options. The long-term goal is to have a UI for this as well, but the timeline is TBD.
- A slew of bug fixes are included.
The release is currently available on [Flathub](https://github.com/jellyfin/jellyfin-desktop) and in the [Arch Linux AUR](https://aur.archlinux.org/packages/jellyfin-desktop).
Stable builds for Windows and macOS builds are not currently available.
Other Linux distributions will likely be added, though we recommend using Flathub for the time being.
We are not currently supporting Ubuntu 24.04 LTS due to it being stuck on the older Qt 6.4 series, while our new dependency, mpvqt, requires at least Qt 6.5.
\- [Andrew Rabert](https://github.com/andrewrabert)
### Jellyfin for Android TV
Two versions of the Android TV app have been released: [v0.19.5](https://github.com/jellyfin/jellyfin-androidtv/releases/tag/v0.19.5) and [v0.19.6](https://github.com/jellyfin/jellyfin-androidtv/releases/tag/v0.19.6)!
These updates contain various improvements to music transcoding. The app now properly displays durations again and allows for seeking when music is transcoding. These changes also solve the issue of lyrics not scrolling in certain cases.
For video playback, we have improved the stability of Live TV and now support direct play for the VC-1 and AV1 codecs (if your device supports them). The AV1 support was already available on Android 10 and newer but now works on older Fire TV devices as well.
\- [Niels van Velzen](https://github.com/nielsvanvelzen)
### Jellyfin for Xbox
The last two updates brought the long awaited full gamepad support and fixes for 4K and HDR.
- **Gamepad support**: Gamepad navigation is now the default navigation type for the Jellyfin for Xbox app and requires a server version of 10.11 or higher to work. However as we cannot switch the input mode type while the app is running, the Jellyfin for Xbox app can no longer connect to older versions than 10.11. As this is a fundamental change in how the app works, there are still a few hiccups like the app not loading correctly and users reporting that the gamepad does not work at all. In those instances we recommend uninstalling and reinstalling the app.
- **Web UI TV mode**: For versions of Jellyfin earlier than 10.11.5 the web UI still runs in the desktop mode, which might look a bit odd. However, with Jellyfin 10.11.5, we have fixed a bug that now correctly sets the web UI to TV mode, so the UI should work a lot better.
- **4K and HDR**: For the last few versions, we have been working on enabling 4K and HDR for the app. This is done by integrating with the web UI and switching the HDMI modes. Sadly, this also comes at the cost of not being allowed to run in the background. To enable 4K support, we had to use a feature flag that allocates more video memory to the Jellyfin for Xbox app, making it incompatible with running in the background.
- **General Improvements**: Alongside the shiny new headline features, we have also been working on the code in general, adding small improvements and cleaning up a lot of code. The latest versions added log files and their upload to the Jellyfin server, tighter integrations with the web UI, a settings view that can be expanded for future features, version compatibility checking, a better server connection experience, and more.
- **Future**: When I took over the for the previous maintainer almost a year ago, I made a rough plan for the general development of the app. I always planned on keeping the app as a web wrapper because while the app is certainly more popular than most think, it does not have enough support in development to be a full UWP app. Nevertheless, there are a few features left on my to-do list:
- Localization to other languages
- Server discovery
- Desktop support
- Better decoder support
- Subtitle storage on-device
\- [JPVenson](https://github.com/JPVenson)
### Jellyfin for Roku
[3.0.15](https://github.com/jellyfin/jellyfin-roku/releases/tag/3.0.15) was released on 2025-12-18 and is our last release before Roku's year-end publishing blackout. It fixes a bug with HDHomeRun Tuners.
\- [1hitsong](https://github.com/1hitsong)
### Swiftfin
#### Swiftfin 1.4 is out now!
This is a large release with a lot of changes under the hood. Our three highlight changes are:
1. [Navigation & Routing Overhaul](https://github.com/jellyfin/Swiftfin/pull/1602)
2. [Jellyfin 10.11 Support](https://github.com/jellyfin/Swiftfin/pull/1772)
3. [Revamped Media Player Manager](https://github.com/jellyfin/Swiftfin/pull/1581)
#### Swiftfin Roadmap
A [roadmap / project board](https://github.com/orgs/jellyfin/projects/68) for Swiftfin is now available!
Follow [this discussion](https://github.com/jellyfin/Swiftfin/discussions/1294) for information about the next tvOS release.
To help organize Issues & PRs, Swiftfin now has milestones to help users identify which changes will be included in each release:
- [Version 1.5](https://github.com/jellyfin/Swiftfin/milestone/2)
- Contains issues that should be resolved in version 1.5 of Swiftfin iOS.
- [tvOS Resync](https://github.com/jellyfin/Swiftfin/milestone/3)
- Contains tvOS-specific issues that will be resolved as part of our next [tvOS Release](https://github.com/jellyfin/Swiftfin/discussions/1294).
- _Issues that impact tvOS but are part of 1.4 or 1.5 will end up in the version milestone instead of this one. Once tvOS is released, it should mirror our existing 1.X structure and iOS._
A more detailed post about these changes can be found [on GitHub](https://github.com/jellyfin/Swiftfin/discussions/1832)!
\- [JPKribs](https://github.com/JPKribs)
### Other TV Platforms
- The Tizen app was submitted for review, but unfortunately [failed testing](https://github.com/jellyfin/jellyfin-tizen/issues/222#issuecomment-3621581689). Additional work is needed to replicate the reported issues and correct them.
- Support for multiple **new** platforms is currently underway, and we will provide updates as progress is made.
Wishing you all happy streaming in 2026 and beyond!
We look forward to another year filled with exciting updates and features for Jellyfin.
\- thornbill and the Jellyfin Team
cspell.json
+28
View File
@@ -0,0 +1,28 @@
{
"$schema": "https://raw.githubusercontent.com/streetsidesoftware/cspell/main/cspell.schema.json",
"version": "0.2",
"language": "en, en-US, en-GB",
"allowCompoundWords": true,
"files": ["**/*.md", "**/*.mdx", "**/*.tsx"],
"dictionaryDefinitions": [
{
"name": "project-words",
"path": "./project-words.txt",
"addWords": true
}
],
"dictionaries": ["project-words"],
"ignorePaths": [
"node_modules",
"/project-words.txt",
"/src/components/common/PlatformIcon.tsx",
"/blog/2019/*",
"/blog/2020/*",
"/blog/2021/*",
"/blog/2022/*",
"/blog/2023/*",
"/blog/2024/*",
"/blog/2025/*"
]
}
docs/general/administration/backup-and-restore.md
+23 -23
View File
@@ -24,7 +24,7 @@ There are two ways of backing up your Jellyfin data. One is with its built-in Ba
Jellyfin's built-in backup system is able to create a backup while your system is online and running, as opposed to the manual process that **requires** you to stop Jellyfin beforehand.
However in 10.11 we still recommend performing the backup process during a time of low activity and while no scan is currently active.
### Create a Backup
### Create a Built-in Backup
To take a new Backup, enter the Jellyfin Dashboard, open the `Backups` tab and click on the `Create Backup` button. The popup will now ask you to select what data you want to backup.
@@ -33,32 +33,32 @@ To take a new Backup, enter the Jellyfin Dashboard, open the `Backups` tab and c
- Subtitles. All extracted subtitles including downloaded ones.
- Trickplay. All trickplay data that is stored not alongside media.
The Backup system will check for at least 4GB of free space in the backup folder where backups a written to. However this can easily not be enough if you also backup Subtitles and Trickplay so ensure you have enough free space there.
The Backup folder is located within your Jellyfin data directory which is located in:
The Backup system will check for at least 5GB of free space in the backup folder where backups a written to. However this can easily not be enough if you also backup Subtitles and Trickplay so ensure you have enough free space there.
The Backup folder is located within your Jellyfin data directory, by default:
- Official Docker: Wherever your `/data` volume are sourced from; this is set in your `docker-compose.yml` or in your `-v` options to `docker run`.
- LinuxServer.io Docker: Data are wherever your `/config` volume is sourced from; this is set in your `docker-compose.yml` or in your `-v` options to `docker run`.
- Debian/Ubuntu packages: `/var/lib/jellyfin/backups`.
- RPMFusion Fedora/CentOS packages: Data is in `/var/lib/jellyfin/backups`.
- Official Docker: `<volume path>/config/data/backups` where `<volume path>` is where your `/config` volume is sourced from; this is set in your `docker-compose.yml` or in your `-v` options to `docker run`.
- LinuxServer.io Docker: `<volume path>/config/data/data/backups` where `<volume path>` is where your `/config` volume is sourced from; this is set in your `docker-compose.yml` or in your `-v` options to `docker run`.
- Debian/Ubuntu packages: `/var/lib/jellyfin/data/backups`.
- RPMFusion Fedora/CentOS packages: `/var/lib/jellyfin/data/backups`.
- Windows User Install: `%LOCALAPPDATA%\Jellyfin\data\backups` (`C:\Users\<Username>\AppData\Local\Jellyfin\data\backups`)
- Windows Service Install: `%PROGRAMDATA%\Jellyfin\Server\data\backups` (`C:\ProgramData\Jellyfin\Server\data\backups`)
- MacOS Installer (.dmg): Data is stored in one of these paths; back up whichever one(s) exist: `~/.config/jellyfin/backups`, `~/.local/share/jellyfin/backups`, `~/Library/Application Support/Jellyfin/backups`:
- Portable Installs:
- Linux: Data is stored in `~/.local/share/jellyfin/backups`.
- Windows: Data and config is in `C:\Users\<Username>\AppData\Local\Jellyfin\backups`, using `%LOCALAPPDATA%`.
- MacOS: Data is stored in these paths; back up whichever one(s) exist: `~/.config/jellyfin/backups`, `~/.local/share/jellyfin/backups`, `~/Library/Application Support/Jellyfin/backups`.
- MacOS Installer (.dmg): Data is stored in one of these paths; back up whichever one(s) exist: `~/.config/jellyfin/data/backups`, `~/.local/share/jellyfin/data/backups`, `~/Library/Application Support/Jellyfin/data/backups`:
- Portable Installs:
- Linux: Data is stored in `~/.local/share/jellyfin/data/backups`.
- Windows: Data and config is in `C:\Users\<Username>\AppData\Local\jellyfin\data\backups`, using `%LOCALAPPDATA%`.
- MacOS: Data is stored in these paths; back up whichever one(s) exist: `~/.config/jellyfin/data/backups`, `~/.local/share/jellyfin/data/backups`, `~/Library/Application Support/Jellyfin/data/backups`.
After clicking on the `Create` button all data will be written into a new zip archive.
### Restore from Backup
### Restore from a Built-in Backup
To restore from a Backup you can either use the webUI by navigating to the same view as for the step above and clicking on the restore button in the list of backups, or you can start jellyfin with the `--restore-archive PATH_TO_BACKUP_ZIP` argument. Note that when you start a restore from the webUI, you server will immediately restart for this process to take place and will be unavailable for that time.
To restore from a Backup you can either use the webUI by navigating to the same view as for the step above and clicking on the restore button in the list of backups, or you can start jellyfin with the `--restore-archive PATH_TO_BACKUP_ZIP` argument. Note that when you start a restore from the webUI, your server will immediately restart for this process to take place and will be unavailable for that time.
## Manual Backup
Taking a manual Backup essentially involves you copying all the data jellyfin requires on your own.
### Taking a Backup
### Create a Manual Backup
1. Stop the running Jellyfin server. This is extremely important, as otherwise the database will be locked and might not be recoverable when restoring. Note that this will interrupt any playback.
- Any platform: Within the Jellyfin Dashboard, click "Shutdown". This should cleanly stop the process on all platforms, but if not, try one of the following.
@@ -71,15 +71,15 @@ Taking a manual Backup essentially involves you copying all the data jellyfin re
2. Copy your data and configuration directories to a destination of your choice. What you name the copies is up to you; personally, I like to use dated and versioned directory names e.g. `jellyfin.2024-05-01_10.8.13`. Where these files are also depends on the platform; generally these follow the [XDG Directory Specification](https://specifications.freedesktop.org/basedir-spec/latest/) for platforms that support it. For more information see [the configuration documentation](/docs/general/administration/configuration/#server-paths).
**NOTE**: These are default locations; if you've changed your data or config paths, use those instead.
- Official Docker: Wherever your `/data` and `/config` volumes are sourced from; this is set in your `docker-compose.yml` or in your `-v` options to `docker run`.
- LinuxServer.io Docker: Data and config are wherever your `/config` volume is sourced from; this is set in your `docker-compose.yml` or in your `-v` options to `docker run`.
- Debian/Ubuntu packages: Data is in `/var/lib/jellyfin` and config is in `/etc/jellyfin`; these are defined in `/etc/default/jellyfin`.
- RPMFusion Fedora/CentOS packages: Data is in `/var/lib/jellyfin` and config is in `/etc/jellyfin`; these are defined in `/etc/sysconfig/jellyfin`.
- Windows Tray/Installer (.exe): Data and config is in `%PROGRAMDATA%\Jellyfin\Server` (`C:\ProgramData\Jellyfin\Server`) or `%LOCALAPPDATA%\Jellyfin` (`C:\Users\<Username>\AppData\Local\Jellyfin`).
- Official Docker: The data directory is wherever your `/config` volume is sourced from; this is set in your `docker-compose.yml` or in your `-v` options to `docker run`. This directory contains the config directory as well.
- LinuxServer.io Docker: The config directory is wherever your `/config` volume is sourced from; this is set in your `docker-compose.yml` or in your `-v` options to `docker run`. This directory contains the data directory as well.
- Debian/Ubuntu packages: The data directory is `/var/lib/jellyfin` and the config directory is `/etc/jellyfin`; these are defined in `/etc/default/jellyfin`.
- RPMFusion Fedora/CentOS packages: The data directory is `/var/lib/jellyfin` and the config directory is `/etc/jellyfin`; these are defined in `/etc/sysconfig/jellyfin`.
- Windows Tray/Installer (.exe): The data directory is `%PROGRAMDATA%\Jellyfin\Server` (`C:\ProgramData\Jellyfin\Server`) or `%LOCALAPPDATA%\Jellyfin` (`C:\Users\<Username>\AppData\Local\Jellyfin`). This directory contains the config directory as well.
- MacOS Installer (.dmg): Data is stored in one of these paths; back up whichever one(s) exist: `~/.config/jellyfin/`, `~/.local/share/jellyfin/`, `~/Library/Application Support/Jellyfin/`.
- Portable Installs:
- Linux: Data is stored in `~/.local/share/jellyfin` and config in `~/.local/share/jellyfin`.
- Windows: Data and config is in `C:\Users\<Username>\AppData\Local\Jellyfin`, using `%LOCALAPPDATA%`.
- Linux: The data and config directories are both `~/.local/share/jellyfin`.
- Windows: The data directory is `%LOCALAPPDATA%\jellyfin` (`C:\Users\<Username>\AppData\Local\jellyfin`). This directory contains the config directory as well.
- MacOS: Data is stored in these paths; back up whichever one(s) exist: `~/.config/jellyfin/`, `~/.local/share/jellyfin/`, `~/Library/Application Support/Jellyfin/`.
As an example, on Debian, you can do this with these commands to make a copy of both directories into a single target directory:
@@ -94,7 +94,7 @@ Taking a manual Backup essentially involves you copying all the data jellyfin re
3. Start up Jellyfin again, either after upgrading or on the current version. You now have a safe copy of your data in the path chosen in step 2.
## Restoring a Backup
### Restore from a Manual Backup
This process assumes you followed the steps above to take the backup.
docs/general/administration/configuration.md
+1 -1
View File
@@ -19,7 +19,7 @@ Documentation for the available command line options can be obtained by adding t
## Server Paths
The file paths used by the server are determined according to the rules outlined below. In general, the [XDG specification](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html) is followed by default for non-Windows systems.
The file paths used by the server are determined according to the rules outlined below. In general, the [XDG specification](https://specifications.freedesktop.org/basedir-spec/latest/) is followed by default for non-Windows systems.
### Data Directory
docs/general/administration/hardware-selection.md
+60 -57
View File
@@ -5,11 +5,11 @@ title: Hardware Selection
# Selecting Appropriate Hardware
This page covers what you need to know in order to select appropriate hardware for a Jellyfin server and take full advantage of its features (e. g. hardware acceleration).
The following is intended to help you choose appropriate hardware for a Jellyfin server and take full advantage of its features (e.g. hardware acceleration).
## TL;DR
## Simple Guide
Below is a list of recommended specs to run Jellyfin. Even though Jellyfin will work on even lower end hardware, the following specs are recommended for a good experience.
Below is a list of recommended specs to run Jellyfin. Whilst Jellyfin can work on relatively low-end hardware, the following specs are recommended for a good experience.
### Shared Items
@@ -17,48 +17,48 @@ Some component recommendations do not change regardless of the hardware configur
- Storage: 100GB SSD for your OS, Jellyfin files and transcoding cache.<sup>1</sup> Consider adding more on Windows 11, or if you have many large media files that need transcoding.
- Networking: Gigabit Ethernet Adapter or faster, WiFi or Powerline not recommended.
- Internet Connection: At least 20mbps upload bandwidth for remote access.<sup>2</sup>
- Internet Connection: At least 20 Mbps upload bandwidth for remote access.<sup>2</sup>
<sup>1</sup>Your largest media file times the max number of concurrent streams all your users will consume can be used as a rule of thumb for the transcoding file size. <br />
<sup>2</sup>If you have less than 100mbps of total upload bandwidth, a bandwidth limit of 70% of your upload speed for Jellyfin is recommended to avoid affecting normal internet usage. This option can be found in the dashboard.
<sup>2</sup>If you have less than 100 Mbps of total upload bandwidth, a bandwidth limit of 70% of your upload speed for Jellyfin is recommended to avoid affecting internet usage outside of Jellyfin. This option can be found in the Jellyfin Server `Dashboard`.
### Hardware Encoder Quality
Different vendors have different hardware encoder implementations and produce different results. Usually, newer generations within the same vendor will provide better results. The following is a quick comparison on the quality between vendors on modern products.
Apple ≥ Intel ≥ Nvidia >>> AMD<sup>\*</sup>
Apple ≥ Intel ≥ NVIDIA >>> AMD<sup>\*</sup>
<sup>\*</sup> This only represents the default Jellyfin settings. The quality may be different depending on your exact configuration.
### Server with Integrated Graphics
If you are not planning to use a dedicated graphics card, the following specs are recommended:
If you do not intend to use a dedicated graphics card, the following specs are recommended:
- CPU: Intel Core i5-11400, Intel Pentium Gold G7400, Intel N100, Apple M series or newer (excluding Intel J/M/N/Y series up to 11th gen)
- RAM: 8GB System RAM (Consider adding more on Windows 11)
- Graphics: Intel UHD 710, Apple M series or newer
AMD is **NOT** recommended if you plan to use integrated graphics for Jellyfin.
AMD is **NOT** recommended if you intend to use integrated graphics for Jellyfin.
:::caution
Intel 7-10th gen CPUs have been removed from this list, since the toolkit for these generations has been deprecated by Intel. If you own 7-10th gen CPUs with integrated graphics, please continue to use them for Jellyfin, as they are still perfectly capable of performing the task. If you are making a purchase decision, please consider something else instead.
Intel 7-10th gen CPUs have been removed from this list, since the toolkit for these generations has been deprecated by Intel. If you own a 7-10th gen CPU with integrated graphics, please continue to use them for Jellyfin, as they are still perfectly capable of performing the task. If you are making a purchase decision, you may wish to consider alternatives.
:::
### Server with Dedicated Graphics
If you are planning to use a dedicated graphics card (including upgrading an old system with a dedicated GPU), the following specs are recommended:
If you intend to use a dedicated graphics card (including upgrading an old system with a dedicated GPU), the following specs are recommended:
- CPU: Intel Core i5-2300， AMD FX-8100 or better (Geekbench 6 Multicore 1500 or better), CPU Vendor / Performance will **NOT** affect hardware encode speed or quality
- RAM: 8GB (4GB should be enough for a server running Linux without a GUI)
- Graphics: Intel Arc A series or newer, Nvidia GTX16/RTX20 series or newer (Excluding GTX1650), **AMD is NOT recommended**.
- CPU: Intel Core i5-2300，AMD FX-8100 or better (Geekbench 6 Multicore 1500 or better), CPU Vendor / Performance will **NOT** affect hardware encode speed or quality
- RAM: 8GB. (4GB may be sufficient for a Linux server without its own GUI.)
- Graphics: Intel Arc A series or newer, NVIDIA GTX16/RTX20 series or newer (Excluding GTX1650), **AMD is NOT recommended**.
Intel Drivers are much easier to install on Linux, with many distributions including them by default. If you do not need CUDA for other applications, it is highly recommended that you stick with Intel Graphics on Linux.
:::caution
Intel ARC B series cards require ReBar to be enabled. This means you must use it on a platform with Intel 10th gen, AMD Ryzen 3000 series or newer.
Intel ARC B-series cards require ReBar to be enabled. This means you must use it on a platform with Intel 10th gen, AMD Ryzen 3000 series or newer. Intel ARC A-series cards do not require ReBar to function, however, ReBar should be enabled for optimal performance.
:::
@@ -70,21 +70,21 @@ where a Ryzen 9 5950X cannot handle even a single video stream. Please read [the
### Low Power Servers
For users with expensive power or running servers on battery power:
For users with expensive electricity, or running battery-powered servers:
- Intel 12th gen or above N series platforms
- Apple M Series mac mini
- Apple M Series Mac mini
- Rockchip RK3588 / RK3588S SBC (**Advanced Users Only**)
### Potentially Problematic Hardware
These hardware platforms might lead to a poor Jellyfin experience. Please be careful to avoid them when shopping for hardware.
- Intel "Atom" CPUs: Intel J/M/N/Y series low power CPUs up to 11th gen use a different architecture than higher end parts, leading to subpar performance despite what their names might suggest. Please be careful about these parts when shopping for a system to run Jellyfin.
- Prebuilt NAS devices: The software environment on most Prebuilt NAS devices often causes 3rd party software to be hard to install and not work properly. They also often have low end processors that are too slow for a good Jellyfin experience (Intel Atom, Realtek ARM CPUs etc.).
- Most Single Board Computers (SBC): Most SBCs (Including Raspberry Pis and **especially the Pi 5**) are too slow to provide a good Jellyfin experience since they often lack proper support for hardware acceleration. If You really want to run Jellyfin on an SBC, please look at models based on the following platforms: Rockchip RK3588 / RK3588S, Intel Core, Intel 12th gen N series
- Intel "Atom" CPUs: Intel J/M/N/Y series low power CPUs up to 11th gen use a different architecture than higher end parts, leading to subpar performance despite what their names might suggest. It is advised to avoid using these parts in a Jellyfin Server.
- Prebuilt NAS Appliances: The software environment on most prebuilt NAS appliances often makes third-party software more challenging to install, sometimes even preventing it from working properly despite a successful installation. They may have low-end processors that are too slow for an acceptable Jellyfin experience. (e.g. Intel Atom, Realtek ARM CPUs, etc.).
- Most Single Board Computers (SBC): Most SBCs (including the Raspberry Pi, **especially the Raspberry Pi 5**) are too slow to provide an acceptable Jellyfin experience as they often lack proper support for hardware acceleration. If you really want to run Jellyfin on an SBC, you may wish to consider models based on the following platforms: Rockchip RK3588 / RK3588S, Intel Core, Intel 12th gen N series
- AMD Graphics: AMD Graphics have poor encoder quality and poor driver support. **This applies even on Linux**.
- Low end GPUs: Certain low end GPUs (eg. GT1030, RX6400) don't have hardware encoding available. These models can't be used for Jellyfin hardware acceleration.
- Low-end GPUs: Certain low-end GPUs (e.g. GT1030, RX6400) are not capable of hardware encoding. These models cannot be used for hardware acceleration for a Jellyfin Server.
## Detailed Guide
@@ -95,94 +95,95 @@ The CPU will be responsible for many tasks, notably:
- Transcoding Audio
- Decoding video in unsupported codecs
Audio codecs are very lightweight and most CPUs should be able to handle them without issues (Ryzen 5950X FLAC -> AAC transcoding runs at ~110x real time). Please note that they will only use one core.
Whilst most audio codecs will only utilize a single core, they are very lightweight and most CPUs should be able to handle them without issues. (e.g. a Ryzen 5950X transcoding `FLAC -> AAC` runs at ~110x real-time.)
Video in unsupported codecs are usually older formats that are easier to decode. Assuming hardware acceleration is properly configured, any modern CPU with 4 threads should be able to handle the workload.
However, newer codecs can also require software decoding if there are no available hardware decoders. HEVC, VP9 and AV1 can be **VERY** demanding even on modern CPUs if hardware acceleration isn't available. This is why a hardware platform capable of HEVC 10bit hardware decoding is strongly recommended.
However, newer codecs can also require software decoding if there are no available hardware decoders. HEVC, VP9 and AV1 can be **VERY** demanding even on modern CPUs if hardware acceleration is not available on a Jellyfin Server. This is why a hardware platform capable of HEVC 10bit hardware decoding is strongly recommended.
In our custom `jellyfin-ffmpeg` fork, the dav1d decoder is enabled, leading to faster software decoding compared to HEVC or VP9. However, it will still use significantly more resources compared to software decoding H.264 or older codecs. Since we have a more efficient AV1 software decoder, and AV1 media isn't common yet, you shouldn't worry about AV1 when shopping for hardware.
In our custom `jellyfin-ffmpeg` fork, the dav1d decoder is enabled, leading to faster software decoding compared to HEVC or VP9. However, it will still use significantly more resources compared to software decoding H.264 and older codecs. Since we have a more efficient AV1 software decoder, and AV1 media isn't common yet, you shouldn't worry about AV1 when choosing components for your Jellyfin Server.
#### Integrated Graphics
Integrated graphics can be useful for transcoding video. Please refer to [the GPU section](/docs/general/administration/hardware-selection#graphics-cards-gpus) for a guide.
Integrated graphics can be useful for transcoding video. For more information, please refer to [the GPU section](/docs/general/administration/hardware-selection#graphics-cards-gpus).
#### Resizable BAR
[Resizable Bar (ReBAR)](https://www.intel.com/content/www/us/en/support/articles/000090831/graphics.html) is a PCI Express feature that optimizes access to PCIe devices. This feature requires support from both the platform and the device. Intel 10th gen or above and AMD Ryzen 3000 Series or above have support for this feature.
[Resizable Bar (ReBAR)](https://www.intel.com/content/www/us/en/support/articles/000090831/graphics.html) is a PCI Express feature that optimizes access to PCIe devices. This feature requires support from both the platform and the device. Support for this feature is respectively available beginning with Intel 10th gen and AMD Ryzen 3000 Series.
In BIOS settings of motherboards, it may also be called `Smart Access Memory` or `Clever Access Memory`
When using Intel ARC Graphics, Resizable BAR is recommended. Disabling it will result in a 10% reduction in transcoding performance. However, given how fast the media engine on Intel ARC is, this will not be a problem for the vast majority of users.
When using Intel ARC Graphics, Resizable BAR is recommended. Disabling it will result in a 10% reduction in transcoding performance. However, given how fast the media engine on Intel ARC is, this should not be a problem for the average deployment.
#### Software HDR to SDR Tone-mapping
If there is no GPU available, the CPU can also be used to tone-map HDR content to SDR. **This can be very demanding on
If there is no GPU available on a Jellyfin Server, the CPU can also be used to tone-map HDR content to SDR. **This can be very demanding on
the CPU, therefore a GPU is ALWAYS recommended.** When using software tone-mapping, a software encoder will always be
used. Tone-mapping 4K 60fps Dolby Vision content to 4K 60fps H264 SDR requires a Ryzen 9 5950X for faster than real time
transcoding. If you would like to output in H265 or AV1, you may end up in situations where no current desktop CPUs have
enough performance.
used. Tone-mapping 4K 60fps Dolby Vision content to 4K 60fps H264 SDR requires a Ryzen 9 5950X for faster than real-time
transcoding. You may find current desktop CPUs do not offer adequate performance if you seek to provide streams in H.265 or AV1.
### System Memory (RAM)
As a general rule of thumb, at least 8GB is recommended for most configurations. For a Linux server running without a GUI, 4GB should be enough.
As a general recommendation, at least 8GB is recommended for the average deployment. For a Linux server running without a GUI, 4GB may be enough.
It is recommended to add more memory on Windows 11 due to the OS being heavier.
It is recommended to add more memory when using Windows 11 due to the OS being heavier.
### Graphics Cards (GPUs)
With modern systems, the media engines are usually located on the GPUs. Therefore, the available hardware acceleration options are determined by the choice of GPU.
Encoder Quality: Apple ≥ Intel ≥ Nvidia >>> AMD<sup>\*</sup>
Encoder Quality: Apple ≥ Intel ≥ NVIDIA >>> AMD<sup>\*</sup>
<sup>\*</sup> This only represents the default Jellyfin settings. The quality may be different depending on your exact configuration.
Intel is always recommended on non-apple hardware for the following reasons:
Intel is always recommended on non-Apple hardware for the following reasons:
- Intel provides a good quality encoder, slightly better than Nvidia and significantly better than AMD.
- Intel drivers and the compute environment is much easier to setup than both Nvidia and AMD
- Intel provides a good quality encoder, slightly better than NVIDIA and significantly better than AMD.
- Intel drivers and the compute environment is much easier to setup than both NVIDIA and AMD
AMD is not recommended because of poor quality H.264 and H.265(HEVC) output, as well as being hard to setup the compute environment. While AMD has significantly improved AV1 encoder quality, you are still more likely to transcode to H.264 or H.265 than to AV1 due to compatibility.
AMD is not recommended due to poor quality H.264 and H.265 (HEVC) output, as well as being hard to set up the compute environment. While AMD has significantly improved AV1 encoder quality, you are still more likely to transcode to H.264 or H.265 than to AV1 due to the hardware capabilities of the average Jellyfin client.
A list of common codecs can be found in the [codec support documentation](/docs/general/clients/codec-support/).
The following is a list of video codecs Jellyfin supports transcoding to:
- H.264 (Most common transcode target)
- H.265 (Limited support by clients)
- AV1 (New in 10.9, supported by most modern browsers)
- H.264 (most common transcode target)
- H.265 (Jellyfin clients have limited support)
- AV1 (new in Jellyfin v10.9, supported by most modern browsers)
For decoding support, the more codecs the better. However, there are only a few codecs that media is commonly available in. The most important one to look for is HEVC 10bit decoding support, as it can be very demanding on the CPU to decode.
A greater number of codecs is desirable for decoding support. With that said, media is generally available in a small number of codecs. The most important one to look for is HEVC 10bit decoding support, as decoding can be CPU intensive.
#### Intel Graphics
Please refer to [this table](https://en.wikipedia.org/wiki/Intel_Quick_Sync_Video#Hardware_decoding_and_encoding) for supported codecs.
Intel CPUs with a model description that ends with F don't have integrated graphics. These are intended to be used with a dedicated graphics card. Please beware if you intend to use Intel integrated graphics.
Intel CPUs with a model name that ends with `F` do not have integrated graphics. These are intended to be used with a dedicated graphics card, meaning that if you wish to use Intel integrated graphics, this is not an appropriate choice of component for your Jellyfin Server.
If you are planning to use Linux with Intel 12/13th Gen integrated graphics or ARC, these GPUs only work on Linux Kernel 6.2 or newer. Please check your distribution to make sure it has a supported Linux Kernel version. Please read [Known Intel limitations on Linux](/docs/general/post-install/transcoding/hardware-acceleration/known-issues#intel-on-linux) for more info.
If you intend to use Linux with Intel 12/13th gen integrated graphics or ARC, these GPUs only work on Linux Kernel 6.2 or newer. Please check your distribution to make sure it has a supported Linux Kernel version. Further information: [Known Intel limitations on Linux](/docs/general/post-install/transcoding/hardware-acceleration/known-issues#intel-on-linux).
:::caution
Intel 10th gen and older integrated graphics are losing support for QSV on Linux due to the SDK for these platforms being deprecated by Intel. If you own 7-10th gen CPUs with integrated graphics, please continue to use them for Jellyfin. If you are making a purchase decision, please choose a newer CPU if you plan on using Intel integrated graphics.
Intel 10th gen and older integrated graphics are losing support for QSV on Linux due to the SDK for these platforms being deprecated by Intel. If you own 7-10th gen CPUs with integrated graphics, please continue to use them for Jellyfin. If you are making a purchase decision, you may wish to consider a newer CPU if you plan on using Intel integrated graphics.
:::
#### Nvidia Graphics
#### NVIDIA Graphics
Please refer to [this table](https://developer.nvidia.com/video-encode-and-decode-gpu-support-matrix-new) for supported codecs.
Certain low end cards (e.g. GT 1030) don't have encoding hardware. Please be careful when choosing a GPU.
Certain low-end cards (e.g. GT 1030) do not have encoding hardware. Please be careful when choosing a GPU.
#### AMD Graphics
AMD graphics is not recommended for Jellyfin, but the information is still provided for convenience. Please refer to [this article](https://en.wikipedia.org/wiki/Video_Coding_Engine) for supported codecs.
AMD graphics is not recommended for Jellyfin, this information is solely provided for reference. Further reading on AMD VCE supported codecs: [https://en.wikipedia.org/wiki/Video_Coding_Engine](https://en.wikipedia.org/wiki/Video_Coding_Engine).
Certain low end cards (e.g. RX 6400, RX 6500) don't have encoding hardware. Please be careful when choosing a GPU.
Certain low-end cards (e.g., RX 6400, RX 6500) do not have encoding hardware. Please be careful when choosing a GPU.
Many AMD CPUs don't have integrated graphics. These are intended to be used with a dedicated graphics card.
Many AMD CPUs do not have integrated graphics. These are intended to be used with a dedicated graphics card.
For Ryzen 1000 ~ 5000 Series, desktop CPUs with a model description that ends with G have integrated graphics while other desktop CPUs do NOT. For Ryzen 7000 Series, desktop CPUs with a model description that ends with F do NOT have integrated graphics while others do.
For Ryzen 1000 - 5000 Series, only desktop CPUs with a model description that ends with `G` have integrated graphics—other Ryzen 1000-5000 desktop CPUs do NOT.
For Ryzen 7000 Series, desktop CPUs with a model description that ends with `F` do NOT have integrated graphics, whereas the rest do.
Please check the product page of your CPU for more info.
@@ -202,17 +203,17 @@ Supported codecs are listed below:
✅ = Encode + Decode, 🔶 = Decode Only, ❌ = Not Supported.
<sup>1</sup> Although the hardware does support AV1 decoding, [ffmpeg does not support it yet](https://trac.ffmpeg.org/ticket/10642).
<sup>1</sup> Although the hardware does support AV1 decoding, [ffmpeg does not yet support it](https://trac.ffmpeg.org/ticket/10642).
:::caution
No Apple Silicon media engine drivers currently exist for non-macOS operating systems. You will NOT be able to use hardware acceleration if you are running [Asahi Linux](https://asahilinux.org/).
No Apple Silicon media engine drivers currently exist for non-macOS operating systems. You will NOT be able to use hardware acceleration if the server is running [Asahi Linux](https://asahilinux.org/).
:::
#### Rockchip VPU
Currently only the VPU on RK3588/3588S SoC is recommended. It can handle most common video codecs, including AV1 decode.
Currently only the VPU on RK3588/3588S SoC is recommended, which can handle most common video codecs, including AV1 decode.
Supported codecs are listed below:
@@ -233,16 +234,18 @@ Supported codecs are listed below:
### Storage
There are two general types of storage that can be used on a Jellyfin server. Media libraries and Jellyfin files require different performance characteristics.
There are two general types of storage that can be used on a Jellyfin Server. Media files and Jellyfin files respectively require specific hardware to optimize performance.
#### Media Storage
Anything with higher sequential access speed than bitrate of media will work. This storage can be a network share or a cloud storage service mounted on the Jellyfin host if desired.
Anything with higher sequential access speed than bitrate of media is acceptable. If desired, this storage may be a network share, or a cloud storage service mounted on the Jellyfin Server host.
#### Jellyfin Files
Jellyfin files will see lots of random access, therefore SSDs are recommended for Jellyfin files. AVOID mechanical drives that use [SMR (Shingled Magnetic Recording)](https://en.wikipedia.org/wiki/Shingled_magnetic_recording) as they will result in a VERY poor experience.
The files for Jellyfin itself (i.e., not your media files) will see a lot of random access, therefore SSDs are recommended for these files. AVOID mechanical drives that use [SMR (Shingled Magnetic Recording)](https://en.wikipedia.org/wiki/Shingled_magnetic_recording) as they will result in a VERY poor experience.
### Networking
Networking is for connecting your Jellyfin server to other devices. It is recommended that the server be connected to the internet via Ethernet cables. Wi-Fi or Powerline solutions are NOT recommended.
Networking is for connecting your Jellyfin server to other devices. It is recommended that the Jellyfin Server be connected to your network via Ethernet cable for optimal performance. Wi-Fi or Powerline solutions for a Jellyfin Server are NOT recommended and will result in an especially poor experience.
Jellyfin Server is not designed to be exposed directly to the internet. Ensure it remains protected behind a properly configured firewall or other secure network environment.
docs/general/administration/storage.md
+28 -8
View File
@@ -3,15 +3,13 @@ uid: server-storage
title: Storage
---
## Storage
Jellyfin is designed to directly read media from the filesystem. A network storage device that is using samba or NFS must be directly mounted to the OS. The Jellyfin database should also be stored locally and not on a network storage device.
:::caution
There are [scheduled maintenance tasks](/docs/general/server/tasks) which remove items from your library if triggered while your media storage is unavailable.
:::
### NFS
## NFS
In case you encounter performance issues where files take a long time to start playing while using NFSv3, you might be running in an issue with .NET locking without NFSv3 having locking enabled.
@@ -22,18 +20,40 @@ To solve this, you have the following options:
- Enable the lock service.
- Use NFSv4 which has built-in lock support.
## Docker or VMs
## Docker and VMs
For storage, a moderate size library database can grow anywhere from 10 to 100 GB. The [transcoding](/docs/general/post-install/transcoding) folder needs roughly the same size as the original media if it's being transcoded at the same bitrate. A single 50GB Blu-Ray Remux by itself can take up to approximately 60GB or as little as 15GB, depending on the quality selected. If the transcoding folder is held on the same storage as the database, this must be taken into consideration.
A database for a moderate-sized library can grow anywhere from 10 to 100 GB.
## Cloud
The [transcoding](/docs/general/post-install/transcoding) folder typically requires about the same amount of space as the original media when transcoded at an equivalent bitrate. For example, a single 50 GB Blu-ray remux might consume as much as ~60 GB or as little as ~15 GB after transcoding. If the transcoding folder shares the same storage as the database, this should be accounted for to avoid any problems.
A popular choice for cloud storage has been the program [rclone](https://rclone.org/downloads/). It is supported on most Operating Systems. To facilitate combining local and cloud filesystems, rclone can be paired with another program such as [mergerfs](https://github.com/trapexit/mergerfs). For cloud storage, it is recommended to disable image extraction as this requires downloading the entire file to perform this task.
## Cloud Storage Providers
### MergerFS
[rclone](https://rclone.org/downloads/) is a popular choice for integrating cloud storage with a Jellyfin Server. rclone is supported on most operating systems. To combine local and cloud filesystems, rclone can be paired with another program such as [mergerfs](https://github.com/trapexit/mergerfs).
When using cloud storage, it is recommended to disable image extraction as it requires downloading the entire file.
## MergerFS
MergerFS isn't meant for everything, [see here](https://github.com/trapexit/mergerfs#what-should-mergerfs-not-be-used-for) for more.
- rclone recommended [config](https://forum.rclone.org/t/my-best-rclone-config-mount-for-plex/7441).
To modify and examine your mergerfs mount, here's a quick [guide](https://zackreed.me/mergerfs-neat-tricks).
## Filesystem Considerations
For certain filesystems, optimizations are highly recommended for acceptable performance.
### ZFS
Whilst development is being done on further database providers, in the current implementation of Jellyfin Server, the database uses SQLite. ZFS uses a default record size of `128 K`. This is sub-optimal for the SQLite database.
Ideally, you should use a record size of `4 K` or `8 K` on the dataset that contains your Jellyfin Server SQLite database. This is easily configured when running Jellyfin Server within a Docker container as you are able to easily change bind mounts and can set various datasets for each path as appropriate.
The record size for your media file dataset(s) must not be using `4 K` or `8 K`, otherwise you will likely encounter performance issues as your database scales.
For ZFS datasets containing large media files (i.e., not the dataset containing the Jellyfin Server SQLite database), a record size of `1 M` is likely appropriate for optimal performance.
Note that changing the record size on an existing ZFS dataset will not change the existing data within it, meaning performance will not be any different for anything but newly-written changes into the dataset. As such, it is recommended to rewrite your data into the dataset to take advantage of the change in record size; otherwise, the configuration change will not yield the expected change in performance.
As ZFS snapshots can use a lot of storage over time without a sensible `destroy` schedule, there may be a temptation to keep your data on a mechanical drive instead of an SSD. Do not use ZFS-formatted mechanical drives to store your Jellyfin Server data (everything except your media files), as this will result in poor performance. An SSD is strongly recommended.
docs/general/administration/troubleshooting.md
+7 -6
View File
@@ -49,10 +49,7 @@ To enable debug logging, create the `logging.json` file and add the following co
{
"Serilog": {
"MinimumLevel": {
"Default": "Debug",
"Override": {
"": "Debug"
}
"Default": "Debug"
}
}
}
@@ -227,7 +224,7 @@ You have 3 options to set the locking mode to:
- `Optimistic` - Defines that all writes should be attempted and should be retried when they fail.
- `Pessimistic` - Defines a behavior that always blocks all reads while any one write is done.
Stop your Jellyin server and navigate to its config directory. There are a lot of xml files, look for the `database.xml` file and edit the `LockingBehavior` option:
Stop your Jellyfin server and navigate to its config directory. There are a lot of xml files, look for the `database.xml` file and edit the `LockingBehavior` option:
```xml
<?xml version="1.0" encoding="utf-8"?>
@@ -239,4 +236,8 @@ Stop your Jellyin server and navigate to its config directory. There are a lot o
</DatabaseConfigurationOptions>
```
then start your jellyfin instance again. If this still does not help with the issues, you can try setting the `LockingBehavior` to `Pessimistic` instead but this comes with a significant performance impact so it is only recommended when `Optimistic` does not help with the issues.
then start your Jellyfin instance again. If this still does not help with the issues, you can try setting the `LockingBehavior` to `Pessimistic` instead but this comes with a significant performance impact so it is only recommended when `Optimistic` does not help with the issues.
### LXC specific issues
It has been brought to the team's attention that there are issues with LXC specifically. If you are getting such errors on LXC after setting lock mode to `Optimistic`, it is recommended that you migrate to full virtualization (virtual machines) or Docker. There is unlikely to be a solution for LXC any time soon, and we will be unable to provide any support for database locked problems on LXC.
docs/general/clients/codec-support.md
+12 -10
View File
@@ -13,16 +13,16 @@ The goal is to Direct Play all media. This means the container, video, audio and
[Test your browser's compatibility for any codec profile.](https://cconcolato.github.io/media-mime-support/)
| Sorted by efficiency (excluding bit depth) | Chrome | Edge | Firefox | Safari | Android | Android TV | iOS | SwiftFin (iOS) | [Roku](https://developer.roku.com/docs/specs/media/streaming-specifications.md) | Kodi | Jellyfin Media Player |
| ------------------------------------------------------------------------------------------------------------------ | -------------- | -------------- | ------- | --------------- | -------------- | -------------- | -------------- | --------------- | ------------------------------------------------------------------------------- | ---- | --------------------- |
| [MPEG-4 Part 2/SP](https://en.wikipedia.org/wiki/DivX) | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | ✅ |
| [MPEG-4 Part 2/ASP](<https://en.wikipedia.org/wiki/MPEG-4_Part_2#Advanced_Simple_Profile_(ASP)>) | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ | | ✅ | ✅ |
| [H.264 8Bit](https://caniuse.com/#feat=mpeg4 'H264 Browser Support Reference') | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
| [H.264 10Bit](https://caniuse.com/#feat=mpeg4 'H264 Browser Support Reference') | ✅ | ✅ | ❌ | 🔶<sup>12</sup> | ✅ | ✅ | ❌ | ✅ | ❌ | ✅ | ✅ |
| Sorted by efficiency (excluding bit depth) | Chrome | Edge | Firefox | Safari | Android | Android TV | iOS | SwiftFin (iOS) | [Roku](https://developer.roku.com/docs/specs/media/streaming-specifications.md) | Kodi | Jellyfin Media Player |
| ------------------------------------------------------------------------------------------------------------------ | -------------- | -------------- | --------------- | --------------- | -------------- | -------------- | -------------- | --------------- | ------------------------------------------------------------------------------- | ---- | --------------------- |
| [MPEG-4 Part 2/SP](https://en.wikipedia.org/wiki/DivX) | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | ✅ |
| [MPEG-4 Part 2/ASP](<https://en.wikipedia.org/wiki/MPEG-4_Part_2#Advanced_Simple_Profile_(ASP)>) | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ | | ✅ | ✅ |
| [H.264 8Bit](https://caniuse.com/#feat=mpeg4 'H264 Browser Support Reference') | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
| [H.264 10Bit](https://caniuse.com/#feat=mpeg4 'H264 Browser Support Reference') | ✅ | ✅ | ❌ | 🔶<sup>12</sup> | ✅ | ✅ | ❌ | ✅ | ❌ | ✅ | ✅ |
| [H.265 8Bit](https://caniuse.com/#feat=hevc 'HEVC Browser Support Reference') | 🔶<sup>8</sup> | ✅<sup>7</sup> | ✅<sup>15</sup> | 🔶<sup>1</sup> | 🔶<sup>2</sup> | ✅<sup>5</sup> | 🔶<sup>1</sup> | ✅<sup>6</sup> | 🔶<sup>9</sup> | ✅ | ✅ |
| [H.265 10Bit](https://caniuse.com/#feat=hevc 'HEVC Browser Support Reference') | 🔶<sup>8</sup> | ✅<sup>7</sup> | ✅<sup>15</sup> | 🔶<sup>1</sup> | 🔶<sup>2</sup> | 🔶<sup>5</sup> | 🔶<sup>1</sup> | ✅<sup>6</sup> | 🔶<sup>9</sup> | ✅ | ✅ |
| [VP9](https://developer.mozilla.org/en-US/docs/Web/Media/Formats/Video_codecs#VP9 'V9 Browser Support Reference') | ✅ | ✅ | ✅ | ✅<sup>10</sup> | ✅<sup>3</sup> | 🔶<sup>3</sup> | ❌ | ✅<sup>13</sup> | ✅ | ✅ | ✅ |
| [AV1](https://developer.mozilla.org/en-US/docs/Web/Media/Formats/Video_codecs#AV1 'AV1 Browser Support Reference') | ✅ | ✅ | ✅ | 🔶<sup>11</sup> | ✅ | 🔶<sup>4</sup> | ❌ | 🔶<sup>14</sup> | ✅ | ✅ | ✅ |
| [VP9](https://developer.mozilla.org/en-US/docs/Web/Media/Formats/Video_codecs#VP9 'V9 Browser Support Reference') | ✅ | ✅ | ✅ | ✅<sup>10</sup> | ✅<sup>3</sup> | 🔶<sup>3</sup> | ❌ | ✅<sup>13</sup> | ✅ | ✅ | ✅ |
| [AV1](https://developer.mozilla.org/en-US/docs/Web/Media/Formats/Video_codecs#AV1 'AV1 Browser Support Reference') | ✅ | ✅ | ✅ | 🔶<sup>11</sup> | ✅ | 🔶<sup>4</sup> | ❌ | 🔶<sup>14</sup> | ✅ | ✅ | ✅ |
<sup>1</sup>HEVC is only supported in MP4, M4V, and MOV containers.
<br />
@@ -48,7 +48,7 @@ The goal is to Direct Play all media. This means the container, video, audio and
<br />
<sup>12</sup>Need to be manually enabled in Settings > Playback > Enable H.264 High 10 Profile. Playback on Apple Silicon Macs with macOS version < 14 and Intel Macs with all macOS versions may result in blank frames if this is enabled.
<br />
<sup>13</sup>VP9 is only availble with Swiftfin (VLCKit) player.
<sup>13</sup>VP9 is only available with Swiftfin (VLCKit) player.
<br />
<sup>14</sup>AV1 is enabled by default for Swiftfin (VLCKit). AV1 is disabled by default but can be enabled for Native (AVKit) using Custom Device Profiles. Enabling AV1 may result in a poor experience for SOCs prior to A17.
<br />
@@ -198,7 +198,7 @@ If the container is unsupported, this will result in remuxing. The video and aud
| Container | Chrome | Edge | Firefox | Safari | Android | Android TV | Kodi | Roku |
| :-------------------------------------------------------------------: | :----: | :--: | :-----: | :----: | :-----: | :--------: | :--: | :--: |
| [MP4](https://en.wikipedia.org/wiki/MPEG-4_Part_14)<sup>1</sup> | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
| [MKV](https://en.wikipedia.org/wiki/Matroska)<sup>2, 3</sup> | ❌ | ✅ | ❌ | ❌ | ✅ | ✅ | ✅ | ✅ |
| [MKV](https://en.wikipedia.org/wiki/Matroska)<sup>2, 3, 8</sup> | ❌ | ✅ | ❌ | ❌ | ✅ | ✅ | ✅ | ✅ |
| [WebM](https://en.wikipedia.org/wiki/WebM)<sup>3, 5, 6</sup> | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
| [TS](https://en.wikipedia.org/wiki/MPEG_transport_stream)<sup>4</sup> | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
| [OGG](https://en.wikipedia.org/wiki/Ogg)<sup>5, 7</sup> | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
@@ -216,3 +216,5 @@ If the container is unsupported, this will result in remuxing. The video and aud
<sup>6</sup>WebM on Safari requires at least Safari 14.
<br />
<sup>7</sup>OGG on Safari requires at least iOS 18.4 / macOS 15.4
<br />
<sup>8</sup>MKV support in Firefox is currently disabled in Jellyfin, as there are significant issues making it unusable for Jellyfin. [1](https://bugzilla.mozilla.org/show_bug.cgi?id=2000420) [2](https://bugzilla.mozilla.org/show_bug.cgi?id=1991746)
docs/general/clients/css-customization.md
+8 -8
View File
@@ -95,7 +95,7 @@ This will affect the played/watched indicator. Replace the hex color with any va
![Screenshot of watched indicators with a custom transparent color applied](/images/docs/custom-css-transparentwatched.png)
### Transparant count indicators (eg. Series)
### Transparent count indicators (eg. Series)
```css
/* Make count indicator icon dark and transparent */
@@ -736,19 +736,19 @@ Material Icons:
- Outlined:
```css
@import url("https://cdn.jsdelivr.net/gh/prayag17/Jellyfin-Icons/Outline.css");
@import url('https://cdn.jsdelivr.net/gh/prayag17/Jellyfin-Icons/Outline.css');
```
- Rounded:
```css
@import url("https://cdn.jsdelivr.net/gh/prayag17/Jellyfin-Icons/round.css");
@import url('https://cdn.jsdelivr.net/gh/prayag17/Jellyfin-Icons/round.css');
```
- Sharp:
```css
@import url("https://cdn.jsdelivr.net/gh/prayag17/Jellyfin-Icons/Sharp.css");
@import url('https://cdn.jsdelivr.net/gh/prayag17/Jellyfin-Icons/Sharp.css');
```
Fontawesome Icons:
@@ -756,25 +756,25 @@ Fontawesome Icons:
- Solid:
```css
@import url("https://cdn.jsdelivr.net/gh/prayag17/Jellyfin-Icons/Font%20Awesome/solid.css");
@import url('https://cdn.jsdelivr.net/gh/prayag17/Jellyfin-Icons/Font%20Awesome/solid.css');
```
- Regular:
```css
@import url("https://cdn.jsdelivr.net/gh/prayag17/Jellyfin-Icons/Font%20Awesome/regular.css");
@import url('https://cdn.jsdelivr.net/gh/prayag17/Jellyfin-Icons/Font%20Awesome/regular.css');
```
- Light:
```css
@import url("https://cdn.jsdelivr.net/gh/prayag17/Jellyfin-Icons/Font%20Awesome/light.css");
@import url('https://cdn.jsdelivr.net/gh/prayag17/Jellyfin-Icons/Font%20Awesome/light.css');
```
- duotone:
```css
@import url("https://cdn.jsdelivr.net/gh/prayag17/Jellyfin-Icons/Font%20Awesome/duotone.css");
@import url('https://cdn.jsdelivr.net/gh/prayag17/Jellyfin-Icons/Font%20Awesome/duotone.css');
```
## Community Links
docs/general/clients/jellyfin-vue.md
+4 -2
View File
@@ -54,7 +54,7 @@ services:
watchtower:
container_name: watchtower
image: ghcr.io/containrrr/watchtower
image: ghcr.io/nicholas-fedor/watchtower
volumes:
- /var/run/docker.sock:/var/run/docker.sock
environment:
@@ -77,7 +77,9 @@ located where the `docker-compose.yml` file is.
With this compose file:
- Jellyfin Vue will be accessible on `8080` port of the machine that's running the containers
- Watchtower takes care of updating the container to the latest commit available on the [repository](https://github.com/jellyfin/jellyfin-vue).
- Watchtower (fork, [the original is unmaintained](https://github.com/containrrr/watchtower/issues/2067))
takes care of updating the container to the latest commit available on the
[repository](https://github.com/jellyfin/jellyfin-vue).
This is a good idea because:
- As of now, stable releases don't exist and there have only been prereleases that don't necessarily meet a quality criteria, but
[major development milestones](https://jellyfin.org/posts/vue-vue3/).
docs/general/clients/kodi.md
+4 -34
View File
@@ -28,7 +28,7 @@ The installation method for the repository varies depending on what kind of devi
- If prompted, enter settings and enable "Unknown Sources", then go back to the Add-on Browser
- Select the newly downloaded file and it will be installed
#### "Embedded" Devices (Android TV, Firestick, and other TV Boxes)
#### "Embedded" Devices (Android TV, FireTV Stick, and other TV Boxes)
1. Open Kodi, go to the settings menu, and navigate to "File manager"
- Select "Add source"
@@ -91,40 +91,9 @@ To use Add-on mode, simply choose "Add-on" at the dialog and proceed to [Library
#### Native Mode
:::caution
Do not use Native mode! Use Addon-mode instead.
Jellyfin 10.10 no longer provides the shared network folder via the API, and as such native mode does not get the required information to function.
:::
Native mode accesses your media files directly from the filesystem, bypassing the Jellyfin server during playback. Native mode needs more setup and configuration, but it can, on rare occasions, lead to better performance where network bandwidth is a limitation. It requires your media to be available to the device Kodi is running on over either NFS or Samba, and therefore should only be used on a LAN or over a VPN connection.
To use Native mode, first set up your libraries in Jellyfin with a remote path.
:::caution
Starting from Jellyfin 10.9 it is no longer possible to set the shared network folder.
:::
1. In the Jellyfin server, navigate to the Libraries section of the admin dashboard.
- Select an existing library (or create a new one)
- Select the media folder
- Enter the path to your network share in the "Shared network folder" textbox
- Possible formats:
- NFS
- `nfs://192.168.0.10:/path/to/media`
- Samba
- Guest User - `\\192.168.0.10\share_name`
- Custom User (Not Recommended) - `\\user:password@192.168.0.10\share_name`
- It's more secure to use the generic Guest mapping here and specify credentials from within Kodi
- Mounted share
- If you have mounted your network share, you can reference the local mount point. This can be more performant but generally means it only works for one type of operating system, given the difference between the file systems
- `/mnt/media` (Linux)
- `Z:\media` (Windows)
- `/Volumes/media` (Mac OS)
2. Configure libraries in Kodi
1. Configure libraries in Kodi
- Skip the initial library selection. We need to add file shares to Kodi first
- Within Kodi, navigate to the settings menu and select "File manager"
- Select "Add source"
@@ -134,7 +103,8 @@ Starting from Jellyfin 10.9 it is no longer possible to set the shared network f
- Select your newly created location and choose "Ok"
- Give your media source a name and choose "Ok"
- Go to Add-ons -> Jellyfin -> Manage Libraries -> Add Libraries
3. Proceed to [Library Syncing](/docs/general/clients/kodi#library-syncing)
2. Proceed to [Library Syncing](/docs/general/clients/kodi#library-syncing)
3. Make sure to set up path replacements to rewrite paths on your Jellyfin server to the correct paths on your network share
#### Library Syncing
docs/general/contributing/documentation.md
+2 -2
View File
@@ -11,11 +11,11 @@ Documentation is fast-moving and ever-changing. Please think carefully about wha
## Please Self-Review
Before finalizing your changes, please be courteous to reviewers and run your changes through, at least, a spellchecker (e.g. `apsell`) and potentially a grammar checker. AI is fine for this though please use it sparingly for *generating* content. Make sure you re-read what comes out and adjust as required. We appreciate individual writing styles but the bulk of our review back-and-forth is over minor issues like this, so please do your part to get it right first.
Before finalizing your changes, please be courteous to reviewers and run your changes through, at least, a spellchecker (e.g. `apsell`) and potentially a grammar checker. AI is fine for this though please use it sparingly for _generating_ content. Make sure you re-read what comes out and adjust as required. We appreciate individual writing styles but the bulk of our review back-and-forth is over minor issues like this, so please do your part to get it right first.
## Peer Copyediting
For very large changes, we encourage the idea of peer copyediting. Instead of submitting a massive PR and then having back-and-forth line-by-line editing in there, we suggest placing your new/updated doc in a collaborative document editor such as [Framapad](https://framapad.org/abc/en/) and sharing it in our [documentation Matrix room](/contact). You can then, between chat and the collaborative editor, obtain a line-by-line copyedit for spelling, grammar, and formatting, without back-and-forth in the PR. Once both sides are happy with the changes, a pull request can then be submitted.
For very large changes, we encourage the idea of peer copyediting. Instead of submitting a massive PR and then having back-and-forth line-by-line editing in there, we suggest placing your new/updated doc in a collaborative document editor such as [HackMD](https://hackmd.io) and sharing it in our [documentation Matrix room](/contact). You can then, between chat and the collaborative editor, obtain a line-by-line copyedit for spelling, grammar, and formatting, without back-and-forth in the PR. Once both sides are happy with the changes, a pull request can then be submitted.
While this does seem like "more work", for substantial changes this should ideally be a small part of the entire process, and will help ensure that final reviews go more smoothly.
docs/general/contributing/issues.md
+1 -1
View File
@@ -43,7 +43,7 @@ When writing a bug issue, please ensure you capture as much relevant detail as p
Bugs should be tagged with `[bug]` at the beginning of their title. This will later be removed by the Jellyfin team when assigning labels. To assist in triaging, if you know which other [label(s)](/docs/general/contributing/issues#issue-labels) should be applied to your issue, please add them after the `[bug]` label.
Bugs should be reproduceable. That is, you should be able to have determined through troubleshooting how to replicate the issue. While one-time bugs should not be ignored, if they're difficult or impossible to reproduce, it's likely very hard to fix them. Please attempt to reproduce the bug before filing the issue and include the smallest test case you can to demonstrate it.
Bugs should be reproducible. That is, you should be able to have determined through troubleshooting how to replicate the issue. While one-time bugs should not be ignored, if they're difficult or impossible to reproduce, it's likely very hard to fix them. Please attempt to reproduce the bug before filing the issue and include the smallest test case you can to demonstrate it.
If you ever need assistance for troubleshooting or opening an issue, please [contact the community](/docs/general/getting-help) and we'll try to help you out!
docs/general/contributing/llm-policies.md
+49
View File
@@ -0,0 +1,49 @@
---
uid: llm-policies
title: LLM/"AI" Policies
---
# Jellyfin LLM/"AI" Development Policy
The rise of LLMs as a useful development tool over the last year or so has been significant. The power and flexibility of tools like Claude Code and ChatGPT have given a lot of functionality both to experienced developers and new developers alike. But there are trade-offs.
The Jellyfin project has, from day one, had a major focus on code quality - readability, simplicity, conciseness. This is a mostly manual effort driven by a dedicated team of individuals, and is motivated by a desire to fix the code Jellyfin is based off of which, without beating a dead horse too much, was extremely fragile, spaghettified, and prone to over-engineered complexity.
We are seeing a precipitous rise in contributors using AI within the Jellyfin ecosystem, both in the server and for clients, as well as a rise in criticism and concern about LLMs generally. At this time we are writing this policy to address exactly what we expect and desire with respect to contributions and interactions within our community that may use LLMs. These rules apply to all of our official projects and community spaces.
## General Guidelines
1. LLM output is **expressly prohibited** for any direct communication, including the following:
* issues or comments
* feature requests or comments
* pull request bodies or comments
* forum/chat/etc. posts or comments
In short, if you are posting **any** of those things, the output must be your own words, explanation, description, etc., not a verbatim dump of an LLM's output. We expect you to understand what you're posting. Violating this rule will result in closure/deletion of the offending item(s).
An exception will be made for **LLM-assisted translations** if you are having trouble accurately conveying your intent in English. Please explicitly note this ("I have translated this from MyLanguage with an LLM") and, if possible, post in your original language as well.
2. LLM code contributions are subject to more granularity below, but the general principle is that "pure 'vibe coding' will be rejected" and "you are responsible for what you commit". We will review in that vein. If the **code looks terrible**, it will be **rejected as such**.
## LLM Code Contributions to Official Projects
The use of LLMs for code is controversial and open to much interpretation. These guidelines are our best effort attempt to ensure that knowledgeable developers who seek to use these tools as a legitimate aid are not overly-hindered, while also preventing an ongoing flood of slop contributions that violate our core ethos above. These apply to **all official Jellyfin projects**.
1. Contributions should be **concise and focused**. If the PR claims to target X, and is also touching unrelated Y and Z, it will be rejected. This includes incidental changes to unrelated functionality, a hallmark of poorly-worded or too-general prompts. Similarly, a large PR must be **broken into multiple small, manageable commits** for review and history purposes.
2. Formatting and quality **standards must be upheld**. Excessive unhelpful comments, spaghetti code, spaces on empty lines, etc. will be interpreted as pure LLM output and rejected; you must **clean up the mess** before submitting. Also **do not commit LLM metafiles** (e.g. `.claude` configs) or any other editor-created non-code files.
3. You must **review the output** and be able to **explain** in the PR body - **without** LLM output as noted above - **what is being changed and why**. Your PR body (and, if applicable, commit bodies) should be providing context to other developers about why a change was made, and if your name is on it, we want **your** words and explanations, not an LLM's. If **you can't explain** what the LLM did, we are **not interested** in the change.
4. The changes must be **tested**. The code should build and run correctly, or it will be rejected. You should also **explicitly test the functionality being modified**.
5. You must be able and willing to **handle review feedback** and implement the suggested change(s) as required. What this means in practice is, if you do not know what has been changed or why (see #3), and thus can't implement suggested changes or discuss them **yourself**, then we are **not interested** in the change. Just dumping reviewer feedback into an LLM and expecting what comes out to be "good enough", is not.
6. **Features or refactors** require **an in-depth level of understanding** about what is being changed and why. It is obvious to our reviewers when changes are made without the developer making them understanding what is happening. These will be rejected. And as noted in #1, the PR must **contain multiple discrete commits**. _We_ will squash commits as deemed appropriate after review. Large changes must also follow our other development policies (discussion, review, implementation, testing process).
7. The **final discretion always lies with the reviewers**. If your PR is not capable of being reasonably reviewed, for any reason (over-complexity, size, squashed commits, etc.) it will be rejected, and this goes just as much for non-LLM-assisted PRs as it does for LLM-assisted PRs. You will be asked to split such a PR up into multiple PRs that each present a focused, concise set of changes instead.
The golden rule is this: **do not just let an LLM loose on the codebase with a vague vibe prompt and then commit the results as-is**. This is lazy development, will **always** result in a **poor-quality contribution** from our perspective, and we are not at all interested in such slop. **Make an effort** or please do not bother. And again, you are free to use LLMs to **assist** you, but not as the sole source of code changes.
## LLM-generated Tools, Clients, etc. Shared in the Community
You are of course free to do whatever you wish for your own non-official projects. However, we will be enforcing the following rules for any **sharing of such projects within our communities**.
1. Any primarily-LLM-developed projects should be **clearly marked as such**. It is up to users to decide if this is acceptable to them or not. If you used an LLM for secondary assistance (e.g. docs, formatting, etc.) in an obvious way, we would err towards disclosure as well.
2. You **must** respect and follow licenses. If you are basing your project off of existing code, **following its license is not optional**. You must **credit existing contributors in full** for **all contributions**. Do not **mangle the Git history**, and do not **commit pending 3rd party changes as your own** (i.e. by copying the code and then committing it). Doing so will result in, not just rejection, but a ban from our organization and community. We have a **zero tolerance policy** for code theft and bad-faith attribution attempts.
3. For members of the community, **do not report** LLM-generated tools, clients, etc. **on that basis alone**, and do not engage in anti-LLM "witch hunts". As mentioned above, this is **permitted** and it is your choice whether to "support" said tool/client/etc. or not.
4. We, the moderators, are not going to play "LLM police" about 3rd party projects by nitpicking to try to "find LLM contributions" that otherwise follow our rules here; this is tedious and a waste of our time and effort. What this means in practice is that rule #1 is up to the author, and rule #3 must be interpreted in that vein. If you **only suspect** a tool is LLM-generated and violates rule #1, then downvote/ignore it and move on. **Only if** we see **blatant breaking of rule #1** we will enforce it, but again we will not be going through code line by line playing the "was this LLM generated?" game. Rule #2 will always be enforced regardless of LLM-ness or not.
docs/general/installation/_container-docker-compose.md
+2 -1
View File
@@ -13,13 +13,14 @@ You WILL NOT receive any support for running Jellyfin in Docker on platforms oth
:::
Create a `docker-compose.yml` file with the following contents. Add in the UID and GID that you would like to run jellyfin as in the user line below, or remove the user line to use the default (root).
Create a `docker-compose.yml` file like the following.
```yml
services:
jellyfin:
image: jellyfin/jellyfin
container_name: jellyfin
# Optional - specify the uid and gid you would like Jellyfin to use instead of root
user: uid:gid
ports:
- 8096:8096/tcp
docs/general/installation/_container-podman.md
+2 -2
View File
@@ -29,7 +29,7 @@ Steps to run Jellyfin using Podman are similar to the Docker steps.
3. Open the necessary ports in your machine's firewall if you wish to permit access to the Jellyfin server from outside the host.
This is not done automatically when using rootless Podman.
If your distribution uses `firewalld`, the following commands save and load a new firewall rule opening the HTTP port `8096` for TCP connections. Additionaly port 7359 UDP needs to be opened for auto discovery.
If your distribution uses `firewalld`, the following commands save and load a new firewall rule opening the HTTP port `8096` for TCP connections. Additionally port 7359 UDP needs to be opened for auto discovery.
```sh
sudo firewall-cmd --add-port=8096/tcp --permanent
@@ -44,7 +44,7 @@ The `--user` option will run with the provided user id and group id _inside_ the
The `--userns keep-id` flag ensures that current user's id is mapped to the non-root user's id inside the container.
This ensures that the permissions for directories bind-mounted inside the container are mapped correctly between the user running Podman and the user running Jellyfin inside the container.
Keep in mind that the `--label "io.containers.autoupdate=image"` flag will allow the container to be automatically updated via `podman auto-update`.
Keep in mind that the `--label "io.containers.autoupdate=image"` flag will allow the container to be automatically updated via `podman auto-update`, and a [backup](/docs/general/administration/backup-and-restore) will be required to restore a previous version.
The `z` (shared volume) or `Z` (private volume) volume option and `relabel=shared` or `relabel=private` mount option tell Podman to relabel files inside the volumes as appropriate, for systems running SELinux.
docs/general/installation/advanced/truenas.md
+1 -1
View File
@@ -527,7 +527,7 @@ You can also pull new images to use in the future.
You can choose to pull from Jellyfin's [Docker Hub](https://hub.docker.com/r/jellyfin/jellyfin) or [GitHub Container Registry](https://github.com/jellyfin/jellyfin/pkgs/container/jellyfin).
- To pull from Docker Hub, use: `jellyfin/jellyin`
- To pull from Docker Hub, use: `jellyfin/jellyfin`
- To pull from from GHCR, use: `ghcr.io/jellyfin/jellyfin`
- [You can check this blog post for more info about GHCR:](/posts/jellyfin-release-10.9.0#key-release-notesbreaking-changes)
- "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."
docs/general/installation/container.md
+8
View File
@@ -19,6 +19,14 @@ hotio image: `ghcr.io/hotio/jellyfin`.
Jellyfin distributes official container images on [Docker Hub](https://hub.docker.com/r/jellyfin/jellyfin/) and the [GitHub Container Registry](https://ghcr.io/jellyfin/jellyfin) for multiple architectures.
These images are based on Debian and [built directly from the Jellyfin source code](https://github.com/jellyfin/jellyfin-packaging/blob/master/docker/Dockerfile).
Several tags are available tracking different builds and [version](/docs/general/contributing/release-procedure/#versioning) levels.
- `latest` always tracks the latest stable release, including through major and minor version bumps
- `X` (e.g. `10`) tracks the major version, e.g. the latest 10.Y.Z
- `X.Y` (e.g. `10.11`) tracks the minor version, e.g. the latest 10.11.Z
- `X.Y.Z` (e.g. `10.11.0`) tracks a specific release
- `X.Y.Z.YYYYMMDD-HHMMSS` (e.g. `10.11.0.20251020-004604`) tracks a specific packaging build
Additionally, there are several third parties providing unofficial container images, including the [LinuxServer.io](https://www.linuxserver.io/) ([Dockerfile](https://github.com/linuxserver/docker-jellyfin/blob/master/Dockerfile)) project and [hotio](https://github.com/hotio) ([Dockerfile](https://github.com/hotio/jellyfin/blob/release/linux-amd64.Dockerfile)), which offer images based on Ubuntu and the official Jellyfin Ubuntu binary packages.
## Installation Instructions
docs/general/installation/linux.md
+1 -1
View File
@@ -8,7 +8,7 @@ sidebar_position: 3
## Debian / Ubuntu and derivatives
To simplify deployment and help automate this for as many users as possible, we provide a BASH script to handle repo installation as well as installing Jellyfin on Debian / Ubuntu and derivatives.
All you need to do is run this command on your system (requires `curl`, or subsitute `curl` with `wget -O-`):
All you need to do is run this command on your system (requires `curl`, or substitute `curl` with `wget -O-`):
```sh
curl https://repo.jellyfin.org/install-debuntu.sh | sudo bash
docs/general/post-install/networking/2_tailscale.md
+3 -3
View File
@@ -30,13 +30,13 @@ Cons:
Setup on server:
1. Install the Tailscale app on the client device. Instructions are available in [Tailscale's official install guide](https://tailscale.com/kb/1347/installation)
2. Login to the Tailscale client and connect to the tailnet. On Windows and macOS that can be done through the icon in the system tray. On Linux that can be done with the comnand `sudo tailscale up`
2. Login to the Tailscale client and connect to the tailnet. On Windows and macOS that can be done through the icon in the system tray. On Linux that can be done with the command `sudo tailscale up`
3. Find and note your Tailscale IP of the server according to the [Tailscale Documentation](https://tailscale.com/kb/1033/ip-and-dns-addresses?tab=linux#finding-your-tailscale-ip-address). This IP will be used for other devices to connect. The IP should start with 100 (e.g. 100.12.34.56).
Setup on clients:
1. Install the Tailscale app on the client device. Instructions are available in [Tailscale's official install guide](https://tailscale.com/kb/1347/installation)
2. Login to the Tailscale client and connect to the tailnet. On Windows and macOS that can be done through the icon in the system tray. On Linux that can be done with the comnand `sudo tailscale up`. On mobile devices that can be done through the tailscale app.
2. Login to the Tailscale client and connect to the tailnet. On Windows and macOS that can be done through the icon in the system tray. On Linux that can be done with the command `sudo tailscale up`. On mobile devices that can be done through the tailscale app.
3. Type in the server IP from above into your browser or Jellyfin client of choice and connect. (e.g. 100.12.34.56:8096)
## Using Tailscale with a reverse proxy
@@ -52,7 +52,7 @@ Setup on Jellyfin server:
Setup on reverse proxy server:
1. Install the Tailscale app on the client device. Instructions are available in [Tailscale's official install guide](https://tailscale.com/kb/1347/installation)
2. Login to the tailscale client and connect to the tailnet. On Linux this can be done with the comnand `sudo tailscale up`
2. Login to the tailscale client and connect to the tailnet. On Linux this can be done with the command `sudo tailscale up`
3. Setup a reverse proxy of your choice and set the upstream server to the IP from above. Example [Caddy](./reverse-proxy/caddy) configuration: (Assuming server has Tailscale IP of 100.12.34.56)
```txt
docs/general/post-install/networking/8_reverse-proxy/caddy.md
-2
View File
@@ -4,8 +4,6 @@ title: Caddy
sidebar-position: 1
---
## Caddy
> **Note:** For HTTP/3 support, ensure UDP port 443 is forwarded/opened on your firewall, as HTTP/3 uses UDP.
"[Caddy](https://caddyserver.com/), sometimes clarified as the Caddy web server, is an open source, HTTP/2-enabled web server written in Go. It uses the Go standard library for its HTTP functionality." - [Wikipedia](<https://en.wikipedia.org/wiki/Caddy_(web_server)>)
docs/general/post-install/networking/8_reverse-proxy/nginx.md
+2 -1
View File
@@ -94,7 +94,7 @@ server {
### Censor sensitive information in logs
This censors any 'api_key' URL parameter from the logfile.
This censors any 'api_key' or 'ApiKey' URL parameter from the logfile.
```conf
#Must be in HTTP block
@@ -105,6 +105,7 @@ log_format stripsecrets '$remote_addr $host - $remote_user [$time_local] '
map $request $secretfilter {
~*^(?<prefix1>.*[\?&]api_key=)([^&]*)(?<suffix1>.*)$ "${prefix1}***$suffix1";
~*^(?<prefix1>.*[\?&]ApiKey=)([^&]*)(?<suffix1>.*)$ "${prefix1}***$suffix1";
default $request;
}
docs/general/post-install/networking/9_advanced/fail2ban.md
+8 -7
View File
@@ -13,6 +13,7 @@ Jellyfin produces logs that can be monitored by Fail2ban to prevent brute-force
- Jellyfin remotely accessible
- Fail2ban installed and running
- Knowing where the logs for Jellyfin are stored: by default `/var/log/jellyfin/` for desktop and `/config/log/` for docker containers.
- Jellyfin log level set to `Info` (failed authentication entries are not logged at `Error`). This setting is can be found in `logging.json`
## Step one: create the jail
@@ -35,7 +36,7 @@ filter = jellyfin
maxretry = 3
bantime = 86400
findtime = 43200
logpath = /path_to_logs/jellyfin*.log
logpath = /path_to_logs/log_*.log
```
Save and exit nano.
@@ -82,7 +83,7 @@ sudo systemctl status fail2ban
Assuming you've at least one failed authentication attempt, you can test this new jail with `fail2ban-regex`:
```bash
sudo fail2ban-regex /path_to_logs/*.log /etc/fail2ban/filter.d/jellyfin.conf --print-all-matched
sudo fail2ban-regex /path_to_logs/log_*.log /etc/fail2ban/filter.d/jellyfin.conf --print-all-matched
```
---
@@ -150,7 +151,7 @@ Replace `<upstream-server-ip>` with the actual IP address of your upstream serve
iptables -C INPUT -j f2b-<name> 2>/dev/null || iptables -I INPUT -j f2b-<name>; \
iptables -I f2b-<name> 1 -s <ip> -j DROP' && \
echo "Banned <ip> from jail <name> via upstream proxy" >> /var/log/fail2ban.log
# Option: actionunban
# 1. Remove the banned IP from the dynamic chain
# 2. Remove the chain if it becomes empty (cleanup)
@@ -165,7 +166,7 @@ Replace `<upstream-server-ip>` with the actual IP address of your upstream serve
echo "Unbanned <ip> from jail <name> via upstream proxy and cleaned up chain if empty" >> /var/log/fail2ban.log
```
After making chaneges, save and close the file.
After making changes, save and close the file.
2. **Update Fail2Ban Jails to Use the Dynamic Chain Action**:
@@ -195,7 +196,7 @@ Replace `<upstream-server-ip>` with the actual IP address of your upstream serve
action = proxy-iptables-dynamic
```
After making chaneges, save and close the file.
After making changes, save and close the file.
### Step three: Add proxy IPs to Jellyfin
@@ -211,7 +212,7 @@ Replace `<upstream-server-ip>` with the actual IP address of your upstream serve
Open your Jellyfin server's dashboard, go to `Advanced` -> `Networking`, and then scroll down to `Known proxies`.
Enter your comma-seperated list of proxy IP ranges. You'll need to reboot the Jellyfin server as indicated.
Enter your comma-separated list of proxy IP ranges. You'll need to reboot the Jellyfin server as indicated.
### Step four: Restart Fail2Ban and Test the Setup
@@ -257,7 +258,7 @@ Replace `<upstream-server-ip>` with the actual IP address of your upstream serve
6. **Verify Unban**:
Verify that the IP is removed from the corresponding jail's chain ('f2b-jail-name'):
Verify that the IP is removed from the corresponding jail's chain ('f2b-jail-name'):
```bash
ssh root@<upstream-server-ip> "iptables -L f2b-jellyfin"
docs/general/post-install/networking/index.md
+15 -15
View File
@@ -16,24 +16,24 @@ Neither does Jellyfin require an internet connection to run; however you should
This section aims to provide an administrator with knowledge on what ports Jellyfin binds to and what purpose they serve.
| Port | Protocol | Configurable | Description |
|---|---|---|---|
| 8096 | TCP | ✔️ | Default HTTP |
| 8920 | TCP | ✔️ | Default HTTPS |
| 7359 | UDP | ❌ | Client Discovery |
| Port | Protocol | Configurable | Description |
| ---- | -------- | ------------ | ---------------- |
| 8096 | TCP | ✔️ | Default HTTP |
| 8920 | TCP | ✔️ | Default HTTPS |
| 7359 | UDP | ❌ | Client Discovery |
<details>
<summary>See details</summary>
- **HTTP Traffic** (8096/TCP):
The web frontend can be accessed here. You can modify this setting from the **Networking** page in the admin settings.
The web frontend can be accessed here. You can modify this setting from the **Networking** page in the admin settings.
- **HTTPS Traffic** (8920/TCP):
Used when https is enabled. By default this port will not be used.
This setting can also be modified from the **Networking** page to use a different port.
Used when https is enabled. By default this port will not be used.
This setting can also be modified from the **Networking** page to use a different port.
- **Client Discovery** (7359/UDP):
Allows clients to discover Jellyfin on the local network. A broadcast message to this port will return detailed information about your server that includes name, ip-address and ID.
Allows clients to discover Jellyfin on the local network. A broadcast message to this port will return detailed information about your server that includes name, ip-address and ID.
</details>
@@ -67,18 +67,18 @@ Opening a port directly to the Internet is therefore insecure and not recommende
There are different layers where a firewall can be placed:
| Layer | Example | Description |
| --- | --- | --- |
| Local | Docker, VM | Open ports at this layer to allow traffic from the Host to enter the Application |
| Host | physical machine, operating system | Open ports at this layer to allow traffic from the Network to enter the Host device |
| Network | Router | Open ports at this layer to allow traffic from the Internet to enter the Local Network |
| Layer | Example | Description |
| ------- | ---------------------------------- | -------------------------------------------------------------------------------------- |
| Local | Docker, VM | Open ports at this layer to allow traffic from the Host to enter the Application |
| Host | physical machine, operating system | Open ports at this layer to allow traffic from the Network to enter the Host device |
| Network | Router | Open ports at this layer to allow traffic from the Internet to enter the Local Network |
<details>
<summary>Port forwarding vs. opening a Port</summary>
Whilst Routers often allow you to forward a port, firewalls typically only allow you to open one.
The difference is within the Target. Opening a Port essentially just means that traffic on this Port will go through.
Forwarding a Port you typically do in NAT scenarios - traffic is coming in on your public IP Address, what device inside your network should recieve it.
Forwarding a Port you typically do in NAT scenarios - traffic is coming in on your public IP Address, what device inside your network should receive it.
Sometimes, port forwarding also lets you map an external port to a different internal port.
</details>
docs/general/post-install/transcoding/hardware-acceleration/amd.md
+1 -8
View File
@@ -38,13 +38,11 @@ Hardware accelerated HDR/DV to SDR tone-mapping is supported on **all AMD GPUs t
There are two different methods that can be used on Windows and/or Linux. Pros and cons are listed below:
1. **OpenCL**
- Pros - Supports Dolby Vision P5, detailed fine-tuning options, widely supported hardware.
- Cons - Zero-copy is not supported on Linux.
2. **Vulkan**
- Pros - Supports Dolby Vision P5, libplacebo renderer, ROCm OpenCL runtime is not required.
- Cons - Linux only, zero-copy only supports Polaris+ GPUs.
@@ -113,7 +111,7 @@ Encoding speed and quality:
## Windows Setups
Windows 10 64-bit and newer is recommeded. **AMF is not available in Windows Docker and WSL/WSL2.**
Windows 10 64-bit and newer is recommended. **AMF is not available in Windows Docker and WSL/WSL2.**
### Known Issues And Limitations On Windows
@@ -126,7 +124,6 @@ Please refer to [this section](./known-issues.md#amd-on-windows) for known issue
2. Clean install the latest driver from [AMD Drivers and Support](https://www.amd.com/en/support).
3. Don't allow the GPU to be preempted by the Windows Remote desktop session.
- Type `gpedit.msc` in Win+R shortcut key dialog and run to open the "Local Group Policy Editor".
- Navigate in the left tree **[Computer Configuration > Administrative Templates > Windows Components]**
@@ -154,7 +151,6 @@ Please refer to [this section](./known-issues.md#amd-on-windows) for known issue
Duplicate engine names indicate the GPU may have multiple video engines.
:::
- **3D** - 2D/3D engine or GPGPU workload
- **Copy** - Blitter/Copy engine workload
@@ -311,7 +307,6 @@ Root permission is required.
```
2. User mode Mesa drivers are required to be manually installed for VA-API and RADV Vulkan:
- [libva-mesa-driver](https://archlinux.org/packages/extra/x86_64/libva-mesa-driver/)
- [vulkan-radeon](https://archlinux.org/packages/extra/x86_64/vulkan-radeon/)
@@ -404,7 +399,6 @@ Root permission is required.
```
2. Use Docker command line **or** docker compose:
- Example command line:
```shell
@@ -486,7 +480,6 @@ Root permission is required.
:::
1. Install the `radeontop` package. The name varies between distros.
- On Debian & Ubuntu:
```shell
docs/general/post-install/transcoding/hardware-acceleration/index.md
+5 -5
View File
@@ -99,13 +99,13 @@ lshw -C display
See the table below to pick the best hardware acceleration method for your hardware:
| GPU Vendor | Windows | macOS | Linux |
| ---------- | ------------------------------------------ | -------------------------- | -------------------------------------- |
| GPU Vendor | Windows | macOS | Linux |
| ---------- | --------------------------------------------- | -------------------------- | ----------------------------------------- |
| AMD | [AMF (Windows)](./amd.md#windows-setups) | [VideoToolbox](./apple.md) | [VAAPI (AMD)](./amd.md#linux-setups) |
| Apple | N/A | [VideoToolbox](./apple.md) | N/A |
| Apple | N/A | [VideoToolbox](./apple.md) | N/A |
| Intel | [QSV (Windows)](./intel.md#windows-setups) | [VideoToolbox](./apple.md) | [QSV (Linux)](./intel.md#linux-setups) |
| Nvidia | [NVENC (Windows)](./nvidia.md#windows-setups) | N/A | [NVENC (Linux)](./nvidia.md#linux-setups) |
| Rockchip | N/A | N/A | [RKMPP](./rockchip.md) |
| Rockchip | N/A | N/A | [RKMPP](./rockchip.md) |
## Remote Hardware Acceleration
@@ -127,7 +127,7 @@ Dolby Vision (P5 & P8) to SDR tone-mapping is supported in Jellyfin 10.8 and req
- Intel VPP HDR10 tone-mapping is supported on Intel QSV and VA-API on Linux.
- VPP is prefered if both tone-mapping options are enabled.
- VPP is preferred if both tone-mapping options are enabled.
- Rockchip RKMPP does support Dolby Vision tone-mapping Jellyfin 10.11 and later versions.
docs/general/post-install/transcoding/hardware-acceleration/intel.md
+4 -17
View File
@@ -54,13 +54,11 @@ Hardware accelerated HDR/DV to SDR tone-mapping is supported on **all Intel GPUs
There are two different methods that can be used on Windows and/or Linux. Pros and cons are listed below:
1. **OpenCL**
- Pros - Supports Dolby Vision P5, detailed fine-tuning options, widely supported hardware.
- Cons - The OpenCL runtime sometimes need to be manually installed on Linux.
2. **QSV VPP**
- Pros - Lower power consumption, realized by Intel fixed-function LUT hardware.
- Cons - Poor tuning options, limited supported GPU models, **currently only available on Linux**.
@@ -205,7 +203,7 @@ You only need to follow the [Windows Setups](./intel.md#windows-setups) and [Lin
## Windows Setups
Windows 10 64-bit and newer is recommeded. **QSV is not available on Windows Docker and WSL/WSL2.**
Windows 10 64-bit and newer is recommended. **QSV is not available on Windows Docker and WSL/WSL2.**
### Known Issues And Limitations On Windows
@@ -218,7 +216,6 @@ Please refer to [this section](/docs/general/post-install/transcoding/hardware-a
2. Clean install the latest EXE or INF driver from [Intel download center](https://www.intel.com/content/www/us/en/download-center/home.html).
3. Don't allow the GPU to be preempted by the Windows Remote desktop session.
- Type `gpedit.msc` in Win+R shortcut key dialog and run to open the "Local Group Policy Editor".
- Navigate in the left tree **[Computer Configuration > Administrative Templates > Windows Components]**
@@ -246,7 +243,6 @@ Please refer to [this section](/docs/general/post-install/transcoding/hardware-a
Duplicate engine names indicate the GPU may have multiple MFX video engines.
:::
- **3D** - 2D/3D engine, QSV VPP or GPGPU workload
- **Copy** - Blitter/Copy engine workload
@@ -349,7 +345,6 @@ Root permission is required.
7. Check the supported QSV / VA-API codecs:
:::note
- `iHD driver` indicates support for the QSV and VA-API interfaces.
- `i965 driver` indicates only support for the VA-API interface, which should only be used on pre-Broadwell platforms.
@@ -407,7 +402,6 @@ Root permission is required.
```
2. User mode Intel media drivers and the OpenCL runtime are required to be manually installed for enabling QSV / VA-API:
- [intel-media-driver](https://archlinux.org/packages/extra/x86_64/intel-media-driver/)
- [intel-media-sdk](https://archlinux.org/packages/extra/x86_64/intel-media-sdk/)
@@ -496,7 +490,6 @@ What you need to do is pass the host's `render` group id to Docker and modify th
```
2. Use docker command line **or** docker compose:
- Example command line:
```shell
@@ -565,7 +558,7 @@ This follows the same principles as for the Docker, with one small change that y
The devices in Kubernetes are added as host path mounts, they are not separated into separate volumes like in the Docker example.
1. Example Kubernetes (API version 1) configuraton file written in YAML:
1. Example Kubernetes (API version 1) configuration file written in YAML:
```yaml
# Example of an incomplete deployment spec
@@ -635,7 +628,7 @@ This has been tested with LXC 3.0 and may or may not work with older versions.
lxc config device add <CONTAINER_NAME> gpu gpu gid=<GID_OF_HOST_RENDER_GROUP>
```
4. Make sure you have the requied devices within the container:
4. Make sure you have the required devices within the container:
```shell
$ lxc exec jellyfin -- ls -l /dev/dri
@@ -668,7 +661,6 @@ This has been tested with LXC 3.0 and may or may not work with older versions.
**Proxmox VE 7 or Older**:
:::note
- Jellyfin needs to run in a **privileged** LXC container.
- An existing unprivileged container can be converted to a privileged container by taking a backup and restoring it as privileged.
@@ -706,7 +698,6 @@ Root permission is required.
:::
1. Install the `intel-gpu-tools` package **on the host system**, which is used for debugging Intel graphics driver on Linux. The name varies between distros.
- On Debian & Ubuntu:
```shell
@@ -728,7 +719,6 @@ Root permission is required.
Duplicate engine names indicate the GPU may have multiple MFX video engines.
:::
- **Render/3D** - 2D/3D engine, QSV VPP or GPGPU workload
- **Blitter** - Blitter/Copy engine workload
@@ -777,7 +767,7 @@ More detail information about Intel video hardware can be found [on the Intel me
:::note
Gen X refers to Intel graphics architechure instead of the CPU generation. (i.e. Gen 9 graphics ≠ 9th Gen processors)
Gen X refers to [Intel graphics architecture](https://en.wikipedia.org/wiki/Intel_Graphics_Technology) instead of the CPU generation. (i.e. Gen 9 graphics ≠ 9th Gen processors)
:::
@@ -816,7 +806,6 @@ Root permission is required.
:::
1. Install the latest linux firmware packages **on the host system**. The name varies between distros.
- On Debian:
```shell
@@ -845,7 +834,6 @@ Root permission is required.
```
2. Add the required i915 kernel parameter on the host system to enable loading GuC and HuC firmware:
- Check the kernel module in use, goto step 3 if **xe** kernel driver is in use.
:::note
@@ -879,7 +867,6 @@ Root permission is required.
```
3. Update the initramfs and grub. The commands varies between distros.
- On Debian & Ubuntu:
```shell
docs/general/post-install/transcoding/hardware-acceleration/known-issues.md
+2 -7
View File
@@ -16,7 +16,6 @@ This page lists all known issues and limitations of hardware acceleration with J
1. Some Linux distros intentionally disabled the H.264 and HEVC codecs from the Mesa VA-API driver.
Known affected distros:
- [Fedora](https://www.phoronix.com/news/Fedora-Disable-Bad-VA-API)
- [OpenSUSE](https://www.webpronews.com/fedora-and-opensuse-disable-gpu-accelerated-video-over-patent-concerns/)
@@ -40,11 +39,9 @@ This page lists all known issues and limitations of hardware acceleration with J
## Intel on Linux
1. Intel Gen 11 [**Jasper Lake**](https://ark.intel.com/content/www/us/en/ark/products/codename/128823/products-formerly-jasper-lake.html) and [**Elkhart Lake**](https://ark.intel.com/content/www/us/en/ark/products/codename/128825/products-formerly-elkhart-lake.html) platforms (e.g. N5095, N5105, N6005, J6412) have quirks when using video encoders on Linux. The [Low-Power Encoding](./intel.md#low-power-encoding) mode MUST be configured and enabled for correct VBR and CBR bitrate control that is required by Jellyfin.
- Ticket: [https://gitlab.freedesktop.org/drm/intel/-/issues/8080](https://gitlab.freedesktop.org/drm/intel/-/issues/8080)
2. The default kernel 5.15 that comes with Ubuntu 22.04 LTS has a regression on Intel Gen 11 graphics (ICL, JSL and EHL) that prevents you from using the Low-Power encoding mode. Linux 5.16+ is not affected.
- Ticket: [https://gitlab.freedesktop.org/drm/intel/-/issues/4067](https://gitlab.freedesktop.org/drm/intel/-/issues/4067)
- Fixed by: [drm/i915/gen11: Moving WAs to icl_gt_workarounds_init()](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=52255ef662a5d490678fbad64a735f88fcba564d)
@@ -58,7 +55,6 @@ This page lists all known issues and limitations of hardware acceleration with J
This will move you off a 5.15 kernel which could have other implications. If it breaks something you can return to the normal kernel by installing the linux-generic package.
3. The kernel range from 5.18 to 6.1.3 have an issue that locks up and resets the i915 kernel driver when using OpenCL based HDR/DV tone-mapping. Linux 5.18-, 6.0.18+, 6.1.4+ are not affected.
- Ticket: [https://gitlab.freedesktop.org/drm/intel/-/issues/7627](https://gitlab.freedesktop.org/drm/intel/-/issues/7627)
- Fixed by: [drm/i915: improve the catch-all evict to handle lock contention](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=3f882f2d4f689627c1566c2c92087bc3ff734953)
@@ -80,7 +76,6 @@ This page lists all known issues and limitations of hardware acceleration with J
11. The kernel support for Intel Gen 13 (or Gen 20?) LNL and BMG / ARC B-series are incomplete before Linux 6.12.
12. The LTS kernel range 6.6.26 - 6.6.32 and the stable kernel range 6.8.5 - 6.9.3 have i915 driver bugs, which may cause problems on Intel Gen 12.5 DG2 / ARC A-series GPUs. If you are affected, please upgrade to kernel 6.6.33+ (LTS) or 6.9.4+. Ubuntu 24.04 with kernel versions 6.8.0-38 thru 6.8.0-41 are also affected by this issue. Upgrade to Ubuntu kernel 6.8.0-44+ if you are on the affected kernels.
- Issue: [https://github.com/jellyfin/jellyfin/issues/11380](https://github.com/jellyfin/jellyfin/issues/11380)
- Ubuntu bug: [https://bugs.launchpad.net/ubuntu/+source/linux/+bug/2072755](https://bugs.launchpad.net/ubuntu/+source/linux/+bug/2072755)
@@ -88,7 +83,7 @@ This page lists all known issues and limitations of hardware acceleration with J
14. Resizable-BAR is mandatory for hardware acceleration on BMG / ARC B-series cards, or the [media driver will crash the transcoder](https://github.com/intel/media-driver/issues/1893).
15. Intel Compute-Runtime currently uses LLVM 14 for compilation [as seen on the Intel bug report page](https://github.com/intel/intel-graphics-compiler/issues/289), making it unavailable in some distibutions like Debian Trixie [as seen on the Debian bug report page](https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1072376). Intel provided releases [on the Intel GitHub page](https://github.com/intel/compute-runtime/releases) which only require matching a matching libc runtime may be used instead.
15. Intel Compute-Runtime currently uses LLVM 14 for compilation [as seen on the Intel bug report page](https://github.com/intel/intel-graphics-compiler/issues/289), making it unavailable in some distributions like Debian Trixie [as seen on the Debian bug report page](https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1072376). Intel provided releases [on the Intel GitHub page](https://github.com/intel/compute-runtime/releases) which only require matching a matching libc runtime may be used instead.
## Nvidia
@@ -106,4 +101,4 @@ This page lists all known issues and limitations of hardware acceleration with J
- [https://github.com/ollama/ollama/issues/6928#issuecomment-2586208913](https://github.com/ollama/ollama/issues/6928#issuecomment-2586208913)
3. Docker desktop isn't supported by Nvidia Container Toolkit.
- [https://github.com/NVIDIA/nvidia-container-toolkit/issues/219#issuecomment-1903941381](https://github.com/NVIDIA/nvidia-container-toolkit/issues/219#issuecomment-1903941381)
If you need a GUI, use the docker package and podman, or similar.
If you need a GUI, use the docker package and podman, or similar.
docs/general/post-install/transcoding/hardware-acceleration/nvidia.md
+8 -13
View File
@@ -67,7 +67,7 @@ Maxwell+ GPUs provide support for HEVC:
:::note
Note that in Maxwell 2nd Gen series only the GM206 variants provide HEVC 10-bit decoding support. Its sucessor Pascal has full support for HEVC 10-bit and improved speed and quality.
Note that in Maxwell 2nd Gen series only the GM206 variants provide HEVC 10-bit decoding support. Its successor Pascal has full support for HEVC 10-bit and improved speed and quality.
:::
@@ -113,7 +113,7 @@ NVENC/NVDEC performance tables:
## Windows Setups
Windows 10 64-bit and newer is recommeded. **In Jellyfin 10.10 the minimum required NVIDIA driver version is 522.25**.
Windows 10 64-bit and newer is recommended. **In Jellyfin 10.10 the minimum required NVIDIA driver version is 522.25**.
### Configure On Windows Host
@@ -136,7 +136,6 @@ Refer to [Configure On Linux Host](./nvidia.md#configure-on-linux-host) and [Con
2. Open the "Task Manager" and navigate to the GPU page.
3. Check the occupancy of the engines as follows.
- **3D** - 2D/3D engine or CUDA/GPGPU workload
- **Copy** - Blitter/Copy engine workload
@@ -176,7 +175,6 @@ Root permission is required.
```
3. Install the NVIDIA proprietary driver by following these links. Then install two extra packages for NVENC and NVDEC support:
- On Debian: [https://wiki.debian.org/NvidiaGraphicsDrivers](https://wiki.debian.org/NvidiaGraphicsDrivers)
```shell
@@ -237,7 +235,6 @@ Root permission is required.
```
2. Install the NVIDIA proprietary driver by following the link. Then install an extra package for NVENC and NVDEC support:
- [https://wiki.archlinux.org/title/NVIDIA#Installation](https://wiki.archlinux.org/title/NVIDIA#Installation)
```shell
@@ -310,11 +307,9 @@ Root permission is required.
1. Install the NVIDIA proprietary driver on the host system. See above instructions.
2. Install the NVIDIA Container Toolkit on the host system by following this link:
- [https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#installation-guide](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#installation-guide)
3. Use the Docker command line **or** docker-compose:
- Example command line:
```shell
@@ -355,7 +350,7 @@ Root permission is required.
:::note
If you encounter the upsteam issue `CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected`, pass these extra devices to the Docker:
If you encounter the upstream issue `CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected`, pass these extra devices to the Docker:
```shell
/dev/nvidia-caps:/dev/nvidia-caps
@@ -464,7 +459,7 @@ The paths of Jellyfin config and data folders in the official and LSIO Docker im
--environment=JELLYFIN_CONFIG_DIR=/etc/jellyfin
--environment=JELLYFIN_LOG_DIR=/var/log/jellyfin
--environment=JELLYFIN_CACHE_DIR=/var/cache/jellyfin
--volume=/your/path/to/data:/var/lib/jellyfin # Replace paths with actual paths on your host's filestystem
--volume=/your/path/to/data:/var/lib/jellyfin # Replace paths with actual paths on your host's filesystem
--volume=/your/path/to/config:/etc/jellyfin
--volume=/your/path/to/logs:/var/log/jellyfin
--volume=/your/path/to/cache:/var/cache/jellyfin
@@ -477,7 +472,7 @@ The paths of Jellyfin config and data folders in the official and LSIO Docker im
```sh
[Unit]
Description=jellyfin
[Container]
Image=docker.io/jellyfin/jellyfin:latest
AutoUpdate=registry
@@ -489,7 +484,7 @@ The paths of Jellyfin config and data folders in the official and LSIO Docker im
Environment=JELLYFIN_CONFIG_DIR=/etc/jellyfin
Environment=JELLYFIN_LOG_DIR=/var/log/jellyfin
Environment=JELLYFIN_CACHE_DIR=/var/cache/jellyfin
Volume=/your/path/to/data:/var/lib/jellyfin # Replace paths with actual paths on your host's filestystem
Volume=/your/path/to/data:/var/lib/jellyfin # Replace paths with actual paths on your host's filesystem
Volume=/your/path/to/config:/etc/jellyfin
Volume=/your/path/to/logs:/var/log/jellyfin
Volume=/your/path/to/cache:/var/cache/jellyfin
@@ -497,10 +492,10 @@ The paths of Jellyfin config and data folders in the official and LSIO Docker im
[Service]
# Inform systemd of additional exit status
SuccessExitStatus=0 143
[Install]
# Start by default on boot
WantedBy=default.target
WantedBy=default.target
```
5. Create the following udev rule to make sure the GPU devices are initialized before the container is started.
docs/general/post-install/transcoding/hardware-acceleration/rockchip.md
+3 -5
View File
@@ -155,7 +155,6 @@ Root permission is required.
Only needed before using HDR tone-mapping on RK3588/3588S. This is done to ensure that the user space firmware and kernel driver versions match, otherwise OpenCL will not work properly.
:::
- For the 6.1 LTS kernel on [Ubuntu-Rockchip](https://github.com/Joshua-Riek/ubuntu-rockchip) & [Armbian](https://github.com/armbian) and the legacy 5.10 LTS kernel, install [v1.9-1-2131373](https://github.com/tsukumijima/libmali-rockchip/releases/download/v1.9-1-2131373/libmali-valhall-g610-g24p0-gbm_1.9-1_arm64.deb).
- For the 6.1 LTS kernel on other SBC **vendor-made** distros, install [v1.9-1-55611b0](https://github.com/tsukumijima/libmali-rockchip/releases/download/v1.9-1-55611b0/libmali-valhall-g610-g13p0-gbm_1.9-1_arm64.deb).
@@ -193,7 +192,7 @@ Root permission is required.
:::
1. Use Docker command line: (the extensive device names between `for...done` is used to ensure backward compatiblity)
1. Use Docker command line: (the extensive device names between `for...done` is used to ensure backward compatibility)
```shell
sudo docker run -d \
@@ -233,7 +232,7 @@ Root permission is required.
#### LXC (Linux Containers)
This setup might be useful for those, who use RK3588/3588S SoC as [Proxmox](https://www.proxmox.com/en/) host, where LXC is the official and the only supported way of doing lightweight virtualiztion with the help of system containers (LXC) vs application containers (docker). As of today Proxmox team does not support ARM platforms as hosts - and probably will never do - however successful deployments on ARM devices [are possible](https://github.com/jiangcuo/Proxmox-Port?tab=readme-ov-file).
This setup might be useful for those, who use RK3588/3588S SoC as [Proxmox](https://www.proxmox.com/en/) host, where LXC is the official and the only supported way of doing lightweight virtualization with the help of system containers (LXC) vs application containers (docker). As of today Proxmox team does not support ARM platforms as hosts - and probably will never do - however successful deployments on ARM devices [are possible](https://github.com/jiangcuo/Proxmox-Port?tab=readme-ov-file).
LXC setup idea is a bit similar to docker - you need to pass the **device files** of VPU from host to LXC and enable the **privileged mode** (see also important "_note_" below about privileged LXC containers).
@@ -251,7 +250,7 @@ LXC setup idea is a bit similar to docker - you need to pass the **device files*
device /dev/mpp_service
```
Example of the minumum requried extra (not full) container configuration to make VPU hardware accelearion working is presented below:
Example of the minimum required extra (not full) container configuration to make VPU hardware acceleration working is presented below:
```shell
lxc.mount.entry: /dev/dri dev/dri none bind,optional,create=dir
@@ -273,7 +272,6 @@ LXC setup idea is a bit similar to docker - you need to pass the **device files*
2. Install supported [jellyfin package](https://jellyfin.org/docs/general/installation/linux) into LXC container or optionally you can even use an official docker image inside LXC container.
3. Verify OpenCL runtime status as following - example is collected from LXC runtime of Ubuntu Jammy - steps are the same as docker deployments:
- _libmali user-space drivers should be installed inside LXC container, otherwise opencl=ocl@rk device won't be initialized_
```shell
docs/general/post-install/transcoding/index.mdx
+1 -1
View File
@@ -37,4 +37,4 @@ There are four types of playback; three of which involve transcoding. The type b
When the source video is in HDR, it will need to be tone-mapped to SDR when transcoding, as Jellyfin currently
doesn't support HDR to HDR tone-mapping, or passing through HDR metadata. While this can be done in software, it is
very slow, and you may encounter situations where no modern consumer CPUs can transcode in real time. Therefore, a GPU
is always recommended, where even a basic Intel iGPU can handle as much load as a Ryzen 5800X for this usecase.
is always recommended, where even a basic Intel iGPU can handle as much load as a Ryzen 5800X for this use case.
docs/general/server/media/_metadata-images.md
+33 -29
View File
@@ -2,7 +2,9 @@
## Metadata Images
Images can either be provided as external files within the media folders, or embedded in the media files themselves. When external imaged are provided, they should be placed alongside the media files. When they are provided, they will take precedence over other sources.
Images can either be provided as external files within the media folders, or embedded in the media files themselves. When external images are provided, they should be placed alongside the media files. When they are provided, they will take precedence over other sources.
Similar to media folders, an artist image can be placed in the root of an artist’s folder. It will be shown both when browsing artists and on the artist’s detail page.
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
@@ -10,12 +12,14 @@ import TabItem from '@theme/TabItem';
<Tabs>
<TabItem value='music' label='Music'>
```txt
Album
├── cover.jpg
├── backdrop.webp
├── logo.png
├── Track 1.m4a
└── Track 2.m4a
Artist
├── Album
│ ├── cover.jpg
│ ├── backdrop.webp
│ ├── logo.png
│ ├── Track 1.m4a
│ └── Track 2.m4a
└── folder.jpg
```
When no images are provided for music, Jellyfin will take the cover image from the first track that has an embedded cover image.
</TabItem>
@@ -49,7 +53,7 @@ Image types:
| Type | Description |
| -------- | --------------------------------------------------------------------------------------- |
| Primary | The primary cover image |
| Primary | The primary cover/artist image |
| Backdrop | Background image in media page <sup>1</sup> |
| Banner | Displayed when browsing library in banner mode. Video only. <sup>2</sup> |
| Logo | Logo displayed on the top of a media item. |
@@ -57,33 +61,33 @@ Image types:
<sup>1</sup>Multiple backdrop images can be used to cycle through several over time. Simply append a number to the end of the filename directly after or after a hyphen, e.g. `backdrop-1.jpg`, `backdrop2.jpg`.
<sup>2</sup>These can be added to both video and audio content, but are not used by any client for audio conent.
<sup>2</sup>These can be added to both video and audio content, but are not used by any client for audio content.
<details>
<summary>Filenames, their respective types and supported media types</summary>
Unless otherwise noted, all filenames can be used either standalone (e.g. `logo.png`) or as a suffix (e.g. `movie-logo.png`)
| Filename | Type | Movies | Series | Season | Episode | Music |
| --------------------------- | -------- | --------------- | ------ | ------ | ------- | ----- |
| poster | Primary | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ |
| folder | Primary | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ |
| cover | Primary | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ |
| default | Primary | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ |
| movie | Primary | ✅ <sup>2</sup> | | | | |
| show | Primary | | ✅ | | | |
| jacket | Primary | | | | | ✅ |
| thumb (suffix) <sup>1</sup> | Primary | | | | ✅ | |
| backdrop | Backdrop | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ |
| fanart | Backdrop | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ |
| background | Backdrop | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ |
| art | Backdrop | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ |
| extrafanart (folder) | Backdrop | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ |
| banner | Banner | ✅ | ✅ | ✅ | | ✅ |
| logo | Logo | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ |
| clearlogo | Logo | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ |
| landscape | Thumb | ✅ | ✅ | ✅ | | ✅ |
| thumb | Thumb | ✅ | ✅ | ✅ | | ✅ |
| Filename | Type | Movies | Series | Season | Episode | Music | Artist |
| --------------------------- | -------- | --------------- | ------ | ------ | ------- | ----- | ------ |
| poster | Primary | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ | |
| folder | Primary | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ | ✅ |
| cover | Primary | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ | |
| default | Primary | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ | |
| movie | Primary | ✅ <sup>2</sup> | | | | | |
| show | Primary | | ✅ | | | | |
| jacket | Primary | | | | | ✅ | |
| thumb (suffix) <sup>1</sup> | Primary | | | | ✅ | | |
| backdrop | Backdrop | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ | |
| fanart | Backdrop | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ | |
| background | Backdrop | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ | |
| art | Backdrop | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ | |
| extrafanart (folder) | Backdrop | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ | |
| banner | Banner | ✅ | ✅ | ✅ | | ✅ | |
| logo | Logo | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ | |
| clearlogo | Logo | ✅ <sup>2</sup> | ✅ | ✅ | | ✅ | |
| landscape | Thumb | ✅ | ✅ | ✅ | | ✅ | |
| thumb | Thumb | ✅ | ✅ | ✅ | | ✅ | |
<sup>1</sup> For example: `S01E01 Some Episode-thumb.jpg` <br />
<sup>2</sup> These file names can also be embedded in supported media containers (e.g. mkv) and will be used when the `Embedded Image Extractor` source is enabled for movies.
docs/general/server/media/_video-external-extras.md
+13 -4
View File
@@ -21,6 +21,8 @@ Supported folder types are:
- `other` - Generic catch all for extras of an unknown type.
- `extras` - Generic catch all for extras of an unknown type.
- `trailers`
- `theme-music`
- `backdrops`
```txt
Best_Movie_Ever (2019)
@@ -35,10 +37,17 @@ Best_Movie_Ever (2019)
Awesome TV Show (2024)
├── Season 1
│ ├── Awesome TV Show (2024) S01E01 episode name.mp4
│ └── trailers
│ └── trailer1.mp4
└── interviews
└── Interview with the Director.mp4
│ ├── trailers
│ │ └── trailer1.mp4
│ ├── theme-music
│ │ ├── Season 01 OP.mp3
│ │ └── Season 01 ED.flac
│ └── backdrops
│ └── S1Intro.mkv
├── interviews
│ └── Interview with the Director.mp4
└── theme-music
└── Series Opening.wav
```
### File Name
docs/general/server/media/_video-header.md
+1 -1
View File
@@ -4,4 +4,4 @@ Most common video formats are supported by Jellyfin, such as `mp4` and `mkv`. In
`.iso` files and other disc image formats should work, but are not supported. It is recommended that disc image formats be remuxed into `mkv` containers, or extracted into `VIDEO_TS` or `BDMV` folders.
File names containing special characters WILL cause problems. The following characters are known to cause issues: `<`, `>`, `:`, `"`, `/`, `\`, `|`, `?`, `*`
File names should match the name listed by your metadata provider whenever possible. However, certain characters cannot be used as they are reserved by jellyfin. Including them WILL cause problems. The following characters are known to cause issues: `<`, `>`, `:`, `"`, `/`, `\`, `|`, `?`, `*`
docs/general/server/media/_video-metadata-providers.md
+8 -11
View File
@@ -2,16 +2,13 @@
### Metadata providers
Jellyfin fetches information about the media automatically from external metadata providers. The following metadata providers are supported:
Jellyfin fetches information about the media automatically from external metadata providers for most types of content.
Movies and shows can be named with a metadata provider ID to improve matching.
Movies and shows can be named with a metadata provider ID to improve matching.
- [TheMovieDB (TMDB)](https://www.themoviedb.org/)
- [TheTVDB (TVDB)](https://www.thetvdb.com/) (Shows Only)
- [OMDb API (OMDB)](https://www.omdbapi.com/) (English Only)
```txt
Movie Name (year) [metadata provider id]
Series Name (year) [metadata provider id]
```
Movies and show series can be named with a metadata provider ID to improve matching. They can be added to a file name in the following format:
- `[imdbid-tt12345678]`
- `[tmdbid-12345]`
- `[tvdbid-67890]`
Multiple IDs can be added in the same file / folder. e.g. `Jellyfin Documentary [imdbid-tt00000000] [tmdbid-00000].mkv`
Read more about it in the [metadata provider identifiers section](/docs/general/server/metadata/identifiers.md).
docs/general/server/media/_video-multiversion.md
+1 -1
View File
@@ -2,7 +2,7 @@
## Multiple Versions
Multiple versions of the same video can be stored together in the library using a file suffix in Movie and Music Video library types. The part before any suffixes **MUST** be exactly the same, including any years and/or metadata provider IDs.
Jellyfin supports storing multiple versions of the same video within a single movie folder by using filename suffixes. Each file **must** begin exactly with the parent folder name - including any year and/or metadata provider IDs - before adding a version label. This prefix must match character-for-character; otherwise, the files will be treated as separate movies.
```txt
Movie (2021) [imdbid-tt12801262]
docs/general/server/media/excluding-directory.md
+32 -4
View File
@@ -1,18 +1,22 @@
---
uid: server-media-excluding-directory
title: Excluding a directory
title: Excluding Files and Directories
---
# Excluding a directory
# Excluding Files and Directories
Directories, and their respective media files, can be excluded from the library scan. This can be achieved by placing a `.ignore` file in the directory you want to exclude. As a result, the directory, and it's subdirectories, will be excluded from being scanned and shown to the end user.
Directories and files can be set for exclusion from Jellyfin media library scans, permitting you to include non-tracked files and directories within your media library. This is done by using `.ignore` (dot-ignore) files within your media library directories.
:::tip
When placing a `.ignore` file inside a directory, make sure to refresh/ rescan the metadata afterwards for it to be applied.
When creating or updating a `.ignore` file, ensure that you refresh/rescan the library afterwards for it to be applied.
:::
## Excluding whole directories
To exclude an entire directory, place an **empty** file named `.ignore` inside the directory. This directory, and all files and subdirectories within it, will be excluded.
The example given below results in the directories `Season 03` and `OST` being ignored:
```txt
@@ -29,3 +33,27 @@ Shows
├── .ignore
└── ...
```
## Excluding specific files or subdirectories
When a `.ignore` file is **not empty**, it is treated as a list of items to ignore using the [same format as a Git `.gitignore` file](https://git-scm.com/docs/gitignore#_pattern_format).
:::caution
This is a new feature in Jellyfin 10.11.x and later; older versions did not care about the contents of `.ignore` files. Legacy non-empty `.ignore` files must be manually corrected or they will stop functioning as expected.
:::
For example, a `.ignore` containing the following:
```txt
*.avi
sample.mkv
specials/
```
Will trigger Jellyfin to ignore:
* any file that ends with `.avi`.
* any file named exactly `sample.mkv`.
* the subdirectory `specials` and all files under it.
docs/general/server/media/movies.md
+4 -4
View File
@@ -41,17 +41,17 @@ Movies
The folder containing the movie should be named in the following format:
```txt
Movie Name (year) [external id]
Movie Name (year) [metadata provider id]
```
The `year` and `external id` fields are optional, but they will help identify media more reliably.
The `year` and `metadata provider id` fields are optional, but they will help identify media more reliably.
The video files within the folder should have the same name as the folder. I.e. if the folder is named `Super Fun Movie`, the video file within should be named `Super Fun Movie.mp4` (or any other extension), optionally with tags defined below.
- Example with name only: `Jellyfin Documentary.mkv`
- Example with year: `Jellyfin Documentary (2030).mkv`
- Example with external id: `Jellyfin Documentary [imdbid-tt00000000].mkv`
- Example with both year and external id: `Jellyfin Documentary (2030) [imdbid-tt00000000].mkv`
- Example with metadata provider id: `Jellyfin Documentary [imdbid-tt00000000].mkv`
- Example with both year and metadata provider id: `Jellyfin Documentary (2030) [imdbid-tt00000000].mkv`
import VideoMetadataProviders from './\_video-metadata-providers.md';
docs/general/server/media/shows.md
+5 -5
View File
@@ -47,17 +47,17 @@ Each video file may contain multiple episodes. However, they will be shown as a
The series folder should be named in the following format:
```txt
Series Name (year) [external id]
Series Name (year) [metadata provider id]
```
The `year` and `external id` fields are optional, but they will help identify media more reliably.
The `year` and `metadata provider id` fields are optional, but they will help identify media more reliably.
- Example with name only: `Jellyfin Documentary.mkv`
- Example with year: `Jellyfin Documentary (2030)`
- Example with external id: `Jellyfin Documentary [imdbid-tt00000000]`
- Example with both year and external id: `Jellyfin Documentary (2030) [imdbid-tt00000000]`
- Example with metadata provider id: `Jellyfin Documentary [imdbid-tt00000000]`
- Example with both year and metadata provider id: `Jellyfin Documentary (2030) [imdbid-tt00000000]`
The Season folders should be named `Season *`, with `*` being any number. For the best results, please pad the season number with `0`s at the front to make sure each entry has the same number of digits. For example: `Season 5` -> `Season 05`.
The Season folders should be named `Season *`, with `*` being any number. Do not abbreviate the `Season` name to `S01` or `SE01`. For the best results, please pad the season number with `0`s at the front to make sure each entry has the same number of digits. For example: `Season 5` -> `Season 05`. Also do not mix Season folders with episodes in the Shows folder.
import VideoMetadataProviders from './\_video-metadata-providers.md';
docs/general/server/metadata/chapter-images.md
+52
View File
@@ -0,0 +1,52 @@
---
uid: server-metadata-chapter-images
title: Chapter Images
---
:::note
Not to be confused with chapters, which are the ticks you see in the timeline when watching a video. Chapter Images must be enabled to be displayed; chapters can be displayed even when Chapter Images are disabled.
:::
Chapter images are a type of metadata for video media files stored in Jellyfin. They are images that correspond to chapters and give a preview of the video at that timestamp.
Jellyfin stores the chapter images within the metadata directory, which should be located inside your server's config directory.
## Getting Started
The feature is enabled per library. There are 2 ways to get to the library settings
1. When you add a new library, pick a video Content type, then navigate to "Chapter Images"
2. Click the 3 dots of an existing library and then navigate to "Chapter Images"
### Enable chapter image extraction
This will enable the Chapter image feature.
### Extract chapter images during the library scan
This will change the scheduled extraction to happen in the "Scan Media Library" task instead of the "Extract Chapter Images" task.
:::note
Extracting chapter images can be computationally intensive and slow down library scans significantly - especially on large libraries.
:::
## Other Settings
In the dashboard, you can configure other behaviours of the chapter image feature. These settings are found in Libraries -> Metadata
### Interval
This creates dummy chapters at a given interval (0 will disable dummy chapters) if no chapters are detected in the media file. The value is in seconds.
:::note
Not recommended to use small values here. Small intervals could slow down video playback as Jellyfin's webUI video player will try to render all the chapters on the timeline.
:::
### Resolution
This will set the resolution of the image files that are extracted. These images are used in a small preview window and will never take up the full screen, so setting a high resolution here is not necessary.
docs/general/server/metadata/identifiers.md
+60
View File
@@ -0,0 +1,60 @@
---
uid: metadata-provider-identifiers
title: Metadata Provider Identifiers
---
# Metadata Provider Identifiers
To improve the accuracy of media identification, you can manually specify a metadata provider identifier for each movie or show. Each metadata provider uses a unique identifier for its content, and adding these identifiers greatly improves media identification. Identifiers can be specified in your movie/show file or folder name. Multiple identifiers can be specified. For example:
```txt
Movies
├── Best_Movie_Ever (1994) [tmdbid-680] [imdbid-1234]
│ ├── Best_Movie_Ever (1994) [tmdbid-680].mp4
└── Movie (2021) [imdbid-tt12801262]
└── Movie (2021) [imdbid-tt12801262].mp4
Shows
└── Series Name (2018) [tvdbid-79168]
├── Season 01
| ├── Series Name B S01E01.mkv
| └── Series Name B S01E02.mkv
└── Season 02
├── Series Name B S02E01-E02.mkv
└── Series Name B S02E03.mkv
```
## Supported Metadata Providers
The following metadata providers are supported:
- [The Movie DB (TMDB)](https://www.themoviedb.org/)
- [The TV Database (TVDB)](https://www.thetvdb.com/) (Shows Only)
- [OMDb API (OMDB)](https://www.omdbapi.com/) (English Only)
## Finding Metadata Provider Identifiers
Below are instructions on how to find metadata provider identifiers for each supported provider.
### The Movie Database (TMDB)
The identifier is found in the URL of the title. For example:
URL: `https://www.themoviedb.org/movie/569094-spider-man-across-the-spider-verse`
Identifier: `[tmdbid-569094]`
### The TV Database (TVDB)
The identifier is found on the main page of the title. For example:
![How to find The TVDB media identifier](/images/docs/tvdb-media-identifier-example.png)
Identifier: `[tvdbid-266189]`
### OMDb API (OMDB)
OMDB provider uses Internet Movie Database (IMDB) IDs as identifiers. The identifier is found in the URL of the title. For example:
URL: `https://www.imdb.com/title/tt9362722/`
Identifier: `[imdbid-tt9362722]`
docs/general/server/metadata/index.md
+2 -2
View File
@@ -17,10 +17,10 @@ There are more official providers available in our [Plugin Catalog](/docs/genera
:::caution Notice for Users in Mainland China 中国大陆地区用户请注意
Because of external factors, certain metadata providers may not be accessable in mainland China. <br />
Because of external factors, certain metadata providers may not be accessible in mainland China. <br />
由于外部因素，部分元数据提供者在中国大陆地区可能无法访问。
Below is a list of known inaccessable providers: <br />
Below is a list of known inaccessible providers: <br />
下方为已知无法访问的提供者：
- The Movie Database (TMDb)
docs/general/server/metadata/media-segments.md
+22 -33
View File
@@ -3,30 +3,7 @@ uid: server-metadata-media-segments
title: Media segments
---
# Media segments
Media segments are a type of metadata for media files stored in Jellyfin. Unlike chapters, which have no type, media segments can contain type information, allowing different actions based on the type of each segment.
## Getting started
There's a few steps to follow if you want to use media segments:
1. Update your server to version 10.10 or above.
2. First, you'll need one or multiple plugins that can provide media segments. Read the [plugins section](#plugin-support) below to find out more.
3. Run the `Media segment scan` task in the dashboard to create segments immediately, this task also runs automatically in the background.
4. Enable actions for the different segment types, the way you do this differs per client, but they are generally found in the playback settings of the client.
## Types
The following types are currently available:
- Commercial
- Preview
- Recap
- Outro
- Intro
## An example
Media segments (first introduced in 10.10) are a type of metadata for media files stored in Jellyfin. Unlike chapters, which have no type, media segments can contain type information, allowing different actions based on the type of each segment.
A video that is 16 minutes (00:16:00) long could have the following segments:
@@ -36,18 +13,30 @@ A video that is 16 minutes (00:16:00) long could have the following segments:
Jellyfin can store this information and provide it to clients. Clients can then decide what they want to do with the provided information.
## Getting started
There's a few steps to follow if you want to use media segments:
1. Install one or multiple media segment providers. Read the [plugins section](#plugins) below to find out more.
2. Run the `Media segment scan` task in the dashboard to create segments immediately, this task also runs automatically in the background.
3. Set actions for the different segment types, the way you do this differs per client, but they are generally found in the playback settings of the client.
## Creating media segments
Media segments are provided by plugins. Learn more in the [plugin support section](#plugin-support).
Media segments are provided by plugins. In general, they include a `begin` and `end`-Timestamp, followed by a `type.`
## Clients
Media segments are supported by the web client, Android TV and Roku.
Upon receiving media segment information from the server, clients can choose to provide any number of actions based on the segment type, such as showing a "skip" button to skip the section. Because it is still a new feature, client support is very sparse and will take some time to become more wide-spread.
## Plugin support
### Plugins
Plugins can utilize this system to store their information about intros, outros, commercials and all other types of segments. This information can then be used by clients to provide actions, such as a "skip" button in their user interface. This approach generalizes how segments are handled, so more platforms can be easily supported, without custom modifications to clients.
There is an official `Chapter Segments Provider` plugin that creates media segments from chapters.
There is an official `Chapter Segments Provider` plugin that creates media segments based on chapters and chapter-names.
### Types
The following types are currently available:
- Commercial
- Preview
- Recap
- Outro
- Intro
docs/general/server/metadata/nfo.md
+49 -49
View File
@@ -37,54 +37,54 @@ It's currently not possible to disable .nfo metadata. Local metadata will always
User data importing is only possible for a single user. This user can be set in the .nfo settings.
:::
| Tag | Note |
| ------------- | --------------------------------------------------------------------------------------------------------------------- |
| name | |
| title | same as name |
| localtitle | same as name |
| dateadded | |
| originaltitle | |
| sortname | |
| criticrating | |
| sorttitle | |
| plot | |
| biography | same as plot |
| review | same as plot |
| language | |
| watched | please see the note about user data |
| playcount | please see the note about user data |
| lastplayed | please see the note about user data |
| countrycode | |
| lockedfields | |
| tagline | |
| country | |
| mpaa | |
| customrating | |
| runtime | |
| aspectratio | |
| lockdata | |
| studio | multiple tags allowed |
| director | multiple tags allowed |
| credits | multiple tags allowed |
| writer | multiple tags allowed |
| actor | multiple tags allowed |
| trailer | kodi format |
| displayorder | |
| year | |
| rating | same as customrating |
| ratings | multiple child tags allowed; name attribute of each tag will specify wheter the rating is critics or community rating |
| aired | |
| formed | |
| premiered | |
| releasedate | |
| enddate | |
| genre | multiple tags allowed. These tags will be ignored for music albums and music artists. |
| tag | multiple tags allowed |
| style | multiple tags allowed |
| fileinfo | |
| uniqueid | type attribute specifies id provider |
| thumb | please see the [section about images](#image-paths-and-urls-in-nfo-files) |
| fanart | please see the [section about images](#image-paths-and-urls-in-nfo-files) |
| Tag | Note |
| ------------- | ---------------------------------------------------------------------------------------------------------------------- |
| name | |
| title | same as name |
| localtitle | same as name |
| dateadded | |
| originaltitle | |
| sortname | |
| criticrating | |
| sorttitle | |
| plot | |
| biography | same as plot |
| review | same as plot |
| language | |
| watched | please see the note about user data |
| playcount | please see the note about user data |
| lastplayed | please see the note about user data |
| countrycode | |
| lockedfields | |
| tagline | |
| country | |
| mpaa | |
| customrating | |
| runtime | |
| aspectratio | |
| lockdata | |
| studio | multiple tags allowed |
| director | multiple tags allowed |
| credits | multiple tags allowed |
| writer | multiple tags allowed |
| actor | multiple tags allowed |
| trailer | kodi format |
| displayorder | |
| year | |
| rating | same as customrating |
| ratings | multiple child tags allowed; name attribute of each tag will specify whether the rating is critics or community rating |
| aired | |
| formed | |
| premiered | |
| releasedate | |
| enddate | |
| genre | multiple tags allowed. These tags will be ignored for music albums and music artists. |
| tag | multiple tags allowed |
| style | multiple tags allowed |
| fileinfo | |
| uniqueid | type attribute specifies id provider |
| thumb | please see the [section about images](#image-paths-and-urls-in-nfo-files) |
| fanart | please see the [section about images](#image-paths-and-urls-in-nfo-files) |
Provider id tags are supported as well if they follow the scheme: `<PROVIDER_NAME`+ `id>`.
@@ -99,7 +99,7 @@ Jellyfin can write metadata to .nfo files. To enable this option, select the "Nf
| .nfo tag | Note |
| ------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| title | |
| id | IMDb id for movies, TVDb id for tv shows, |
| id | IMDb id for movies, TVDb id for tv shows, |
| originaltitle | |
| seasonnumber | only for tv show seasons |
| showtitle | only for tv show episodes |
docs/general/server/plugins/tvheadend.md
+2 -3
View File
@@ -25,7 +25,7 @@ The objective of the guide is to configure the Jellyfin TVHeadend plugin to back
- Change parameters: Rights,Channel number range,Channel tags,DVR configurations,Streaming profiles,Connection limits
- Web interface: ✔
- Streaming: Basic,Advanced,HTSP
- Video recoder: Basic,HTSP,View all
- Video recorder: Basic,HTSP,View all
- (Optional) Comment: Comment for the user (for example: User used by Jellyfin)
- (Optional) Allowed networks: _Network address with network mask to allow_ (for example 127.0.0.1/32)
- Press Save
@@ -38,7 +38,7 @@ The objective of the guide is to configure the Jellyfin TVHeadend plugin to back
:::note
The parameters Change parameters, Streaming and Video recoder must be marked as shown. Otherwise, Jellyfin can connect to TVHeadend but problems may arise when reproducing the content.
The parameters Change parameters, Streaming and Video recorder must be marked as shown. Otherwise, Jellyfin can connect to TVHeadend but problems may arise when reproducing the content.
:::
@@ -56,7 +56,6 @@ By default the the _TVHeadend Hostname or IP Address_ section is configured by d
:::
3. Configure the channels for viewing in Jellyfin: even if Jellyfin manages to connect to TVHeadend, the guide will not be synchronized because there has to be a number assigned to the channels in TVHeadend. [Reference](https://emby.media/community/index.php?/topic/64583-no-channels-with-tvheadend-plugin/#entry642268)
- Manual mode
- Go to Configuration > Channel/EPG > Channels
- Select the channel to be changed and press Edit
docs/general/server/tasks.md
+1 -1
View File
@@ -11,7 +11,7 @@ Note: If your media files are unavailable when the `Clean up collections and pla
## Default Jellyfin Tasks
Below is a list of tasks that Jellyfin runs peoridically by default:
Below is a list of tasks that Jellyfin runs periodically by default:
### Libraries
docs/project/branding.md
+1 -1
View File
@@ -37,7 +37,7 @@ As a general rule, "Jellyfin" should always be capitalized, but language, file,
- C# class and project names, including their files and directories, should use capitalized `Jellyfin` as required by the C# case standards (camelCase or PascalCase). `Jellyfin.LiveTv`, `Jellyfin.sln`
- Other code elements, where the code formatting or style requires lowercase, should use lowercase `jellyfin`. `jellyfinWebComponentsBowerPath`
- The Git repository and non-C# files inside of it should use lowercase `jellyfin` for convenience on case-sensitive filesystems. `build-jellyfin.ps1`
- The final output binary, initscrips, and package names should use lowercase `jellyfin` for similar reasons as above. `jellyfin.dll`, `jellyfin_3.5.2-1_all.deb`, `jellyfin.zip`
- The final output binary, initscripts, and package names should use lowercase `jellyfin` for similar reasons as above. `jellyfin.dll`, `jellyfin_3.5.2-1_all.deb`, `jellyfin.zip`
- Configuration directories can use either depending on operating system conventions. `/var/lib/jellyfin`, `AppData/Jellyfin`
- The logo has no strict rules for capitalization, the style is dependent on aesthetics and font choice.
eslint.config.mjs
+1 -1
View File
@@ -22,7 +22,7 @@ export default ts.config([
'**/*.json'
]),
react.configs.flat.recommended,
reactHooks.configs['recommended-latest'],
reactHooks.configs.flat.recommended,
...ts.configs.recommended,
jsxA11Y.flatConfigs.recommended,
{
package-lock.json
Generated
+1744 -175
View File
File diff suppressed because it is too large Load Diff
package.json
+16 -13
View File
@@ -16,6 +16,7 @@
"write-translations": "docusaurus write-translations",
"write-heading-ids": "docusaurus write-heading-ids",
"lint": "eslint --ext .ts,.js,.json,.jsx,.tsx .",
"lint:markdown": "markdownlint **/*.md --ignore node_modules",
"test:blog-urls": "node ./scripts/check-urls.mjs ./scripts/data/jellyfin-blog-urls.json",
"test:docs-urls": "node ./scripts/check-urls.mjs ./scripts/data/jellyfin-docs-urls.json",
"test:web-urls": "node ./scripts/check-urls.mjs ./scripts/data/jellyfin-web-urls.json"
@@ -30,7 +31,7 @@
"@docusaurus/plugin-svgr": "3.9.2",
"@docusaurus/theme-classic": "3.9.2",
"@docusaurus/theme-mermaid": "3.9.2",
"@easyops-cn/docusaurus-search-local": "0.52.1",
"@easyops-cn/docusaurus-search-local": "0.52.2",
"@fontsource/noto-sans": "5.2.10",
"@icons-pack/react-simple-icons": "13.8.0",
"@img-comparison-slider/react": "8.0.2",
@@ -43,9 +44,9 @@
"file-loader": "6.2.0",
"react": "18.3.1",
"react-dom": "18.3.1",
"sass": "1.93.2",
"swiper": "12.0.2",
"ua-parser-js": "2.0.6",
"sass": "1.97.3",
"swiper": "12.0.3",
"ua-parser-js": "2.0.8",
"url-loader": "4.1.1"
},
"browserslist": {
@@ -63,24 +64,26 @@
"devDependencies": {
"@docusaurus/module-type-aliases": "3.9.2",
"@docusaurus/tsconfig": "3.9.2",
"@eslint/js": "9.38.0",
"@types/react": "18.3.26",
"@eslint/js": "9.39.2",
"@types/react": "18.3.27",
"@types/react-helmet": "6.1.11",
"@types/react-router-dom": "5.3.3",
"eslint": "9.38.0",
"cspell": "9.6.0",
"eslint": "9.39.2",
"eslint-config-prettier": "10.1.8",
"eslint-plugin-import": "2.32.0",
"eslint-plugin-jsx-a11y": "6.10.2",
"eslint-plugin-n": "17.23.1",
"eslint-plugin-prettier": "5.5.4",
"eslint-plugin-n": "17.23.2",
"eslint-plugin-prettier": "5.5.5",
"eslint-plugin-promise": "7.2.1",
"eslint-plugin-react": "7.37.5",
"eslint-plugin-react-hooks": "5.2.0",
"globals": "16.4.0",
"eslint-plugin-react-hooks": "7.0.1",
"globals": "17.0.0",
"markdownlint-cli": "0.47.0",
"node-fetch": "3.3.2",
"prettier": "3.6.2",
"prettier": "3.8.1",
"typescript": "5.9.3",
"typescript-eslint": "8.46.2",
"typescript-eslint": "8.53.1",
"typescript-plugin-css-modules": "5.2.0"
}
}
project-words.txt
+485
View File
@@ -0,0 +1,485 @@
aabc
abled
actionban
actionunban
addrepo
airsafter
airsbefore
alac
albumartistsort
allports
alpn
analyzeduration
AniDB
AniList
anthonylavado
apiclient
apsell
archlinux
armbian
armhf
asahi
aspectratio
aspm
atsc
audiodbalbumid
audiodbartistid
audiofin
autoclean
autoremove
autoscans
avhw
avsd
banip
bantime
barebones
Battlemage
BDMV
behindthescenes
blitter
Blitter
boxset
Broadwell
buildinfo
cachedir
Caddyfile
candry
cdart
Celeron
centurylinklabs
certbot
Certbot
certificateresolvers
certificatesresolvers
certonly
cewert
CGNAT
CHACHA
Cheatsheet
chevrotin
chromecast
Chromecast
chronyd
CIFS
clearart
clearlogo
clinfo
codenames
codesign
collectionnumber
comskip
configdir
confs
countrycode
cpus
criticrating
crosstool
cuda
customrating
customresponseheaders
CUVID
datasheet
dateadded
dden
dearmor
debuntu
deinterlacing
deletedscene
DHLEVEL
dhparams
directio
DISABLEFILELOCKING
discart
displayepisode
displayorder
displayseason
distros
dists
dkanada
dlna
DNSPLUGIN
Dockerfiles
downmix
Downmix
downmixes
downmixing
dpkg
DRTG
druscoe
drwxr
DUCKDNSTOKEN
DXVA
elrc
emby
enddate
enmod
ETSI
evermeet
executionpolicy
exposedbydefault
EXTINF
EXTM
extradomains
extrafanart
extrepo
failregex
fanart
fastcgi
favorited
fedor
ferferga
FFMPEGDIR
ffprobe
Fider
findtime
firewalld
firmware
firmwares
flac
Flathub
Flix
Floostream
focuscontainer
Fontawesome
forwardfor
Freccia
Freenode
frontpage
fsbs
ftab
fullchain
Geekbench
Geforce
geoblocking
Geoip
geolocation
getent
gifsicle
Gotify
gpedit
GPGPU
gstreamer
HDHR
Headend
healthcheck
hitsong
hmac
Homerun
hostname
hostnames
hostwebclient
hotfixes
hotio
hoverable
hsbs
hsts
htab
HTPC
HTSP
httpchallenge
httpchk
hwaccel
imdb
imdbid
initscripts
inotify
ipban
IPTV
ircs
irqs
itid
iwalton
Izzy
jeffbridges
jellyfin
JELLYFINDIR
Jellyfins
Jellyseer
jfdiscord
jftest
jimdogx
joshuaboniface
journalctl
jpegd
jpege
Kaby
keyrings
keyserver
Kinopoisk
Kitsu
kodi
Kodi
Kribs
lastplayed
Lavado
lavfi
ldconfig
leresolver
letsencrypt
libc
libera
libmali
libnvcuvid
libnvidia
libplacebo
libva
llvmpipe
localappdata
localtitle
lockdata
lockedfields
logdir
logfile
logfiles
logpath
lshw
LSIO
lzma
machinectl
macvlan
MAINPID
Maxr
maxretry
Mbps
mcarlton
mediaserver
mergerfs
metaarchive
metaimage
metapackage
metapackages
Metapackages
mintls
mirrorbits
mirrorinfo
mirrorlist
mirrorstats
mirrorsync
mkinitcpio
mmdb
mobi
modeset
mopidy
mpaa
mpvqt
Multicore
multiversion
Multiview
musicbox
musicbrainzalbumartistid
musicbrainzalbumid
musicbrainzartistid
musicbrainzreleasegroupid
mycoolname
myjellyfin
myvideos
nasm
Navi
ncmpcpp
newbaseurl
nftables
Niels
nielsvanvelzen
nightlies
Nightmode
noarch
noarchive
noautorunwebapp
nodesource
nodistro
noimageindex
nonfree
noninteractive
Nontranscoded
nosniff
nosnippet
notranslate
nowebclient
nssm
NVDEC
NVENC
nvidiactl
ocid
ocsp
offtopic
OLDFILES
Olivo
OMDB
onevpl
OPTOUT
originaltitle
outros
pacman
Palinuro
partnumber
parttype
𝘱𝘢𝘵𝘩
PGID
PGSSUB
Pictureless
playcount
playerstats
Powerline
privkey
probesize
Profil
PROGRAMDATA
projectname
providernameid
publickey
PUID
Quadro
QUIC
Rabert
Radarr
radeon
Radeon
radeonsi
radeontop
RADV
ratelimits
rclone
RDNA
readthrough
Realtek
redir
redirections
redirector
redirectscheme
referer
releasedate
remoteip
remux
remuxed
remuxing
repofile
rescan
rffmpeg
rgba
rkmpp
RKMPP
rkrga
rkvdec
rkvenc
Robibero
rockchip
Ronin
rpmfusion
RSSDP
rsyncd
Ryzen
scrobble
scrollbuttons
scroller
Scyfin
seasonnumber
secp
secretfilter
seekbar
SEMA
sendfile
Serilog
setsebool
Shoko
Shokofin
shoutcast
showtitle
Skia
skylake
Skylake
Sonarr
sortname
sorttitle
soughtafter
Spacetech
spaghettified
specifishity
speedbumps
splashscreen
SSDP
storebadge
stripsecrets
subcc
subcomponents
subfolders
subheaders
subpackages
subteam
sudoedit
superfast
Swiftfin
synchronised
syncplay
sysconfig
Sysoev
systempaths
tailnet
Themerr
thornbill
Tigerlake
timedatectl
Tizen
TMDB
tmdbid
tmpfs
tonemapping
triaging
trickplay
Trixie
truenas
TSIG
TVDB
tvdbid
tvheadend
tvrageid
tvshow
TXTT
Ultrachromic
ultrafast
unban
unbanip
Uncorr
unsynchronised
Unsynchronized
upvote
usermod
userns
vaapi
vainfo
valhall
Vasily
vdpu
Velzen
Venson
vepu
veryfast
veryslow
videoid
videotoolbox
vitorsemeano
Vium
Vorbis
VORBIS
weba
webclient
webdir
Weblate
webroot
Webroot
Webstorm
webui
wheter
withcolor
withuserdata
Wizdom
wstunnel
xattr
Xbmc
XMLTV
xorg
Xorg
Xvolume
xvzf
ycbcr
youruser
yourusername
redirects.ts
+1 -1
View File
@@ -13,7 +13,7 @@ const redirects: ClientRedirects.Options['redirects'] = [
'/docs/general/server/media/subtitles.html',
'/docs/general/server/media/external-files'
],
to: '/docs/general/server/media/movies#external-subtitles-and-audio-racks'
to: '/docs/general/server/media/movies#external-subtitles-and-audio-tracks'
},
// Storage docs moved from the server guide to administrative docs
{
scripts/data/jellyfin-web-urls.json
+1
View File
@@ -1,4 +1,5 @@
[
"/docs/general/administration/backup-and-restore",
"/docs/general/administration/hardware-acceleration.html",
"/docs/general/administration/hardware-acceleration/intel",
"/docs/general/contributing/index.html",
src/components/contribute/ContributorGuide.tsx
+2 -2
View File
@@ -84,7 +84,7 @@ export default function ContributorGuide() {
{contributorOption === ContributorOption.Code && (
<>
<div className='margin-top--md'>
There are a couple ways to get involved with Jellyfin depending on your skillset.
There are a couple ways to get involved with Jellyfin depending on your skill set.
</div>
<div>
<button
@@ -467,7 +467,7 @@ export default function ContributorGuide() {
{otherOption === OtherOption.Troubleshoot && (
<div className='margin-top--md'>
We have a large and diverse userbase, with so many features that the combinations and configurations are
We have a large and diverse user base, with so many features that the combinations and configurations are
almost endless. But as a volunteer-run project, the contributors can often be limited in the help they can
provide. If you are well-versed in Jellyfin&apos;s operation, we welcome you to try to help troubleshoot
problems your fellow users are having. Troubleshooting generally occurs in our{' '}
src/css/custom.scss
+6 -2
View File
@@ -6,8 +6,12 @@
*/
html {
-moz-font-feature-settings: 'liga' on;
font-feature-settings: 'liga';
/* Note: "normal" activates all common ligatures */
font-variant-ligatures: normal;
}
code {
font-variant-ligatures: none;
}
:root {
src/data/clients.ts
+89
View File
@@ -915,6 +915,95 @@ const thirdPartyClients: Array<Client> = [
url: 'https://monk-studio.com/finer'
}
]
},
{
id: 'streamyfin',
name: 'Streamyfin',
description: 'A modern Jellyfin client with support for downloads, Live TV, skip intro & credits, trickplay image and more!',
clientType: ClientType.ThirdParty,
deviceTypes: [DeviceType.Mobile],
licenseType: LicenseType.OpenSource,
platforms: [Platform.Android, Platform.IOS],
primaryLinks: [
{
id: 'play-store',
name: 'Play Store',
url: 'https://play.google.com/store/apps/details?id=com.fredrikburmester.streamyfin'
},
{
id: 'app-store',
name: 'App Store',
url: 'https://apps.apple.com/app/streamyfin/id6593660679'
}
],
secondaryLinks: [
{
id: 'github',
name: 'GitHub',
url: 'https://github.com/streamyfin/streamyfin'
},
{
id: 'website',
name: 'Website',
url: 'https://streamyfin.app'
}
]
},
{
id: 'gelly',
name: 'Gelly',
description: 'A light, native music client for Linux.',
clientType: ClientType.ThirdParty,
deviceTypes: [DeviceType.Desktop],
licenseType: LicenseType.OpenSource,
platforms: [Platform.Desktop, Platform.Linux],
primaryLinks: [
{
id: 'flathub',
name: 'Flathub (Linux)',
url: 'https://flathub.org/apps/details/io.m51.Gelly'
}
],
secondaryLinks: [
{
id: 'github',
name: 'Github',
url: 'https://github.com/Fingel/gelly'
}
]
},
{
id: 'jellify',
name: 'Jellify',
description: 'A free and open source music player available for iOS and Android',
clientType: ClientType.ThirdParty,
deviceTypes: [DeviceType.Mobile],
licenseType: LicenseType.OpenSource,
platforms: [Platform.IOS, Platform.Android],
primaryLinks: [
{
id: 'app-store',
name: 'App Store',
url: 'https://apps.apple.com/us/app/jellify/id6736884612'
},
{
id: 'google-play',
name: 'Google Play',
url: 'https://play.google.com/store/apps/details?id=com.cosmonautical.jellify'
}
],
secondaryLinks: [
{
id: 'github',
name: 'GitHub',
url: 'https://github.com/Jellify-Music/App'
},
{
id: 'website',
name: 'Website',
url: 'https://jellify.app'
}
]
}
];
src/data/downloads.tsx
+2 -7
View File
@@ -307,12 +307,7 @@ sudo apt install jellyfin`}
{
id: 'arch-stable-link',
name: 'Arch Downloads',
url: 'https://archlinux.org/packages/?q=jellyfin'
},
{
id: 'arch-aur-link',
name: 'AUR Downloads',
url: 'https://aur.archlinux.org/packages/?K=jellyfin'
url: 'https://archlinux.org/packages/extra/x86_64/jellyfin-server/'
}
],
unstableButtons: [
@@ -332,7 +327,7 @@ makepkg -si`}
{
id: 'arch-aur-link',
name: 'AUR Downloads',
url: 'https://aur.archlinux.org/packages/?K=jellyfin'
url: 'https://aur.archlinux.org/packages/jellyfin-server-git'
}
],
otherButtons: []
src/pages/contribute.module.scss
-13
View File
@@ -1,16 +1,3 @@
.button--digitalocean {
background-color: #0080ff;
border-color: #0080ff;
}
.button--digitalocean:hover {
background-color: #0073e6;
border-color: #0073e6;
}
.button--digitalocean:active {
background-color: #006dd9;
border-color: #006dd9;
}
.button--jetbrains {
background-color: #fff;
border-color: #fff;
src/pages/contribute.tsx
+1 -10
View File
@@ -1,5 +1,5 @@
import Link from '@docusaurus/Link';
import { SiDigitalocean, SiJetbrains } from '@icons-pack/react-simple-icons';
import { SiJetbrains } from '@icons-pack/react-simple-icons';
import Layout from '@theme/Layout';
import clsx from 'clsx';
import React from 'react';
@@ -53,15 +53,6 @@ export default function Contribute() {
<h3>Sponsors</h3>
<div className={styles['sponsor-list']}>
<a
href='https://www.digitalocean.com'
className={clsx('button', 'button--lg', styles['button--digitalocean'])}
style={{ display: 'inline-flex' }}
>
<SiDigitalocean size={28} className='margin-right--sm' />
DigitalOcean
</a>
<a
href='https://www.jetbrains.com'
className={clsx('button', 'button--lg', styles['button--jetbrains'])}
src/pages/downloads/clients/index.tsx
+7 -8
View File
@@ -4,11 +4,11 @@ import { mdiFilter } from '@mdi/js';
import Icon from '@mdi/react';
import Layout from '@theme/Layout';
import clsx from 'clsx';
import React, { useEffect, useState } from 'react';
import React, { useMemo, useState } from 'react';
import ClientDetails from '../../../components/clients/ClientDetails';
import Pill from '../../../components/common/Pill';
import { Client, Clients, DeviceType } from '../../../data/clients';
import { Clients, DeviceType } from '../../../data/clients';
import Platform, { FeaturedClientPlatforms } from '../../../data/platform';
import styles from '../index.module.scss';
@@ -37,7 +37,6 @@ export default function ClientsPage({ recommended = true }: { recommended?: bool
const location = useLocation();
const searchParams = new URLSearchParams(location.search);
const [filteredClients, setFilteredClients] = useState<Client[]>([...Clients]);
const [filter, setFilterValue] = useState<ClientFilter>({
recommended,
deviceTypes: (searchParams.get('type')?.split(',') ?? []) as DeviceType[],
@@ -62,8 +61,8 @@ export default function ClientsPage({ recommended = true }: { recommended?: bool
setFilterValue(filter);
};
useEffect(() => {
setFilteredClients(
const filteredClients = useMemo(
() =>
Clients.filter((client) => {
let result = true;
@@ -81,9 +80,9 @@ export default function ClientsPage({ recommended = true }: { recommended?: bool
(filter.platforms.length === 0 || client.platforms.some((platform) => filter.platforms.includes(platform)));
return result;
})
);
}, [filter, setFilteredClients]);
}),
[filter]
);
return (
<Layout title='Clients'>
static/.well-known/org.flathub.VerifiedApps.txt
+1
View File
@@ -1 +1,2 @@
d48b4366-63ef-487c-87f9-f08a26e23e6d
92811634-ec91-45d6-9495-5eb2effbc21f
static/images/docs/tvdb-media-identifier-example.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 10 KiB