# Jellyfin Web: the browser client most Jellyfin apps are built on

> Jellyfin Web is the GPL-2.0 frontend for desktop browsers, Android and iOS clients. It is a build-time project, not a server, and the README assumes you already run one.

**jellyfin/jellyfin-web** — The Free Software Media System - Official Web Client

- Repository: https://github.com/jellyfin/jellyfin-web
- Website: https://jellyfin.org
- Stars: 3,883 · Forks: 2,244
- Language: JavaScript
- License: GPL-2.0
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/jellyfin-jellyfin-web

## What jellyfin-web actually is, and who it is for

Jellyfin Web is the frontend used for most of the clients available for end users, according to the README, naming desktop browsers, Android and iOS. That sentence is the whole scope. This repository ships the interface: the screens, the player controls, the library browsing, the login form. It does not ship a catalog, a transcoder or a database. Someone else has to serve the media.

The audience follows from that. If you are a frontend developer working on Jellyfin's UI, this is your repository. If you are translating the interface, the README points at a Weblate instance and says translations can be improved very easily there. If you are an operator who wants a media server, you are in the wrong place: the README never describes how to run a server, only how to build and run the client.

One practical consequence is easy to miss. Because the same frontend is reused across desktop browsers, Android and iOS, a change here reaches more than one client. That is the argument for treating this repository as shared infrastructure rather than one app among several.

## How the frontend is put together and what it needs at runtime

The repository is JavaScript with a TypeScript configuration present, and the build tooling is visible in the top-level files. There is a webpack.common.js, a webpack.dev.js and a webpack.prod.js, plus a vite.config.ts, so two bundlers coexist in the tree. Babel configuration sits alongside them, and the package.json lists a large devDependencies block covering ESLint, Stylelint, Babel presets, React type packages and testing tools such as @vitest/coverage-v8 and jsdom.

The dependency list is a useful signal about the shape of the codebase. React types, react-dom types and eslint-plugin-react-hooks appear, so React is part of the stack. So do dompurify and escape-html types, which points at rendering untrusted strings, a normal concern for a client that displays media metadata. The presence of es-check and eslint-plugin-compat suggests the project checks the output against target browser versions rather than assuming a modern engine.

What the client needs at runtime is a Jellyfin server it can reach. The README does not spell out that handshake, and it does not document the port the client expects or how the server address is configured. Anyone evaluating this repository should treat that gap as real: the build produces a client, and the connection details live outside this repository's documentation.

## Building jellyfin-web locally with npm

The README lists two dependencies, Node.js and npm, which ships with Node.js. The steps below are copied from it. Clone the repository and move into the directory first.

```sh
git clone https://github.com/jellyfin/jellyfin-web.git
cd jellyfin-web
```

Install the build dependencies inside the project directory. The README gives a single command for this, and it will pull the devDependencies listed in package.json.

```sh
npm install
```

## Running the client for development and building it for deployment

Two scripts cover the common cases. npm start runs the web client with webpack for local development, which is what you want while iterating. npm run build:development produces a build with sourcemaps available, which is what you want when you need to debug a deployed client.

```sh
npm start
npm run build:development
```

After npm start, the README says the client runs with webpack for local development. It does not state which port the dev server binds to, so read the terminal output rather than assuming a number.

## Limits, failure modes and the wrong mental model

The clearest limitation is that this is not a server. The README describes a frontend and nothing else. If you clone this repository expecting to point a browser at it and watch a film, the missing piece is the entire backend. The README does not document how the client discovers a server address, which port it uses, or what happens when no server responds. Those are the first questions a new user asks and the documentation is silent on them.

A second limit is the build toolchain. The tree carries webpack configuration for development and production, a Vite configuration, Babel, ESLint, Stylelint, PostCSS and cssnano. That is a lot of moving parts for someone who only wants to change a colour. Contributing is not a one-file edit.

A third is licensing. The repository is GPL-2.0-or-later, and the README badge says GPL 2.0. If you fork the interface into a closed product, that license is the constraint you have to reason about, and this article is not legal advice. The README directs larger feature ideas to an issue first so the implementation can be discussed, which is a process constraint rather than a technical one, but it shapes how outside work lands.

Finally, the README does not document rollback or version pinning. There is a bump_version script in the repository root and the package.json version is 13.0.0 while the most recent release listed is v12.1. That mismatch is visible in the repository and worth confirming before you build against a specific tag.

## Alternatives: jellyfin-web against a native client

The natural comparison is a native Jellyfin client rather than another web frontend. A browser client runs inside the browser's media stack and its codec support, and it depends on the server to transcode when the browser cannot decode a file directly. A native application can bundle its own playback components and reach formats the browser will not.

The trade-off is deployment. A web client updates when the server updates it. A native client has to be installed and updated per device. If your users are on managed desktops or mixed platforms, the browser route removes an install step. If your library is full of formats the browser handles poorly, the browser route moves the cost to the server's transcoding capacity. Neither is free, and the choice depends on which resource you would rather spend.

## Maintenance, releases and what upgrading costs you

The repository is not archived, and the last push was on 2026-09-23. Recent releases listed are v12.1 on 2026-09-15, v12.0 on 2026-09-08 and v12.0-rc7 on 2026-08-31. That cadence means the client moves on a schedule of its own, and a self-hosted deployment that pins an old build will drift from the server it talks to.

Upgrade cost is mostly the toolchain. Because the build depends on a pinned devDependencies set in package.json, a jump between releases can mean re-resolving that set, and the coexistence of webpack and Vite configuration means the build path may shift between versions. The package.json version reads 13.0.0 while the latest release listed is v12.1, so verify which ref you are building before assuming the numbers line up.

On licensing: GPL-2.0-or-later is a copyleft license. Redistributing a modified client carries obligations that a permissive license would not, and the specifics depend on how you distribute. That is a question for someone qualified to answer it, not something to infer from a badge.

## Conclusion

Adopt jellyfin-web if you are developing against Jellyfin's frontend, self-hosting a customised web interface, or contributing translations through Weblate. Do not adopt it expecting a media server: the repository contains no playback backend, and the README gives no instructions for running one. Before you start, verify that Node.js and npm are installed, that you have a Jellyfin server reachable from your browser, and that you know which npm script matches your goal, npm start for local development or npm run build:development for a sourcemapped build.

## FAQ

### Can you use Jellyfin on a browser?

Yes. Jellyfin Web is the frontend used for most of the clients available for end users, and the README names desktop browsers alongside Android and iOS. The client still needs a Jellyfin server to talk to.

### How do I access the Jellyfin web interface?

The README does not document the address or port a deployed client is reached on. It only covers building and running the client locally with npm start, so the access details come from your server deployment rather than this repository.

### Can I use Jellyfin without a server?

No. This repository is the web interface only. The README describes a frontend and gives no instructions for running a media server, so there is nothing here to serve media from.

### How do I install jellyfin-web?

Clone the repository, run npm install in the project directory, then npm start for local development or npm run build:development for a build with sourcemaps. Node.js and npm are the only dependencies the README lists.

### What is jellyfin-web?

It is the frontend used for most of the Jellyfin clients available for end users, including desktop browsers, Android and iOS. The repository is JavaScript, licensed GPL-2.0-or-later, and builds with npm.

### How do I update the jellyfin web version?

The README does not document an upgrade path. It lists releases such as v12.1 and v12.0, and the package.json version reads 13.0.0, so check which ref you are building before assuming the version numbers match.

## Sources

- [jellyfin/jellyfin-web on GitHub](https://github.com/jellyfin/jellyfin-web)
- [License: GPL-2.0](https://github.com/jellyfin/jellyfin-web/blob/master/LICENSE)
- [Project website](https://jellyfin.org)
- [README](https://github.com/jellyfin/jellyfin-web/blob/master/README.md)
- [Releases](https://github.com/jellyfin/jellyfin-web/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jellyfin-jellyfin-web