# Watcharr: a self-hosted watched list for movies, TV, anime and games

> Watcharr is a Go and SvelteKit application that keeps your watched, watching and planned titles in one place behind user authentication. It installs as a single container, and the trade-offs are in the metadata sources, not the setup.

**sbondCo/Watcharr** — Open source, self-hostable watched list for all your content (movies, tv series, anime, games) with user authentication, modern and clean UI and a very simple setup.

- Repository: https://github.com/sbondCo/Watcharr
- Website: https://watcharr.app
- Stars: 1,517 · Forks: 82
- Language: Go
- License: GPL-3.0
- Published: 2026-08-08 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/sbondco-watcharr

## The problem Watcharr solves, and who it is for

Most watched-list services are hosted. You sign in, you add titles, and the list lives on someone else's server under someone else's account model. Watcharr takes the opposite position: it is software you run, with its own user authentication, so the list belongs to the machine you control. The README describes it as "your new easily self-hosted content watched list", and the scope is deliberately broad: movies, TV shows and anime by default, with video games available through "some extra configuration".

The audience is narrow in a useful way. This is for people who already run a container or two, want a shared list for a household or a small group of friends, and do not want to depend on a third-party service staying online or keeping its current terms. The demo instance is explicitly described as a worst-case scenario for speed, which tells you the intended deployment is your own hardware, not a public instance. If you have no server and no interest in running one, the project has nothing to offer you.

## How the Go backend and SvelteKit frontend fit together

The repository splits cleanly into a server directory and a src directory, and the Dockerfile builds them as separate stages. The backend stage starts from golang:1.26-alpine, copies server/, installs musl-dev, gcc and build-base, and builds a binary named watcharr with CGO_ENABLED=1 and the flag CGO_CFLAGS="-D_LARGEFILE64_SOURCE". That combination points at a cgo-based SQLite driver, which is why the build needs a C toolchain at all and why the final binary is copied as a single file into the runtime stage.

The frontend stage uses node:24-alpine, runs npm install and npm run build, and produces a build directory that is copied to /ui in the runner image. The final image installs production dependencies with npm ci --omit=dev --ignore-scripts=true, and the comment in the Dockerfile explains why: the prepare script is meant for development and would error in this context. The runtime image exposes port 3080 and starts the Go binary directly.

The practical consequence is that the web UI is served by the Go process alongside the API, and all state lives under /data, which the compose file bind-mounts to ./data on the host. The README says that directory contains "all of watcharr data (database & cache)". That single fact drives most of the operational advice below.

## Installing Watcharr with Docker Compose

The README points at the documentation for an up-to-date setup guide and offers the repository's docker-compose.yml as the shortcut. The compose file defines one service, watcharr, using the image ghcr.io/sbondco/watcharr:latest, mapping port 3080 to 3080, mounting ./data into /data, and setting restart: unless-stopped.

```yaml
services:
  watcharr:
    image: ghcr.io/sbondco/watcharr:latest
    container_name: watcharr
    ports:
      - 3080:3080
    volumes:
      - ./data:/data
    restart: unless-stopped
```

Run it from the directory containing the file:

```bash
docker compose up -d
```

The container starts the Go binary, which serves the UI on port 3080. Open http://localhost:3080 in a browser. The README notes that there is no demo account on the hosted demo, and the same applies to a fresh instance: you create the first user yourself through the sign-up flow.

The compose file carries a comment worth repeating. The :latest tag is used for simplicity, and the file itself recommends using an actual version and checking the releases for changelogs when updating. Given that v4.2.1 was published on 2026-08-04, pinning to a tag like ghcr.io/sbondco/watcharr:v4.2.1 is the more predictable choice for a list you care about. The last push to the repository was on 2026-08-04, so the project is not dormant, but that is also not a promise about any particular release.

## Where Watcharr is the wrong tool

The first limitation is stated by the project itself. Game tracking is not part of the default experience; the README links to a server configuration page for IGDB-backed game support. If your list is mostly games, you are signing up for an integration step that the movie and TV path does not require, and the configuration is external to the compose file shown above.

The second limitation is the data directory. Everything, database and cache, sits under /data. There is no documented export path in the README, and no rollback procedure is described for a failed upgrade. A version bump that changes the schema therefore depends on your own backup of ./data, not on anything the project provides. The frontend dependencies do include papaparse, which suggests CSV handling exists somewhere in the UI, but the README does not document an export or import workflow, so do not assume one.

The third is the demo. The README states that the server hosting the Watcharr Demo was having problems starting 23rd Aug 2026 and would likely be offline for a couple of days. That is a hosting issue, not a defect in the application, but it means you may not be able to evaluate the UI before installing. The README's own advice is to set up your own instance to look around, which it claims takes less than a minute.

Finally, the community tooling is explicitly unsupported. The Kodi plugin listed under Community Made Tools is described as something the maintainer cannot provide assurances for or stay on top of, with problems to be filed in that tool's own repository.

## Watcharr compared with a hosted tracker

The closest alternative in practice is a hosted service in the same category, such as Trakt or Simkl. The difference is not features, it is where the list lives and who can change it. A hosted tracker gives you an account, an app on every platform, and no server to patch. Watcharr gives you a container, a SQLite-backed data directory, and the responsibility for backups and upgrades.

That trade is sharper than it first appears. With a hosted service, the provider decides when the API changes and when the product is discontinued. With Watcharr, you decide when to pull a new image, and a discontinued project still runs on your hardware. What you give up is the network effect: there is no shared public profile ecosystem, and the README's community tools section is a short list rather than a plugin marketplace.

If your reason for self-hosting is privacy or control, Watcharr is the right shape. If your reason is that you want the widest device support with the least maintenance, a hosted tracker wins on effort, and Watcharr will feel like a second job.

## Licence, maintenance and upgrade cost

Watcharr is licensed under GPL-3.0, and package.json records the licence as GPL-3.0-only. The README points to the LICENSE file in the repository root for the full text. The practical implication for most users is nil: running the container for yourself does not trigger distribution obligations. It matters if you modify the source and distribute the result, or if you embed it in a product, because the GPL requires derivative distributions to carry the same licence. That is a description of the licence, not legal advice; read the LICENSE file if your use is commercial.

On maintenance, the repository is not archived, and the last push was on 2026-08-04. The release history shows v4.1.1 on 2026-07-26, v4.2.0 on 2026-08-03 and v4.2.1 on 2026-08-04, so patch releases have arrived close together. The README also notes that most patches are tracked through a project board and that the maintainer describes the process as unorganised, with surprise updates. Plan for that: pin an image tag, read the changelog before moving it, and keep a copy of ./data outside the host.

The upgrade procedure itself is the standard compose one. Change the image tag, then run docker compose pull followed by docker compose up -d. Because the database lives in the bind mount rather than inside the container, recreating the container does not destroy your list. That is the whole safety margin, and it is only as good as your backup.

## Conclusion

Adopt Watcharr if you want a single-user or small-group watched list that you control, and you are comfortable running one container with a bind-mounted data directory. Skip it if you need a hosted service with no server to maintain, or if you expect every content type to work without extra configuration. Before committing, check the current tag on ghcr.io/sbondco/watcharr instead of :latest, confirm that ./data is backed up, and read the game-support configuration page if games are part of your list, because the README states that tracking video games requires additional setup.

## FAQ

### How do I install Watcharr?

The README points to the installation documentation and offers the repository's docker-compose.yml as the quick path. That file runs the image ghcr.io/sbondco/watcharr:latest, maps port 3080, and mounts ./data into /data.

### Does Watcharr support games as well as movies and TV?

Movies, TV shows and anime are the default scope. The README states that with some extra configuration, linked from the docs under server_config/game-support-igdb, video games can be tracked too.

### Where does Watcharr store its data?

The docker-compose.yml mounts ./data on the host into /data in the container, and its comment says that directory contains all of watcharr data, meaning the database and cache.

### What licence is Watcharr released under?

The README states the project is licensed under GPLv3, and package.json records the licence as GPL-3.0-only. The full text is in the LICENSE file in the repository root.

## Sources

- [Official documentation](https://watcharr.app)
- [Official README](https://github.com/sbondCo/Watcharr#readme)
- [Project repository](https://github.com/sbondCo/Watcharr)
- [Release notes](https://github.com/sbondCo/Watcharr/releases)

---

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