Skip to content

About

Vora Media Server backend system, Admin Interface, and Client Web Interface

Resources

Security policy

Stars

12 stars

Watchers

0 watching

Forks

Repository files navigation

Vora

A self-hosted media server with a cinematic, template-themed client. Vora indexes your media library and surfaces it through a modern UI with support for movies, TV, music, IPTV with DVR, multi-server clients, profiles, plugins, and scheduled visual templates.

Tech stack

  • Backend: .NET 10, C#, minimal APIs (Vora.Api)
  • Database: PostgreSQL with the vector extension, EF Core
  • Real-time: SignalR (/hubs/Vora)
  • Frontend: React + TypeScript + Vite + Tailwind (Vora.Web)
  • Container: Single Docker image bundling the API and React client; FFmpeg + Comskip included for transcoding and DVR commercial detection

Running Vora

Vora is distributed as a Docker image at ghcr.io/<owner>/vora-media-server. The container serves both the API and the bundled React client on port 8080. It expects a PostgreSQL database with the vector extension enabled.

The full deployment is two pieces:

  1. A PostgreSQL server (with pgvector).
  2. The Vora container itself.

When the Vora container starts in any non-Development environment, it automatically applies any pending EF Core migrations against the configured database — so there's no manual schema step. You only need to make sure the database exists and is reachable.

The sections below walk through each piece on a single Linux host using Docker, with an Unraid-specific walkthrough at the end. The same pattern works on TrueNAS Scale or any host with Docker installed; tweak volume paths to match your system.

1. Set up PostgreSQL with pgvector

The recommended path is the official pgvector/pgvector image, which ships PostgreSQL with the vector extension prebuilt. Create a dedicated data directory on the host and start the container:

mkdir -p /srv/vora/postgres-data

docker run -d \
  --name vora-postgres \
  --restart unless-stopped \
  -e POSTGRES_DB=vora \
  -e POSTGRES_USER=vora \
  -e POSTGRES_PASSWORD=change-me-to-a-strong-password \
  -p 5432:5432 \
  -v /srv/vora/postgres-data:/var/lib/postgresql/data \
  pgvector/pgvector:pg16

A few notes:

  • Pin a specific Postgres major (pg16, pg17, …) rather than a moving tag. Postgres major upgrades require a manual pg_upgrade step.
  • If Vora and Postgres will share a Docker network (recommended — see the compose example below), drop the -p 5432:5432 publish so the database isn't exposed on the host's public interface.
  • Pick a real password. The connection string is the only thing protecting your library metadata.

Once the container is healthy, verify that the vector extension is available:

docker exec -it vora-postgres psql -U vora -d vora -c "CREATE EXTENSION IF NOT EXISTS vector;"

You should see CREATE EXTENSION (or NOTICE: extension "vector" already exists). EF Core will also create the extension on first migration, but running this once up front confirms the image is wired up correctly.

2. Run the Vora container

Pull the image from GHCR and run it with a connection string pointing at the Postgres container, a JWT secret for signing auth tokens, and volume mounts for your media and persistent data. On first start, Vora will apply all EF Core migrations against the database; subsequent starts only apply new ones.

Make sure ASPNETCORE_ENVIRONMENT is not set to Development (it's unset by default, which falls back to Production — that's what you want for a server).

mkdir -p /srv/vora/data

docker run -d \
  --name vora \
  --restart unless-stopped \
  -p 8080:8080 \
  -e PUID=99 \
  -e PGID=100 \
  -e ASPNETCORE_HTTP_PORTS=8080 \
  -e ConnectionStrings__DefaultConnection="Host=vora-postgres;Port=5432;Database=vora;Username=vora;Password=change-me-to-a-strong-password" \
  -e Jwt__SecretKey="$(openssl rand -base64 64)" \
  -e StoragePaths__CustomArtwork=/app/data/custom_artwork \
  -e StoragePaths__OriginalArtworkCache=/app/data/original_artwork_cache \
  -e StoragePaths__EpgCache=/app/data/iptv/epg_cache \
  -e StoragePaths__IptvDvr=/app/data/iptv/dvr \
  -e StoragePaths__UserImages=/app/data/users \
  -e StoragePaths__Plugins=/app/data/plugins \
  -e StoragePaths__Subtitles=/app/data/subtitles \
  -e StoragePaths__VideoThumbnails=/app/data/video-thumbnails \
  -e StoragePaths__Logs=/app/data/logs \
  -e StoragePaths__Backups=/app/data/backups \
  -e StoragePaths__DataProtection=/app/data/dp-keys \
  -v /srv/vora/data:/app/data \
  -v /mnt/media/movies:/media/movies:ro \
  -v /mnt/media/shows:/media/shows:ro \
  -v /mnt/media/music:/media/music:ro \
  --link vora-postgres \
  ghcr.io/axufuris/vora-media-server:latest

Vora is now reachable at http://<host>:8080. The first account you create through the setup flow becomes the server admin.

Key environment variables:

  • PUID / PGID — the user and group the container runs as, just like Jellyfin, Plex, and the LinuxServer images. On startup, while still root, the container ensures a vora user/group with these ids, recursively chowns the /app/data and /transcode mounts to match, then drops privileges and runs the app as that user. This makes bind mounts writable no matter how the host directories are owned, with no host-side chown needed. The library mounts under /media are never chowned — they keep their host ownership (mount them :ro anyway). Defaults are 99 / 100 (Unraid's nobody:users); on a plain Linux host set them to your own id -u / id -g. Restarts are idempotent — the ids are re-applied cleanly every time. An optional UMASK (default 022) controls the permissions of files the app creates.
  • ConnectionStrings__DefaultConnection — Npgsql connection string. Use the container name of the Postgres service as Host when both run on the same Docker network.
  • Jwt__SecretKey — long random string used to sign profile and account tokens, at least 32 characters (the server refuses to start with a shorter one or the placeholder). Generate once and keep it stable; rotating it invalidates every existing session.
  • TZ — the container's time zone, e.g. America/Chicago. Without it a container runs on UTC, and every scheduled time in the admin settings (nightly scan, intro/credit detection, thumbnail generation, IPTV syncs, poster overlays) is read against UTC — so "02:00" runs at 02:00 UTC, which is the previous evening in the Americas. Either set this, or pick a zone under Settings → Core → Scanning → Schedule Time Zone, which overrides it.
  • StoragePaths__* — locations inside the container for user-uploaded artwork, the original-artwork download cache, the IPTV EPG cache, DVR recordings, user profile images, uploaded plugins, downloaded subtitles, scrub-bar thumbnails, log files, backups and the keys that protect the saved SMTP password. Keep them all under one mounted volume so a single backup covers everything. The app's own folder (/app) is not writable, so a path must never point there. Any path you leave out goes in the same folder as the ones you did set, or in /app/data when none is set, so mounting /app/data is enough on its own. At startup Vora logs where each folder is, and raises an admin alert for any it cannot write to. Transcoder scratch (HLS segments, IPTV timeshift) lives under /transcode and is configured separately through the admin UI — that path should be a fast local disk or tmpfs. The server also writes a resized-artwork cache under StoragePaths__CustomArtwork/imagecache (posters/stills/backdrops the clients request through /api/artwork/thumb). It self-bounds at 512 MB and needs no separate volume — see docs/artwork-image-cache.md.

Media mounts should be read-only (:ro) unless you want Vora to manage the files. Read-only is safer; the API only needs to read.

docker-compose example

For most self-hosted setups it's easier to run the whole stack from a single docker-compose.yml. The repo includes one tuned for local development; the snippet below is a server-ready version:

services:
  postgres:
    image: pgvector/pgvector:pg16
    container_name: vora-postgres
    restart: unless-stopped
    environment:
      POSTGRES_DB: vora
      POSTGRES_USER: vora
      POSTGRES_PASSWORD: change-me-to-a-strong-password
    volumes:
      - /srv/vora/postgres-data:/var/lib/postgresql/data

  vora:
    image: ghcr.io/axufuris/vora-media-server:latest
    container_name: vora
    restart: unless-stopped
    depends_on:
      - postgres
    ports:
      - "8080:8080"
    environment:
      PUID: 99
      PGID: 100
      ASPNETCORE_HTTP_PORTS: 8080
      ConnectionStrings__DefaultConnection: "Host=postgres;Port=5432;Database=vora;Username=vora;Password=change-me-to-a-strong-password"
      Jwt__SecretKey: "REPLACE_WITH_A_LONG_RANDOM_STRING"

      # Without this the container runs on UTC and every scheduled
      # time in the admin settings is read against UTC.
      TZ: "America/Chicago"
      StoragePaths__CustomArtwork: /app/data/custom_artwork
      StoragePaths__OriginalArtworkCache: /app/data/original_artwork_cache
      StoragePaths__EpgCache: /app/data/iptv/epg_cache
      StoragePaths__IptvDvr: /app/data/iptv/dvr
      StoragePaths__UserImages: /app/data/users
      StoragePaths__Plugins: /app/data/plugins
      StoragePaths__Subtitles: /app/data/subtitles
      StoragePaths__VideoThumbnails: /app/data/video-thumbnails
      StoragePaths__Logs: /app/data/logs
      StoragePaths__Backups: /app/data/backups
      StoragePaths__DataProtection: /app/data/dp-keys
    volumes:
      - /srv/vora/data:/app/data
      - /srv/vora/transcode:/transcode
      - /mnt/media/movies:/media/movies:ro
      - /mnt/media/shows:/media/shows:ro
      - /mnt/media/music:/media/music:ro

Bring it up with docker compose up -d. Vora will wait for the Postgres container to start, apply migrations, and then begin serving.

Optional: GPU transcoding

Vora can transcode on an NVIDIA, Intel or AMD GPU. Under System Settings → Core → Transcoding, Hardware acceleration starts on Auto: at startup Vora test-encodes a 2-second clip on each GPU it can see (NVIDIA first, then Intel Quick Sync, then VAAPI) and uses the first that works. Test hardware runs the same check on demand. If a GPU can't start a stream, Vora retries that stream on the CPU.

NVIDIA

Install the NVIDIA Container Toolkit on the host and add a deploy block to the vora service:

    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu, video]

The image ships with NVIDIA_VISIBLE_DEVICES=all and NVIDIA_DRIVER_CAPABILITIES=all baked in, so on any host that launches it with the NVIDIA runtime, libnvidia-container injects libcuda.so.1 plus the NVENC/NVDEC and Vulkan/OpenCL driver libraries — CUDA decode, NVENC encode, and the tonemap_cuda HDR→SDR filter all work out of the box. The host only needs the NVIDIA Container Toolkit runtime enabled. Don't override NVIDIA_DRIVER_CAPABILITIES with a narrower value (e.g. utility) — that omits libcuda.so.1 and you'll see Could not dynamically load CUDA / Cannot load libcuda.so.1 when a transcode starts.

Intel or AMD

Pass the host's render devices into the vora service:

    devices:
      - /dev/dri:/dev/dri

Nothing else is needed. The image's FFmpeg carries the Intel and AMD VA-API drivers, Intel's Quick Sync runtime and the Vulkan drivers, and the container's start script adds Vora's user to the group that owns the render device, so there are no permissions to fix by hand. If it still can't open the device, the container log says so at startup. Intel tone-maps HDR on the GPU. AMD does too through Vulkan where the card supports it; otherwise it decodes and encodes on the GPU and tone-maps on the CPU.

Unraid

Unraid users typically install both containers from Apps → Add Container (Community Applications) using a manual template. Both templates need the Network Type set to the same custom Docker network so the Vora container can resolve Postgres by its container name. Create one first if you don't already have a user-defined bridge:

Settings → Docker → Add Network → bridge → name it "vora"

Then add each container. The fields below assume the Unraid array is mounted at /mnt/user and that your media lives under /mnt/user/media.

Postgres container

Field Value
Name vora-postgres
Repository pgvector/pgvector:pg16
Network Type vora (the custom bridge above)
Console shell Bash
Restart Policy unless-stopped
Path: /var/lib/postgresql/data /mnt/user/appdata/vora-postgres
Variable: POSTGRES_DB vora
Variable: POSTGRES_USER vora
Variable: POSTGRES_PASSWORD a strong password you generate

Leave the port unmapped — keeping Postgres off the LAN is safer, and the Vora container will reach it over the internal Docker network. Apply, then wait for the container to go green in the Docker tab.

Vora container

Field Value
Name vora
Repository ghcr.io/axufuris/vora-media-server:latest
Network Type vora (same custom bridge as Postgres)
Restart Policy unless-stopped
Port: container 8080 host 8080 (or any free port)
Variable: PUID 99 (Unraid's nobody)
Variable: PGID 100 (Unraid's users)
Path: /app/data /mnt/user/appdata/vora
Path: /media/movies /mnt/user/media/movies — Access Mode Read Only
Path: /media/shows /mnt/user/media/shows — Access Mode Read Only
Path: /media/music /mnt/user/media/music — Access Mode Read Only
Variable: ASPNETCORE_HTTP_PORTS 8080
Variable: ConnectionStrings__DefaultConnection Host=vora-postgres;Port=5432;Database=vora;Username=vora;Password=<the password from above>
Variable: Jwt__SecretKey a long random string (e.g. output of openssl rand -base64 64 from any shell)
Variable: StoragePaths__CustomArtwork /app/data/custom_artwork
Variable: StoragePaths__OriginalArtworkCache /app/data/original_artwork_cache
Variable: StoragePaths__EpgCache /app/data/iptv/epg_cache
Variable: StoragePaths__IptvDvr /app/data/iptv/dvr
Variable: StoragePaths__UserImages /app/data/users
Variable: StoragePaths__Plugins /app/data/plugins
Variable: StoragePaths__Subtitles /app/data/subtitles
Variable: StoragePaths__VideoThumbnails /app/data/video-thumbnails
Variable: StoragePaths__Logs /app/data/logs
Variable: StoragePaths__Backups /app/data/backups
Variable: StoragePaths__DataProtection /app/data/dp-keys
Path: /transcode /mnt/user/appdata/vora-transcode (or a fast scratch disk)

PUID=99 / PGID=100 are Unraid's nobody:users, which own everything under /mnt/user by default — so Vora writes to its appdata and transcode shares out of the box with no manual chmod/chown. They're already the container defaults; the rows above just make them visible and editable on the template. If your shares are owned by a different user, set these to that user's id instead.

Apply. Vora will auto-migrate the database on first launch (watch the container log if you want to confirm — you should see Applying N pending database migration(s)). Once it's up, open http://<unraid-ip>:8080 and create the first account, which becomes the server admin.

For an Intel or AMD GPU on Unraid, set the template's Intel/AMD GPU field to /dev/dri (or add --device=/dev/dri to Extra Parameters).

For NVIDIA GPU transcoding on Unraid, install the Nvidia-Driver plugin from CA, then on the Vora container template set Extra Parameters to --runtime=nvidia. That's the only change required — the image already carries NVIDIA_VISIBLE_DEVICES=all and NVIDIA_DRIVER_CAPABILITIES=all, so you do not need to add those variables by hand (Unraid's --runtime=nvidia path ignores the compose deploy capabilities list, which is why baking them into the image is what makes CUDA work here). To pin a specific GPU, you can still add a NVIDIA_VISIBLE_DEVICES variable set to its UUID from nvidia-smi, but leave NVIDIA_DRIVER_CAPABILITIES alone — narrowing it drops libcuda.so.1 and breaks transcoding.

Behind a reverse proxy

Nothing to configure. Vora reads the real client address from the X-Forwarded-For header whenever the connection comes from a private network (127.0.0.0/8, 10.0.0.0/8, 172.16.0.0/12 — which includes Docker's networks — 192.168.0.0/16, and IPv6 unique-local / link-local). That covers a proxy on the same machine, in Docker beside Vora (Nginx Proxy Manager, SWAG, Traefik, Caddy), or elsewhere on your LAN, and chains such as a Cloudflare tunnel feeding a proxy. The real address is what the Authorized Devices page shows and locates, what per-client rate limits use, and what decides whether a stream counts as remote for your remote-bitrate and upload limits.

It can't be spoofed from the internet: an address on the public internet is never trusted to forward, and the header is read from the right, stopping at the first address that isn't one of your own proxies.

To narrow it to specific proxies, or turn it off:

environment:
  - ForwardedHeaders__KnownProxies__0=192.168.1.5        # only this proxy
  - ForwardedHeaders__KnownNetworks__0=172.18.0.0/16     # or only this network
  - ForwardedHeaders__Enabled=false                      # or not at all

Listing any proxy or network replaces the private-network default. Without a proxy, devices on your LAN that reach the container through Docker's port mapping can appear as Docker's gateway (for example 172.20.0.1); on Unraid, give the container its own address (Network Type br0) to see each device's own address.

Upgrading

When a new image is published, pull it and restart the Vora container. On startup it detects any new EF Core migrations and applies them automatically before serving traffic; your /app/data volume and the Postgres data directory persist across upgrades. If a migration fails, the container exits without serving traffic — check the logs, fix the issue, and restart. Background tasks that were queued or running when the container stopped (a library scan, a subtitle pass, thumbnails) are queued again on startup instead of being lost.

Bootstrapping plugin API keys from environment variables

You can supply plugin API keys (and any other plugin setting) as environment variables in your docker run / docker-compose.yml. On startup Vora reads them, validates that the plugin and setting key both exist, and writes the value into the database — but only when the row is empty. Once a value lives in the database, the seeder leaves it alone so changes you make later through the admin UI are preserved across container restarts.

Format

Vora__PluginSettings__<pluginId>__<settingKey>=<value>

The double underscores are the standard .NET configuration separator; they map to the Vora:PluginSettings:<pluginId>:<settingKey> config path inside the app. The <pluginId> matches the plugin's internal id (see the table below), and <settingKey> is one of the setting keys that plugin defines.

Every plugin also responds to a special is_enabled key, so you can enable or disable a plugin from compose:

Vora__PluginSettings__openai_recommendations__is_enabled=true

What gets seeded, what doesn't

The seeder runs once per container start, after database migrations and before workers come up. For each environment variable it sees, it:

  1. Verifies the plugin exists. If <pluginId> doesn't match an installed plugin, the variable is skipped with a warning in the logs: WARN Plugin settings environment variable references plugin 'foo', but no plugin with that id is installed — skipping.
  2. Verifies the setting key exists. If <settingKey> isn't a recognized setting for that plugin (and isn't is_enabled), it's skipped with: WARN Plugin 'tmdb_metadata' has no setting named 'bogus_key' — skipping seed value.
  3. Checks the database. If the setting already has a non-empty value in the database, the env var is ignored — admin UI edits win. The seed only fires when the row is missing or blank.
  4. Redacts values in logs. The seeder logs which keys it wrote (fanart_artwork.api_key, tmdb_metadata.api_key, …) but never the values themselves, so API keys never end up in your log files or the in-app log viewer.

Plugins and their settings

The table below lists every plugin shipped with Vora and the settings it accepts. Every plugin also supports is_enabled (true / false) in addition to the keys shown.

Plugin id Plugin name Settings
tmdb_metadata The Movie Database (TMDB) api_key
tmdb_discovery TMDB Discovery Engine discovery_region, discovery_language
tmdb_artwork TMDB Artwork —
tvdb_metadata The TV Database (TVDB) api_key, subscriber_pin
tvdb_artwork TVDB Artwork —
omdb_imdb OMDb — IMDb Ratings api_key
fanart_artwork Fanart.tv Artwork api_key
fanart_music_artwork Fanart.tv Music Artwork —
mediux_artwork MediUX Artwork api_key
theaudiodb_artwork TheAudioDB Artwork api_key
musicbrainz_artwork MusicBrainz Artwork —
mal_artwork MyAnimeList Artwork client_id
mal_discovery MyAnimeList Discovery Engine —
lastfm_listening Last.fm Scrobbling api_key, api_secret
genius_lyrics Genius Lyrics access_token
lrclib_lyrics LRClib Lyrics —
serpapi_theater SerpApi Google Showtimes api_key, default_location, max_theaters, auto_showtimes
radarr_calendar Radarr Calendar — (reads from Request Servers tagged "Use for Release Calendar")
radarr_requester Radarr — (uses Request Servers admin page)
sonarr_calendar Sonarr Calendar — (reads from Request Servers tagged "Use for Release Calendar")
sonarr_requester Sonarr — (uses Request Servers admin page)
trakt_collection_sync Trakt.tv Lists client_id
trakt_chronology Trakt.tv Community Lists —
mdblist_collection_sync MDbList.com api_key
mdblist_chronology MDbList.com Timelines —
imdb_collection_sync IMDb Public Lists —
imdb_chronology IMDB Community Lists —
itunes_podcast_discovery iTunes Podcast Discovery —
opensubtitles_search OpenSubtitles api_key, auth_mode, username, password, default_languages
openai_recommendations AI Smart Recommendations (holds the AI connection for every AI feature) base_url, api_key, chat_model, collections_model, music_playlists_model, embedding_model, schedule_time, monthly_token_limit
local_imagesharp_overlays Vora Native Overlays enable_schedule, schedule_time
local_metadata Local Assets (NFO & Images) —
local_artwork Local Assets Artwork —
local_recommendations Vora Local Recommendations —
local_calendar Vora Local Calendar —
Vora_scanner Vora Standard Scanner —
polling_watcher Polling Watcher —
native_watcher Native OS Watcher —

A note on the TVDB key. TVDB v4 issues API keys per project, not per person — register your own at thetvdb.com/api-information. Vora ships no key of its own, so each install uses the one its owner registered, and nobody shares a rate limit. There are two kinds:

  • A licensed key authenticates on its own. Set api_key and leave subscriber_pin empty.
  • A user-supported (free) key also needs the PIN of a TVDB subscriber, shown on your account's subscription page. Set both.

If TVDB rejects a key that looks correct, a missing PIN is the usual reason — Test Connection on the plugin page says so explicitly.

Full docker-compose example

A realistic environment block prefilling the common third-party provider keys:

    environment:
      ASPNETCORE_HTTP_PORTS: 8080
      ConnectionStrings__DefaultConnection: "Host=postgres;Port=5432;Database=vora;Username=vora;Password=change-me"
      Jwt__SecretKey: "REPLACE_WITH_A_LONG_RANDOM_STRING"

      # Storage
      StoragePaths__CustomArtwork: /app/data/custom_artwork
      StoragePaths__OriginalArtworkCache: /app/data/original_artwork_cache
      StoragePaths__EpgCache: /app/data/iptv/epg_cache
      StoragePaths__IptvDvr: /app/data/iptv/dvr
      StoragePaths__UserImages: /app/data/users
      StoragePaths__Plugins: /app/data/plugins
      StoragePaths__Subtitles: /app/data/subtitles
      StoragePaths__VideoThumbnails: /app/data/video-thumbnails
      StoragePaths__Logs: /app/data/logs
      StoragePaths__Backups: /app/data/backups
      StoragePaths__DataProtection: /app/data/dp-keys

      # Metadata + artwork
      Vora__PluginSettings__tmdb_metadata__api_key: "YOUR_TMDB_API_KEY"
      Vora__PluginSettings__tvdb_metadata__api_key: "YOUR_TVDB_API_KEY"
      # Only for a user-supported (free) TVDB key; a licensed key needs no PIN.
      # Vora__PluginSettings__tvdb_metadata__subscriber_pin: "YOUR_TVDB_SUBSCRIBER_PIN"
      Vora__PluginSettings__omdb_imdb__api_key: "YOUR_OMDB_API_KEY"
      Vora__PluginSettings__fanart_artwork__api_key: "YOUR_FANART_KEY"
      Vora__PluginSettings__mediux_artwork__api_key: "YOUR_MEDIUX_KEY"
      Vora__PluginSettings__theaudiodb_artwork__api_key: "YOUR_AUDIODB_KEY"
      Vora__PluginSettings__mal_artwork__client_id: "YOUR_MAL_CLIENT_ID"

      # Discovery tuning
      Vora__PluginSettings__tmdb_discovery__discovery_region: "US"
      Vora__PluginSettings__tmdb_discovery__discovery_language: "en-US"

      # Lyrics + scrobbling
      Vora__PluginSettings__lastfm_listening__api_key: "YOUR_LASTFM_KEY"
      Vora__PluginSettings__lastfm_listening__api_secret: "YOUR_LASTFM_SECRET"
      Vora__PluginSettings__genius_lyrics__access_token: "YOUR_GENIUS_TOKEN"

      # Subtitle search (Find Subtitles). auth_mode is "apikey" (default) or
      # "account"; username/password are only read in account mode, and a blank
      # pair falls back to the anonymous quota with a warning rather than failing.
      Vora__PluginSettings__opensubtitles_search__api_key: "YOUR_OPENSUBTITLES_KEY"
      Vora__PluginSettings__opensubtitles_search__auth_mode: "account"
      Vora__PluginSettings__opensubtitles_search__username: "YOUR_OPENSUBTITLES_USERNAME"
      Vora__PluginSettings__opensubtitles_search__password: "YOUR_OPENSUBTITLES_PASSWORD"
      Vora__PluginSettings__opensubtitles_search__default_languages: "en,es"

      # Movie showtimes
      Vora__PluginSettings__serpapi_theater__api_key: "YOUR_SERPAPI_KEY"
      Vora__PluginSettings__serpapi_theater__default_location: "90210"
      Vora__PluginSettings__serpapi_theater__max_theaters: "10"
      Vora__PluginSettings__serpapi_theater__auto_showtimes: "true"

      # Trakt / MDbList list sync
      Vora__PluginSettings__trakt_collection_sync__client_id: "YOUR_TRAKT_CLIENT_ID"
      Vora__PluginSettings__mdblist_collection_sync__api_key: "YOUR_MDBLIST_KEY"

      # AI features (opt-in). OpenAI needs only the key; the rest are its defaults.
      Vora__PluginSettings__openai_recommendations__is_enabled: "true"
      Vora__PluginSettings__openai_recommendations__api_key: "YOUR_OPENAI_KEY"
      Vora__PluginSettings__openai_recommendations__chat_model: "gpt-4o-mini"
      Vora__PluginSettings__openai_recommendations__schedule_time: "02:00"
      # A model you run yourself instead (Ollama shown): no key, and name the models.
      # Vora__PluginSettings__openai_recommendations__base_url: "http://host.docker.internal:11434/v1"
      # Vora__PluginSettings__openai_recommendations__chat_model: "llama3.1"
      # Vora__PluginSettings__openai_recommendations__embedding_model: "nomic-embed-text"

      # Local poster overlays
      Vora__PluginSettings__local_imagesharp_overlays__enable_schedule: "true"
      Vora__PluginSettings__local_imagesharp_overlays__schedule_time: "03:00"

Only set the keys you actually use — the seeder simply does nothing for plugins you don't reference. If you later add a new key to your compose file and rebuild, it will be picked up on the next start provided the database row is still empty for that key. If you've already saved a value through the admin UI, you can clear it in the UI to let the env var take effect on the next start, or just continue to manage it through the UI from then on.

Poster overlays

Vora can add badges to your posters and episode thumbnails: resolution (4K, HDR, Dolby Vision…), audio codec, content rating, edition (Director's Cut, Extended…), a post-credits "stinger" tag, and a cluster of ratings. Design the layout in Admin → Poster Overlays, with a template each for movie, TV show and season posters (2:3) and episode thumbnails (16:9). Vora applies it after a library is scanned and analysed, and can also run on a schedule through the Vora Native Overlays plugin (local_imagesharp_overlays: enable_schedule, schedule_time). Deleting a template puts the posters back as they were. See docs/artwork-image-cache.md for how it works.

Thanks to the Kometa team

The overlay badge images Vora uses come from the Kometa project and are used with the Kometa team's permission. A big thank you to the whole Kometa team for their work and for letting Vora use it, and a special thanks to Sohjiro and Bullmoose.

Learn more about Kometa at https://kometa.wiki/.

Versions and releases

Vora follows semantic versioning. Released images are published to GHCR as ghcr.io/axufuris/vora-media-server:<version>.

  • Stable releases — 1.2.3, plus the rolling 1.2, 1 and latest tags.
  • Pre-releases — 1.1.0-beta.1 and friends. A GitHub release marked as a pre-release never moves latest or the rolling tags, so latest always points at the newest stable build. Pin the exact tag to run a beta.
  • QA builds — every push to main publishes :qa and :qa-<short-sha>. Not for production.

From 1.0, breaking changes (schema, endpoints, plugin contracts) only land in a major release; minor releases add features and patch releases fix bugs. Read the release notes before upgrading.

The running server reports its own build at GET /api/system/version, and the admin sidebar shows it at the bottom. Include that version in any bug report.

Cutting a release (maintainers)

  1. Tag the commit: git tag v1.0.0 && git push origin v1.0.0.
  2. Publish a GitHub release for that tag, ticking Set as a pre-release for anything that isn't stable.
  3. deploy-prod.yml then runs the test suite, builds the image with the tag baked in as its version, and pushes it to GHCR.

The version comes from the tag, not from a file in the tree: the workflow passes it to the build, and Directory.Build.props only supplies the fallback used by local builds.

Building in Release needs a Six Labors licence for ImageSharp. The workflows read it from the SIXLABORS_LICENSE_KEY secret; locally, put sixlabors.lic at the repo root (it is gitignored). See docs/architecture.md.

Documentation

Project documentation lives under docs/. Highlights:

License

Vora is released under the GNU Affero General Public License v3.0. See LICENSE for the full text.

AGPL-3.0 means you are free to use, study, modify, and distribute Vora, including in commercial settings — but if you run a modified version that interacts with users over a network, you must make the modified source code available to those users under the same license.

Trademark

"Vora" and the Vora logo are trademarks of Andreas (Andy) Xufuris.

The AGPL-3.0 license grants you broad rights to use, modify, and redistribute the Vora source code, but it does not grant any right to use the Vora name, logo, or other brand assets. If you fork this project or build a derivative work, you must use a different name and visual identity. You may state factually that your project is "based on Vora" or "a fork of Vora," but you may not present your fork as Vora itself or use the Vora marks in a way that suggests endorsement.

Use of the Vora name and marks in any commercial context — including hosted services, distributions, or merchandise — requires prior written permission.

See TRADEMARK.md for the full trademark policy.

About

Vora Media Server backend system, Admin Interface, and Client Web Interface

Resources

Security policy

Stars

12 stars

Watchers

0 watching

Forks

Releases

Packages

Used by

Contributors

Languages