Download and install

The server is delivered as a ready-made container image. You need Docker, a folder for the server data and a folder with your media. A compose file does the rest in a few minutes.

Quick start with Docker Compose

Pick the version, copy the file, change two lines and start. The same works on most Linux machines and NAS units with Docker. Steps specific to your hardware are further down.

Coming soon

The server container image has not been released yet, so there is nothing to download right now. Quick start, versions and a ready example will appear here as soon as the first version is out. The hardware guides below can be read already.

Versions

Every release with date and changes. Release candidates (rc) are hidden by default, and latest never points at a release candidate.

The first version has not been released yet. The list of versions and changes will appear here.

Requirements

Machine: 64-bit x86 (Intel or AMD) or 64-bit ARM (arm64). 32-bit systems are not supported.
Docker: Docker Engine 20.10 or newer with Compose v2, or Docker Desktop. Podman has not been tried.
Memory: The server uses under 100 MB at rest with a small library. Count on 1 GB free while scanning and transcoding.
Space: The image takes about 650 MB unpacked. The data folder grows with the number of titles and images, and previews and transcoding use temporary space.
Network: A fixed address for the machine. TCP 8420 and UDP 7421 must be open on the local network. mDNS (UDP 5353) is used for discovery.
Media: Any folder the machine can read. It is mounted read-only, and the server never changes your files.
Transcoding: A small NAS without a graphics device can play most things directly, but cannot transcode 1080p HEVC. See hardware transcoding below.

Update and roll back

The server never updates itself. The administration tells you when a newer version exists, and you update when it suits you.

Make a backup under Backup in the administration, or copy the data folder.
If the compose file says latest: run the two commands below. If you use a fixed version, change the version in the file first.
The database is upgraded automatically at start-up, and a copy is saved under data/backups first.
Check the version under Overview in the administration, or with the command below.

Roll back

Put the old version in the compose file and run the commands again. A server cannot open a database that has been upgraded by a newer version. If the database has been upgraded, first restore the backup you made before the update (Backup in the administration, or the copy in data/backups).

The update check fetches a small file from this site (/api/v1/releases/latest.json) at most once a day and only compares the version number. Nothing about you or your media is sent, only a User-Agent with your version. You can switch the check off or change the address under Settings.

Update

docker compose pull
docker compose up -d

Roll back to a specific version

# change the tag in docker-compose.yml to the old version, for example
# image: ghcr.io/themsn/nielix:0.2.0
docker compose pull
docker compose up -d

See which version is running

docker exec nielix nielix --version

Guides for your hardware

Each guide has a ready example and the steps specific to that platform. All use the same image and the same settings: port 8420, data in /data, media read-only in /media and host networking.

The examples use the image ghcr.io/themsn/nielix, which only exists once the first version is released.

Tested means the developer has run it. Not tested means the guide was written from the vendor documentation and has not been tried on that hardware. Details may differ, especially menu names, which change between versions.

Docker Compose on Linux

Tried? Tested

The simplest way. Works on Debian, Ubuntu, Fedora and other distributions with Docker.

Tested by the developer with Docker Compose on Linux.

Install Docker Engine with the Compose plugin following your distribution guide, or with the commands below on Debian and Ubuntu.
Make a folder, for example /opt/nielix, and put the compose file in it. Docker creates the data folder as root on first start.
Start with docker compose up -d and open the administration on port 8420.
Open the ports in the firewall if you have one: TCP 8420 and UDP 7421.
If you do not want to run as root, set user in the compose file and give the folder to the same user (the command below). This has been tested.

The container must use host networking. Without it the TV app cannot find the server on its own, and the server writes a warning in the log.
If the media files are on a network drive, mount it on the host first and point the compose file at the mount point.

docker-compose.yml

services:
  nielix:
    image: ghcr.io/themsn/nielix:latest
    container_name: nielix
    # host networking, so apps can find the server on their own
    network_mode: host
    environment:
      TZ: Europe/Copenhagen   # CHANGE: your time zone
      NIELIX_ADDR: ":8420"
      NIELIX_NAME: Nielix   # the name devices see
      NIELIX_MEDIA_ROOTS: /media
    volumes:
      - ./data:/data   # database, images and backups: back up this folder
      - /path/to/your/media:/media:ro   # CHANGE: the folder with your films and series (:ro = read-only)
    restart: unless-stopped

Or with docker run

docker run -d --name nielix --restart unless-stopped \
  --network host \
  -e TZ=Europe/Copenhagen \
  -e NIELIX_MEDIA_ROOTS=/media \
  -v "$PWD/data:/data" \
  -v /path/to/your/media:/media:ro \
  ghcr.io/themsn/nielix:latest

Install Docker (Debian, Ubuntu, Raspberry Pi OS)

curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker "$USER"
# log out and in again so the group applies
docker compose version

Open the ports in a firewall (ufw)

sudo ufw allow 8420/tcp
sudo ufw allow 7421/udp
sudo ufw allow 5353/udp

Permissions for the data folder

sudo chown -R 1000:1000 ./data
# and in docker-compose.yml:
#   user: "1000:1000"

Synology (DSM 7.2 and newer)

Tried? Partly tested

Container Manager is Synology's Docker. Older DSM (7.0 and 7.1) calls the package Docker, and the steps are the same.

Partly tested: the server has run as a container with host networking and hardware transcoding on an Intel-based Synology, started from the command line. The Container Manager steps are written from the documentation and have not been tried.

Install Container Manager from Package Center.
Make the folder nielix/data in the shared folder docker in File Station. Your media is in another shared folder, for example video.
Open Container Manager, Project, Create. Name the project nielix, choose the folder docker/nielix as the path and "Create docker-compose.yml". Paste the example below.
Change the path to your media (for example /volume1/video) and the time zone. Press Next and Done, and the container is pulled and started.
Open TCP 8420 and UDP 7421 under Control Panel, Security, Firewall, if the firewall is on.
Open http://<NAS address>:8420/admin/ and follow the wizard.

Host networking is required. In projects it is network_mode: host in the file. In the Containers wizard the option is called "Use the same network as Docker host".
Folders: paths on the NAS start with /volume1 (or /volume2 and so on). The server runs as root inside the container, so it can read most shared folders. If access is denied, check the folder permissions and any ACL.
Hardware transcoding only works on models with an Intel processor with integrated graphics, where /dev/dri exists. Find the render group id with ls -ln /dev/dri and getent group, and set it under group_add (937 is an example, not a promise). After a DSM update the permissions on /dev/dri may have been reset, so check again if transcoding suddenly falls back to the processor.
Update by opening the project and choosing Action, Build. If the image is latest, the newest one is pulled. Alternatively over SSH with docker compose pull and up -d.
DSM pitfalls: the time zone is UTC if TZ is missing. Put the data on a volume with enough space, and previews can take a lot if you turn them on.

docker-compose.yml for Synology

services:
  nielix:
    image: ghcr.io/themsn/nielix:latest
    container_name: nielix
    # host networking, so apps can find the server on their own
    network_mode: host
    environment:
      TZ: Europe/Copenhagen   # CHANGE: your time zone
      NIELIX_ADDR: ":8420"
      NIELIX_NAME: Nielix   # the name devices see
      NIELIX_MEDIA_ROOTS: /media
    volumes:
      - /volume1/docker/nielix/data:/data   # database, images and backups: back up this folder
      - /volume1/video:/media:ro   # CHANGE: the folder with your films and series (:ro = read-only)
    restart: unless-stopped

QNAP (Container Station)

Tried? Not tested

Container Station 3 can create an application directly from a compose file.

Not tested on QNAP. Written from the Container Station 3 documentation.

Install Container Station from App Center.
Make the folder Container/nielix/data in File Station (the shared folder Container is created by Container Station).
Open Container Station, Applications, Create. Name the application nielix and paste the example below as YAML.
Change the path to your media (for example /share/Multimedia) and the time zone. Press Create.
Open TCP 8420 and UDP 7421 in the QTS firewall if it is on, and open the administration on port 8420.

Host networking: network_mode: host in the file gives the container the NAS own network address, so apps can find the server.
Paths start with /share/ on QNAP. The media folder must be readable by the user running the container.
Hardware transcoding needs a QNAP with an Intel processor with integrated graphics. Give the container /dev/dri as shown under hardware transcoding.

docker-compose.yml for QNAP

services:
  nielix:
    image: ghcr.io/themsn/nielix:latest
    container_name: nielix
    # host networking, so apps can find the server on their own
    network_mode: host
    environment:
      TZ: Europe/Copenhagen   # CHANGE: your time zone
      NIELIX_ADDR: ":8420"
      NIELIX_NAME: Nielix   # the name devices see
      NIELIX_MEDIA_ROOTS: /media
    volumes:
      - /share/Container/nielix/data:/data   # database, images and backups: back up this folder
      - /share/Multimedia:/media:ro   # CHANGE: the folder with your films and series (:ro = read-only)
    restart: unless-stopped

Unraid

Tried? Not tested

On Unraid you set the container up with the fields in the Docker tab. If you have the Compose Manager plugin you can use the compose file instead.

Not tested on Unraid. Written from the Unraid documentation of the Docker tab.

Open the Docker tab and press Add Container.
Name: nielix. Repository: ghcr.io/themsn/nielix:latest (or a fixed version). Network Type: Host.
Press Add another Path, Port, Variable, Label or Device. Path: Container Path /data, Host Path /mnt/user/appdata/nielix, Access Mode Read/Write.
Another Path: Container Path /media, Host Path the share with your media (for example /mnt/user/media), Access Mode Read Only.
Variable: TZ with your time zone, and NIELIX_MEDIA_ROOTS with the value /media.
Press Apply. Turn on Autostart for the container, and open the administration on port 8420.

Hardware transcoding: add a Device with the value /dev/dri, and under Extra Parameters set --group-add=<gid> with the group id of the render group on your Unraid.
Update with Check for Updates on the Docker tab. For a fixed version, change the tag in Repository.
Compose Manager: put the example below in a new stack.

docker-compose.yml for Unraid (Compose Manager)

services:
  nielix:
    image: ghcr.io/themsn/nielix:latest
    container_name: nielix
    # host networking, so apps can find the server on their own
    network_mode: host
    environment:
      TZ: Europe/Copenhagen   # CHANGE: your time zone
      NIELIX_ADDR: ":8420"
      NIELIX_NAME: Nielix   # the name devices see
      NIELIX_MEDIA_ROOTS: /media
    volumes:
      - /mnt/user/appdata/nielix:/data   # database, images and backups: back up this folder
      - /mnt/user/media:/media:ro   # CHANGE: the folder with your films and series (:ro = read-only)
    restart: unless-stopped

TrueNAS SCALE (custom app)

Tried? Not tested

TrueNAS SCALE can run a docker image as a custom app. From version 24.10 you can paste a compose file directly.

Not tested on TrueNAS. Written from the custom app documentation. Menus change between releases.

Make a dataset for the app data (for example apps/nielix) and make sure your media dataset can be read.
Open Apps, Discover Apps, Custom App. Choose "Install via YAML" and paste the example below.
Change the paths to your datasets (/mnt/<pool>/...) and the time zone.
Older releases have a form instead: image ghcr.io/themsn/nielix, tag, "Host Network" turned on, two Host Path storages (/data read and write, /media read-only) and the environment variables from the example.
Open TCP 8420 and UDP 7421 if you use a firewall, and open the administration on port 8420.

Host networking is required for the TV app to find the server on its own.
Permissions: the container runs as root and reads the media dataset unless it is locked to one user with an ACL that excludes root.
Graphics: give the app an Intel or AMD device under Resources if your release offers it. See hardware transcoding for the settings.

YAML for a custom app

services:
  nielix:
    image: ghcr.io/themsn/nielix:latest
    container_name: nielix
    # host networking, so apps can find the server on their own
    network_mode: host
    environment:
      TZ: Europe/Copenhagen   # CHANGE: your time zone
      NIELIX_ADDR: ":8420"
      NIELIX_NAME: Nielix   # the name devices see
      NIELIX_MEDIA_ROOTS: /media
    volumes:
      - /mnt/pool/apps/nielix/data:/data   # database, images and backups: back up this folder
      - /mnt/pool/media:/media:ro   # CHANGE: the folder with your films and series (:ro = read-only)
    restart: unless-stopped

Raspberry Pi and other ARM machines

Tried? Not tested

The image exists for 64-bit ARM. Use a Raspberry Pi 4 or 5 with 64-bit Raspberry Pi OS (arm64). 32-bit systems and the Raspberry Pi Zero and 1 are not supported.

Not tested on a Raspberry Pi. The ARM image (arm64) is built but has not been run on real ARM hardware.

Check that the system is 64-bit: the command uname -m must say aarch64.
Install Docker with the commands below.
Put the data folder on an SSD or USB disk, not on the SD card. The server database writes often, and SD cards wear out.
Mount the disk with your media permanently in /etc/fstab, and point the compose file at the mount point.
Start with docker compose up -d and open the administration on port 8420.

Transcoding: a Raspberry Pi has no hardware transcoding that works in Nielix, and the processor is too slow for 1080p HEVC. Use direct play (apps and screens that can decode the files themselves). Set NIELIX_HWACCEL to none to avoid attempts.
The first scan of a large library takes a long time on a Pi. Turn previews off until the scan is done.
Other ARM machines (for example an ARM-based NAS) follow the same guide as long as they run 64-bit Linux with Docker.

Install Docker (Debian, Ubuntu, Raspberry Pi OS)

curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker "$USER"
# log out and in again so the group applies
docker compose version

docker-compose.yml for Raspberry Pi

services:
  nielix:
    image: ghcr.io/themsn/nielix:latest
    container_name: nielix
    # host networking, so apps can find the server on their own
    network_mode: host
    environment:
      TZ: Europe/Copenhagen   # CHANGE: your time zone
      NIELIX_ADDR: ":8420"
      NIELIX_NAME: Nielix   # the name devices see
      NIELIX_MEDIA_ROOTS: /media
      NIELIX_HWACCEL: none
    volumes:
      - /mnt/ssd/nielix/data:/data   # database, images and backups: back up this folder
      - /mnt/media:/media:ro   # CHANGE: the folder with your films and series (:ro = read-only)
    restart: unless-stopped

Mount an external disk with media (example)

lsblk -f    # find the UUID of the disk
sudo mkdir -p /mnt/media
echo "UUID=<uuid>  /mnt/media  ext4  defaults,nofail,ro  0  2" | sudo tee -a /etc/fstab
sudo mount -a

Proxmox (VM or LXC with Docker)

Tried? Not tested

The safest way is a small virtual machine with Debian or Ubuntu and Docker. To save resources, Docker can run in an LXC container.

Not tested on Proxmox. Written from the Proxmox documentation. Docker in LXC is not an officially recommended setup from Proxmox.

VM: create a Debian or Ubuntu VM with networking on your bridge (vmbr0), install Docker as under Linux and use the compose file. The VM gets its own address on your network, so host networking works as on a real machine.
LXC: create a Debian or Ubuntu container, turn on Nesting and keyctl under Features, and install Docker in it. Use a privileged container if you want it simple, or an unprivileged one with the necessary settings.
Media: make the media storage available in the LXC with a bind mount (mp0 in the configuration below, with ro=1), or mount a network drive in the VM.
Start with docker compose up -d, and open the administration on port 8420.

Graphics for LXC: pass /dev/dri/renderD128 in with dev0 (see the configuration below) and set gid to the id of the render group inside the container. For a VM it needs PCI passthrough, which is a bigger task and depends on your hardware.
Take a snapshot of the VM or LXC container before an update, on top of the Nielix backup.

docker-compose.yml in an LXC or VM

services:
  nielix:
    image: ghcr.io/themsn/nielix:latest
    container_name: nielix
    # host networking, so apps can find the server on their own
    network_mode: host
    environment:
      TZ: Europe/Copenhagen   # CHANGE: your time zone
      NIELIX_ADDR: ":8420"
      NIELIX_NAME: Nielix   # the name devices see
      NIELIX_MEDIA_ROOTS: /media
    volumes:
      - /opt/nielix/data:/data   # database, images and backups: back up this folder
      - /media:/media:ro   # CHANGE: the folder with your films and series (:ro = read-only)
    restart: unless-stopped

Additions to the LXC configuration on the Proxmox host

# /etc/pve/lxc/<id>.conf
features: nesting=1,keyctl=1
mp0: /mnt/media,mp=/media,ro=1
# only for hardware transcoding: gid is the id of the render group inside the container
dev0: /dev/dri/renderD128,gid=104

Windows (Docker Desktop)

Tried? Not tested

Fine for trying Nielix out or for a machine that is on anyway. For round-the-clock use a NAS or a Linux machine is better.

Not tested on Windows. Written from the Docker Desktop documentation.

Install Docker Desktop with WSL 2 as the engine and start it.
Make a folder and put the compose file in it. The example uses a named volume for data, because SQLite is slow and fragile on a Windows folder.
Change the media path, for example C:/Users/you/Videos. Use forward slashes. The folder must be shared with Docker under Settings, Resources, File sharing, if you use Hyper-V.
Run docker compose up -d in the folder, and allow Docker in the Windows firewall when it asks.
Open http://localhost:8420/admin/. From other devices use the computer address, and in the TV app type the address with port 8420.

Host networking works differently: on Docker Desktop the container runs in a light virtual machine, so UDP discovery (broadcast and mDNS) does not reach your network. That is why the example uses port forwarding, and the apps need the server address typed in.
There is no hardware transcoding in Docker Desktop. The server uses the processor.
Set Docker Desktop to start at login, and adjust power settings so the computer does not sleep while someone is watching.

docker-compose.yml for Windows

services:
  nielix:
    image: ghcr.io/themsn/nielix:latest
    container_name: nielix
    # without host networking: apps cannot find the server on their own, type the address in the app
    ports:
      - "8420:8420"
    environment:
      TZ: Europe/Copenhagen   # CHANGE: your time zone
      NIELIX_ADDR: ":8420"
      NIELIX_NAME: Nielix   # the name devices see
      NIELIX_MEDIA_ROOTS: /media
    volumes:
      - nielix-data:/data   # database, images and backups: back up this folder
      - C:/Users/you/Videos:/media:ro   # CHANGE: the folder with your films and series (:ro = read-only)
    restart: unless-stopped

volumes:
  nielix-data:

macOS (Docker Desktop)

Tried? Not tested

Works on both Apple Silicon (uses the arm64 image) and Intel (amd64). As on Windows it is mostly for trying out.

Not tested on macOS. Written from the Docker Desktop documentation.

Install Docker Desktop for Mac and start it.
Make a folder and put the compose file in it.
Change the media path, for example /Users/you/Movies. Give Docker access to the folder under Settings, Resources, File sharing, and under Privacy and Security in macOS if the folder is in Documents, Desktop or on an external drive.
Run docker compose up -d in the folder and open http://localhost:8420/admin/.
From other devices use the Mac address. Type it with port 8420 in the TV app.

Host networking and automatic discovery do not work as on Linux, for the same reason as on Windows. Use the port forwarding in the example.
No hardware transcoding. The server does not use the Apple graphics accelerator.
Do not let the Mac sleep while the server needs to be available.

docker-compose.yml for macOS

services:
  nielix:
    image: ghcr.io/themsn/nielix:latest
    container_name: nielix
    # without host networking: apps cannot find the server on their own, type the address in the app
    ports:
      - "8420:8420"
    environment:
      TZ: Europe/Copenhagen   # CHANGE: your time zone
      NIELIX_ADDR: ":8420"
      NIELIX_NAME: Nielix   # the name devices see
      NIELIX_MEDIA_ROOTS: /media
    volumes:
      - nielix-data:/data   # database, images and backups: back up this folder
      - /Users/you/Movies:/media:ro   # CHANGE: the folder with your films and series (:ro = read-only)
    restart: unless-stopped

volumes:
  nielix-data:

Hardware transcoding

When a device cannot play a file directly, the server transcodes it to H.264 and AAC. That is heavy for a processor. The server can use the graphics device through VAAPI (Intel and AMD), Intel QSV or NVIDIA NVENC if the container is allowed to. Of these, only VAAPI on an Intel chip has been tried on real hardware by the developer.

Intel (VAAPI or QSV, integrated graphics)

Partly tested

Give the container /dev/dri and the render group. The image contains the drivers iHD (Intel from 8th generation) and i965 (older). The server picks VAAPI or QSV itself after a test encode at start-up, and you can choose in the administration. Tried by the developer on an Intel J4125 with VAAPI and two simultaneous streams (HEVC and H.264). QSV is built and unit-tested but not tried on real hardware, and not every Intel generation has been tried.

AMD (VAAPI)

Not tested

The same setup as Intel. The image contains the Mesa driver for AMD. Not tested on AMD hardware.

NVIDIA

Not tested

The server can transcode with NVENC, but it needs the NVIDIA Container Toolkit and an ffmpeg with NVENC support: the ffmpeg shipped in the image has no NVENC. Point to your own ffmpeg with NIELIX_FFMPEG. Built and unit-tested, but not tried on real NVIDIA hardware. Without it the server uses the processor.

How to do it

Find out whether the machine has /dev/dri: the command ls -l /dev/dri on the host shows card0 and renderD128 if it does.
Find the group id of the render group on the host: getent group render video. The number differs from machine to machine.
Use the example below: devices gives the graphics device, group_add gives the group, and NIELIX_HWACCEL can stay on auto.
Check that the graphics device is seen in the container with the command below, and see under Health in the administration that transcoding uses hardware.

What is not supported

NVIDIA NVENC with the ffmpeg shipped in the image (it has no NVENC), and NVDEC.
Apple VideoToolbox (macOS) and graphics in Docker Desktop on Windows and macOS.
Hardware encoders on Raspberry Pi and other ARM chips (V4L2 and similar).
AMD AMF as a separate method. AMD is only used through VAAPI.
Synology and QNAP models without Intel graphics (for example with an ARM processor), as they have no /dev/dri.

docker-compose.yml with Intel or AMD for transcoding

services:
  nielix:
    image: ghcr.io/themsn/nielix:latest
    container_name: nielix
    # host networking, so apps can find the server on their own
    network_mode: host
    environment:
      TZ: Europe/Copenhagen   # CHANGE: your time zone
      NIELIX_ADDR: ":8420"
      NIELIX_NAME: Nielix   # the name devices see
      NIELIX_MEDIA_ROOTS: /media
      NIELIX_HWACCEL: auto
    volumes:
      - ./data:/data   # database, images and backups: back up this folder
      - /path/to/your/media:/media:ro   # CHANGE: the folder with your films and series (:ro = read-only)
    devices:
      - /dev/dri:/dev/dri
    group_add:
      - "937"   # CHANGE: group id of the render group on the host (getent group render video)
    restart: unless-stopped

Check that the graphics device is seen in the container

docker exec nielix vainfo --display drm --device /dev/dri/renderD128

The Android TV app

The Android TV app is where you watch Nielix. It finds the server on its own on your network, or you type the server address with port 8420.

Google Play: the app will be published on Google Play when it is ready. It is not published yet, and this page will get a link when it is.

Manual installation (adb)

A signed APK for manual installation cannot be offered publicly yet. If you have been given an APK by us, install it from a computer on the same network as the TV box:

Turn on developer options on the TV box (Settings, About, tap Build number seven times) and turn on Network debugging or ADB debugging.
Connect: adb connect <TV box address>:5555
Install: adb install nielix.apk

Open item: a public APK download has not been set up yet.