diff --git a/.claude/settings.local.json b/.claude/settings.local.json
deleted file mode 100644
index 5de72aec..00000000
--- a/.claude/settings.local.json
+++ /dev/null
@@ -1,120 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "WebSearch",
-      "WebFetch(domain:doc.qt.io)",
-      "WebFetch(domain:forum.qt.io)",
-      "WebFetch(domain:github.com)",
-      "Bash(uv run ruff check:*)",
-      "Bash(uv run:*)",
-      "Bash(python:*)",
-      "Bash(git log:*)",
-      "Bash(git show:*)",
-      "Bash(git status:*)",
-      "Bash(git diff:*)",
-      "Bash(git blame:*)",
-      "Bash(git ls-files:*)",
-      "Bash(git ls-tree:*)",
-      "Bash(git rev-parse:*)",
-      "Bash(git reflog:*)",
-      "Bash(git describe:*)",
-      "Bash(git shortlog:*)",
-      "Bash(git stash list:*)",
-      "Bash(git cat-file:*)",
-      "Bash(git remote -v:*)",
-      "Bash(git config --get:*)",
-      "Bash(git config --list:*)",
-      "Bash(gh pr list:*)",
-      "Bash(gh pr view:*)",
-      "Bash(gh pr status:*)",
-      "Bash(gh pr checks:*)",
-      "Bash(gh pr diff:*)",
-      "Bash(gh issue list:*)",
-      "Bash(gh issue view:*)",
-      "Bash(gh issue status:*)",
-      "Bash(gh repo view:*)",
-      "Bash(gh repo list:*)",
-      "Bash(gh release list:*)",
-      "Bash(gh release view:*)",
-      "Bash(gh run list:*)",
-      "Bash(gh run view:*)",
-      "Bash(gh workflow list:*)",
-      "Bash(gh workflow view:*)",
-      "Bash(gh search:*)",
-      "Bash(gh status:*)",
-      "Bash(gh auth status:*)",
-      "Bash(gh label list:*)",
-      "Bash(gh gist list:*)",
-      "Bash(gh gist view:*)",
-      "Bash(gh cache list:*)",
-      "Bash(gh ruleset list:*)",
-      "Bash(gh ruleset view:*)",
-      "Bash(gh variable list:*)",
-      "Bash(gh secret list:*)",
-      "Bash(gh project list:*)",
-      "Bash(gh project view:*)",
-      "Bash(dir:*)",
-      "Bash(find:*)",
-      "Bash(findstr:*)",
-      "Bash(type:*)",
-      "Bash(where:*)",
-      "Bash(tree:*)",
-      "Bash(whoami:*)",
-      "Bash(hostname:*)",
-      "Bash(ver:*)",
-      "Bash(fc:*)",
-      "Bash(echo:*)",
-      "Bash(Get-Content:*)",
-      "Bash(Get-ChildItem:*)",
-      "Bash(Get-Item:*)",
-      "Bash(Get-ItemProperty:*)",
-      "Bash(Get-Location:*)",
-      "Bash(Get-Process:*)",
-      "Bash(Get-Command:*)",
-      "Bash(Get-Help:*)",
-      "Bash(Get-Date:*)",
-      "Bash(Get-Host:*)",
-      "Bash(Get-Module:*)",
-      "Bash(Get-Variable:*)",
-      "Bash(Get-Alias:*)",
-      "Bash(Get-Service:*)",
-      "Bash(Select-String:*)",
-      "Bash(Select-Object:*)",
-      "Bash(Where-Object:*)",
-      "Bash(Sort-Object:*)",
-      "Bash(Format-Table:*)",
-      "Bash(Format-List:*)",
-      "Bash(Measure-Object:*)",
-      "Bash(Compare-Object:*)",
-      "Bash(Test-Path:*)",
-      "Bash(Resolve-Path:*)",
-      "Bash(Split-Path:*)",
-      "Bash(Join-Path:*)",
-      "Bash(ls:*)",
-      "Bash(xargs:*)",
-      "WebFetch(domain:ffmpeg.org)",
-      "Bash(ffmpeg -h:*)",
-      "Bash(ffmpeg:*)",
-      "WebFetch(domain:gitlab.com)",
-      "WebFetch(domain:wiki.x266.mov)",
-      "WebFetch(domain:raw.githubusercontent.com)",
-      "Bash(grep:*)",
-      "WebFetch(domain:docs.rs)",
-      "WebFetch(domain:gist.github.com)",
-      "WebFetch(domain:manpages.debian.org)",
-      "WebFetch(domain:api.github.com)",
-      "WebFetch(domain:codecalamity.com)",
-      "WebFetch(domain:www.mail-archive.com)",
-      "WebFetch(domain:trac.ffmpeg.org)",
-      "WebFetch(domain:dev.to)",
-      "WebFetch(domain:www.ffmpeg.org)",
-      "WebFetch(domain:www.phoronix.com)",
-      "Bash(copy:*)",
-      "Bash(ffprobe:*)",
-      "Bash(gh api:*)",
-      "Bash(git:*)",
-      "WebFetch(domain:docs.nvidia.com)",
-      "Bash(gh discussion:*)"
-    ]
-  }
-}
diff --git a/.claude/skills/build-installer.md b/.claude/skills/build-installer.md
new file mode 100644
index 00000000..67d5479c
--- /dev/null
+++ b/.claude/skills/build-installer.md
@@ -0,0 +1,68 @@
+---
+description: Build the FastFlix installer, distribution, launcher, and uninstaller
+---
+
+# Building the FastFlix Installer & Distribution
+
+## Prerequisites
+
+- Go 1.22+ installed
+- `go-winres` installed (pinned): `go install github.com/tc-hib/go-winres@v0.3.3`, with `%GOPATH%\bin` on PATH
+- Python 3.13+ with `uv`
+- Internet access (first build downloads embeddable Python and wheels)
+
+`zstandard` is not a project dependency; run the script through `uv run --with zstandard`.
+
+## Full Build (everything from scratch)
+
+```bash
+uv run --with zstandard python scripts/build_distribution.py --archive --installer
+```
+
+This produces `dist/FastFlix_installer.exe`. The script:
+- Downloads the embeddable Python (version constant `DEFAULT_PYTHON_VERSION` in the script)
+- Builds a fresh FastFlix wheel (wipes `dist/wheels`, requires exactly one wheel)
+- Installs dependencies pinned from `uv.lock` for the bundled CPython 3.13 / win_amd64 (`--arch arm64` for ARM64)
+- Syncs `cmd/*/winres/winres.json` with `fastflix/version.py` (versions + copyright year)
+- Runs `go-winres make` in each `cmd/*` and builds `FastFlix.exe` + `uninstall.exe` (+ installer with `--installer`)
+  with `-X main.Version=... -X main.BuildDate=...`
+- Trims unused PySide6 modules (~527 MB savings), keeping third-party licence files
+- Creates `fastflix_dist.tar.zst`, copies `licenses.txt`, generates `terms_translations.json`
+
+Use `--archive` alone to stop before building the installer.
+
+## Manual rebuilds (after Go code changes)
+
+Run `go-winres make` in the `cmd/<name>` directory first (the `.syso` files are gitignored), then:
+
+```bash
+go build -ldflags="-s -w -X main.Version=6.3.0 -X main.BuildDate=2026-01-01" -o dist/FastFlix/FastFlix.exe ./cmd/launcher
+go build -ldflags="-s -w -H windowsgui -X main.Version=6.3.0" -o dist/FastFlix/uninstall.exe ./cmd/uninstaller
+go build -ldflags="-s -w -H windowsgui -X main.Version=6.3.0 -X main.BuildDate=2026-01-01" -o dist/FastFlix_installer.exe ./cmd/installer   # needs the archive
+```
+
+## Checks
+
+```bash
+GOOS=windows go vet ./...
+go test ./cmd/internal/...
+```
+
+## Important Notes
+
+- **Launcher**: Built WITHOUT `-H windowsgui` (needs console for logs); passes all arguments through to `python -m fastflix`
+- **Installer/Uninstaller**: Built WITH `-H windowsgui` (no console)
+- **Shared logic** (path safety, manifest-based removal, registry, self-delete batch) is in `cmd/internal/ffinstall`; never delete directories with `RemoveAll` on a registry-derived path without `ffinstall.SafeToRemove`
+- **Uninstall** removes only files listed by `install_manifest.txt` (top-level entries) and keeps user files like a portable `fastflix.yaml`
+- **DO NOT** use `CREATE_NO_WINDOW` flag on the launcher's child process - breaks FFmpeg pipe handles
+- **DO NOT** use `walk` or other Go GUI frameworks - they have `TTM_ADDTOOL` failures on modern Windows. Use raw Win32 API.
+- For `WM_DRAWITEM`-style lParam casts use `*(**T)(unsafe.Pointer(&lParam))` (keeps `go vet` clean)
+
+## Testing
+
+```bash
+dist/FastFlix/FastFlix.exe --version
+dist/FastFlix/FastFlix.exe --test
+dist/FastFlix_installer.exe
+"%LOCALAPPDATA%\Programs\FastFlix\uninstall.exe"
+```
diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
index ec21ab99..d13f108e 100644
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -96,41 +96,41 @@ jobs:
       run: |
         mkdir dist
         New-Item -Path Env: -Name VERSION -Value $(python.exe scripts\get_version.py)
-        New-Item -Path Env: -Name EXACT_VERSION -Value $(python.exe scripts\get_version.py exact)
-        New-Item -Path Env: -Name PRODUCT_VERSION -Value $(python.exe scripts\get_version.py nsis)
         echo "Building branch $env:GITHUB_REF - version $env:VERSION"
         echo "::set-env name=VERSION::$env:VERSION"
-        echo "::set-env name=EXACT_VERSION::$env:EXACT_VERSION"
-        echo "::set-env name=PRODUCT_VERSION::$env:PRODUCT_VERSION"
       env:
         ACTIONS_ALLOW_UNSECURE_COMMANDS: true
 
+    - name: Set up Go
+      uses: actions/setup-go@v5
+      with:
+        go-version: "1.24"
+        cache-dependency-path: go.sum
+
+    - name: Install go-winres (icon / manifest / version resources)
+      shell: bash
+      run: |
+        go install github.com/tc-hib/go-winres@v0.3.3
+        echo "$(go env GOPATH)/bin" >> "$GITHUB_PATH"
+
     - name: Install Python Dependencies
       run: uv sync --frozen
 
-    - name: Build single executable
+    # Builds python runtime + dependencies (pinned by uv.lock), runs go-winres for the launcher and
+    # uninstaller, builds FastFlix.exe + uninstall.exe, writes cmd/installer/fastflix_dist.tar.zst, then
+    # runs go-winres for the installer and builds dist\FastFlix_installer.exe with
+    # -ldflags "-s -w -H windowsgui -X main.Version=<fastflix/version.py> -X main.BuildDate=<today>".
+    - name: Build distribution and installer
       shell: cmd
-      run: uv run pyinstaller FastFlix_Windows_OneFile.spec
+      run: uv run --with zstandard python scripts\build_distribution.py --archive --installer
 
-    - name: Build installer executable
+    - name: Go vet
       shell: cmd
-      run: uv run pyinstaller FastFlix_Windows_Installer.spec
-
-#    - uses: skymatic/code-sign-action@v1
-#      with:
-#        certificate: '${{ secrets.CODE_CERT_B64 }}'
-#        password: '${{ secrets.CODE_CERT_PASS }}'
-#        certificatesha1: '${{ secrets.CODE_CERT_THUMB }}'
-#        description: 'FastFlix'
-#        timestampUrl: 'http://timestamp.sectigo.com'
-#        folder: 'dist\FastFlix'
-#        recursive: false
+      run: go vet ./...
 
-    - name: Package installer
+    - name: Go tests
       shell: cmd
-      run: |
-        makensis.exe /INPUTCHARSET UTF8 /DVERSION=${{ env.EXACT_VERSION }} /DPRODUCT_VERSION=${{ env.PRODUCT_VERSION }} FastFlix.nsi
-        move FastFlix_installer.exe dist\FastFlix_${{ env.VERSION }}_installer.exe
+      run: go test ./cmd/internal/...
 
 #    - uses: skymatic/code-sign-action@v1
 #      with:
@@ -140,29 +140,29 @@ jobs:
 #        description: 'FastFlix'
 #        timestampUrl: 'http://timestamp.sectigo.com'
 #        folder: 'dist'
-#        recursive: false
+#        recursive: true
 
-    - name: Test executable
+    - name: Test launcher
+      shell: cmd
       run: |
-        dist\FastFlix.exe --version
-        dist\FastFlix.exe --test
+        dist\FastFlix\FastFlix.exe --version
+        dist\FastFlix\FastFlix.exe --test
 
-    - name: Package single executable
+    - name: Package installer and portable archive
       shell: cmd
       run: |
-        move dist\*.exe .
-        move docs\build-licenses.txt LICENSE
+        move dist\FastFlix_installer.exe dist\FastFlix_${{ env.VERSION }}_installer.exe
+        copy docs\build-licenses.txt dist\FastFlix\LICENSE
+        7z a -mm=Deflate -mfb=258 -mpass=15 dist\FastFlix_${{ env.VERSION }}_win64.zip .\dist\FastFlix\*
 
-    - name: Upload standalone executable artifact
+    - name: Upload portable archive artifact
       uses: actions/upload-artifact@v4
       with:
         name: FastFlix_${{ env.VERSION }}_win64
-        path: |
-          FastFlix.exe
-          LICENSE
+        path: dist/FastFlix_${{ env.VERSION }}_win64.zip
 
     - name: Upload installer artifact
       uses: actions/upload-artifact@v4
       with:
         name: FastFlix_${{ env.VERSION }}_installer
-        path: FastFlix_${{ env.VERSION }}_installer.exe
+        path: dist/FastFlix_${{ env.VERSION }}_installer.exe
diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
index f45a8437..0e22c01f 100644
--- a/.github/workflows/test.yaml
+++ b/.github/workflows/test.yaml
@@ -48,4 +48,5 @@ jobs:
     - name: Run tests
       env:
         PYTEST_QT_API: pyside6
+        QT_QPA_PLATFORM: offscreen
       run: uv run pytest tests -v
diff --git a/.gitignore b/.gitignore
index 07eb55e2..c002adbd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -125,4 +125,13 @@ iso-639-3.*
 build-dir/
 benchmarking/
 
-./.claude/settings.local.json
+.claude/settings.local.json
+
+# Go installer build artifacts
+cmd/installer/fastflix_dist.*
+cmd/*/*.syso
+cmd/installer/licenses.txt
+cmd/installer/terms_translations.json
+
+# Build script cache (downloaded Python embeddable, get-pip.py)
+scripts/cache/
diff --git a/CHANGES b/CHANGES
index 407c2d1d..ec5abf6c 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,5 +1,125 @@
 # Changelog
 
+## Version 6.3.0
+
+* Adding #202 new video filters to the Advanced panel: vibrance, color temperature, curves presets, colorbalance presets, unsharp mask, deflicker, pad/letterbox, LUT3D file loading, and nlmeans_opencl GPU-accelerated denoise — with rigaya hardware encoder support for curves (--vpp-curves), unsharp (--vpp-unsharp), pad (--vpp-pad), LUT3D (--vpp-colorspace lut3d), and nlmeans_opencl (--vpp-nlmeans)
+* Adding #212 full source and output file path tooltip on hover for queue items, with responsive text eliding for long file names (thanks to bmcassagne)
+* Adding #344 lossless encoding option for AVC (x264), AV1 (AOM), VP9, and AV1 (SVT-AV1) encoders
+* Adding #377 #550 #694 gamma and hue options to the Equalizer in the Advanced panel (FFmpeg eq/hue filters for software encoders, --vpp-tweak for rigaya) (thanks to lincsat, DCNerds, and Patrick Isbendjian)
+* Adding #405 sharpen filter (CAS) to the Advanced panel (FFmpeg cas filter for software encoders, --vpp-unsharp for rigaya)
+* Adding #447 GOP length setting to the Advanced panel (FFmpeg -g, rigaya --gop-len) (thanks to colemar)
+* Adding #457 QSVEncC --tune parameter support (default, psnr, ssim, ms_ssim, vmaf, perceptual) for HEVC, AV1, and AVC encoders (thanks to Marco Ravich)
+* Adding #480 2-pass CRF encoding for the AOM AV1 encoder for improved quality (thanks to jimbow973)
+* Adding #498 deinterlace method and mode options (yadif, bwdif, w3fdif, estdif with send_frame/send_field modes) to the Advanced panel, with persistence in profiles
+* Adding #520 "Source" option for the output file extension, matching the output container to the source format for batch encoding mixed MKV/MP4 files (thanks to x9sim9)
+* Adding #523 drag and drop folder support in the Concatenation Builder (thanks to GokieKS)
+* Adding #526 -movflags +faststart toggle for MP4/MOV containers, enabled by default (thanks to Aria)
+* Adding #594 codec and codec+profile matching options for audio profile pattern matching, allowing users to distinguish between e.g. DTS-HD MA and regular DTS tracks (thanks to Damundai)
+* Adding #665 profile-level control for subtitle "default" and "forced" disposition flags with Keep Source, Clear All, and Set on First Track modes (thanks to legoleigh)
+* Adding #677 "Keep source loaded after adding to queue" setting to allow tweaking and re-queuing the same source without reloading (thanks to Mine181)
+* Adding #682 HE-AAC and HE-AAC v2 audio profile selection for the libfdk_aac codec, including in profile audio matching and for rigaya encoders (HE-AAC v2 falls back to HE-AAC for non-stereo output) (thanks to Augusto7743)
+* Adding Reverse Video option in the Advanced panel (applies FFmpeg reverse video filter and areverse audio filter for converted tracks, always seeking on the input side so trimmed segments stay aligned)
+* Adding rigaya encoder support for Equalizer (--vpp-tweak), Denoise (--vpp-nlmeans/knn/pmd), Deblock (--vpp-deblock), Output FPS (--vpp-fps), and Video Track Title — only Video Speed and Reverse Video remain unsupported
+* Adding #544 Download HDR10 Metadata button in Source Details tab for exporting mastering display and content light level data in x265-compatible format (thanks to yundebian918)
+* Adding structured table view to Source Details tab with grouped sections, human-readable value formatting, Download JSON export, and full path tooltips on source/output filename fields
+* Adding warning in Data & Attachments tab and reason text when tracks are incompatible with the output format (e.g. data streams in MKV)
+* Adding Go-based Windows installer, launcher and uninstaller using an embeddable Python distribution (per-user and all-users installs, Add/Remove Programs integration, upgrades from previous NSIS installs) replacing the PyInstaller and NSIS Windows builds, plus a portable zip release
+* Changing Advanced panel layout to use QGroupBox sections (Video Details, Frame Rate, Video Processing, Color & Appearance, Color, Output) with restoration filters separated from color correction filters
+* Fixing #766 FFmpeg and other external tools failing on Linux PyInstaller builds (e.g. AUR fastflix-bin) with library symbol errors due to inherited bundled `LD_LIBRARY_PATH` (thanks to anne-o-pixel)
+* Fixing #741 VideoToolbox HEVC and H264 encoders passing invalid numeric profile index instead of profile name, causing "incorrect parameters" errors on macOS (thanks to enaveso)
+* Fixing #560 queue items could not be removed while encoding — now allows removing non-running items and grays out unavailable controls (move, reload, load queue) during encoding (thanks to 54x1)
+* Fixing #736 thumbnail and crop preview generation failing with FFmpeg 8.0+ by adding `-update 1` flag required by the image2 muxer for single-image output (thanks to kliffgomel)
+* Fixing #738 conversion error with Google Pixel videos by disabling data stream mapping for Matroska containers which do not support data streams (attachments like fonts are still allowed) (thanks to Hankuuuu)
+* Fixing attachment streams (fonts, etc.) losing mimetype/filename metadata during conversion due to `-map_metadata -1` stripping per-stream tags required by the muxers
+* Fixing cover image metadata targeting wrong output stream when data/attachment tracks are present (FFmpeg places `-map` streams before `-attach` streams in output order)
+* Fixing data streams being auto-included by FFmpeg when encoding to MKV, causing "Only audio, video, and subtitles are supported" errors — now explicitly excludes unmapped data with `-dn` and rechecks compatibility when output format changes
+* Fixing #739 unable to add more than 1 video per session due to AttributeError when closing audio track widgets (thanks to mrdav1)
+* Fixing #130 auto-crop producing invalid crop rectangles for non-standard aspect ratios (4:3 FHD, 2.76:1 ultra-wide) due to independent dimension tracking across cropdetect frames and Python falsy-zero bug (thanks to hallmansm)
+* Fixing HDR tonemapping failing with zscale "no path between colorspaces" by passing complete source colorspace parameters (primaries, matrix, transfer) to the zscale filter, with fallback retry for crop previews when tonemapping still fails
+* Fixing bitrate combobox being unreadably small on x264 and x265 encoders — combo now sizes to fit its widest item
+* Fixing rigaya encoder pad/letterbox calculation ignoring crop dimensions due to incorrect type check
+* Fixing rigaya encoders (NVEncC, QSVEncC, VCEEncC) crashing with no output when data streams are copied to non-MKV containers — `--data-copy` and `--attachment-copy` are now only emitted for Matroska output
+* Fixing startup crash when queue file exists but is missing the 'queue' key
+* Fixing FFmpeg HEVC and AV1 NVENC bitrate mode failing with FFmpeg 8 due to removed `-2pass` option and unsupported `-pass` two-pass mode — now a single encode using NVENC `-multipass`
+* Fixing FFmpeg HEVC NVENC passing invalid `-spatial_aq` option instead of `-spatial-aq`
+* Fixing auto-detected interlaced sources having deinterlacing turned off by profile defaults on load and profile change
+* Fixing bwdif, w3fdif and estdif deinterlace send_frame mode doubling the frame rate (filters default to one frame per field)
+* Fixing duplicate queue entry ids and work folders when keeping the source loaded after adding to queue
+* Fixing custom resolution values such as `1280:-2` / `-1:720` disabling scaling, and auto-calculated dimensions rounding down instead of to the nearest multiple of 8
+* Fixing auto-crop being thrown off by fully black frames and over-cropping mixed letterbox/pillarbox samples by using the union of detected content per edge
+* Fixing x264 lossless failing when a profile other than high444 is selected, and SVT-AV1 / AOM lossless encodes still applying film grain and denoise
+* Fixing pad/letterbox being applied before rotation (FFmpeg and rigaya encoders)
+* Fixing duplicate `--vpp-colorspace` arguments when combining HDR to SDR with a 3D LUT on rigaya encoders
+* Fixing nlmeans_opencl denoise failing without HDR removal and in previews, and truncating 10-bit sources to 8-bit
+* Fixing data, attachment and cover stream metadata being written to the wrong output stream after toggling tracks or burning in subtitles
+* Fixing Copy encoder reversing converted audio when Reverse Video is enabled, and burned-in text subtitles playing forward over reversed video
+* Fixing GOP length of 0 producing all-intra encodes and being lost on reload
+* Fixing video speed and reverse warning dialogs popping up while loading videos, profiles or queue items
+* Fixing Data & Attachments track selection being lost after switching to an incompatible output format and back
+* Fixing Source Details tab leaving the HDR10 button visible after clearing the video, rendering tag text as HTML, and silently ignoring save errors
+* Fixing missing word wrap in yes/no dialogs, queue titles not eliding, and disabled toggle switches not looking disabled
+* Fixing missing and English-only translations for new strings
+* Adding SVT-AV1 tune options 3 (IQ), 4 (MS-SSIM) and 5 (VMAF) (IQ and MS-SSIM for AVIF), Variance Boost (strength and octile), temporal filtering, startup mini-gop size and quantization matrix (min/max) options to the SVT-AV1 encoder
+
+* Fixing config file being written non-atomically; it is now replaced atomically with a .bak kept, and a corrupt or truncated config falls back to the backup (or defaults, keeping the bad file aside) instead of preventing startup
+* Fixing a single invalid profile or wrongly-typed config value preventing FastFlix from starting
+* Fixing legacy fastflix.json upgrade setting the ffmpeg path from the ffprobe value
+* Fixing a single unreadable queue item discarding the entire saved queue; bad items are skipped and the original queue file is kept aside
+* Fixing queue file lock handling and replacing the queue file atomically on Windows, and cleaning up leftover temporary queue files
+* Fixing a corrupt history file being overwritten with an empty history (it is now moved aside to history.yaml.corrupt-<time> and a new history started, while a file that is only temporarily unreadable is left untouched), and history thumbnail deletion following paths outside the thumbnails folder
+* Fixing encodes killed by a signal (out of memory, crash) being reported as successful
+* Fixing cancel, pause and resume not affecting every process of a piped or shell-run command
+* Fixing Download FFmpeg latest from the version warning dialog raising an error
+* Fixing AMD (Advanced Micro Devices, ATI) GPUs not being detected, and GPU encoder downloads that fail or are cancelled never being retried
+* Fixing the encoder worker leaving ffmpeg running or hanging on exit after a crash or closing the GUI
+* Fixing HDR10+ detection checking the wrong stream and reading entire files
+* Fixing the FastFlix update check failing on unusual release tags and having its timeouts reversed
+* Fixing file paths with spaces near the start being altered in subtitle and LUT filters
+* Fixing FFmpeg, rigaya encoder and hdr10plus_tool downloads lacking timeouts and checksum verification, and picking the wrong FFmpeg build or version
+* Fixing concat list files resolving relative paths and escaped quotes incorrectly
+* Fixing the overwrite confirmation allowing Esc to overwrite an existing output file
+* Fixing the after-done action running when an encode is cancelled or paused
+* Fixing crop and large preview images not rendering (ffmpeg was run through a shell) and hanging without a timeout
+* Fixing drag and drop of non-file URLs and slow rebuilds and overlapping thumbnail generation while typing start, end or crop values
+* Fixing a hung FFmpeg thumbnail process blocking all later thumbnail generation (it now times out after 2 minutes)
+* Fixing deleting a duplicated audio track breaking the remaining audio tracks, and audio title edits rebuilding commands on every keystroke
+* Fixing HDR10+ extraction using a full CPU core while waiting, and post-encode validation hanging with no timeout
+* Fixing file paths being rendered as rich text in concat, multiple files and profile windows, and removing the unused HDR10+ Inject window
+* Fixing VCEEncC pre analysis (`--pa`) being passed as a single argument containing a space
+* Fixing invalid `--vpp-deblock` parameters on NVEncC, QSVEncC and VCEEncC
+* Fixing output frame rate using a non-existent `--vpp-fps` option; NVEncC now uses `--vpp-fruc`, QSVEncC and VCEEncC ignore it with a warning
+* Fixing HDR10 mastering display and max CLL metadata being written when tone mapping to SDR on rigaya encoders
+* Fixing NVEncC custom arguments being split on whitespace instead of shell quoting, and video stream id 0 being ignored on rigaya encoders
+* Fixing NVEncC AV1 emitting HEVC only `--tier`, and VCEEncC AV1 emitting H.264/HEVC only `--motion-est` and `--vbaq`
+* Fixing NVEncC profile, and VCEEncC HEVC/AV1 B frames being collected but never passed to the encoder
+* Fixing QSVEncC lookahead depth being passed with rate control modes that ignore it, and AV1 lookahead missing `--extbrc`
+* Fixing rigaya encoder detection finding no devices when the encoder prints warnings, and hanging on a stuck encoder
+* Adding NVEncC `--tune` option (hq, uhq, lowlatency, ultralowlatency, lossless) and NVEncC / QSVEncC / VCEEncC quality based VBR (`--qvbr`)
+* Fixing PGS (hdmv_pgs_subtitle) burn-in generating a text subtitles filter that fails; bitmap subtitles are now overlaid, and after tone mapping
+* Fixing bitmap subtitle tracks (PGS/VobSub) failing MP4/MOV encodes (they are now skipped) and -default_mode being passed to non-Matroska muxers
+* Fixing burn-in of the first subtitle track not renumbering later subtitle tracks, and external subtitle burn-in track lookup
+* Fixing audio conversion crashing on channel layouts such as 5.1.2, 7.1.4 and octagonal, unknown layouts being forced to stereo, and AC-3 quality bitrates exceeding the 640k limit
+* Fixing HDR tone mapping being applied after color grading filters, dimming burned-in bitmap subtitles, dropping to 8-bit for 10-bit targets, and not tagging the SDR output as bt709
+* Fixing invalid pad colors breaking the filter chain, quoted values and backslashes in custom start options being mangled on Windows, and eq being forced to per-frame evaluation
+* Fixing PGS OCR reporting failure when the .srt already exists, not handling ISO 639-2/B language codes (fre, ger, chi), and modifying the global PATH
+* Fixing VAAPI encoders passing the invalid `-low-power` option instead of `-low_power`
+* Fixing VAAPI scaling being silently dropped, and VAAPI filters (crop, rotate, scale, burn-in) now run on software frames before `hwupload` so sources the GPU cannot hardware-decode no longer fail at `hwdownload`
+* Adding 8-bit/10-bit selection for VAAPI HEVC and VP9 (nv12/p010 upload with Main10/Profile 2), and fixing VAAPI HDR to SDR tone mapping so it receives 10-bit p010 input
+* Fixing VAAPI ICQ/QVBR rate control to use `-global_quality`, avoiding incoherent rate control and bitrate combinations, and no longer emitting `-level auto`
+* Fixing removed NVENC presets and rate control modes (hp, hq, ll, lossless, vbr_hq, ...) in saved profiles and queues, they are now converted to the equivalent p1-p7 preset and tune
+* Adding NVENC multipass selection (disabled, qres, fullres) for HEVC bitrate encodes
+* Adding HEVC and AV1 NVENC temporal AQ, AQ strength, constant quality (CQ), temporal filter, lookahead level, split encode, weighted prediction, unidirectional B-frames and no scenecut options
+* Fixing AV1 NVENC AQ Strength showing the wrong value when loading a profile
+* Fixing HEVC in MP4, M4V and MOV not being tagged hvc1, which prevented playback in QuickTime, iOS and Safari (x265, NVENC, VAAPI and VideoToolbox)
+* Fixing VideoToolbox bitrate mode running a useless first pass (VideoToolbox ignores two-pass), it is now a single pass with an optional constant bit rate setting
+* Fixing HEVC VideoToolbox failing when the profile (Main/Main10) did not match the selected bit depth
+* Fixing VVC (libvvenc) two-pass encoding and bitrate caps failing at encoder init by using FFmpeg -pass/-passlogfile instead of pass/rcstatsfile/vbv-* keys in -vvenc-params
+* Fixing VP9 CRF encoding ignoring the Speed setting (and the fast first pass option) in single and two-pass modes
+* Fixing GIF encoding of HDR sources producing washed-out colors by tone mapping when Remove HDR is set, and dropping frames to the target FPS before scaling so GIF creation is faster
+* Fixing x265 two-pass stats file being written to the working directory instead of the FastFlix work path, and x265 HDR10 settings leaking into later rebuilds of the same video
+* Fixing HDR10 metadata (mastering display, max CLL) being dropped for 4:2:2 and 4:4:4 10/12-bit output in x265, x264, SVT-AV1, rav1e and VVC encoders
+* Adding HDR10 mastering display and content light level metadata for 10-bit AVC (x264) encodes
+
 ## Version 6.2.1
 
 * Fixing #529 window geometry and menu anchoring issues when displays are powered off/on or reconfigured during use (thanks to wiznillyp)
diff --git a/CLAUDE.md b/CLAUDE.md
index cb176a07..1ab95a67 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -29,8 +29,14 @@ uv run pytest tests/encoders/test_hevc_x265_command_builder.py -v
 # Run the application
 python -m fastflix
 
-# Build executables
-uv run pyinstaller FastFlix_Windows_OneFile.spec
+# Build Windows distribution + installer (Go-based, replaces PyInstaller). Needs Go and
+# go-winres (go install github.com/tc-hib/go-winres@v0.3.3) on PATH. The script syncs winres.json versions,
+# runs go-winres for each cmd/, builds FastFlix.exe + uninstall.exe, and injects Version/BuildDate via -ldflags.
+uv run --with zstandard python scripts/build_distribution.py --archive --installer   # -> dist/FastFlix_installer.exe
+uv run --with zstandard python scripts/build_distribution.py --archive               # dist + archive only
+GOOS=windows go vet ./... && go test ./cmd/internal/...                                # Go checks
+
+# Build Linux/macOS executables (still uses PyInstaller)
 uv run pyinstaller FastFlix_Nix_OneFile.spec
 ```
 
diff --git a/WINDOWS_BUILD.md b/WINDOWS_BUILD.md
index 8f46effa..1c1f779e 100644
--- a/WINDOWS_BUILD.md
+++ b/WINDOWS_BUILD.md
@@ -1,133 +1,176 @@
 # Building FastFlix on Windows
 
-This guide explains how to build FastFlix executables on Windows.
+This guide explains how to build the FastFlix Windows distribution, launcher, uninstaller and installer.
 
 ## Prerequisites
 
 1. **Python 3.13 or higher**
    - Download from [python.org](https://www.python.org/downloads/)
-   - Make sure to check "Add Python to PATH" during installation
 
-2. **Git** (to clone/update the repository)
-   - Download from [git-scm.com](https://git-scm.com/download/win)
+2. **Go 1.22 or higher**
+   - Download from [go.dev](https://go.dev/dl/)
+   - Needed for the launcher, installer, and uninstaller binaries
 
-## Build Steps
+3. **go-winres** (for embedding icons, manifests and version info) - pinned version
+   ```bash
+   go install github.com/tc-hib/go-winres@v0.3.3
+   ```
+   Make sure `%GOPATH%\bin` (usually `%USERPROFILE%\go\bin`) is on your `PATH`.
 
-### 1. Open Command Prompt or PowerShell
+4. **uv** (Python package manager; also used to pin the bundled dependencies to `uv.lock`)
+   ```bash
+   pip install uv
+   ```
 
-Navigate to where you want to clone/have the FastFlix repository:
+5. **Git** (to clone/update the repository)
 
-```bash
-cd C:\path\to\your\projects
-git clone https://github.com/cdgriffith/FastFlix.git
-cd FastFlix
-```
-
-Or if you already have it:
+## Quick Build (Full Installer)
 
 ```bash
 cd C:\path\to\FastFlix
-```
 
-### 2. Create and Activate Virtual Environment
+# Install Python dependencies
+uv sync --frozen
 
-```bash
-python -m venv venv
-venv\Scripts\activate
+# Build the distribution, the archive, all Go binaries and the installer in one go
+uv run --with zstandard python scripts/build_distribution.py --archive --installer
 ```
 
-You should see `(venv)` in your command prompt.
-
-### 3. Install Dependencies
+The installer will be at `dist\FastFlix_installer.exe` (~87 MB). The script reads the version from
+`fastflix/version.py`, updates `cmd\*\winres\winres.json` (file/product version and copyright year) and passes
+`-X main.Version=<version> -X main.BuildDate=<date>` to every Go build, so the installer, launcher and uninstaller
+always report the right version.
 
-```bash
-pip install --upgrade pip
-pip install -e ".[dev]"
-```
+Use `--archive` without `--installer` to stop after writing `cmd\installer\fastflix_dist.tar.zst`.
+Use `--arch arm64` to bundle the ARM64 Python and wheels.
 
-This installs FastFlix in editable mode with all development dependencies including PyInstaller.
+## What the Build Script Does
 
-### 4. Build the Executable
+1. Downloads the official Python 3.13 embeddable distribution (~11 MB). The patch version is the single constant
+   `DEFAULT_PYTHON_VERSION` in `scripts/build_distribution.py` (override with `--python-version`).
+2. Configures the embeddable Python to find installed packages (`python313._pth`)
+3. Builds a FastFlix wheel (the `dist\wheels` folder is wiped first, exactly one wheel must result) and installs it
+   with all dependencies pinned by `uv.lock` (`uv export` + `uv pip install --target`), resolved for the *bundled*
+   CPython 3.13 / `win_amd64` (or `win_arm64`), not for the build host's Python
+4. Runs `go-winres make` and builds the Go launcher (`FastFlix.exe`) and uninstaller (`uninstall.exe`)
+5. Trims unused PySide6 modules (~527 MB savings); third-party licence files are kept
+6. Copies licenses and generates translated terms text
+7. Creates a compressed `tar.zst` archive (~83 MB) that is embedded into the installer via `go:embed`
+8. With `--installer`: runs `go-winres make` for the installer and builds `dist\FastFlix_installer.exe`
 
-You have two options:
+## Building Individual Components
 
-#### Option A: Single Executable (Recommended for distribution)
+The build script is the supported path (it also syncs versions and generates resources). To rebuild a single piece
+by hand, run `go-winres make` in the command's directory first, then:
 
 ```bash
-pyinstaller FastFlix_Windows_OneFile.spec
-```
+# Launcher (console app, needs stdout for logs)
+go build -ldflags="-s -w -X main.Version=6.3.0 -X main.BuildDate=2026-01-01" -o dist\FastFlix\FastFlix.exe .\cmd\launcher
 
-The executable will be in: `dist\FastFlix.exe`
+# Uninstaller (GUI)
+go build -ldflags="-s -w -H windowsgui -X main.Version=6.3.0" -o dist\FastFlix\uninstall.exe .\cmd\uninstaller
 
-#### Option B: Directory with Multiple Files (Faster startup)
-
-```bash
-pyinstaller FastFlix_Windows_Installer.spec
+# Installer (GUI, requires cmd\installer\fastflix_dist.tar.zst, licenses.txt, terms_translations.json from --archive)
+go build -ldflags="-s -w -H windowsgui -X main.Version=6.3.0 -X main.BuildDate=2026-01-01" -o dist\FastFlix_installer.exe .\cmd\installer
 ```
 
-The executable will be in: `dist\FastFlix\FastFlix.exe`
-
-### 5. Test the Build
+## Checks
 
 ```bash
-cd dist
-FastFlix.exe
+GOOS=windows go vet ./...          # needs the installer's embedded files to exist (run the build script once)
+go test ./cmd/internal/...          # path-safety / uninstall logic
 ```
 
-Or for the installer version:
+## Testing the Build
 
 ```bash
-cd dist\FastFlix
-FastFlix.exe
+dist\FastFlix\FastFlix.exe --version
+dist\FastFlix\FastFlix.exe --test     # headless startup validation; arguments are passed through to FastFlix
+dist\FastFlix\FastFlix.exe            # launch the app
+dist\FastFlix_installer.exe           # run the installer
 ```
 
-## Running Without Building (For Testing)
-
-If you just want to test changes without building an executable:
+## Running Without Building (For Development)
 
 ```bash
+uv sync --frozen
 python -m fastflix
 ```
 
 ## Troubleshooting
 
-### Missing Dependencies
-
-If you get import errors, try reinstalling:
+### Missing Go / go-winres
 
+The build script stops with a clear error if `go` or `go-winres` is not on `PATH`:
 ```bash
-pip install --upgrade --force-reinstall -e ".[dev]"
+go version
+go install github.com/tc-hib/go-winres@v0.3.3
 ```
 
-### Build Errors
+### `zstandard` not installed
+
+`zstandard` is not a project dependency; run the script with `uv run --with zstandard python ...`.
 
-1. Make sure you're in the FastFlix root directory
-2. Ensure the virtual environment is activated (you see `(venv)`)
-3. Try deleting `build` and `dist` folders and rebuilding:
+### Missing licenses.txt or terms_translations.json
 
+These are generated by `scripts/build_distribution.py --archive`.
+
+### Build Errors
+
+Try deleting `dist` and rebuilding:
 ```bash
-rmdir /s /q build dist
-pyinstaller FastFlix_Windows_OneFile.spec
+rmdir /s /q dist
+uv run --with zstandard python scripts/build_distribution.py --archive --installer
 ```
 
 ### FFmpeg Not Found
 
-The FastFlix executable doesn't include FFmpeg. You need to:
+The FastFlix distribution doesn't include FFmpeg. Download it from
+[ffmpeg.org](https://ffmpeg.org/download.html#build-windows), add its `bin` folder to your PATH, or configure it in
+FastFlix settings.
+
+## Architecture
+
+The Windows distribution uses three Go binaries instead of PyInstaller:
 
-1. Download FFmpeg from [ffmpeg.org](https://ffmpeg.org/download.html#build-windows)
-2. Extract it somewhere
-3. Add the `bin` folder to your PATH, or configure it in FastFlix settings
+| Binary | Purpose | Console |
+|--------|---------|---------|
+| `FastFlix.exe` | Go launcher - sets up the Python environment and runs `python.exe -m fastflix <args>` | Yes (for logs) |
+| `uninstall.exe` | Standalone uninstaller - registered with Windows Add/Remove Programs | No (GUI) |
+| `FastFlix_installer.exe` | Dark-themed installer with embedded distribution archive | No (GUI) |
 
-## Known Limitations
+Shared safety logic (path validation, manifest-based removal, registry cleanup, self-delete) lives in
+`cmd/internal/ffinstall`.
 
-### PGS to SRT OCR (PyInstaller builds)
+The installer supports two modes:
+- **Install for just me** - installs to `%LOCALAPPDATA%\Programs\FastFlix` (no admin required)
+- **Install for all users** - installs to `%ProgramFiles%\FastFlix` (triggers UAC)
 
-Due to an upstream issue in pgsrip v0.1.12, PGS to SRT OCR conversion does not work in PyInstaller-built executables. The feature works perfectly when running from source (`python -m fastflix`).
+The installer writes `install_manifest.txt` next to the files it installs. Uninstalling (from Add/Remove Programs or
+from the installer's "Uninstall previous version" button) removes only what the installer put there, leaves user
+files such as a portable `fastflix.yaml`, only removes the folder if it ends up empty, and only touches the registry
+root (HKLM or HKCU) that registered that install. Upgrades remove the old version the same way, so a portable
+config survives.
 
-If you need PGS OCR functionality, please run FastFlix from source instead of using the compiled executable.
+## CI
+
+The `build-windows-2022` job in `.github/workflows/build.yaml` installs Go and go-winres, runs the build script with
+`--archive --installer`, runs `go vet` / `go test`, smoke-tests `FastFlix.exe --version` / `--test`, and uploads
+`FastFlix_<version>_installer` (the installer) and `FastFlix_<version>_win64` (a portable zip of the distribution).
+The old PyInstaller one-file build and the NSIS installer (`FastFlix.nsi`) are no longer built on Windows.
+
+## Linux/macOS
+
+Linux and macOS builds still use PyInstaller:
+
+```bash
+uv run pyinstaller FastFlix_Nix_OneFile.spec
+```
 
 ## Notes
 
-- The build process creates a `portable.py` file temporarily (it's removed after)
-- The `.spec` files automatically collect all dependencies from `pyproject.toml`
-- The icon is located at `fastflix\data\icon.ico`
+- The Go launcher is built as a **console app** (not GUI) so users can see log output
+- The installer and uninstaller are built with `-H windowsgui` (no console window)
+- Icons/manifests are embedded via `go-winres` - `.syso` files are gitignored
+- The distribution archive uses Zstandard compression (level 22) for best ratio
+- PySide6 trimming removes WebEngine (193 MB), Quick/QML, 3D, Designer, and other unused Qt modules
diff --git a/cmd/installer/install.go b/cmd/installer/install.go
new file mode 100644
index 00000000..c66f1f4d
--- /dev/null
+++ b/cmd/installer/install.go
@@ -0,0 +1,510 @@
+package main
+
+import (
+	"archive/tar"
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"unsafe"
+
+	"github.com/cdgriffith/fastflix-installer/cmd/internal/ffinstall"
+	"github.com/klauspost/compress/zstd"
+	"golang.org/x/sys/windows"
+	"golang.org/x/sys/windows/registry"
+)
+
+const (
+	productName   = ffinstall.ProductName
+	productAuthor = "Chris Griffith"
+)
+
+// installMode determines where to install and which registry root to use.
+type installMode int
+
+const (
+	modeUser     installMode = iota // Install for current user only
+	modeAllUsers                    // Install for all users (admin required)
+)
+
+// installPaths returns the install directory, registry root, and Start Menu path for the given mode.
+func installPaths(mode installMode) (installDir string, regRoot registry.Key, startMenu string) {
+	switch mode {
+	case modeUser:
+		installDir = filepath.Join(os.Getenv("LOCALAPPDATA"), "Programs", productName)
+		regRoot = registry.CURRENT_USER
+		startMenu = filepath.Join(os.Getenv("APPDATA"), "Microsoft", "Windows", "Start Menu", "Programs", productName)
+	case modeAllUsers:
+		installDir = filepath.Join(os.Getenv("ProgramFiles"), productName)
+		regRoot = registry.LOCAL_MACHINE
+		startMenu = filepath.Join(os.Getenv("ProgramData"), "Microsoft", "Windows", "Start Menu", "Programs", productName)
+	}
+	return
+}
+
+// countArchiveEntries counts the number of file entries in the tar.zst archive.
+func countArchiveEntries(data []byte) int {
+	decoder, err := zstd.NewReader(bytes.NewReader(data))
+	if err != nil {
+		return 0
+	}
+	defer decoder.Close()
+
+	count := 0
+	tr := tar.NewReader(decoder)
+	for {
+		_, err := tr.Next()
+		if err != nil {
+			break
+		}
+		count++
+	}
+	return count
+}
+
+// extractTarZstd decompresses a tar.zst archive to the target directory.
+// Calls progressFn(current, total) after each file is extracted.
+// Returns the relative paths of the files that were extracted (also on error, for cleanup).
+func extractTarZstd(data []byte, targetDir string, progressFn func(current, total int)) ([]string, error) {
+	total := countArchiveEntries(data)
+	if total == 0 {
+		total = 1
+	}
+
+	decoder, err := zstd.NewReader(bytes.NewReader(data))
+	if err != nil {
+		return nil, fmt.Errorf("open zstd: %w", err)
+	}
+	defer decoder.Close()
+
+	var files []string
+	current := 0
+	tr := tar.NewReader(decoder)
+	for {
+		header, err := tr.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return files, fmt.Errorf("read tar: %w", err)
+		}
+
+		target := filepath.Join(targetDir, header.Name)
+
+		// Prevent path traversal
+		if !strings.HasPrefix(filepath.Clean(target), filepath.Clean(targetDir)+string(os.PathSeparator)) {
+			continue
+		}
+
+		switch header.Typeflag {
+		case tar.TypeDir:
+			os.MkdirAll(target, 0755)
+		case tar.TypeReg:
+			os.MkdirAll(filepath.Dir(target), 0755)
+			files = append(files, filepath.ToSlash(header.Name))
+			outFile, err := os.OpenFile(target, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0755)
+			if err != nil {
+				return files, fmt.Errorf("create %s: %w", header.Name, err)
+			}
+			_, err = io.Copy(outFile, tr)
+			outFile.Close()
+			if err != nil {
+				return files, fmt.Errorf("extract %s: %w", header.Name, err)
+			}
+		}
+
+		current++
+		if progressFn != nil {
+			progressFn(current, total)
+		}
+	}
+	return files, nil
+}
+
+// installFiles extracts the embedded distribution into dir and records an install manifest so a later
+// uninstall removes exactly these files. On failure everything extracted so far is removed again.
+func installFiles(dir string, progressFn func(current, total int)) error {
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return err
+	}
+	files, err := extractTarZstd(distArchive, dir, progressFn)
+	if err != nil {
+		ffinstall.RemoveExtracted(dir, files)
+		return err
+	}
+	if err := ffinstall.WriteManifest(dir, files); err != nil {
+		ffinstall.RemoveExtracted(dir, files)
+		return fmt.Errorf("write install manifest: %w", err)
+	}
+	return nil
+}
+
+// writeRegistry creates registry entries for the installation.
+func writeRegistry(installDir string, regRoot registry.Key) {
+	// Application registry key
+	appKey, _, _ := registry.CreateKey(regRoot, `SOFTWARE\`+productName, registry.SET_VALUE)
+	if appKey != 0 {
+		appKey.SetStringValue("Install_Dir", installDir)
+		appKey.Close()
+	}
+
+	// Determine uninstall flag based on mode
+	uninstallFlag := "--user"
+	if regRoot == registry.LOCAL_MACHINE {
+		uninstallFlag = "--allusers"
+	}
+
+	// Uninstall registry key
+	uKey, _, _ := registry.CreateKey(regRoot, ffinstall.RegistryUninstallPaths[0], registry.SET_VALUE)
+	if uKey != 0 {
+		uKey.SetStringValue("DisplayName", productName)
+		uKey.SetStringValue("DisplayVersion", Version)
+		uKey.SetStringValue("Publisher", productAuthor)
+		uKey.SetStringValue("DisplayIcon", filepath.Join(installDir, "FastFlix.exe"))
+		uKey.SetStringValue("UninstallString", `"`+filepath.Join(installDir, "uninstall.exe")+`" --uninstall `+uninstallFlag)
+		uKey.SetStringValue("InstallLocation", installDir)
+		uKey.SetDWordValue("NoModify", 1)
+		uKey.SetDWordValue("NoRepair", 1)
+		uKey.Close()
+	}
+}
+
+// writeInstalledSize calculates and writes the EstimatedSize registry value.
+func writeInstalledSize(installDir string, regRoot registry.Key) {
+	var totalKB int64
+	filepath.Walk(installDir, func(path string, info os.FileInfo, err error) error {
+		if err == nil && !info.IsDir() {
+			totalKB += info.Size() / 1024
+		}
+		return nil
+	})
+
+	uKey, err := registry.OpenKey(regRoot, ffinstall.RegistryUninstallPaths[0], registry.SET_VALUE)
+	if err == nil {
+		uKey.SetDWordValue("EstimatedSize", uint32(totalKB))
+		uKey.Close()
+	}
+}
+
+// createShortcuts creates Start Menu shortcuts.
+func createShortcuts(installDir, startMenu string) error {
+	if err := os.MkdirAll(startMenu, 0755); err != nil {
+		return err
+	}
+	return createShortcutFile(
+		filepath.Join(startMenu, productName+".lnk"),
+		filepath.Join(installDir, "FastFlix.exe"),
+		installDir,
+		"FastFlix Video Encoder",
+	)
+}
+
+// createShortcutFile creates a .lnk shortcut via PowerShell. The paths are handed over through environment
+// variables, never interpolated into the script, so quotes or other characters in a path cannot break it.
+func createShortcutFile(lnkPath, targetPath, workDir, description string) error {
+	script := `$ws = New-Object -ComObject WScript.Shell; ` +
+		`$sc = $ws.CreateShortcut($env:FF_LNK); ` +
+		`$sc.TargetPath = $env:FF_TARGET; ` +
+		`$sc.WorkingDirectory = $env:FF_WORKDIR; ` +
+		`$sc.Description = $env:FF_DESC; ` +
+		`$sc.Save()`
+	cmd := exec.Command("powershell", "-NoProfile", "-NonInteractive", "-Command", script)
+	cmd.Env = append(os.Environ(),
+		"FF_LNK="+lnkPath, "FF_TARGET="+targetPath, "FF_WORKDIR="+workDir, "FF_DESC="+description)
+	cmd.SysProcAttr = &syscall.SysProcAttr{CreationFlags: 0x08000000}
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("create shortcut %s: %v %s", lnkPath, err, strings.TrimSpace(string(out)))
+	}
+	if _, statErr := os.Stat(lnkPath); statErr != nil {
+		return fmt.Errorf("shortcut %s was not created", lnkPath)
+	}
+	return nil
+}
+
+// existingInstall represents a single discovered FastFlix installation.
+type existingInstall struct {
+	RegRoot      registry.Key
+	InstallDir   string
+	UninstallStr string
+	Version      string
+}
+
+// installNeedsAdmin reports whether removing inst requires elevation: it lives in Program Files or its
+// registration is under HKLM (all-users).
+func installNeedsAdmin(inst existingInstall) bool {
+	return inst.RegRoot == registry.LOCAL_MACHINE ||
+		(inst.InstallDir != "" && ffinstall.IsProtectedPath(inst.InstallDir))
+}
+
+// startMenuDirs returns the per-user and common Start Menu folders for FastFlix.
+func startMenuDirs() (user, common string) {
+	user = filepath.Join(os.Getenv("APPDATA"), "Microsoft", "Windows", "Start Menu", "Programs", productName)
+	common = filepath.Join(os.Getenv("ProgramData"), "Microsoft", "Windows", "Start Menu", "Programs", productName)
+	return
+}
+
+// cleanupInstallation removes a FastFlix installation: its files (user files such as a portable
+// fastflix.yaml are preserved), Start Menu and desktop shortcuts, and registry keys.
+// Installs in Program Files need admin; those are handled up-front by runElevatedUninstall.
+func cleanupInstallation(inst existingInstall) {
+	if inst.InstallDir != "" {
+		if _, err := os.Stat(inst.InstallDir); err == nil {
+			// Refuses (returns an error) for anything that is not clearly a FastFlix folder
+			ffinstall.RemoveInstalledFiles(inst.InstallDir, "")
+		}
+	}
+
+	userSM, commonSM := startMenuDirs()
+	os.RemoveAll(userSM)
+	os.RemoveAll(commonSM) // fails harmlessly without admin; the elevated step handles it
+
+	os.Remove(filepath.Join(os.Getenv("USERPROFILE"), "Desktop", productName+".lnk"))
+	os.Remove(filepath.Join(os.Getenv("PUBLIC"), "Desktop", productName+".lnk"))
+
+	cleanAllRegistryKeys()
+}
+
+// cleanAllRegistryKeys removes all FastFlix registry keys from all known locations,
+// including the WOW6432Node paths that the 32-bit NSIS installer wrote to.
+func cleanAllRegistryKeys() {
+	for _, root := range []registry.Key{registry.LOCAL_MACHINE, registry.CURRENT_USER} {
+		ffinstall.CleanRegistry(root)
+	}
+}
+
+// Exit codes of the elevated helpers (--elevated-install / --elevated-uninstall). The elevated process never
+// writes to a user-controlled location; the unelevated GUI learns the outcome from the process exit code only.
+const (
+	exitOK             = 0 // success
+	exitError          = 1 // generic failure / bad arguments
+	exitBadLocation    = 2 // install location is not the expected all-users location
+	exitOKWithWarnings = 3 // success, but a non-fatal step (shortcut) failed
+	exitInstallFailed  = 4 // extracting the files failed
+	exitUninstallProbs = 5 // some directories could not be removed
+)
+
+// describeExit turns a helper exit code into a user-facing message.
+func describeExit(code uint32) string {
+	switch code {
+	case exitBadLocation:
+		return "unexpected install location (exit code 2)"
+	case exitInstallFailed:
+		return "the files could not be extracted (exit code 4)"
+	case exitUninstallProbs:
+		return "some files could not be removed (exit code 5)"
+	}
+	return fmt.Sprintf("the elevated helper failed (exit code %d)", code)
+}
+
+// shellExecuteInfo mirrors SHELLEXECUTEINFOW.
+type shellExecuteInfo struct {
+	Size       uint32
+	Mask       uint32
+	Hwnd       uintptr
+	Verb       *uint16
+	File       *uint16
+	Parameters *uint16
+	Directory  *uint16
+	Show       int32
+	InstApp    uintptr
+	IDList     uintptr
+	Class      *uint16
+	KeyClass   uintptr
+	HotKey     uint32
+	Icon       uintptr
+	Process    windows.Handle
+}
+
+// launchElevated starts the installer exe elevated (UAC) with the given arguments and returns the process
+// handle (caller must CloseHandle it). declined is true if the user cancelled the UAC prompt.
+func launchElevated(args string) (h windows.Handle, declined bool, err error) {
+	selfPath, err := os.Executable()
+	if err != nil {
+		return 0, false, err
+	}
+	const seeMaskNoCloseProcess, seeMaskNoAsync = 0x40, 0x100
+	verb, _ := syscall.UTF16PtrFromString("runas")
+	exe, _ := syscall.UTF16PtrFromString(selfPath)
+	argPtr, _ := syscall.UTF16PtrFromString(args)
+	cwd, _ := syscall.UTF16PtrFromString(filepath.Dir(selfPath))
+	info := shellExecuteInfo{
+		Mask: seeMaskNoCloseProcess | seeMaskNoAsync,
+		Verb: verb, File: exe, Parameters: argPtr, Directory: cwd, Show: 0, // SW_HIDE
+	}
+	info.Size = uint32(unsafe.Sizeof(info))
+	ret, _, callErr := syscall.NewLazyDLL("shell32.dll").NewProc("ShellExecuteExW").Call(uintptr(unsafe.Pointer(&info)))
+	if ret == 0 {
+		if errors.Is(callErr, windows.ERROR_CANCELLED) {
+			return 0, true, nil
+		}
+		return 0, false, callErr
+	}
+	if info.Process == 0 {
+		return 0, false, errors.New("no process handle returned")
+	}
+	return info.Process, false, nil
+}
+
+// waitElevated waits up to maxSeconds for the elevated process to exit (calling tick every 500ms so the GUI
+// can animate) and returns its exit code. done is false on timeout. The handle is closed.
+func waitElevated(h windows.Handle, maxSeconds int, tick func(i int)) (code uint32, done bool) {
+	defer windows.CloseHandle(h)
+	for i := 1; i <= maxSeconds*2; i++ {
+		ev, _ := windows.WaitForSingleObject(h, 500)
+		if ev == windows.WAIT_OBJECT_0 {
+			if err := windows.GetExitCodeProcess(h, &code); err != nil {
+				return exitError, true
+			}
+			return code, true
+		}
+		if tick != nil {
+			tick(i)
+		}
+	}
+	return 0, false
+}
+
+// elevatedUninstall removes the given (protected) install directories plus all HKLM keys and the common
+// Start Menu entry in one elevated helper run. Returns false if elevation was refused or the helper failed.
+func elevatedUninstall(dirs []string) (ok bool, detail string) {
+	args := `--elevated-uninstall`
+	for _, d := range dirs {
+		if err := ffinstall.ValidatePathString(d); err != nil {
+			return false, err.Error()
+		}
+		args += ` --dir "` + d + `"`
+	}
+	h, declined, err := launchElevated(args)
+	if declined {
+		return false, "elevation was declined"
+	}
+	if err != nil {
+		return false, err.Error()
+	}
+	code, done := waitElevated(h, 120, nil)
+	if !done {
+		return false, "timed out waiting for the elevated helper"
+	}
+	if code != exitOK {
+		return false, describeExit(code)
+	}
+	return true, ""
+}
+
+// fastflixRunning reports whether FastFlix (or an orphaned bundled python.exe) is running.
+func fastflixRunning() bool {
+	pf, _, _ := installPaths(modeAllUsers)
+	local, _, _ := installPaths(modeUser)
+	dirs := []string{pf, local}
+	for _, inst := range state.existingInstalls {
+		dirs = append(dirs, inst.InstallDir)
+	}
+	return ffinstall.IsRunning(dirs...)
+}
+
+// findAllExistingInstalls checks both registry and known disk paths for existing FastFlix installations.
+// Returns all found installations (could be multiple: old NSIS in Program Files + user install).
+func findAllExistingInstalls() []existingInstall {
+	var results []existingInstall
+	seen := map[string]bool{} // deduplicate by install dir (lowercased)
+
+	// 1. Check registry: HKLM and HKCU, in both the 64-bit and the 32-bit (WOW6432Node) view, because the
+	// old 32-bit NSIS installer wrote its keys to the 32-bit view and never set InstallLocation.
+	for _, root := range []registry.Key{registry.LOCAL_MACHINE, registry.CURRENT_USER} {
+		for _, view := range []uint32{0, registry.WOW64_32KEY} {
+			uKey, err := registry.OpenKey(root, ffinstall.RegistryUninstallPaths[0], registry.QUERY_VALUE|view)
+			if err != nil {
+				continue
+			}
+			dir, _, _ := uKey.GetStringValue("InstallLocation")
+			uninstall, _, _ := uKey.GetStringValue("UninstallString")
+			version, _, _ := uKey.GetStringValue("DisplayVersion")
+			uKey.Close()
+
+			if dir == "" {
+				// NSIS-style: Software\FastFlix\Install_Dir in the same view
+				if appKey, err2 := registry.OpenKey(root, ffinstall.RegistryAppPaths[0], registry.QUERY_VALUE|view); err2 == nil {
+					dir, _, _ = appKey.GetStringValue("Install_Dir")
+					appKey.Close()
+				}
+			}
+			if dir == "" && uninstall != "" {
+				// Last resort: the directory of the uninstaller exe in UninstallString
+				u := strings.TrimSpace(uninstall)
+				if strings.HasPrefix(u, `"`) {
+					if end := strings.Index(u[1:], `"`); end >= 0 {
+						dir = filepath.Dir(u[1 : end+1])
+					}
+				}
+			}
+
+			if dir != "" || uninstall != "" {
+				dirKey := strings.ToLower(filepath.Clean(dir))
+				if !seen[dirKey] {
+					seen[dirKey] = true
+					results = append(results, existingInstall{
+						RegRoot:      root,
+						InstallDir:   dir,
+						UninstallStr: uninstall,
+						Version:      version,
+					})
+				}
+			}
+		}
+		// Install_Dir without an Uninstall key (view-aware)
+		for _, view := range []uint32{0, registry.WOW64_32KEY} {
+			if appKey, err := registry.OpenKey(root, ffinstall.RegistryAppPaths[0], registry.QUERY_VALUE|view); err == nil {
+				dir, _, _ := appKey.GetStringValue("Install_Dir")
+				appKey.Close()
+				if dir != "" {
+					dirKey := strings.ToLower(filepath.Clean(dir))
+					if !seen[dirKey] {
+						seen[dirKey] = true
+						results = append(results, existingInstall{RegRoot: root, InstallDir: dir})
+					}
+				}
+			}
+		}
+	}
+
+	// 2. Check known disk paths even if registry keys are missing
+	// (handles installs where registry was cleaned up or never written)
+	knownPaths := []string{
+		filepath.Join(os.Getenv("ProgramFiles"), productName),
+		filepath.Join(os.Getenv("LOCALAPPDATA"), "Programs", productName),
+	}
+	for _, dir := range knownPaths {
+		dirKey := strings.ToLower(filepath.Clean(dir))
+		if seen[dirKey] {
+			continue
+		}
+		// Check if FastFlix.exe exists at this path
+		exePath := filepath.Join(dir, "FastFlix.exe")
+		if _, err := os.Stat(exePath); err != nil {
+			continue
+		}
+		seen[dirKey] = true
+		results = append(results, existingInstall{InstallDir: dir})
+	}
+
+	return results
+}
+
+// messageBox shows a Windows message box and returns the button clicked.
+func messageBox(title, msg string, flags uintptr) int {
+	user32 := syscall.NewLazyDLL("user32.dll")
+	proc := user32.NewProc("MessageBoxW")
+	titlePtr, _ := syscall.UTF16PtrFromString(title)
+	msgPtr, _ := syscall.UTF16PtrFromString(msg)
+	ret, _, _ := proc.Call(0,
+		uintptr(unsafe.Pointer(msgPtr)),
+		uintptr(unsafe.Pointer(titlePtr)),
+		flags)
+	return int(ret)
+}
diff --git a/cmd/installer/main.go b/cmd/installer/main.go
new file mode 100644
index 00000000..be183922
--- /dev/null
+++ b/cmd/installer/main.go
@@ -0,0 +1,139 @@
+// FastFlix Installer
+//
+// Polished GUI installer drawn with raw Win32 calls and a dark theme.
+// Supports per-user and all-users installation modes.
+//
+// Build (scripts/build_distribution.py --installer does all of this and injects the version):
+//   cd cmd/installer && go-winres make && cd ../..
+//   go build -ldflags="-s -w -H windowsgui -X main.Version=6.3.0 -X main.BuildDate=2026-01-01" -o FastFlix_installer.exe ./cmd/installer
+
+package main
+
+import (
+	"os"
+	"runtime"
+	"strings"
+	"syscall"
+	"unsafe"
+
+	"github.com/cdgriffith/fastflix-installer/cmd/internal/ffinstall"
+	"golang.org/x/sys/windows/registry"
+)
+
+// Version and BuildDate are set at build time via -ldflags
+var Version = "dev"
+var BuildDate = "" // format: 2006-01-02
+
+func main() {
+	runtime.LockOSThread()
+
+	// Single-instance check via named mutex (skipped for the silent elevated helpers)
+	args := os.Args[1:]
+	isHelper := containsArg(args, "--elevated-install") || containsArg(args, "--elevated-uninstall")
+	if !isHelper {
+		mutexName, _ := syscall.UTF16PtrFromString(`Global\FastFlixInstaller`)
+		handle, _, err := kernel32DLL.NewProc("CreateMutexW").Call(0, 1, uintptr(unsafe.Pointer(mutexName)))
+		if handle != 0 && err == syscall.ERROR_ALREADY_EXISTS {
+			messageBox("FastFlix Installer", "The FastFlix installer is already running.", 0x40)
+			return
+		}
+		// mutex handle stays open until process exits — no need to close it
+	}
+
+	// --elevated-install: silent elevated helper (extracts + registry + shortcuts)
+	// Called by the GUI installer when "Install for all users" is clicked
+	if containsArg(args, "--elevated-install") {
+		runElevatedInstall(args)
+		return
+	}
+
+	// --elevated-uninstall: silent elevated helper that removes protected (Program Files) installs
+	if containsArg(args, "--elevated-uninstall") {
+		runElevatedUninstall(args)
+		return
+	}
+
+	// Default: show the installer GUI
+	runInstallerGUI()
+}
+
+// runElevatedInstall does everything: extract embedded archive to dest, registry, shortcuts.
+// Called as an elevated process — no UI. The outcome is reported only through the process exit code (see the
+// exit* constants); the elevated process never writes to a path chosen by the unelevated caller.
+func runElevatedInstall(args []string) {
+	dst := getArgValue(args, "--dest")
+	if dst == "" {
+		os.Exit(exitError)
+	}
+
+	// Only ever install to the all-users location
+	expected, regRoot, startMenu := installPaths(modeAllUsers)
+	if !strings.EqualFold(strings.TrimRight(dst, `\`), expected) {
+		os.Exit(exitBadLocation)
+	}
+
+	// Extract embedded archive directly to destination (includes uninstall.exe)
+	if err := installFiles(dst, nil); err != nil {
+		os.Exit(exitInstallFailed)
+	}
+
+	// Write HKLM registry + shortcuts
+	writeRegistry(dst, regRoot)
+	writeInstalledSize(dst, regRoot)
+	if err := createShortcuts(dst, startMenu); err != nil {
+		os.Exit(exitOKWithWarnings)
+	}
+	os.Exit(exitOK)
+}
+
+// runElevatedUninstall removes the given protected install directories (--dir, repeatable), then all HKLM
+// keys and the common Start Menu / public desktop shortcuts. Elevated, no UI; reports via exit code.
+func runElevatedUninstall(args []string) {
+	problems := false
+	for i, a := range args {
+		if !strings.EqualFold(a, "--dir") || i+1 >= len(args) {
+			continue
+		}
+		dir := args[i+1]
+		if _, err := os.Stat(dir); err != nil {
+			continue // already gone
+		}
+		// RemoveInstalledFiles validates the directory (SafeToRemove) and refuses anything that is not
+		// clearly a FastFlix install, including the legacy delete-everything branch.
+		if err := ffinstall.RemoveInstalledFiles(dir, ""); err != nil {
+			problems = true
+		}
+	}
+
+	ffinstall.CleanRegistry(registry.LOCAL_MACHINE)
+	_, commonSM := startMenuDirs()
+	os.RemoveAll(commonSM)
+	os.Remove(publicDesktopShortcut())
+
+	if problems {
+		os.Exit(exitUninstallProbs)
+	}
+	os.Exit(exitOK)
+}
+
+func publicDesktopShortcut() string {
+	return os.Getenv("PUBLIC") + `\Desktop\` + productName + ".lnk"
+}
+
+func getArgValue(args []string, key string) string {
+	for i, a := range args {
+		if strings.EqualFold(a, key) && i+1 < len(args) {
+			return args[i+1]
+		}
+	}
+	return ""
+}
+
+func containsArg(args []string, flag string) bool {
+	for _, a := range args {
+		if strings.EqualFold(a, flag) {
+			return true
+		}
+	}
+	return false
+}
diff --git a/cmd/installer/resources.go b/cmd/installer/resources.go
new file mode 100644
index 00000000..fe706f82
--- /dev/null
+++ b/cmd/installer/resources.go
@@ -0,0 +1,116 @@
+package main
+
+import (
+	_ "embed"
+	"encoding/json"
+	"strings"
+	"syscall"
+)
+
+//go:embed fastflix_dist.tar.zst
+var distArchive []byte
+
+//go:embed terms_translations.json
+var termsTranslationsJSON string
+
+//go:embed licenses.txt
+var licensesFileText string
+
+const mitLicense = `The MIT License
+
+Copyright (c) 2019-2025 Chris Griffith
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.`
+
+var termsAndLicensesText string
+
+func init() {
+	terms := loadTermsForLocale()
+
+	// Use \r\n throughout for Windows EDIT control compatibility
+	sep := "\r\n\r\n" + strings.Repeat("\u2550", 50) + "\r\n"
+
+	termsAndLicensesText = terms +
+		sep + "SOFTWARE LICENSE (MIT)\r\n" + strings.Repeat("\u2550", 50) + "\r\n\r\n" +
+		strings.ReplaceAll(mitLicense, "\n", "\r\n") +
+		sep + "THIRD-PARTY LICENSES\r\n" + strings.Repeat("\u2550", 50) + "\r\n\r\n" +
+		strings.ReplaceAll(licensesFileText, "\n", "\r\n")
+}
+
+// loadTermsForLocale returns the terms text for the current system language.
+// If the system language is not English and is supported, shows the translation
+// followed by a divider and the English version.
+func loadTermsForLocale() string {
+	var translations map[string]string
+	json.Unmarshal([]byte(termsTranslationsJSON), &translations)
+
+	english := translations["eng"]
+	if english == "" {
+		english = "FastFlix Terms and Agreements\r\n\r\n(Terms text not available)"
+	}
+
+	langCode := detectSystemLanguage()
+
+	if langCode != "eng" {
+		if translated, ok := translations[langCode]; ok && translated != "" {
+			divider := "\r\n\r\n" + strings.Repeat("\u2500", 50) + "\r\n\r\n"
+			return translated + divider + english
+		}
+	}
+	return english
+}
+
+// detectSystemLanguage uses GetUserDefaultUILanguage to detect the OS language
+// and maps it to a FastFlix language code.
+func detectSystemLanguage() string {
+	kernel32 := syscall.NewLazyDLL("kernel32.dll")
+	ret, _, _ := kernel32.NewProc("GetUserDefaultUILanguage").Call()
+	primaryLang := int(ret) & 0x3FF
+
+	switch primaryLang {
+	case 0x07:
+		return "deu" // German
+	case 0x0C:
+		return "fra" // French
+	case 0x10:
+		return "ita" // Italian
+	case 0x0A:
+		return "spa" // Spanish
+	case 0x04:
+		return "chs" // Chinese Simplified
+	case 0x11:
+		return "jpn" // Japanese
+	case 0x19:
+		return "rus" // Russian
+	case 0x16:
+		return "por" // Portuguese
+	case 0x1D:
+		return "swe" // Swedish
+	case 0x15:
+		return "pol" // Polish
+	case 0x22:
+		return "ukr" // Ukrainian
+	case 0x12:
+		return "kor" // Korean
+	case 0x18:
+		return "ron" // Romanian
+	default:
+		return "eng"
+	}
+}
diff --git a/cmd/installer/ui.go b/cmd/installer/ui.go
new file mode 100644
index 00000000..99b32b0d
--- /dev/null
+++ b/cmd/installer/ui.go
@@ -0,0 +1,1345 @@
+package main
+
+import (
+	"fmt"
+	"math"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"syscall"
+	"unsafe"
+
+	"github.com/cdgriffith/fastflix-installer/cmd/internal/ffinstall"
+)
+
+// Win32 API bindings
+var (
+	user32DLL   = syscall.NewLazyDLL("user32.dll")
+	kernel32DLL = syscall.NewLazyDLL("kernel32.dll")
+	gdi32DLL    = syscall.NewLazyDLL("gdi32.dll")
+	dwmapiDLL   = syscall.NewLazyDLL("dwmapi.dll")
+	comctl32DLL = syscall.NewLazyDLL("comctl32.dll")
+
+	registerClassExW    = user32DLL.NewProc("RegisterClassExW")
+	createWindowExW     = user32DLL.NewProc("CreateWindowExW")
+	showWindow          = user32DLL.NewProc("ShowWindow")
+	updateWindow        = user32DLL.NewProc("UpdateWindow")
+	getMessageW         = user32DLL.NewProc("GetMessageW")
+	translateMessage    = user32DLL.NewProc("TranslateMessage")
+	dispatchMessageW    = user32DLL.NewProc("DispatchMessageW")
+	defWindowProcW      = user32DLL.NewProc("DefWindowProcW")
+	postQuitMessage     = user32DLL.NewProc("PostQuitMessage")
+	sendMessageW        = user32DLL.NewProc("SendMessageW")
+	enableWindow        = user32DLL.NewProc("EnableWindow")
+	setTimer            = user32DLL.NewProc("SetTimer")
+	destroyWindow       = user32DLL.NewProc("DestroyWindow")
+	getSystemMetrics    = user32DLL.NewProc("GetSystemMetrics")
+	invalidateRect      = user32DLL.NewProc("InvalidateRect")
+	loadImageW          = user32DLL.NewProc("LoadImageW")
+	loadIconW           = user32DLL.NewProc("LoadIconW")
+	drawIconEx          = user32DLL.NewProc("DrawIconEx")
+	beginPaint          = user32DLL.NewProc("BeginPaint")
+	endPaint            = user32DLL.NewProc("EndPaint")
+	fillRectProc        = user32DLL.NewProc("FillRect")
+	setWindowTextW      = user32DLL.NewProc("SetWindowTextW")
+	getClientRectProc   = user32DLL.NewProc("GetClientRect")
+	getWindowTextW      = user32DLL.NewProc("GetWindowTextW")
+	isWindowProc        = user32DLL.NewProc("IsWindow")
+	setForegroundWindow = user32DLL.NewProc("SetForegroundWindow")
+
+	createSolidBrush = gdi32DLL.NewProc("CreateSolidBrush")
+	createFontW      = gdi32DLL.NewProc("CreateFontW")
+	selectObject     = gdi32DLL.NewProc("SelectObject")
+	setTextColor     = gdi32DLL.NewProc("SetTextColor")
+	setBkMode        = gdi32DLL.NewProc("SetBkMode")
+	drawTextW        = user32DLL.NewProc("DrawTextW")
+	deleteObject     = gdi32DLL.NewProc("DeleteObject")
+
+	initCommonControlsEx  = comctl32DLL.NewProc("InitCommonControlsEx")
+	dwmSetWindowAttribute = dwmapiDLL.NewProc("DwmSetWindowAttribute")
+	getModuleHandleW      = kernel32DLL.NewProc("GetModuleHandleW")
+)
+
+// Win32 constants
+const (
+	wsOverlapped   = 0x00000000
+	wsCaption      = 0x00C00000
+	wsSysMenu      = 0x00080000
+	wsMinimizeBox  = 0x00020000
+	wsVisible      = 0x10000000
+	wsChild        = 0x40000000
+	wsTabStop      = 0x00010000
+	wsExComposited = 0x02000000
+	wsVScroll      = 0x00200000
+	wsBorder       = 0x00800000
+
+	bsAutoCheckBox = 0x00000003
+	bsOwnerDraw    = 0x0000000B
+	ssCenter       = 0x00000001
+	ssNotify       = 0x00000100
+	ssOwnerDraw    = 0x0000000D
+	pbsSmooth      = 0x01
+	esMultiline    = 0x0004
+	esReadOnly     = 0x0800
+	esAutoVScroll  = 0x0040
+
+	wmDestroy        = 0x0002
+	wmPaint          = 0x000F
+	wmClose          = 0x0010
+	wmSetText        = 0x000C
+	wmSetFont        = 0x0030
+	wmSetIcon        = 0x0080
+	wmCommand        = 0x0111
+	wmTimer          = 0x0113
+	wmCtlColorStatic = 0x0138
+	wmCtlColorBtn    = 0x0135
+	wmCtlColorEdit   = 0x0133
+	wmDrawItem       = 0x002B
+
+	bmGetCheck   = 0x00F0
+	bstChecked   = 0x0001
+	pbmSetRange  = 0x0406
+	pbmSetPos    = 0x0402
+	emSetMargins = 0x00D3
+
+	bnClicked   = 0
+	smCXScreen  = 0
+	smCYScreen  = 1
+	swShow      = 5
+	swHide      = 0
+	transparent = 1
+	imageIcon   = 1
+
+	dtCenter     = 0x00000001
+	dtSingleLine = 0x00000020
+	dtVCenter    = 0x00000004
+)
+
+// Control IDs
+const (
+	idcAgree     = 101
+	idcTerms     = 102
+	idcUninstall = 103
+	idcUser      = 104
+	idcAll       = 105
+	idcWarning   = 106
+	idcProgress  = 107
+	idcProgLabel = 108
+	idcLaunch    = 109
+	idcInstInfo  = 110
+	idcClose     = 111
+	idtProcCheck = 1
+	idcDlgEdit   = 201
+	idcDlgClose  = 202
+)
+
+// Colors (COLORREF = 0x00BBGGRR)
+const (
+	clrBg        = 0x00333333
+	clrText      = 0x00E6E6E6
+	clrSubtext   = 0x00A0A0A0
+	clrAccent    = 0x00F0AA46 // #46AAF0 in BGR (cyan)
+	clrRed       = 0x003C3CDC
+	clrBtnBg     = 0x00F0D030 // bright cyan #30D0F0 in BGR
+	clrBtnText   = 0x00202020 // dark text on bright buttons
+	clrBtnDis    = 0x00555555
+	clrBtnRed    = 0x004848CC
+	clrBtnRedDis = 0x00444466
+	clrEditBg    = 0x003A3A3A
+)
+
+// Window dimensions — computed at runtime from screen size
+var (
+	winWidth  int
+	winHeight int
+	iconSz    int
+)
+
+type wndState struct {
+	hwnd       syscall.Handle
+	hInstance  syscall.Handle
+	hBgBrush   syscall.Handle
+	hEditBrush syscall.Handle
+
+	hTitleFont  syscall.Handle
+	hNormalFont syscall.Handle
+	hSmallFont  syscall.Handle
+	hIcon       syscall.Handle
+	hShieldIcon syscall.Handle
+
+	hAgree        syscall.Handle
+	hTerms        syscall.Handle
+	hUninstallBtn syscall.Handle
+	hUserBtn      syscall.Handle
+	hAllBtn       syscall.Handle
+	hWarning      syscall.Handle
+	hProgress     syscall.Handle
+	hProgLabel    syscall.Handle
+	hLaunchBtn    syscall.Handle
+	hCloseBtn     syscall.Handle
+	hInstallInfo  syscall.Handle // label showing where previous versions were found
+
+	processRunning      bool
+	installing          bool
+	agreeChecked        bool              // owner-drawn checkbox state
+	termsLinkX          int32             // X position where "Terms and Conditions" text starts (for hit-test)
+	installedDir        string            // set after install completes, for launch button
+	progressValue       int               // 0-100 progress percentage
+	uninstallNeedsAdmin bool              // true if any existing install is in Program Files
+	existingInstalls    []existingInstall // all detected installs (for info display)
+	existingFound       bool
+	existingVersion     string
+	existingDir         string
+	previousRemoved     bool
+}
+
+var state wndState
+
+// Win32 struct types
+type wndClassExW struct {
+	Size       uint32
+	Style      uint32
+	WndProc    uintptr
+	ClsExtra   int32
+	WndExtra   int32
+	Instance   syscall.Handle
+	Icon       syscall.Handle
+	Cursor     syscall.Handle
+	Background syscall.Handle
+	MenuName   *uint16
+	ClassName  *uint16
+	IconSm     syscall.Handle
+}
+
+type paintStruct struct {
+	HDC       syscall.Handle
+	Erase     int32
+	RcPaint   rect
+	Restore   int32
+	IncUpdate int32
+	Reserved  [32]byte
+}
+
+type rect struct{ Left, Top, Right, Bottom int32 }
+
+type msg struct {
+	Hwnd    syscall.Handle
+	Message uint32
+	WParam  uintptr
+	LParam  uintptr
+	Time    uint32
+	Pt      struct{ X, Y int32 }
+}
+
+type drawItemStruct struct {
+	CtlType    uint32
+	CtlID      uint32
+	ItemID     uint32
+	ItemAction uint32
+	ItemState  uint32
+	HwndItem   syscall.Handle
+	HDC        syscall.Handle
+	RcItem     rect
+	ItemData   uintptr
+}
+
+type initCommonControlsExStruct struct {
+	Size uint32
+	ICC  uint32
+}
+
+func utf16Ptr(s string) *uint16 {
+	p, _ := syscall.UTF16PtrFromString(s)
+	return p
+}
+
+func runInstallerGUI() {
+	runtime.LockOSThread()
+
+	icc := initCommonControlsExStruct{Size: 8, ICC: 0x00000020}
+	initCommonControlsEx.Call(uintptr(unsafe.Pointer(&icc)))
+
+	hInst, _, _ := getModuleHandleW.Call(0)
+	state.hInstance = syscall.Handle(hInst)
+
+	// Compute window size relative to screen (width ~20% of screen)
+	screenW, _, _ := getSystemMetrics.Call(smCXScreen)
+	screenH, _, _ := getSystemMetrics.Call(smCYScreen)
+	winWidth = int(screenW) * 20 / 100
+	if winWidth < 400 {
+		winWidth = 400
+	}
+	winHeight = winWidth * 150 / 100 // 1.5:1 aspect ratio (tall)
+	if winHeight > int(screenH)*85/100 {
+		winHeight = int(screenH) * 85 / 100
+	}
+	iconSz = winWidth * 30 / 100 // Icon is ~30% of window width
+	if iconSz > 256 {
+		iconSz = 256
+	}
+
+	// Brushes
+	ret, _, _ := createSolidBrush.Call(clrBg)
+	state.hBgBrush = syscall.Handle(ret)
+	ret, _, _ = createSolidBrush.Call(clrEditBg)
+	state.hEditBrush = syscall.Handle(ret)
+
+	// Fonts — scale with window width
+	titlePt := winWidth * 54 / 660
+	normalPt := winWidth * 24 / 660
+	smallPt := winWidth * 20 / 660
+	state.hTitleFont = makeFont("Segoe UI", titlePt, true)
+	state.hNormalFont = makeFont("Segoe UI", normalPt, false)
+	state.hSmallFont = makeFont("Segoe UI", smallPt, false)
+
+	// App icon
+	ret, _, _ = loadImageW.Call(hInst, uintptr(1), imageIcon, uintptr(iconSz), uintptr(iconSz), 0)
+	state.hIcon = syscall.Handle(ret)
+
+	// UAC shield icon — try multiple methods
+	ret, _, _ = loadImageW.Call(0, uintptr(106), imageIcon, 0, 0, 0x00008000) // OIC_SHIELD=106, LR_SHARED
+	if ret == 0 {
+		ret, _, _ = loadIconW.Call(0, uintptr(32518)) // IDI_SHIELD fallback
+	}
+	state.hShieldIcon = syscall.Handle(ret)
+
+	// Register window class
+	className := utf16Ptr("FastFlixInstaller")
+	cursor, _, _ := user32DLL.NewProc("LoadCursorW").Call(0, uintptr(32512))
+
+	wc := wndClassExW{
+		Size:       uint32(unsafe.Sizeof(wndClassExW{})),
+		Style:      0x0003,
+		WndProc:    syscall.NewCallback(wndProc),
+		Instance:   state.hInstance,
+		Icon:       state.hIcon,
+		Cursor:     syscall.Handle(cursor),
+		Background: state.hBgBrush,
+		ClassName:  className,
+		IconSm:     state.hIcon,
+	}
+	registerClassExW.Call(uintptr(unsafe.Pointer(&wc)))
+
+	posX := (int(screenW) - winWidth) / 2
+	posY := (int(screenH) - winHeight) / 2
+
+	hwnd, _, _ := createWindowExW.Call(
+		wsExComposited,
+		uintptr(unsafe.Pointer(className)),
+		uintptr(unsafe.Pointer(utf16Ptr("FastFlix Installer"))),
+		0x00800000, // WS_BORDER only — no title bar, no system menu
+		uintptr(posX), uintptr(posY), uintptr(winWidth), uintptr(winHeight),
+		0, 0, hInst, 0,
+	)
+	state.hwnd = syscall.Handle(hwnd)
+
+	// Dark title bar
+	var dark int32 = 1
+	dwmSetWindowAttribute.Call(hwnd, 20, uintptr(unsafe.Pointer(&dark)), 4)
+
+	// Window icon
+	if state.hIcon != 0 {
+		sendMessageW.Call(hwnd, wmSetIcon, 0, uintptr(state.hIcon))
+		sendMessageW.Call(hwnd, wmSetIcon, 1, uintptr(state.hIcon))
+	}
+
+	// Detect existing installs and process state BEFORE creating controls
+	detectExistingInstall()
+	state.processRunning = fastflixRunning()
+
+	createControls(hwnd, hInst)
+
+	// Check process every 10 seconds
+	setTimer.Call(hwnd, idtProcCheck, 10000, 0)
+
+	showWindow.Call(hwnd, swShow)
+	updateWindow.Call(hwnd)
+
+	// Message loop
+	var m msg
+	for {
+		r, _, _ := getMessageW.Call(uintptr(unsafe.Pointer(&m)), 0, 0, 0)
+		if r == 0 {
+			break
+		}
+		translateMessage.Call(uintptr(unsafe.Pointer(&m)))
+		dispatchMessageW.Call(uintptr(unsafe.Pointer(&m)))
+	}
+}
+
+const bsAutoRadioButton = 0x00000009
+
+func createControls(hwnd, hInst uintptr) {
+	cx := int32(winWidth)
+	pad := cx * 9 / 100 // ~9% padding on each side
+	btnW := cx - pad*2
+	btnH := int32(winHeight) * 7 / 100 // button height ~7% of window
+
+	// --- Checkbox + Terms link as a single owner-drawn button ---
+	// This eliminates the gap between "the" and "Terms" since we draw it all ourselves
+	y := int32(winHeight) * 50 / 100
+	agreeW := cx * 65 / 100
+	agreeX := (cx - agreeW) / 2
+	ctlH := int32(winHeight) * 4 / 100
+
+	// Hide agree checkbox if we need to uninstall first
+	agreeStyle := uint32(wsChild | wsTabStop | bsOwnerDraw)
+	if !state.existingFound {
+		agreeStyle |= wsVisible
+	}
+	state.hAgree = createCtl("BUTTON", "",
+		agreeStyle,
+		agreeX, y, agreeW, ctlH, idcAgree, hwnd, hInst)
+
+	// Terms link is hidden — clicks on the "Terms and Conditions" part of the
+	// owner-drawn button are detected in WM_LBUTTONUP by hit-testing
+	state.hTerms = 0 // no separate control
+
+	y += int32(winHeight) * 8 / 100
+
+	// Uninstall button
+	uninstallText := "Uninstall previous version"
+	if len(state.existingInstalls) > 1 {
+		uninstallText = "Uninstall previous versions"
+	}
+	uninstallStyle := uint32(wsChild | wsTabStop | bsOwnerDraw)
+	if state.existingFound {
+		uninstallStyle |= wsVisible
+	}
+	state.hUninstallBtn = createCtl("BUTTON", uninstallText, uninstallStyle,
+		pad, y, btnW, btnH, idcUninstall, hwnd, hInst)
+	if state.processRunning {
+		enableWindow.Call(uintptr(state.hUninstallBtn), 0)
+	}
+
+	// Remember where the uninstall button is for placing install buttons at the same Y
+	uninstallY := y
+
+	y += btnH + ctlH/4
+
+	// Info label showing where previous installs were found (only if existing)
+	infoStyle := uint32(wsChild | ssCenter)
+	if state.existingFound {
+		infoStyle |= wsVisible
+	}
+	infoH := ctlH * int32(len(state.existingInstalls))
+	if infoH < ctlH {
+		infoH = ctlH
+	}
+	state.hInstallInfo = createCtl("STATIC", buildInstallInfoText(),
+		infoStyle, pad, y, btnW, infoH, idcInstInfo, hwnd, hInst)
+	setFont(state.hInstallInfo, state.hSmallFont)
+
+	// Install buttons — placed at same Y as uninstall button (they swap visibility)
+	installY := uninstallY
+	installStyle := uint32(wsChild | wsTabStop | bsOwnerDraw)
+	if !state.existingFound {
+		installStyle |= wsVisible
+	}
+
+	state.hUserBtn = createCtl("BUTTON", "Install for just me", installStyle,
+		pad, installY, btnW, btnH, idcUser, hwnd, hInst)
+	enableWindow.Call(uintptr(state.hUserBtn), 0)
+
+	installY += btnH + btnH*20/100
+
+	state.hAllBtn = createCtl("BUTTON", "Install for all users", installStyle,
+		pad, installY, btnW, btnH, idcAll, hwnd, hInst)
+	enableWindow.Call(uintptr(state.hAllBtn), 0)
+
+	y = installY + btnH + btnH*40/100
+
+	// Warning label (below buttons area)
+	warningStyle := uint32(wsChild | ssCenter)
+	if state.processRunning {
+		warningStyle |= wsVisible
+	}
+	warnH := int32(winHeight) * 5 / 100
+	state.hWarning = createCtl("STATIC",
+		"\u26D4  FastFlix is currently running, please close it to continue",
+		warningStyle, pad/2, y, cx-pad, warnH, idcWarning, hwnd, hInst)
+	setFont(state.hWarning, state.hNormalFont)
+
+	// --- Install progress + ad area (all hidden until install starts) ---
+	// Progress bar right below the title/version area (~48%)
+	progY := int32(winHeight) * 53 / 100
+	progH := int32(winHeight) * 3 / 100
+	labelH := int32(winHeight) * 4 / 100
+
+	state.hProgress = createCtl("STATIC", "",
+		wsChild|ssOwnerDraw, pad, progY, btnW, progH, idcProgress, hwnd, hInst)
+
+	state.hProgLabel = createCtl("STATIC", "",
+		wsChild|ssCenter, pad, progY+progH+labelH/4, btnW, labelH, idcProgLabel, hwnd, hInst)
+	setFont(state.hProgLabel, state.hNormalFont)
+
+	// Launch button near bottom (hidden until install completes)
+	launchY := int32(winHeight) - btnH - int32(winHeight)*12/100
+	state.hLaunchBtn = createCtl("BUTTON", "Launch FastFlix",
+		wsChild|wsTabStop|bsOwnerDraw,
+		pad, launchY, btnW, btnH, idcLaunch, hwnd, hInst)
+
+	// Close button — small, centered at bottom, visible during uninstall/install screens
+	closeBtnW := cx * 20 / 100
+	closeBtnH := int32(winHeight) * 4 / 100
+	closeY := int32(winHeight) - closeBtnH - int32(winHeight)*13/100
+	state.hCloseBtn = createCtl("BUTTON", "Close",
+		wsChild|wsVisible|wsTabStop|bsOwnerDraw,
+		(cx-closeBtnW)/2, closeY, closeBtnW, closeBtnH, idcClose, hwnd, hInst)
+}
+
+func createCtl(class, text string, style uint32, x, y, w, h int32, id int, parent, hInst uintptr) syscall.Handle {
+	h2, _, _ := createWindowExW.Call(0,
+		uintptr(unsafe.Pointer(utf16Ptr(class))),
+		uintptr(unsafe.Pointer(utf16Ptr(text))),
+		uintptr(style),
+		uintptr(x), uintptr(y), uintptr(w), uintptr(h),
+		parent, uintptr(id), hInst, 0)
+	return syscall.Handle(h2)
+}
+
+func setFont(hwnd, hFont syscall.Handle) {
+	sendMessageW.Call(uintptr(hwnd), wmSetFont, uintptr(hFont), 1)
+}
+
+func makeFont(family string, size int, bold bool) syscall.Handle {
+	weight := int32(400)
+	if bold {
+		weight = 700
+	}
+	h, _, _ := createFontW.Call(uintptr(uint32(-size)), 0, 0, 0,
+		uintptr(weight), 0, 0, 0, 1, 0, 0, 5, 0,
+		uintptr(unsafe.Pointer(utf16Ptr(family))))
+	return syscall.Handle(h)
+}
+
+func setText(hwnd syscall.Handle, text string) {
+	setWindowTextW.Call(uintptr(hwnd), uintptr(unsafe.Pointer(utf16Ptr(text))))
+}
+
+func sleepMs(ms uint32) {
+	kernel32DLL.NewProc("Sleep").Call(uintptr(ms))
+}
+
+// --- Window procedure ---
+
+func wndProc(hwnd syscall.Handle, m uint32, wParam, lParam uintptr) uintptr {
+	switch m {
+	case wmPaint:
+		paintWindow(hwnd)
+		return 0
+	case wmCtlColorStatic:
+		hdc := syscall.Handle(wParam)
+		ctl := syscall.Handle(lParam)
+		setTextColor.Call(uintptr(hdc), clrText)
+		setBkMode.Call(uintptr(hdc), transparent)
+		if ctl == state.hWarning {
+			setTextColor.Call(uintptr(hdc), clrRed)
+		}
+		return uintptr(state.hBgBrush)
+	case wmCtlColorBtn:
+		return uintptr(state.hBgBrush)
+	case wmDrawItem:
+		dis := *(**drawItemStruct)(unsafe.Pointer(&lParam))
+		if dis.HwndItem == state.hProgress {
+			drawProgressBar(dis)
+		} else {
+			drawButton(dis)
+		}
+		return 1
+	case wmCommand:
+		handleCommand(int(wParam&0xFFFF), int((wParam>>16)&0xFFFF))
+		return 0
+	case wmTimer:
+		if int(wParam) == idtProcCheck {
+			checkProcessTimer()
+		}
+		return 0
+	case wmClose:
+		destroyWindow.Call(uintptr(hwnd))
+		return 0
+	case wmDestroy:
+		postQuitMessage.Call(0)
+		return 0
+	}
+	ret, _, _ := defWindowProcW.Call(uintptr(hwnd), uintptr(m), wParam, lParam)
+	return ret
+}
+
+func paintWindow(hwnd syscall.Handle) {
+	var ps paintStruct
+	hdc, _, _ := beginPaint.Call(uintptr(hwnd), uintptr(unsafe.Pointer(&ps)))
+
+	var rc rect
+	getClientRectProc.Call(uintptr(hwnd), uintptr(unsafe.Pointer(&rc)))
+	fillRectProc.Call(hdc, uintptr(unsafe.Pointer(&rc)), uintptr(state.hBgBrush))
+
+	// Icon centered at top (~16% of window height margin)
+	iconTop := int32(winHeight) * 16 / 100
+	if state.hIcon != 0 {
+		iconX := (int32(winWidth) - int32(iconSz)) / 2
+		drawIconEx.Call(hdc, uintptr(iconX), uintptr(iconTop), uintptr(state.hIcon),
+			uintptr(iconSz), uintptr(iconSz), 0, 0, 3)
+	}
+
+	setBkMode.Call(hdc, transparent)
+
+	// "FastFlix" title — gap below icon (~4% of window height)
+	titleGap := int32(winHeight) * 4 / 100
+	titleY := iconTop + int32(iconSz) + titleGap
+	setTextColor.Call(hdc, clrText)
+	selectObject.Call(hdc, uintptr(state.hTitleFont))
+	titleH := int32(winHeight) * 7 / 100
+	titleR := rect{0, titleY, int32(winWidth), titleY + titleH}
+	drawTextW.Call(hdc, uintptr(unsafe.Pointer(utf16Ptr("FastFlix"))),
+		uintptr(len("FastFlix")), uintptr(unsafe.Pointer(&titleR)), dtCenter|dtSingleLine)
+
+	// Version — tight below title
+	setTextColor.Call(hdc, clrSubtext)
+	selectObject.Call(hdc, uintptr(state.hNormalFont))
+	ver := "version " + Version
+	if BuildDate != "" {
+		ver += " (" + BuildDate + ")"
+	}
+	verY := titleY + titleH - int32(winHeight)*1/100
+	verH := int32(winHeight) * 4 / 100
+	verR := rect{0, verY, int32(winWidth), verY + verH}
+	drawTextW.Call(hdc, uintptr(unsafe.Pointer(utf16Ptr(ver))),
+		uintptr(len(ver)), uintptr(unsafe.Pointer(&verR)), dtCenter|dtSingleLine)
+
+	endPaint.Call(uintptr(hwnd), uintptr(unsafe.Pointer(&ps)))
+}
+
+var (
+	procEllipse   = gdi32DLL.NewProc("Ellipse")
+	procCreatePen = gdi32DLL.NewProc("CreatePen")
+	procRoundRect = gdi32DLL.NewProc("RoundRect")
+)
+
+func drawButton(dis *drawItemStruct) {
+	hdc := dis.HDC
+	rc := dis.RcItem
+	disabled := dis.ItemState&0x0004 != 0
+	isUninstall := dis.HwndItem == state.hUninstallBtn
+	isAllUsers := dis.HwndItem == state.hAllBtn
+	showShield := (isAllUsers || (isUninstall && state.uninstallNeedsAdmin)) && state.hShieldIcon != 0
+	isAgree := dis.HwndItem == state.hAgree
+
+	// --- Special drawing for the agree checkbox ---
+	if isAgree {
+		drawAgreeCheckbox(uintptr(hdc), rc)
+		return
+	}
+
+	bgColor := uintptr(clrBtnBg)
+	txtColor := uintptr(clrBtnText)
+	if isUninstall {
+		bgColor = clrBtnRed
+		txtColor = clrText
+		if disabled {
+			bgColor = clrBtnRedDis
+			txtColor = clrSubtext
+		}
+	} else if disabled {
+		bgColor = clrBtnDis
+		txtColor = clrSubtext
+	}
+
+	// Clear button area with window bg (so rounded corners don't show square artifacts)
+	fillRectProc.Call(uintptr(hdc), uintptr(unsafe.Pointer(&rc)), uintptr(state.hBgBrush))
+
+	// Rounded rectangle background
+	cornerR := (rc.Bottom - rc.Top) / 4 // corner radius = 25% of button height
+	brush, _, _ := createSolidBrush.Call(bgColor)
+	// Need a null pen so RoundRect doesn't draw an outline
+	nullPen, _, _ := procCreatePen.Call(5, 0, 0) // PS_NULL
+	oldBrush, _, _ := selectObject.Call(uintptr(hdc), brush)
+	oldPen2, _, _ := selectObject.Call(uintptr(hdc), nullPen)
+	procRoundRect.Call(uintptr(hdc),
+		uintptr(rc.Left), uintptr(rc.Top), uintptr(rc.Right), uintptr(rc.Bottom),
+		uintptr(cornerR), uintptr(cornerR))
+	selectObject.Call(uintptr(hdc), oldBrush)
+	selectObject.Call(uintptr(hdc), oldPen2)
+	deleteObject.Call(brush)
+	deleteObject.Call(nullPen)
+
+	setBkMode.Call(uintptr(hdc), transparent)
+	setTextColor.Call(uintptr(hdc), txtColor)
+	selectObject.Call(uintptr(hdc), uintptr(state.hNormalFont))
+
+	buf := make([]uint16, 256)
+	getWindowTextW.Call(uintptr(dis.HwndItem), uintptr(unsafe.Pointer(&buf[0])), 256)
+	text := syscall.UTF16ToString(buf)
+
+	// Shield icon size relative to button height
+	shieldSz := (rc.Bottom - rc.Top) * 40 / 100
+	if shieldSz < 16 {
+		shieldSz = 16
+	}
+	if showShield {
+		// Measure text width to place shield right beside it
+		var measureR rect
+		drawTextW.Call(uintptr(hdc), uintptr(unsafe.Pointer(utf16Ptr(text))),
+			uintptr(len(text)), uintptr(unsafe.Pointer(&measureR)),
+			dtSingleLine|0x00000400) // DT_CALCRECT
+
+		// Total width = text + gap + shield, centered in button
+		gap := shieldSz / 3
+		totalW := measureR.Right + gap + shieldSz
+		startX := rc.Left + (rc.Right-rc.Left-totalW)/2
+
+		// Draw text
+		textRc := rect{startX, rc.Top, startX + measureR.Right, rc.Bottom}
+		drawTextW.Call(uintptr(hdc), uintptr(unsafe.Pointer(utf16Ptr(text))),
+			uintptr(len(text)), uintptr(unsafe.Pointer(&textRc)), dtSingleLine|dtVCenter)
+
+		// Draw shield right after text
+		shieldX := startX + measureR.Right + gap
+		shieldY := rc.Top + (rc.Bottom-rc.Top-shieldSz)/2
+		drawIconEx.Call(uintptr(hdc), uintptr(shieldX), uintptr(shieldY),
+			uintptr(state.hShieldIcon), uintptr(shieldSz), uintptr(shieldSz), 0, 0, 3)
+	} else {
+		drawTextW.Call(uintptr(hdc), uintptr(unsafe.Pointer(utf16Ptr(text))),
+			uintptr(len(text)), uintptr(unsafe.Pointer(&rc)), dtCenter|dtSingleLine|dtVCenter)
+	}
+}
+
+func drawAgreeCheckbox(hdc uintptr, rc rect) {
+	h := rc.Bottom - rc.Top
+	// Fill background
+	fillRectProc.Call(hdc, uintptr(unsafe.Pointer(&rc)), uintptr(state.hBgBrush))
+
+	setBkMode.Call(hdc, transparent)
+	selectObject.Call(hdc, uintptr(state.hNormalFont))
+
+	// Draw circle (radio indicator) — scaled to row height
+	circleR := h * 25 / 100 // radius (compact)
+	circleCX := rc.Left + circleR + h*15/100
+	circleCY := rc.Top + h/2
+
+	// Circle outline — 3px thick for visibility
+	penWidth := uintptr(3)
+	if circleR > 12 {
+		penWidth = 4
+	}
+	pen, _, _ := procCreatePen.Call(0, penWidth, clrAccent) // PS_SOLID, thick, accent color
+	oldPen, _, _ := selectObject.Call(hdc, pen)
+	if state.agreeChecked {
+		// Filled circle
+		br, _, _ := createSolidBrush.Call(clrAccent)
+		oldBr, _, _ := selectObject.Call(hdc, br)
+		procEllipse.Call(hdc,
+			uintptr(circleCX-circleR), uintptr(circleCY-circleR),
+			uintptr(circleCX+circleR), uintptr(circleCY+circleR))
+		selectObject.Call(hdc, oldBr)
+		deleteObject.Call(br)
+	} else {
+		// Empty circle
+		nullBrush, _, _ := gdi32DLL.NewProc("GetStockObject").Call(5) // HOLLOW_BRUSH
+		oldBr, _, _ := selectObject.Call(hdc, nullBrush)
+		procEllipse.Call(hdc,
+			uintptr(circleCX-circleR), uintptr(circleCY-circleR),
+			uintptr(circleCX+circleR), uintptr(circleCY+circleR))
+		selectObject.Call(hdc, oldBr)
+	}
+	selectObject.Call(hdc, oldPen)
+	deleteObject.Call(pen)
+
+	// Text starts after circle
+	textX := circleCX + circleR + h*15/100
+
+	// "I Agree to the " in normal text color
+	setTextColor.Call(hdc, clrText)
+	agreeStr := "I Agree to the "
+	agreeR := rect{textX, rc.Top, rc.Right, rc.Bottom}
+	drawTextW.Call(hdc, uintptr(unsafe.Pointer(utf16Ptr(agreeStr))),
+		uintptr(len(agreeStr)), uintptr(unsafe.Pointer(&agreeR)), dtSingleLine|dtVCenter)
+
+	// Measure "I Agree to the " width to position the link text
+	var measureR rect
+	drawTextW.Call(hdc, uintptr(unsafe.Pointer(utf16Ptr(agreeStr))),
+		uintptr(len(agreeStr)), uintptr(unsafe.Pointer(&measureR)), dtSingleLine|0x00000400) // DT_CALCRECT
+
+	// "Terms and Conditions" in accent color — immediately after
+	termsX := textX + measureR.Right
+	setTextColor.Call(hdc, clrAccent)
+	termsStr := "Terms and Conditions"
+	termsR := rect{termsX, rc.Top, rc.Right, rc.Bottom}
+	drawTextW.Call(hdc, uintptr(unsafe.Pointer(utf16Ptr(termsStr))),
+		uintptr(len(termsStr)), uintptr(unsafe.Pointer(&termsR)), dtSingleLine|dtVCenter)
+
+	// Store the terms link X boundary for hit-testing
+	state.termsLinkX = termsX
+}
+
+func drawProgressBar(dis *drawItemStruct) {
+	hdc := uintptr(dis.HDC)
+	rc := dis.RcItem
+	cornerR := (rc.Bottom - rc.Top) / 3
+
+	// Dark background track
+	bgBrush, _, _ := createSolidBrush.Call(0x00222222) // very dark gray
+	nullPen, _, _ := procCreatePen.Call(5, 0, 0)       // PS_NULL
+	oldBr, _, _ := selectObject.Call(hdc, bgBrush)
+	oldPn, _, _ := selectObject.Call(hdc, nullPen)
+	procRoundRect.Call(hdc,
+		uintptr(rc.Left), uintptr(rc.Top), uintptr(rc.Right), uintptr(rc.Bottom),
+		uintptr(cornerR), uintptr(cornerR))
+
+	// Filled portion
+	if state.progressValue > 0 {
+		fillW := (rc.Right - rc.Left) * int32(state.progressValue) / 100
+		if fillW < cornerR*2 {
+			fillW = cornerR * 2 // minimum width for rounded rect to look right
+		}
+		fillBrush, _, _ := createSolidBrush.Call(clrBtnBg) // accent color
+		selectObject.Call(hdc, fillBrush)
+		procRoundRect.Call(hdc,
+			uintptr(rc.Left), uintptr(rc.Top), uintptr(rc.Left+fillW), uintptr(rc.Bottom),
+			uintptr(cornerR), uintptr(cornerR))
+		deleteObject.Call(fillBrush)
+	}
+
+	selectObject.Call(hdc, oldBr)
+	selectObject.Call(hdc, oldPn)
+	deleteObject.Call(bgBrush)
+	deleteObject.Call(nullPen)
+}
+
+func setProgress(pct int) {
+	state.progressValue = pct
+	invalidateRect.Call(uintptr(state.hProgress), 0, 1)
+}
+
+// --- Command handling ---
+
+func handleCommand(id, notif int) {
+	switch id {
+	case idcAgree:
+		// Toggle agree state and check if they clicked on the "Terms" portion
+		state.agreeChecked = !state.agreeChecked
+		invalidateRect.Call(uintptr(state.hAgree), 0, 1)
+		// Get cursor position to check if they clicked on the link text
+		var pt struct{ X, Y int32 }
+		user32DLL.NewProc("GetCursorPos").Call(uintptr(unsafe.Pointer(&pt)))
+		user32DLL.NewProc("ScreenToClient").Call(uintptr(state.hAgree), uintptr(unsafe.Pointer(&pt)))
+		if state.termsLinkX > 0 {
+			// Account for the agree button's position in the parent
+			var agreeRect rect
+			user32DLL.NewProc("GetWindowRect").Call(uintptr(state.hAgree), uintptr(unsafe.Pointer(&agreeRect)))
+			var parentRect rect
+			user32DLL.NewProc("GetWindowRect").Call(uintptr(state.hwnd), uintptr(unsafe.Pointer(&parentRect)))
+			localTermsX := state.termsLinkX - (agreeRect.Left - parentRect.Left)
+			if pt.X >= localTermsX {
+				// Clicked on "Terms and Conditions" — open dialog
+				// Undo the toggle since this was a link click, not an agree click
+				state.agreeChecked = !state.agreeChecked
+				invalidateRect.Call(uintptr(state.hAgree), 0, 1)
+				showScrollableDialog("Terms and Conditions", termsAndLicensesText)
+			}
+		}
+		updateButtonState()
+	case idcUninstall:
+		if notif == bnClicked {
+			go onUninstallClicked() // Run in goroutine to keep UI responsive
+		}
+	case idcUser:
+		if notif == bnClicked {
+			go doInstallFromGUI(modeUser)
+		}
+	case idcAll:
+		if notif == bnClicked {
+			go doInstallForAllUsers()
+		}
+	case idcClose:
+		postQuitMessage.Call(0)
+	case idcLaunch:
+		// Accept any notification — owner-drawn buttons may send different codes
+		exePath := filepath.Join(state.installedDir, "FastFlix.exe")
+		if state.installedDir == "" {
+			messageBox("Error", "Install directory not set", 0x10)
+			return
+		}
+		if _, err := os.Stat(exePath); err != nil {
+			messageBox("Error", "FastFlix.exe not found at:\n"+exePath, 0x10)
+			return
+		}
+		// Launch via cmd.exe /c start "" "path" to get a fully detached process with console
+		cmd := fmt.Sprintf(`/c start "" "%s"`, exePath)
+		cmdPtr, _ := syscall.UTF16PtrFromString(cmd)
+		exeCmd, _ := syscall.UTF16PtrFromString("cmd.exe")
+		dirPtr, _ := syscall.UTF16PtrFromString(state.installedDir)
+		shell32 := syscall.NewLazyDLL("shell32.dll")
+		shell32.NewProc("ShellExecuteW").Call(
+			0, 0, // NULL verb = "open"
+			uintptr(unsafe.Pointer(exeCmd)),
+			uintptr(unsafe.Pointer(cmdPtr)),
+			uintptr(unsafe.Pointer(dirPtr)),
+			0) // SW_HIDE for the cmd, FastFlix opens its own window
+		postQuitMessage.Call(0)
+	}
+}
+
+func updateButtonState() {
+	agreed := state.agreeChecked
+
+	// Uninstall button
+	if state.existingFound && !state.previousRemoved {
+		can := agreed && !state.processRunning && !state.installing
+		e := uintptr(0)
+		if can {
+			e = 1
+		}
+		enableWindow.Call(uintptr(state.hUninstallBtn), e)
+		invalidateRect.Call(uintptr(state.hUninstallBtn), 0, 1)
+	}
+
+	// Install buttons
+	canInstall := agreed && !state.processRunning && !state.installing && !state.existingFound
+	e := uintptr(0)
+	if canInstall {
+		e = 1
+	}
+	enableWindow.Call(uintptr(state.hUserBtn), e)
+	enableWindow.Call(uintptr(state.hAllBtn), e)
+	invalidateRect.Call(uintptr(state.hUserBtn), 0, 1)
+	invalidateRect.Call(uintptr(state.hAllBtn), 0, 1)
+}
+
+func onUninstallClicked() {
+	// Re-check if FastFlix is running right now
+	if fastflixRunning() {
+		state.processRunning = true
+		showWindow.Call(uintptr(state.hWarning), swShow)
+		enableWindow.Call(uintptr(state.hUninstallBtn), 0)
+		invalidateRect.Call(uintptr(state.hUninstallBtn), 0, 1)
+		messageBox("FastFlix Running",
+			"FastFlix is currently running.\n\nPlease close FastFlix before uninstalling.", 0x30)
+		return
+	}
+
+	enableWindow.Call(uintptr(state.hUninstallBtn), 0)
+	setText(state.hUninstallBtn, "Uninstalling...")
+	invalidateRect.Call(uintptr(state.hUninstallBtn), 0, 1)
+
+	installs := findAllExistingInstalls()
+
+	// Installs in a protected path (Program Files) are removed by ONE elevated helper run (single UAC prompt):
+	// it deletes the files we installed (user files are kept), all HKLM keys and the common Start Menu entry.
+	var protectedDirs []string
+	needsElevation := false
+	for _, inst := range installs {
+		if installNeedsAdmin(inst) {
+			needsElevation = true
+			if inst.InstallDir != "" {
+				if _, err := os.Stat(inst.InstallDir); err == nil {
+					protectedDirs = append(protectedDirs, inst.InstallDir)
+				}
+			}
+		}
+	}
+	if needsElevation && !ffinstall.IsAdmin() {
+		setText(state.hUninstallBtn, "Removing (elevated)...")
+		invalidateRect.Call(uintptr(state.hUninstallBtn), 0, 1)
+		if ok, detail := elevatedUninstall(protectedDirs); !ok {
+			messageBox("Administrator Access Required",
+				"The previous installation is in a protected location (Program Files).\n\n"+
+					"Administrator access is required to remove it ("+detail+"). Please click Uninstall again and accept the permission prompt.",
+				0x30)
+			resetUninstallButton()
+			return
+		}
+	}
+
+	// Clean up all installs directly — we don't call existing uninstallers
+	// because they may be old installer builds that show UI or hit mutex issues.
+	// cleanupInstallation handles: dirs, shortcuts, desktop icons, registry.
+	for _, inst := range installs {
+		cleanupInstallation(inst)
+	}
+
+	// Final verify — only transition if installs are actually gone
+	remaining := findAllExistingInstalls()
+	if len(remaining) > 0 {
+		// Try one more cleanup pass
+		for _, inst := range remaining {
+			cleanupInstallation(inst)
+		}
+		remaining = findAllExistingInstalls()
+	}
+
+	if len(remaining) > 0 {
+		// Check if it's just orphaned registry (dirs actually gone) vs real remaining files
+		var realRemaining []string
+		for _, inst := range remaining {
+			if inst.InstallDir != "" {
+				// Only FastFlix files count; preserved user files (fastflix.yaml) do not
+				if ffinstall.LooksInstalled(inst.InstallDir) {
+					realRemaining = append(realRemaining, inst.InstallDir)
+				}
+			}
+		}
+
+		if len(realRemaining) > 0 {
+			// Directories still exist — show error
+			msg := "The following could not be fully removed:\n\n" + strings.Join(realRemaining, "\n")
+			msg += "\n\nThis may require administrator permissions or the files may be in use."
+			msg += "\nPlease try again or remove manually."
+			messageBox("Uninstall Incomplete", msg, 0x30)
+			resetUninstallButton()
+			return
+		}
+		// Dirs are gone but registry lingers — clean it up and continue
+		cleanAllRegistryKeys()
+	}
+
+	// Uninstall succeeded — show agree checkbox + install buttons
+	state.previousRemoved = true
+	state.existingFound = false
+	showWindow.Call(uintptr(state.hUninstallBtn), swHide)
+	showWindow.Call(uintptr(state.hInstallInfo), swHide)
+	showWindow.Call(uintptr(state.hAgree), swShow)
+	showWindow.Call(uintptr(state.hUserBtn), swShow)
+	showWindow.Call(uintptr(state.hAllBtn), swShow)
+	updateButtonState()
+}
+
+// showPostInstallScreen hides progress and shows the launch button.
+func showPostInstallScreen() {
+	showWindow.Call(uintptr(state.hProgress), swHide)
+	showWindow.Call(uintptr(state.hProgLabel), swHide)
+
+	showWindow.Call(uintptr(state.hLaunchBtn), swShow)
+	setText(state.hLaunchBtn, "Launch FastFlix")
+	enableWindow.Call(uintptr(state.hLaunchBtn), 1)
+}
+
+func resetUninstallButton() {
+	resetText := "Uninstall previous version"
+	if len(state.existingInstalls) > 1 {
+		resetText = "Uninstall previous versions"
+	}
+	setText(state.hUninstallBtn, resetText)
+	enableWindow.Call(uintptr(state.hUninstallBtn), 1)
+	invalidateRect.Call(uintptr(state.hUninstallBtn), 0, 1)
+}
+
+func checkProcessTimer() {
+	running := fastflixRunning()
+	if running != state.processRunning {
+		state.processRunning = running
+		if running {
+			showWindow.Call(uintptr(state.hWarning), swShow)
+		} else {
+			showWindow.Call(uintptr(state.hWarning), swHide)
+		}
+		updateButtonState()
+	}
+}
+
+func detectExistingInstall() {
+	installs := findAllExistingInstalls()
+	if len(installs) == 0 {
+		return
+	}
+
+	// Filter: only keep installs where the directory has a real FastFlix install. A folder holding only
+	// leftovers (e.g. a portable fastflix.yaml or an orphaned uninstall.exe) is NOT deleted here -- nothing is
+	// removed before the user consents -- it is simply not treated as an install.
+	var real []existingInstall
+	for _, inst := range installs {
+		if inst.InstallDir != "" {
+			ffExe := filepath.Join(inst.InstallDir, "FastFlix.exe")
+			pythonDir := filepath.Join(inst.InstallDir, "python")
+			if _, err := os.Stat(ffExe); err == nil {
+				real = append(real, inst)
+			} else if _, err := os.Stat(pythonDir); err == nil {
+				real = append(real, inst)
+			}
+		}
+	}
+
+	// Orphaned registry keys (directory is gone entirely) are stale Add/Remove Programs entries of ours;
+	// drop them so they don't linger. Never touch anything on disk here.
+	if len(real) == 0 {
+		allGone := true
+		for _, inst := range installs {
+			if inst.InstallDir != "" {
+				if _, err := os.Stat(inst.InstallDir); err == nil {
+					allGone = false
+				}
+			}
+		}
+		if allGone {
+			cleanAllRegistryKeys()
+		}
+		return // No actual installs on disk — skip uninstall screen
+	}
+
+	state.existingFound = true
+	state.existingInstalls = real
+	state.existingDir = real[0].InstallDir
+	for _, inst := range real {
+		if inst.Version != "" {
+			state.existingVersion = inst.Version
+			break
+		}
+	}
+	for _, inst := range real {
+		if installNeedsAdmin(inst) {
+			state.uninstallNeedsAdmin = true
+			break
+		}
+	}
+}
+
+// buildInstallInfoText creates a human-readable summary of where previous installs were found.
+func buildInstallInfoText() string {
+	var lines []string
+	programFiles := os.Getenv("ProgramFiles")
+	localAppData := os.Getenv("LOCALAPPDATA")
+
+	for _, inst := range state.existingInstalls {
+		ver := inst.Version
+		if ver == "" {
+			ver = "unknown version"
+		}
+		location := inst.InstallDir
+		if programFiles != "" && ffinstall.IsWithin(programFiles, inst.InstallDir) {
+			location = "Program Files"
+		} else if localAppData != "" && ffinstall.IsWithin(localAppData, inst.InstallDir) {
+			location = "Local Apps"
+		}
+		lines = append(lines, fmt.Sprintf("%s found in %s", ver, location))
+	}
+	return strings.Join(lines, "\n")
+}
+
+func doInstallFromGUI(mode installMode) {
+	state.installing = true
+	updateButtonState()
+
+	// Hide controls, show progress
+	for _, h := range []syscall.Handle{state.hAgree, state.hUserBtn, state.hAllBtn, state.hWarning, state.hUninstallBtn, state.hInstallInfo, state.hCloseBtn} {
+		showWindow.Call(uintptr(h), swHide)
+	}
+	showWindow.Call(uintptr(state.hProgress), swShow)
+	showWindow.Call(uintptr(state.hProgLabel), swShow)
+	setText(state.hProgLabel, "Installing...")
+
+	installDir, regRoot, startMenu := installPaths(mode)
+
+	lastPct := -1
+	err := installFiles(installDir, func(current, total int) {
+		pct := (current * 95) / total // 0-95% for extraction
+		if pct != lastPct {           // only update on actual change
+			lastPct = pct
+			setProgress(pct)
+			setText(state.hProgLabel, fmt.Sprintf("Installing... %d%%", pct))
+		}
+	})
+	if err != nil {
+		// installFiles already removed the partially extracted files
+		os.Remove(installDir)
+		state.installing = false
+		messageBox("Installation Failed", "Failed to extract files:\n"+err.Error(), 0x10)
+		postQuitMessage.Call(0)
+		return
+	}
+
+	setText(state.hProgLabel, "Finalizing...")
+	setProgress(95)
+
+	writeRegistry(installDir, regRoot)
+	writeInstalledSize(installDir, regRoot)
+	shortcutErr := createShortcuts(installDir, startMenu)
+
+	setProgress(100)
+	setText(state.hProgLabel, "Installation complete!")
+	if shortcutErr != nil {
+		messageBox("Shortcut Not Created",
+			"FastFlix was installed, but the Start Menu shortcut could not be created:\n"+shortcutErr.Error(), 0x30)
+	}
+
+	state.installedDir = installDir
+	showPostInstallScreen()
+}
+
+// doInstallForAllUsers triggers UAC immediately, then the elevated process does everything.
+// The GUI stays visible and polls for completion.
+func doInstallForAllUsers() {
+	state.installing = true
+	updateButtonState()
+
+	installDir, _, _ := installPaths(modeAllUsers)
+
+	// Trigger UAC IMMEDIATELY — elevated process does extract + registry + shortcuts. The result comes back
+	// as the process exit code; nothing user-writable is shared with the elevated process.
+	proc, declined, launchErr := launchElevated(fmt.Sprintf(`--elevated-install --dest "%s"`, installDir))
+	if declined || launchErr != nil {
+		state.installing = false
+		updateButtonState()
+		if launchErr != nil {
+			messageBox("Installation Failed", "Could not start the elevated installer:\n"+launchErr.Error(), 0x10)
+		}
+		return
+	}
+
+	// UAC accepted — now show progress
+	for _, h := range []syscall.Handle{state.hAgree, state.hUserBtn, state.hAllBtn, state.hWarning, state.hUninstallBtn, state.hInstallInfo, state.hCloseBtn} {
+		showWindow.Call(uintptr(h), swHide)
+	}
+	showWindow.Call(uintptr(state.hProgress), swShow)
+	showWindow.Call(uintptr(state.hProgLabel), swShow)
+	setText(state.hProgLabel, "Installing to Program Files...")
+
+	// Wait for completion with smooth animated progress (ease-out curve: fast at start, slows towards 95%)
+	code, done := waitElevated(proc, 300, func(i int) {
+		pct := int(95.0 * (1.0 - math.Exp(-float64(i)/30.0)))
+		if pct > 95 {
+			pct = 95
+		}
+		setProgress(pct)
+		setText(state.hProgLabel, fmt.Sprintf("Installing to Program Files... %d%%", pct))
+	})
+
+	if !done || (code != exitOK && code != exitOKWithWarnings) {
+		var msg string
+		if !done {
+			msg = "The installation timed out and may be incomplete."
+		} else {
+			msg = "The installation failed:\n" + describeExit(code)
+		}
+		state.installing = false
+		messageBox("Installation Failed", msg, 0x10)
+		postQuitMessage.Call(0)
+		return
+	}
+
+	setProgress(100)
+	setText(state.hProgLabel, "Installation complete!")
+	if code == exitOKWithWarnings {
+		messageBox("Shortcut Not Created",
+			"FastFlix was installed, but the Start Menu shortcut could not be created.", 0x30)
+	}
+
+	state.installedDir = installDir
+	showPostInstallScreen()
+}
+
+// --- Scrollable text dialog ---
+
+var dlgState struct {
+	hEdit  syscall.Handle
+	hClose syscall.Handle
+}
+
+func showScrollableDialog(title, content string) {
+	hInst := state.hInstance
+	className := utf16Ptr("FastFlixDialog")
+	cursor, _, _ := user32DLL.NewProc("LoadCursorW").Call(0, uintptr(32512))
+
+	wc := wndClassExW{
+		Size:       uint32(unsafe.Sizeof(wndClassExW{})),
+		Style:      0x0003,
+		WndProc:    syscall.NewCallback(dialogWndProc),
+		Instance:   hInst,
+		Cursor:     syscall.Handle(cursor),
+		Background: state.hBgBrush,
+		ClassName:  className,
+	}
+	registerClassExW.Call(uintptr(unsafe.Pointer(&wc)))
+
+	screenW, _, _ := getSystemMetrics.Call(smCXScreen)
+	screenH, _, _ := getSystemMetrics.Call(smCYScreen)
+	// Dialog: 35% of screen width, 50% of screen height
+	dlgW := int32(screenW) * 35 / 100
+	dlgH := int32(screenH) * 50 / 100
+	if dlgW < 500 {
+		dlgW = 500
+	}
+	if dlgH < 400 {
+		dlgH = 400
+	}
+	posX := (int(screenW) - int(dlgW)) / 2
+	posY := (int(screenH) - int(dlgH)) / 2
+	dlgPad := dlgW * 2 / 100 // 2% padding
+
+	hwnd, _, _ := createWindowExW.Call(0,
+		uintptr(unsafe.Pointer(className)),
+		uintptr(unsafe.Pointer(utf16Ptr(title))),
+		wsOverlapped|wsCaption|wsSysMenu,
+		uintptr(posX), uintptr(posY), uintptr(dlgW), uintptr(dlgH),
+		uintptr(state.hwnd), 0, uintptr(hInst), 0)
+
+	var dark int32 = 1
+	dwmSetWindowAttribute.Call(hwnd, 20, uintptr(unsafe.Pointer(&dark)), 4)
+
+	// Edit control fills most of the dialog
+	btnH := dlgH * 7 / 100
+	editH := dlgH - dlgPad*2 - btnH - dlgPad*3
+	dlgState.hEdit = createCtl("EDIT", "",
+		wsChild|wsVisible|wsVScroll|wsBorder|esMultiline|esReadOnly|esAutoVScroll|wsTabStop,
+		dlgPad, dlgPad, dlgW-dlgPad*2-16, editH, idcDlgEdit, hwnd, uintptr(hInst))
+	setFont(dlgState.hEdit, state.hSmallFont)
+	editMargin := dlgW * 2 / 100
+	sendMessageW.Call(uintptr(dlgState.hEdit), emSetMargins, 3, uintptr(editMargin|(editMargin<<16)))
+	sendMessageW.Call(uintptr(dlgState.hEdit), wmSetText, 0, uintptr(unsafe.Pointer(utf16Ptr(content))))
+
+	// Close button centered at bottom
+	closeBtnW := dlgW * 25 / 100
+	dlgState.hClose = createCtl("BUTTON", "Close",
+		wsChild|wsVisible|wsTabStop|bsOwnerDraw,
+		(dlgW-closeBtnW)/2, dlgPad+editH+dlgPad, closeBtnW, btnH, idcDlgClose, hwnd, uintptr(hInst))
+
+	showWindow.Call(hwnd, swShow)
+	updateWindow.Call(hwnd)
+	enableWindow.Call(uintptr(state.hwnd), 0)
+
+	var m msg
+	for {
+		r, _, _ := getMessageW.Call(uintptr(unsafe.Pointer(&m)), 0, 0, 0)
+		if r == 0 {
+			break
+		}
+		alive, _, _ := isWindowProc.Call(hwnd)
+		if alive == 0 {
+			break
+		}
+		translateMessage.Call(uintptr(unsafe.Pointer(&m)))
+		dispatchMessageW.Call(uintptr(unsafe.Pointer(&m)))
+	}
+
+	enableWindow.Call(uintptr(state.hwnd), 1)
+	setForegroundWindow.Call(uintptr(state.hwnd))
+}
+
+func dialogWndProc(hwnd syscall.Handle, m uint32, wParam, lParam uintptr) uintptr {
+	switch m {
+	case wmCtlColorStatic, wmCtlColorEdit:
+		hdc := syscall.Handle(wParam)
+		setTextColor.Call(uintptr(hdc), clrText)
+		// IMPORTANT: Use OPAQUE mode for EDIT controls, not TRANSPARENT.
+		// TRANSPARENT causes garbled text as redraws paint over previous text.
+		setBkMode.Call(uintptr(hdc), 2) // OPAQUE
+		gdi32DLL.NewProc("SetBkColor").Call(uintptr(hdc), clrEditBg)
+		return uintptr(state.hEditBrush)
+	case wmDrawItem:
+		drawButton(*(**drawItemStruct)(unsafe.Pointer(&lParam)))
+		return 1
+	case wmCommand:
+		if int(wParam&0xFFFF) == idcDlgClose {
+			destroyWindow.Call(uintptr(hwnd))
+			return 0
+		}
+	case wmClose:
+		destroyWindow.Call(uintptr(hwnd))
+		return 0
+	case wmDestroy:
+		postQuitMessage.Call(0)
+		return 0
+	}
+	ret, _, _ := defWindowProcW.Call(uintptr(hwnd), uintptr(m), wParam, lParam)
+	return ret
+}
diff --git a/cmd/installer/winres/icon.ico b/cmd/installer/winres/icon.ico
new file mode 100644
index 00000000..7fe27dfb
Binary files /dev/null and b/cmd/installer/winres/icon.ico differ
diff --git a/cmd/installer/winres/winres.json b/cmd/installer/winres/winres.json
new file mode 100644
index 00000000..cf77a31a
--- /dev/null
+++ b/cmd/installer/winres/winres.json
@@ -0,0 +1,44 @@
+{
+  "RT_GROUP_ICON": {
+    "#1": {
+      "0000": "icon.ico"
+    }
+  },
+  "RT_MANIFEST": {
+    "#1": {
+      "0409": {
+        "identity": {
+          "name": "FastFlix.Installer",
+          "version": "6.3.0.0"
+        },
+        "description": "FastFlix Installer",
+        "minimum-os": "win10",
+        "execution-level": "asInvoker",
+        "dpi-awareness": "system",
+        "use-common-controls": true
+      }
+    }
+  },
+  "RT_VERSION": {
+    "#1": {
+      "0000": {
+        "fixed": {
+          "file_version": "6.3.0.0",
+          "product_version": "6.3.0.0"
+        },
+        "info": {
+          "0409": {
+            "CompanyName": "Chris Griffith",
+            "FileDescription": "FastFlix Installer",
+            "FileVersion": "6.3.0",
+            "InternalName": "FastFlix.Installer",
+            "LegalCopyright": "(c) Chris Griffith 2019-2026",
+            "OriginalFilename": "FastFlix_installer.exe",
+            "ProductName": "FastFlix",
+            "ProductVersion": "6.3.0"
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/cmd/internal/ffinstall/ffinstall.go b/cmd/internal/ffinstall/ffinstall.go
new file mode 100644
index 00000000..156ac06c
--- /dev/null
+++ b/cmd/internal/ffinstall/ffinstall.go
@@ -0,0 +1,377 @@
+// Package ffinstall holds the safety-critical helpers shared by the FastFlix installer and uninstaller:
+// path validation, manifest-based file removal, registry cleanup, process detection and self-deletion.
+package ffinstall
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"unsafe"
+
+	"golang.org/x/sys/windows"
+	"golang.org/x/sys/windows/registry"
+)
+
+const (
+	// ProductName is the registry / Start Menu / folder name.
+	ProductName = "FastFlix"
+	// ManifestName lists every file the installer extracted (relative paths, one per line).
+	ManifestName = "install_manifest.txt"
+	// UserConfigName is the portable-mode config. It is user data and is never deleted by an uninstall.
+	UserConfigName = "fastflix.yaml"
+)
+
+// distEntries are the top-level entries of the distribution, used when an install has no manifest
+// (installs made before manifests existed).
+var distEntries = []string{
+	"python", "lib", "FastFlix.exe", "uninstall.exe", "CHANGES", "build-licenses.txt", "build_version", "LICENSE",
+	ManifestName,
+}
+
+// RegistryUninstallPaths are the Add/Remove Programs keys (64-bit view and the WOW6432Node view used by the
+// old 32-bit NSIS installer).
+var RegistryUninstallPaths = []string{
+	`Software\Microsoft\Windows\CurrentVersion\Uninstall\` + ProductName,
+	`Software\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\` + ProductName,
+}
+
+// RegistryAppPaths are the per-application keys (Install_Dir) in both registry views.
+var RegistryAppPaths = []string{
+	`SOFTWARE\` + ProductName,
+	`SOFTWARE\WOW6432Node\` + ProductName,
+}
+
+// IsAdmin reports whether the current process token is elevated.
+func IsAdmin() bool {
+	return windows.GetCurrentProcessToken().IsElevated()
+}
+
+// ValidatePathString rejects strings that must never be handed to ShellExecute / batch files: empty paths,
+// non-absolute paths, quotes, control characters and characters that are invalid in Windows paths.
+// (No path is ever passed through cmd.exe for deletion; the batch script used for self-deletion escapes
+// '%' itself, so '&', '^' and '%' are legal here.)
+func ValidatePathString(p string) error {
+	if strings.TrimSpace(p) == "" {
+		return errors.New("empty path")
+	}
+	if !filepath.IsAbs(p) {
+		return fmt.Errorf("path is not absolute: %q", p)
+	}
+	for _, r := range p {
+		if r < 0x20 || strings.ContainsRune(`"<>|*?`, r) {
+			return fmt.Errorf("path contains an illegal character: %q", p)
+		}
+	}
+	return nil
+}
+
+// IsWithin reports whether child is parent itself or lies beneath it (separator-aware, case-insensitive).
+func IsWithin(parent, child string) bool {
+	p := filepath.Clean(parent)
+	c := filepath.Clean(child)
+	if len(c) < len(p) || !strings.EqualFold(c[:len(p)], p) {
+		return false
+	}
+	return len(c) == len(p) || strings.HasSuffix(p, `\`) || c[len(p)] == filepath.Separator
+}
+
+// IsProtectedPath reports whether dir lies under Program Files (needs admin to modify).
+func IsProtectedPath(dir string) bool {
+	for _, env := range []string{"ProgramFiles", "ProgramW6432", "ProgramFiles(x86)"} {
+		if root := os.Getenv(env); root != "" && IsWithin(root, dir) {
+			return true
+		}
+	}
+	return false
+}
+
+// forbiddenRoots are directories that must never be removed (nor any of their parents).
+func forbiddenRoots() []string {
+	var roots []string
+	for _, env := range []string{
+		"ProgramFiles", "ProgramW6432", "ProgramFiles(x86)", "SystemRoot", "windir", "SystemDrive",
+		"USERPROFILE", "LOCALAPPDATA", "APPDATA", "ProgramData", "PUBLIC", "TEMP", "TMP",
+	} {
+		if v := os.Getenv(env); v != "" {
+			if env == "SystemDrive" {
+				v += `\`
+			}
+			roots = append(roots, v)
+		}
+	}
+	// Per-user "Programs" parent
+	if la := os.Getenv("LOCALAPPDATA"); la != "" {
+		roots = append(roots, filepath.Join(la, "Programs"))
+	}
+	return roots
+}
+
+// exists reports whether name exists in dir.
+func exists(dir, name string) bool {
+	_, err := os.Stat(filepath.Join(dir, name))
+	return err == nil
+}
+
+// LooksInstalled reports whether dir is a FastFlix install: FastFlix.exe must exist AND at least one other
+// install artifact (the manifest, uninstall.exe or the python runtime). A bare uninstall.exe or python folder
+// is not proof of anything.
+func LooksInstalled(dir string) bool {
+	if !exists(dir, "FastFlix.exe") {
+		return false
+	}
+	return exists(dir, ManifestName) || exists(dir, "uninstall.exe") || exists(dir, "python")
+}
+
+// SafeToRemove returns nil only if dir is plausibly a FastFlix install directory that is safe to delete from.
+func SafeToRemove(dir string) error {
+	if err := ValidatePathString(dir); err != nil {
+		return err
+	}
+	clean := filepath.Clean(dir)
+	if vol := filepath.VolumeName(clean); len(clean) <= len(vol)+1 {
+		return fmt.Errorf("refusing to remove drive root: %q", dir)
+	}
+	for _, root := range forbiddenRoots() {
+		// dir must not be one of the roots, nor an ancestor of one of them
+		if IsWithin(clean, root) {
+			return fmt.Errorf("refusing to remove protected location: %q", dir)
+		}
+	}
+	if !LooksInstalled(clean) {
+		return fmt.Errorf("%q does not contain a FastFlix installation", dir)
+	}
+	return nil
+}
+
+// ReadManifest returns the relative paths recorded by the installer, or nil if there is no manifest.
+func ReadManifest(dir string) []string {
+	f, err := os.Open(filepath.Join(dir, ManifestName))
+	if err != nil {
+		return nil
+	}
+	defer f.Close()
+	var files []string
+	sc := bufio.NewScanner(f)
+	sc.Buffer(make([]byte, 0, 64*1024), 1024*1024)
+	for sc.Scan() {
+		if line := strings.TrimSpace(sc.Text()); line != "" {
+			files = append(files, line)
+		}
+	}
+	return files
+}
+
+// WriteManifest records the extracted files (relative paths) so an uninstall removes only what we installed.
+func WriteManifest(dir string, files []string) error {
+	return os.WriteFile(filepath.Join(dir, ManifestName), []byte(strings.Join(files, "\r\n")+"\r\n"), 0644)
+}
+
+// topLevelNames returns the distinct first path components of the given relative paths.
+func topLevelNames(files []string) []string {
+	seen := map[string]bool{}
+	var out []string
+	for _, f := range files {
+		f = filepath.ToSlash(f)
+		name := strings.SplitN(f, "/", 2)[0]
+		if name == "" || name == "." || name == ".." || seen[strings.ToLower(name)] {
+			continue
+		}
+		seen[strings.ToLower(name)] = true
+		out = append(out, name)
+	}
+	return out
+}
+
+// RemoveOwned deletes the given top-level entries of dir (directories recursively), except self, then removes
+// dir if (and only if) it is empty. Anything else in dir (portable fastflix.yaml, user files) is left alone.
+func RemoveOwned(dir string, names []string, self string) error {
+	var firstErr error
+	for _, name := range names {
+		p := filepath.Join(dir, name)
+		if !IsWithin(dir, p) || strings.EqualFold(filepath.Clean(p), filepath.Clean(self)) {
+			continue
+		}
+		if err := os.RemoveAll(p); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	os.Remove(dir) // non-recursive: fails harmlessly while user files or self remain
+	return firstErr
+}
+
+// RemoveInstalledFiles removes a FastFlix installation from dir without touching user files.
+// With a manifest only the top-level entries it names are removed; without one, the known distribution
+// entries are removed (or, for legacy PyInstaller/NSIS installs, everything except the portable config).
+// self (the running uninstaller) is skipped so it can be deleted after exit.
+func RemoveInstalledFiles(dir, self string) error {
+	if err := SafeToRemove(dir); err != nil {
+		return err
+	}
+	if files := ReadManifest(dir); files != nil {
+		return RemoveOwned(dir, append(topLevelNames(files), ManifestName), self)
+	}
+	if _, err := os.Stat(filepath.Join(dir, "python")); err == nil {
+		return RemoveOwned(dir, distEntries, self)
+	}
+	// Legacy one-folder install (old PyInstaller/NSIS): remove everything but user config. Because this deletes
+	// the whole folder, demand much stronger evidence: the folder must be named FastFlix and hold both
+	// FastFlix.exe and uninstall.exe.
+	if !strings.EqualFold(filepath.Base(filepath.Clean(dir)), ProductName) ||
+		!exists(dir, "FastFlix.exe") || !exists(dir, "uninstall.exe") {
+		return fmt.Errorf("refusing to remove %q: not a recognizable legacy FastFlix install folder", dir)
+	}
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return err
+	}
+	var names []string
+	for _, e := range entries {
+		if !strings.EqualFold(e.Name(), UserConfigName) {
+			names = append(names, e.Name())
+		}
+	}
+	return RemoveOwned(dir, names, self)
+}
+
+// RemoveExtracted cleans up after a failed extraction: removes the top-level entries named by files.
+func RemoveExtracted(dir string, files []string) {
+	RemoveOwned(dir, topLevelNames(files), "")
+}
+
+// CleanRegistry deletes FastFlix's Add/Remove Programs and application keys (both registry views) under root.
+func CleanRegistry(root registry.Key) {
+	for _, p := range RegistryUninstallPaths {
+		registry.DeleteKey(root, p)
+	}
+	for _, p := range RegistryAppPaths {
+		registry.DeleteKey(root, p)
+	}
+}
+
+// ReadInstallDirFromRegistry looks for the install directory recorded by FastFlix (or the NSIS installer)
+// under root, checking InstallLocation and Install_Dir in both the 64-bit and 32-bit registry views.
+func ReadInstallDirFromRegistry(root registry.Key) string {
+	for _, view := range []uint32{0, registry.WOW64_32KEY} {
+		if k, err := registry.OpenKey(root, RegistryUninstallPaths[0], registry.QUERY_VALUE|view); err == nil {
+			dir, _, _ := k.GetStringValue("InstallLocation")
+			k.Close()
+			if dir != "" {
+				return dir
+			}
+		}
+		if k, err := registry.OpenKey(root, RegistryAppPaths[0], registry.QUERY_VALUE|view); err == nil {
+			dir, _, _ := k.GetStringValue("Install_Dir")
+			k.Close()
+			if dir != "" {
+				return dir
+			}
+		}
+	}
+	return ""
+}
+
+// IsRunning reports whether FastFlix is running: FastFlix.exe by name, or an orphaned python.exe /
+// pythonw.exe whose image lives inside one of dirs (the launcher's child keeps running if the launcher dies).
+func IsRunning(dirs ...string) bool {
+	snap, err := windows.CreateToolhelp32Snapshot(windows.TH32CS_SNAPPROCESS, 0)
+	if err != nil {
+		return false
+	}
+	defer windows.CloseHandle(snap)
+
+	var pe windows.ProcessEntry32
+	pe.Size = uint32(unsafe.Sizeof(pe))
+	if windows.Process32First(snap, &pe) != nil {
+		return false
+	}
+	for {
+		name := windows.UTF16ToString(pe.ExeFile[:])
+		if strings.EqualFold(name, "FastFlix.exe") {
+			return true
+		}
+		if len(dirs) > 0 && (strings.EqualFold(name, "python.exe") || strings.EqualFold(name, "pythonw.exe")) {
+			if img := processImagePath(pe.ProcessID); img != "" {
+				for _, d := range dirs {
+					if d != "" && IsWithin(d, img) {
+						return true
+					}
+				}
+			}
+		}
+		if windows.Process32Next(snap, &pe) != nil {
+			break
+		}
+	}
+	return false
+}
+
+func processImagePath(pid uint32) string {
+	h, err := windows.OpenProcess(windows.PROCESS_QUERY_LIMITED_INFORMATION, false, pid)
+	if err != nil {
+		return ""
+	}
+	defer windows.CloseHandle(h)
+	buf := make([]uint16, windows.MAX_LONG_PATH)
+	size := uint32(len(buf))
+	if windows.QueryFullProcessImageName(h, 0, &buf[0], &size) != nil {
+		return ""
+	}
+	return windows.UTF16ToString(buf[:size])
+}
+
+// ScheduleSelfDelete deletes self and then (if empty) dir after the current process exits. It writes a temp
+// .bat that retries until the exe is unlocked and then deletes itself, and runs it hidden and detached.
+// The paths are passed through environment variables (UTF-16 in the process environment) rather than written
+// into the script, so non-ASCII, '%' or '&' characters in them need no batch escaping or code page handling.
+func ScheduleSelfDelete(self, dir string) error {
+	if err := ValidatePathString(self); err != nil {
+		return err
+	}
+	if err := ValidatePathString(dir); err != nil {
+		return err
+	}
+	script := "@echo off\r\n" +
+		"setlocal\r\n" +
+		"set n=0\r\n" +
+		":retry\r\n" +
+		"set /a n+=1\r\n" +
+		"ping 127.0.0.1 -n 2 >nul\r\n" +
+		"del /f /q \"%FF_CLEANUP_SELF%\" >nul 2>&1\r\n" +
+		"if exist \"%FF_CLEANUP_SELF%\" if %n% lss 60 goto retry\r\n" +
+		"rmdir \"%FF_CLEANUP_DIR%\" >nul 2>&1\r\n" +
+		"(goto) 2>nul & del \"%~f0\"\r\n"
+
+	f, err := os.CreateTemp("", "fastflix-cleanup-*.bat")
+	if err != nil {
+		return err
+	}
+	bat := f.Name()
+	if _, err := f.WriteString(script); err != nil {
+		f.Close()
+		os.Remove(bat)
+		return err
+	}
+	f.Close()
+
+	// CREATE_NO_WINDOW gives cmd a hidden console that ping inherits. DETACHED_PROCESS must not be used: with no
+	// console at all, every console child (ping) would pop up its own visible window.
+	const createNoWindow = 0x08000000
+	cmdExe := filepath.Join(os.Getenv("SystemRoot"), "System32", "cmd.exe")
+	cmd := exec.Command(cmdExe)
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		CmdLine:       `"` + cmdExe + `" /d /c ""` + bat + `""`,
+		HideWindow:    true,
+		CreationFlags: createNoWindow,
+	}
+	cmd.Env = append(os.Environ(), "FF_CLEANUP_SELF="+self, "FF_CLEANUP_DIR="+dir)
+	if err := cmd.Start(); err != nil {
+		os.Remove(bat)
+		return err
+	}
+	return cmd.Process.Release()
+}
diff --git a/cmd/internal/ffinstall/ffinstall_test.go b/cmd/internal/ffinstall/ffinstall_test.go
new file mode 100644
index 00000000..cb996154
--- /dev/null
+++ b/cmd/internal/ffinstall/ffinstall_test.go
@@ -0,0 +1,201 @@
+package ffinstall
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestIsWithin(t *testing.T) {
+	cases := []struct {
+		parent, child string
+		want          bool
+	}{
+		{`C:\Program Files`, `C:\Program Files\FastFlix`, true},
+		{`C:\Program Files`, `c:\program files`, true},
+		{`C:\Program Files`, `C:\Program Files (x86)\FastFlix`, false}, // prefix without separator
+		{`C:\Program Files`, `C:\Program FilesEvil`, false},
+		{`C:\`, `C:\Users`, true},
+	}
+	for _, c := range cases {
+		if got := IsWithin(c.parent, c.child); got != c.want {
+			t.Errorf("IsWithin(%q, %q) = %v, want %v", c.parent, c.child, got, c.want)
+		}
+	}
+}
+
+func TestValidatePathString(t *testing.T) {
+	for _, bad := range []string{"", "relative\\dir", `C:\a"b`, "C:\\a\nb", `C:\a|b`} {
+		if ValidatePathString(bad) == nil {
+			t.Errorf("expected %q to be rejected", bad)
+		}
+	}
+	if err := ValidatePathString(`C:\Users\Tom & Jerry\FastFlix`); err != nil {
+		t.Errorf("unexpected rejection: %v", err)
+	}
+}
+
+func TestSafeToRemoveRefusesRootsAndUnmarked(t *testing.T) {
+	for _, dir := range []string{`C:\`, os.Getenv("ProgramFiles"), os.Getenv("USERPROFILE"), os.Getenv("LOCALAPPDATA"), `C:\Users`} {
+		if dir == "" {
+			continue
+		}
+		if SafeToRemove(dir) == nil {
+			t.Errorf("SafeToRemove(%q) should refuse", dir)
+		}
+	}
+	empty := t.TempDir()
+	if SafeToRemove(empty) == nil {
+		t.Error("directory without a FastFlix marker should be refused")
+	}
+}
+
+func TestRemoveInstalledFilesKeepsUserFiles(t *testing.T) {
+	dir := filepath.Join(t.TempDir(), "FastFlix")
+	must := func(err error) {
+		t.Helper()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	must(os.MkdirAll(filepath.Join(dir, "python"), 0755))
+	must(os.MkdirAll(filepath.Join(dir, "lib", "pkg", "__pycache__"), 0755))
+	must(os.WriteFile(filepath.Join(dir, "python", "python.exe"), []byte("x"), 0644))
+	must(os.WriteFile(filepath.Join(dir, "lib", "pkg", "__pycache__", "m.pyc"), []byte("x"), 0644)) // runtime litter
+	must(os.WriteFile(filepath.Join(dir, "FastFlix.exe"), []byte("x"), 0644))
+	must(os.WriteFile(filepath.Join(dir, "uninstall.exe"), []byte("x"), 0644))
+	must(os.WriteFile(filepath.Join(dir, UserConfigName), []byte("cfg"), 0644))
+	must(WriteManifest(dir, []string{"python/python.exe", "lib/pkg/__init__.py", "FastFlix.exe", "uninstall.exe"}))
+
+	self := filepath.Join(dir, "uninstall.exe")
+	must(RemoveInstalledFiles(dir, self))
+
+	for _, gone := range []string{"python", "lib", "FastFlix.exe", ManifestName} {
+		if _, err := os.Stat(filepath.Join(dir, gone)); err == nil {
+			t.Errorf("%s should have been removed", gone)
+		}
+	}
+	for _, kept := range []string{UserConfigName, "uninstall.exe"} {
+		if _, err := os.Stat(filepath.Join(dir, kept)); err != nil {
+			t.Errorf("%s should have been kept: %v", kept, err)
+		}
+	}
+}
+
+func writeFiles(t *testing.T, dir string, files ...string) {
+	t.Helper()
+	for _, f := range files {
+		p := filepath.Join(dir, f)
+		if filepath.Ext(f) == "" && f == "python" {
+			if err := os.MkdirAll(p, 0755); err != nil {
+				t.Fatal(err)
+			}
+			continue
+		}
+		if err := os.MkdirAll(filepath.Dir(p), 0755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(p, []byte("x"), 0644); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func TestLooksInstalledRequiresFastFlixExe(t *testing.T) {
+	cases := []struct {
+		name  string
+		files []string
+		want  bool
+	}{
+		{"only uninstall.exe", []string{"uninstall.exe"}, false},
+		{"only python", []string{"python"}, false},
+		{"only FastFlix.exe", []string{"FastFlix.exe"}, false},
+		{"exe + uninstall", []string{"FastFlix.exe", "uninstall.exe"}, true},
+		{"exe + python", []string{"FastFlix.exe", "python"}, true},
+		{"exe + manifest", []string{"FastFlix.exe", ManifestName}, true},
+	}
+	for _, c := range cases {
+		dir := t.TempDir()
+		writeFiles(t, dir, c.files...)
+		if got := LooksInstalled(dir); got != c.want {
+			t.Errorf("%s: LooksInstalled = %v, want %v", c.name, got, c.want)
+		}
+	}
+}
+
+func TestRemoveInstalledFilesRefusesWeakEvidence(t *testing.T) {
+	for _, files := range [][]string{{"uninstall.exe", "a.txt"}, {"python", "a.txt"}} {
+		dir := filepath.Join(t.TempDir(), "FastFlix")
+		writeFiles(t, dir, files...)
+		if RemoveInstalledFiles(dir, "") == nil {
+			t.Errorf("%v: should be refused", files)
+		}
+		if !exists(dir, "a.txt") {
+			t.Errorf("%v: user file was deleted", files)
+		}
+	}
+}
+
+func TestRemoveInstalledFilesLegacyBranch(t *testing.T) {
+	// Wrong folder name: refused, nothing deleted
+	bad := filepath.Join(t.TempDir(), "Documents")
+	writeFiles(t, bad, "FastFlix.exe", "uninstall.exe", "precious.docx")
+	if RemoveInstalledFiles(bad, "") == nil {
+		t.Error("legacy removal should be refused when the folder is not named FastFlix")
+	}
+	if !exists(bad, "precious.docx") || !exists(bad, "FastFlix.exe") {
+		t.Error("refused legacy removal must not delete anything")
+	}
+
+	// FastFlix.exe without uninstall.exe (named correctly): refused
+	noUn := filepath.Join(t.TempDir(), "FastFlix")
+	writeFiles(t, noUn, "FastFlix.exe", "other.dll")
+	if LooksInstalled(noUn) {
+		t.Fatal("exe alone should not look installed")
+	}
+	if RemoveInstalledFiles(noUn, "") == nil {
+		t.Error("legacy removal should be refused without uninstall.exe")
+	}
+
+	// Proper legacy install: everything but fastflix.yaml goes
+	good := filepath.Join(t.TempDir(), "fastflix")
+	writeFiles(t, good, "FastFlix.exe", "uninstall.exe", "old.dll", UserConfigName)
+	if err := RemoveInstalledFiles(good, ""); err != nil {
+		t.Fatal(err)
+	}
+	if exists(good, "old.dll") || exists(good, "FastFlix.exe") {
+		t.Error("legacy files should have been removed")
+	}
+	if !exists(good, UserConfigName) {
+		t.Error("fastflix.yaml should have been kept")
+	}
+}
+
+func TestScheduleSelfDelete(t *testing.T) {
+	for _, name := range []string{"FastFlix", "FastFlix José", "Fast & Flix", "Fast 100%"} {
+		t.Run(name, func(t *testing.T) { testScheduleSelfDelete(t, name) })
+	}
+}
+
+func testScheduleSelfDelete(t *testing.T, name string) {
+	dir := filepath.Join(t.TempDir(), name)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	self := filepath.Join(dir, "uninstall.exe")
+	if err := os.WriteFile(self, []byte("x"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	if err := ScheduleSelfDelete(self, dir); err != nil {
+		t.Fatal(err)
+	}
+	deadline := time.Now().Add(20 * time.Second)
+	for time.Now().Before(deadline) {
+		if _, err := os.Stat(dir); err != nil {
+			return
+		}
+		time.Sleep(500 * time.Millisecond)
+	}
+	t.Fatal("self-delete batch did not remove the file and folder")
+}
diff --git a/cmd/launcher/main.go b/cmd/launcher/main.go
new file mode 100644
index 00000000..b70e4563
--- /dev/null
+++ b/cmd/launcher/main.go
@@ -0,0 +1,141 @@
+// FastFlix Launcher
+//
+// Native Go binary that launches FastFlix via Python's embeddable distribution.
+// Replaces PyInstaller to avoid antivirus false positives caused by the
+// PyInstaller bootloader's temp-extraction behavior.
+//
+// Build: go build -ldflags="-s -w -X main.Version=6.3.0 -X main.BuildDate=2026-01-01" -o FastFlix.exe ./cmd/launcher
+// (scripts/build_distribution.py does this and runs go-winres first.)
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"unsafe"
+)
+
+// Version and BuildDate are set at build time via -ldflags
+var Version = "dev"
+var BuildDate = "" // format: 2006-01-02
+
+func main() {
+	// Resolve install directory from the launcher's own location
+	exePath, err := os.Executable()
+	if err != nil {
+		fatal("Cannot resolve executable path: %v", err)
+	}
+	installDir := filepath.Dir(exePath)
+
+	// Handle CLI flags
+	if len(os.Args) > 1 {
+		switch os.Args[1] {
+		case "--version":
+			if BuildDate != "" {
+				fmt.Printf("FastFlix %s (built %s)\n", Version, BuildDate)
+			} else {
+				fmt.Printf("FastFlix %s\n", Version)
+			}
+			os.Exit(0)
+		case "--help":
+			fmt.Printf("FastFlix %s\n", Version)
+			fmt.Println("Usage: FastFlix.exe [--version] [--test] [--help]")
+			os.Exit(0)
+		}
+	}
+
+	// Normal launch (and --test): use python.exe (console visible for log output) and pass every
+	// argument through to FastFlix, so e.g. "FastFlix.exe movie.mkv" or "--test" reach `python -m fastflix`.
+	runPython(installDir, "python.exe", os.Args[1:])
+}
+
+func runPython(installDir, pythonBin string, extraArgs []string) {
+	pythonDir := filepath.Join(installDir, "python")
+	libDir := filepath.Join(installDir, "lib")
+	pythonExe := filepath.Join(pythonDir, pythonBin)
+
+	// Verify Python exists
+	if _, err := os.Stat(pythonExe); os.IsNotExist(err) {
+		fatal("Python not found at %s\nPlease reinstall FastFlix.", pythonExe)
+	}
+
+	// Build environment. PYTHONHOME/PYTHONPATH are intentionally NOT set: the embeddable distribution's
+	// python313._pth file (see scripts/build_distribution.py) fixes sys.path, including ../lib, and makes
+	// Python ignore those variables.
+	env := os.Environ()
+	env = setEnv(env, "FASTFLIX_BUNDLED", "1")
+
+	// Detect portable mode: fastflix.yaml next to the launcher
+	portableConfig := filepath.Join(installDir, "fastflix.yaml")
+	if _, err := os.Stat(portableConfig); err == nil {
+		env = setEnv(env, "FASTFLIX_PORTABLE", "1")
+	}
+
+	// Prepend python/ and lib/PySide6/ to PATH for DLL discovery
+	currentPath := os.Getenv("PATH")
+	pyside6Dir := filepath.Join(libDir, "PySide6")
+	newPath := pythonDir + ";" + pyside6Dir + ";" + currentPath
+	env = setEnv(env, "PATH", newPath)
+
+	// Set QT_PLUGIN_PATH so PySide6 finds its plugins
+	env = setEnv(env, "QT_PLUGIN_PATH", filepath.Join(pyside6Dir, "plugins"))
+
+	// Build command: python -m fastflix [args...]
+	args := append([]string{pythonExe, "-m", "fastflix"}, extraArgs...)
+
+	// Set working directory to install dir so base_path resolves correctly
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Dir = installDir
+	cmd.Env = env
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Stdin = os.Stdin
+
+	if err := cmd.Run(); err != nil {
+		if exitErr, ok := err.(*exec.ExitError); ok {
+			os.Exit(exitErr.ExitCode())
+		}
+		fatal("Failed to start FastFlix: %v", err)
+	}
+}
+
+// setEnv sets or replaces an environment variable in the env slice.
+func setEnv(env []string, key, value string) []string {
+	prefix := key + "="
+	for i, e := range env {
+		if strings.HasPrefix(strings.ToUpper(e), strings.ToUpper(prefix)) {
+			env[i] = prefix + value
+			return env
+		}
+	}
+	return append(env, prefix+value)
+}
+
+func fatal(format string, args ...any) {
+	msg := fmt.Sprintf(format, args...)
+	// Try to show a Windows message box since we may not have a console
+	showMessageBox(msg)
+	os.Exit(1)
+}
+
+func showMessageBox(msg string) {
+	user32 := syscall.NewLazyDLL("user32.dll")
+	messageBoxW := user32.NewProc("MessageBoxW")
+
+	title, _ := syscall.UTF16PtrFromString("FastFlix Error")
+	text, _ := syscall.UTF16PtrFromString(msg)
+
+	const MB_OK = 0x00000000
+	const MB_ICONERROR = 0x00000010
+	// MessageBoxW(hWnd, lpText, lpCaption, uType)
+	messageBoxW.Call(
+		0, // NULL hWnd
+		uintptr(unsafe.Pointer(text)),
+		uintptr(unsafe.Pointer(title)),
+		uintptr(MB_OK|MB_ICONERROR),
+	)
+}
diff --git a/cmd/launcher/winres/icon.ico b/cmd/launcher/winres/icon.ico
new file mode 100644
index 00000000..7fe27dfb
Binary files /dev/null and b/cmd/launcher/winres/icon.ico differ
diff --git a/cmd/launcher/winres/winres.json b/cmd/launcher/winres/winres.json
new file mode 100644
index 00000000..dfd68700
--- /dev/null
+++ b/cmd/launcher/winres/winres.json
@@ -0,0 +1,44 @@
+{
+  "RT_GROUP_ICON": {
+    "#1": {
+      "0000": "icon.ico"
+    }
+  },
+  "RT_MANIFEST": {
+    "#1": {
+      "0409": {
+        "identity": {
+          "name": "FastFlix",
+          "version": "6.3.0.0"
+        },
+        "description": "FastFlix Video Encoder",
+        "minimum-os": "win10",
+        "execution-level": "asInvoker",
+        "dpi-awareness": "system",
+        "use-common-controls": true
+      }
+    }
+  },
+  "RT_VERSION": {
+    "#1": {
+      "0000": {
+        "fixed": {
+          "file_version": "6.3.0.0",
+          "product_version": "6.3.0.0"
+        },
+        "info": {
+          "0409": {
+            "CompanyName": "Chris Griffith",
+            "FileDescription": "FastFlix Video Encoder",
+            "FileVersion": "6.3.0",
+            "InternalName": "FastFlix",
+            "LegalCopyright": "(c) Chris Griffith 2019-2026",
+            "OriginalFilename": "FastFlix.exe",
+            "ProductName": "FastFlix",
+            "ProductVersion": "6.3.0"
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/cmd/uninstaller/main.go b/cmd/uninstaller/main.go
new file mode 100644
index 00000000..b3c4ab53
--- /dev/null
+++ b/cmd/uninstaller/main.go
@@ -0,0 +1,595 @@
+// FastFlix Standalone Uninstaller
+//
+// Dark-themed GUI that only knows how to uninstall FastFlix from its own directory.
+// Registered with Windows Add/Remove Programs. Does NOT contain installer functionality.
+//
+// Build:
+//   cd cmd/uninstaller && go-winres make && cd ../..
+//   go build -ldflags="-s -w -H windowsgui" -o uninstall.exe ./cmd/uninstaller
+//   (scripts/build_distribution.py does all of this and injects the version)
+
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"syscall"
+	"unsafe"
+
+	"github.com/cdgriffith/fastflix-installer/cmd/internal/ffinstall"
+	"golang.org/x/sys/windows/registry"
+)
+
+const productName = ffinstall.ProductName
+
+// Version is set at build time via -ldflags="-X main.Version=..."
+var Version = "dev"
+
+// Win32 API
+var (
+	user32   = syscall.NewLazyDLL("user32.dll")
+	kernel32 = syscall.NewLazyDLL("kernel32.dll")
+	gdi32    = syscall.NewLazyDLL("gdi32.dll")
+	dwmapi   = syscall.NewLazyDLL("dwmapi.dll")
+	comctl32 = syscall.NewLazyDLL("comctl32.dll")
+)
+
+// State
+var st struct {
+	hwnd       syscall.Handle
+	hInst      syscall.Handle
+	hBgBrush   syscall.Handle
+	hIcon      syscall.Handle
+	hTitleFont syscall.Handle
+	hFont      syscall.Handle
+	hSmFont    syscall.Handle
+
+	hUninstBtn syscall.Handle
+	hCloseBtn  syscall.Handle
+	hStatus    syscall.Handle
+	hProgress  syscall.Handle
+	hProgLabel syscall.Handle
+
+	installDir string
+	selfPath   string
+	regRoot    registry.Key // registry root that owns this install (HKLM for all-users, HKCU for per-user)
+	regOwned   bool         // true if that root's keys actually point at installDir
+	allUsers   bool
+	winW, winH int
+	iconSz     int
+	silent     bool
+}
+
+// Colors
+const (
+	clrBg     = 0x00333333
+	clrText   = 0x00E6E6E6
+	clrSub    = 0x00A0A0A0
+	clrBtn    = 0x004848CC // red
+	clrBtnDis = 0x00444466
+	clrBtnCls = 0x00F0D030 // cyan close
+	clrBtnTxt = 0x00FFFFFF
+	clrRed    = 0x003C3CDC
+	clrDarkBg = 0x00222222
+)
+
+// Control IDs
+const (
+	idUninstall = 101
+	idClose     = 102
+	idStatus    = 103
+	idProgress  = 104
+	idProgLabel = 105
+)
+
+type rect struct{ Left, Top, Right, Bottom int32 }
+type paintStruct struct {
+	HDC       syscall.Handle
+	Erase     int32
+	RcPaint   rect
+	Restore   int32
+	IncUpdate int32
+	Reserved  [32]byte
+}
+type msg struct {
+	Hwnd    syscall.Handle
+	Message uint32
+	WParam  uintptr
+	LParam  uintptr
+	Time    uint32
+	Pt      struct{ X, Y int32 }
+}
+type drawItemStruct struct {
+	CtlType, CtlID, ItemID, ItemAction, ItemState uint32
+	HwndItem, HDC                                 syscall.Handle
+	RcItem                                        rect
+	ItemData                                      uintptr
+}
+type wndClassExW struct {
+	Size       uint32
+	Style      uint32
+	WndProc    uintptr
+	ClsExtra   int32
+	WndExtra   int32
+	Instance   syscall.Handle
+	Icon       syscall.Handle
+	Cursor     syscall.Handle
+	Background syscall.Handle
+	MenuName   *uint16
+	ClassName  *uint16
+	IconSm     syscall.Handle
+}
+
+func utf16P(s string) *uint16 { p, _ := syscall.UTF16PtrFromString(s); return p }
+
+func main() {
+	runtime.LockOSThread()
+	args := os.Args[1:]
+	st.silent = containsArg(args, "--silent") || containsArg(args, "/S")
+
+	var err error
+	st.selfPath, err = os.Executable()
+	if err != nil {
+		os.Exit(1)
+	}
+	st.installDir = filepath.Dir(st.selfPath)
+
+	// Verify FastFlix install
+	if _, err := os.Stat(filepath.Join(st.installDir, "python")); err != nil {
+		if _, err2 := os.Stat(filepath.Join(st.installDir, "FastFlix.exe")); err2 != nil {
+			if !st.silent {
+				msgBox("FastFlix Uninstaller",
+					"No FastFlix installation found in:\n"+st.installDir+"\n\nIt may have already been removed.", 0x40)
+			}
+			os.Exit(0)
+		}
+	}
+
+	st.regRoot, st.regOwned = detectRegRoot(st.installDir, args)
+	st.allUsers = st.regRoot == registry.LOCAL_MACHINE || ffinstall.IsProtectedPath(st.installDir)
+
+	// All-users installs (HKLM / Program Files) need admin, in silent mode as well
+	if st.allUsers && !ffinstall.IsAdmin() {
+		relaunchElevated(st.selfPath, args)
+		return
+	}
+
+	// Silent mode — never remove files out from under a running FastFlix
+	if st.silent {
+		if isRunning() {
+			os.Exit(1)
+		}
+		doUninstall()
+		return
+	}
+
+	// Show GUI
+	showGUI()
+}
+
+// detectRegRoot finds which registry root registered the install living in dir. owned is false when no
+// registry key points at dir (the registry is then left untouched).
+func detectRegRoot(dir string, args []string) (root registry.Key, owned bool) {
+	for _, r := range []registry.Key{registry.CURRENT_USER, registry.LOCAL_MACHINE} {
+		if d := ffinstall.ReadInstallDirFromRegistry(r); d != "" && strings.EqualFold(filepath.Clean(d), filepath.Clean(dir)) {
+			return r, true
+		}
+	}
+	if containsArg(args, "--allusers") || ffinstall.IsProtectedPath(dir) {
+		return registry.LOCAL_MACHINE, false
+	}
+	return registry.CURRENT_USER, false
+}
+
+func showGUI() {
+	hInst, _, _ := kernel32.NewProc("GetModuleHandleW").Call(0)
+	st.hInst = syscall.Handle(hInst)
+
+	screenW, _, _ := user32.NewProc("GetSystemMetrics").Call(0)
+	screenH, _, _ := user32.NewProc("GetSystemMetrics").Call(1)
+	st.winW = int(screenW) * 20 / 100
+	if st.winW < 400 {
+		st.winW = 400
+	}
+	st.winH = st.winW * 150 / 100
+	if st.winH > int(screenH)*85/100 {
+		st.winH = int(screenH) * 85 / 100
+	}
+	st.iconSz = st.winW * 30 / 100
+	if st.iconSz > 256 {
+		st.iconSz = 256
+	}
+
+	ret, _, _ := gdi32.NewProc("CreateSolidBrush").Call(clrBg)
+	st.hBgBrush = syscall.Handle(ret)
+
+	titlePt := st.winW * 54 / 660
+	normalPt := st.winW * 24 / 660
+	smallPt := st.winW * 20 / 660
+	st.hTitleFont = mkFont("Segoe UI", titlePt, true)
+	st.hFont = mkFont("Segoe UI", normalPt, false)
+	st.hSmFont = mkFont("Segoe UI", smallPt, false)
+
+	ret, _, _ = user32.NewProc("LoadImageW").Call(hInst, 1, 1, uintptr(st.iconSz), uintptr(st.iconSz), 0)
+	st.hIcon = syscall.Handle(ret)
+
+	cls := utf16P("FastFlixUninstaller")
+	cur, _, _ := user32.NewProc("LoadCursorW").Call(0, 32512)
+	wc := wndClassExW{
+		Size: uint32(unsafe.Sizeof(wndClassExW{})), Style: 3,
+		WndProc: syscall.NewCallback(wndProc), Instance: st.hInst,
+		Icon: st.hIcon, Cursor: syscall.Handle(cur), Background: st.hBgBrush,
+		ClassName: cls, IconSm: st.hIcon,
+	}
+	user32.NewProc("RegisterClassExW").Call(uintptr(unsafe.Pointer(&wc)))
+
+	px := (int(screenW) - st.winW) / 2
+	py := (int(screenH) - st.winH) / 2
+	hwnd, _, _ := user32.NewProc("CreateWindowExW").Call(0x02000000,
+		uintptr(unsafe.Pointer(cls)), uintptr(unsafe.Pointer(utf16P("FastFlix Uninstaller"))),
+		0x00800000, // WS_BORDER
+		uintptr(px), uintptr(py), uintptr(st.winW), uintptr(st.winH), 0, 0, hInst, 0)
+	st.hwnd = syscall.Handle(hwnd)
+
+	var dark int32 = 1
+	dwmapi.NewProc("DwmSetWindowAttribute").Call(hwnd, 20, uintptr(unsafe.Pointer(&dark)), 4)
+	if st.hIcon != 0 {
+		user32.NewProc("SendMessageW").Call(hwnd, 0x0080, 0, uintptr(st.hIcon))
+		user32.NewProc("SendMessageW").Call(hwnd, 0x0080, 1, uintptr(st.hIcon))
+	}
+
+	createControls(hwnd, hInst)
+
+	// Check if running on startup
+	if isRunning() {
+		setText(st.hStatus, "\u26D4  FastFlix is running, please close it first")
+		user32.NewProc("ShowWindow").Call(uintptr(st.hStatus), 5)
+		user32.NewProc("EnableWindow").Call(uintptr(st.hUninstBtn), 0)
+		inval(st.hUninstBtn)
+	}
+
+	// Timer to check process every 10s
+	user32.NewProc("SetTimer").Call(hwnd, 1, 10000, 0)
+
+	user32.NewProc("ShowWindow").Call(hwnd, 5)
+	user32.NewProc("UpdateWindow").Call(hwnd)
+
+	var m msg
+	for {
+		r, _, _ := user32.NewProc("GetMessageW").Call(uintptr(unsafe.Pointer(&m)), 0, 0, 0)
+		if r == 0 {
+			break
+		}
+		user32.NewProc("TranslateMessage").Call(uintptr(unsafe.Pointer(&m)))
+		user32.NewProc("DispatchMessageW").Call(uintptr(unsafe.Pointer(&m)))
+	}
+}
+
+func createControls(hwnd, hInst uintptr) {
+	cx := int32(st.winW)
+	pad := cx * 9 / 100
+	btnW := cx - pad*2
+	btnH := int32(st.winH) * 7 / 100
+	ctlH := int32(st.winH) * 4 / 100
+
+	// Uninstall button at ~58%
+	y := int32(st.winH) * 58 / 100
+	st.hUninstBtn = mkCtl("BUTTON", "Uninstall FastFlix", 0x50000000|0x0000000B,
+		pad, y, btnW, btnH, idUninstall, hwnd, hInst) // WS_CHILD|WS_VISIBLE|BS_OWNERDRAW
+
+	y += btnH + ctlH/2
+	// Location info
+	loc := locationLabel()
+	mkStatic(loc, 0x50000000|0x01, pad, y, btnW, ctlH, hwnd, hInst) // SS_CENTER
+
+	y += ctlH + ctlH/2
+	// Status (hidden)
+	st.hStatus = mkCtl("STATIC", "", 0x40000000|0x01, pad, y, btnW, ctlH*2, idStatus, hwnd, hInst)
+	setFont(st.hStatus, st.hFont)
+
+	// Progress (hidden)
+	progY := int32(st.winH) * 58 / 100
+	progH := int32(st.winH) * 3 / 100
+	st.hProgress = mkCtl("STATIC", "", 0x40000000|0x0000000D, pad, progY, btnW, progH, idProgress, hwnd, hInst) // SS_OWNERDRAW
+	st.hProgLabel = mkCtl("STATIC", "", 0x40000000|0x01, pad, progY+progH+progH/2, btnW, ctlH, idProgLabel, hwnd, hInst)
+	setFont(st.hProgLabel, st.hFont)
+
+	// Close button at bottom
+	closW := cx * 20 / 100
+	closH := int32(st.winH) * 4 / 100
+	closY := int32(st.winH) - closH - int32(st.winH)*8/100
+	st.hCloseBtn = mkCtl("BUTTON", "Close", 0x50000000|0x00010000|0x0000000B,
+		(cx-closW)/2, closY, closW, closH, idClose, hwnd, hInst)
+}
+
+func locationLabel() string {
+	dirLower := strings.ToLower(st.installDir)
+	loc := st.installDir
+	if strings.Contains(dirLower, "program files") {
+		loc = "Program Files"
+	} else if strings.Contains(dirLower, "appdata") {
+		loc = "Local Apps"
+	}
+	return "Installed in " + loc
+}
+
+func wndProc(hwnd syscall.Handle, m uint32, wParam, lParam uintptr) uintptr {
+	switch m {
+	case 0x000F: // WM_PAINT
+		paint(hwnd)
+		return 0
+	case 0x0138: // WM_CTLCOLORSTATIC
+		hdc := syscall.Handle(wParam)
+		ctl := syscall.Handle(lParam)
+		gdi32.NewProc("SetTextColor").Call(uintptr(hdc), clrText)
+		gdi32.NewProc("SetBkMode").Call(uintptr(hdc), 1)
+		if ctl == st.hStatus {
+			gdi32.NewProc("SetTextColor").Call(uintptr(hdc), clrRed)
+		}
+		return uintptr(st.hBgBrush)
+	case 0x0135: // WM_CTLCOLORBTN
+		return uintptr(st.hBgBrush)
+	case 0x002B: // WM_DRAWITEM
+		dis := *(**drawItemStruct)(unsafe.Pointer(&lParam))
+		if dis.HwndItem == st.hProgress {
+			drawProgress(dis)
+		} else {
+			drawBtn(dis)
+		}
+		return 1
+	case 0x0111: // WM_COMMAND
+		id := int(wParam & 0xFFFF)
+		if id == idClose {
+			user32.NewProc("PostQuitMessage").Call(0)
+		}
+		if id == idUninstall {
+			go onUninstall()
+		}
+		return 0
+	case 0x0113: // WM_TIMER
+		checkProc()
+		return 0
+	case 0x0010: // WM_CLOSE
+		user32.NewProc("DestroyWindow").Call(uintptr(hwnd))
+		return 0
+	case 0x0002: // WM_DESTROY
+		user32.NewProc("PostQuitMessage").Call(0)
+		return 0
+	}
+	r, _, _ := user32.NewProc("DefWindowProcW").Call(uintptr(hwnd), uintptr(m), wParam, lParam)
+	return r
+}
+
+func paint(hwnd syscall.Handle) {
+	var ps paintStruct
+	hdc, _, _ := user32.NewProc("BeginPaint").Call(uintptr(hwnd), uintptr(unsafe.Pointer(&ps)))
+	var rc rect
+	user32.NewProc("GetClientRect").Call(uintptr(hwnd), uintptr(unsafe.Pointer(&rc)))
+	user32.NewProc("FillRect").Call(hdc, uintptr(unsafe.Pointer(&rc)), uintptr(st.hBgBrush))
+
+	if st.hIcon != 0 {
+		ix := (int32(st.winW) - int32(st.iconSz)) / 2
+		user32.NewProc("DrawIconEx").Call(hdc, uintptr(ix), uintptr(int32(st.winH)*16/100),
+			uintptr(st.hIcon), uintptr(st.iconSz), uintptr(st.iconSz), 0, 0, 3)
+	}
+
+	gdi32.NewProc("SetBkMode").Call(hdc, 1)
+	iconBot := int32(st.winH)*16/100 + int32(st.iconSz) + int32(st.winH)*4/100
+
+	gdi32.NewProc("SetTextColor").Call(hdc, clrText)
+	gdi32.NewProc("SelectObject").Call(hdc, uintptr(st.hTitleFont))
+	tH := int32(st.winH) * 7 / 100
+	tr := rect{0, iconBot, int32(st.winW), iconBot + tH}
+	user32.NewProc("DrawTextW").Call(hdc, uintptr(unsafe.Pointer(utf16P("FastFlix"))),
+		uintptr(len("FastFlix")), uintptr(unsafe.Pointer(&tr)), 0x21) // DT_CENTER|DT_SINGLELINE
+
+	gdi32.NewProc("SetTextColor").Call(hdc, clrSub)
+	gdi32.NewProc("SelectObject").Call(hdc, uintptr(st.hFont))
+	vr := rect{0, iconBot + tH, int32(st.winW), iconBot + tH + int32(st.winH)*4/100}
+	txt := "Uninstaller " + Version
+	user32.NewProc("DrawTextW").Call(hdc, uintptr(unsafe.Pointer(utf16P(txt))),
+		uintptr(len(txt)), uintptr(unsafe.Pointer(&vr)), 0x21)
+
+	user32.NewProc("EndPaint").Call(uintptr(hwnd), uintptr(unsafe.Pointer(&ps)))
+}
+
+var progressVal int
+
+func drawBtn(dis *drawItemStruct) {
+	hdc := uintptr(dis.HDC)
+	rc := dis.RcItem
+	disabled := dis.ItemState&0x0004 != 0
+	isClose := dis.HwndItem == st.hCloseBtn
+
+	bg := uintptr(clrBtn)
+	txt := uintptr(clrBtnTxt)
+	if isClose {
+		bg = clrBtnCls
+		txt = 0x00202020
+	}
+	if disabled {
+		bg = clrBtnDis
+		txt = clrSub
+	}
+
+	// Clear + rounded rect
+	user32.NewProc("FillRect").Call(hdc, uintptr(unsafe.Pointer(&rc)), uintptr(st.hBgBrush))
+	cornerR := (rc.Bottom - rc.Top) / 4
+	br, _, _ := gdi32.NewProc("CreateSolidBrush").Call(bg)
+	np, _, _ := gdi32.NewProc("CreatePen").Call(5, 0, 0)
+	ob, _, _ := gdi32.NewProc("SelectObject").Call(hdc, br)
+	op, _, _ := gdi32.NewProc("SelectObject").Call(hdc, np)
+	gdi32.NewProc("RoundRect").Call(hdc, uintptr(rc.Left), uintptr(rc.Top), uintptr(rc.Right), uintptr(rc.Bottom), uintptr(cornerR), uintptr(cornerR))
+	gdi32.NewProc("SelectObject").Call(hdc, ob)
+	gdi32.NewProc("SelectObject").Call(hdc, op)
+	gdi32.NewProc("DeleteObject").Call(br)
+	gdi32.NewProc("DeleteObject").Call(np)
+
+	gdi32.NewProc("SetBkMode").Call(hdc, 1)
+	gdi32.NewProc("SetTextColor").Call(hdc, txt)
+	gdi32.NewProc("SelectObject").Call(hdc, uintptr(st.hFont))
+	buf := make([]uint16, 256)
+	user32.NewProc("GetWindowTextW").Call(uintptr(dis.HwndItem), uintptr(unsafe.Pointer(&buf[0])), 256)
+	t := syscall.UTF16ToString(buf)
+	user32.NewProc("DrawTextW").Call(hdc, uintptr(unsafe.Pointer(utf16P(t))),
+		uintptr(len(t)), uintptr(unsafe.Pointer(&rc)), 0x25) // DT_CENTER|DT_SINGLELINE|DT_VCENTER
+}
+
+func drawProgress(dis *drawItemStruct) {
+	hdc := uintptr(dis.HDC)
+	rc := dis.RcItem
+	cornerR := (rc.Bottom - rc.Top) / 3
+	bg, _, _ := gdi32.NewProc("CreateSolidBrush").Call(clrDarkBg)
+	np, _, _ := gdi32.NewProc("CreatePen").Call(5, 0, 0)
+	ob, _, _ := gdi32.NewProc("SelectObject").Call(hdc, bg)
+	op, _, _ := gdi32.NewProc("SelectObject").Call(hdc, np)
+	gdi32.NewProc("RoundRect").Call(hdc, uintptr(rc.Left), uintptr(rc.Top), uintptr(rc.Right), uintptr(rc.Bottom), uintptr(cornerR), uintptr(cornerR))
+	if progressVal > 0 {
+		fillW := (rc.Right - rc.Left) * int32(progressVal) / 100
+		if fillW < cornerR*2 {
+			fillW = cornerR * 2
+		}
+		fb, _, _ := gdi32.NewProc("CreateSolidBrush").Call(clrBtnCls)
+		gdi32.NewProc("SelectObject").Call(hdc, fb)
+		gdi32.NewProc("RoundRect").Call(hdc, uintptr(rc.Left), uintptr(rc.Top), uintptr(rc.Left+fillW), uintptr(rc.Bottom), uintptr(cornerR), uintptr(cornerR))
+		gdi32.NewProc("DeleteObject").Call(fb)
+	}
+	gdi32.NewProc("SelectObject").Call(hdc, ob)
+	gdi32.NewProc("SelectObject").Call(hdc, op)
+	gdi32.NewProc("DeleteObject").Call(bg)
+	gdi32.NewProc("DeleteObject").Call(np)
+}
+
+func onUninstall() {
+	if isRunning() {
+		setText(st.hStatus, "\u26D4  FastFlix is running, please close it first")
+		user32.NewProc("ShowWindow").Call(uintptr(st.hStatus), 5)
+		user32.NewProc("EnableWindow").Call(uintptr(st.hUninstBtn), 0)
+		inval(st.hUninstBtn)
+		return
+	}
+
+	// Switch to progress view
+	user32.NewProc("ShowWindow").Call(uintptr(st.hUninstBtn), 0)
+	user32.NewProc("ShowWindow").Call(uintptr(st.hCloseBtn), 0)
+	user32.NewProc("ShowWindow").Call(uintptr(st.hStatus), 0)
+	user32.NewProc("ShowWindow").Call(uintptr(st.hProgress), 5)
+	user32.NewProc("ShowWindow").Call(uintptr(st.hProgLabel), 5)
+	setText(st.hProgLabel, "Uninstalling...")
+
+	doUninstall()
+
+	setProgress(100)
+	if _, err := os.Stat(filepath.Join(st.installDir, ffinstall.UserConfigName)); err == nil {
+		setText(st.hProgLabel, "FastFlix has been removed (settings file kept).")
+	} else {
+		setText(st.hProgLabel, "FastFlix has been removed.")
+	}
+
+	// Show close button again
+	user32.NewProc("ShowWindow").Call(uintptr(st.hCloseBtn), 5)
+}
+
+func doUninstall() {
+	setProgress(10)
+
+	// Shortcuts: only the ones belonging to the kind of install being removed
+	if st.regRoot == registry.LOCAL_MACHINE {
+		os.RemoveAll(filepath.Join(os.Getenv("ProgramData"), "Microsoft", "Windows", "Start Menu", "Programs", productName))
+		os.Remove(filepath.Join(os.Getenv("PUBLIC"), "Desktop", productName+".lnk"))
+	} else {
+		os.RemoveAll(filepath.Join(os.Getenv("APPDATA"), "Microsoft", "Windows", "Start Menu", "Programs", productName))
+		os.Remove(filepath.Join(os.Getenv("USERPROFILE"), "Desktop", productName+".lnk"))
+	}
+
+	setProgress(30)
+
+	// Registry: only the root that registered this install (and only if it really points at this directory)
+	if st.regOwned {
+		ffinstall.CleanRegistry(st.regRoot)
+	}
+
+	setProgress(50)
+
+	// Remove the files the installer put here. User files (portable fastflix.yaml etc.) are left alone and
+	// the folder is only removed if it ends up empty. The running uninstaller removes itself after exit.
+	ffinstall.RemoveInstalledFiles(st.installDir, st.selfPath)
+
+	setProgress(90)
+
+	ffinstall.ScheduleSelfDelete(st.selfPath, st.installDir)
+}
+
+func checkProc() {
+	running := isRunning()
+	if running {
+		setText(st.hStatus, "\u26D4  FastFlix is running, please close it first")
+		user32.NewProc("ShowWindow").Call(uintptr(st.hStatus), 5)
+		user32.NewProc("EnableWindow").Call(uintptr(st.hUninstBtn), 0)
+	} else {
+		user32.NewProc("ShowWindow").Call(uintptr(st.hStatus), 0)
+		user32.NewProc("EnableWindow").Call(uintptr(st.hUninstBtn), 1)
+	}
+	inval(st.hUninstBtn)
+}
+
+// Helpers
+
+func setProgress(pct int) {
+	progressVal = pct
+	inval(st.hProgress)
+}
+
+func setText(h syscall.Handle, s string) {
+	user32.NewProc("SetWindowTextW").Call(uintptr(h), uintptr(unsafe.Pointer(utf16P(s))))
+}
+func setFont(h, f syscall.Handle) {
+	user32.NewProc("SendMessageW").Call(uintptr(h), 0x0030, uintptr(f), 1)
+}
+func inval(h syscall.Handle) {
+	user32.NewProc("InvalidateRect").Call(uintptr(h), 0, 1)
+}
+func mkFont(fam string, sz int, bold bool) syscall.Handle {
+	w := int32(400)
+	if bold {
+		w = 700
+	}
+	h, _, _ := gdi32.NewProc("CreateFontW").Call(uintptr(uint32(-sz)), 0, 0, 0, uintptr(w), 0, 0, 0, 1, 0, 0, 5, 0, uintptr(unsafe.Pointer(utf16P(fam))))
+	return syscall.Handle(h)
+}
+func mkCtl(cls, txt string, style uint32, x, y, w, h int32, id int, parent, hInst uintptr) syscall.Handle {
+	r, _, _ := user32.NewProc("CreateWindowExW").Call(0, uintptr(unsafe.Pointer(utf16P(cls))), uintptr(unsafe.Pointer(utf16P(txt))), uintptr(style), uintptr(x), uintptr(y), uintptr(w), uintptr(h), parent, uintptr(id), hInst, 0)
+	return syscall.Handle(r)
+}
+func mkStatic(txt string, style uint32, x, y, w, h int32, parent, hInst uintptr) syscall.Handle {
+	r := mkCtl("STATIC", txt, style, x, y, w, h, 0, parent, hInst)
+	setFont(r, st.hSmFont)
+	return r
+}
+
+func containsArg(a []string, f string) bool {
+	for _, v := range a {
+		if strings.EqualFold(v, f) {
+			return true
+		}
+	}
+	return false
+}
+func isRunning() bool { return ffinstall.IsRunning(st.installDir) }
+
+func relaunchElevated(self string, args []string) {
+	v, _ := syscall.UTF16PtrFromString("runas")
+	e, _ := syscall.UTF16PtrFromString(self)
+	a, _ := syscall.UTF16PtrFromString(strings.Join(args, " "))
+	c, _ := syscall.UTF16PtrFromString(filepath.Dir(self))
+	syscall.NewLazyDLL("shell32.dll").NewProc("ShellExecuteW").Call(0, uintptr(unsafe.Pointer(v)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(a)), uintptr(unsafe.Pointer(c)), 1)
+}
+
+func msgBox(title, msg string, flags uintptr) int {
+	t, _ := syscall.UTF16PtrFromString(title)
+	m, _ := syscall.UTF16PtrFromString(msg)
+	ret, _, _ := user32.NewProc("MessageBoxW").Call(0, uintptr(unsafe.Pointer(m)), uintptr(unsafe.Pointer(t)), flags)
+	return int(ret)
+}
diff --git a/cmd/uninstaller/winres/icon.ico b/cmd/uninstaller/winres/icon.ico
new file mode 100644
index 00000000..7fe27dfb
Binary files /dev/null and b/cmd/uninstaller/winres/icon.ico differ
diff --git a/cmd/uninstaller/winres/winres.json b/cmd/uninstaller/winres/winres.json
new file mode 100644
index 00000000..c3512387
--- /dev/null
+++ b/cmd/uninstaller/winres/winres.json
@@ -0,0 +1,44 @@
+{
+  "RT_GROUP_ICON": {
+    "#1": {
+      "0000": "icon.ico"
+    }
+  },
+  "RT_MANIFEST": {
+    "#1": {
+      "0409": {
+        "identity": {
+          "name": "FastFlix.Uninstaller",
+          "version": "6.3.0.0"
+        },
+        "description": "FastFlix Uninstaller",
+        "minimum-os": "win10",
+        "execution-level": "asInvoker",
+        "dpi-awareness": "system",
+        "use-common-controls": true
+      }
+    }
+  },
+  "RT_VERSION": {
+    "#1": {
+      "0000": {
+        "fixed": {
+          "file_version": "6.3.0.0",
+          "product_version": "6.3.0.0"
+        },
+        "info": {
+          "0409": {
+            "CompanyName": "Chris Griffith",
+            "FileDescription": "FastFlix Uninstaller",
+            "FileVersion": "6.3.0",
+            "InternalName": "FastFlix.Uninstaller",
+            "LegalCopyright": "(c) Chris Griffith 2019-2026",
+            "OriginalFilename": "uninstall.exe",
+            "ProductName": "FastFlix",
+            "ProductVersion": "6.3.0"
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/fastflix/__main__.py b/fastflix/__main__.py
index e616c929..a1731fdb 100644
--- a/fastflix/__main__.py
+++ b/fastflix/__main__.py
@@ -37,11 +37,16 @@ def setup_ocr_environment():
 
 def start_fastflix():
     exit_code = 2
-    portable_mode = True
-    try:
-        from fastflix import portable  # noqa: F401
-    except ImportError:
-        portable_mode = False
+
+    # Portable mode: Go launcher sets FASTFLIX_PORTABLE=1, PyInstaller uses portable.py import
+    portable_mode = os.environ.get("FASTFLIX_PORTABLE") == "1"
+    if not portable_mode:
+        try:
+            from fastflix import portable  # noqa: F401
+
+            portable_mode = True
+        except ImportError:
+            pass
 
     if portable_mode:
         print("PORTABLE MODE DETECTED: now using local config file and workspace in same directory as the executable")
diff --git a/fastflix/application.py b/fastflix/application.py
index 1066d43d..270d43a1 100644
--- a/fastflix/application.py
+++ b/fastflix/application.py
@@ -204,6 +204,14 @@ def init_fastflix_directories(app: FastFlixApp):
     app.fastflix.log_path.mkdir(parents=True, exist_ok=True)
 
 
+def _refresh_ffmpeg_info(app: FastFlixApp):
+    config = app.fastflix.config
+    ffmpeg_configuration(app, config)
+    ffmpeg_audio_encoders(app, config)
+    ffmpeg_video_encoders(app, config)
+    init_encoders(app)
+
+
 def _handle_ffmpeg_version_warning_windows(app: FastFlixApp, container: Container):
     msg = QtWidgets.QMessageBox(container)
     msg.setIcon(QtWidgets.QMessageBox.Warning)
@@ -227,7 +235,7 @@ def _handle_ffmpeg_version_warning_windows(app: FastFlixApp, container: Containe
                 signal_task=True,
                 can_cancel=True,
             )
-            ffmpeg_configuration(app)
+            _refresh_ffmpeg_info(app)
         except Exception:
             logger.exception("Failed to download FFmpeg")
 
diff --git a/fastflix/audio_processing.py b/fastflix/audio_processing.py
index 4d24a7c5..92ff2fc1 100644
--- a/fastflix/audio_processing.py
+++ b/fastflix/audio_processing.py
@@ -80,4 +80,33 @@ def apply_audio_filters(
                 else:
                     tracks.extend(subset_tracks)
 
+        elif audio_match.match_item == MatchItem.CODEC:
+            subset_tracks = []
+            for track in original_tracks:
+                if audio_match.match_input.lower() == track.codec_name.lower():
+                    subset_tracks.append((track, audio_match))
+            if subset_tracks:
+                if audio_match.match_type == MatchType.FIRST:
+                    tracks.append(subset_tracks[0])
+                elif audio_match.match_type == MatchType.LAST:
+                    tracks.append(subset_tracks[-1])
+                else:
+                    tracks.extend(subset_tracks)
+
+        elif audio_match.match_item == MatchItem.CODEC_PROFILE:
+            subset_tracks = []
+            match_codec, _, match_profile = audio_match.match_input.partition(":")
+            for track in original_tracks:
+                if match_codec.lower() == track.codec_name.lower():
+                    track_profile = track.get("profile", "") or ""
+                    if match_profile.lower() == track_profile.lower():
+                        subset_tracks.append((track, audio_match))
+            if subset_tracks:
+                if audio_match.match_type == MatchType.FIRST:
+                    tracks.append(subset_tracks[0])
+                elif audio_match.match_type == MatchType.LAST:
+                    tracks.append(subset_tracks[-1])
+                else:
+                    tracks.extend(subset_tracks)
+
     return sorted(tracks, key=lambda x: x[0].index)
diff --git a/fastflix/command_runner.py b/fastflix/command_runner.py
index 35a9768d..e3f0fdd7 100644
--- a/fastflix/command_runner.py
+++ b/fastflix/command_runner.py
@@ -8,12 +8,14 @@
 from pathlib import Path
 from queue import Full
 from subprocess import PIPE
-from threading import Thread
+from threading import Thread, current_thread
 from typing import Literal
 import sys
 
 from psutil import Popen
 
+from fastflix.resources import clean_env
+
 try:
     from psutil import (
         HIGH_PRIORITY_CLASS,
@@ -59,6 +61,7 @@ def __init__(self, log_queue):
         self.error_message = []
         self.success_message = []
         self.started_at = None
+        self._reader_thread = None
 
     def start_exec(self, command, work_dir: str = None, shell: bool = False, errors=(), successes=()):
         self.clean()
@@ -93,6 +96,7 @@ def start_exec(self, command, work_dir: str = None, shell: bool = False, errors=
                 stderr=stderr_handle,
                 stdin=PIPE,  # FFmpeg can try to read stdin and wrecks havoc on linux
                 encoding="utf-8",
+                env=clean_env(),
             )
         except PermissionError:
             logger.error(
@@ -117,8 +121,13 @@ def start_exec(self, command, work_dir: str = None, shell: bool = False, errors=
 
         self.started_at = datetime.datetime.now(datetime.timezone.utc)
 
-        thread = Thread(target=self.read_output, daemon=True)
-        thread.start()
+        self._reader_thread = Thread(target=self.read_output, daemon=True)
+        self._reader_thread.start()
+
+    def join_reader(self, timeout: float = 1.0):
+        thread = self._reader_thread
+        if thread and thread.is_alive() and thread is not current_thread():
+            thread.join(timeout=timeout)
 
     def change_priority(
         self, new_priority: Literal["Realtime", "High", "Above Normal", "Normal", "Below Normal", "Idle"]
@@ -138,13 +147,14 @@ def _safe_log_put(self, msg):
             pass  # GUI likely dead or log queue full, skip
 
     def read_output(self):
+        process = self.process
         with (
             open(self.output_file, "r", encoding="utf-8", errors="ignore") as out_file,
             open(self.error_output_file, "r", encoding="utf-8", errors="ignore") as err_file,
         ):
             while True:
                 time.sleep(0.01)
-                if not self.is_alive():
+                if process is None or process.poll() is not None:
                     excess = out_file.read()
                     logger.info(excess)
                     self._safe_log_put(excess)
@@ -152,7 +162,7 @@ def read_output(self):
                     err_excess = err_file.read()
                     logger.info(err_excess)
                     self._safe_log_put(err_excess)
-                    if self.process.returncode is not None and self.process.returncode > 0:
+                    if process is not None and process.returncode not in (None, 0) and not self.killed:
                         self.error_detected = True
                     break
                 line = out_file.readline().rstrip()
@@ -198,34 +208,50 @@ def is_alive(self):
 
     def clean(self):
         self.kill(log=False)
+        self.join_reader(timeout=2.0)
         self.process = None
+        self._reader_thread = None
         self.error_detected = False
         self.success_detected = False
         self.killed = False
         self.started_at = None
 
+    def _process_tree(self):
+        """The direct child plus every descendant (e.g. both sides of a shell pipe)."""
+        if not self.process:
+            return []
+        try:
+            descendants = self.process.children(recursive=True)
+        except Exception:
+            descendants = []
+        return [*descendants, self.process]
+
     def kill(self, log=True):
+        self.killed = True
         if self.process and self.process.poll() is None:
             if log:
                 logger.warning(f"Stopping encoder worker process {self.process.pid}")
-            try:
-                # if reusables.win_based:
-                #     os.kill(self.process.pid, signal.CTRL_C_EVENT)
-                # else:
-                #     os.killpg(os.getpgid(self.process.pid), signal.SIGTERM)
-                self.process.terminate()
-                self.process.kill()
-            except Exception as err:
-                if log:
-                    logger.exception(f"Couldn't terminate process: {err}")
-        self.killed = True
+            for proc in self._process_tree():
+                try:
+                    proc.kill()
+                except Exception as err:
+                    if log:
+                        logger.warning(f"Couldn't terminate process: {err}")
 
     def pause(self):
         if not self.process:
             return False
-        self.process.suspend()
+        for proc in self._process_tree():
+            try:
+                proc.suspend()
+            except Exception as err:
+                logger.warning(f"Couldn't suspend process: {err}")
 
     def resume(self):
         if not self.process:
             return False
-        self.process.resume()
+        for proc in self._process_tree():
+            try:
+                proc.resume()
+            except Exception as err:
+                logger.warning(f"Couldn't resume process: {err}")
diff --git a/fastflix/conversion_worker.py b/fastflix/conversion_worker.py
index 64209c97..d0e16a54 100644
--- a/fastflix/conversion_worker.py
+++ b/fastflix/conversion_worker.py
@@ -56,88 +56,94 @@ def start_command():
 
     shutdown_requested = False
 
-    while True:
-        if currently_encoding and not runner.is_alive():
-            reusables.remove_file_handlers(logger)
-            try:
-                log_queue.put("STOP_TIMER", timeout=1.0)
-            except Full:
-                pass  # GUI likely dead, ignore
-            currently_encoding = False
-
-            # Check error_detected (set by read_output thread) AND check the
-            # process return code directly.  The read_output daemon thread may
-            # not have run yet when FFmpeg exits very quickly (e.g. VAAPI init
-            # failure on Windows), so we must not rely solely on error_detected.
-            process_failed = (
-                runner.process is not None and runner.process.returncode is not None and runner.process.returncode > 0
-            )
-            if runner.error_detected or process_failed:
-                logger.info(t("Error detected while converting"))
-
-                status_queue.put(("error", video_uuid, command_uuid))
-                if gui_died or shutdown_requested:
-                    return
-                continue
-
-            status_queue.put(("complete", video_uuid, command_uuid))
-            if gui_died or shutdown_requested:
-                return
-
-        if not gui_died and not gui_proc.is_alive():
-            gui_proc.join()
-            gui_died = True
-            if runner.is_alive() or currently_encoding:
-                logger.info(t("The GUI might have died, but I'm going to keep converting!"))
-            else:
-                logger.debug(t("Conversion worker shutting down"))
-                return
-        try:
-            request = worker_queue.get(block=True, timeout=0.05)
-        except Empty:
-            continue
-        except KeyboardInterrupt:
-            status_queue.put(("exit",))
-            return
-        else:
-            if request[0] == "execute":
-                _, video_uuid, command_uuid, command, work_dir, log_name, shell = request
-                start_command()
-
-            elif request[0] == "cancel":
-                logger.debug(t("Cancel has been requested, killing encoding"))
-                runner.kill()
-                currently_encoding = False
-                status_queue.put(("cancelled", video_uuid, command_uuid))
+    try:
+        while True:
+            if currently_encoding and not runner.is_alive():
+                reusables.remove_file_handlers(logger)
                 try:
                     log_queue.put("STOP_TIMER", timeout=1.0)
                 except Full:
                     pass  # GUI likely dead, ignore
+                currently_encoding = False
 
-            elif request[0] == "pause encode":
-                logger.debug(t("Command worker received request to pause current encode"))
-                try:
-                    runner.pause()
-                except Exception:
-                    logger.exception("Could not pause command")
-
-            elif request[0] == "resume encode":
-                logger.debug(t("Command worker received request to resume paused encode"))
-                try:
-                    runner.resume()
-                except Exception:
-                    logger.exception("Could not resume command")
-
-            elif request[0] == "priority":
-                priority = request[1]
-                if runner.is_alive():
-                    runner.change_priority(priority)
-
-            elif request[0] == "shutdown":
-                logger.debug(t("Shutdown signal received from GUI"))
-                if runner.is_alive():
-                    logger.info(t("Waiting for current encode to finish before shutdown"))
-                    shutdown_requested = True
+                # Check error_detected (set by read_output thread) AND check the
+                # process return code directly.  The read_output daemon thread may
+                # not have run yet when FFmpeg exits very quickly (e.g. VAAPI init
+                # failure on Windows), so we must not rely solely on error_detected.
+                runner.join_reader(timeout=1.0)
+                process_failed = (
+                    runner.process is not None and runner.process.returncode not in (None, 0) and not runner.killed
+                )
+                if runner.error_detected or process_failed:
+                    logger.info(t("Error detected while converting"))
+
+                    status_queue.put(("error", video_uuid, command_uuid))
+                    if gui_died or shutdown_requested:
+                        return
                     continue
-                logger.debug(t("Worker shutting down gracefully"))
+
+                status_queue.put(("complete", video_uuid, command_uuid))
+                if gui_died or shutdown_requested:
+                    return
+
+            if not gui_died and not gui_proc.is_alive():
+                gui_proc.join()
+                gui_died = True
+                if runner.is_alive() or currently_encoding:
+                    logger.info(t("The GUI might have died, but I'm going to keep converting!"))
+                else:
+                    logger.debug(t("Conversion worker shutting down"))
+                    return
+            try:
+                request = worker_queue.get(block=True, timeout=0.05)
+            except Empty:
+                continue
+            except KeyboardInterrupt:
+                status_queue.put(("exit",))
                 return
+            else:
+                if request[0] == "execute":
+                    _, video_uuid, command_uuid, command, work_dir, log_name, shell = request
+                    start_command()
+
+                elif request[0] == "cancel":
+                    logger.debug(t("Cancel has been requested, killing encoding"))
+                    runner.kill()
+                    currently_encoding = False
+                    status_queue.put(("cancelled", video_uuid, command_uuid))
+                    try:
+                        log_queue.put("STOP_TIMER", timeout=1.0)
+                    except Full:
+                        pass  # GUI likely dead, ignore
+
+                elif request[0] == "pause encode":
+                    logger.debug(t("Command worker received request to pause current encode"))
+                    try:
+                        runner.pause()
+                    except Exception:
+                        logger.exception("Could not pause command")
+
+                elif request[0] == "resume encode":
+                    logger.debug(t("Command worker received request to resume paused encode"))
+                    try:
+                        runner.resume()
+                    except Exception:
+                        logger.exception("Could not resume command")
+
+                elif request[0] == "priority":
+                    priority = request[1]
+                    if runner.is_alive():
+                        runner.change_priority(priority)
+
+                elif request[0] == "shutdown":
+                    logger.debug(t("Shutdown signal received from GUI"))
+                    if runner.is_alive():
+                        logger.info(t("Waiting for current encode to finish before shutdown"))
+                        shutdown_requested = True
+                        continue
+                    logger.debug(t("Worker shutting down gracefully"))
+                    return
+    finally:
+        runner.kill(log=False)
+        if gui_died:
+            log_queue.cancel_join_thread()
diff --git a/fastflix/data/languages.yaml b/fastflix/data/languages.yaml
index b9d93652..b68e1945 100644
--- a/fastflix/data/languages.yaml
+++ b/fastflix/data/languages.yaml
@@ -298,6 +298,21 @@ Auto Crop - Finding black bars at:
   ukr: Автоматичне обрізання - знаходження чорних смуг на
   kor: 자동 자르기 - 다음에서 검은색 막대 찾기
   ron: Auto Crop - Găsirea barelor negre la
+Average Frame Rate:
+  eng: Average Frame Rate
+  deu: Durchschnittliche Bildrate
+  fra: Taux de rafraîchissement moyen
+  ita: Frequenza media dei fotogrammi
+  spa: Frecuencia de imagen media
+  jpn: 平均フレームレート
+  rus: Средняя частота кадров
+  por: Taxa de quadros média
+  swe: Genomsnittlig bildfrekvens
+  pol: Średnia liczba klatek na sekundę
+  chs: 平均帧频
+  ukr: Середня частота кадрів
+  kor: 평균 프레임 속도
+  ron: Rata medie a cadrelor
 Automatically detect black borders:
   deu: Automatische Erkennung von schwarzen Rändern
   eng: Automatically detect black borders
@@ -388,6 +403,21 @@ Bit Depth:
   ukr: Глибина біта
   kor: 비트 깊이
   ron: Adâncimea biților
+Bit Rate:
+  eng: Bit Rate
+  deu: Bitrate
+  fra: Débit binaire
+  ita: Velocità di trasmissione
+  spa: Tasa de bits
+  jpn: ビット・レート
+  rus: Скорость передачи данных
+  por: Taxa de bits
+  swe: Bithastighet
+  pol: Szybkość transmisji
+  chs: 比特率
+  ukr: Бітрейт
+  kor: 비트 전송률
+  ron: Rata de biți
 Bitrate:
   deu: Bitrate
   eng: Bitrate
@@ -403,6 +433,36 @@ Bitrate:
   ukr: Бітрейт
   kor: 비트 전송률
   ron: Bitrate
+Bits per Raw Sample:
+  eng: Bits per Raw Sample
+  deu: Bits pro Rohsample
+  fra: Bits par échantillon brut
+  ita: Bit per campione grezzo
+  spa: Bits por muestra bruta
+  jpn: 生サンプルあたりのビット数
+  rus: Биты на сырой образец
+  por: Bits por amostra bruta
+  swe: Bitar per råprov
+  pol: Bity na próbkę surową
+  chs: 每个原始采样的比特
+  ukr: Біти на сирий зразок
+  kor: 원시 샘플당 비트 수
+  ron: Biți pe eșantion brut
+Bits per Sample:
+  eng: Bits per Sample
+  deu: Bits pro Probe
+  fra: Bits par échantillon
+  ita: Bit per campione
+  spa: Bits por muestra
+  jpn: サンプルあたりのビット数
+  rus: Биты на образец
+  por: Bits por amostra
+  swe: Bitar per prov
+  pol: Bity na próbkę
+  chs: 每个采样比特
+  ukr: Біти на зразок
+  kor: 샘플당 비트 수
+  ron: Biți pe eșantion
 Block Size:
   deu: Blockgröße
   eng: Block Size
@@ -733,6 +793,21 @@ CodeCalamity UHD HDR Encoding Guide:
   ukr: Посібник із кодування UHD HDR від CodeCalamity
   kor: 코드캘러미티 UHD HDR 인코딩 가이드
   ron: CodeCalamity Ghid de codare UHD HDR
+Chroma Location:
+  eng: Chroma Location
+  deu: Chroma Standort
+  fra: Emplacement du chroma
+  ita: Posizione di Chroma
+  spa: Ubicación de Chroma
+  jpn: クロマ・ロケーション
+  rus: Расположение хрома
+  por: Localização do Chroma
+  swe: Chroma-läge
+  pol: Lokalizacja Chroma
+  chs: 色度位置
+  ukr: Розташування Chroma
+  kor: 크로마 위치
+  ron: Locația Chroma
 Color Primaries:
   deu: Grundfarbmodell
   eng: Color Primaries
@@ -748,6 +823,21 @@ Color Primaries:
   ukr: Кольорові праймери
   kor: 색상 원색
   ron: Primare de culoare
+Color Range:
+  eng: Color Range
+  deu: Farbpalette
+  fra: Gamme de couleurs
+  ita: Gamma di colori
+  spa: Gama de colores
+  jpn: カラー・レンジ
+  rus: Цветовая гамма
+  por: Gama de cores
+  swe: Färgområde
+  pol: Zakres kolorów
+  chs: 颜色范围
+  ukr: Колірна гамма
+  kor: 색상 범위
+  ron: Gama de culori
 Color Space:
   deu: Farbraum
   eng: Color Space
@@ -1558,6 +1648,21 @@ Disposition:
   ukr: Диспозиція
   kor: 처분
   ron: Dispoziție
+Display Aspect Ratio:
+  eng: Display Aspect Ratio
+  deu: Seitenverhältnis der Anzeige
+  fra: Rapport d'aspect de l'écran
+  ita: Rapporto d'aspetto del display
+  spa: Relación de aspecto de la pantalla
+  jpn: ディスプレイのアスペクト比
+  rus: Соотношение сторон экрана
+  por: Relação de aspeto do ecrã
+  swe: Bildskärmens bildförhållande
+  pol: Współczynnik proporcji wyświetlacza
+  chs: 显示屏宽高比
+  ukr: Співвідношення сторін дисплея
+  kor: 화면 비율 표시
+  ron: Raportul de aspect al afișajului
 Dither:
   deu: Dithern
   eng: Dither
@@ -1603,6 +1708,21 @@ Download:
   ukr: Завантажити
   kor: 다운로드
   ron: Descărcați
+Download JSON:
+  eng: Download JSON
+  deu: JSON herunterladen
+  fra: Télécharger JSON
+  ita: Scarica JSON
+  spa: Descargar JSON
+  jpn: JSONダウンロード
+  rus: Загрузить JSON
+  por: Descarregar JSON
+  swe: Ladda ner JSON
+  pol: Pobierz JSON
+  chs: 下载 JSON
+  ukr: Завантажити JSON
+  kor: JSON 다운로드
+  ron: Descărcați JSON
 Download Cancelled:
   deu: Download abgebrochen
   eng: Download Cancelled
@@ -1753,6 +1873,21 @@ Enables the yadif filter.:
   ukr: Вмикає фільтр yadif.
   kor: 야디프 필터를 활성화합니다.
   ron: Activează filtrul yadif.
+Enables deinterlacing (method selectable in Advanced panel).:
+  deu: Aktiviert Deinterlacing (Methode im Erweitert-Panel auswählbar).
+  eng: Enables deinterlacing (method selectable in Advanced panel).
+  fra: Active le désentrelacement (méthode sélectionnable dans le panneau Avancé).
+  ita: Abilita il deinterlacciamento (metodo selezionabile nel pannello Avanzato).
+  spa: Habilita el desentrelazado (método seleccionable en el panel Avanzado).
+  chs: 启用反交错（方法可在高级面板中选择）。
+  jpn: デインターレースを有効にします（方法は詳細パネルで選択可能）。
+  rus: Включает деинтерлейс (метод выбирается в панели Дополнительно).
+  por: Habilita o desentrelaçamento (método selecionável no painel Avançado).
+  swe: Aktiverar deinterlacing (metod valbar i panelen Avancerat).
+  pol: Włącza usuwanie przeplotu (metoda do wyboru w panelu Zaawansowane).
+  ukr: Вмикає деінтерлейс (метод обирається в панелі Додатково).
+  kor: 디인터레이스를 활성화합니다 (방법은 고급 패널에서 선택 가능).
+  ron: Activează deinterlacing (metoda selectabilă în panoul Avansat).
 Enables true lossless coding by bypassing scaling, transform, quantization and in-loop filtering.:
   deu: Ermöglicht echte verlustfreie Kodierung unter Umgehung von Skalierung, Transformation, Quantisierung und In-Loop-Filterung.
   eng: Enables true lossless coding by bypassing scaling, transform, quantization and in-loop filtering.
@@ -2263,6 +2398,21 @@ Fast first pass:
   ukr: Швидкий перший прохід
   kor: 빠른 첫 패스
   ron: Prima trecere rapidă
+Field Order:
+  eng: Field Order
+  deu: Feld Bestellung
+  fra: Ordre de mission
+  ita: Ordine di campo
+  spa: Orden de campo
+  jpn: フィールドオーダー
+  rus: Полевой заказ
+  por: Ordem de campo
+  swe: Fältbeställning
+  pol: Field Order
+  chs: 实地订单
+  ukr: Польовий порядок
+  kor: 필드 주문
+  ron: Comanda de câmp
 File:
   deu: Datei
   eng: File
@@ -2458,6 +2608,21 @@ Generating thumbnail:
   ukr: Створення мініатюри
   kor: 썸네일 생성
   ron: Generarea miniaturii
+General:
+  eng: General
+  deu: Allgemein
+  fra: Général
+  ita: Generale
+  spa: General
+  jpn: 一般
+  rus: Общие сведения
+  por: Geral
+  swe: Allmänt
+  pol: Ogólne
+  chs: 一般情况
+  ukr: Генерал
+  kor: 일반
+  ron: Generalități
 Google's VP9 HDR Encoding Guide:
   deu: VP9-HDR-Kodierungsanleitung von Google
   eng: Google's VP9 HDR Encoding Guide
@@ -2548,6 +2713,21 @@ HDR10+ Optimizations:
   ukr: Оптимізація HDR10+
   kor: HDR10+ 최적화
   ron: Optimizări HDR10+
+HDR tonemapping unavailable for preview - colors in output will differ from this thumbnail:
+  eng: HDR tonemapping unavailable for preview - colors in output will differ from this thumbnail
+  deu: HDR-Tonemapping in der Vorschau nicht verfügbar - die Farben in der Ausgabe weichen von dieser Miniaturansicht ab
+  fra: Le tonemapping HDR n'est pas disponible pour la prévisualisation - les couleurs de la sortie seront différentes de celles de la vignette.
+  ita: "Il tonemapping HDR non è disponibile per l'anteprima: i colori in uscita differiscono da questa miniatura."
+  spa: El mapeado tonal HDR no está disponible para la previsualización - los colores en la salida diferirán de esta miniatura
+  jpn: プレビューではHDRトーンマッピングを使用できません。
+  rus: Тонирование HDR недоступно для предварительного просмотра - цвета на выходе будут отличаться от этой миниатюры
+  por: Mapeamento de tons HDR indisponível para pré-visualização - as cores na saída serão diferentes desta miniatura
+  swe: HDR tonemapping är inte tillgänglig för förhandsgranskning - färgerna i resultatet kommer att skilja sig från denna miniatyrbild
+  pol: Mapowanie tonów HDR niedostępne w podglądzie - kolory na wyjściu będą się różnić od tej miniatury.
+  chs: 预览时无法使用 HDR 色调映射 - 输出中的颜色将与此缩略图不同
+  ukr: HDR тональність недоступна для попереднього перегляду - кольори на виході відрізнятимуться від цієї мініатюри
+  kor: 미리보기에서 HDR 톤 매핑을 사용할 수 없음 - 출력의 색상이 이 썸네일과 다를 수 있습니다.
+  ron: HDR tonemapping indisponibil pentru previzualizare - culorile din ieșire vor diferi de această miniatură
 Have to select a video first:
   deu: Es muss zuerst ein Video ausgewählt werden
   eng: Have to select a video first
@@ -2623,6 +2803,36 @@ Horizontal Flip:
   ukr: Горизонтальне сальто
   kor: 수평 뒤집기
   ron: Flip orizontal
+Has B-Frames:
+  eng: Has B-Frames
+  deu: Hat B-Frames
+  fra: A des cadres B
+  ita: Ha cornici B
+  spa: Tiene marcos B
+  jpn: Bフレーム
+  rus: Имеет B-образные рамки
+  por: Tem molduras B
+  swe: Har B-ramar
+  pol: Posiada ramki B
+  chs: 有 B 型框架
+  ukr: Має B-фрейми
+  kor: B-프레임 있음
+  ron: Are rame B
+Index:
+  eng: Index
+  deu: Index
+  fra: Index
+  ita: Indice
+  spa: Índice
+  jpn: インデックス
+  rus: Индекс
+  por: Índice
+  swe: Index
+  pol: Indeks
+  chs: 索引
+  ukr: Індекс
+  kor: 색인
+  ron: Index
 Init Q:
   deu: Init Q
   eng: Init Q
@@ -2713,6 +2923,21 @@ Invalid Crop:
   ukr: Неприпустима культура
   kor: 잘못된 자르기
   ron: Cultură invalidă
+JSON Files:
+  eng: JSON Files
+  deu: JSON-Dateien
+  fra: Fichiers JSON
+  ita: File JSON
+  spa: Archivos JSON
+  jpn: JSONファイル
+  rus: Файлы JSON
+  por: Ficheiros JSON
+  swe: JSON-filer
+  pol: Pliki JSON
+  chs: JSON 文件
+  ukr: Файли JSON
+  kor: JSON 파일
+  ron: Fișiere JSON
 It is recommended that AQ-mode be enabled along with this feature:
   deu: Es wird empfohlen, dass zusammen mit dieser Funktion auch der AQ-Mode aktiviert wird
   eng: It is recommended that AQ-mode be enabled along with this feature
@@ -3043,6 +3268,21 @@ Min Q:
   ukr: Min Q
   kor: 민큐
   ron: Min Q
+Mode:
+  deu: Modus
+  eng: Mode
+  fra: Mode
+  ita: Modalità
+  spa: Modo
+  chs: 模式
+  jpn: モード
+  rus: Режим
+  por: Modo
+  swe: Läge
+  pol: Tryb
+  ukr: Режим
+  kor: 모드
+  ron: Mod
 Motion vector accuracy:
   deu: Genauigkeit des Bewegungsvektors
   eng: Motion vector accuracy
@@ -3343,6 +3583,21 @@ Not a video file:
   ukr: Не відеофайл
   kor: 동영상 파일이 아닙니다.
   ron: Nu este un fișier video
+Number of Frames:
+  eng: Number of Frames
+  deu: Anzahl der Frames
+  fra: Nombre d'images
+  ita: Numero di fotogrammi
+  spa: Número de fotogramas
+  jpn: フレーム数
+  rus: Количество кадров
+  por: Número de fotogramas
+  swe: Antal ramar
+  pol: Liczba klatek
+  chs: 帧数
+  ukr: Кількість кадрів
+  kor: 프레임 수
+  ron: Număr de cadre
 Only put the HDR10+ dynamic metadata in the IDR and frames where the values have changed.:
   deu: Setzen der dynamischen HDR10+-Metadaten nur in die IDR und Frames, bei denen sich die Werte geändert haben.
   eng: Only put the HDR10+ dynamic metadata in the IDR and frames where the values have changed.
@@ -3418,6 +3673,21 @@ Open Log Directory:
   ukr: Відкрити каталог журналів
   kor: 로그 디렉터리 열기
   ron: Deschideți directorul de jurnal
+Other:
+  eng: Other
+  deu: Andere
+  fra: Autres
+  ita: Altro
+  spa: Otros
+  jpn: その他
+  rus: Другие
+  por: Outros
+  swe: Övriga
+  pol: Inne
+  chs: 其他
+  ukr: Інше
+  kor: 기타
+  ron: Altele
 Output:
   deu: Ausgabe
   eng: Output
@@ -3583,6 +3853,21 @@ Pause Queue:
   ukr: Пауза Черга
   kor: 대기열 일시 중지
   ron: Pauză Coadă de așteptare
+Pixel Format:
+  eng: Pixel Format
+  deu: Pixel Format
+  fra: Format des pixels
+  ita: Formato pixel
+  spa: Formato de píxeles
+  jpn: ピクセル・フォーマット
+  rus: Пиксельный формат
+  por: Formato de pixel
+  swe: Pixelformat
+  pol: Format pikseli
+  chs: 像素格式
+  ukr: Формат пікселів
+  kor: 픽셀 형식
+  ron: Format pixel
 Pixel Format (requires at least 10-bit for HDR):
   deu: Pixelformat (erfordert mindestens 10-Bit für HDR)
   eng: Pixel Format (requires at least 10-bit for HDR)
@@ -3778,6 +4063,21 @@ Profiles:
   ukr: Профілі
   kor: 프로필
   ron: Profiluri
+Property:
+  eng: Property
+  deu: Eigentum
+  fra: Propriété
+  ita: Proprietà
+  spa: Propiedad
+  jpn: プロパティ
+  rus: Недвижимость
+  por: Imóveis
+  swe: Fastighet
+  pol: Nieruchomość
+  chs: 物业
+  ukr: Власність
+  kor: 속성
+  ron: Proprietate
 Python:
   deu: Python
   eng: Python
@@ -4258,6 +4558,51 @@ Same as Source:
   ukr: Те саме, що й Джерело
   kor: 소스와 동일
   ron: Același ca și Sursa
+Sample Aspect Ratio:
+  eng: Sample Aspect Ratio
+  deu: Muster Seitenverhältnis
+  fra: Rapport d'aspect de l'échantillon
+  ita: Rapporto d'aspetto del campione
+  spa: Relación de aspecto de la muestra
+  jpn: サンプル・アスペクト比
+  rus: Соотношение сторон образца
+  por: Amostra de rácio de aspeto
+  swe: Aspect Ratio för prov
+  pol: Przykładowy współczynnik proporcji
+  chs: 样品长宽比
+  ukr: Зразок співвідношення сторін
+  kor: 샘플 종횡비
+  ron: Raportul de aspect al eșantionului
+Sample Format:
+  eng: Sample Format
+  deu: Musterformat
+  fra: Modèle de format
+  ita: Formato campione
+  spa: Modelo de formato
+  jpn: サンプル・フォーマット
+  rus: Образец формата
+  por: Formato de amostra
+  swe: Exempel på format
+  pol: Przykładowy format
+  chs: 格式样本
+  ukr: Зразок формату
+  kor: 샘플 형식
+  ron: Exemplu de format
+Sample Rate:
+  eng: Sample Rate
+  deu: Stichprobenrate
+  fra: Taux d'échantillonnage
+  ita: Frequenza di campionamento
+  spa: Frecuencia de muestreo
+  jpn: サンプルレート
+  rus: Частота дискретизации
+  por: Taxa de amostragem
+  swe: Samplingsfrekvens
+  pol: Częstotliwość próbkowania
+  chs: 采样率
+  ukr: Частота дискретизації
+  kor: 샘플 속도
+  ron: Rata de eșantionare
 Save:
   deu: speichern
   eng: Save
@@ -4468,6 +4813,21 @@ Settings:
   ukr: Налаштування
   kor: 설정
   ron: Setări
+Side Data:
+  eng: Side Data
+  deu: Seite Daten
+  fra: Données latérales
+  ita: Dati laterali
+  spa: Datos laterales
+  jpn: サイドデータ
+  rus: Побочные данные
+  por: Dados laterais
+  swe: Sidodata
+  pol: Dane boczne
+  chs: 侧面数据
+  ukr: Побічні ефекти
+  kor: 사이드 데이터
+  ron: Date laterale
 Single Pass (Bitrate):
   deu: Ein einzelner Durchlauf (Bitrate)
   eng: Single Pass (Bitrate)
@@ -4783,6 +5143,21 @@ Supported Image Files:
   ukr: Підтримувані файли зображень
   kor: 지원되는 이미지 파일
   ron: Fișiere de imagine acceptate
+Tags:
+  eng: Tags
+  deu: Tags
+  fra: Tags
+  ita: Tag
+  spa: Etiquetas
+  jpn: タグ
+  rus: Теги
+  por: Etiquetas
+  swe: Etiketter
+  pol: Tagi
+  chs: 标签
+  ukr: Теги
+  kor: 태그
+  ron: Etichete
 The GUI might have died, but I'm going to keep converting!:
   deu: Die GUI ist eventuell abgestürzt, aber ich werde weiter konvertieren!
   eng: The GUI might have died, but I'm going to keep converting!
@@ -5308,6 +5683,21 @@ VBR Target:
   ukr: 'Значення: 0:none; 1:fast; 2:full(trellis) за замовчуванням'
   kor: '값: 0:없음; 1:빠른; 2:전체(격자) 기본값'
   ron: 'Valori: 0:niciunul; 1:rapid; 2:complet (spalier) implicit'
+Value:
+  eng: Value
+  deu: Wert
+  fra: Valeur
+  ita: Valore
+  spa: Valor
+  jpn: 価値
+  rus: Значение
+  por: Valor
+  swe: Värde
+  pol: Wartość
+  chs: 价值
+  ukr: Значення
+  kor: 가치
+  ron: Valoare
 Variable:
   deu: Variabel
   eng: Variable
@@ -6058,21 +6448,6 @@ good is the default and recommended for most applications:
   ukr: 'hdr10: Примусова сигналізація параметрів HDR10 у пакетах SEI.'
   kor: 'HDR10: SEI 패킷에서 HDR10 파라미터를 강제 신호화합니다.'
   ron: 'hdr10: Forțează semnalizarea parametrilor HDR10 în pachetele SEI.'
-hq - High Quality, ll - Low Latency, ull - Ultra Low Latency:
-  deu: hq - Hohe Qualität, ll - niedrige Latenz, ull - extrem niedrige Latenz
-  eng: hq - High Quality, ll - Low Latency, ull - Ultra Low Latency
-  fra: hq - Haute qualité, ll - Latence faible, ull - Latence ultra faible
-  ita: hq - Alta qualità, ll - Bassa latenza, ull - Ultra bassa latenza
-  spa: hq - Alta calidad, ll - Baja latencia, ull - Ultra baja latencia
-  chs: hq - 高质量，ll - 低延迟，ull - 超低延迟。
-  jpn: hq - 高品質, ll - 低遅延, ull - 超低遅延
-  rus: hq - высокое качество, ll - низкая задержка, ull - сверхнизкая задержка
-  por: hq - Alta Qualidade, ll - Baixa Latência, ull - Ultra Baixa Latência
-  swe: hq - Hög kvalitet, ll - Låg latenstid, ull - Ultralåg latenstid
-  pol: hq - High Quality, ll - Low Latency, ull - Ultra Low Latency
-  ukr: hq - Висока якість, ll - Низька затримка, ull - Наднизька затримка
-  kor: hq - 고품질, ll - 저지연, ull - 초저지연
-  ron: hq - Calitate înaltă, ll - Latență redusă, ull - Latență foarte redusă
 installer:
   deu: Installationsprogramm
   eng: installer
@@ -7078,6 +7453,21 @@ Drag and Drop to reorder - All items need to be same dimensions:
   ukr: Перетягніть, щоб змінити порядок - всі елементи повинні мати однакові розміри
   kor: 드래그 앤 드롭으로 재주문 - 모든 항목의 크기가 동일해야 합니다.
   ron: Trageți și plasați pentru a reordona - Toate articolele trebuie să aibă aceleași dimensiuni
+Drag and Drop to reorder, or drop a folder to load files - All items need to be same dimensions:
+  deu: Ziehen und Ablegen zum Neuordnen, oder Ordner ablegen um Dateien zu laden - Alle Elemente müssen die gleichen Abmessungen haben
+  eng: Drag and Drop to reorder, or drop a folder to load files - All items need to be same dimensions
+  fra: Glissez et déposez pour réorganiser, ou déposez un dossier pour charger les fichiers - Tous les éléments doivent avoir les mêmes dimensions
+  ita: Trascina e rilascia per riordinare, o rilascia una cartella per caricare i file - Tutti gli elementi devono avere le stesse dimensioni
+  spa: Arrastrar y soltar para reordenar, o soltar una carpeta para cargar archivos - Todos los elementos deben tener las mismas dimensiones
+  chs: 拖放来重新排序，或拖放文件夹来加载文件 - 所有项目的尺寸都需要相同
+  jpn: ドラッグ＆ドロップで並び替え、またはフォルダをドロップしてファイルを読み込み - すべてのアイテムが同じ寸法である必要があります
+  rus: Перетаскивание для изменения порядка или перетащите папку для загрузки файлов - все элементы должны иметь одинаковые размеры
+  por: Arraste e solte para reordenar, ou solte uma pasta para carregar arquivos - Todos os itens precisam ter as mesmas dimensões
+  swe: Dra och släpp för att ändra ordning, eller släpp en mapp för att ladda filer - Alla objekt måste ha samma dimensioner
+  pol: Przeciągnij i upuść, aby zmienić kolejność, lub upuść folder aby załadować pliki - Wszystkie elementy muszą mieć te same wymiary
+  ukr: Перетягніть, щоб змінити порядок, або перетягніть папку для завантаження файлів - всі елементи повинні мати однакові розміри
+  kor: 드래그 앤 드롭으로 재정렬하거나 폴더를 드롭하여 파일 로드 - 모든 항목의 크기가 동일해야 합니다
+  ron: Trageți și plasați pentru a reordona, sau plasați un folder pentru a încărca fișierele - Toate articolele trebuie să aibă aceleași dimensiuni
 The following items were excluded as they could not be identified as image or video files:
   deu: Die folgenden Elemente wurden ausgeschlossen, da sie nicht als Bild- oder Videodateien identifiziert werden konnten
   eng: The following items were excluded as they could not be identified as image or video files
@@ -10023,6 +10413,96 @@ Codec:
   ukr: Кодек
   kor: 코덱
   ron: Codec
+Codec & Profile:
+  eng: Codec & Profile
+  deu: Codec & Profil
+  fra: Codec et profil
+  ita: Codec e profilo
+  spa: Códec y perfil
+  jpn: コーデック＆プロファイル
+  rus: Кодек и профиль
+  por: Codec e perfil
+  swe: Codec & profil
+  pol: Kodek i profil
+  chs: 编解码器和简介
+  ukr: Кодек і профіль
+  kor: 코덱 및 프로필
+  ron: Codec și profil
+Codec Long Name:
+  eng: Codec Long Name
+  deu: Codec Langer Name
+  fra: Nom long du codec
+  ita: Nome lungo del codec
+  spa: Nombre largo del códec
+  jpn: コーデック・ロングネーム
+  rus: Длинное имя кодека
+  por: Nome longo do codec
+  swe: Codec långt namn
+  pol: Długa nazwa kodeka
+  chs: 编解码器长名称
+  ukr: Повна назва кодека
+  kor: 코덱 긴 이름
+  ron: Codec Nume lung
+Codec Name:
+  eng: Codec Name
+  deu: Codec-Name
+  fra: Nom du codec
+  ita: Nome del codec
+  spa: Nombre del códec
+  jpn: コーデック名
+  rus: Имя кодека
+  por: Nome do codec
+  swe: Codec-namn
+  pol: Nazwa kodeka
+  chs: 编解码器名称
+  ukr: Назва кодека
+  kor: 코덱 이름
+  ron: Nume codec
+Codec Type:
+  eng: Codec Type
+  deu: Codec-Typ
+  fra: Type de codec
+  ita: Tipo di codec
+  spa: Tipo de códec
+  jpn: コーデック・タイプ
+  rus: Тип кодека
+  por: Tipo de codec
+  swe: Codec-typ
+  pol: Typ kodeka
+  chs: 编解码器类型
+  ukr: Тип кодека
+  kor: 코덱 유형
+  ron: Tip codec
+'e.g. dts, truehd, aac':
+  eng: 'e.g. dts, truehd, aac'
+  deu: z.B. dts, truehd, aac
+  fra: par exemple, dts, truehd, aac
+  ita: ad esempio dts, truehd, aac
+  spa: por ejemplo, dts, truehd, aac
+  jpn: 例：DTS、Truehd、AAC
+  rus: например, dts, truehd, aac
+  por: por exemplo, dts, truehd, aac
+  swe: t.ex. dts, truehd, aac
+  pol: np. dts, truehd, aac
+  chs: 例如：DTS、TRUEHD、AAC
+  ukr: наприклад, dts, truehd, aac
+  kor: '예: DTS, TRUEHD, AAC'
+  ron: de ex. dts, truehd, aac
+'e.g. dts:DTS-HD MA':
+  eng: 'e.g. dts:DTS-HD MA'
+  deu: z.B. dts:DTS-HD MA
+  fra: par exemple dts:DTS-HD MA
+  ita: ad esempio dts:DTS-HD MA
+  spa: por ejemplo, dts:DTS-HD MA
+  jpn: 例：dts:DTS-HD MA
+  rus: например, dts:DTS-HD MA
+  por: por exemplo, dts:DTS-HD MA
+  swe: t.ex. dts:DTS-HD MA
+  pol: np. dts:DTS-HD MA
+  chs: 例如 dts:DTS-HD MA
+  ukr: наприклад, dts:DTS-HD MA
+  kor: '예: dts:DTS-HD MA'
+  ron: de ex. dts:DTS-HD MA
 Near Lossless:
   eng: Near Lossless
   deu: Fast verlustfrei
@@ -10098,6 +10578,21 @@ Custom Bitrate:
   ukr: Користувацький бітрейт
   kor: 사용자 지정 비트레이트
   ron: Bitrate personalizat
+AAC Profile:
+  eng: AAC Profile
+  deu: AAC-Profil
+  fra: Profil du CAA
+  ita: Profilo AAC
+  spa: Perfil de la CAA
+  jpn: AACプロフィール
+  rus: Профиль AAC
+  por: Perfil da AAC
+  swe: Profil AAC
+  pol: Profil AAC
+  chs: AAC 简介
+  ukr: Профіль AAC
+  kor: AAC 프로필
+  ron: Profilul AAC
 Audio Quality:
   eng: Audio Quality
   deu: Audio-Qualität
@@ -14142,6 +14637,21 @@ Show completion popup message:
   ukr: Показати спливаюче повідомлення про завершення
   kor: 완료 팝업 메시지 표시
   ron: Afișați mesajul pop-up de finalizare
+Keep source loaded after adding to queue:
+  eng: Keep source loaded after adding to queue
+  deu: Quelle nach Hinzufügen zur Warteschlange geladen lassen
+  fra: Maintenir la source chargée après l'avoir ajoutée à la file d'attente
+  ita: Mantenere la sorgente caricata dopo l'aggiunta alla coda
+  spa: Mantener la fuente cargada después de añadirla a la cola
+  jpn: キューに追加した後もソースをロードしたままにする
+  rus: Сохраняйте источник загруженным после добавления в очередь
+  por: Manter a fonte carregada após adicionar à fila
+  swe: Håll källan laddad efter att den har lagts till i kön
+  pol: Zachowaj załadowane źródło po dodaniu do kolejki
+  chs: 添加到队列后保持源加载
+  ukr: Тримати джерело завантаженим після додавання до черги
+  kor: 대기열에 추가한 후에도 소스가 로드된 상태로 유지
+  ron: Mențineți sursa încărcată după adăugarea la coadă
 Show error popup message:
   eng: Show error popup message
   deu: Fehler-Popup-Meldung anzeigen
@@ -14896,3 +15406,1518 @@ Please load a video first:
   ukr: Будь ласка, спочатку завантажте відео
   kor: 먼저 동영상을 로드하세요.
   ron: Vă rugăm să încărcați mai întâi un videoclip
+Reverse Video:
+  eng: Reverse Video
+  deu: Video umkehren
+  fra: Vidéo inversée
+  ita: Video inverso
+  spa: Vídeo inverso
+  jpn: リバースビデオ
+  rus: Обратное видео
+  por: Vídeo invertido
+  swe: Omvänd video
+  pol: Odwrócone wideo
+  chs: 反向视频
+  ukr: Зворотне відео
+  kor: 리버스 비디오
+  ron: Reverse Video
+Gamma:
+  eng: Gamma
+  deu: Gamma
+  fra: Gamma
+  ita: Gamma
+  spa: Gamma
+  jpn: ガンマ
+  rus: Гамма
+  por: Gama
+  swe: Gamma
+  pol: Gamma
+  chs: 伽马
+  ukr: Гамма.
+  kor: 감마
+  ron: Gamma
+Not supported by rigaya's hardware encoders (Video Speed, Reverse Video):
+  eng: Not supported by rigaya's hardware encoders (Video Speed, Reverse Video)
+  deu: Nicht unterstützt von Rigayas Hardware-Encodern (Video Speed, Reverse Video)
+  fra: Non pris en charge par les encodeurs matériels de rigaya (vitesse vidéo, vidéo inversée)
+  ita: Non supportato dai codificatori hardware di rigaya (Velocità video, Video inverso)
+  spa: No compatible con los codificadores hardware de rigaya (Velocidad de vídeo, Vídeo inverso)
+  jpn: リガヤのハードウェアエンコーダではサポートされていません（ビデオスピード、リバースビデオ）
+  rus: Не поддерживается аппаратными кодировщиками rigaya (Video Speed, Reverse Video).
+  por: Não suportado pelos codificadores de hardware da rigaya (velocidade de vídeo, vídeo invertido)
+  swe: Stöds inte av Rigayas hårdvarukodare (videohastighet, omvänd video)
+  pol: Nieobsługiwane przez kodery sprzętowe rigaya (Video Speed, Reverse Video).
+  chs: 不支持 rigaya 硬件编码器（视频速度、反向视频）
+  ukr: Не підтримується апаратними кодерами rigaya (Video Speed, Reverse Video)
+  kor: 리가야의 하드웨어 인코더(비디오 속도, 리버스 비디오)에서는 지원되지 않습니다.
+  ron: Nu este acceptat de codificatoarele hardware ale rigaya (Video Speed, Reverse Video)
+Reverse Video Warning:
+  eng: Reverse Video Warning
+  deu: Rückwärts-Video-Warnung
+  fra: Avertissement vidéo inversé
+  ita: Avviso video di retromarcia
+  spa: Advertencia de vídeo inverso
+  jpn: 逆再生ビデオ警告
+  rus: Видеопредупреждение о реверсе
+  por: Aviso de vídeo em marcha-atrás
+  swe: Varning för omvänd video
+  pol: Ostrzeżenie o odwróconym wideo
+  chs: 反向视频警告
+  ukr: Відеопопередження про рух заднім ходом
+  kor: 리버스 비디오 경고
+  ron: Avertizare video inversă
+The reverse filter buffers all video frames in memory.:
+  eng: The reverse filter buffers all video frames in memory.
+  deu: Der Umkehrfilter puffert alle Videobilder im Speicher.
+  fra: Le filtre inversé met en mémoire tampon toutes les images vidéo.
+  ita: Il filtro inverso memorizza tutti i fotogrammi video.
+  spa: El filtro inverso almacena todos los fotogramas de vídeo en la memoria.
+  jpn: リバースフィルターは、すべてのビデオフレームをメモリにバッファリングする。
+  rus: Обратный фильтр буферизирует все видеокадры в памяти.
+  por: O filtro reverso armazena todos os quadros de vídeo na memória.
+  swe: Det omvända filtret buffrar alla videobilder i minnet.
+  pol: Filtr wsteczny buforuje wszystkie klatki wideo w pamięci.
+  chs: 反向滤波器在内存中缓冲所有视频帧。
+  ukr: Зворотний фільтр буферизує всі відеокадри в пам'яті.
+  kor: 리버스 필터는 메모리의 모든 비디오 프레임을 버퍼링합니다.
+  ron: Filtrul invers stochează toate cadrele video în memorie.
+This may require significant RAM for long or high-resolution videos.:
+  eng: This may require significant RAM for long or high-resolution videos.
+  deu: Dies kann bei langen oder hochauflösenden Videos viel Arbeitsspeicher erfordern.
+  fra: Cela peut nécessiter une quantité importante de mémoire vive pour les vidéos longues ou à haute résolution.
+  ita: Ciò può richiedere una notevole quantità di RAM per i video lunghi o ad alta risoluzione.
+  spa: Esto puede requerir una cantidad considerable de RAM para vídeos largos o de alta resolución.
+  jpn: 長い動画や高解像度の動画では、かなりのRAMが必要になるかもしれない。
+  rus: Это может потребовать значительного объема оперативной памяти для длинных видеороликов или видеороликов с высоким разрешением.
+  por: Isto pode exigir uma quantidade significativa de RAM para vídeos longos ou de alta resolução.
+  swe: Detta kan kräva mycket RAM-minne för långa eller högupplösta videor.
+  pol: Może to wymagać znacznej ilości pamięci RAM w przypadku długich filmów lub filmów w wysokiej rozdzielczości.
+  chs: 对于长视频或高分辨率视频，这可能需要大量内存。
+  ukr: Це може вимагати значного обсягу оперативної пам'яті для довгих відео або відео з високою роздільною здатністю.
+  kor: 긴 동영상이나 고해상도 동영상의 경우 상당한 RAM이 필요할 수 있습니다.
+  ron: Acest lucru poate necesita memorie RAM semnificativă pentru videoclipuri lungi sau de înaltă rezoluție.
+Audio on converted (non-copy) tracks will also be reversed.:
+  eng: Audio on converted (non-copy) tracks will also be reversed.
+  deu: Der Ton auf konvertierten (nicht kopierten) Spuren wird ebenfalls umgekehrt.
+  fra: L'audio des pistes converties (non copiées) sera également inversé.
+  ita: Anche l'audio delle tracce convertite (non copiate) sarà invertito.
+  spa: El audio de las pistas convertidas (no copiadas) también se invertirá.
+  jpn: 変換された（コピーされていない）トラックのオーディオも反転されます。
+  rus: Аудио на конвертированных (не копированных) дорожках также будет перевернуто.
+  por: O áudio das faixas convertidas (não copiadas) também será invertido.
+  swe: Ljud på konverterade spår (som inte är kopior) kommer också att reverseras.
+  pol: Dźwięk na przekonwertowanych (niekopiowanych) ścieżkach również zostanie odwrócony.
+  chs: 已转换（非复制）音轨上的音频也会反转。
+  ukr: Звук на конвертованих (не копіях) доріжках також буде реверсовано.
+  kor: 변환된(복사본이 아닌) 트랙의 오디오도 반전됩니다.
+  ron: Audio pe pistele convertite (necopiate) va fi, de asemenea, inversat.
+Don't show this warning again:
+  eng: Don't show this warning again
+  deu: Zeigen Sie diese Warnung nicht mehr an
+  fra: Ne plus afficher cet avertissement
+  ita: Non mostrare più questo avviso
+  spa: No volver a mostrar este aviso
+  jpn: この警告を二度と表示しないでください
+  rus: Больше не показывайте это предупреждение
+  por: Não voltar a mostrar este aviso
+  swe: Visa inte denna varning igen
+  pol: Nie pokazuj więcej tego ostrzeżenia
+  chs: 不要再显示此警告
+  ukr: Не показуйте це попередження більше
+  kor: 이 경고를 다시 표시하지 마세요.
+  ron: Nu mai afișați acest avertisment
+OK:
+  eng: OK
+  deu: OK
+  fra: OK
+  ita: OK
+  spa: OK
+  jpn: OK
+  rus: OK
+  por: OK
+  swe: OK
+  pol: OK
+  chs: 好的
+  ukr: ГАРАЗД.
+  kor: 확인
+  ron: OK
+Hue:
+  eng: Hue
+  deu: Farbton
+  fra: Hue
+  ita: Tonalità
+  spa: Hue
+  jpn: 色相
+  rus: Hue
+  por: Matiz
+  swe: Hue
+  pol: Hue
+  chs: 色调
+  ukr: Відтінок
+  kor: 색조
+  ron: Hue
+Video Processing:
+  eng: Video Processing
+  deu: Videoverarbeitung
+  fra: Traitement vidéo
+  ita: Elaborazione video
+  spa: Tratamiento de vídeo
+  jpn: ビデオ加工
+  rus: Обработка видео
+  por: Processamento de vídeo
+  swe: Videobearbetning
+  pol: Przetwarzanie wideo
+  chs: 视频处理
+  ukr: Обробка відео
+  kor: 비디오 처리
+  ron: Procesare video
+Color:
+  eng: Color
+  deu: Farbe
+  fra: Couleur
+  ita: Colore
+  spa: Color
+  jpn: カラー
+  rus: Цвет
+  por: Cor
+  swe: Färg
+  pol: Kolor
+  chs: 颜色
+  ukr: Колір
+  kor: 색상
+  ron: Culoare
+Video Details:
+  eng: Video Details
+  deu: Video-Details
+  fra: Détails de la vidéo
+  ita: Dettagli video
+  spa: Detalles del vídeo
+  jpn: ビデオ詳細
+  rus: Подробности видео
+  por: Detalhes do vídeo
+  swe: Video Detaljer
+  pol: Szczegóły wideo
+  chs: 视频详情
+  ukr: Деталі відео
+  kor: 비디오 세부 정보
+  ron: Detalii video
+Sharpen:
+  eng: Sharpen
+  deu: Schärfen
+  fra: Aiguiser
+  ita: Affilare
+  spa: Afilar
+  jpn: 研ぐ
+  rus: Заточка
+  por: Afiar
+  swe: Skärpa
+  pol: Ostrzenie
+  chs: 锐化
+  ukr: Гостріше.
+  kor: 샤프닝
+  ron: Ascuțiți
+Vibrance:
+  eng: Vibrance
+  deu: Lebendigkeit
+  fra: Vibrance
+  ita: Vibrazione
+  spa: Vibrance
+  jpn: 活気
+  rus: Vibrance
+  por: Vibração
+  swe: Vibrance
+  pol: Wibracja
+  chs: 活力
+  ukr: Вібрація
+  kor: 활기
+  ron: Vibranță
+Color Temperature:
+  eng: Color Temperature
+  deu: Farbtemperatur
+  fra: Température de couleur
+  ita: Temperatura del colore
+  spa: Temperatura de color
+  jpn: 色温度
+  rus: Цветовая температура
+  por: Temperatura de cor
+  swe: Färgtemperatur
+  pol: Temperatura barwowa
+  chs: 色温
+  ukr: Колірна температура
+  kor: 색온도
+  ron: Temperatura de culoare
+Curves Preset:
+  eng: Curves Preset
+  deu: Kurven Voreinstellung
+  fra: Préréglage des courbes
+  ita: Curve preimpostate
+  spa: Preajuste de curvas
+  jpn: カーブ・プリセット
+  rus: Предварительная настройка кривых
+  por: Predefinição de curvas
+  swe: Förinställda kurvor
+  pol: Wstępne ustawienie krzywych
+  chs: 曲线预设
+  ukr: Попереднє налаштування кривих
+  kor: 커브 프리셋
+  ron: Curbe prestabilite
+Colorbalance:
+  eng: Colorbalance
+  deu: Farbbalance
+  fra: Équilibre des couleurs
+  ita: Colorbalance
+  spa: Colorbalance
+  jpn: カラーバランス
+  rus: Colorbalance
+  por: Balanço de cores
+  swe: Färgbalans
+  pol: Colorbalance
+  chs: 色彩平衡
+  ukr: Баланс кольорів
+  kor: 컬러 밸런스
+  ron: Colorbalance
+Unsharp Mask:
+  eng: Unsharp Mask
+  deu: Unscharf maskieren
+  fra: Masque de netteté
+  ita: Maschera non nitida
+  spa: Máscara de desenfoque
+  jpn: アンシャープマスク
+  rus: Маска нерезкости
+  por: Máscara de nitidez
+  swe: Oskärpa Mask
+  pol: Maska wyostrzająca
+  chs: 非清晰蒙版
+  ukr: Негостра маска
+  kor: 선명하지 않은 마스크
+  ron: Mască Unsharp
+Deflicker:
+  eng: Deflicker
+  deu: Deflicker
+  fra: Deflicker
+  ita: Deflicker
+  spa: Deflicker
+  jpn: デフリッカー
+  rus: Дефликер
+  por: Deflicker
+  swe: Deflicker
+  pol: Deflicker
+  chs: 除颤器
+  ukr: Мерехтіння
+  kor: 디플리커
+  ron: Deflicker
+Pad Aspect:
+  eng: Pad Aspect
+  deu: Pad-Aspekt
+  fra: Aspect du tampon
+  ita: Aspetto del pad
+  spa: Aspecto de la almohadilla
+  jpn: パッド・アスペクト
+  rus: Аспект площадки
+  por: Aspeto da almofada
+  swe: Pad Aspect
+  pol: Pad Aspect
+  chs: 垫子规格
+  ukr: Аспект прокладки
+  kor: 패드 측면
+  ron: Aspect pad
+Pad Color:
+  eng: Pad Color
+  deu: Pad Farbe
+  fra: Couleur du tampon
+  ita: Colore del tampone
+  spa: Color de la almohadilla
+  jpn: パッドカラー
+  rus: Цвет подушечки
+  por: Cor da almofada
+  swe: Pad färg
+  pol: Kolor podkładki
+  chs: 焊盘颜色
+  ukr: Колір подушечки
+  kor: 패드 색상
+  ron: Culoare tampon
+Color & Appearance:
+  eng: Color & Appearance
+  deu: Farbe und Erscheinungsbild
+  fra: Couleur et apparence
+  ita: Colore e aspetto
+  spa: Color y aspecto
+  jpn: 色と外観
+  rus: Цвет и внешний вид
+  por: Cor e aspeto
+  swe: Färg och utseende
+  pol: Kolor i wygląd
+  chs: 颜色和外观
+  ukr: Колір і зовнішній вигляд
+  kor: 색상 및 외관
+  ron: Culoare și aspect
+LUT3D:
+  eng: LUT3D
+  deu: LUT3D
+  fra: LUT3D
+  ita: LUT3D
+  spa: LUT3D
+  jpn: LUT3D
+  rus: LUT3D
+  por: LUT3D
+  swe: LUT3D
+  pol: LUT3D
+  chs: LUT3D
+  ukr: LUT3D
+  kor: LUT3D
+  ron: LUT3D
+Select LUT File:
+  eng: Select LUT File
+  deu: LUT-Datei auswählen
+  fra: Sélectionner le fichier LUT
+  ita: Selezionare il file LUT
+  spa: Seleccionar archivo LUT
+  jpn: LUTファイルを選択
+  rus: Выберите файл LUT
+  por: Selecionar ficheiro LUT
+  swe: Välj LUT-fil
+  pol: Wybierz plik LUT
+  chs: 选择 LUT 文件
+  ukr: Виберіть файл LUT
+  kor: LUT 파일 선택
+  ron: Selectați fișierul LUT
+LUT Files:
+  eng: LUT Files
+  deu: LUT-Dateien
+  fra: Fichiers LUT
+  ita: File LUT
+  spa: Archivos LUT
+  jpn: LUTファイル
+  rus: Файлы LUT
+  por: Ficheiros LUT
+  swe: LUT-filer
+  pol: Pliki LUT
+  chs: LUT 文件
+  ukr: LUT-файли
+  kor: LUT 파일
+  ron: Fișiere LUT
+No LUT file selected:
+  eng: No LUT file selected
+  deu: Keine LUT-Datei ausgewählt
+  fra: Aucun fichier LUT sélectionné
+  ita: Nessun file LUT selezionato
+  spa: No se ha seleccionado ningún archivo LUT
+  jpn: LUTファイルが選択されていない
+  rus: Файл LUT не выбран
+  por: Nenhum ficheiro LUT selecionado
+  swe: Ingen LUT-fil vald
+  pol: Nie wybrano pliku LUT
+  chs: 未选择 LUT 文件
+  ukr: Не вибрано файл LUT
+  kor: 선택한 LUT 파일 없음
+  ron: Nu este selectat niciun fișier LUT
+Pad color (e.g. black, white, 0x000000). FFmpeg only — rigaya always uses black.:
+  eng: Pad color (e.g. black, white, 0x000000). FFmpeg only — rigaya always uses black.
+  deu: Pad-Farbe (z.B. schwarz, weiß, 0x000000). Nur FFmpeg - Rigaya verwendet immer Schwarz.
+  fra: Couleur du bloc (par exemple noir, blanc, 0x000000). FFmpeg uniquement - rigaya utilise toujours le noir.
+  ita: Colore del pad (ad es. nero, bianco, 0x000000). Solo FFmpeg - rigaya usa sempre il nero.
+  spa: Color del pad (por ejemplo, negro, blanco, 0x000000). Sólo FFmpeg - rigaya siempre utiliza el negro.
+  jpn: パッドの色（例：黒、白、0x000000）。FFmpegのみ - rigayaは常に黒を使用します。
+  rus: Цвет блока (например, черный, белый, 0x000000). Только для FFmpeg - rigaya всегда использует черный цвет.
+  por: Cor do bloco (por exemplo, preto, branco, 0x000000). Apenas FFmpeg - rigaya usa sempre preto.
+  swe: Pad-färg (t.ex. svart, vit, 0x000000). Endast FFmpeg - rigaya använder alltid svart.
+  pol: Kolor podkładki (np. czarny, biały, 0x000000). Tylko FFmpeg - rigaya zawsze używa koloru czarnego.
+  chs: 垫色（如黑色、白色、0x000000）。仅限 FFmpeg - rigaya 始终使用黑色。
+  ukr: Колір пікселів (наприклад, чорний, білий, 0x000000). Тільки FFmpeg - rigaya завжди використовує чорний.
+  kor: '패드 색상(예: 검정, 흰색, 0x000000). FFmpeg 전용 - 리가야는 항상 검은색을 사용합니다.'
+  ron: Culoare pad (de exemplu, negru, alb, 0x000000). Numai FFmpeg - rigaya utilizează întotdeauna negru.
+? Not supported by rigaya's hardware encoders (Video Speed, Reverse Video, Deflicker, Vibrance, Color Temperature, Colorbalance)
+: eng: Not supported by rigaya's hardware encoders (Video Speed, Reverse Video, Deflicker, Vibrance, Color Temperature, Colorbalance)
+  deu: Nicht unterstützt von Rigayas Hardware-Encodern (Video Speed, Reverse Video, Deflicker, Vibrance, Color Temperature, Colorbalance)
+  fra: Non pris en charge par les encodeurs matériels de rigaya (vitesse vidéo, vidéo inversée, Deflicker, Vibrance, température des couleurs, balance des couleurs).
+  ita: Non supportato dai codificatori hardware di rigaya (Velocità video, Inversione video, Deflicker, Vibrazione, Temperatura colore, Bilanciamento colore).
+  spa: No es compatible con los codificadores hardware de rigaya (Velocidad de vídeo, Vídeo inverso, Deflicker, Vibrance, Temperatura de color, Colorbalance)
+  jpn: リガヤのハードウェアエンコーダ（ビデオスピード、リバースビデオ、デフリッカー、ビブランス、色温度、カラーバランス）ではサポートされていません。
+  rus: Не поддерживаются аппаратными кодировщиками rigaya (Скорость видео, Обратное видео, Дефликер, Вибрация, Цветовая температура, Цветовой баланс).
+  por: Não suportado pelos codificadores de hardware da rigaya (Velocidade de vídeo, Vídeo invertido, Deflicker, Vibração, Temperatura de cor, Balanço de cores)
+  swe: Stöds inte av Rigayas hårdvarukodare (Video Speed, Reverse Video, Deflicker, Vibrance, Color Temperature, Colorbalance)
+  pol: Nieobsługiwane przez kodery sprzętowe rigaya (prędkość wideo, odwrócenie wideo, migotanie, żywość, temperatura kolorów, balans kolorów).
+  chs: 不支持 rigaya 硬件编码器（视频速度、反向视频、去闪烁、亮度、色温、色差）。
+  ukr: Не підтримується апаратними кодерами rigaya (швидкість відео, реверс відео, мерехтіння, вібрація, колірна температура, колірний баланс)
+  kor: 리가야의 하드웨어 인코더(비디오 속도, 리버스 비디오, 디플리커, 생동감, 색온도, 컬러밸런스)에서는 지원되지 않습니다.
+  ron: Nu este acceptat de codificatoarele hardware ale rigaya (Video Speed, Reverse Video, Deflicker, Vibrance, Color Temperature, Colorbalance)
+Fast Start (MP4/MOV):
+  eng: Fast Start (MP4/MOV)
+  deu: Schnellstart (MP4/MOV)
+  fra: Démarrage rapide (MP4/MOV)
+  ita: Avvio veloce (MP4/MOV)
+  spa: Inicio rápido (MP4/MOV)
+  jpn: ファストスタート（MP4/MOV）
+  rus: Быстрый старт (MP4/MOV)
+  por: Início rápido (MP4/MOV)
+  swe: Snabb start (MP4/MOV)
+  pol: Szybki start (MP4/MOV)
+  chs: 快速启动（MP4/MOV）
+  ukr: Швидкий старт (MP4/MOV)
+  kor: 빠른 시작(MP4/MOV)
+  ron: Start rapid (MP4/MOV)
+Moves metadata to the beginning of the file for faster streaming start:
+  eng: Moves metadata to the beginning of the file for faster streaming start
+  deu: Verschiebt Metadaten an den Anfang der Datei, um das Streaming zu beschleunigen
+  fra: Déplace les métadonnées au début du fichier pour un démarrage plus rapide de la lecture en continu.
+  ita: Sposta i metadati all'inizio del file per un avvio più rapido dello streaming.
+  spa: Desplaza los metadatos al principio del archivo para acelerar el inicio de la transmisión.
+  jpn: ストリーミング開始を高速化するために、メタデータをファイルの先頭に移動する。
+  rus: Перемещает метаданные в начало файла для ускорения начала потоковой передачи.
+  por: Move os metadados para o início do ficheiro para um início de transmissão mais rápido
+  swe: Flyttar metadata till början av filen för snabbare streamingstart
+  pol: Przenosi metadane na początek pliku w celu szybszego rozpoczęcia przesyłania strumieniowego.
+  chs: 将元数据移至文件开头，以更快地启动流式传输
+  ukr: Переміщує метадані на початок файлу для швидшого запуску потокового передавання
+  kor: 더 빠른 스트리밍 시작을 위해 메타데이터를 파일 앞부분으로 이동합니다.
+  ron: Mută metadatele la începutul fișierului pentru o pornire mai rapidă a fluxului
+GOP Length:
+  eng: GOP Length
+  deu: GOP-Länge
+  fra: Longueur du GOP
+  ita: Lunghezza GOP
+  spa: Longitud del GOP
+  jpn: GOPの長さ
+  rus: Длина GOP
+  por: Comprimento GOP
+  swe: GOP Längd
+  pol: Długość GOP
+  chs: GOP 长度
+  ukr: Довжина GOP
+  kor: GOP 길이
+  ron: GOP Lungime
+GOP length in frames (leave empty for encoder default):
+  eng: GOP length in frames (leave empty for encoder default)
+  deu: GOP-Länge in Frames (leer lassen für Encoder-Standard)
+  fra: Longueur du GOP en images (laisser vide pour la valeur par défaut de l'encodeur)
+  ita: Lunghezza GOP in fotogrammi (lasciare vuoto per l'encoder predefinito)
+  spa: Longitud del GOP en fotogramas (dejar vacío para el codificador por defecto)
+  jpn: GOPの長さ（フレーム単位）（エンコーダのデフォルトは空のまま
+  rus: Длина GOP в кадрах (оставить пустым для кодера по умолчанию)
+  por: Comprimento do GOP em fotogramas (deixar vazio para a predefinição do codificador)
+  swe: GOP-längd i bildrutor (lämna tom för standardkodning)
+  pol: Długość GOP w klatkach (pozostaw puste dla domyślnego kodera)
+  chs: 以帧为单位的 GOP 长度（编码器默认留空）
+  ukr: Довжина GOP у кадрах (залиште порожнім для кодера за замовчуванням)
+  kor: 프레임 단위의 GOP 길이(인코더 기본값을 위해 비워둠)
+  ron: Lungimea GOP în cadre (lăsați gol pentru codarea implicită)
+Video Speed Warning:
+  eng: Video Speed Warning
+  deu: Video-Geschwindigkeitswarnung
+  fra: Avertissement vidéo sur la vitesse
+  ita: Video Avviso di velocità
+  spa: Aviso de velocidad por vídeo
+  jpn: ビデオ速度警告
+  rus: Видеопредупреждение о скорости
+  por: Vídeo de aviso de velocidade
+  swe: Video Hastighetsvarning
+  pol: Wideo ostrzeżenie o prędkości
+  chs: 视频速度警告
+  ukr: Попередження про швидкість відео
+  kor: 비디오 속도 경고
+  ron: Avertizare video privind viteza
+"Warning: Audio will not be modified when changing video speed.":
+  eng: "Warning: Audio will not be modified when changing video speed."
+  deu: Achtung! Der Ton wird beim Ändern der Videogeschwindigkeit nicht verändert.
+  fra: "Avertissement : L'audio ne sera pas modifié lors de la modification de la vitesse de la vidéo."
+  ita: "Attenzione: L'audio non viene modificato quando si cambia la velocità del video."
+  spa: 'Advertencia: El audio no se modificará al cambiar la velocidad de vídeo.'
+  jpn: 警告ビデオスピードを変更しても音声は変更されません。
+  rus: 'Внимание: Звук не будет изменен при изменении скорости видео.'
+  por: 'Aviso: O áudio não será modificado quando a velocidade do vídeo for alterada.'
+  swe: 'Varning för ljud: Ljudet kommer inte att ändras när videohastigheten ändras.'
+  pol: 'Ostrzeżenie: Dźwięk nie zostanie zmodyfikowany podczas zmiany prędkości wideo.'
+  chs: 警告：改变视频速度时不会修改音频。
+  ukr: 'Попередження: При зміні швидкості відео звук не змінюється.'
+  kor: '경고: 동영상 속도를 변경할 때 오디오는 수정되지 않습니다.'
+  ron: 'Avertisment: Sunetul nu va fi modificat la schimbarea vitezei video.'
+Browse:
+  eng: Browse
+  deu: durchsuchen
+  fra: Parcourir
+  ita: Sfogliare
+  spa: Visite
+  jpn: ブラウズ
+  rus: Просмотреть
+  por: Navegar
+  swe: Bläddra
+  pol: Przeglądaj
+  chs: 浏览
+  ukr: Переглянути
+  kor: 찾아보기
+  ron: Răsfoiește
+Clear:
+  eng: Clear
+  deu: Klar
+  fra: Clair
+  ita: Libero
+  spa: Claro
+  jpn: クリア
+  rus: Очистить
+  por: Limpo
+  swe: Klart
+  pol: Wyczyść
+  chs: 清晰
+  ukr: Чисто
+  kor: 지우기
+  ron: Clar
+Thumbnail generation failed - preview may not be available:
+  eng: Thumbnail generation failed - preview may not be available
+  deu: Thumbnail-Generierung fehlgeschlagen - möglicherweise ist die Vorschau nicht verfügbar
+  fra: La génération de vignettes a échoué - l'aperçu n'est peut-être pas disponible
+  ita: Generazione di miniature non riuscita - l'anteprima potrebbe non essere disponibile
+  spa: Error en la generación de miniaturas - la vista previa puede no estar disponible
+  jpn: サムネイル生成に失敗 - プレビューが利用できない可能性があります。
+  rus: Не удалось создать миниатюру - предварительный просмотр может быть недоступен
+  por: Falha na geração de miniaturas - a pré-visualização pode não estar disponível
+  swe: Generering av miniatyrbild misslyckades - förhandsgranskning kanske inte är tillgänglig
+  pol: Generowanie miniatur nie powiodło się - podgląd może być niedostępny
+  chs: 缩略图生成失败 - 可能无法预览
+  ukr: Не вдалося згенерувати мініатюри - попередній перегляд може бути недоступним
+  kor: 썸네일 생성 실패 - 미리 보기를 사용할 수 없습니다.
+  ron: Generarea miniaturii a eșuat - este posibil ca previzualizarea să nu fie disponibilă
+Creation Time:
+  eng: Creation Time
+  deu: Schöpfungszeit
+  fra: Le temps de la création
+  ita: Tempo di creazione
+  spa: Tiempo de creación
+  jpn: 創造の時
+  rus: Время создания
+  por: Tempo de criação
+  swe: Skapelsetid
+  pol: Czas tworzenia
+  chs: 创建时间
+  ukr: Час створення
+  kor: 생성 시간
+  ron: Timpul creației
+Handler Name:
+  eng: Handler Name
+  deu: Name des Bearbeiters
+  fra: Nom du gestionnaire
+  ita: Nome del gestore
+  spa: Nombre del manipulador
+  jpn: ハンドラー名
+  rus: Имя обработчика
+  por: Nome do manipulador
+  swe: Handläggarens namn
+  pol: Nazwa administratora
+  chs: 处理程序名称
+  ukr: Ім'я обробника
+  kor: 핸들러 이름
+  ron: Numele manipulatorului
+Timecode:
+  eng: Timecode
+  deu: Zeitcode
+  fra: Code temporel
+  ita: Timecode
+  spa: Código de tiempo
+  jpn: タイムコード
+  rus: Таймкод
+  por: Código de tempo
+  swe: Tidkod
+  pol: Kod czasowy
+  chs: 时间码
+  ukr: Часовий код
+  kor: 타임코드
+  ron: Timecode
+Unknown:
+  eng: Unknown
+  deu: Unbekannt
+  fra: Inconnu
+  ita: Sconosciuto
+  spa: Desconocido
+  jpn: 不明
+  rus: Неизвестный
+  por: Desconhecido
+  swe: Okänd
+  pol: Nieznany
+  chs: 未知
+  ukr: Невідомо
+  kor: 알 수 없음
+  ron: Necunoscut
+Red X:
+  eng: Red X
+  deu: Rotes X
+  fra: Rouge X
+  ita: Rosso X
+  spa: Rojo X
+  jpn: レッドX
+  rus: Красный X
+  por: Vermelho X
+  swe: Röd X
+  pol: Czerwony X
+  chs: 红色 X
+  ukr: Червоний X
+  kor: 빨간색 X
+  ron: Roșu X
+Red Y:
+  eng: Red Y
+  deu: Rot Y
+  fra: Rouge Y
+  ita: Rosso Y
+  spa: Rojo Y
+  jpn: レッド・Y
+  rus: Красный Y
+  por: Vermelho Y
+  swe: Röd Y
+  pol: Czerwony Y
+  chs: 红色 Y
+  ukr: Червоний Y
+  kor: 빨간색 Y
+  ron: Roșu Y
+Green X:
+  eng: Green X
+  deu: Grün X
+  fra: Vert X
+  ita: Verde X
+  spa: Verde X
+  jpn: グリーンX
+  rus: Зеленый X
+  por: Verde X
+  swe: Grön X
+  pol: Green X
+  chs: 绿色 X
+  ukr: Зелений X
+  kor: 녹색 X
+  ron: Verde X
+Green Y:
+  eng: Green Y
+  deu: Grün Y
+  fra: Vert Y
+  ita: Verde Y
+  spa: Verde Y
+  jpn: グリーンY
+  rus: Зеленый Y
+  por: Verde Y
+  swe: Grön Y
+  pol: Zielony Y
+  chs: 绿色 Y
+  ukr: Зелений Y
+  kor: Green Y
+  ron: Verde Y
+Blue X:
+  eng: Blue X
+  deu: Blau X
+  fra: Bleu X
+  ita: Blu X
+  spa: Azul X
+  jpn: ブルーX
+  rus: Синий X
+  por: Azul X
+  swe: Blå X
+  pol: Blue X
+  chs: 蓝 X
+  ukr: Синій X
+  kor: 블루 X
+  ron: Albastru X
+Blue Y:
+  eng: Blue Y
+  deu: Blau Y
+  fra: Bleu Y
+  ita: Blu Y
+  spa: Azul Y
+  jpn: ブルー・Y
+  rus: Синий Y
+  por: Azul Y
+  swe: Blå Y
+  pol: Niebieski Y
+  chs: 蓝 Y
+  ukr: Синій Y
+  kor: Blue Y
+  ron: Albastru Y
+White Point X:
+  eng: White Point X
+  deu: Weißer Punkt X
+  fra: White Point X
+  ita: Punto bianco X
+  spa: Punto Blanco X
+  jpn: ホワイトポイントX
+  rus: Уайт Пойнт X
+  por: Ponto Branco X
+  swe: White Point X
+  pol: White Point X
+  chs: 白点 X
+  ukr: Біла точка X
+  kor: 화이트 포인트 X
+  ron: Punct alb X
+White Point Y:
+  eng: White Point Y
+  deu: Weißer Punkt Y
+  fra: White Point Y
+  ita: Punto Bianco Y
+  spa: Punto Blanco Y
+  jpn: ホワイトポイントY
+  rus: Уайт Пойнт Y
+  por: Ponto Branco Y
+  swe: White Point Y
+  pol: White Point Y
+  chs: 白点 Y
+  ukr: Біла точка Y
+  kor: 화이트 포인트 Y
+  ron: White Point Y
+Min Luminance:
+  eng: Min Luminance
+  deu: Min Leuchtdichte
+  fra: Luminance minimale
+  ita: Luminanza minima
+  spa: Luminancia mínima
+  jpn: 最低輝度
+  rus: Минимальная яркость
+  por: Luminância mínima
+  swe: Min Luminans
+  pol: Minimalna luminancja
+  chs: 最低亮度
+  ukr: Мінімальна яскравість
+  kor: 최소 휘도
+  ron: Luminozitate minimă
+Max Luminance:
+  eng: Max Luminance
+  deu: Maximale Leuchtdichte
+  fra: Luminance maximale
+  ita: Luminanza massima
+  spa: Luminancia máxima
+  jpn: 最大輝度
+  rus: Максимальная яркость
+  por: Luminância máxima
+  swe: Max luminans
+  pol: Maksymalna luminancja
+  chs: 最大亮度
+  ukr: Максимальна яскравість
+  kor: 최대 휘도
+  ron: Luminozitate maximă
+Max Content:
+  eng: Max Content
+  deu: Maximaler Inhalt
+  fra: Contenu maximal
+  ita: Contenuto massimo
+  spa: Contenido máximo
+  jpn: 最大コンテンツ
+  rus: Максимальное содержание
+  por: Conteúdo máximo
+  swe: Max innehåll
+  pol: Maksymalna zawartość
+  chs: 最大内容
+  ukr: Максимальний вміст
+  kor: 최대 콘텐츠
+  ron: Conținut maxim
+Max Average:
+  eng: Max Average
+  deu: Max Durchschnitt
+  fra: Max Moyenne
+  ita: Media massima
+  spa: Max Media
+  jpn: 最大平均
+  rus: Максимальное среднее
+  por: Média máxima
+  swe: Max Genomsnitt
+  pol: Maksymalna średnia
+  chs: 最大值 平均值
+  ukr: Максимальне середнє значення
+  kor: 최대 평균
+  ron: Max Medie
+Codec Tag String:
+  eng: Codec Tag String
+  deu: Codec Tag String
+  fra: Chaîne d'étiquettes de codec
+  ita: Stringa tag codec
+  spa: Cadena de etiquetas de códecs
+  jpn: コーデック・タグ文字列
+  rus: Строка тега кодека
+  por: Codec Tag String
+  swe: Codec Tag String
+  pol: Ciąg znacznika kodeka
+  chs: 编解码器标签字符串
+  ukr: Рядок тегу кодека
+  kor: 코덱 태그 문자열
+  ron: Codec Tag String
+Codec Tag:
+  eng: Codec Tag
+  deu: Codec-Tag
+  fra: Codec Tag
+  ita: Tag Codec
+  spa: Etiqueta del códec
+  jpn: コーデック・タグ
+  rus: Тег кодека
+  por: Etiqueta de codec
+  swe: Codec-tagg
+  pol: Znacznik kodeka
+  chs: 编解码器标签
+  ukr: Тег кодека
+  kor: 코덱 태그
+  ron: Etichetă Codec
+Coded Width:
+  eng: Coded Width
+  deu: Codierte Breite
+  fra: Largeur codée
+  ita: Larghezza codificata
+  spa: Anchura codificada
+  jpn: コード幅
+  rus: Кодированная ширина
+  por: Largura codificada
+  swe: Kodad bredd
+  pol: Kodowana szerokość
+  chs: 编码宽度
+  ukr: Кодована ширина
+  kor: 코드 너비
+  ron: Lățime codificată
+Coded Height:
+  eng: Coded Height
+  deu: Codierte Höhe
+  fra: Hauteur codée
+  ita: Altezza codificata
+  spa: Altura codificada
+  jpn: コード化された高さ
+  rus: Кодированная высота
+  por: Altura codificada
+  swe: Kodad höjd
+  pol: Kodowana wysokość
+  chs: 编码高度
+  ukr: Кодована висота
+  kor: 코딩된 높이
+  ron: Înălțime codificată
+Id:
+  eng: Id
+  deu: Id
+  fra: Id
+  ita: Id
+  spa: Id
+  jpn: アイド
+  rus: Id
+  por: Id
+  swe: Id
+  pol: Id
+  chs: 同上
+  ukr: Ідентифікатор
+  kor: Id
+  ron: Id
+Time Base:
+  eng: Time Base
+  deu: Zeitbasis
+  fra: Base de temps
+  ita: Base temporale
+  spa: Base temporal
+  jpn: タイムベース
+  rus: База времени
+  por: Base de tempo
+  swe: Tidsbas
+  pol: Baza czasowa
+  chs: 时基
+  ukr: Часовий базис
+  kor: 시간 기준
+  ron: Baza de timp
+Start Pts:
+  eng: Start Pts
+  deu: Start Pkt.
+  fra: Départ Pts
+  ita: Inizio Pts
+  spa: Inicio Pts
+  jpn: スタートポイント
+  rus: Старт Птс
+  por: Início Pts
+  swe: Start Pts
+  pol: Punkty startowe
+  chs: 起始点数
+  ukr: Стартовий бал
+  kor: 포인트 시작
+  ron: Start Pts
+Start Time:
+  eng: Start Time
+  deu: Startzeit
+  fra: Heure de début
+  ita: Ora di inizio
+  spa: Hora de inicio
+  jpn: 開始時間
+  rus: Время начала
+  por: Hora de início
+  swe: Starttid
+  pol: Godzina rozpoczęcia
+  chs: 开始时间
+  ukr: Час початку
+  kor: 시작 시간
+  ron: Ora de începere
+Duration Ts:
+  eng: Duration Ts
+  deu: Dauer Ts
+  fra: Durée Ts
+  ita: Durata Ts
+  spa: Duración Ts
+  jpn: 期間 Ts
+  rus: Продолжительность Ц
+  por: Duração Ts
+  swe: Varaktighet Ts
+  pol: Czas trwania Ts
+  chs: 持续时间 Ts
+  ukr: Тривалість Ts
+  kor: 지속 시간 Ts
+  ron: Durata Ts
+Extradata Size:
+  eng: Extradata Size
+  deu: Extradata Größe
+  fra: Extradata Taille
+  ita: Dimensione Extradata
+  spa: Tamaño Extradata
+  jpn: エクストラデータ・サイズ
+  rus: Размер Extradata
+  por: Tamanho da Extradata
+  swe: Extradata Storlek
+  pol: Rozmiar Extradata
+  chs: Extradata 尺寸
+  ukr: Розмір екстраданих
+  kor: 추가 데이터 크기
+  ron: Extradata Dimensiune
+Mime Codec String:
+  eng: Mime Codec String
+  deu: Mime Codec String
+  fra: Chaîne du codec Mime
+  ita: Stringa di codec mime
+  spa: Cadena de códecs Mime
+  jpn: Mimeコーデック文字列
+  rus: Строка кодека Mime
+  por: Cadeia de caracteres do codec Mime
+  swe: Mime Codec-sträng
+  pol: Ciąg kodeków Mime
+  chs: MIME 编解码字符串
+  ukr: Mime Codec String
+  kor: 마임 코덱 문자열
+  ron: Mime Codec String
+Initial Padding:
+  eng: Initial Padding
+  deu: Initiale Polsterung
+  fra: Rembourrage initial
+  ita: Imbottitura iniziale
+  spa: Relleno inicial
+  jpn: 初期パディング
+  rus: Начальная прокладка
+  por: Preenchimento inicial
+  swe: Initial stoppning
+  pol: Wypełnienie początkowe
+  chs: 初始填充
+  ukr: Початкове заповнення
+  kor: 이니셜 패딩
+  ron: Umplutura inițială
+R Frame Rate:
+  eng: R Frame Rate
+  deu: R Bildfrequenz
+  fra: R Taux de rafraîchissement
+  ita: R Frequenza fotogrammi
+  spa: R Frecuencia de imagen
+  jpn: R フレームレート
+  rus: R Частота кадров
+  por: R Taxa de quadros
+  swe: R Bildfrekvens
+  pol: R Liczba klatek na sekundę
+  chs: R 帧频
+  ukr: R Частота кадрів
+  kor: R 프레임 레이트
+  ron: R Rata cadrelor
+Avg Frame Rate:
+  eng: Avg Frame Rate
+  deu: Durchschnittliche Bildrate
+  fra: Taux de rafraîchissement moyen
+  ita: Frequenza media dei fotogrammi
+  spa: Frecuencia de imagen media
+  jpn: 平均フレームレート
+  rus: Средняя частота кадров
+  por: Taxa média de quadros
+  swe: Genomsnittlig bildfrekvens
+  pol: Średnia liczba klatek na sekundę
+  chs: 平均帧频
+  ukr: Середня частота кадрів
+  kor: 평균 프레임 속도
+  ron: Rata medie a cadrelor
+Nb Frames:
+  eng: Nb Frames
+  deu: Nb-Rahmen
+  fra: Cadres Nb
+  ita: Cornici Nb
+  spa: Nb Marcos
+  jpn: Nbフレーム
+  rus: Nb Рамки
+  por: Quadros Nb
+  swe: Nb ramar
+  pol: Nb Frames
+  chs: Nb 框架
+  ukr: Nb Рамки
+  kor: Nb 프레임
+  ron: Nb Cadre
+Codec Full Name:
+  eng: Codec Full Name
+  deu: Codec Vollständiger Name
+  fra: Nom complet du codec
+  ita: Nome completo del codec
+  spa: Nombre completo del códec
+  jpn: コーデック・フルネーム
+  rus: Полное имя кодека
+  por: Nome completo do codec
+  swe: Codec fullständigt namn
+  pol: Pełna nazwa kodeka
+  chs: 编解码器全名
+  ukr: Повна назва кодека
+  kor: 코덱 전체 이름
+  ron: Codec Nume complet
+Frames:
+  eng: Frames
+  deu: Rahmen
+  fra: Cadres
+  ita: Cornici
+  spa: Marcos
+  jpn: フレーム
+  rus: Рамки
+  por: Molduras
+  swe: Ramar
+  pol: Ramki
+  chs: 框架
+  ukr: Рамки
+  kor: 프레임
+  ron: Rame
+Format:
+  eng: Format
+  deu: Format
+  fra: Format
+  ita: Formato
+  spa: Formato
+  jpn: フォーマット
+  rus: Формат
+  por: Formato
+  swe: Format
+  pol: Format
+  chs: 格式
+  ukr: Формат
+  kor: 형식
+  ron: Format
+B-Frames:
+  eng: B-Frames
+  deu: B-Rahmen
+  fra: Cadres B
+  ita: Cornici B
+  spa: Marcos B
+  jpn: Bフレーム
+  rus: B-Frames
+  por: Quadros B
+  swe: B-ramar
+  pol: Ramki B
+  chs: B 型框架
+  ukr: B-фрейми
+  kor: B-프레임
+  ron: Rame B
+Chroma:
+  eng: Chroma
+  deu: Chroma
+  fra: Chroma
+  ita: Croma
+  spa: Croma
+  jpn: クロマ
+  rus: Chroma
+  por: Croma
+  swe: Chroma
+  pol: Chroma
+  chs: 色度
+  ukr: Chroma
+  kor: 크로마
+  ron: Chroma
+Sample AR:
+  eng: Sample AR
+  deu: Beispiel AR
+  fra: Exemple d'AR
+  ita: Campione AR
+  spa: Muestra AR
+  jpn: サンプルAR
+  rus: Образец AR
+  por: Amostra de AR
+  swe: Prov AR
+  pol: Przykładowy AR
+  chs: AR 示例
+  ukr: Зразок АР
+  kor: 샘플 AR
+  ron: Exemplu AR
+Display AR:
+  eng: Display AR
+  deu: AR anzeigen
+  fra: Affichage AR
+  ita: Visualizzazione AR
+  spa: Mostrar AR
+  jpn: ARディスプレイ
+  rus: Дисплей AR
+  por: Exibir AR
+  swe: Display AR
+  pol: Wyświetlacz AR
+  chs: 显示 AR
+  ukr: Дисплей AR
+  kor: 디스플레이 AR
+  ron: Afișare AR
+Range:
+  eng: Range
+  deu: Bereich
+  fra: Gamme
+  ita: Gamma
+  spa: Gama
+  jpn: レンジ
+  rus: Диапазон
+  por: Gama
+  swe: Räckvidd
+  pol: Zasięg
+  chs: 范围
+  ukr: Діапазон
+  kor: 범위
+  ron: Gama
+Space:
+  eng: Space
+  deu: Weltraum
+  fra: L'espace
+  ita: Spazio
+  spa: Espacio
+  jpn: スペース
+  rus: Космос
+  por: Espaço
+  swe: Utrymme
+  pol: Przestrzeń
+  chs: 空间
+  ukr: Простір
+  kor: 공간
+  ron: Spațiu
+Transfer:
+  eng: Transfer
+  deu: Übertragung
+  fra: Transfert
+  ita: Trasferimento
+  spa: Transferencia
+  jpn: 譲渡
+  rus: Передача
+  por: Transferência
+  swe: Överföring
+  pol: Transfer
+  chs: 转让
+  ukr: Переказ
+  kor: 전송
+  ron: Transfer
+Primaries:
+  eng: Primaries
+  deu: Vorwahlen
+  fra: Primaires
+  ita: Primarie
+  spa: Primarias
+  jpn: 予備選挙
+  rus: Праймериз
+  por: Primárias
+  swe: Primärval
+  pol: Premie
+  chs: 初选
+  ukr: Праймеріз
+  kor: 프라이머리
+  ron: Primare
+Mastering display metadata:
+  eng: Mastering display metadata
+  deu: Metadaten der Anzeige beherrschen
+  fra: Maîtriser les métadonnées d'affichage
+  ita: Padroneggiare i metadati di visualizzazione
+  spa: Dominar los metadatos de visualización
+  jpn: ディスプレイ・メタデータを使いこなす
+  rus: Освоение метаданных дисплея
+  por: Dominar os metadados de visualização
+  swe: Metadata för visning av mastering
+  pol: Opanowanie wyświetlania metadanych
+  chs: 掌握显示元数据
+  ukr: Освоєння метаданих дисплея
+  kor: 디스플레이 메타데이터 마스터하기
+  ron: Stăpânirea metadatelor de afișare
+Content light level metadata:
+  eng: Content light level metadata
+  deu: Metadaten der Inhaltsebene
+  fra: Métadonnées sur le niveau de luminosité du contenu
+  ita: Metadati sul livello di luce del contenuto
+  spa: Metadatos de nivel de iluminación del contenido
+  jpn: コンテンツ・ライト・レベルのメタデータ
+  rus: Метаданные уровня освещенности содержимого
+  por: Metadados de nível de luz do conteúdo
+  swe: Metadata för innehållets ljusnivå
+  pol: Metadane poziomu podświetlenia treści
+  chs: 内容轻量级元数据
+  ukr: Метадані про рівень освітленості вмісту
+  kor: 콘텐츠 조명 수준 메타데이터
+  ron: Metadate privind nivelul de luminozitate al conținutului
+Layout:
+  eng: Layout
+  deu: Layout
+  fra: Mise en page
+  ita: Layout
+  spa: Diseño
+  jpn: レイアウト
+  rus: Макет
+  por: Disposição
+  swe: Layout
+  pol: Układ
+  chs: 布局
+  ukr: Макет
+  kor: 레이아웃
+  ron: Layout
+Sample Fmt:
+  eng: Sample Fmt
+  deu: Muster Fmt
+  fra: Fmt de l'échantillon
+  ita: Esempio di Fmt
+  spa: Muestra Fmt
+  jpn: サンプル
+  rus: Образец Fmt
+  por: Fmt de amostra
+  swe: Exempel Fmt
+  pol: Przykładowy format
+  chs: 样本格式
+  ukr: Зразок Fmt
+  kor: 샘플 Fmt
+  ron: Exemplu Fmt
+Bits/Sample:
+  eng: Bits/Sample
+  deu: Bits/Probe
+  fra: Bits/échantillon
+  ita: Bit/Campione
+  spa: Bits/Muestra
+  jpn: ビット/サンプル
+  rus: Биты/образец
+  por: Bits/Amostra
+  swe: Bits/prov
+  pol: Bity/próbka
+  chs: 比特/样本
+  ukr: Біти/вибірка
+  kor: 비트/샘플
+  ron: Biți/echipament
+Type:
+  eng: Type
+  deu: Typ
+  fra: Type
+  ita: Tipo
+  spa: Tipo
+  jpn: タイプ
+  rus: Тип
+  por: Tipo
+  swe: Typ
+  pol: Typ
+  chs: 类型
+  ukr: Тип
+  kor: 유형
+  ron: Tip
+Bits/Raw Sample:
+  eng: Bits/Raw Sample
+  deu: Bits/Rohstichprobe
+  fra: Bits/Echantillon brut
+  ita: Bit/Campione grezzo
+  spa: Bits/Muestra en bruto
+  jpn: ビット/生サンプル
+  rus: Биты/сырой образец
+  por: Bits/Amostra bruta
+  swe: Bits/rått prov
+  pol: Bity/Próbka surowa
+  chs: 比特/原始样本
+  ukr: Біти / Сирий зразок
+  kor: 비트/원시 샘플
+  ron: Biți / Probă brută
+Audio Service Type:
+  eng: Audio Service Type
+  deu: Audio-Dienstart
+  fra: Type de service audio
+  ita: Tipo di servizio audio
+  spa: Tipo de servicio de audio
+  jpn: オーディオ・サービス・タイプ
+  rus: Тип аудиосервиса
+  por: Tipo de serviço de áudio
+  swe: Typ av ljudtjänst
+  pol: Typ usługi audio
+  chs: 音频服务类型
+  ukr: Тип аудіопослуги
+  kor: 오디오 서비스 유형
+  ron: Tip serviciu audio
+Keep Source:
+  deu: Quelle beibehalten
+  eng: Keep Source
+  fra: Conserver la source
+  ita: Mantieni sorgente
+  spa: Mantener origen
+  chs: 保留源文件设置
+  jpn: ソースを維持
+  rus: Оставить как в источнике
+  por: Manter origem
+  swe: Behåll källa
+  pol: Zachowaj źródło
+  ukr: Залишити як в джерелі
+  kor: 원본 유지
+  ron: Păstrați sursa
+Clear All:
+  deu: Alle löschen
+  eng: Clear All
+  fra: Tout effacer
+  ita: Cancella tutto
+  spa: Borrar todo
+  chs: 全部清除
+  jpn: すべてクリア
+  rus: Очистить все
+  por: Limpar tudo
+  swe: Rensa alla
+  pol: Wyczyść wszystko
+  ukr: Очистити все
+  kor: 모두 지우기
+  ron: Ștergeți tot
+Set on First Track:
+  deu: Auf erster Spur setzen
+  eng: Set on First Track
+  fra: Définir sur la première piste
+  ita: Imposta sulla prima traccia
+  spa: Establecer en la primera pista
+  chs: 设置在第一条轨道上
+  jpn: 最初のトラックに設定
+  rus: Установить на первой дорожке
+  por: Definir na primeira faixa
+  swe: Ange på första spåret
+  pol: Ustaw na pierwszej ścieżce
+  ukr: Встановити на першій доріжці
+  kor: 첫 번째 트랙에 설정
+  ron: Setați pe prima pistă
+Default flag:
+  deu: Standard-Flag
+  eng: Default flag
+  fra: Indicateur par défaut
+  ita: Flag predefinito
+  spa: Indicador predeterminado
+  chs: 默认标志
+  jpn: デフォルトフラグ
+  rus: Флаг «по умолчанию»
+  por: Sinalizador padrão
+  swe: Standardflagga
+  pol: Flaga domyślna
+  ukr: Прапорець «за замовчуванням»
+  kor: 기본 플래그
+  ron: Marcaj implicit
+Forced flag:
+  deu: Forced-Flag
+  eng: Forced flag
+  fra: Indicateur forcé
+  ita: Flag forzato
+  spa: Indicador forzado
+  chs: 强制标志
+  jpn: 強制フラグ
+  rus: Флаг «принудительно»
+  por: Sinalizador forçado
+  swe: Tvingad flagga
+  pol: Flaga wymuszona
+  ukr: Прапорець «примусово»
+  kor: 강제 플래그
+  ron: Marcaj forțat
+Embeddable Python:
+  deu: Einbettbares Python
+  eng: Embeddable Python
+  fra: Python intégrable
+  ita: Python incorporabile
+  spa: Python incrustable
+  chs: 可嵌入的 Python
+  jpn: 埋め込み可能な Python
+  rus: Встраиваемый Python
+  por: Python incorporável
+  swe: Inbäddningsbar Python
+  pol: Osadzalny Python
+  ukr: Вбудований Python
+  kor: 임베디드 Python
+  ron: Python încorporabil
+Download HDR10:
+  deu: HDR10 herunterladen
+  eng: Download HDR10
+  fra: Télécharger HDR10
+  ita: Scarica HDR10
+  spa: Descargar HDR10
+  chs: 下载 HDR10
+  jpn: HDR10をダウンロード
+  rus: Скачать HDR10
+  por: Transferir HDR10
+  swe: Ladda ner HDR10
+  pol: Pobierz HDR10
+  ukr: Завантажити HDR10
+  kor: HDR10 다운로드
+  ron: Descărcați HDR10
+Text Files:
+  deu: Textdateien
+  eng: Text Files
+  fra: Fichiers texte
+  ita: File di testo
+  spa: Archivos de texto
+  chs: 文本文件
+  jpn: テキストファイル
+  rus: Текстовые файлы
+  por: Ficheiros de texto
+  swe: Textfiler
+  pol: Pliki tekstowe
+  ukr: Текстові файли
+  kor: 텍스트 파일
+  ron: Fișiere text
+Data and attachment streams are not supported by hardware encoders for this output format:
+  deu: Daten- und Anhangsströme werden von Hardware-Encodern für dieses Ausgabeformat nicht unterstützt
+  eng: Data and attachment streams are not supported by hardware encoders for this output format
+  fra: Les flux de données et de pièces jointes ne sont pas pris en charge par les encodeurs matériels pour ce format de sortie
+  ita: I flussi di dati e allegati non sono supportati dagli encoder hardware per questo formato di output
+  spa: Los flujos de datos y adjuntos no son compatibles con los codificadores por hardware para este formato de salida
+  chs: 此输出格式的硬件编码器不支持数据流和附件流
+  jpn: この出力形式では、ハードウェアエンコーダーはデータストリームと添付ストリームをサポートしていません
+  rus: Потоки данных и вложений не поддерживаются аппаратными кодировщиками для этого выходного формата
+  por: Os fluxos de dados e anexos não são suportados pelos codificadores de hardware para este formato de saída
+  swe: Data- och bilagoströmmar stöds inte av hårdvarukodare för detta utdataformat
+  pol: Strumienie danych i załączników nie są obsługiwane przez enkodery sprzętowe dla tego formatu wyjściowego
+  ukr: Потоки даних і вкладень не підтримуються апаратними кодувальниками для цього вихідного формату
+  kor: 이 출력 형식에서는 하드웨어 인코더가 데이터 및 첨부 스트림을 지원하지 않습니다
+  ron: Fluxurile de date și atașamente nu sunt acceptate de codificatoarele hardware pentru acest format de ieșire
+Could not save file:
+  deu: Datei konnte nicht gespeichert werden
+  eng: Could not save file
+  fra: Impossible d'enregistrer le fichier
+  ita: Impossibile salvare il file
+  spa: No se pudo guardar el archivo
+  chs: 无法保存文件
+  jpn: ファイルを保存できませんでした
+  rus: Не удалось сохранить файл
+  por: Não foi possível guardar o ficheiro
+  swe: Det gick inte att spara filen
+  pol: Nie można zapisać pliku
+  ukr: Не вдалося зберегти файл
+  kor: 파일을 저장할 수 없습니다
+  ron: Fișierul nu a putut fi salvat
+AAC-LC (default):
+  deu: AAC-LC (Standard)
+  eng: AAC-LC (default)
+  fra: AAC-LC (par défaut)
+  ita: AAC-LC (predefinito)
+  spa: AAC-LC (predeterminado)
+  chs: AAC-LC（默认）
+  jpn: AAC-LC（デフォルト）
+  rus: AAC-LC (по умолчанию)
+  por: AAC-LC (predefinição)
+  swe: AAC-LC (standard)
+  pol: AAC-LC (domyślnie)
+  ukr: AAC-LC (за замовчуванням)
+  kor: AAC-LC (기본값)
+  ron: AAC-LC (implicit)
+libfdk_aac only:
+  deu: nur libfdk_aac
+  eng: libfdk_aac only
+  fra: libfdk_aac uniquement
+  ita: solo libfdk_aac
+  spa: solo libfdk_aac
+  chs: 仅限 libfdk_aac
+  jpn: libfdk_aac のみ
+  rus: только libfdk_aac
+  por: apenas libfdk_aac
+  swe: endast libfdk_aac
+  pol: tylko libfdk_aac
+  ukr: лише libfdk_aac
+  kor: libfdk_aac 전용
+  ron: doar libfdk_aac
+HE-AAC profiles require the libfdk_aac encoder:
+  deu: HE-AAC-Profile erfordern den Encoder libfdk_aac
+  eng: HE-AAC profiles require the libfdk_aac encoder
+  fra: Les profils HE-AAC nécessitent l'encodeur libfdk_aac
+  ita: I profili HE-AAC richiedono l'encoder libfdk_aac
+  spa: Los perfiles HE-AAC requieren el codificador libfdk_aac
+  chs: HE-AAC 配置文件需要 libfdk_aac 编码器
+  jpn: HE-AACプロファイルにはlibfdk_aacエンコーダーが必要です
+  rus: Профили HE-AAC требуют кодировщик libfdk_aac
+  por: Os perfis HE-AAC requerem o codificador libfdk_aac
+  swe: HE-AAC-profiler kräver kodaren libfdk_aac
+  pol: Profile HE-AAC wymagają enkodera libfdk_aac
+  ukr: Профілі HE-AAC потребують кодувальника libfdk_aac
+  kor: HE-AAC 프로필에는 libfdk_aac 인코더가 필요합니다
+  ron: Profilurile HE-AAC necesită codificatorul libfdk_aac
diff --git a/fastflix/data/styles/breeze_styles/dark/stylesheet.qss b/fastflix/data/styles/breeze_styles/dark/stylesheet.qss
index e75d15fd..7fe79aa6 100644
--- a/fastflix/data/styles/breeze_styles/dark/stylesheet.qss
+++ b/fastflix/data/styles/breeze_styles/dark/stylesheet.qss
@@ -218,49 +218,51 @@ QRadioButton:disabled
 
 QRadioButton::indicator
 {
-    width: 1em;
-    height: 1em;
-}
-
-QRadioButton::indicator:unchecked,
-QRadioButton::indicator:unchecked:focus
-{
-    border-image: url(dark:radio_unchecked_disabled.svg);
+    width: 12px;
+    height: 12px;
+    border: 2px solid #76797c;
+    border-radius: 8px;
+    background-color: transparent;
 }
 
 QRadioButton::indicator:unchecked:hover,
 QRadioButton::indicator:unchecked:pressed
 {
-    border: none;
-    outline: none;
-    border-image: url(dark:radio_unchecked.svg);
+    border: 2px solid #aaaaaa;
 }
 
 QRadioButton::indicator:checked
 {
-    border: none;
-    outline: none;
-    border-image: url(dark:radio_checked.svg);
+    width: 10px;
+    height: 10px;
+    border: 3px solid #4a9eed;
+    border-radius: 8px;
+    background-color: white;
 }
 
 QRadioButton::indicator:checked:hover,
 QRadioButton::indicator:checked:focus,
 QRadioButton::indicator:checked:pressed
 {
-    border: none;
-    outline: none;
-    border-image: url(dark:radio_checked.svg);
+    width: 10px;
+    height: 10px;
+    border: 3px solid #4a9eed;
+    border-radius: 8px;
+    background-color: white;
 }
 
 QRadioButton::indicator:checked:disabled
 {
-    outline: none;
-    border-image: url(dark:radio_checked_disabled.svg);
+    width: 10px;
+    height: 10px;
+    border: 3px solid #76797c;
+    border-radius: 8px;
+    background-color: #aaaaaa;
 }
 
 QRadioButton::indicator:unchecked:disabled
 {
-    border-image: url(dark:radio_unchecked_disabled.svg);
+    border: 2px solid #5a5a5a;
 }
 
 QMenuBar
diff --git a/fastflix/data/styles/breeze_styles/light/stylesheet.qss b/fastflix/data/styles/breeze_styles/light/stylesheet.qss
index 4ff8ac38..6a7b53a9 100644
--- a/fastflix/data/styles/breeze_styles/light/stylesheet.qss
+++ b/fastflix/data/styles/breeze_styles/light/stylesheet.qss
@@ -218,49 +218,51 @@ QRadioButton:disabled
 
 QRadioButton::indicator
 {
-    width: 1em;
-    height: 1em;
-}
-
-QRadioButton::indicator:unchecked,
-QRadioButton::indicator:unchecked:focus
-{
-    border-image: url(light:radio_unchecked_disabled.svg);
+    width: 12px;
+    height: 12px;
+    border: 2px solid #bab9b8;
+    border-radius: 8px;
+    background-color: transparent;
 }
 
 QRadioButton::indicator:unchecked:hover,
 QRadioButton::indicator:unchecked:pressed
 {
-    border: none;
-    outline: none;
-    border-image: url(light:radio_unchecked.svg);
+    border: 2px solid #7f8c8d;
 }
 
 QRadioButton::indicator:checked
 {
-    border: none;
-    outline: none;
-    border-image: url(light:radio_checked.svg);
+    width: 10px;
+    height: 10px;
+    border: 3px solid #3daee9;
+    border-radius: 8px;
+    background-color: white;
 }
 
 QRadioButton::indicator:checked:hover,
 QRadioButton::indicator:checked:focus,
 QRadioButton::indicator:checked:pressed
 {
-    border: none;
-    outline: none;
-    border-image: url(light:radio_checked.svg);
+    width: 10px;
+    height: 10px;
+    border: 3px solid #3daee9;
+    border-radius: 8px;
+    background-color: white;
 }
 
 QRadioButton::indicator:checked:disabled
 {
-    outline: none;
-    border-image: url(light:radio_checked_disabled.svg);
+    width: 10px;
+    height: 10px;
+    border: 3px solid #bab9b8;
+    border-radius: 8px;
+    background-color: #d5d5d5;
 }
 
 QRadioButton::indicator:unchecked:disabled
 {
-    border-image: url(light:radio_unchecked_disabled.svg);
+    border: 2px solid #d5d5d5;
 }
 
 QMenuBar
diff --git a/fastflix/data/styles/breeze_styles/onyx/stylesheet.qss b/fastflix/data/styles/breeze_styles/onyx/stylesheet.qss
index c8d4575a..2f202f71 100644
--- a/fastflix/data/styles/breeze_styles/onyx/stylesheet.qss
+++ b/fastflix/data/styles/breeze_styles/onyx/stylesheet.qss
@@ -219,49 +219,51 @@ QRadioButton:disabled
 
 QRadioButton::indicator
 {
-    width: 1em;
-    height: 1em;
-}
-
-QRadioButton::indicator:unchecked,
-QRadioButton::indicator:unchecked:focus
-{
-    border-image: url(onyx:radio_unchecked_disabled.png);
+    width: 12px;
+    height: 12px;
+    border: 2px solid #76797c;
+    border-radius: 8px;
+    background-color: transparent;
 }
 
 QRadioButton::indicator:unchecked:hover,
 QRadioButton::indicator:unchecked:pressed
 {
-    border: none;
-    outline: none;
-    border-image: url(onyx:radio_unchecked.png);
+    border: 2px solid #aaaaaa;
 }
 
 QRadioButton::indicator:checked
 {
-    border: none;
-    outline: none;
-    border-image: url(onyx:radio_checked.png);
+    width: 10px;
+    height: 10px;
+    border: 3px solid #4a9eed;
+    border-radius: 8px;
+    background-color: white;
 }
 
 QRadioButton::indicator:checked:hover,
 QRadioButton::indicator:checked:focus,
 QRadioButton::indicator:checked:pressed
 {
-    border: none;
-    outline: none;
-    border-image: url(onyx:radio_checked.png);
+    width: 10px;
+    height: 10px;
+    border: 3px solid #4a9eed;
+    border-radius: 8px;
+    background-color: white;
 }
 
 QRadioButton::indicator:checked:disabled
 {
-    outline: none;
-    border-image: url(onyx:radio_checked_disabled.png);
+    width: 10px;
+    height: 10px;
+    border: 3px solid #76797c;
+    border-radius: 8px;
+    background-color: #aaaaaa;
 }
 
 QRadioButton::indicator:unchecked:disabled
 {
-    border-image: url(onyx:radio_unchecked_disabled.png);
+    border: 2px solid #5a5a5a;
 }
 
 QMenuBar
@@ -408,7 +410,7 @@ QSlider:focus
 
 QLineEdit
 {
-    background-color: #1d2023;
+    background-color: #434c54;
     padding: 0.23em;
     border-style: solid;
     border: 0.05em solid #76797c;
@@ -786,6 +788,7 @@ QPushButton:pressed
 
 QComboBox
 {
+    background-color: #434c54;
     border: 0.05em solid #76797c;
     border-radius: 0.09em;
     padding: 4px 10px;
@@ -794,7 +797,7 @@ QComboBox
 
 QComboBox:editable
 {
-    background-color: #1d2023;
+    background-color: #434c54;
 }
 
 QPushButton:checked
@@ -850,7 +853,7 @@ QTreeView:hover:pressed
 
 QComboBox:hover:pressed:editable
 {
-    background-color: #1d2023;
+    background-color: #434c54;
 }
 
 QComboBox QAbstractItemView
diff --git a/fastflix/encoders/av1_aom/command_builder.py b/fastflix/encoders/av1_aom/command_builder.py
index 2702caec..c2b00b3b 100644
--- a/fastflix/encoders/av1_aom/command_builder.py
+++ b/fastflix/encoders/av1_aom/command_builder.py
@@ -37,18 +37,26 @@ def build(fastflix: FastFlix):
     if settings.tune != "default":
         beginning.extend(["-tune", settings.tune])
 
-    if settings.denoise_noise_level > 0:
+    if settings.denoise_noise_level > 0 and not settings.lossless:
         beginning.extend(["-denoise-noise-level", str(settings.denoise_noise_level)])
 
     if settings.aq_mode != "default":
         beginning.extend(["-aq-mode", settings.aq_mode])
 
-    if settings.aom_params:
-        beginning.extend(["-aom-params", ":".join(settings.aom_params)])
+    aom_params = settings.aom_params.copy()
+    if settings.lossless:
+        aom_params.append("lossless=1")
+    if aom_params:
+        beginning.extend(["-aom-params", ":".join(aom_params)])
 
     extra = shlex.split(settings.extra) if settings.extra else []
     extra_both = shlex.split(settings.extra) if settings.extra and settings.extra_both_passes else []
 
+    if settings.lossless:
+        # Lossless mode — no rate control needed
+        command = beginning + extra + ending
+        return [Command(command=command, name="Single Pass lossless")]
+
     if settings.bitrate:
         pass_log_file = fastflix.current_video.work_path / f"pass_log_file_{secrets.token_hex(10)}"
         command_1 = (
@@ -67,5 +75,26 @@ def build(fastflix: FastFlix):
             Command(command=command_2, name="Second Pass bitrate"),
         ]
     elif settings.crf:
-        command_1 = beginning + ["-crf", str(settings.crf)] + extra + ending
-        return [Command(command=command_1, name="Single Pass CRF")]
+        if not settings.single_pass:
+            pass_log_file = fastflix.current_video.work_path / f"pass_log_file_{secrets.token_hex(10)}"
+            command_1 = (
+                beginning
+                + ["-passlogfile", str(pass_log_file), "-crf", str(settings.crf), "-pass", "1"]
+                + extra_both
+                + ["-an"]
+                + output_fps
+                + ["-f", "matroska", null]
+            )
+            command_2 = (
+                beginning
+                + ["-passlogfile", str(pass_log_file), "-crf", str(settings.crf), "-pass", "2"]
+                + extra
+                + ending
+            )
+            return [
+                Command(command=command_1, name="First Pass CRF"),
+                Command(command=command_2, name="Second Pass CRF"),
+            ]
+        else:
+            command_1 = beginning + ["-crf", str(settings.crf)] + extra + ending
+            return [Command(command=command_1, name="Single Pass CRF")]
diff --git a/fastflix/encoders/av1_aom/settings_panel.py b/fastflix/encoders/av1_aom/settings_panel.py
index d607ed25..753822f8 100644
--- a/fastflix/encoders/av1_aom/settings_panel.py
+++ b/fastflix/encoders/av1_aom/settings_panel.py
@@ -83,10 +83,15 @@ def __init__(self, parent, main, app: FastFlixApp):
         grid.addLayout(self.init_modes(), 0, 2, 5, 4)
         grid.addLayout(self.init_denoise(), 5, 2, 1, 4)
         grid.addLayout(self.init_aom_params(), 6, 2, 1, 4)
-        grid.addLayout(self.init_hdr10plus_row(), 7, 2, 1, 4)
+        checkboxes = QtWidgets.QHBoxLayout()
+        checkboxes.addLayout(self.init_single_pass())
+        checkboxes.addStretch(1)
+        checkboxes.addLayout(self.init_lossless())
+        grid.addLayout(checkboxes, 7, 2, 1, 4)
+        grid.addLayout(self.init_hdr10plus_row(), 8, 2, 1, 4)
 
         self.ffmpeg_level = QtWidgets.QLabel()
-        grid.addWidget(self.ffmpeg_level, 8, 2, 1, 4)
+        grid.addWidget(self.ffmpeg_level, 9, 2, 1, 4)
 
         custom_layout = self._add_custom()
         guide_label = QtWidgets.QLabel(
@@ -310,6 +315,38 @@ def new_source(self):
             except Exception:
                 pass
 
+    def init_single_pass(self):
+        return self._add_check_box(
+            label="Single Pass (uncheck for 2-pass CRF)",
+            widget_name="single_pass",
+            tooltip="Uncheck for 2-pass encoding which improves quality at the cost of encoding time",
+            opt="single_pass",
+        )
+
+    def init_lossless(self):
+        layout = self._add_check_box(
+            label="Lossless",
+            widget_name="lossless",
+            tooltip=(
+                "Enable lossless encoding mode.\n"
+                "Produces bit-exact output with no quality loss.\n"
+                "Rate control options are ignored in lossless mode."
+            ),
+            opt="lossless",
+            connect=lambda: (self._toggle_lossless(), self.main.page_update(build_thumbnail=False)),
+        )
+        return layout
+
+    def _toggle_lossless(self):
+        enabled = not self.widgets.lossless.isChecked()
+        self.qp_radio.setEnabled(enabled)
+        self.bitrate_radio.setEnabled(enabled)
+        self.widgets.crf.setEnabled(enabled)
+        self.widgets.custom_crf.setEnabled(enabled)
+        self.widgets.bitrate.setEnabled(enabled)
+        self.widgets.custom_bitrate.setEnabled(enabled)
+        self.widgets.single_pass.setEnabled(enabled)
+
     def init_modes(self):
         return self._add_modes(recommended_bitrates, recommended_crfs, qp_name="crf")
 
@@ -342,9 +379,11 @@ def update_video_encoder_settings(self):
             max_muxing_queue_size=self.widgets.max_mux.currentText(),
             pix_fmt=self.widgets.pix_fmt.currentText().split(":")[1].strip(),
             denoise_noise_level=denoise_noise_level,
+            single_pass=self.widgets.single_pass.isChecked(),
             extra=self.ffmpeg_extras,
             extra_both_passes=self.widgets.extra_both_passes.isChecked(),
             aom_params=aom_params_text.split(":") if aom_params_text else [],
+            lossless=self.widgets.lossless.isChecked(),
         )
         encode_type, q_value = self.get_mode_settings()
         settings.crf = q_value if encode_type == "qp" else None
diff --git a/fastflix/encoders/avc_x264/command_builder.py b/fastflix/encoders/avc_x264/command_builder.py
index 6f7137b9..b6063cda 100644
--- a/fastflix/encoders/avc_x264/command_builder.py
+++ b/fastflix/encoders/avc_x264/command_builder.py
@@ -2,6 +2,7 @@
 import secrets
 import shlex
 
+from fastflix.encoders.common.hdr_metadata import is_hdr_bit_depth, parse_master_display
 from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details, null
 from fastflix.models.encode import x264Settings
 from fastflix.models.fastflix import FastFlix
@@ -17,7 +18,8 @@ def build(fastflix: FastFlix):
 
     beginning.extend(generate_color_details(fastflix))
 
-    if settings.profile and settings.profile != "default":
+    # libx264 refuses lossless (-qp 0) with the baseline/main/high/high10/high422 profiles, only high444 is valid
+    if settings.profile and settings.profile != "default" and (not settings.lossless or settings.profile == "high444"):
         beginning.extend(["-profile:v", settings.profile])
 
     if settings.aq_mode and settings.aq_mode != "default":
@@ -31,6 +33,14 @@ def build(fastflix: FastFlix):
         beginning.extend(["-level", settings.level])
 
     x264_params = settings.x264_params.copy()
+
+    if not fastflix.current_video.video_settings.remove_hdr and is_hdr_bit_depth(settings.pix_fmt):
+        master_display = parse_master_display(fastflix.current_video.master_display)
+        if master_display:
+            x264_params.append(f"mastering-display={master_display.to_x265()}")
+        if fastflix.current_video.cll:
+            x264_params.append(f"cll={fastflix.current_video.cll}")
+
     if x264_params:
         beginning.extend(["-x264-params", ":".join(x264_params)])
 
@@ -39,6 +49,11 @@ def build(fastflix: FastFlix):
     extra = shlex.split(settings.extra) if settings.extra else []
     extra_both = shlex.split(settings.extra) if settings.extra and settings.extra_both_passes else []
 
+    if settings.lossless:
+        # Lossless mode — use QP 0 which is mathematically lossless, no rate control needed
+        command = beginning + ["-qp", "0", "-preset:v", settings.preset] + extra + ending
+        return [Command(command=command, name="Single pass lossless", exe="ffmpeg")]
+
     if settings.bitrate:
         if settings.bitrate_passes == 2:
             command_1 = (
diff --git a/fastflix/encoders/avc_x264/settings_panel.py b/fastflix/encoders/avc_x264/settings_panel.py
index eb3f6f13..762f6a05 100644
--- a/fastflix/encoders/avc_x264/settings_panel.py
+++ b/fastflix/encoders/avc_x264/settings_panel.py
@@ -85,6 +85,7 @@ def __init__(self, parent, main, app: FastFlixApp):
         grid.addLayout(self.init_psy_rd(), 5, 2, 1, 4)
         grid.addLayout(self.init_level(), 6, 0, 1, 2)
         grid.addLayout(self.init_x264_params(), 6, 2, 1, 4)
+        grid.addLayout(self.init_lossless(), 7, 0, 1, 2)
 
         grid.setRowStretch(9, 1)
 
@@ -216,6 +217,31 @@ def init_level(self):
             opt="level",
         )
 
+    def init_lossless(self):
+        layout = self._add_check_box(
+            label="Lossless",
+            widget_name="lossless",
+            tooltip=(
+                "Enable true lossless coding by bypassing all lossy compression.\n"
+                "Reconstructed output pictures are bit-exact to the input pictures.\n"
+                "All rate control options are ignored in lossless mode.\n"
+                "Slower presets will generally achieve better compression efficiency."
+            ),
+            opt="lossless",
+            connect=lambda: (self._toggle_lossless(), self.main.page_update(build_thumbnail=False)),
+        )
+        return layout
+
+    def _toggle_lossless(self):
+        enabled = not self.widgets.lossless.isChecked()
+        self.qp_radio.setEnabled(enabled)
+        self.bitrate_radio.setEnabled(enabled)
+        self.widgets.crf.setEnabled(enabled)
+        self.widgets.custom_crf.setEnabled(enabled)
+        self.widgets.bitrate.setEnabled(enabled)
+        self.widgets.custom_bitrate.setEnabled(enabled)
+        self.widgets.bitrate_passes.setEnabled(enabled)
+
     def init_x264_params(self):
         layout = QtWidgets.QHBoxLayout()
         self.labels.x264_params = QtWidgets.QLabel(t("Additional x264 params"))
@@ -272,6 +298,7 @@ def update_video_encoder_settings(self):
             psy_rd=psy_rd_text if psy_rd_text else None,
             level=self.widgets.level.currentText(),
             x264_params=x264_params_text.split(":") if x264_params_text else [],
+            lossless=self.widgets.lossless.isChecked(),
         )
         encode_type, q_value = self.get_mode_settings()
         settings.crf = q_value if encode_type == "qp" else None
diff --git a/fastflix/encoders/common/attachments.py b/fastflix/encoders/common/attachments.py
index 66979938..90490229 100644
--- a/fastflix/encoders/common/attachments.py
+++ b/fastflix/encoders/common/attachments.py
@@ -16,8 +16,13 @@ def image_type(file: Path | str) -> tuple[str | None, str | None]:
     return mime_type, ext_type
 
 
-def build_attachments(attachments: list[AttachmentTrack]) -> List[str]:
+def build_attachments(attachments: list[AttachmentTrack], mapped_attachment_count: int = 0) -> List[str]:
+    """
+    FFmpeg creates -attach streams after all mapped streams, so address them by attachment-type index
+    (after any attachment streams mapped from the source) rather than a stored absolute stream index.
+    """
     commands = []
+    attachment_index = mapped_attachment_count
     for attachment in attachments:
         if attachment.attachment_type == "cover":
             mime_type, ext_type = image_type(attachment.file_path)
@@ -25,10 +30,11 @@ def build_attachments(attachments: list[AttachmentTrack]) -> List[str]:
                 [
                     "-attach",
                     str(attachment.file_path),
-                    f"-metadata:s:{attachment.outdex}",
+                    f"-metadata:s:t:{attachment_index}",
                     f"mimetype={mime_type}",
-                    f"-metadata:s:{attachment.outdex}",
+                    f"-metadata:s:t:{attachment_index}",
                     f"filename={attachment.filename}.{ext_type}",
                 ]
             )
+            attachment_index += 1
     return commands
diff --git a/fastflix/encoders/common/audio.py b/fastflix/encoders/common/audio.py
index 2fe8f039..745bff2b 100644
--- a/fastflix/encoders/common/audio.py
+++ b/fastflix/encoders/common/audio.py
@@ -27,13 +27,45 @@
     "7.0(front)": 7,
     "7.1": 8,
     "7.1(wide)": 8,
+    "2.2": 4,
+    "3.1.2": 6,
+    "4.1": 5,
+    "5.0(side)": 5,
+    "5.1.2": 8,
+    "5.1.4": 10,
+    "6.1(back)": 7,
+    "7.1(wide-side)": 8,
+    "7.1.2": 10,
+    "7.1.4": 12,
+    "7.2.3": 12,
+    "9.1.4": 14,
+    "9.1.6": 16,
+    "octagonal": 8,
+    "cube": 8,
+    "hexadecagonal": 16,
+    "downmix": 2,
+    "22.2": 24,
 }
 
+
+def channels_for_layout(layout, channels=None):
+    """Channel count for an ffprobe layout name, falling back to the stream's ``channels`` field."""
+    if layout in channel_list:
+        return channel_list[layout]
+    if isinstance(channels, int) and channels > 0:
+        return channels
+    return None
+
+
+# Encoder bitrate ceilings in kbps (ac3enc.c: AC-3 tops out at 640k, E-AC-3 at 128 * sample_rate bits/s = 6144k @48kHz)
+max_bitrate_kbps = {"ac3": 640, "eac3": 6144}
+
 lossless = ["flac", "truehd", "alac", "tta", "wavpack", "mlp"]
 
 
 def audio_quality_converter(quality, codec, channels=2, track_number=1):
     base = [120, 96, 72, 48, 24, 24, 16, 8, 8, 8][quality]
+    channels = channels or 2
 
     match codec:
         case "libopus":
@@ -47,17 +79,44 @@ def audio_quality_converter(quality, codec, channels=2, track_number=1):
         case "libmp3lame" | "mp3":
             return f"-q:{track_number} {quality}"
         case "ac3" | "eac3" | "truehd":
-            return f"-b:{track_number} {base * channels * 4}k"
+            bitrate = base * channels * 4
+            if codec in max_bitrate_kbps:
+                bitrate = min(bitrate, max_bitrate_kbps[codec])
+            return f"-b:{track_number} {bitrate}k"
         case _:
             return f"-b:{track_number} {base * channels}k"
 
 
+AAC_HE_PROFILES = ("aac_he", "aac_he_v2")
+
+
+def resolve_aac_profile(codec: str, profile, channels=None):
+    """Return the AAC profile that is safe to request, or None for the encoder default.
+
+    - HE-AAC / HE-AACv2 are only supported by libfdk_aac. FFmpeg's native ``aac`` encoder fails with
+      "Invalid argument" (-22) when asked for them, so the profile is dropped for every other codec.
+    - HE-AACv2 (Parametric Stereo) requires exactly 2 channels; for any other channel count it falls back
+      to HE-AAC (v1), which supports mono and multichannel.
+    """
+    if not profile:
+        return None
+    if codec != "libfdk_aac":
+        if profile in AAC_HE_PROFILES:
+            logger.warning(f"AAC profile {profile} is only supported by libfdk_aac, ignoring for codec {codec}")
+            return None
+        return profile
+    if profile == "aac_he_v2" and channels is not None and channels != 2:
+        logger.warning(f"HE-AACv2 requires stereo output (got {channels} channels), falling back to HE-AAC")
+        return "aac_he"
+    return profile
+
+
 def _split_quality(quality_str: str) -> List[str]:
     """Split a quality string like '-vbr:1 on -b:1 120k' into list items."""
     return quality_str.split()
 
 
-def build_audio(audio_tracks, audio_file_index=0) -> List[str]:
+def build_audio(audio_tracks, audio_file_index=0, reverse_video: bool = False) -> List[str]:
     command_list = []
     has_truehd = False
     has_opus = False
@@ -89,15 +148,26 @@ def build_audio(audio_tracks, audio_file_index=0) -> List[str]:
             try:
                 cl = track.downmix if track.downmix and track.downmix != "No Downmix" else track.raw_info.channel_layout
             except (AssertionError, KeyError, AttributeError):
-                cl = "stereo"
-                logger.warning("Could not determine channel layout, defaulting to stereo, please manually specify")
+                cl = None
+                logger.warning("Could not determine channel layout, not forcing a channel layout filter")
+
+            try:
+                source_channels = track.raw_info.get("channels") or track.channels
+            except AttributeError:
+                source_channels = track.channels
+            out_channels = channels_for_layout(cl, source_channels)
 
             downmix = (
                 [f"-ac:{track.outdex}", str(channel_list[cl])]
-                if track.downmix and track.downmix != "No Downmix"
+                if track.downmix and track.downmix != "No Downmix" and cl in channel_list
                 else []
             )
-            channel_layout = [f"-filter:{track.outdex}", f"aformat=channel_layouts={cl}"]
+            audio_filters = []
+            if reverse_video:
+                audio_filters.append("areverse")
+            if cl in channel_list:
+                audio_filters.append(f"aformat=channel_layouts={cl}")
+            channel_layout = [f"-filter:{track.outdex}", ",".join(audio_filters)] if audio_filters else []
 
             bitrate_parts = []
             if track.conversion_codec not in lossless:
@@ -113,12 +183,15 @@ def build_audio(audio_tracks, audio_file_index=0) -> List[str]:
                         audio_quality_converter(
                             track.conversion_aq or 0,
                             track.conversion_codec,
-                            track.raw_info.get("channels"),
+                            out_channels,
                             track.outdex,
                         )
                     )
 
             command_list.extend([f"-c:{track.outdex}", track.conversion_codec])
+            aac_profile = resolve_aac_profile(track.conversion_codec, track.conversion_profile, out_channels)
+            if aac_profile:
+                command_list.extend([f"-profile:{track.outdex}", aac_profile])
             command_list.extend(bitrate_parts)
             command_list.extend(downmix)
             command_list.extend(channel_layout)
diff --git a/fastflix/encoders/common/encc_helpers.py b/fastflix/encoders/common/encc_helpers.py
index 9262c86f..faf8fce5 100644
--- a/fastflix/encoders/common/encc_helpers.py
+++ b/fastflix/encoders/common/encc_helpers.py
@@ -1,15 +1,21 @@
 # -*- coding: utf-8 -*-
 import logging
+from fractions import Fraction
 from typing import List, Optional
 
 from fastflix.models.video import SubtitleTrack, AudioTrack, DataTrack, Video
-from fastflix.encoders.common.audio import lossless
+from fastflix.encoders.common.audio import lossless, resolve_aac_profile, channel_list
+from fastflix.encoders.common.helpers import split_extra_args  # noqa: F401  (re-exported for builders)
 from fastflix.models.fastflix import FastFlix
 from fastflix.models.encode import VCEEncCAVCSettings, VCEEncCAV1Settings, VCEEncCSettings
 
 logger = logging.getLogger("fastflix")
 
 
+# FastFlix (FFmpeg) AAC profile name -> libavcodec profile name used by rigaya's --audio-profile
+RIGAYA_AUDIO_PROFILES = {"aac_low": "LC", "aac_he": "HE-AAC", "aac_he_v2": "HE-AACv2"}
+
+
 def audio_quality_converter(quality, codec, channels=2, track_number=1):
     base = [120, 96, 72, 48, 24, 24, 16, 8, 8, 8][quality]
 
@@ -72,7 +78,63 @@ def rigaya_auto_options(fastflix: FastFlix) -> List[str]:
     ]
 
 
-def _parse_frame_rate(frame_rate_str: str) -> Optional[float]:
+def rigaya_hdr_static_metadata(fastflix: FastFlix) -> List[str]:
+    """--master-display / --max-cll, skipped when tone mapping to SDR since they would describe HDR content."""
+    video = fastflix.current_video
+    if video.video_settings.remove_hdr:
+        return []
+    result = []
+    if video.master_display:
+        md = video.master_display
+        result.extend(["--master-display", f"G{md.green}B{md.blue}R{md.red}WP{md.white}L{md.luminance}"])
+    if video.cll:
+        result.extend(["--max-cll", str(video.cll)])
+    return result
+
+
+# Valid --profile values per codec, from the NVEncC options documentation
+NVENC_PROFILES = {
+    "hevc": ("main", "main10", "main444"),
+    "av1": ("main", "high"),
+    "avc": ("baseline", "main", "high", "high10", "high422", "high444"),
+}
+
+
+def nvenc_profile_args(profile: Optional[str], codec: str) -> List[str]:
+    if not profile or profile.lower() == "auto":
+        return []
+    if profile.lower() not in NVENC_PROFILES[codec]:
+        logger.warning(f"Profile {profile} is not valid for NVEncC {codec}, ignoring")
+        return []
+    return ["--profile", profile.lower()]
+
+
+# Valid --tune values per codec, from the NVEncC options documentation (uhq: HEVC/AV1 only, lossless: H.264/HEVC)
+NVENC_TUNES = {
+    "hevc": ("hq", "uhq", "lowlatency", "ultralowlatency", "lossless"),
+    "av1": ("hq", "uhq", "lowlatency", "ultralowlatency"),
+    "avc": ("hq", "lowlatency", "ultralowlatency", "lossless"),
+}
+
+
+def nvenc_tune_args(tune: Optional[str], codec: str) -> List[str]:
+    if not tune or tune.lower() == "hq":
+        return []
+    if tune.lower() not in NVENC_TUNES[codec]:
+        logger.warning(f"Tune {tune} is not valid for NVEncC {codec}, ignoring")
+        return []
+    return ["--tune", tune.lower()]
+
+
+def qvbr_quality_value(settings) -> Optional[str]:
+    """Quality for quality based VBR (--qvbr), None when QVBR is off."""
+    value = getattr(settings, "qvbr_quality", None)
+    if value is None or str(value).strip().lower() in ("", "off", "auto", "none"):
+        return None
+    return str(value).strip()
+
+
+def parse_frame_rate(frame_rate_str: str) -> Optional[float]:
     """Parse a frame rate string like '24000/1001' or '30' into a float.
 
     Returns None if the string is empty or cannot be parsed.
@@ -105,7 +167,7 @@ def rigaya_trim_or_seek(video: Video) -> List[str]:
         return []
 
     if not video.video_settings.fast_seek:
-        fps = _parse_frame_rate(video.frame_rate)
+        fps = parse_frame_rate(video.frame_rate)
         if fps:
             start_frame = int(start_time * fps) if start_time else 0
             if end_time:
@@ -122,11 +184,11 @@ def rigaya_trim_or_seek(video: Video) -> List[str]:
     return result
 
 
-def pa_builder(settings: VCEEncCAVCSettings | VCEEncCAV1Settings | VCEEncCSettings):
+def pa_builder(settings: VCEEncCAVCSettings | VCEEncCAV1Settings | VCEEncCSettings) -> List[str]:
     if not settings.pre_analysis:
-        return ""
+        return []
     base = (
-        f"--pa sc={settings.pa_sc},"
+        f"sc={settings.pa_sc},"
         f"ss={settings.pa_ss},"
         f"activity-type={settings.pa_activity_type},"
         f"caq-strength={settings.pa_caq_strength},"
@@ -145,7 +207,7 @@ def pa_builder(settings: VCEEncCAVCSettings | VCEEncCAV1Settings | VCEEncCSettin
     if settings.pa_motion_quality is not None:
         base += f"motion-quality={settings.pa_motion_quality},"
 
-    return base.rstrip(",")
+    return ["--pa", base.rstrip(",")]
 
 
 def get_stream_pos(streams) -> dict:
@@ -196,6 +258,16 @@ def build_audio(audio_tracks: list[AudioTrack], audio_streams) -> List[str]:
                     bitrate_parts = quality_str.split()
             command_list.extend(downmix)
             command_list.extend(["--audio-codec", f"{audio_id}?{track.conversion_codec}"])
+            # rigaya matches the profile against libavcodec's profile names (LC, HE-AAC, HE-AACv2)
+            if track.downmix and track.downmix != "No Downmix":
+                out_channels = channel_list.get(track.downmix)
+            else:
+                out_channels = track.raw_info.get("channels") if track.raw_info else None
+            aac_profile = resolve_aac_profile(track.conversion_codec, track.conversion_profile, out_channels)
+            if aac_profile:
+                command_list.extend(
+                    ["--audio-profile", f"{audio_id}?{RIGAYA_AUDIO_PROFILES.get(aac_profile, aac_profile)}"]
+                )
             command_list.extend(bitrate_parts)
             command_list.extend(["--audio-metadata", f"{audio_id}?clear"])
 
@@ -266,9 +338,17 @@ def build_subtitle(subtitle_tracks: list[SubtitleTrack], subtitle_streams, video
     return result
 
 
-def build_data(data_tracks: list[DataTrack], data_streams, attachment_streams) -> List[str]:
+def build_data(data_tracks: list[DataTrack], data_streams, attachment_streams, output_path=None) -> List[str]:
     if not data_tracks:
         return []
+
+    # Rigaya encoders can only copy data/attachment streams to Matroska containers.
+    # MP4/MOV and other formats crash because the muxer can't handle data streams.
+    if output_path:
+        ext = str(output_path).rsplit(".", 1)[-1].lower() if "." in str(output_path) else ""
+        if f".{ext}" not in {".mkv", ".mka"}:
+            return []
+
     command_list = []
     data_copies = []
     attachment_copies = []
@@ -288,3 +368,218 @@ def build_data(data_tracks: list[DataTrack], data_streams, attachment_streams) -
     if attachment_copies:
         command_list.extend(["--attachment-copy", ",".join(attachment_copies)])
     return command_list
+
+
+# Mapping of FastFlix FFmpeg denoise preset strings to rigaya VPP equivalents.
+# nlmeans -> --vpp-nlmeans (direct equivalent: s->sigma/h, p->patch, r->search)
+# atadenoise -> --vpp-knn (closest spatial/temporal alternative)
+# hqdn3d -> --vpp-pmd (closest spatial denoiser)
+# vaguedenoiser -> --vpp-pmd (no wavelet denoiser in rigaya)
+RIGAYA_UNSHARP_MAP: dict[str, list[str]] = {
+    "unsharp=5:5:0.5:5:5:0.0": ["--vpp-unsharp", "radius=3,weight=0.3"],
+    "unsharp=5:5:1.0:5:5:0.5": ["--vpp-unsharp", "radius=3,weight=0.6"],
+    "unsharp=7:7:1.5:7:7:1.0": ["--vpp-unsharp", "radius=5,weight=1.0"],
+}
+
+RIGAYA_DENOISE_MAP: dict[str, list[str]] = {
+    # nlmeans weak/moderate/strong
+    "nlmeans=s=1.0:p=3:r=9": ["--vpp-nlmeans", "sigma=1.0,h=1.0,patch=3,search=9"],
+    "nlmeans=s=1.0:p=7:r=15": ["--vpp-nlmeans", "sigma=1.0,h=1.0,patch=7,search=15"],
+    "nlmeans=s=10.0:p=13:r=25": ["--vpp-nlmeans", "sigma=10.0,h=10.0,patch=13,search=25"],
+    # nlmeans_opencl -> same rigaya nlmeans (natively GPU-accelerated)
+    "nlmeans_opencl=s=1.0:p=3:r=9": ["--vpp-nlmeans", "sigma=1.0,h=1.0,patch=3,search=9"],
+    "nlmeans_opencl=s=1.0:p=7:r=15": ["--vpp-nlmeans", "sigma=1.0,h=1.0,patch=7,search=15"],
+    "nlmeans_opencl=s=10.0:p=13:r=25": ["--vpp-nlmeans", "sigma=10.0,h=10.0,patch=13,search=25"],
+    # atadenoise weak/moderate/strong -> knn
+    "atadenoise=0a=0.01:0b=0.02:1a=0.01:1b=0.02:2a=0.01:2b=0.02:s=9": [
+        "--vpp-knn",
+        "radius=3,strength=0.04,lerp=0.2,th_lerp=0.8",
+    ],
+    "atadenoise=0a=0.02:0b=0.04:1a=0.02:1b=0.04:2a=0.02:2b=0.04:s=9": [
+        "--vpp-knn",
+        "radius=3,strength=0.08,lerp=0.2,th_lerp=0.8",
+    ],
+    "atadenoise=0a=0.04:0b=0.12:1a=0.04:1b=0.12:2a=0.04:2b=0.12:s=9": [
+        "--vpp-knn",
+        "radius=3,strength=0.16,lerp=0.2,th_lerp=0.8",
+    ],
+    # hqdn3d weak/moderate/strong -> pmd
+    "hqdn3d=luma_spatial=2:chroma_spatial=1.5:luma_tmp=3:chroma_tmp=2.25": [
+        "--vpp-pmd",
+        "apply_count=1,strength=50,threshold=80",
+    ],
+    "hqdn3d=luma_spatial=4:chroma_spatial=3:luma_tmp=6:chroma_tmp=4.5": [
+        "--vpp-pmd",
+        "apply_count=2,strength=80,threshold=100",
+    ],
+    "hqdn3d=luma_spatial=10:chroma_spatial=7.5:luma_tmp=15:chroma_tmp=11.25": [
+        "--vpp-pmd",
+        "apply_count=2,strength=100,threshold=120",
+    ],
+    # vaguedenoiser weak/moderate/strong -> pmd
+    "vaguedenoiser=threshold=1:method=soft:nsteps=5": ["--vpp-pmd", "apply_count=1,strength=50,threshold=80"],
+    "vaguedenoiser=threshold=3:method=soft:nsteps=5": ["--vpp-pmd", "apply_count=2,strength=80,threshold=100"],
+    "vaguedenoiser=threshold=6:method=soft:nsteps=5": ["--vpp-pmd", "apply_count=2,strength=100,threshold=120"],
+}
+
+
+def output_fps_to_fraction(value: str) -> Optional[str]:
+    """Convert a user supplied frame rate ("30", "23.976", "24000/1001") to the <int>/<int> form --vpp-fruc needs."""
+    try:
+        fraction = Fraction(str(value).strip()).limit_denominator(1001)
+    except (ValueError, ZeroDivisionError):
+        return None
+    if fraction <= 0:
+        return None
+    return f"{fraction.numerator}/{fraction.denominator}"
+
+
+def rigaya_extra_options(video: Video, hdr2sdr: Optional[str] = None, fruc: bool = False) -> List[str]:
+    """Build extra VPP filter and encoder arguments for rigaya encoders from advanced panel settings.
+
+    ``hdr2sdr`` is an optional ``hdr2sdr=<tonemap>`` parameter that gets merged with LUT3D into one --vpp-colorspace.
+    ``fruc`` is True for NVEncC, the only rigaya encoder with a target frame rate filter (--vpp-fruc fps=).
+    """
+    result: List[str] = []
+    vs = video.video_settings
+
+    # Equalizer via --vpp-tweak
+    tweak_parts = []
+    try:
+        if vs.brightness is not None and vs.brightness.strip():
+            val = float(vs.brightness)
+            if val != 0.0:
+                tweak_parts.append(f"brightness={max(-1.0, min(1.0, val))}")
+    except ValueError:
+        logger.warning(f"Invalid brightness value for rigaya: {vs.brightness}")
+    try:
+        if vs.contrast is not None and vs.contrast.strip():
+            val = float(vs.contrast)
+            if val != 1.0:
+                tweak_parts.append(f"contrast={max(-2.0, min(2.0, val))}")
+    except ValueError:
+        logger.warning(f"Invalid contrast value for rigaya: {vs.contrast}")
+    try:
+        if vs.saturation is not None and vs.saturation.strip():
+            val = float(vs.saturation)
+            if val != 1.0:
+                tweak_parts.append(f"saturation={max(0.0, min(3.0, val))}")
+    except ValueError:
+        logger.warning(f"Invalid saturation value for rigaya: {vs.saturation}")
+    try:
+        if vs.gamma is not None and vs.gamma.strip():
+            val = float(vs.gamma)
+            if val != 1.0:
+                tweak_parts.append(f"gamma={max(0.1, min(10.0, val))}")
+    except ValueError:
+        logger.warning(f"Invalid gamma value for rigaya: {vs.gamma}")
+    try:
+        if vs.hue is not None and vs.hue.strip():
+            val = float(vs.hue)
+            if val != 0.0:
+                tweak_parts.append(f"hue={max(-180.0, min(180.0, val))}")
+    except ValueError:
+        logger.warning(f"Invalid hue value for rigaya: {vs.hue}")
+    if tweak_parts:
+        result.extend(["--vpp-tweak", ",".join(tweak_parts)])
+
+    # Unsharp mask (preset-based, takes priority over CAS sharpen for --vpp-unsharp)
+    has_unsharp = False
+    if vs.unsharp:
+        rigaya_unsharp = RIGAYA_UNSHARP_MAP.get(vs.unsharp)
+        if rigaya_unsharp:
+            result.extend(rigaya_unsharp)
+            has_unsharp = True
+        else:
+            logger.warning(f"No rigaya unsharp mapping for: {vs.unsharp}")
+
+    # Sharpen (CAS) — only apply if unsharp mask is not already set (both use --vpp-unsharp)
+    if not has_unsharp:
+        try:
+            if vs.sharpen is not None and vs.sharpen.strip():
+                val = float(vs.sharpen)
+                if val > 0:
+                    result.extend(["--vpp-unsharp", f"radius=3,weight={max(0.0, min(1.0, val))}"])
+        except ValueError:
+            logger.warning(f"Invalid sharpen value for rigaya: {vs.sharpen}")
+
+    # Denoise
+    if vs.denoise:
+        rigaya_denoise = RIGAYA_DENOISE_MAP.get(vs.denoise)
+        if rigaya_denoise:
+            result.extend(rigaya_denoise)
+        else:
+            logger.warning(f"No rigaya denoise mapping for: {vs.denoise}")
+
+    # Deblock
+    if vs.deblock:
+        if vs.deblock == "weak":
+            result.extend(["--vpp-deblock", "qp=24"])
+        elif vs.deblock == "strong":
+            result.extend(["--vpp-deblock", "qp=36,alpha=2,beta=2"])
+
+    # Curves preset
+    if vs.curves_preset:
+        result.extend(["--vpp-curves", f"preset={vs.curves_preset}"])
+
+    # --vpp-colorspace may only be given once, so hdr2sdr and lut3d are combined into a single argument
+    colorspace_parts = []
+    if hdr2sdr:
+        colorspace_parts.append(hdr2sdr)
+    if vs.lut3d_path:
+        colorspace_parts.append(f"lut3d={vs.lut3d_path},lut3d_interp=tetrahedral")
+    if colorspace_parts:
+        result.extend(["--vpp-colorspace", ",".join(colorspace_parts)])
+
+    # Pad / Letterbox
+    if vs.pad_aspect and vs.pad_aspect != "none":
+        try:
+            num, den = vs.pad_aspect.split(":")
+            target_ratio = int(num) / int(den)
+            # Start with source dimensions, apply crop
+            sw = video.width
+            sh = video.height
+            if vs.crop:
+                sw = sw - vs.crop.left - vs.crop.right
+                sh = sh - vs.crop.top - vs.crop.bottom
+            # rigaya applies --vpp-rotate before resize and pad (crop happens at input), so a 90/270 degree
+            # rotation swaps the cropped dimensions before padding.
+            if vs.rotate in (1, 3):
+                sw, sh = sh, sw
+            # --output-res is the final (post-rotation) size, so scaled dimensions are used as-is
+            if video.output_width is not None and video.output_height is not None:
+                sw = video.output_width
+                sh = video.output_height
+            current_ratio = sw / sh if sh else 1
+            if current_ratio < target_ratio:
+                new_w = int(round(sh * target_ratio / 2) * 2)
+                pad_left = (new_w - sw) // 2
+                pad_right = new_w - sw - pad_left
+                result.extend(["--vpp-pad", f"{pad_left},{0},{pad_right},{0}"])
+            elif current_ratio > target_ratio:
+                new_h = int(round(sw / target_ratio / 2) * 2)
+                pad_top = (new_h - sh) // 2
+                pad_bottom = new_h - sh - pad_top
+                result.extend(["--vpp-pad", f"{0},{pad_top},{0},{pad_bottom}"])
+        except (ValueError, ZeroDivisionError):
+            logger.warning(f"Invalid pad aspect for rigaya: {vs.pad_aspect}")
+
+    # Output FPS: only NVEncC has a target frame rate filter (Turing+, Windows only, processes in 8 bit)
+    if vs.output_fps:
+        fps_fraction = output_fps_to_fraction(vs.output_fps) if fruc else None
+        if fps_fraction:
+            result.extend(["--vpp-fruc", f"fps={fps_fraction}"])
+        elif fruc:
+            logger.warning(f"Invalid output frame rate for NVEncC, ignoring: {vs.output_fps}")
+        else:
+            logger.warning("QSVEncC and VCEEncC have no output frame rate filter, ignoring the output frame rate")
+
+    # Video track title
+    if vs.video_track_title:
+        result.extend(["--video-metadata", f"title={vs.video_track_title}"])
+
+    # GOP length
+    if vs.gop_length is not None and vs.gop_length > 0:
+        result.extend(["--gop-len", str(vs.gop_length)])
+
+    return result
diff --git a/fastflix/encoders/common/hdr_metadata.py b/fastflix/encoders/common/hdr_metadata.py
new file mode 100644
index 00000000..02a06951
--- /dev/null
+++ b/fastflix/encoders/common/hdr_metadata.py
@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+import re
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+HDR_BIT_DEPTHS = (10, 12)
+
+valid_color_primaries = [
+    "bt709",
+    "unknown",
+    "reserved",
+    "bt470m",
+    "bt470bg",
+    "smpte170m",
+    "smpte240m",
+    "film",
+    "bt2020",
+    "smpte428",
+    "smpte431",
+    "smpte432",
+]
+
+valid_color_transfers = [
+    "bt709",
+    "unknown",
+    "reserved",
+    "bt470m",
+    "bt470bg",
+    "smpte170m",
+    "smpte240m",
+    "linear",
+    "log100",
+    "log316",
+    "iec61966-2-4",
+    "bt1361e",
+    "iec61966-2-1",
+    "bt2020-10",
+    "bt2020-12",
+    "smpte2084",
+    "smpte428",
+    "arib-std-b67",
+]
+
+valid_color_matrix = [
+    "gbr",
+    "bt709",
+    "unknown",
+    "reserved",
+    "fcc",
+    "bt470bg",
+    "smpte170m",
+    "smpte240m",
+    "ycgco",
+    "bt2020nc",
+    "bt2020c",
+    "smpte2085",
+    "chroma-derived-nc",
+    "chroma-derived-c",
+    "ictcp",
+]
+
+color_primaries_mapping = {"smpte428_1": "smpte428"}
+
+color_transfer_mapping = {
+    "iec61966_2_4": "iec61966-2-4",
+    "iec61966_2_1": "iec61966-2-1",
+    "bt2020_10": "bt2020-10",
+    "bt2020_10bit": "bt2020-10",
+    "bt2020_12": "bt2020-12",
+    "bt2020_12bit": "bt2020-12",
+    "smpte428_1": "smpte428",
+}
+
+color_matrix_mapping = {"bt2020_ncl": "bt2020nc", "bt2020_cl": "bt2020c"}
+
+chromaloc_mapping = {"left": 0, "center": 1, "topleft": 2, "top": 3, "bottomleft": 4, "bottom": 5}
+
+
+def get_bit_depth(pix_fmt: Optional[str]) -> int:
+    """Bit depth encoded in an ffmpeg pix_fmt name (yuv422p10le, p010le, ...); 8 when none is present."""
+    if not pix_fmt:
+        return 8
+    match = re.search(r"p0?(\d{2})(?:le|be)?$", pix_fmt)
+    return int(match.group(1)) if match else 8
+
+
+def is_hdr_bit_depth(pix_fmt: Optional[str]) -> bool:
+    """True for 10/12 bit formats of any chroma subsampling."""
+    return get_bit_depth(pix_fmt) in HDR_BIT_DEPTHS
+
+
+def _pair(value: str) -> Tuple[str, str]:
+    first, second = str(value).strip().strip("()").split(",")
+    return first.strip(), second.strip()
+
+
+@dataclass(frozen=True)
+class MasterDisplay:
+    """Mastering display metadata as stored by flix.convert_mastering_display.
+
+    Chromaticities are in 1/50000 units, luminance in 1/10000 cd/m2 units; values are kept as the stored tokens.
+    """
+
+    green: Tuple[str, str]
+    blue: Tuple[str, str]
+    red: Tuple[str, str]
+    white: Tuple[str, str]
+    luminance: Tuple[str, str]
+
+    def to_x265(self) -> str:
+        return (
+            f"G({','.join(self.green)})B({','.join(self.blue)})R({','.join(self.red)})"
+            f"WP({','.join(self.white)})L({','.join(self.luminance)})"
+        )
+
+    def to_rav1e(self) -> str:
+        # librav1e does not read this through rav1e-params (it only logs a warning); kept as previously emitted
+        return self.to_x265()
+
+    def to_svt_av1(self) -> str:
+        def scale(pair, rate=50_000):
+            return ",".join(f"{float(v) / rate:0.4f}" for v in pair)
+
+        return (
+            f"G({scale(self.green)})B({scale(self.blue)})R({scale(self.red)})"
+            f"WP({scale(self.white)})L({scale(self.luminance, 10_000)})"
+        )
+
+    def to_vvenc(self) -> str:
+        """vvenc MasteringDisplayColourVolume: Gx,Gy,Bx,By,Rx,Ry,WPx,WPy,Lmax,Lmin"""
+        return ",".join(",".join(p) for p in (self.green, self.blue, self.red, self.white, self.luminance))
+
+
+def parse_master_display(master_display) -> Optional[MasterDisplay]:
+    if not master_display:
+        return None
+    return MasterDisplay(
+        green=_pair(master_display.green),
+        blue=_pair(master_display.blue),
+        red=_pair(master_display.red),
+        white=_pair(master_display.white),
+        luminance=_pair(master_display.luminance),
+    )
diff --git a/fastflix/encoders/common/helpers.py b/fastflix/encoders/common/helpers.py
index 99b97831..1d2c4229 100644
--- a/fastflix/encoders/common/helpers.py
+++ b/fastflix/encoders/common/helpers.py
@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+import re
 import shlex
 import subprocess
 import sys
@@ -17,6 +18,25 @@
 
 null = "/dev/null"
 
+BITMAP_SUBTITLE_TYPES = ("picture", "pgs")
+
+_COLOR_NAME = re.compile(r"^[A-Za-z]+$")
+_COLOR_HEX = re.compile(r"^(0x|#)[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?$")
+_COLOR_ALPHA = re.compile(r"^(0x[0-9A-Fa-f]{1,2}|[0-9]*\.?[0-9]+)$")
+
+
+def validate_ffmpeg_color(value, default="black") -> str:
+    """Return value if it is an ffmpeg colour (name or 0xRRGGBB/#RRGGBB, optional @alpha), otherwise default."""
+    if not isinstance(value, str):
+        return default
+    value = value.strip()
+    color, _, alpha = value.partition("@")
+    if not (_COLOR_NAME.match(color) or _COLOR_HEX.match(color)):
+        return default
+    if "@" in value and not _COLOR_ALPHA.match(alpha):
+        return default
+    return value
+
 
 if reusables.win_based:
     null = "NUL"
@@ -48,6 +68,16 @@ def to_string(self) -> str:
         return shlex.join(self.command)
 
 
+def split_extra_args(text: str) -> List[str]:
+    """Split user supplied custom arguments like a shell; backslashes stay literal on Windows (paths)."""
+    lex = shlex.shlex(text, posix=True)
+    lex.whitespace_split = True
+    lex.commenters = ""
+    if sys.platform == "win32":
+        lex.escape = ""
+    return list(lex)
+
+
 def generate_ffmpeg_start(
     source,
     ffmpeg,
@@ -70,14 +100,22 @@ def generate_ffmpeg_start(
     remove_hdr: bool = True,
     start_extra: Union[List[str], str] = "",
     extra_inputs: Optional[List[str]] = None,
+    gop_length=None,
+    denoise: Optional[str] = None,
+    reverse_video: bool = False,
     **_,
 ) -> List[str]:
     command = [str(ffmpeg)]
+    uses_nlmeans_opencl = bool(denoise) and denoise.startswith("nlmeans_opencl")
+    # The reverse filter operates on the filtergraph output, so output-side (exact) seeking would trim the
+    # already reversed timeline (mirrored segment) and desync copied streams. Always seek on the input side.
+    if reverse_video and filters:
+        fast_seek = True
 
     if start_extra:
-        command.extend(start_extra if isinstance(start_extra, list) else shlex.split(start_extra))
+        command.extend(start_extra if isinstance(start_extra, list) else split_extra_args(start_extra))
 
-    if enable_opencl and remove_hdr:
+    if enable_opencl and (remove_hdr or uses_nlmeans_opencl):
         command.extend(["-init_hw_device", "opencl:0.0=ocl", "-filter_hw_device", "ocl"])
 
     command.append("-y")
@@ -133,6 +171,9 @@ def generate_ffmpeg_start(
     if video_track_title:
         command.extend(["-metadata:s:v:0", f"title={video_track_title}"])
 
+    if gop_length is not None and gop_length > 0:
+        command.extend(["-g", str(gop_length)])
+
     return command
 
 
@@ -160,6 +201,7 @@ def generate_ending(
     source_has_rotation=False,
     copy_data=False,
     data_tracks=None,
+    faststart=True,
     **_,
 ):
     command = []
@@ -191,24 +233,55 @@ def generate_ending(
     if cover:
         command.extend(cover)
 
+    mapped_data = False
     if data_tracks:
         has_data = False
         has_attachment = False
+        # Compute the real output stream index from what is actually mapped (video + audio + subtitles that are
+        # not burned in), instead of trusting the stored outdex which can go stale.
+        next_outdex = (
+            1 + sum(1 for x in (audio or []) if x == "-map") + sum(1 for x in (subtitles or []) if x == "-map")
+        )
         for track in data_tracks:
             if not track.enabled:
                 continue
+            mapped_data = True
             command.extend(["-map", f"0:{track.index}"])
+            outdex = next_outdex
+            next_outdex += 1
+            # Clear title/handler metadata (same as audio tracks)
+            if track.title:
+                command.extend([f"-metadata:s:{outdex}", f"title={track.title}"])
+                command.extend([f"-metadata:s:{outdex}", f"handler={track.title}"])
+            else:
+                command.extend([f"-metadata:s:{outdex}", "title="])
+                command.extend([f"-metadata:s:{outdex}", "handler="])
             if track.codec_type == "data":
                 has_data = True
             elif track.codec_type == "attachment":
                 has_attachment = True
+                # Restore mimetype/filename stripped by -map_metadata -1
+                # (required by the matroska muxer for attachment streams)
+                if track.mimetype:
+                    command.extend([f"-metadata:s:{outdex}", f"mimetype={track.mimetype}"])
+                if track.filename:
+                    command.extend([f"-metadata:s:{outdex}", f"filename={track.filename}"])
         if has_data:
             command.extend(["-c:d", "copy"])
         if has_attachment:
             command.extend(["-c:t", "copy"])
     elif copy_data:
+        mapped_data = True
         command.extend(["-map", "0:d", "-c:d", "copy"])
 
+    # Explicitly disable data/attachment streams when none are mapped to prevent
+    # FFmpeg from auto-including them (causes failures with formats like MKV)
+    if not mapped_data:
+        command.append("-dn")
+
+    if faststart and output_video and output_video.suffix.lower() in (".mp4", ".mov", ".m4v"):
+        command.extend(["-movflags", "+faststart"])
+
     if output_video and not null_ending:
         command.append(str(sanitize(output_video)))
     else:
@@ -226,6 +299,7 @@ def generate_filters(
     sar=None,
     remove_hdr=False,
     vaapi: bool = False,
+    vaapi_format: str = "nv12",
     rotate=0,
     vertical_flip=None,
     horizontal_flip=None,
@@ -238,28 +312,36 @@ def generate_filters(
     start_filters=None,
     raw_filters=False,
     deinterlace=False,
+    deinterlace_filter="yadif",
     contrast=None,
     brightness=None,
     saturation=None,
+    gamma=None,
+    hue=None,
+    sharpen=None,
     enable_opencl: bool = False,
     tone_map: str = "hable",
     video_speed: Union[float, int] = 1,
+    reverse_video: bool = False,
     deblock: Union[str, None] = None,
     deblock_size: int = 4,
     denoise: Union[str, None] = None,
     color_transfer: Optional[str] = None,
-    **_,
+    color_primaries: Optional[str] = None,
+    color_space: Optional[str] = None,
+    source_pix_fmt: Optional[str] = None,
+    target_pix_fmt: Optional[str] = None,
+    **_kw,
 ):
     filter_list = []
     if start_filters:
         filter_list.append(start_filters)
     if deinterlace:
-        filter_list.append("yadif")
+        filter_list.append(deinterlace_filter or "yadif")
     if crop:
         filter_list.append(f"crop={crop['width']}:{crop['height']}:{crop['left']}:{crop['top']}")
     if scale:
-        if not vaapi:
-            filter_list.append(f"scale={scale}:flags={scale_filter},setsar=1:1")
+        filter_list.append(f"scale={scale}:flags={scale_filter},setsar=1:1")
     elif sar and sar != "1:1" and sar != "1/1":
         filter_list.append("setsar=1:1")
     if rotate:
@@ -273,12 +355,66 @@ def generate_filters(
         filter_list.append("vflip")
     if horizontal_flip:
         filter_list.append("hflip")
+    # Pad after rotation/flip so the target aspect is applied to the final orientation
+    pad_aspect = _kw.get("pad_aspect")
+    if pad_aspect and pad_aspect != "none":
+        pad_color = validate_ffmpeg_color(_kw.get("pad_color", "black") or "black")
+        num, den = pad_aspect.split(":")
+        target_ratio = int(num) / int(den)
+        filter_list.append(
+            f"pad=w=if(gt(a\\,{target_ratio})\\,iw\\,ceil(ih*{target_ratio}/2)*2)"
+            f":h=if(gt(a\\,{target_ratio})\\,ceil(iw/{target_ratio}/2)*2\\,ih)"
+            f":x=(ow-iw)/2:y=(oh-ih)/2:color={pad_color}"
+        )
     if video_speed and video_speed != 1:
         filter_list.append(f"setpts={video_speed}*PTS")
+    text_sub_filter = None
+    if burn_in_subtitle_track is not None and burn_in_subtitle_type not in BITMAP_SUBTITLE_TYPES:
+        original_size = f":original_size={source_width}x{source_height}" if source_width and source_height else ""
+        text_sub_filter = f"subtitles='{quoted_path(str(source))}':si={burn_in_subtitle_track}{original_size}"
+    if reverse_video:
+        if text_sub_filter:
+            # Burn subtitles in before reversing so they stay in sync with the reversed video
+            filter_list.append(text_sub_filter)
+            text_sub_filter = None
+        filter_list.append("reverse")
     if deblock:
         filter_list.append(f"deblock=filter={deblock}:block={deblock_size}")
     if denoise:
-        filter_list.append(denoise)
+        if denoise.startswith("nlmeans_opencl"):
+            if enable_opencl:
+                bits_fmt = "p010" if any(x in (source_pix_fmt or "") for x in ("10", "12", "16")) else "yuv420p"
+                filter_list.append(f"format={bits_fmt},hwupload,{denoise},hwdownload,format={bits_fmt}")
+            else:
+                # No OpenCL device available (e.g. previews), fall back to the equivalent CPU filter
+                filter_list.append(denoise.replace("nlmeans_opencl", "nlmeans", 1))
+        else:
+            filter_list.append(denoise)
+    if _kw.get("deflicker"):
+        filter_list.append(_kw["deflicker"])
+    if _kw.get("unsharp"):
+        filter_list.append(_kw["unsharp"])
+
+    software_tonemap = None
+    if remove_hdr and not enable_opencl and not vaapi:
+        tin = color_transfer if color_transfer else "smpte2084"
+        pin = color_primaries if color_primaries else "bt2020"
+        min_val = color_space if color_space else "bt2020nc"
+        keep_bits = (
+            bool(target_pix_fmt)
+            and target_pix_fmt.startswith("yuv")
+            and ("10" in target_pix_fmt or "12" in target_pix_fmt)
+        )
+        out_fmt = target_pix_fmt if keep_bits else "yuv420p"
+        software_tonemap = (
+            f"zscale=tin={tin}:pin={pin}:min={min_val}:t=linear:npl=100,format=gbrpf32le,zscale=p=bt709,"
+            f"tonemap=tonemap={tone_map}:desat=0,zscale=t=bt709:m=bt709:r=tv,format={out_fmt}"
+        )
+    bitmap_burn_in = burn_in_subtitle_track is not None and burn_in_subtitle_type in BITMAP_SUBTITLE_TYPES
+    # Bitmap subtitles are overlaid on the tone-mapped (SDR) frames, so tone map first and overlay straight after.
+    tonemap_before_overlay = software_tonemap if bitmap_burn_in else None
+    if software_tonemap and not bitmap_burn_in:
+        filter_list.append(software_tonemap)
 
     eq_filters = []
     if brightness:
@@ -287,27 +423,37 @@ def generate_filters(
         eq_filters.append(f"saturation={saturation}")
     if contrast:
         eq_filters.append(f"contrast={contrast}")
+    if gamma:
+        eq_filters.append(f"gamma={gamma}")
     if eq_filters:
-        eq_filters.insert(0, "eq=eval=frame")
-        filter_list.append(":".join(eq_filters))
-
-    if filter_list and vaapi:
-        filter_list.insert(0, "hwdownload")
-    if vaapi:
-        filter_list.append("format=nv12|vaapi,hwupload")
+        filter_list.append("eq=" + ":".join(eq_filters))
+    if hue:
+        filter_list.append(f"hue=h={hue}")
+    if _kw.get("vibrance"):
+        filter_list.append(f"vibrance=intensity={_kw['vibrance']}")
+    if _kw.get("colorbalance"):
+        filter_list.append(_kw["colorbalance"])
+    if _kw.get("color_temperature"):
+        filter_list.append(f"colortemperature=temperature={_kw['color_temperature']}")
+    if _kw.get("curves_preset"):
+        filter_list.append(f"curves=preset={_kw['curves_preset']}")
+    if _kw.get("lut3d_path"):
+        filter_list.append(f"lut3d=file='{quoted_path(str(_kw['lut3d_path']))}'")
+
+    if sharpen:
+        filter_list.append(f"cas=strength={sharpen}")
+
+    # VAAPI frames are processed as software frames and uploaded last (after custom filters and subtitle burn-in)
+    vaapi_tail = f"format={vaapi_format},hwupload" if vaapi else ""
 
     if remove_hdr:
-        if enable_opencl:
+        if enable_opencl and not vaapi:
             filter_list.append(
                 f"format=p010,hwupload,tonemap_opencl=tonemap={tone_map}:desat=0:r=tv:p=bt709:t=bt709:m=bt709:format=nv12,hwdownload,format=nv12"
             )
         elif vaapi:
-            filter_list.append("tonemap_vaapi=format=nv12:p=bt709:t=bt709:m=bt709")
-        else:
-            tin = color_transfer if color_transfer else "smpte2084"
-            filter_list.append(
-                f"zscale=tin={tin}:t=linear:npl=100,format=gbrpf32le,zscale=p=bt709,tonemap=tonemap={tone_map}:desat=0,zscale=t=bt709:m=bt709:r=tv,format=yuv420p"
-            )
+            tonemap_format = "p010" if vaapi_format == "p010le" else "nv12"
+            vaapi_tail = f"format=p010le,hwupload,tonemap_vaapi=format={tonemap_format}:p=bt709:t=bt709:m=bt709"
 
     filters = ",".join(filter_list) if filter_list else ""
 
@@ -316,17 +462,31 @@ def generate_filters(
     elif not filters and custom_filters:
         filters = custom_filters
 
+    if vaapi_tail:
+        if text_sub_filter:
+            text_sub_filter = f"{text_sub_filter},{vaapi_tail}"
+        else:
+            filters = f"{filters},{vaapi_tail}" if filters else vaapi_tail
+
     if burn_in_subtitle_track is not None:
-        if burn_in_subtitle_type == "picture":
+        if bitmap_burn_in:
+            # You have to overlay first for it to work when scaled
+            base = f"[0:{selected_track}]"
+            tonemap_prefix = ""
+            if tonemap_before_overlay:
+                tonemap_prefix = f"{base}{tonemap_before_overlay}[tonemapped];"
+                base = "[tonemapped]"
+            overlay = f"{base}[{burn_in_file_index}:{burn_in_subtitle_track}]overlay"
             if filters:
-                # You have to overlay first for it to work when scaled
-                filter_complex = f"[0:{selected_track}][{burn_in_file_index}:{burn_in_subtitle_track}]overlay[subbed];[subbed]{filters}[v]"
+                filter_complex = f"{tonemap_prefix}{overlay}[subbed];[subbed]{filters}[v]"
             else:
-                filter_complex = f"[0:{selected_track}][{burn_in_file_index}:{burn_in_subtitle_track}]overlay[v]"
+                filter_complex = f"{tonemap_prefix}{overlay}[v]"
         else:
             filter_prefix = f"{filters}," if filters else ""
-            original_size = f":original_size={source_width}x{source_height}" if source_width and source_height else ""
-            filter_complex = f"[0:{selected_track}]{filter_prefix}subtitles='{quoted_path(str(source))}':si={burn_in_subtitle_track}{original_size}[v]"
+            if text_sub_filter:
+                filter_complex = f"[0:{selected_track}]{filter_prefix}{text_sub_filter}[v]"
+            else:
+                filter_complex = f"[0:{selected_track}]{filters}[v]"
     elif filters:
         filter_complex = f"[0:{selected_track}]{filters}[v]"
     else:
@@ -355,7 +515,15 @@ def generate_all(
     # Detect source rotation for metadata clearing (FFmpeg auto-rotates during re-encoding)
     source_rotation_degrees = fastflix.current_video.source_rotation
 
-    audio_cmd = build_audio(fastflix.current_video.audio_tracks) if audio else []
+    audio_cmd = (
+        build_audio(
+            fastflix.current_video.audio_tracks,
+            # Video filters (including reverse) are not applied when disabled (copy), keep audio forward then
+            reverse_video=fastflix.current_video.video_settings.reverse_video and not disable_filters,
+        )
+        if audio
+        else []
+    )
 
     # Assign file_index to external subtitle tracks and collect unique external file paths
     subtitle_tracks = fastflix.current_video.subtitle_tracks
@@ -373,7 +541,8 @@ def generate_all(
         subtitles_cmd, burn_in_track, burn_in_type = build_subtitle(
             subtitle_tracks, output_path=fastflix.current_video.video_settings.output_path
         )
-        if burn_in_type == "text":
+        burn_in_is_external = any(x.burn_in and x.enabled and x.external for x in subtitle_tracks)
+        if burn_in_type == "text" and not burn_in_is_external:
             for i, x in enumerate(fastflix.current_video.streams["subtitle"]):
                 if x["index"] == burn_in_track:
                     burn_in_track = i
@@ -390,7 +559,10 @@ def generate_all(
                     burn_in_file_index = track.file_index
                 break
 
-    attachments_cmd = build_attachments(fastflix.current_video.attachment_tracks)
+    mapped_attachment_count = sum(
+        1 for track in fastflix.current_video.data_tracks if track.enabled and track.codec_type == "attachment"
+    )
+    attachments_cmd = build_attachments(fastflix.current_video.attachment_tracks, mapped_attachment_count)
 
     enable_opencl = fastflix.opencl_support
     if "enable_opencl" in filters_extra:
@@ -414,6 +586,8 @@ def generate_all(
             scale=fastflix.current_video.scale,
             sar=fastflix.current_video.sar,
             enable_opencl=enable_opencl,
+            source_pix_fmt=fastflix.current_video.pix_fmt,
+            target_pix_fmt=getattr(settings, "pix_fmt", None),
             vaapi=vaapi,
             **filter_details,
         )
@@ -433,8 +607,10 @@ def generate_all(
     # External inputs need their own -ss/-to to stay in sync with the seeked video.
     vs = fastflix.current_video.video_settings
     extra_inputs = []
+    # Reverse forces input-side seeking (see generate_ffmpeg_start)
+    input_seek = vs.fast_seek or bool(filters_cmd and vs.reverse_video)
     for file_path in extra_input_files:
-        if vs.fast_seek:
+        if input_seek:
             if vs.start_time:
                 extra_inputs.extend(["-ss", str(vs.start_time)])
             if vs.end_time:
@@ -459,7 +635,7 @@ def generate_all(
 
 def generate_color_details(fastflix: FastFlix) -> List[str]:
     if fastflix.current_video.video_settings.remove_hdr:
-        return []
+        return ["-color_primaries", "bt709", "-color_trc", "bt709", "-colorspace", "bt709"]
 
     details = []
     if fastflix.current_video.video_settings.color_primaries:
@@ -470,3 +646,10 @@ def generate_color_details(fastflix: FastFlix) -> List[str]:
         details.extend(["-colorspace", fastflix.current_video.video_settings.color_space])
 
     return details
+
+
+def hevc_tag_args(output_path: Union[str, Path, None]) -> List[str]:
+    """Tag HEVC as hvc1 for mp4/m4v/mov, FFmpeg defaults to hev1 which QuickTime, iOS and Safari will not play."""
+    if output_path and Path(output_path).suffix.lower() in (".mp4", ".m4v", ".mov"):
+        return ["-tag:v", "hvc1"]
+    return []
diff --git a/fastflix/encoders/common/nvenc_options.py b/fastflix/encoders/common/nvenc_options.py
new file mode 100644
index 00000000..76a2503a
--- /dev/null
+++ b/fastflix/encoders/common/nvenc_options.py
@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+# Shared helpers for FFmpeg's hevc_nvenc / av1_nvenc. Option names verified against
+# https://github.com/FFmpeg/FFmpeg/blob/master/libavcodec/nvenc_hevc.c and nvenc_av1.c
+
+# FFmpeg 9.0 removed the deprecated NVENC presets, they are aliases of these p1-p7 presets plus a tune
+# (see NVENC_DEPRECATED_PRESET aliases in libavcodec/nvenc.c of FFmpeg 8.0)
+LEGACY_PRESETS = {
+    "default": ("p4", None),
+    "hp": ("p1", None),
+    "hq": ("p7", None),
+    "bd": ("p5", None),
+    "ll": ("p4", "ll"),
+    "llhp": ("p1", "ll"),
+    "llhq": ("p7", "ll"),
+    "lossless": ("p4", "lossless"),
+    "losslesshp": ("p1", "lossless"),
+}
+
+LEGACY_RC = {
+    "vbr_minqp": "vbr",
+    "vbr_2pass": "vbr",
+    "vbr_hq": "vbr",
+    "ll_2pass_quality": "vbr",
+    "ll_2pass_size": "vbr",
+    "cbr_hq": "cbr",
+    "cbr_ld_hq": "cbr",
+}
+
+
+def migrate_legacy_options(data):
+    """Rewrite removed NVENC preset / rate control values (from old profiles and queues) to supported ones."""
+    if not isinstance(data, dict):
+        return data
+    data = dict(data)
+    if data.get("preset") in LEGACY_PRESETS:
+        data["preset"], tune = LEGACY_PRESETS[data["preset"]]
+        if tune:
+            data["tune"] = tune
+    if data.get("rc") in LEGACY_RC:
+        data["rc"] = LEGACY_RC[data["rc"]]
+    return data
+
+
+def advanced_args(settings) -> list[str]:
+    """Arguments for the optional NVENC settings, nothing is emitted for default values."""
+    args = []
+    if settings.tf_level != "default":
+        args.extend(["-tf_level", settings.tf_level])
+    if settings.lookahead_level != "default":
+        args.extend(["-lookahead_level", settings.lookahead_level])
+    if settings.split_encode_mode != "default":
+        args.extend(["-split_encode_mode", settings.split_encode_mode])
+    if settings.weighted_pred:
+        args.extend(["-weighted_pred", "1"])
+    if getattr(settings, "unidir_b", False):
+        args.extend(["-unidir_b", "1"])
+    if settings.no_scenecut:
+        args.extend(["-no-scenecut", "1"])
+    return args
+
+
+def uses_cq(settings) -> bool:
+    return not settings.bitrate and settings.cq > 0
diff --git a/fastflix/encoders/common/setting_panel.py b/fastflix/encoders/common/setting_panel.py
index da923669..b86d8d5f 100644
--- a/fastflix/encoders/common/setting_panel.py
+++ b/fastflix/encoders/common/setting_panel.py
@@ -12,6 +12,7 @@
 from fastflix.ui_scale import scaler
 from fastflix.widgets.background_tasks import ExtractHDR10
 from fastflix.resources import group_box_style, get_icon
+from fastflix.widgets.toggle_switch import ToggleSwitch
 
 
 logger = logging.getLogger("fastflix")
@@ -265,7 +266,7 @@ def _add_text_box(
     def _add_check_box(self, label, widget_name, opt, connect="default", enabled=True, tooltip=""):
         layout = QtWidgets.QHBoxLayout()
 
-        self.widgets[widget_name] = QtWidgets.QCheckBox(t(label))
+        self.widgets[widget_name] = ToggleSwitch(t(label))
         self.opts[widget_name] = opt
         self.widgets[widget_name].setChecked(self.app.fastflix.config.encoder_opt(self.profile_name, opt))
         self.widgets[widget_name].setDisabled(not enabled)
@@ -291,7 +292,7 @@ def _add_custom(self, title="Custom ffmpeg options", connect="default", disable_
         layout.addWidget(self.labels.ffmpeg_options)
         self.ffmpeg_extras_widget = QtWidgets.QLineEdit()
         self.ffmpeg_extras_widget.setText(ffmpeg_extra_command)
-        self.widgets["extra_both_passes"] = QtWidgets.QCheckBox(t("Both Passes"))
+        self.widgets["extra_both_passes"] = ToggleSwitch(t("Both Passes"))
         self.opts["extra_both_passes"] = "extra_both_passes"
 
         if connect and connect != "default":
@@ -398,8 +399,14 @@ def _add_modes(
         if not disable_bitrate:
             self.bitrate_radio = QtWidgets.QRadioButton("Bitrate")
             self.bitrate_radio.setFixedWidth(scaler.scale(67))
+            self.bitrate_radio.setStyleSheet(
+                "QRadioButton::indicator { width: 12px; height: 12px; border-image: none; border: 2px solid #888888; border-radius: 8px; background-color: transparent; }"
+                " QRadioButton::indicator:checked { border-image: none; width: 10px; height: 10px; border: 3px solid #4a9eed; border-radius: 8px; background-color: white; }"
+                " QRadioButton::indicator:unchecked:hover { border-image: none; border: 2px solid #aaaaaa; }"
+            )
             self.widgets.mode.addButton(self.bitrate_radio)
             self.widgets.bitrate = QtWidgets.QComboBox()
+            self.widgets.bitrate.setSizeAdjustPolicy(QtWidgets.QComboBox.SizeAdjustPolicy.AdjustToContents)
             self.widgets.bitrate.addItems(recommended_bitrates)
             self.widgets.bitrate_passes = QtWidgets.QComboBox()
             self.widgets.bitrate_passes.addItems(["1", "2"])
@@ -422,7 +429,7 @@ def _add_modes(
             self.widgets.custom_bitrate.textChanged.connect(lambda: self.main.build_commands())
             self.widgets.custom_bitrate.setValidator(self.only_int)
             bitrate_box_layout.addWidget(self.bitrate_radio)
-            bitrate_box_layout.addWidget(self.widgets.bitrate, 1)
+            bitrate_box_layout.addWidget(self.widgets.bitrate)
             bitrate_box_layout.addStretch(1)
             if show_bitrate_passes:
                 self.widgets.bitrate_passes.setCurrentIndex(
@@ -439,9 +446,15 @@ def _add_modes(
             self.qp_radio.setChecked(True)
             self.qp_radio.setFixedWidth(scaler.scale(67))
             self.qp_radio.setToolTip(qp_help)
+            self.qp_radio.setStyleSheet(
+                "QRadioButton::indicator { width: 12px; height: 12px; border-image: none; border: 2px solid #888888; border-radius: 8px; background-color: transparent; }"
+                " QRadioButton::indicator:checked { border-image: none; width: 10px; height: 10px; border: 3px solid #4a9eed; border-radius: 8px; background-color: white; }"
+                " QRadioButton::indicator:unchecked:hover { border-image: none; border: 2px solid #aaaaaa; }"
+            )
             self.widgets.mode.addButton(self.qp_radio)
 
         self.widgets[qp_name] = QtWidgets.QComboBox()
+        self.widgets[qp_name].setSizeAdjustPolicy(QtWidgets.QComboBox.SizeAdjustPolicy.AdjustToContents)
         self.widgets[qp_name].setToolTip(qp_help)
         self.widgets[qp_name].addItems(recommended_qps)
         custom_qp = False
@@ -474,7 +487,7 @@ def _add_modes(
             self.widgets.bitrate_passes.currentIndexChanged.connect(lambda: self.mode_update())
             self.widgets.bitrate.currentIndexChanged.connect(lambda: self.mode_update())
         self.widgets[qp_name].currentIndexChanged.connect(lambda: self.mode_update())
-        qp_box_layout.addWidget(self.widgets[qp_name], 1)
+        qp_box_layout.addWidget(self.widgets[qp_name])
         qp_box_layout.addStretch(1)
         qp_box_layout.addStretch(1)
         if disable_custom_qp:
@@ -928,6 +941,15 @@ def init_level(self):
             opt="level",
         )
 
+    def init_bit_depth(self):
+        return self._add_combo_box(
+            label="Bit Depth",
+            tooltip="8-bit uploads frames as nv12, 10-bit as p010 (required for 10-bit HDR output)",
+            options=["8-bit", "10-bit"],
+            widget_name="bit_depth",
+            opt="bit_depth",
+        )
+
     def init_aud(self):
         return self._add_check_box(
             label="AUD",
diff --git a/fastflix/encoders/common/subtitles.py b/fastflix/encoders/common/subtitles.py
index 5bb1fb7d..7718b6f1 100644
--- a/fastflix/encoders/common/subtitles.py
+++ b/fastflix/encoders/common/subtitles.py
@@ -1,11 +1,18 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+import logging
 from pathlib import Path
 from typing import List, Tuple, Union
 
 from fastflix.models.video import SubtitleTrack
 
+logger = logging.getLogger("fastflix")
+
+BITMAP_SUBTITLE_TYPES = ("picture", "pgs")
+MP4_EXTENSIONS = (".mp4", ".m4v", ".mov")
+MATROSKA_EXTENSIONS = (".mkv", ".mka", ".mks", ".mk3d", ".webm")
+
 
 def build_subtitle(
     subtitle_tracks: list[SubtitleTrack], subtitle_file_index=0, output_path=None
@@ -17,21 +24,31 @@ def build_subtitle(
 
     # Determine if output is MP4 format (requires mov_text codec for subtitles)
     is_mp4 = False
+    # -default_mode is a Matroska muxer option, other muxers reject it
+    is_matroska = True
     if output_path:
         try:
             ext = Path(output_path).suffix.lower()
-            is_mp4 = ext in (".mp4", ".m4v")
+            is_mp4 = ext in MP4_EXTENSIONS
+            is_matroska = ext in MATROSKA_EXTENSIONS
         except Exception:
             pass
 
+    removed = 0
+
     for track in subtitle_tracks:
         if not track.enabled:
             continue
         if track.burn_in:
             burn_in_track = track.index
             burn_in_type = track.subtitle_type
+            removed += 1
+        elif is_mp4 and track.subtitle_type in BITMAP_SUBTITLE_TYPES:
+            # Bitmap subtitles cannot be converted to mov_text, mapping them would fail the encode
+            logger.warning(f"Skipping bitmap subtitle track {track.index}, not supported in MP4/MOV containers")
+            removed += 1
         else:
-            outdex = track.outdex - (1 if burn_in_track else 0)
+            outdex = track.outdex - removed
             # MP4 containers require mov_text codec for text subtitles instead of copy (#481)
             codec = "mov_text" if is_mp4 else "copy"
             file_idx = track.file_index if track.file_index else subtitle_file_index
@@ -53,6 +70,6 @@ def build_subtitle(
             else:
                 command_list.extend([f"-metadata:s:{outdex}", "title="])
                 command_list.extend([f"-metadata:s:{outdex}", "handler="])
-    if not subs_enabled:
+    if not subs_enabled and is_matroska:
         command_list.extend(["-default_mode", "infer_no_subs"])
     return command_list, burn_in_track, burn_in_type
diff --git a/fastflix/encoders/common/vaapi.py b/fastflix/encoders/common/vaapi.py
new file mode 100644
index 00000000..07c084b9
--- /dev/null
+++ b/fastflix/encoders/common/vaapi.py
@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+from typing import List
+
+QUALITY_MODES = ("CQP", "ICQ")
+BITRATE_MODES = ("CBR", "VBR", "AVBR")
+
+
+def vaapi_sw_format(bit_depth) -> str:
+    """Software pixel format frames are converted to before hwupload."""
+    return "p010le" if str(bit_depth or "").startswith("10") else "nv12"
+
+
+def vaapi_level_args(settings) -> List[str]:
+    level = getattr(settings, "level", None)
+    if not level or str(level).lower() == "auto":
+        return []
+    return ["-level", str(level)]
+
+
+def vaapi_rate_control_args(settings, explicit_qp: bool) -> List[str]:
+    """Rate control arguments for the *_vaapi encoders.
+
+    CQP uses the encoder's private ``-qp`` where it exists (h264/hevc), ICQ/QVBR (and CQP for encoders without
+    ``-qp``) use ``-global_quality``. Combinations that cannot work (a quality mode with only a bitrate, a bitrate
+    mode with only a quality) fall back to letting FFmpeg choose the mode from the value that is available.
+    """
+    mode = str(settings.rc_mode or "auto")
+    has_bitrate = bool(settings.bitrate)
+    has_quality = settings.qp is not None
+
+    args = []
+    if mode in QUALITY_MODES and not has_quality:
+        mode = "fallback"
+    elif mode in BITRATE_MODES + ("QVBR",) and not has_bitrate:
+        mode = "fallback"
+    if mode != "fallback":
+        args.extend(["-rc_mode", mode])
+
+    if has_bitrate and mode not in QUALITY_MODES:
+        args.extend(["-b:v", str(settings.bitrate)])
+
+    use_quality = has_quality and (
+        mode in QUALITY_MODES + ("QVBR",) or (mode in ("auto", "fallback") and not has_bitrate)
+    )
+    if use_quality:
+        if mode in ("ICQ", "QVBR") or not explicit_qp:
+            args.extend(["-global_quality", str(settings.qp)])
+        else:
+            args.extend(["-qp", str(settings.qp)])
+    return args
diff --git a/fastflix/encoders/ffmpeg_av1_nvenc/command_builder.py b/fastflix/encoders/ffmpeg_av1_nvenc/command_builder.py
index aa7b833b..34d7c4c3 100644
--- a/fastflix/encoders/ffmpeg_av1_nvenc/command_builder.py
+++ b/fastflix/encoders/ffmpeg_av1_nvenc/command_builder.py
@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
-import secrets
 import shlex
 
-from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details, null
+from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details
+from fastflix.encoders.common.nvenc_options import advanced_args, uses_cq
 from fastflix.models.encode import FFmpegAV1NVENCSettings
 from fastflix.models.fastflix import FastFlix
 
@@ -46,52 +46,21 @@ def build(fastflix: FastFlix):
     if settings.aq_strength != 8:
         beginning.extend(["-aq-strength:v", str(settings.aq_strength)])
 
+    beginning.extend(advanced_args(settings))
+    cq_mode = uses_cq(settings)
+    if cq_mode and not settings.rc:
+        beginning.extend(["-rc:v", "vbr"])
+
     extra = shlex.split(settings.extra) if settings.extra else []
-    extra_both = shlex.split(settings.extra) if settings.extra and settings.extra_both_passes else []
+
+    if cq_mode:
+        command = beginning + ["-cq:v", str(settings.cq), "-b:v", "0", "-preset:v", settings.preset] + extra + ending
+        return [Command(command=command, name="Constant quality encode", exe="ffmpeg")]
 
     if not settings.bitrate:
         command = beginning + ["-qp:v", str(settings.qp), "-preset:v", settings.preset] + extra + ending
         return [Command(command=command, name="Single QP encode", exe="ffmpeg")]
 
-    pass_log_file = fastflix.current_video.work_path / f"pass_log_file_{secrets.token_hex(10)}"
-
-    command_1 = (
-        beginning
-        + [
-            "-pass",
-            "1",
-            "-passlogfile",
-            str(pass_log_file),
-            "-b:v",
-            settings.bitrate,
-            "-preset:v",
-            settings.preset,
-            "-2pass",
-            "1",
-        ]
-        + extra_both
-        + ["-an", "-sn", "-dn"]
-        + output_fps
-        + ["-f", "mp4", null]
-    )
-    command_2 = (
-        beginning
-        + [
-            "-pass",
-            "2",
-            "-passlogfile",
-            str(pass_log_file),
-            "-2pass",
-            "1",
-            "-b:v",
-            settings.bitrate,
-            "-preset:v",
-            settings.preset,
-        ]
-        + extra
-        + ending
-    )
-    return [
-        Command(command=command_1, name="First pass bitrate", exe="ffmpeg"),
-        Command(command=command_2, name="Second pass bitrate", exe="ffmpeg"),
-    ]
+    # NVENC performs two-pass internally via -multipass; FFmpeg's -pass/-2pass are not supported by NVENC
+    command = beginning + ["-b:v", settings.bitrate, "-preset:v", settings.preset] + extra + ending
+    return [Command(command=command, name="Bitrate encode", exe="ffmpeg")]
diff --git a/fastflix/encoders/ffmpeg_av1_nvenc/settings_panel.py b/fastflix/encoders/ffmpeg_av1_nvenc/settings_panel.py
index c1900334..1bbb1b54 100644
--- a/fastflix/encoders/ffmpeg_av1_nvenc/settings_panel.py
+++ b/fastflix/encoders/ffmpeg_av1_nvenc/settings_panel.py
@@ -21,6 +21,8 @@
     "p7",
 ]
 
+SPLIT_OPTIONS = ["default", "disabled", "auto", "forced", "2", "3", "4"]
+
 recommended_bitrates = [
     "800k   (320x240p @ 30fps)",
     "1000k  (640x360p @ 30fps)",
@@ -97,6 +99,22 @@ def __init__(self, parent, main, app: FastFlixApp):
         a.addLayout(self.init_aq_strength())
         grid.addLayout(a, 4, 2, 1, 4)
 
+        c = QtWidgets.QHBoxLayout()
+        c.addLayout(self.init_tf_level())
+        c.addStretch(1)
+        c.addLayout(self.init_lookahead_level())
+        c.addStretch(1)
+        c.addLayout(self.init_split_encode_mode())
+        grid.addLayout(c, 5, 2, 1, 4)
+
+        d = QtWidgets.QHBoxLayout()
+        d.addLayout(self.init_cq())
+        d.addStretch(1)
+        d.addLayout(self.init_weighted_pred())
+        d.addStretch(1)
+        d.addLayout(self.init_no_scenecut())
+        grid.addLayout(d, 6, 2, 1, 4)
+
         grid.setRowStretch(9, 1)
 
         self.setLayout(grid)
@@ -254,15 +272,70 @@ def init_b_ref_mode(self):
         return layout
 
     def init_aq_strength(self):
-        layout = self._add_combo_box(
+        return self._add_text_box(
             label="AQ Strength",
             tooltip="When Spatial AQ is enabled, sets AQ strength (1 = low, 15 = aggressive, default 8)",
             widget_name="aq_strength",
             opt="aq_strength",
-            options=[str(x) for x in range(1, 16)],
+            validator="int",
+            default="8",
+            width=30,
+        )
+
+    def init_cq(self):
+        return self._add_text_box(
+            label="CQ",
+            tooltip="Constant quality target (0-63 max, 0 = off). When set in quality mode, uses VBR with -cq instead of constant QP",
+            widget_name="cq",
+            opt="cq",
+            validator="int",
+            default="0",
+            width=30,
+        )
+
+    def init_tf_level(self):
+        return self._add_combo_box(
+            label="Temporal Filter",
+            tooltip="Strength of the NVENC temporal filter (0 = off, 4 = on), needs B-frames and lookahead",
+            widget_name="tf_level",
+            options=["default", "0", "4"],
+            opt="tf_level",
+        )
+
+    def init_lookahead_level(self):
+        return self._add_combo_box(
+            label="Lookahead Level",
+            tooltip="Lookahead level, higher may improve quality at the expense of performance (needs RC Lookahead)",
+            widget_name="lookahead_level",
+            options=["default", "auto", "0", "1", "2", "3"],
+            opt="lookahead_level",
+        )
+
+    def init_split_encode_mode(self):
+        return self._add_combo_box(
+            label="Split Encode",
+            tooltip="Split frame encoding across multiple NVENC engines (high-end GPUs with more than one NVENC)",
+            widget_name="split_encode_mode",
+            options=SPLIT_OPTIONS,
+            opt="split_encode_mode",
+        )
+
+    def init_weighted_pred(self):
+        return self._add_combo_box(
+            label="Weighted Prediction",
+            tooltip="Enable weighted prediction (not compatible with B-frames)",
+            widget_name="weighted_pred",
+            options=["off", "on"],
+            opt="weighted_pred",
+        )
+
+    def init_no_scenecut(self):
+        return self._add_check_box(
+            opt="no_scenecut",
+            label="No Scenecut",
+            tooltip="When lookahead is enabled, disable adaptive I-frame insertion at scene cuts",
+            widget_name="no_scenecut",
         )
-        self.widgets.aq_strength.setMinimumWidth(50)
-        return layout
 
     def init_modes(self):
         layout = self._add_modes(recommended_bitrates, recommended_crfs, qp_name="qp")
@@ -302,9 +375,15 @@ def update_video_encoder_settings(self):
             level=self.widgets.level.currentText() if self.widgets.level.currentIndex() != 0 else None,
             gpu=int(self.widgets.gpu.currentText() or -1) if self.widgets.gpu.currentIndex() != 0 else -1,
             b_ref_mode=self.widgets.b_ref_mode.currentText(),
-            aq_strength=int(self.widgets.aq_strength.currentText() or 8),
+            aq_strength=int(self.widgets.aq_strength.text() or 8),
             tier=self.widgets.tier.currentText(),
             hw_accel=self.widgets.hw_accel.isChecked(),
+            cq=int(self.widgets.cq.text() or 0),
+            tf_level=self.widgets.tf_level.currentText(),
+            lookahead_level=self.widgets.lookahead_level.currentText(),
+            split_encode_mode=self.widgets.split_encode_mode.currentText(),
+            weighted_pred=self.widgets.weighted_pred.currentIndex(),
+            no_scenecut=self.widgets.no_scenecut.isChecked(),
         )
         encode_type, q_value = self.get_mode_settings()
         settings.qp = q_value if encode_type == "qp" else None
diff --git a/fastflix/encoders/ffmpeg_hevc_nvenc/command_builder.py b/fastflix/encoders/ffmpeg_hevc_nvenc/command_builder.py
index d65b0ea0..ff6cfd51 100644
--- a/fastflix/encoders/ffmpeg_hevc_nvenc/command_builder.py
+++ b/fastflix/encoders/ffmpeg_hevc_nvenc/command_builder.py
@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
-import secrets
 import shlex
 
-from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details, null
+from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details, hevc_tag_args
+from fastflix.encoders.common.nvenc_options import advanced_args, uses_cq
 from fastflix.models.encode import FFmpegNVENCSettings
 from fastflix.models.fastflix import FastFlix
 
@@ -19,7 +19,7 @@ def build(fastflix: FastFlix):
     beginning.extend(generate_color_details(fastflix))
     beginning.extend(
         [
-            "-spatial_aq:v",
+            "-spatial-aq:v",
             str(settings.spatial_aq),
             "-tier:v",
             settings.tier,
@@ -31,62 +31,37 @@ def build(fastflix: FastFlix):
             str(settings.b_ref_mode),
         ]
     )
+    if settings.temporal_aq:
+        beginning.extend(["-temporal-aq:v", str(settings.temporal_aq)])
+    if settings.aq_strength != 8:
+        beginning.extend(["-aq-strength:v", str(settings.aq_strength)])
+    beginning.extend(advanced_args(settings))
+    beginning.extend(hevc_tag_args(fastflix.current_video.video_settings.output_path))
 
     if settings.profile:
         beginning.extend(["-profile:v", settings.profile])
 
+    cq_mode = uses_cq(settings)
     if settings.rc:
         beginning.extend(["-rc:v", settings.rc])
+    elif cq_mode:
+        beginning.extend(["-rc:v", "vbr"])
 
     if settings.level:
         beginning.extend(["-level:v", settings.level])
 
     extra = shlex.split(settings.extra) if settings.extra else []
-    extra_both = shlex.split(settings.extra) if settings.extra and settings.extra_both_passes else []
+
+    if cq_mode:
+        quality = ["-cq:v", str(settings.cq), "-b:v", "0"]
+        command = beginning + quality + ["-preset:v", settings.preset] + extra + ending
+        return [Command(command=command, name="Constant quality encode", exe="ffmpeg")]
 
     if not settings.bitrate:
         command = beginning + ["-qp:v", str(settings.qp), "-preset:v", settings.preset] + extra + ending
         return [Command(command=command, name="Single QP encode", exe="ffmpeg")]
 
-    pass_log_file = fastflix.current_video.work_path / f"pass_log_file_{secrets.token_hex(10)}"
-
-    command_1 = (
-        beginning
-        + [
-            "-pass",
-            "1",
-            "-passlogfile",
-            str(pass_log_file),
-            "-b:v",
-            settings.bitrate,
-            "-preset:v",
-            settings.preset,
-            "-2pass",
-            "1",
-        ]
-        + extra_both
-        + ["-an", "-sn", "-dn"]
-        + output_fps
-        + ["-f", "mp4", null]
-    )
-    command_2 = (
-        beginning
-        + [
-            "-pass",
-            "2",
-            "-passlogfile",
-            str(pass_log_file),
-            "-2pass",
-            "1",
-            "-b:v",
-            settings.bitrate,
-            "-preset:v",
-            settings.preset,
-        ]
-        + extra
-        + ending
-    )
-    return [
-        Command(command=command_1, name="First pass bitrate", exe="ffmpeg"),
-        Command(command=command_2, name="Second pass bitrate", exe="ffmpeg"),
-    ]
+    # NVENC performs two-pass internally via -multipass; FFmpeg's -pass/-2pass are not supported by NVENC
+    multipass = ["-multipass:v", settings.multipass] if settings.multipass != "disabled" else []
+    command = beginning + ["-b:v", settings.bitrate, "-preset:v", settings.preset] + multipass + extra + ending
+    return [Command(command=command, name="Bitrate encode", exe="ffmpeg")]
diff --git a/fastflix/encoders/ffmpeg_hevc_nvenc/settings_panel.py b/fastflix/encoders/ffmpeg_hevc_nvenc/settings_panel.py
index 2ce522d4..cf9a30f8 100644
--- a/fastflix/encoders/ffmpeg_hevc_nvenc/settings_panel.py
+++ b/fastflix/encoders/ffmpeg_hevc_nvenc/settings_panel.py
@@ -11,26 +11,7 @@
 logger = logging.getLogger("fastflix")
 
 
-presets = [
-    "slow",
-    "medium",
-    "fast",
-    "hp",
-    "hq",
-    "bd",
-    "ll",
-    "llhq",
-    "llhp",
-    "lossless",
-    "losslesshp",
-    "p1",
-    "p2",
-    "p3",
-    "p4",
-    "p5",
-    "p6",
-    "p7",
-]
+presets = ["slow", "medium", "fast", "p1", "p2", "p3", "p4", "p5", "p6", "p7"]
 
 recommended_bitrates = [
     "800k   (320x240p @ 30fps)",
@@ -66,6 +47,8 @@
     "Custom",
 ]
 
+SPLIT_OPTIONS = ["default", "disabled", "auto", "forced", "2", "3"]
+
 pix_fmts = ["8-bit: yuv420p", "10-bit: p010le"]
 
 
@@ -97,6 +80,7 @@ def __init__(self, parent, main, app: FastFlixApp):
         grid.addLayout(self.init_spatial_aq(), 7, 0, 1, 2)
 
         grid.addLayout(self.init_hw_accel(), 4, 2, 1, 1)
+        grid.addLayout(self.init_multipass(), 8, 0, 1, 2)
 
         a = QtWidgets.QHBoxLayout()
         a.addLayout(self.init_rc_lookahead())
@@ -108,6 +92,30 @@ def __init__(self, parent, main, app: FastFlixApp):
         a.addLayout(self.init_b_ref_mode())
         grid.addLayout(a, 3, 2, 1, 4)
 
+        b = QtWidgets.QHBoxLayout()
+        b.addLayout(self.init_temporal_aq())
+        b.addStretch(1)
+        b.addLayout(self.init_aq_strength())
+        b.addStretch(1)
+        b.addLayout(self.init_cq())
+        b.addStretch(1)
+        b.addLayout(self.init_weighted_pred())
+        grid.addLayout(b, 5, 2, 1, 4)
+
+        c = QtWidgets.QHBoxLayout()
+        c.addLayout(self.init_tf_level())
+        c.addStretch(1)
+        c.addLayout(self.init_lookahead_level())
+        c.addStretch(1)
+        c.addLayout(self.init_split_encode_mode())
+        grid.addLayout(c, 6, 2, 1, 4)
+
+        d = QtWidgets.QHBoxLayout()
+        d.addLayout(self.init_unidir_b())
+        d.addStretch(1)
+        d.addLayout(self.init_no_scenecut())
+        grid.addLayout(d, 7, 2, 1, 4)
+
         grid.setRowStretch(9, 1)
 
         # guide_label = QtWidgets.QLabel(
@@ -171,21 +179,19 @@ def init_rc(self):
             label="Rate Control",
             tooltip="Override the preset rate-control",
             widget_name="rc",
-            options=[
-                "default",
-                "vbr",
-                "cbr",
-                "vbr_minqp",
-                "ll_2pass_quality",
-                "ll_2pass_size",
-                "vbr_2pass",
-                "cbr_ld_hq",
-                "cbr_hq",
-                "vbr_hq",
-            ],
+            options=["default", "constqp", "vbr", "cbr"],
             opt="rc",
         )
 
+    def init_multipass(self):
+        return self._add_combo_box(
+            label="Multipass",
+            tooltip="Set multipass encoding for bitrate mode\ndisabled - Single pass\nqres - Two pass (quarter resolution first pass)\nfullres - Two pass (full resolution first pass)",
+            widget_name="multipass",
+            options=["disabled", "qres", "fullres"],
+            opt="multipass",
+        )
+
     def init_hw_accel(self):
         return self._add_check_box(
             opt="hw_accel",
@@ -203,6 +209,89 @@ def init_spatial_aq(self):
             opt="spatial_aq",
         )
 
+    def init_temporal_aq(self):
+        return self._add_combo_box(
+            label="Temporal AQ",
+            tooltip="Enable temporal adaptive quantization for better quality in scenes with motion",
+            widget_name="temporal_aq",
+            options=["off", "on"],
+            opt="temporal_aq",
+        )
+
+    def init_aq_strength(self):
+        return self._add_text_box(
+            label="AQ Strength",
+            tooltip="When Spatial AQ is enabled, sets AQ strength (1 = low, 15 = aggressive, default 8)",
+            widget_name="aq_strength",
+            opt="aq_strength",
+            validator="int",
+            default="8",
+            width=30,
+        )
+
+    def init_cq(self):
+        return self._add_text_box(
+            label="CQ",
+            tooltip="Constant quality target (0-51 max, 0 = off). When set in quality mode, uses VBR with -cq instead of constant QP",
+            widget_name="cq",
+            opt="cq",
+            validator="int",
+            default="0",
+            width=30,
+        )
+
+    def init_tf_level(self):
+        return self._add_combo_box(
+            label="Temporal Filter",
+            tooltip="Strength of the NVENC temporal filter (0 = off, 4 = on), needs B-frames and lookahead",
+            widget_name="tf_level",
+            options=["default", "0", "4"],
+            opt="tf_level",
+        )
+
+    def init_lookahead_level(self):
+        return self._add_combo_box(
+            label="Lookahead Level",
+            tooltip="Lookahead level, higher may improve quality at the expense of performance (needs RC Lookahead)",
+            widget_name="lookahead_level",
+            options=["default", "auto", "0", "1", "2", "3"],
+            opt="lookahead_level",
+        )
+
+    def init_split_encode_mode(self):
+        return self._add_combo_box(
+            label="Split Encode",
+            tooltip="Split frame encoding across multiple NVENC engines (high-end GPUs with more than one NVENC)",
+            widget_name="split_encode_mode",
+            options=SPLIT_OPTIONS,
+            opt="split_encode_mode",
+        )
+
+    def init_weighted_pred(self):
+        return self._add_combo_box(
+            label="Weighted Prediction",
+            tooltip="Enable weighted prediction (not compatible with B-frames)",
+            widget_name="weighted_pred",
+            options=["off", "on"],
+            opt="weighted_pred",
+        )
+
+    def init_no_scenecut(self):
+        return self._add_check_box(
+            opt="no_scenecut",
+            label="No Scenecut",
+            tooltip="When lookahead is enabled, disable adaptive I-frame insertion at scene cuts",
+            widget_name="no_scenecut",
+        )
+
+    def init_unidir_b(self):
+        return self._add_check_box(
+            opt="unidir_b",
+            label="Unidirectional B",
+            tooltip="Use unidirectional B-frames",
+            widget_name="unidir_b",
+        )
+
     def init_rc_lookahead(self):
         return self._add_text_box(
             label="RC Lookahead",
@@ -286,6 +375,16 @@ def update_video_encoder_settings(self):
             b_ref_mode=self.widgets.b_ref_mode.currentText(),
             tier=self.widgets.tier.currentText(),
             hw_accel=self.widgets.hw_accel.isChecked(),
+            multipass=self.widgets.multipass.currentText(),
+            temporal_aq=self.widgets.temporal_aq.currentIndex(),
+            aq_strength=int(self.widgets.aq_strength.text() or 8),
+            cq=int(self.widgets.cq.text() or 0),
+            tf_level=self.widgets.tf_level.currentText(),
+            lookahead_level=self.widgets.lookahead_level.currentText(),
+            split_encode_mode=self.widgets.split_encode_mode.currentText(),
+            weighted_pred=self.widgets.weighted_pred.currentIndex(),
+            no_scenecut=self.widgets.no_scenecut.isChecked(),
+            unidir_b=self.widgets.unidir_b.isChecked(),
         )
         encode_type, q_value = self.get_mode_settings()
         settings.qp = q_value if encode_type == "qp" else None
diff --git a/fastflix/encoders/gif/command_builder.py b/fastflix/encoders/gif/command_builder.py
index 7c46a8e6..0308f267 100644
--- a/fastflix/encoders/gif/command_builder.py
+++ b/fastflix/encoders/gif/command_builder.py
@@ -18,11 +18,15 @@ def build(fastflix: FastFlix):
     # Convert crop to dict if it exists (generate_filters expects dict, not Pydantic model)
     crop = video_settings.crop.model_dump() if video_settings.crop else None
 
-    args = f"=stats_mode={settings.stats_mode}"
+    palettegen_args = f"=stats_mode={settings.stats_mode}"
     if settings.max_colors != "256":
-        args += f":max_colors={settings.max_colors}"
+        palettegen_args += f":max_colors={settings.max_colors}"
+
+    # Dropping frames first avoids scaling/tone mapping frames that never reach the GIF; with a speed change the
+    # frame rate has to be set after setpts, so it stays at the end of the chain then.
+    fps_first = video_settings.video_speed == 1
+    fps_filter = f"fps={settings.fps}"
 
-    # Build base filters for fps and scale (applied before palette operations)
     # Scale must use lanczos for better GIF quality
     base_filters = generate_filters(
         selected_track=video_settings.selected_track,
@@ -34,35 +38,24 @@ def build(fastflix: FastFlix):
         vertical_flip=video_settings.vertical_flip,
         horizontal_flip=video_settings.horizontal_flip,
         video_speed=video_settings.video_speed,
+        reverse_video=video_settings.reverse_video,
         deblock=video_settings.deblock,
         deblock_size=video_settings.deblock_size,
         brightness=video_settings.brightness,
         saturation=video_settings.saturation,
         contrast=video_settings.contrast,
-        custom_filters=f"fps={settings.fps}",
+        gamma=video_settings.gamma,
+        hue=video_settings.hue,
+        sharpen=video_settings.sharpen,
+        denoise=video_settings.denoise,
+        deinterlace=video_settings.deinterlace,
+        remove_hdr=video_settings.remove_hdr,
+        tone_map=video_settings.tone_map,
+        start_filters=fps_filter if fps_first else None,
+        custom_filters=None if fps_first else fps_filter,
         raw_filters=True,
     )
 
-    # Palette generation filters include the base filters + palettegen
-    # This returns List[str] since raw_filters=False (default)
-    palettegen_filters = generate_filters(
-        selected_track=video_settings.selected_track,
-        source=fastflix.current_video.source,
-        crop=crop,
-        scale=scale,
-        scale_filter="lanczos",
-        rotate=video_settings.rotate,
-        vertical_flip=video_settings.vertical_flip,
-        horizontal_flip=video_settings.horizontal_flip,
-        video_speed=video_settings.video_speed,
-        deblock=video_settings.deblock,
-        deblock_size=video_settings.deblock_size,
-        brightness=video_settings.brightness,
-        saturation=video_settings.saturation,
-        contrast=video_settings.contrast,
-        custom_filters=f"fps={settings.fps},palettegen{args}",
-    )
-
     output_video = str(sanitize(fastflix.current_video.video_settings.output_path))
 
     beginning = [str(fastflix.config.ffmpeg)]
@@ -80,7 +73,10 @@ def build(fastflix: FastFlix):
     extra_both = shlex.split(settings.extra) if settings.extra and settings.extra_both_passes else []
     extra = shlex.split(settings.extra) if settings.extra else []
 
-    command_1 = beginning + palettegen_filters + extra_both + ["-y", str(temp_palette)]
+    palettegen_graph = f"{base_filters};[v]palettegen{palettegen_args}[palette]"
+    command_1 = (
+        beginning + ["-filter_complex", palettegen_graph, "-map", "[palette]"] + extra_both + ["-y", str(temp_palette)]
+    )
 
     # For GIF creation, apply same base filters then use palette
     # Format: [base_filters];[v][1:v]paletteuse=dither={dither}[o]
diff --git a/fastflix/encoders/gifski/command_builder.py b/fastflix/encoders/gifski/command_builder.py
index e1371e6b..eb9aae7d 100644
--- a/fastflix/encoders/gifski/command_builder.py
+++ b/fastflix/encoders/gifski/command_builder.py
@@ -26,11 +26,17 @@ def build(fastflix: FastFlix):
         vertical_flip=video_settings.vertical_flip,
         horizontal_flip=video_settings.horizontal_flip,
         video_speed=video_settings.video_speed,
+        reverse_video=video_settings.reverse_video,
         deblock=video_settings.deblock,
         deblock_size=video_settings.deblock_size,
         brightness=video_settings.brightness,
         saturation=video_settings.saturation,
         contrast=video_settings.contrast,
+        gamma=video_settings.gamma,
+        hue=video_settings.hue,
+        sharpen=video_settings.sharpen,
+        denoise=video_settings.denoise,
+        deinterlace=video_settings.deinterlace,
         remove_hdr=video_settings.remove_hdr,
         tone_map=video_settings.tone_map,
         custom_filters=f"fps={settings.fps},format=yuv420p",
diff --git a/fastflix/encoders/h264_videotoolbox/command_builder.py b/fastflix/encoders/h264_videotoolbox/command_builder.py
index 9e8ebad3..2191987a 100644
--- a/fastflix/encoders/h264_videotoolbox/command_builder.py
+++ b/fastflix/encoders/h264_videotoolbox/command_builder.py
@@ -1,66 +1,51 @@
 # -*- coding: utf-8 -*-
-import secrets
 import shlex
 
-from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details, null
-from fastflix.models.encode import HEVCVideoToolboxSettings
+from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details
+from fastflix.models.encode import H264VideoToolboxSettings
 from fastflix.models.fastflix import FastFlix
 
 
 def build(fastflix: FastFlix):
-    settings: HEVCVideoToolboxSettings = fastflix.current_video.video_settings.video_encoder_settings
+    settings: H264VideoToolboxSettings = fastflix.current_video.video_settings.video_encoder_settings
     beginning, ending, output_fps = generate_all(fastflix, "h264_videotoolbox")
 
     beginning.extend(generate_color_details(fastflix))
 
+    h264_profiles = {1: "baseline", 2: "main", 3: "high", 4: "extended"}
+
     def clean_bool(item):
         return "true" if item else "false"
 
-    details = [
-        "-profile:v",
-        str(settings.profile),
-        "-allow_sw",
-        clean_bool(settings.allow_sw),
-        "-require_sw",
-        clean_bool(settings.require_sw),
-        "-realtime",
-        clean_bool(settings.realtime),
-        "-frames_before",
-        clean_bool(settings.frames_before),
-        "-frames_after",
-        clean_bool(settings.frames_after),
-    ]
+    details = []
+    profile_name = h264_profiles.get(settings.profile)
+    if profile_name:
+        details.extend(["-profile:v", profile_name])
+    details.extend(
+        [
+            "-allow_sw",
+            clean_bool(settings.allow_sw),
+            "-require_sw",
+            clean_bool(settings.require_sw),
+            "-realtime",
+            clean_bool(settings.realtime),
+            "-frames_before",
+            clean_bool(settings.frames_before),
+            "-frames_after",
+            clean_bool(settings.frames_after),
+        ]
+    )
 
     extra = shlex.split(settings.extra) if settings.extra else []
-    extra_both = shlex.split(settings.extra) if settings.extra and settings.extra_both_passes else []
 
     if settings.bitrate:
-        pass_log_file = fastflix.current_video.work_path / f"pass_log_file_{secrets.token_hex(10)}"
-
-        command_1 = (
-            beginning
-            + ["-b:v", settings.bitrate]
-            + details
-            + ["-pass", "1", "-passlogfile", str(pass_log_file)]
-            + extra_both
-            + ["-an"]
-            + output_fps
-            + ["-f", "mp4", null]
-        )
-        command_2 = (
-            beginning
-            + ["-b:v", settings.bitrate]
-            + details
-            + ["-pass", "2", "-passlogfile", str(pass_log_file)]
-            + extra
-            + ending
-        )
-        return [
-            Command(command=command_1, name="First pass bitrate", exe="ffmpeg"),
-            Command(command=command_2, name="Second pass bitrate", exe="ffmpeg"),
-        ]
-    command_1 = beginning + ["-q:v", str(settings.q)] + details + extra + ending
+        bitrate_args = ["-b:v", settings.bitrate]
+        if settings.constant_bit_rate:
+            bitrate_args.extend(["-constant_bit_rate", "true"])
+        command = beginning + bitrate_args + details + extra + ending
+        return [Command(command=command, name="Single pass bitrate", exe="ffmpeg")]
+    command = beginning + ["-q:v", str(settings.q)] + details + extra + ending
 
     return [
-        Command(command=command_1, name="Single pass constant quality", exe="ffmpeg"),
+        Command(command=command, name="Single pass constant quality", exe="ffmpeg"),
     ]
diff --git a/fastflix/encoders/h264_videotoolbox/settings_panel.py b/fastflix/encoders/h264_videotoolbox/settings_panel.py
index ad5a4a96..d626e491 100644
--- a/fastflix/encoders/h264_videotoolbox/settings_panel.py
+++ b/fastflix/encoders/h264_videotoolbox/settings_panel.py
@@ -61,6 +61,7 @@ def __init__(self, parent, main, app: FastFlixApp):
         grid.addLayout(self.init_realtime(), 4, 0, 1, 2)
         grid.addLayout(self.init_frames_before(), 5, 0, 1, 2)
         grid.addLayout(self.init_frames_after(), 6, 0, 1, 2)
+        grid.addLayout(self.init_constant_bit_rate(), 5, 2, 1, 2)
         grid.addLayout(self.init_max_mux(), 7, 0, 1, 2)
 
         grid.addLayout(self.init_modes(), 0, 2, 5, 4)
@@ -147,6 +148,14 @@ def init_frames_after(self):
             opt="frames_after",
         )
 
+    def init_constant_bit_rate(self):
+        return self._add_check_box(
+            label="Constant Bit Rate",
+            tooltip="Require constant bit rate in bitrate mode (macOS 13 or newer)",
+            widget_name="constant_bit_rate",
+            opt="constant_bit_rate",
+        )
+
     def init_modes(self):
         return self._add_modes(
             recommended_bitrates, [str(x) for x in range(1, 101)], qp_name="q", disable_custom_qp=True
@@ -169,6 +178,7 @@ def update_video_encoder_settings(self):
             realtime=self.widgets.realtime.isChecked(),
             frames_before=self.widgets.frames_before.isChecked(),
             frames_after=self.widgets.frames_after.isChecked(),
+            constant_bit_rate=self.widgets.constant_bit_rate.isChecked(),
         )
         encode_type, q_value = self.get_mode_settings()
         settings.q = q_value if encode_type == "qp" else None
diff --git a/fastflix/encoders/hevc_videotoolbox/command_builder.py b/fastflix/encoders/hevc_videotoolbox/command_builder.py
index 6746fb63..742f15f9 100644
--- a/fastflix/encoders/hevc_videotoolbox/command_builder.py
+++ b/fastflix/encoders/hevc_videotoolbox/command_builder.py
@@ -1,8 +1,7 @@
 # -*- coding: utf-8 -*-
-import secrets
 import shlex
 
-from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details, null
+from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details, hevc_tag_args
 from fastflix.models.encode import HEVCVideoToolboxSettings
 from fastflix.models.fastflix import FastFlix
 
@@ -12,55 +11,45 @@ def build(fastflix: FastFlix):
     beginning, ending, output_fps = generate_all(fastflix, "hevc_videotoolbox")
 
     beginning.extend(generate_color_details(fastflix))
+    beginning.extend(hevc_tag_args(fastflix.current_video.video_settings.output_path))
+
+    hevc_profiles = {1: "main", 2: "main10"}
+    ten_bit_pix_fmts = ("p010le", "yuv420p10le")
 
     def clean_bool(item):
         return "true" if item else "false"
 
-    details = [
-        "-profile:v",
-        str(settings.profile),
-        "-allow_sw",
-        clean_bool(settings.allow_sw),
-        "-require_sw",
-        clean_bool(settings.require_sw),
-        "-realtime",
-        clean_bool(settings.realtime),
-        "-frames_before",
-        clean_bool(settings.frames_before),
-        "-frames_after",
-        clean_bool(settings.frames_after),
-    ]
+    details = []
+    profile_name = hevc_profiles.get(settings.profile)
+    if profile_name:
+        profile_name = "main10" if settings.pix_fmt in ten_bit_pix_fmts else "main"
+    if profile_name:
+        details.extend(["-profile:v", profile_name])
+    details.extend(
+        [
+            "-allow_sw",
+            clean_bool(settings.allow_sw),
+            "-require_sw",
+            clean_bool(settings.require_sw),
+            "-realtime",
+            clean_bool(settings.realtime),
+            "-frames_before",
+            clean_bool(settings.frames_before),
+            "-frames_after",
+            clean_bool(settings.frames_after),
+        ]
+    )
 
     extra = shlex.split(settings.extra) if settings.extra else []
-    extra_both = shlex.split(settings.extra) if settings.extra and settings.extra_both_passes else []
 
     if settings.bitrate:
-        pass_log_file = fastflix.current_video.work_path / f"pass_log_file_{secrets.token_hex(10)}"
-
-        command_1 = (
-            beginning
-            + ["-b:v", settings.bitrate]
-            + details
-            + ["-pass", "1", "-passlogfile", str(pass_log_file)]
-            + extra_both
-            + ["-an"]
-            + output_fps
-            + ["-f", "mp4", null]
-        )
-        command_2 = (
-            beginning
-            + ["-b:v", settings.bitrate]
-            + details
-            + ["-pass", "2", "-passlogfile", str(pass_log_file)]
-            + extra
-            + ending
-        )
-        return [
-            Command(command=command_1, name="First pass bitrate", exe="ffmpeg"),
-            Command(command=command_2, name="Second pass bitrate", exe="ffmpeg"),
-        ]
-    command_1 = beginning + ["-q:v", str(settings.q)] + details + extra + ending
+        bitrate_args = ["-b:v", settings.bitrate]
+        if settings.constant_bit_rate:
+            bitrate_args.extend(["-constant_bit_rate", "true"])
+        command = beginning + bitrate_args + details + extra + ending
+        return [Command(command=command, name="Single pass bitrate", exe="ffmpeg")]
+    command = beginning + ["-q:v", str(settings.q)] + details + extra + ending
 
     return [
-        Command(command=command_1, name="Single pass constant quality", exe="ffmpeg"),
+        Command(command=command, name="Single pass constant quality", exe="ffmpeg"),
     ]
diff --git a/fastflix/encoders/hevc_videotoolbox/settings_panel.py b/fastflix/encoders/hevc_videotoolbox/settings_panel.py
index 67e4674d..7a2b8564 100644
--- a/fastflix/encoders/hevc_videotoolbox/settings_panel.py
+++ b/fastflix/encoders/hevc_videotoolbox/settings_panel.py
@@ -63,6 +63,7 @@ def __init__(self, parent, main, app: FastFlixApp):
         grid.addLayout(self.init_realtime(), 4, 0, 1, 2)
         grid.addLayout(self.init_frames_before(), 5, 0, 1, 2)
         grid.addLayout(self.init_frames_after(), 6, 0, 1, 2)
+        grid.addLayout(self.init_constant_bit_rate(), 5, 2, 1, 2)
         grid.addLayout(self.init_max_mux(), 7, 0, 1, 2)
 
         grid.addLayout(self.init_modes(), 0, 2, 5, 4)
@@ -147,6 +148,14 @@ def init_frames_after(self):
             opt="frames_after",
         )
 
+    def init_constant_bit_rate(self):
+        return self._add_check_box(
+            label="Constant Bit Rate",
+            tooltip="Require constant bit rate in bitrate mode (macOS 13 or newer)",
+            widget_name="constant_bit_rate",
+            opt="constant_bit_rate",
+        )
+
     def init_modes(self):
         return self._add_modes(
             recommended_bitrates, [str(x) for x in range(1, 101)], qp_name="q", disable_custom_qp=True
@@ -169,6 +178,7 @@ def update_video_encoder_settings(self):
             realtime=self.widgets.realtime.isChecked(),
             frames_before=self.widgets.frames_before.isChecked(),
             frames_after=self.widgets.frames_after.isChecked(),
+            constant_bit_rate=self.widgets.constant_bit_rate.isChecked(),
         )
         encode_type, q_value = self.get_mode_settings()
         settings.q = q_value if encode_type == "qp" else None
diff --git a/fastflix/encoders/hevc_x265/command_builder.py b/fastflix/encoders/hevc_x265/command_builder.py
index 8f2e916f..c8e1056f 100644
--- a/fastflix/encoders/hevc_x265/command_builder.py
+++ b/fastflix/encoders/hevc_x265/command_builder.py
@@ -2,85 +2,32 @@
 import secrets
 import shlex
 
-from fastflix.encoders.common.helpers import Command, generate_all, null
+from fastflix.encoders.common.hdr_metadata import (
+    chromaloc_mapping,
+    color_matrix_mapping,
+    color_primaries_mapping,
+    color_transfer_mapping,
+    is_hdr_bit_depth,
+    parse_master_display,
+    valid_color_matrix,
+    valid_color_primaries,
+    valid_color_transfers,
+)
+from fastflix.encoders.common.helpers import Command, generate_all, hevc_tag_args, null
 from fastflix.models.encode import x265Settings
 from fastflix.models.fastflix import FastFlix
 
-x265_valid_color_primaries = [
-    "bt709",
-    "unknown",
-    "reserved",
-    "bt470m",
-    "bt470bg",
-    "smpte170m",
-    "smpte240m",
-    "film",
-    "bt2020",
-    "smpte428",
-    "smpte431",
-    "smpte432",
-]
-
-x265_valid_color_transfers = [
-    "bt709",
-    "unknown",
-    "reserved",
-    "bt470m",
-    "bt470bg",
-    "smpte170m",
-    "smpte240m",
-    "linear",
-    "log100",
-    "log316",
-    "iec61966-2-4",
-    "bt1361e",
-    "iec61966-2-1",
-    "bt2020-10",
-    "bt2020-12",
-    "smpte2084",
-    "smpte428",
-    "arib-std-b67",
-]
-
-x265_valid_color_matrix = [
-    "gbr",
-    "bt709",
-    "unknown",
-    "reserved",
-    "fcc",
-    "bt470bg",
-    "smpte170m",
-    "smpte240m",
-    "ycgco",
-    "bt2020nc",
-    "bt2020c",
-    "smpte2085",
-    "chroma-derived-nc",
-    "chroma-derived-c",
-    "ictcp",
-]
-
-color_primaries_mapping = {"smpte428_1": "smpte428"}
-
-color_transfer_mapping = {
-    "iec61966_2_4": "iec61966-2-4",
-    "iec61966_2_1": "iec61966-2-1",
-    "bt2020_10": "bt2020-10",
-    "bt2020_10bit": "bt2020-10",
-    "bt2020_12": "bt2020-12",
-    "bt2020_12bit": "bt2020-12",
-    "smpte428_1": "smpte428",
-}
-
-color_matrix_mapping = {"bt2020_ncl": "bt2020nc", "bt2020_cl": "bt2020c"}
-
-chromaloc_mapping = {"left": 0, "center": 1, "topleft": 2, "top": 3, "bottomleft": 4, "bottom": 5}
+
+def quote_x265_value(value: str) -> str:
+    """Single-quote a value for -x265-params (ffmpeg splits on ':' and honours quotes, so 'C:/x' is kept whole)."""
+    return "'" + str(value).replace("'", "'\\''") + "'"
 
 
 def build(fastflix: FastFlix):
     settings: x265Settings = fastflix.current_video.video_settings.video_encoder_settings
 
     beginning, ending, output_fps = generate_all(fastflix, "libx265")
+    beginning.extend(hevc_tag_args(fastflix.current_video.video_settings.output_path))
 
     if settings.tune and settings.tune != "default":
         beginning.extend(["-tune:v", settings.tune])
@@ -101,7 +48,7 @@ def build(fastflix: FastFlix):
         if fastflix.current_video.video_settings.color_primaries:
             x265_params.append(f"colorprim={fastflix.current_video.video_settings.color_primaries}")
         elif fastflix.current_video.color_primaries:
-            if fastflix.current_video.color_primaries in x265_valid_color_primaries:
+            if fastflix.current_video.color_primaries in valid_color_primaries:
                 x265_params.append(f"colorprim={fastflix.current_video.color_primaries}")
             elif fastflix.current_video.color_primaries in color_primaries_mapping:
                 x265_params.append(f"colorprim={color_primaries_mapping[fastflix.current_video.color_primaries]}")
@@ -109,7 +56,7 @@ def build(fastflix: FastFlix):
         if fastflix.current_video.video_settings.color_transfer:
             x265_params.append(f"transfer={fastflix.current_video.video_settings.color_transfer}")
         elif fastflix.current_video.color_transfer:
-            if fastflix.current_video.color_transfer in x265_valid_color_transfers:
+            if fastflix.current_video.color_transfer in valid_color_transfers:
                 x265_params.append(f"transfer={fastflix.current_video.color_transfer}")
             elif fastflix.current_video.color_transfer in color_transfer_mapping:
                 x265_params.append(f"transfer={color_transfer_mapping[fastflix.current_video.color_transfer]}")
@@ -117,30 +64,25 @@ def build(fastflix: FastFlix):
         if fastflix.current_video.video_settings.color_space:
             x265_params.append(f"colormatrix={fastflix.current_video.video_settings.color_space}")
         elif fastflix.current_video.color_space:
-            if fastflix.current_video.color_space in x265_valid_color_matrix:
+            if fastflix.current_video.color_space in valid_color_matrix:
                 x265_params.append(f"colormatrix={fastflix.current_video.color_space}")
             elif fastflix.current_video.color_space in color_matrix_mapping:
                 x265_params.append(f"colormatrix={color_matrix_mapping[fastflix.current_video.color_space]}")
 
-        if settings.pix_fmt in ("yuv420p10le", "yuv420p12le"):
+        if is_hdr_bit_depth(settings.pix_fmt):
+            hdr10 = settings.hdr10
             x265_params.append(f"hdr10_opt={'1' if settings.hdr10_opt else '0'}")
 
-            if fastflix.current_video.master_display:
-                settings.hdr10 = True
-                x265_params.append(
-                    "master-display="
-                    f"G{fastflix.current_video.master_display.green}"
-                    f"B{fastflix.current_video.master_display.blue}"
-                    f"R{fastflix.current_video.master_display.red}"
-                    f"WP{fastflix.current_video.master_display.white}"
-                    f"L{fastflix.current_video.master_display.luminance}"
-                )
+            master_display = parse_master_display(fastflix.current_video.master_display)
+            if master_display:
+                hdr10 = True
+                x265_params.append(f"master-display={master_display.to_x265()}")
 
             if fastflix.current_video.cll:
-                settings.hdr10 = True
+                hdr10 = True
                 x265_params.append(f"max-cll={fastflix.current_video.cll}")
 
-            x265_params.append(f"hdr10={'1' if settings.hdr10 else '0'}")
+            x265_params.append(f"hdr10={'1' if hdr10 else '0'}")
 
         current_chroma_loc = fastflix.current_video.current_video_stream.get("chroma_location")
         if current_chroma_loc in chromaloc_mapping:
@@ -164,10 +106,9 @@ def build(fastflix: FastFlix):
         x265_params.append(f"vbv-maxrate={fastflix.current_video.video_settings.maxrate}")
         x265_params.append(f"vbv-bufsize={fastflix.current_video.video_settings.bufsize}")
 
-    if fastflix.current_video.cll:
-        pass
-
-    pass_log_file = f"pass_log_file_{secrets.token_hex(10)}.log"
+    pass_log_file = quote_x265_value(
+        (fastflix.current_video.work_path / f"pass_log_file_{secrets.token_hex(10)}.log").as_posix()
+    )
 
     def get_x265_params(params=()):
         if not isinstance(params, (list, tuple)):
@@ -178,6 +119,11 @@ def get_x265_params(params=()):
     extra = shlex.split(settings.extra) if settings.extra else []
     extra_both = shlex.split(settings.extra) if settings.extra and settings.extra_both_passes else []
 
+    if settings.lossless:
+        # Lossless mode — no rate control needed, x265 handles it via lossless=1 param
+        command = beginning + get_x265_params() + ["-preset:v", settings.preset] + extra + ending
+        return [Command(command=command, name="Single pass lossless", exe="ffmpeg")]
+
     if settings.bitrate:
         if settings.bitrate_passes == 2:
             command_1 = (
diff --git a/fastflix/encoders/hevc_x265/settings_panel.py b/fastflix/encoders/hevc_x265/settings_panel.py
index cfbc682f..e7637e0a 100644
--- a/fastflix/encoders/hevc_x265/settings_panel.py
+++ b/fastflix/encoders/hevc_x265/settings_panel.py
@@ -383,7 +383,7 @@ def init_intra_refresh(self):
         )
 
     def init_lossless(self):
-        return self._add_check_box(
+        layout = self._add_check_box(
             label="Lossless",
             widget_name="lossless",
             tooltip=(
@@ -394,7 +394,19 @@ def init_lossless(self):
                 "Slower presets will generally achieve better compression efficiency (and generate smaller bitstreams)."
             ),
             opt="lossless",
+            connect=lambda: (self._toggle_lossless(), self.main.page_update(build_thumbnail=False)),
         )
+        return layout
+
+    def _toggle_lossless(self):
+        enabled = not self.widgets.lossless.isChecked()
+        self.qp_radio.setEnabled(enabled)
+        self.bitrate_radio.setEnabled(enabled)
+        self.widgets.crf.setEnabled(enabled)
+        self.widgets.custom_crf.setEnabled(enabled)
+        self.widgets.bitrate.setEnabled(enabled)
+        self.widgets.custom_bitrate.setEnabled(enabled)
+        self.widgets.bitrate_passes.setEnabled(enabled)
 
     def init_preset(self):
         layout = self._add_combo_box(
diff --git a/fastflix/encoders/nvencc_av1/command_builder.py b/fastflix/encoders/nvencc_av1/command_builder.py
index 53959cec..9d9b2a6c 100644
--- a/fastflix/encoders/nvencc_av1/command_builder.py
+++ b/fastflix/encoders/nvencc_av1/command_builder.py
@@ -13,6 +13,12 @@
     rigaya_auto_options,
     rigaya_avformat_reader,
     rigaya_trim_or_seek,
+    rigaya_extra_options,
+    nvenc_profile_args,
+    qvbr_quality_value,
+    nvenc_tune_args,
+    split_extra_args,
+    rigaya_hdr_static_metadata,
 )
 
 logger = logging.getLogger("fastflix")
@@ -62,7 +68,7 @@ def build(fastflix: FastFlix):
     command.extend(["--device", str(settings.device)])
     command.extend(["-i", str(video.source)])
 
-    if stream_id:
+    if stream_id is not None:
         command.extend(["--video-streamid", str(stream_id)])
     command.extend(rigaya_trim_or_seek(video))
     if video.video_settings.source_fps:
@@ -73,11 +79,11 @@ def build(fastflix: FastFlix):
         flip_x = "true" if video.video_settings.horizontal_flip else "false"
         flip_y = "true" if video.video_settings.vertical_flip else "false"
         command.extend(["--vpp-transform", f"flip_x={flip_x},flip_y={flip_y}"])
-    if video.scale:
-        command.extend(["--output-res", video.scale.replace(":", "x")])
     if video.video_settings.crop:
         crop = video.video_settings.crop
         command.extend(["--crop", f"{crop.left},{crop.top},{crop.right},{crop.bottom}"])
+    if video.output_width is not None and video.output_height is not None:
+        command.extend(["--output-res", f"{video.output_width}x{video.output_height}"])
 
     if video.video_settings.remove_metadata:
         command.extend(["--video-metadata", "clear", "--metadata", "clear"])
@@ -87,13 +93,16 @@ def build(fastflix: FastFlix):
         command.extend(["--video-metadata", "copy", "--metadata", "copy"])
 
     if video.video_settings.video_title:
-        command.extend(["--video-metadata", f"title={video.video_settings.video_title}"])
+        command.extend(["--metadata", f"title={video.video_settings.video_title}"])
     if video.video_settings.copy_chapters:
         command.append("--chapter-copy")
 
     command.extend(["-c", "av1"])
 
-    if settings.bitrate:
+    qvbr = qvbr_quality_value(settings)
+    if qvbr:
+        command.extend(["--qvbr", qvbr])
+    elif settings.bitrate:
         command.extend(["--vbr", settings.bitrate.rstrip("k")])
     else:
         command.extend(["--cqp", str(settings.cqp)])
@@ -102,13 +111,13 @@ def build(fastflix: FastFlix):
         command.extend(["--max-bitrate", str(video.video_settings.maxrate)])
         command.extend(["--vbv-bufsize", str(video.video_settings.bufsize)])
 
-    if settings.vbr_target is not None and settings.bitrate:
+    if settings.vbr_target is not None and settings.bitrate and not qvbr:
         command.extend(["--vbr-quality", str(settings.vbr_target)])
-    if init_q and settings.bitrate:
+    if init_q and (settings.bitrate or qvbr):
         command.extend(["--qp-init", str(init_q)])
-    if min_q and settings.bitrate:
+    if min_q and (settings.bitrate or qvbr):
         command.extend(["--qp-min", str(min_q)])
-    if max_q and settings.bitrate:
+    if max_q and (settings.bitrate or qvbr):
         command.extend(["--qp-max", str(max_q)])
     if settings.b_frames:
         command.extend(["--bframes", str(settings.b_frames)])
@@ -117,7 +126,8 @@ def build(fastflix: FastFlix):
 
     command.extend(["--bref-mode", settings.b_ref_mode])
     command.extend(["--preset", settings.preset])
-    command.extend(["--tier", settings.tier])
+    command.extend(nvenc_profile_args(settings.profile, "av1"))
+    command.extend(nvenc_tune_args(settings.tune, "av1"))
 
     if settings.lookahead:
         command.extend(["--lookahead", str(settings.lookahead)])
@@ -133,16 +143,7 @@ def build(fastflix: FastFlix):
 
     command.extend(rigaya_auto_options(fastflix))
 
-    if fastflix.current_video.master_display:
-        md = fastflix.current_video.master_display
-        command.extend(
-            [
-                "--master-display",
-                f"G{md.green}B{md.blue}R{md.red}WP{md.white}L{md.luminance}",
-            ]
-        )
-    if fastflix.current_video.cll:
-        command.extend(["--max-cll", str(fastflix.current_video.cll)])
+    command.extend(rigaya_hdr_static_metadata(fastflix))
     if settings.copy_hdr10 and not video.video_settings.remove_hdr:
         command.extend(["--dhdr10-info", "copy"])
     if settings.copy_dv and not video.video_settings.remove_hdr:
@@ -160,13 +161,16 @@ def build(fastflix: FastFlix):
         command.extend(["--interlace", str(video.interlaced)])
     if video.video_settings.deinterlace:
         command.append("--vpp-yadif")
+    hdr2sdr_param = None
     if video.video_settings.remove_hdr:
         remove_type = (
             video.video_settings.tone_map
             if video.video_settings.tone_map in ("mobius", "hable", "reinhard")
             else "mobius"
         )
-        command.extend(["--vpp-colorspace", f"hdr2sdr={remove_type}"])
+        hdr2sdr_param = f"hdr2sdr={remove_type}"
+
+    command.extend(rigaya_extra_options(video, hdr2sdr=hdr2sdr_param, fruc=True))
 
     if settings.split_mode == "split":
         command.extend(["--split-enc", "auto_forced"])
@@ -179,11 +183,16 @@ def build(fastflix: FastFlix):
     command.extend(build_audio(video.audio_tracks, video.streams.audio))
     command.extend(build_subtitle(video.subtitle_tracks, video.streams.subtitle, video_height=video.height))
     command.extend(
-        build_data(video.data_tracks, getattr(video.streams, "data", []), getattr(video.streams, "attachment", []))
+        build_data(
+            video.data_tracks,
+            getattr(video.streams, "data", []),
+            getattr(video.streams, "attachment", []),
+            video.video_settings.output_path,
+        )
     )
 
     if settings.extra:
-        command.extend(settings.extra.split())
+        command.extend(split_extra_args(settings.extra))
 
     command.extend(["-o", str(video.video_settings.output_path)])
 
diff --git a/fastflix/encoders/nvencc_av1/settings_panel.py b/fastflix/encoders/nvencc_av1/settings_panel.py
index 2123c389..93c8cc6d 100644
--- a/fastflix/encoders/nvencc_av1/settings_panel.py
+++ b/fastflix/encoders/nvencc_av1/settings_panel.py
@@ -77,8 +77,7 @@ def __init__(self, parent, main, app: FastFlixApp):
         custom_layout = self._add_custom(title="Custom NVEncC options", disable_both_passes=True)
 
         grid.addLayout(self.init_preset(), 0, 0, 1, 2)
-        # grid.addLayout(self.init_profile(), 1, 0, 1, 2)
-        grid.addLayout(self.init_tier(), 1, 0, 1, 2)
+        grid.addLayout(self.init_profile(), 1, 0, 1, 2)
         grid.addLayout(self.init_multipass(), 2, 0, 1, 2)
         grid.addLayout(self.init_lookahead(), 3, 0, 1, 2)
         # grid.addLayout(self.init_decoder(), 5, 0, 1, 2)
@@ -97,6 +96,7 @@ def __init__(self, parent, main, app: FastFlixApp):
         grid.addLayout(self.init_aq_strength(), 6, 0, 1, 2)
         grid.addLayout(self.init_mv_precision(), 7, 0, 1, 2)
         grid.addLayout(self.init_devices(), 8, 0, 1, 2)
+        grid.addLayout(self.init_tune(), 9, 0, 1, 2)
 
         qp_line = QtWidgets.QHBoxLayout()
         qp_line.addLayout(self.init_vbr_target())
@@ -107,6 +107,8 @@ def __init__(self, parent, main, app: FastFlixApp):
         qp_line.addStretch(1)
         qp_line.addLayout(self.init_max_q())
 
+        qp_line.addStretch(1)
+        qp_line.addLayout(self.init_qvbr_quality())
         grid.addLayout(qp_line, 5, 2, 1, 4)
 
         advanced = QtWidgets.QHBoxLayout()
@@ -134,7 +136,7 @@ def __init__(self, parent, main, app: FastFlixApp):
         grid.addLayout(hdr_line, 8, 2, 1, 2)
         grid.addLayout(self.init_parallel_mode(add_split=True), 8, 4, 1, 2)
 
-        grid.setRowStretch(9, 1)
+        grid.setRowStretch(11, 1)
 
         guide_label = QtWidgets.QLabel(
             link(
@@ -170,28 +172,24 @@ def init_tune(self):
         return self._add_combo_box(
             label="Tune",
             widget_name="tune",
-            tooltip="Tune the settings for a particular type of source or situation\nhq - High Quality, ll - Low Latency, ull - Ultra Low Latency",
-            options=["hq", "ll", "ull", "lossless"],
+            tooltip=(
+                "Tune the preset for a type of source or situation\n"
+                "hq - High Quality (default)\n"
+                "uhq - Ultra High Quality (HEVC and AV1, requires Turing or newer)\n"
+                "lowlatency / ultralowlatency - Streaming oriented\n"
+                "lossless - Lossless output (H.264 and HEVC)"
+            ),
+            options=["hq", "uhq", "lowlatency", "ultralowlatency"],
             opt="tune",
         )
 
-    # def init_profile(self):
-    #
-    #     return self._add_combo_box(
-    #         label="Profile_encoderopt",
-    #         widget_name="profile",
-    #         tooltip="Enforce an encode profile",
-    #         options=["main", "main10"],
-    #         opt="profile",
-    #     )
-
-    def init_tier(self):
+    def init_profile(self):
         return self._add_combo_box(
-            label="Tier",
-            tooltip="Set the encoding tier",
-            widget_name="tier",
-            options=["main", "high"],
-            opt="tier",
+            label="Profile_encoderopt",
+            widget_name="profile",
+            tooltip="Enforce an encode profile",
+            options=["auto", "main", "high"],
+            opt="profile",
         )
 
     def init_aq(self):
@@ -331,6 +329,16 @@ def init_vbr_target(self):
             min_width=60,
         )
 
+    def init_qvbr_quality(self):
+        return self._add_combo_box(
+            label="QVBR Quality",
+            widget_name="qvbr_quality",
+            tooltip="Quality based VBR (--qvbr), lower is higher quality. Replaces the Bitrate or QP selection above.\nOff uses the selected rate control mode",
+            options=["off"] + [str(x) for x in range(1, 64)],
+            opt="qvbr_quality",
+            min_width=60,
+        )
+
     def init_b_frames(self):
         return self._add_combo_box(
             widget_name="b_frames",
@@ -387,9 +395,9 @@ def setting_change(self, update=True):
     def update_video_encoder_settings(self):
         settings = NVEncCAV1Settings(
             preset=self.widgets.preset.currentText().split("-")[0].strip(),
-            # profile=self.widgets.profile.currentText(),
+            profile=self.widgets.profile.currentText(),
+            tune=self.widgets.tune.currentText(),
             force_ten_bit=self.widgets.force_ten_bit.isChecked(),
-            tier=self.widgets.tier.currentText(),
             lookahead=self.widgets.lookahead.currentIndex() if self.widgets.lookahead.currentIndex() > 0 else None,
             aq=self.widgets.aq.currentText(),
             aq_strength=self.widgets.aq_strength.currentIndex(),
@@ -407,6 +415,7 @@ def update_video_encoder_settings(self):
             min_q_p=self.widgets.min_q_p.currentText() if self.widgets.min_q_p.currentIndex() != 0 else None,
             min_q_b=self.widgets.min_q_b.currentText() if self.widgets.min_q_b.currentIndex() != 0 else None,
             extra=self.ffmpeg_extras,
+            qvbr_quality=self.widgets.qvbr_quality.currentText(),
             metrics=self.widgets.metrics.isChecked(),
             level=self.widgets.level.currentText() if self.widgets.level.currentIndex() != 0 else None,
             b_frames=self.widgets.b_frames.currentText() if self.widgets.b_frames.currentIndex() != 0 else None,
diff --git a/fastflix/encoders/nvencc_avc/command_builder.py b/fastflix/encoders/nvencc_avc/command_builder.py
index 39ab7286..accb18e5 100644
--- a/fastflix/encoders/nvencc_avc/command_builder.py
+++ b/fastflix/encoders/nvencc_avc/command_builder.py
@@ -13,6 +13,11 @@
     rigaya_auto_options,
     rigaya_avformat_reader,
     rigaya_trim_or_seek,
+    rigaya_extra_options,
+    nvenc_profile_args,
+    qvbr_quality_value,
+    nvenc_tune_args,
+    split_extra_args,
 )
 
 logger = logging.getLogger("fastflix")
@@ -56,7 +61,7 @@ def build(fastflix: FastFlix):
     command.extend(["--device", str(settings.device)])
     command.extend(["-i", str(video.source)])
 
-    if stream_id:
+    if stream_id is not None:
         command.extend(["--video-streamid", str(stream_id)])
     command.extend(rigaya_trim_or_seek(video))
     if video.video_settings.source_fps:
@@ -67,11 +72,11 @@ def build(fastflix: FastFlix):
         flip_x = "true" if video.video_settings.horizontal_flip else "false"
         flip_y = "true" if video.video_settings.vertical_flip else "false"
         command.extend(["--vpp-transform", f"flip_x={flip_x},flip_y={flip_y}"])
-    if video.scale:
-        command.extend(["--output-res", video.scale.replace(":", "x")])
     if video.video_settings.crop:
         crop = video.video_settings.crop
         command.extend(["--crop", f"{crop.left},{crop.top},{crop.right},{crop.bottom}"])
+    if video.output_width is not None and video.output_height is not None:
+        command.extend(["--output-res", f"{video.output_width}x{video.output_height}"])
 
     if video.video_settings.remove_metadata:
         command.extend(["--video-metadata", "clear", "--metadata", "clear"])
@@ -79,13 +84,16 @@ def build(fastflix: FastFlix):
         command.extend(["--video-metadata", "copy", "--metadata", "copy"])
 
     if video.video_settings.video_title:
-        command.extend(["--video-metadata", f"title={video.video_settings.video_title}"])
+        command.extend(["--metadata", f"title={video.video_settings.video_title}"])
     if video.video_settings.copy_chapters:
         command.append("--chapter-copy")
 
     command.extend(["-c", "avc"])
 
-    if settings.bitrate:
+    qvbr = qvbr_quality_value(settings)
+    if qvbr:
+        command.extend(["--qvbr", qvbr])
+    elif settings.bitrate:
         command.extend(["--vbr", settings.bitrate.rstrip("k")])
     else:
         command.extend(["--cqp", str(settings.cqp)])
@@ -94,13 +102,13 @@ def build(fastflix: FastFlix):
         command.extend(["--max-bitrate", str(video.video_settings.maxrate)])
         command.extend(["--vbv-bufsize", str(video.video_settings.bufsize)])
 
-    if settings.vbr_target is not None and settings.bitrate:
+    if settings.vbr_target is not None and settings.bitrate and not qvbr:
         command.extend(["--vbr-quality", str(settings.vbr_target)])
-    if init_q and settings.bitrate:
+    if init_q and (settings.bitrate or qvbr):
         command.extend(["--qp-init", str(init_q)])
-    if min_q and settings.bitrate:
+    if min_q and (settings.bitrate or qvbr):
         command.extend(["--qp-min", str(min_q)])
-    if max_q and settings.bitrate:
+    if max_q and (settings.bitrate or qvbr):
         command.extend(["--qp-max", str(max_q)])
     if settings.b_frames:
         command.extend(["--bframes", str(settings.b_frames)])
@@ -109,6 +117,8 @@ def build(fastflix: FastFlix):
 
     command.extend(["--bref-mode", settings.b_ref_mode])
     command.extend(["--preset", settings.preset])
+    command.extend(nvenc_profile_args(settings.profile, "avc"))
+    command.extend(nvenc_tune_args(settings.tune, "avc"))
 
     if settings.lookahead:
         command.extend(["--lookahead", str(settings.lookahead)])
@@ -132,13 +142,16 @@ def build(fastflix: FastFlix):
         command.extend(["--interlace", str(video.interlaced)])
     if video.video_settings.deinterlace:
         command.append("--vpp-yadif")
+    hdr2sdr_param = None
     if video.video_settings.remove_hdr:
         remove_type = (
             video.video_settings.tone_map
             if video.video_settings.tone_map in ("mobius", "hable", "reinhard")
             else "mobius"
         )
-        command.extend(["--vpp-colorspace", f"hdr2sdr={remove_type}"])
+        hdr2sdr_param = f"hdr2sdr={remove_type}"
+
+    command.extend(rigaya_extra_options(video, hdr2sdr=hdr2sdr_param, fruc=True))
 
     if settings.split_mode == "parallel":
         command.extend(["--parallel", "auto"])
@@ -149,11 +162,16 @@ def build(fastflix: FastFlix):
     command.extend(build_audio(video.audio_tracks, video.streams.audio))
     command.extend(build_subtitle(video.subtitle_tracks, video.streams.subtitle, video_height=video.height))
     command.extend(
-        build_data(video.data_tracks, getattr(video.streams, "data", []), getattr(video.streams, "attachment", []))
+        build_data(
+            video.data_tracks,
+            getattr(video.streams, "data", []),
+            getattr(video.streams, "attachment", []),
+            video.video_settings.output_path,
+        )
     )
 
     if settings.extra:
-        command.extend(settings.extra.split())
+        command.extend(split_extra_args(settings.extra))
 
     command.extend(["-o", str(video.video_settings.output_path)])
 
diff --git a/fastflix/encoders/nvencc_avc/settings_panel.py b/fastflix/encoders/nvencc_avc/settings_panel.py
index 88910a6a..6fc80ca7 100644
--- a/fastflix/encoders/nvencc_avc/settings_panel.py
+++ b/fastflix/encoders/nvencc_avc/settings_panel.py
@@ -77,7 +77,7 @@ def __init__(self, parent, main, app: FastFlixApp):
         custom_layout = self._add_custom(title="Custom NVEncC options", disable_both_passes=True)
 
         grid.addLayout(self.init_preset(), 0, 0, 1, 2)
-        # grid.addLayout(self.init_profile(), 1, 0, 1, 2)
+        grid.addLayout(self.init_profile(), 1, 0, 1, 2)
         # grid.addLayout(self.init_tier(), 1, 0, 1, 2)
         grid.addLayout(self.init_multipass(), 2, 0, 1, 2)
         grid.addLayout(self.init_lookahead(), 3, 0, 1, 2)
@@ -97,6 +97,7 @@ def __init__(self, parent, main, app: FastFlixApp):
         grid.addLayout(self.init_aq_strength(), 6, 0, 1, 2)
         grid.addLayout(self.init_mv_precision(), 7, 0, 1, 2)
         grid.addLayout(self.init_devices(), 8, 0, 1, 2)
+        grid.addLayout(self.init_tune(), 9, 0, 1, 2)
 
         qp_line = QtWidgets.QHBoxLayout()
         qp_line.addLayout(self.init_vbr_target())
@@ -107,6 +108,8 @@ def __init__(self, parent, main, app: FastFlixApp):
         qp_line.addStretch(1)
         qp_line.addLayout(self.init_max_q())
 
+        qp_line.addStretch(1)
+        qp_line.addLayout(self.init_qvbr_quality())
         grid.addLayout(qp_line, 5, 2, 1, 4)
 
         advanced = QtWidgets.QHBoxLayout()
@@ -126,7 +129,7 @@ def __init__(self, parent, main, app: FastFlixApp):
         grid.addLayout(even_more, 7, 2, 1, 4)
         grid.addLayout(self.init_parallel_mode(), 8, 4, 1, 2)
 
-        grid.setRowStretch(9, 1)
+        grid.setRowStretch(11, 1)
 
         guide_label = QtWidgets.QLabel(
             link(
@@ -162,20 +165,25 @@ def init_tune(self):
         return self._add_combo_box(
             label="Tune",
             widget_name="tune",
-            tooltip="Tune the settings for a particular type of source or situation\nhq - High Quality, ll - Low Latency, ull - Ultra Low Latency",
-            options=["hq", "ll", "ull", "lossless"],
+            tooltip=(
+                "Tune the preset for a type of source or situation\n"
+                "hq - High Quality (default)\n"
+                "uhq - Ultra High Quality (HEVC and AV1, requires Turing or newer)\n"
+                "lowlatency / ultralowlatency - Streaming oriented\n"
+                "lossless - Lossless output (H.264 and HEVC)"
+            ),
+            options=["hq", "lowlatency", "ultralowlatency", "lossless"],
             opt="tune",
         )
 
-    # def init_profile(self):
-    #     # TODO auto
-    #     return self._add_combo_box(
-    #         label="Profile_encoderopt",
-    #         widget_name="profile",
-    #         tooltip="Enforce an encode profile",
-    #         options=["main", "main10"],
-    #         opt="profile",
-    #     )
+    def init_profile(self):
+        return self._add_combo_box(
+            label="Profile_encoderopt",
+            widget_name="profile",
+            tooltip="Enforce an encode profile",
+            options=["auto", "baseline", "main", "high", "high10", "high422", "high444"],
+            opt="profile",
+        )
 
     # def init_tier(self):
     #     return self._add_combo_box(
@@ -323,6 +331,16 @@ def init_vbr_target(self):
             min_width=60,
         )
 
+    def init_qvbr_quality(self):
+        return self._add_combo_box(
+            label="QVBR Quality",
+            widget_name="qvbr_quality",
+            tooltip="Quality based VBR (--qvbr), lower is higher quality. Replaces the Bitrate or QP selection above.\nOff uses the selected rate control mode",
+            options=["off"] + [str(x) for x in range(1, 52)],
+            opt="qvbr_quality",
+            min_width=60,
+        )
+
     def init_b_frames(self):
         return self._add_combo_box(
             widget_name="b_frames",
@@ -370,7 +388,8 @@ def setting_change(self, update=True):
     def update_video_encoder_settings(self):
         settings = NVEncCAVCSettings(
             preset=self.widgets.preset.currentText().split("-")[0].strip(),
-            # profile=self.widgets.profile.currentText(),
+            profile=self.widgets.profile.currentText(),
+            tune=self.widgets.tune.currentText(),
             # tier=self.widgets.tier.currentText(),
             lookahead=self.widgets.lookahead.currentIndex() if self.widgets.lookahead.currentIndex() > 0 else None,
             aq=self.widgets.aq.currentText(),
@@ -387,6 +406,7 @@ def update_video_encoder_settings(self):
             min_q_p=self.widgets.min_q_p.currentText() if self.widgets.min_q_p.currentIndex() != 0 else None,
             min_q_b=self.widgets.min_q_b.currentText() if self.widgets.min_q_b.currentIndex() != 0 else None,
             extra=self.ffmpeg_extras,
+            qvbr_quality=self.widgets.qvbr_quality.currentText(),
             metrics=self.widgets.metrics.isChecked(),
             level=self.widgets.level.currentText() if self.widgets.level.currentIndex() != 0 else None,
             b_frames=self.widgets.b_frames.currentText() if self.widgets.b_frames.currentIndex() != 0 else None,
diff --git a/fastflix/encoders/nvencc_hevc/command_builder.py b/fastflix/encoders/nvencc_hevc/command_builder.py
index e4621aed..08336cf3 100644
--- a/fastflix/encoders/nvencc_hevc/command_builder.py
+++ b/fastflix/encoders/nvencc_hevc/command_builder.py
@@ -13,6 +13,12 @@
     rigaya_auto_options,
     rigaya_avformat_reader,
     rigaya_trim_or_seek,
+    rigaya_extra_options,
+    nvenc_profile_args,
+    qvbr_quality_value,
+    nvenc_tune_args,
+    split_extra_args,
+    rigaya_hdr_static_metadata,
 )
 
 logger = logging.getLogger("fastflix")
@@ -62,7 +68,7 @@ def build(fastflix: FastFlix):
     command.extend(["--device", str(settings.device)])
     command.extend(["-i", str(video.source)])
 
-    if stream_id:
+    if stream_id is not None:
         command.extend(["--video-streamid", str(stream_id)])
     command.extend(rigaya_trim_or_seek(video))
     if video.video_settings.source_fps:
@@ -73,11 +79,11 @@ def build(fastflix: FastFlix):
         flip_x = "true" if video.video_settings.horizontal_flip else "false"
         flip_y = "true" if video.video_settings.vertical_flip else "false"
         command.extend(["--vpp-transform", f"flip_x={flip_x},flip_y={flip_y}"])
-    if video.scale:
-        command.extend(["--output-res", video.scale.replace(":", "x")])
     if video.video_settings.crop:
         crop = video.video_settings.crop
         command.extend(["--crop", f"{crop.left},{crop.top},{crop.right},{crop.bottom}"])
+    if video.output_width is not None and video.output_height is not None:
+        command.extend(["--output-res", f"{video.output_width}x{video.output_height}"])
 
     if video.video_settings.remove_metadata:
         command.extend(["--video-metadata", "clear", "--metadata", "clear"])
@@ -87,13 +93,16 @@ def build(fastflix: FastFlix):
         command.extend(["--video-metadata", "copy", "--metadata", "copy"])
 
     if video.video_settings.video_title:
-        command.extend(["--video-metadata", f"title={video.video_settings.video_title}"])
+        command.extend(["--metadata", f"title={video.video_settings.video_title}"])
     if video.video_settings.copy_chapters:
         command.append("--chapter-copy")
 
     command.extend(["-c", "hevc"])
 
-    if settings.bitrate:
+    qvbr = qvbr_quality_value(settings)
+    if qvbr:
+        command.extend(["--qvbr", qvbr])
+    elif settings.bitrate:
         command.extend(["--vbr", settings.bitrate.rstrip("k")])
     else:
         command.extend(["--cqp", str(settings.cqp)])
@@ -102,13 +111,13 @@ def build(fastflix: FastFlix):
         command.extend(["--max-bitrate", str(video.video_settings.maxrate)])
         command.extend(["--vbv-bufsize", str(video.video_settings.bufsize)])
 
-    if settings.vbr_target is not None and settings.bitrate:
+    if settings.vbr_target is not None and settings.bitrate and not qvbr:
         command.extend(["--vbr-quality", str(settings.vbr_target)])
-    if init_q and settings.bitrate:
+    if init_q and (settings.bitrate or qvbr):
         command.extend(["--qp-init", str(init_q)])
-    if min_q and settings.bitrate:
+    if min_q and (settings.bitrate or qvbr):
         command.extend(["--qp-min", str(min_q)])
-    if max_q and settings.bitrate:
+    if max_q and (settings.bitrate or qvbr):
         command.extend(["--qp-max", str(max_q)])
     if settings.b_frames:
         command.extend(["--bframes", str(settings.b_frames)])
@@ -117,6 +126,8 @@ def build(fastflix: FastFlix):
 
     command.extend(["--bref-mode", settings.b_ref_mode])
     command.extend(["--preset", settings.preset])
+    command.extend(nvenc_profile_args(settings.profile, "hevc"))
+    command.extend(nvenc_tune_args(settings.tune, "hevc"))
     command.extend(["--tier", settings.tier])
 
     if settings.lookahead:
@@ -133,16 +144,7 @@ def build(fastflix: FastFlix):
 
     command.extend(rigaya_auto_options(fastflix))
 
-    if fastflix.current_video.master_display:
-        md = fastflix.current_video.master_display
-        command.extend(
-            [
-                "--master-display",
-                f"G{md.green}B{md.blue}R{md.red}WP{md.white}L{md.luminance}",
-            ]
-        )
-    if fastflix.current_video.cll:
-        command.extend(["--max-cll", str(fastflix.current_video.cll)])
+    command.extend(rigaya_hdr_static_metadata(fastflix))
     if settings.copy_hdr10 and not video.video_settings.remove_hdr:
         command.extend(["--dhdr10-info", "copy"])
     if settings.copy_dv and not video.video_settings.remove_hdr:
@@ -160,13 +162,16 @@ def build(fastflix: FastFlix):
         command.extend(["--interlace", str(video.interlaced)])
     if video.video_settings.deinterlace:
         command.append("--vpp-yadif")
+    hdr2sdr_param = None
     if video.video_settings.remove_hdr:
         remove_type = (
             video.video_settings.tone_map
             if video.video_settings.tone_map in ("mobius", "hable", "reinhard")
             else "mobius"
         )
-        command.extend(["--vpp-colorspace", f"hdr2sdr={remove_type}"])
+        hdr2sdr_param = f"hdr2sdr={remove_type}"
+
+    command.extend(rigaya_extra_options(video, hdr2sdr=hdr2sdr_param, fruc=True))
 
     if settings.split_mode == "split":
         command.extend(["--split-enc", "auto_forced"])
@@ -179,11 +184,16 @@ def build(fastflix: FastFlix):
     command.extend(build_audio(video.audio_tracks, video.streams.audio))
     command.extend(build_subtitle(video.subtitle_tracks, video.streams.subtitle, video_height=video.height))
     command.extend(
-        build_data(video.data_tracks, getattr(video.streams, "data", []), getattr(video.streams, "attachment", []))
+        build_data(
+            video.data_tracks,
+            getattr(video.streams, "data", []),
+            getattr(video.streams, "attachment", []),
+            video.video_settings.output_path,
+        )
     )
 
     if settings.extra:
-        command.extend(settings.extra.split())
+        command.extend(split_extra_args(settings.extra))
 
     command.extend(["-o", str(video.video_settings.output_path)])
 
diff --git a/fastflix/encoders/nvencc_hevc/settings_panel.py b/fastflix/encoders/nvencc_hevc/settings_panel.py
index 5e683cfd..d071e2cc 100644
--- a/fastflix/encoders/nvencc_hevc/settings_panel.py
+++ b/fastflix/encoders/nvencc_hevc/settings_panel.py
@@ -77,8 +77,10 @@ def __init__(self, parent, main, app: FastFlixApp):
         custom_layout = self._add_custom(title="Custom NVEncC options", disable_both_passes=True)
 
         grid.addLayout(self.init_preset(), 0, 0, 1, 2)
-        # grid.addLayout(self.init_profile(), 1, 0, 1, 2)
-        grid.addLayout(self.init_tier(), 1, 0, 1, 2)
+        profile_tier = QtWidgets.QHBoxLayout()
+        profile_tier.addLayout(self.init_profile())
+        profile_tier.addLayout(self.init_tier())
+        grid.addLayout(profile_tier, 1, 0, 1, 2)
         grid.addLayout(self.init_multipass(), 2, 0, 1, 2)
         grid.addLayout(self.init_lookahead(), 3, 0, 1, 2)
         # grid.addLayout(self.init_decoder(), 5, 0, 1, 2)
@@ -97,6 +99,7 @@ def __init__(self, parent, main, app: FastFlixApp):
         grid.addLayout(self.init_aq_strength(), 6, 0, 1, 2)
         grid.addLayout(self.init_mv_precision(), 7, 0, 1, 2)
         grid.addLayout(self.init_devices(), 8, 0, 1, 2)
+        grid.addLayout(self.init_tune(), 9, 0, 1, 2)
 
         qp_line = QtWidgets.QHBoxLayout()
         qp_line.addLayout(self.init_vbr_target())
@@ -107,6 +110,8 @@ def __init__(self, parent, main, app: FastFlixApp):
         qp_line.addStretch(1)
         qp_line.addLayout(self.init_max_q())
 
+        qp_line.addStretch(1)
+        qp_line.addLayout(self.init_qvbr_quality())
         grid.addLayout(qp_line, 5, 2, 1, 4)
 
         advanced = QtWidgets.QHBoxLayout()
@@ -134,7 +139,7 @@ def __init__(self, parent, main, app: FastFlixApp):
         grid.addLayout(hdr_line, 8, 2, 1, 2)
         grid.addLayout(self.init_parallel_mode(add_split=True), 8, 4, 1, 2)
 
-        grid.setRowStretch(9, 1)
+        grid.setRowStretch(11, 1)
 
         guide_label = QtWidgets.QLabel(
             link(
@@ -166,20 +171,25 @@ def init_tune(self):
         return self._add_combo_box(
             label="Tune",
             widget_name="tune",
-            tooltip="Tune the settings for a particular type of source or situation\nhq - High Quality, ll - Low Latency, ull - Ultra Low Latency",
-            options=["hq", "ll", "ull", "lossless"],
+            tooltip=(
+                "Tune the preset for a type of source or situation\n"
+                "hq - High Quality (default)\n"
+                "uhq - Ultra High Quality (HEVC and AV1, requires Turing or newer)\n"
+                "lowlatency / ultralowlatency - Streaming oriented\n"
+                "lossless - Lossless output (H.264 and HEVC)"
+            ),
+            options=["hq", "uhq", "lowlatency", "ultralowlatency", "lossless"],
             opt="tune",
         )
 
-    # def init_profile(self):
-    #
-    #     return self._add_combo_box(
-    #         label="Profile_encoderopt",
-    #         widget_name="profile",
-    #         tooltip="Enforce an encode profile",
-    #         options=["main", "main10"],
-    #         opt="profile",
-    #     )
+    def init_profile(self):
+        return self._add_combo_box(
+            label="Profile_encoderopt",
+            widget_name="profile",
+            tooltip="Enforce an encode profile",
+            options=["auto", "main", "main10", "main444"],
+            opt="profile",
+        )
 
     def init_tier(self):
         return self._add_combo_box(
@@ -327,6 +337,16 @@ def init_vbr_target(self):
             min_width=60,
         )
 
+    def init_qvbr_quality(self):
+        return self._add_combo_box(
+            label="QVBR Quality",
+            widget_name="qvbr_quality",
+            tooltip="Quality based VBR (--qvbr), lower is higher quality. Replaces the Bitrate or QP selection above.\nOff uses the selected rate control mode",
+            options=["off"] + [str(x) for x in range(1, 52)],
+            opt="qvbr_quality",
+            min_width=60,
+        )
+
     def init_b_frames(self):
         return self._add_combo_box(
             widget_name="b_frames",
@@ -387,7 +407,8 @@ def setting_change(self, update=True):
     def update_video_encoder_settings(self):
         settings = NVEncCSettings(
             preset=self.widgets.preset.currentText().split("-")[0].strip(),
-            # profile=self.widgets.profile.currentText(),
+            profile=self.widgets.profile.currentText(),
+            tune=self.widgets.tune.currentText(),
             force_ten_bit=self.widgets.force_ten_bit.isChecked(),
             tier=self.widgets.tier.currentText(),
             lookahead=self.widgets.lookahead.currentIndex() if self.widgets.lookahead.currentIndex() > 0 else None,
@@ -407,6 +428,7 @@ def update_video_encoder_settings(self):
             min_q_p=self.widgets.min_q_p.currentText() if self.widgets.min_q_p.currentIndex() != 0 else None,
             min_q_b=self.widgets.min_q_b.currentText() if self.widgets.min_q_b.currentIndex() != 0 else None,
             extra=self.ffmpeg_extras,
+            qvbr_quality=self.widgets.qvbr_quality.currentText(),
             metrics=self.widgets.metrics.isChecked(),
             level=self.widgets.level.currentText() if self.widgets.level.currentIndex() != 0 else None,
             b_frames=self.widgets.b_frames.currentText() if self.widgets.b_frames.currentIndex() != 0 else None,
diff --git a/fastflix/encoders/qsvencc_av1/command_builder.py b/fastflix/encoders/qsvencc_av1/command_builder.py
index 37d40fd0..bef1ea56 100644
--- a/fastflix/encoders/qsvencc_av1/command_builder.py
+++ b/fastflix/encoders/qsvencc_av1/command_builder.py
@@ -1,10 +1,9 @@
 # -*- coding: utf-8 -*-
 import logging
-import shlex
 from typing import List
 
 from fastflix.encoders.common.helpers import Command
-from fastflix.models.encode import QSVEncCAV1Settings
+from fastflix.models.encode import sanitize_qsv_tune, QSVEncCAV1Settings
 from fastflix.models.video import Video
 from fastflix.models.fastflix import FastFlix
 from fastflix.encoders.common.encc_helpers import (
@@ -14,6 +13,10 @@
     rigaya_auto_options,
     rigaya_avformat_reader,
     rigaya_trim_or_seek,
+    rigaya_extra_options,
+    qvbr_quality_value,
+    split_extra_args,
+    rigaya_hdr_static_metadata,
 )
 
 logger = logging.getLogger("fastflix")
@@ -56,7 +59,7 @@ def build(fastflix: FastFlix):
 
     command.extend(["-i", str(video.source)])
 
-    if stream_id:
+    if stream_id is not None:
         command.extend(["--video-streamid", str(stream_id)])
 
     command.extend(rigaya_trim_or_seek(video))
@@ -72,12 +75,11 @@ def build(fastflix: FastFlix):
         flip_y = "true" if video.video_settings.vertical_flip else "false"
         command.extend(["--vpp-transform", f"flip_x={flip_x},flip_y={flip_y}"])
 
-    if video.scale:
-        command.extend(["--output-res", video.scale.replace(":", "x")])
-
     if video.video_settings.crop:
         crop = video.video_settings.crop
         command.extend(["--crop", f"{crop.left},{crop.top},{crop.right},{crop.bottom}"])
+    if video.output_width is not None and video.output_height is not None:
+        command.extend(["--output-res", f"{video.output_width}x{video.output_height}"])
 
     if video.video_settings.remove_metadata:
         command.extend(["--video-metadata", "clear", "--metadata", "clear"])
@@ -87,14 +89,17 @@ def build(fastflix: FastFlix):
         command.extend(["--video-metadata", "copy", "--metadata", "copy"])
 
     if video.video_settings.video_title:
-        command.extend(["--video-metadata", f"title={video.video_settings.video_title}"])
+        command.extend(["--metadata", f"title={video.video_settings.video_title}"])
 
     if video.video_settings.copy_chapters:
         command.append("--chapter-copy")
 
     command.extend(["-c", "av1"])
 
-    if settings.bitrate:
+    qvbr = qvbr_quality_value(settings)
+    if settings.bitrate and qvbr:
+        command.extend(["--qvbr", settings.bitrate.rstrip("k"), "--qvbr-quality", qvbr])
+    elif settings.bitrate:
         command.extend(["--vbr", settings.bitrate.rstrip("k")])
     else:
         command.extend([f"--{settings.qp_mode}", str(settings.cqp)])
@@ -118,24 +123,22 @@ def build(fastflix: FastFlix):
 
     command.extend(["--quality", settings.preset])
 
+    tune = sanitize_qsv_tune(settings.tune)
+    if tune:
+        command.extend(["--tune", tune])
+
     if settings.lookahead:
-        command.extend(["--la-depth", str(settings.lookahead)])
+        if settings.bitrate:
+            # AV1 lookahead is the EncTools LookAheadDepth on top of bitrate control, which needs ExtBRC
+            command.extend(["--la-depth", str(settings.lookahead), "--extbrc"])
+        else:
+            logger.warning("QSVEncC AV1 lookahead requires a bitrate rate control mode, ignoring lookahead")
 
     command.extend(["--level", settings.level or "auto"])
 
     command.extend(rigaya_auto_options(fastflix))
 
-    if fastflix.current_video.master_display:
-        md = fastflix.current_video.master_display
-        command.extend(
-            [
-                "--master-display",
-                f"G{md.green}B{md.blue}R{md.red}WP{md.white}L{md.luminance}",
-            ]
-        )
-
-    if fastflix.current_video.cll:
-        command.extend(["--max-cll", str(fastflix.current_video.cll)])
+    command.extend(rigaya_hdr_static_metadata(fastflix))
 
     if settings.copy_hdr10 and not video.video_settings.remove_hdr:
         command.extend(["--dhdr10-info", "copy"])
@@ -155,13 +158,16 @@ def build(fastflix: FastFlix):
     if video.video_settings.deinterlace:
         command.append("--vpp-yadif")
 
+    hdr2sdr_param = None
     if video.video_settings.remove_hdr:
         remove_type = (
             video.video_settings.tone_map
             if video.video_settings.tone_map in ("mobius", "hable", "reinhard")
             else "mobius"
         )
-        command.extend(["--vpp-colorspace", f"hdr2sdr={remove_type}"])
+        hdr2sdr_param = f"hdr2sdr={remove_type}"
+
+    command.extend(rigaya_extra_options(video, hdr2sdr=hdr2sdr_param))
 
     if settings.split_mode == "parallel":
         command.extend(["--parallel", "auto"])
@@ -181,11 +187,16 @@ def build(fastflix: FastFlix):
     command.extend(build_audio(video.audio_tracks, video.streams.audio))
     command.extend(build_subtitle(video.subtitle_tracks, video.streams.subtitle, video_height=video.height))
     command.extend(
-        build_data(video.data_tracks, getattr(video.streams, "data", []), getattr(video.streams, "attachment", []))
+        build_data(
+            video.data_tracks,
+            getattr(video.streams, "data", []),
+            getattr(video.streams, "attachment", []),
+            video.video_settings.output_path,
+        )
     )
 
     if settings.extra:
-        command.extend(shlex.split(settings.extra))
+        command.extend(split_extra_args(settings.extra))
 
     command.extend(["-o", str(video.video_settings.output_path)])
 
diff --git a/fastflix/encoders/qsvencc_av1/settings_panel.py b/fastflix/encoders/qsvencc_av1/settings_panel.py
index 5795820e..91841cad 100644
--- a/fastflix/encoders/qsvencc_av1/settings_panel.py
+++ b/fastflix/encoders/qsvencc_av1/settings_panel.py
@@ -85,8 +85,9 @@ def __init__(self, parent, main, app: FastFlixApp):
         custom_layout = self._add_custom(title="Custom QSVEncC options", disable_both_passes=True)
 
         grid.addLayout(self.init_preset(), 0, 0, 1, 2)
-        grid.addLayout(self.init_lookahead(), 1, 0, 1, 2)
-        grid.addLayout(self.init_qp_mode(), 2, 0, 1, 2)
+        grid.addLayout(self.init_tune(), 1, 0, 1, 2)
+        grid.addLayout(self.init_lookahead(), 2, 0, 1, 2)
+        grid.addLayout(self.init_qp_mode(), 3, 0, 1, 2)
         grid.addLayout(self.init_adapt_ref(), 5, 0, 1, 2)
         grid.addLayout(self.init_adapt_ltr(), 6, 0, 1, 2)
         grid.addLayout(self.init_adapt_cqm(), 7, 0, 1, 2)
@@ -108,6 +109,8 @@ def __init__(self, parent, main, app: FastFlixApp):
         qp_line.addStretch(1)
         qp_line.addLayout(self.init_max_q())
 
+        qp_line.addStretch(1)
+        qp_line.addLayout(self.init_qvbr_quality())
         grid.addLayout(qp_line, 5, 2, 1, 4)
 
         advanced = QtWidgets.QHBoxLayout()
@@ -170,8 +173,14 @@ def init_tune(self):
         return self._add_combo_box(
             label="Tune",
             widget_name="tune",
-            tooltip="Tune the settings for a particular type of source or situation\nhq - High Quality, ll - Low Latency, ull - Ultra Low Latency",
-            options=["hq", "ll", "ull", "lossless"],
+            tooltip=(
+                "Tune the encode quality mode\n"
+                "default - Default\n"
+                "psnr / ssim / ms_ssim - Optimize for the metric\n"
+                "vmaf - Optimize for VMAF\n"
+                "perceptual - Perceptual quality"
+            ),
+            options=["none", "default", "psnr", "ssim", "ms_ssim", "vmaf", "perceptual"],
             opt="tune",
         )
 
@@ -262,6 +271,16 @@ def init_max_q(self):
         )
         return layout
 
+    def init_qvbr_quality(self):
+        return self._add_combo_box(
+            label="QVBR Quality",
+            widget_name="qvbr_quality",
+            tooltip="Quality based VBR (--qvbr-quality, QSVEncC default 23), lower is higher quality.\nUses the selected bitrate as the target, only applies in Bitrate mode. Off uses plain VBR",
+            options=["off"] + [str(x) for x in range(1, 52)],
+            opt="qvbr_quality",
+            min_width=60,
+        )
+
     def init_b_frames(self):
         return self._add_combo_box(
             widget_name="b_frames",
@@ -329,6 +348,7 @@ def update_video_encoder_settings(self):
             min_q_p=self.widgets.min_q_p.currentText() if self.widgets.min_q_p.currentIndex() != 0 else None,
             min_q_b=self.widgets.min_q_b.currentText() if self.widgets.min_q_b.currentIndex() != 0 else None,
             extra=self.ffmpeg_extras,
+            qvbr_quality=self.widgets.qvbr_quality.currentText(),
             metrics=self.widgets.metrics.isChecked(),
             level=self.widgets.level.currentText() if self.widgets.level.currentIndex() != 0 else None,
             b_frames=self.widgets.b_frames.currentText() if self.widgets.b_frames.currentIndex() != 0 else None,
@@ -339,6 +359,7 @@ def update_video_encoder_settings(self):
             adapt_cqm=self.widgets.adapt_cqm.isChecked(),
             adapt_ref=self.widgets.adapt_ref.isChecked(),
             split_mode=self.widgets.split_mode.currentText(),
+            tune=self.widgets.tune.currentText() if self.widgets.tune.currentIndex() != 0 else None,
         )
 
         encode_type, q_value = self.get_mode_settings()
@@ -351,7 +372,7 @@ def set_mode(self, x):
         for group in ("max", "min"):
             for frame_type in ("i", "p", "b"):
                 self.widgets[f"{group}_q_{frame_type}"].setEnabled(self.mode.lower() == "bitrate")
-        # self.widgets.vbr_target.setEnabled(self.mode.lower() == "bitrate")
+        self.widgets.qvbr_quality.setEnabled(self.mode.lower() == "bitrate")
         self.main.build_commands()
 
     def new_source(self):
diff --git a/fastflix/encoders/qsvencc_avc/command_builder.py b/fastflix/encoders/qsvencc_avc/command_builder.py
index e3d8a23f..0fa6c3b6 100644
--- a/fastflix/encoders/qsvencc_avc/command_builder.py
+++ b/fastflix/encoders/qsvencc_avc/command_builder.py
@@ -1,10 +1,9 @@
 # -*- coding: utf-8 -*-
 import logging
-import shlex
 from typing import List
 
 from fastflix.encoders.common.helpers import Command
-from fastflix.models.encode import QSVEncCH264Settings
+from fastflix.models.encode import sanitize_qsv_tune, QSVEncCH264Settings
 from fastflix.models.video import Video
 from fastflix.models.fastflix import FastFlix
 from fastflix.encoders.common.encc_helpers import (
@@ -14,6 +13,9 @@
     rigaya_auto_options,
     rigaya_avformat_reader,
     rigaya_trim_or_seek,
+    rigaya_extra_options,
+    qvbr_quality_value,
+    split_extra_args,
 )
 
 logger = logging.getLogger("fastflix")
@@ -56,7 +58,7 @@ def build(fastflix: FastFlix):
 
     command.extend(["-i", str(video.source)])
 
-    if stream_id:
+    if stream_id is not None:
         command.extend(["--video-streamid", str(stream_id)])
 
     command.extend(rigaya_trim_or_seek(video))
@@ -72,12 +74,11 @@ def build(fastflix: FastFlix):
         flip_y = "true" if video.video_settings.vertical_flip else "false"
         command.extend(["--vpp-transform", f"flip_x={flip_x},flip_y={flip_y}"])
 
-    if video.scale:
-        command.extend(["--output-res", video.scale.replace(":", "x")])
-
     if video.video_settings.crop:
         crop = video.video_settings.crop
         command.extend(["--crop", f"{crop.left},{crop.top},{crop.right},{crop.bottom}"])
+    if video.output_width is not None and video.output_height is not None:
+        command.extend(["--output-res", f"{video.output_width}x{video.output_height}"])
 
     if video.video_settings.remove_metadata:
         command.extend(["--video-metadata", "clear", "--metadata", "clear"])
@@ -85,14 +86,17 @@ def build(fastflix: FastFlix):
         command.extend(["--video-metadata", "copy", "--metadata", "copy"])
 
     if video.video_settings.video_title:
-        command.extend(["--video-metadata", f"title={video.video_settings.video_title}"])
+        command.extend(["--metadata", f"title={video.video_settings.video_title}"])
 
     if video.video_settings.copy_chapters:
         command.append("--chapter-copy")
 
     command.extend(["-c", "h264"])
 
-    if settings.bitrate:
+    qvbr = qvbr_quality_value(settings)
+    if settings.bitrate and qvbr:
+        command.extend(["--qvbr", settings.bitrate.rstrip("k"), "--qvbr-quality", qvbr])
+    elif settings.bitrate:
         command.extend(["--vbr", settings.bitrate.rstrip("k")])
     else:
         command.extend([f"--{settings.qp_mode}", str(settings.cqp)])
@@ -117,8 +121,15 @@ def build(fastflix: FastFlix):
     command.extend(["--quality", settings.preset])
     command.extend(["--profile", settings.profile])
 
+    tune = sanitize_qsv_tune(settings.tune)
+    if tune:
+        command.extend(["--tune", tune])
+
     if settings.lookahead:
-        command.extend(["--la-depth", str(settings.lookahead)])
+        if settings.bitrate or settings.qp_mode == "la-icq":
+            command.extend(["--la-depth", str(settings.lookahead)])
+        else:
+            logger.warning(f"QSVEncC ignores lookahead depth in {settings.qp_mode} mode, ignoring lookahead")
 
     command.extend(["--level", settings.level or "auto"])
 
@@ -134,13 +145,16 @@ def build(fastflix: FastFlix):
     if video.video_settings.deinterlace:
         command.append("--vpp-yadif")
 
+    hdr2sdr_param = None
     if video.video_settings.remove_hdr:
         remove_type = (
             video.video_settings.tone_map
             if video.video_settings.tone_map in ("mobius", "hable", "reinhard")
             else "mobius"
         )
-        command.extend(["--vpp-colorspace", f"hdr2sdr={remove_type}"])
+        hdr2sdr_param = f"hdr2sdr={remove_type}"
+
+    command.extend(rigaya_extra_options(video, hdr2sdr=hdr2sdr_param))
 
     if settings.split_mode == "parallel":
         command.extend(["--parallel", "auto"])
@@ -160,11 +174,16 @@ def build(fastflix: FastFlix):
     command.extend(build_audio(video.audio_tracks, video.streams.audio))
     command.extend(build_subtitle(video.subtitle_tracks, video.streams.subtitle, video_height=video.height))
     command.extend(
-        build_data(video.data_tracks, getattr(video.streams, "data", []), getattr(video.streams, "attachment", []))
+        build_data(
+            video.data_tracks,
+            getattr(video.streams, "data", []),
+            getattr(video.streams, "attachment", []),
+            video.video_settings.output_path,
+        )
     )
 
     if settings.extra:
-        command.extend(shlex.split(settings.extra))
+        command.extend(split_extra_args(settings.extra))
 
     command.extend(["-o", str(video.video_settings.output_path)])
 
diff --git a/fastflix/encoders/qsvencc_avc/settings_panel.py b/fastflix/encoders/qsvencc_avc/settings_panel.py
index 9763fa26..f597d342 100644
--- a/fastflix/encoders/qsvencc_avc/settings_panel.py
+++ b/fastflix/encoders/qsvencc_avc/settings_panel.py
@@ -84,11 +84,12 @@ def __init__(self, parent, main, app: FastFlixApp):
 
         grid.addLayout(self.init_preset(), 0, 0, 1, 2)
         grid.addLayout(self.init_profile(), 1, 0, 1, 2)
-        grid.addLayout(self.init_lookahead(), 2, 0, 1, 2)
-        grid.addLayout(self.init_qp_mode(), 3, 0, 1, 2)
-        grid.addLayout(self.init_adapt_ref(), 5, 0, 1, 2)
-        grid.addLayout(self.init_adapt_ltr(), 6, 0, 1, 2)
-        grid.addLayout(self.init_adapt_cqm(), 7, 0, 1, 2)
+        grid.addLayout(self.init_tune(), 2, 0, 1, 2)
+        grid.addLayout(self.init_lookahead(), 3, 0, 1, 2)
+        grid.addLayout(self.init_qp_mode(), 4, 0, 1, 2)
+        grid.addLayout(self.init_adapt_ref(), 6, 0, 1, 2)
+        grid.addLayout(self.init_adapt_ltr(), 7, 0, 1, 2)
+        grid.addLayout(self.init_adapt_cqm(), 8, 0, 1, 2)
 
         breaker = QtWidgets.QHBoxLayout()
         breaker_label = QtWidgets.QLabel(t("Advanced"))
@@ -98,7 +99,7 @@ def __init__(self, parent, main, app: FastFlixApp):
         breaker.addWidget(breaker_label, alignment=QtCore.Qt.AlignHCenter)
         breaker.addWidget(get_breaker(), stretch=1)
 
-        grid.addLayout(breaker, 4, 0, 1, 6)
+        grid.addLayout(breaker, 5, 0, 1, 6)
 
         qp_line = QtWidgets.QHBoxLayout()
         qp_line.addLayout(self.init_decoder())
@@ -107,7 +108,9 @@ def __init__(self, parent, main, app: FastFlixApp):
         qp_line.addStretch(1)
         qp_line.addLayout(self.init_max_q())
 
-        grid.addLayout(qp_line, 5, 2, 1, 4)
+        qp_line.addStretch(1)
+        qp_line.addLayout(self.init_qvbr_quality())
+        grid.addLayout(qp_line, 6, 2, 1, 4)
 
         advanced = QtWidgets.QHBoxLayout()
         advanced.addLayout(self.init_10_bit())
@@ -119,13 +122,13 @@ def __init__(self, parent, main, app: FastFlixApp):
         advanced.addLayout(self.init_level())
         advanced.addStretch(1)
         advanced.addLayout(self.init_metrics())
-        grid.addLayout(advanced, 6, 2, 1, 4)
+        grid.addLayout(advanced, 7, 2, 1, 4)
 
         self.ffmpeg_level = QtWidgets.QLabel()
-        grid.addWidget(self.ffmpeg_level, 8, 2, 1, 4)
-        grid.addLayout(self.init_parallel_mode(), 7, 4, 1, 2)
+        grid.addWidget(self.ffmpeg_level, 9, 2, 1, 4)
+        grid.addLayout(self.init_parallel_mode(), 8, 4, 1, 2)
 
-        grid.setRowStretch(9, 1)
+        grid.setRowStretch(10, 1)
 
         guide_label = QtWidgets.QLabel(
             link(
@@ -136,7 +139,7 @@ def __init__(self, parent, main, app: FastFlixApp):
         )
         guide_label.setOpenExternalLinks(True)
         custom_layout.addWidget(guide_label)
-        grid.addLayout(custom_layout, 10, 0, 1, 6)
+        grid.addLayout(custom_layout, 11, 0, 1, 6)
 
         self.setLayout(grid)
         self.hide()
@@ -155,8 +158,14 @@ def init_tune(self):
         return self._add_combo_box(
             label="Tune",
             widget_name="tune",
-            tooltip="Tune the settings for a particular type of source or situation\nhq - High Quality, ll - Low Latency, ull - Ultra Low Latency",
-            options=["hq", "ll", "ull", "lossless"],
+            tooltip=(
+                "Tune the encode quality mode\n"
+                "default - Default\n"
+                "psnr / ssim / ms_ssim - Optimize for the metric\n"
+                "vmaf - Optimize for VMAF\n"
+                "perceptual - Perceptual quality"
+            ),
+            options=["none", "default", "psnr", "ssim", "ms_ssim", "vmaf", "perceptual"],
             opt="tune",
         )
 
@@ -252,6 +261,16 @@ def init_max_q(self):
         )
         return layout
 
+    def init_qvbr_quality(self):
+        return self._add_combo_box(
+            label="QVBR Quality",
+            widget_name="qvbr_quality",
+            tooltip="Quality based VBR (--qvbr-quality, QSVEncC default 23), lower is higher quality.\nUses the selected bitrate as the target, only applies in Bitrate mode. Off uses plain VBR",
+            options=["off"] + [str(x) for x in range(1, 52)],
+            opt="qvbr_quality",
+            min_width=60,
+        )
+
     def init_b_frames(self):
         return self._add_combo_box(
             widget_name="b_frames",
@@ -318,6 +337,7 @@ def update_video_encoder_settings(self):
             min_q_p=self.widgets.min_q_p.currentText() if self.widgets.min_q_p.currentIndex() != 0 else None,
             min_q_b=self.widgets.min_q_b.currentText() if self.widgets.min_q_b.currentIndex() != 0 else None,
             extra=self.ffmpeg_extras,
+            qvbr_quality=self.widgets.qvbr_quality.currentText(),
             metrics=self.widgets.metrics.isChecked(),
             level=self.widgets.level.currentText() if self.widgets.level.currentIndex() != 0 else None,
             b_frames=self.widgets.b_frames.currentText() if self.widgets.b_frames.currentIndex() != 0 else None,
@@ -328,6 +348,7 @@ def update_video_encoder_settings(self):
             adapt_cqm=self.widgets.adapt_cqm.isChecked(),
             adapt_ref=self.widgets.adapt_ref.isChecked(),
             split_mode=self.widgets.split_mode.currentText(),
+            tune=self.widgets.tune.currentText() if self.widgets.tune.currentIndex() != 0 else None,
         )
 
         encode_type, q_value = self.get_mode_settings()
@@ -340,7 +361,7 @@ def set_mode(self, x):
         for group in ("max", "min"):
             for frame_type in ("i", "p", "b"):
                 self.widgets[f"{group}_q_{frame_type}"].setEnabled(self.mode.lower() == "bitrate")
-        # self.widgets.vbr_target.setEnabled(self.mode.lower() == "bitrate")
+        self.widgets.qvbr_quality.setEnabled(self.mode.lower() == "bitrate")
         self.main.build_commands()
 
     def new_source(self):
diff --git a/fastflix/encoders/qsvencc_hevc/command_builder.py b/fastflix/encoders/qsvencc_hevc/command_builder.py
index 442868a4..e7d6e2da 100644
--- a/fastflix/encoders/qsvencc_hevc/command_builder.py
+++ b/fastflix/encoders/qsvencc_hevc/command_builder.py
@@ -1,10 +1,9 @@
 # -*- coding: utf-8 -*-
 import logging
-import shlex
 from typing import List
 
 from fastflix.encoders.common.helpers import Command
-from fastflix.models.encode import QSVEncCSettings
+from fastflix.models.encode import sanitize_qsv_tune, QSVEncCSettings
 from fastflix.models.video import Video
 from fastflix.models.fastflix import FastFlix
 from fastflix.encoders.common.encc_helpers import (
@@ -14,6 +13,10 @@
     rigaya_auto_options,
     rigaya_avformat_reader,
     rigaya_trim_or_seek,
+    rigaya_extra_options,
+    qvbr_quality_value,
+    split_extra_args,
+    rigaya_hdr_static_metadata,
 )
 
 logger = logging.getLogger("fastflix")
@@ -56,7 +59,7 @@ def build(fastflix: FastFlix):
 
     command.extend(["-i", str(video.source)])
 
-    if stream_id:
+    if stream_id is not None:
         command.extend(["--video-streamid", str(stream_id)])
 
     command.extend(rigaya_trim_or_seek(video))
@@ -72,12 +75,11 @@ def build(fastflix: FastFlix):
         flip_y = "true" if video.video_settings.vertical_flip else "false"
         command.extend(["--vpp-transform", f"flip_x={flip_x},flip_y={flip_y}"])
 
-    if video.scale:
-        command.extend(["--output-res", video.scale.replace(":", "x")])
-
     if video.video_settings.crop:
         crop = video.video_settings.crop
         command.extend(["--crop", f"{crop.left},{crop.top},{crop.right},{crop.bottom}"])
+    if video.output_width is not None and video.output_height is not None:
+        command.extend(["--output-res", f"{video.output_width}x{video.output_height}"])
 
     if video.video_settings.remove_metadata:
         command.extend(["--video-metadata", "clear", "--metadata", "clear"])
@@ -87,14 +89,17 @@ def build(fastflix: FastFlix):
         command.extend(["--video-metadata", "copy", "--metadata", "copy"])
 
     if video.video_settings.video_title:
-        command.extend(["--video-metadata", f"title={video.video_settings.video_title}"])
+        command.extend(["--metadata", f"title={video.video_settings.video_title}"])
 
     if video.video_settings.copy_chapters:
         command.append("--chapter-copy")
 
     command.extend(["-c", "hevc"])
 
-    if settings.bitrate:
+    qvbr = qvbr_quality_value(settings)
+    if settings.bitrate and qvbr:
+        command.extend(["--qvbr", settings.bitrate.rstrip("k"), "--qvbr-quality", qvbr])
+    elif settings.bitrate:
         command.extend(["--vbr", settings.bitrate.rstrip("k")])
     else:
         command.extend([f"--{settings.qp_mode}", str(settings.cqp)])
@@ -118,24 +123,21 @@ def build(fastflix: FastFlix):
 
     command.extend(["--quality", settings.preset])
 
+    tune = sanitize_qsv_tune(settings.tune)
+    if tune:
+        command.extend(["--tune", tune])
+
     if settings.lookahead:
-        command.extend(["--la-depth", str(settings.lookahead)])
+        if settings.bitrate or settings.qp_mode == "la-icq":
+            command.extend(["--la-depth", str(settings.lookahead)])
+        else:
+            logger.warning(f"QSVEncC ignores lookahead depth in {settings.qp_mode} mode, ignoring lookahead")
 
     command.extend(["--level", settings.level or "auto"])
 
     command.extend(rigaya_auto_options(fastflix))
 
-    if fastflix.current_video.master_display:
-        md = fastflix.current_video.master_display
-        command.extend(
-            [
-                "--master-display",
-                f"G{md.green}B{md.blue}R{md.red}WP{md.white}L{md.luminance}",
-            ]
-        )
-
-    if fastflix.current_video.cll:
-        command.extend(["--max-cll", str(fastflix.current_video.cll)])
+    command.extend(rigaya_hdr_static_metadata(fastflix))
 
     if settings.copy_hdr10 and not video.video_settings.remove_hdr:
         command.extend(["--dhdr10-info", "copy"])
@@ -155,13 +157,16 @@ def build(fastflix: FastFlix):
     if video.video_settings.deinterlace:
         command.append("--vpp-yadif")
 
+    hdr2sdr_param = None
     if video.video_settings.remove_hdr:
         remove_type = (
             video.video_settings.tone_map
             if video.video_settings.tone_map in ("mobius", "hable", "reinhard")
             else "mobius"
         )
-        command.extend(["--vpp-colorspace", f"hdr2sdr={remove_type}"])
+        hdr2sdr_param = f"hdr2sdr={remove_type}"
+
+    command.extend(rigaya_extra_options(video, hdr2sdr=hdr2sdr_param))
 
     if settings.split_mode == "parallel":
         command.extend(["--parallel", "auto"])
@@ -181,11 +186,16 @@ def build(fastflix: FastFlix):
     command.extend(build_audio(video.audio_tracks, video.streams.audio))
     command.extend(build_subtitle(video.subtitle_tracks, video.streams.subtitle, video_height=video.height))
     command.extend(
-        build_data(video.data_tracks, getattr(video.streams, "data", []), getattr(video.streams, "attachment", []))
+        build_data(
+            video.data_tracks,
+            getattr(video.streams, "data", []),
+            getattr(video.streams, "attachment", []),
+            video.video_settings.output_path,
+        )
     )
 
     if settings.extra:
-        command.extend(shlex.split(settings.extra))
+        command.extend(split_extra_args(settings.extra))
 
     command.extend(["-o", str(video.video_settings.output_path)])
 
diff --git a/fastflix/encoders/qsvencc_hevc/settings_panel.py b/fastflix/encoders/qsvencc_hevc/settings_panel.py
index 423b7ef6..01311676 100644
--- a/fastflix/encoders/qsvencc_hevc/settings_panel.py
+++ b/fastflix/encoders/qsvencc_hevc/settings_panel.py
@@ -85,8 +85,9 @@ def __init__(self, parent, main, app: FastFlixApp):
         custom_layout = self._add_custom(title="Custom QSVEncC options", disable_both_passes=True)
 
         grid.addLayout(self.init_preset(), 0, 0, 1, 2)
+        grid.addLayout(self.init_tune(), 1, 0, 1, 2)
         grid.addLayout(self.init_qp_mode(), 2, 0, 1, 2)
-        grid.addLayout(self.init_lookahead(), 1, 0, 1, 2)
+        grid.addLayout(self.init_lookahead(), 3, 0, 1, 2)
         grid.addLayout(self.init_adapt_ref(), 5, 0, 1, 2)
         grid.addLayout(self.init_adapt_ltr(), 6, 0, 1, 2)
         grid.addLayout(self.init_adapt_cqm(), 7, 0, 1, 2)
@@ -108,6 +109,8 @@ def __init__(self, parent, main, app: FastFlixApp):
         qp_line.addStretch(1)
         qp_line.addLayout(self.init_max_q())
 
+        qp_line.addStretch(1)
+        qp_line.addLayout(self.init_qvbr_quality())
         grid.addLayout(qp_line, 5, 2, 1, 4)
 
         advanced = QtWidgets.QHBoxLayout()
@@ -163,8 +166,14 @@ def init_tune(self):
         return self._add_combo_box(
             label="Tune",
             widget_name="tune",
-            tooltip="Tune the settings for a particular type of source or situation\nhq - High Quality, ll - Low Latency, ull - Ultra Low Latency",
-            options=["hq", "ll", "ull", "lossless"],
+            tooltip=(
+                "Tune the encode quality mode\n"
+                "default - Default\n"
+                "psnr / ssim / ms_ssim - Optimize for the metric\n"
+                "vmaf - Optimize for VMAF\n"
+                "perceptual - Perceptual quality"
+            ),
+            options=["none", "default", "psnr", "ssim", "ms_ssim", "vmaf", "perceptual"],
             opt="tune",
         )
 
@@ -255,6 +264,16 @@ def init_max_q(self):
         )
         return layout
 
+    def init_qvbr_quality(self):
+        return self._add_combo_box(
+            label="QVBR Quality",
+            widget_name="qvbr_quality",
+            tooltip="Quality based VBR (--qvbr-quality, QSVEncC default 23), lower is higher quality.\nUses the selected bitrate as the target, only applies in Bitrate mode. Off uses plain VBR",
+            options=["off"] + [str(x) for x in range(1, 52)],
+            opt="qvbr_quality",
+            min_width=60,
+        )
+
     def init_b_frames(self):
         return self._add_combo_box(
             widget_name="b_frames",
@@ -322,6 +341,7 @@ def update_video_encoder_settings(self):
             min_q_p=self.widgets.min_q_p.currentText() if self.widgets.min_q_p.currentIndex() != 0 else None,
             min_q_b=self.widgets.min_q_b.currentText() if self.widgets.min_q_b.currentIndex() != 0 else None,
             extra=self.ffmpeg_extras,
+            qvbr_quality=self.widgets.qvbr_quality.currentText(),
             metrics=self.widgets.metrics.isChecked(),
             level=self.widgets.level.currentText() if self.widgets.level.currentIndex() != 0 else None,
             b_frames=self.widgets.b_frames.currentText() if self.widgets.b_frames.currentIndex() != 0 else None,
@@ -332,6 +352,7 @@ def update_video_encoder_settings(self):
             adapt_cqm=self.widgets.adapt_cqm.isChecked(),
             adapt_ref=self.widgets.adapt_ref.isChecked(),
             split_mode=self.widgets.split_mode.currentText(),
+            tune=self.widgets.tune.currentText() if self.widgets.tune.currentIndex() != 0 else None,
         )
 
         encode_type, q_value = self.get_mode_settings()
@@ -344,7 +365,7 @@ def set_mode(self, x):
         for group in ("max", "min"):
             for frame_type in ("i", "p", "b"):
                 self.widgets[f"{group}_q_{frame_type}"].setEnabled(self.mode.lower() == "bitrate")
-        # self.widgets.vbr_target.setEnabled(self.mode.lower() == "bitrate")
+        self.widgets.qvbr_quality.setEnabled(self.mode.lower() == "bitrate")
         self.main.build_commands()
 
     def new_source(self):
diff --git a/fastflix/encoders/rav1e/command_builder.py b/fastflix/encoders/rav1e/command_builder.py
index 0166dcd2..68beeeb2 100644
--- a/fastflix/encoders/rav1e/command_builder.py
+++ b/fastflix/encoders/rav1e/command_builder.py
@@ -5,6 +5,7 @@
 import secrets
 import shlex
 
+from fastflix.encoders.common.hdr_metadata import is_hdr_bit_depth, parse_master_display
 from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details, null
 from fastflix.models.encode import rav1eSettings
 from fastflix.models.fastflix import FastFlix
@@ -42,16 +43,10 @@ def build(fastflix: FastFlix):
         rav1e_params.append("no_scene_detection=true")
 
     if not fastflix.current_video.video_settings.remove_hdr:
-        if settings.pix_fmt in ("yuv420p10le", "yuv420p12le"):
-            if fastflix.current_video.master_display:
-                rav1e_params.append(
-                    "mastering_display="
-                    f"G{fastflix.current_video.master_display.green}"
-                    f"B{fastflix.current_video.master_display.blue}"
-                    f"R{fastflix.current_video.master_display.red}"
-                    f"WP{fastflix.current_video.master_display.white}"
-                    f"L{fastflix.current_video.master_display.luminance}"
-                )
+        if is_hdr_bit_depth(settings.pix_fmt):
+            master_display = parse_master_display(fastflix.current_video.master_display)
+            if master_display:
+                rav1e_params.append(f"mastering_display={master_display.to_rav1e()}")
 
             if fastflix.current_video.cll:
                 rav1e_params.append(f"content_light={fastflix.current_video.cll}")
diff --git a/fastflix/encoders/svt_av1/command_builder.py b/fastflix/encoders/svt_av1/command_builder.py
index 572c5718..0a129d34 100644
--- a/fastflix/encoders/svt_av1/command_builder.py
+++ b/fastflix/encoders/svt_av1/command_builder.py
@@ -7,6 +7,7 @@
 
 import reusables
 
+from fastflix.encoders.common.hdr_metadata import is_hdr_bit_depth
 from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details, null
 from fastflix.models.encode import SVTAV1Settings
 from fastflix.models.fastflix import FastFlix
@@ -26,7 +27,8 @@ def build(fastflix: FastFlix):
 
     if settings.tune != "1":
         svtav1_params.append(f"tune={settings.tune}")
-    if settings.film_grain:
+    # Film grain synthesis is not compatible with lossless mode
+    if settings.film_grain and not settings.lossless:
         svtav1_params.append(f"film-grain={settings.film_grain}")
         if settings.film_grain_denoise:
             svtav1_params.append("film-grain-denoise=1")
@@ -34,6 +36,22 @@ def build(fastflix: FastFlix):
         svtav1_params.append(f"sharpness={settings.sharpness}")
     if settings.fast_decode != "0":
         svtav1_params.append(f"fast-decode={settings.fast_decode}")
+    if settings.enable_variance_boost:
+        svtav1_params.append("enable-variance-boost=1")
+        if settings.variance_boost_strength != "2":
+            svtav1_params.append(f"variance-boost-strength={settings.variance_boost_strength}")
+        if settings.variance_octile != "5":
+            svtav1_params.append(f"variance-octile={settings.variance_octile}")
+    if settings.enable_tf != "1":
+        svtav1_params.append(f"enable-tf={settings.enable_tf}")
+    if settings.startup_mg_size != "0":
+        svtav1_params.append(f"startup-mg-size={settings.startup_mg_size}")
+    if settings.enable_qm:
+        svtav1_params.append("enable-qm=1")
+        if settings.qm_min != "8":
+            svtav1_params.append(f"qm-min={settings.qm_min}")
+        if settings.qm_max != "15":
+            svtav1_params.append(f"qm-max={settings.qm_max}")
 
     svtav1_params.extend(
         [
@@ -63,7 +81,7 @@ def build(fastflix: FastFlix):
             svtav1_params.append("matrix-coefficients=9")
 
         enable_hdr = False
-        if settings.pix_fmt in ("yuv420p10le", "yuv420p12le"):
+        if is_hdr_bit_depth(settings.pix_fmt):
 
             def convert_me(two_numbers, conversion_rate=50_000) -> str:
                 try:
@@ -91,6 +109,9 @@ def convert_me(two_numbers, conversion_rate=50_000) -> str:
             if enable_hdr:
                 svtav1_params.append("enable-hdr=1")
 
+    if settings.lossless:
+        svtav1_params.append("lossless=1")
+
     if svtav1_params:
         beginning.extend(["-svtav1-params", ":".join(svtav1_params)])
 
@@ -103,7 +124,13 @@ def convert_me(two_numbers, conversion_rate=50_000) -> str:
     extra = shlex.split(settings.extra) if settings.extra else []
     extra_both = shlex.split(settings.extra) if settings.extra and settings.extra_both_passes else []
 
-    if settings.single_pass:
+    if settings.lossless:
+        # Lossless mode — no rate control needed
+        command = beginning + extra + ending
+        return [Command(command=command, name="Single pass lossless", exe="ffmpeg")]
+
+    # SVT-AV1 does not support CRF with multi-pass
+    if settings.single_pass or (not settings.bitrate and settings.qp_mode == "crf"):
         if settings.bitrate:
             command_1 = beginning + ["-b:v", settings.bitrate] + extra + ending
 
diff --git a/fastflix/encoders/svt_av1/settings_panel.py b/fastflix/encoders/svt_av1/settings_panel.py
index 8012fada..e0c74d75 100644
--- a/fastflix/encoders/svt_av1/settings_panel.py
+++ b/fastflix/encoders/svt_av1/settings_panel.py
@@ -92,12 +92,21 @@ def __init__(self, parent, main, app: FastFlixApp):
         grid.addLayout(self.init_qp_or_crf(), 7, 0, 1, 2)
         grid.addLayout(self.init_sharpness(), 8, 0, 1, 2)
         grid.addLayout(self.init_fast_decode(), 9, 0, 1, 2)
+        grid.addLayout(self.init_enable_tf(), 10, 0, 1, 2)
+        grid.addLayout(self.init_startup_mg_size(), 11, 0, 1, 2)
+        grid.addLayout(self.init_variance_boost(), 9, 2, 1, 4)
+        grid.addLayout(self.init_variance_strength(), 10, 2, 1, 2)
+        grid.addLayout(self.init_variance_octile(), 10, 4, 1, 2)
+        grid.addLayout(self.init_enable_qm(), 11, 2, 1, 2)
+        grid.addLayout(self.init_qm_min(), 12, 2, 1, 2)
+        grid.addLayout(self.init_qm_max(), 12, 4, 1, 2)
         grid.addLayout(self.init_modes(), 0, 2, 5, 4)
         grid.addLayout(self.init_film_grain(), 5, 2, 1, 4)
         grid.addLayout(self.init_film_grain_denoise(), 6, 2, 1, 4)
         grid.addLayout(self.init_svtav1_params(), 7, 2, 1, 4)
+        grid.addLayout(self.init_lossless(), 8, 2, 1, 4)
 
-        grid.setRowStretch(12, 1)
+        grid.setRowStretch(13, 1)
         custom_layout = self._add_custom()
         guide_label = QtWidgets.QLabel(
             link(
@@ -165,8 +174,18 @@ def init_tune(self):
         return self._add_combo_box(
             label="Tune",
             widget_name="tune",
-            options=["0 - VQ (Psychovisual)", "1 - PSNR", "2 - SSIM"],
-            tooltip="Optimize encoding for different quality metrics",
+            options=[
+                "0 - VQ (Psychovisual)",
+                "1 - PSNR",
+                "2 - SSIM",
+                "3 - IQ (still image)",
+                "4 - MS-SSIM",
+                "5 - VMAF (video only)",
+            ],
+            tooltip=(
+                "Optimize encoding for different quality metrics.\n"
+                "Tunes 3-5 require a recent SVT-AV1 build (3.0+); older builds will fail."
+            ),
             opt="tune",
         )
 
@@ -188,6 +207,76 @@ def init_fast_decode(self):
             opt="fast_decode",
         )
 
+    def init_enable_tf(self):
+        return self._add_combo_box(
+            label="Temporal Filtering",
+            widget_name="enable_tf",
+            options=["0 - Off", "1 - On", "2 - Adaptive"],
+            tooltip="Enable ALT-REF (temporally filtered) frames (2 = adaptive requires a recent SVT-AV1 build)",
+            opt="enable_tf",
+        )
+
+    def init_startup_mg_size(self):
+        return self._add_combo_box(
+            label="Startup Mini-GOP",
+            widget_name="startup_mg_size",
+            options=["0 - Off", "2 - 3 temporal layers", "3 - 4 temporal layers", "4 - 5 temporal layers"],
+            tooltip="Alternate mini-gop configuration for the first mini-gop after a key frame",
+            opt="startup_mg_size",
+        )
+
+    def init_variance_boost(self):
+        return self._add_check_box(
+            label="Variance Boost",
+            widget_name="enable_variance_boost",
+            tooltip="Enable Variance Boost, improves quality in low-contrast areas (requires a recent SVT-AV1 build)",
+            opt="enable_variance_boost",
+        )
+
+    def init_variance_strength(self):
+        return self._add_combo_box(
+            label="Boost Strength",
+            widget_name="variance_boost_strength",
+            options=["1 - Mild", "2 - Gentle", "3 - Medium", "4 - Aggressive"],
+            tooltip="Variance curve strength for Variance Boost",
+            opt="variance_boost_strength",
+        )
+
+    def init_variance_octile(self):
+        return self._add_combo_box(
+            label="Boost Octile",
+            widget_name="variance_octile",
+            options=[str(x) for x in range(1, 9)],
+            tooltip="Variance algorithm 8x8 block selectivity (1=first octile, 4=median, 5=default, 8=maximum)",
+            opt="variance_octile",
+        )
+
+    def init_enable_qm(self):
+        return self._add_check_box(
+            label="Quantization Matrices",
+            widget_name="enable_qm",
+            tooltip="Enable quantization matrices",
+            opt="enable_qm",
+        )
+
+    def init_qm_min(self):
+        return self._add_combo_box(
+            label="QM Min",
+            widget_name="qm_min",
+            options=[str(x) for x in range(0, 16)],
+            tooltip="Minimum quantization matrix flatness (0-15, default 8)",
+            opt="qm_min",
+        )
+
+    def init_qm_max(self):
+        return self._add_combo_box(
+            label="QM Max",
+            widget_name="qm_max",
+            options=[str(x) for x in range(0, 16)],
+            tooltip="Maximum quantization matrix flatness (0-15, default 15)",
+            opt="qm_max",
+        )
+
     def init_film_grain(self):
         layout = QtWidgets.QHBoxLayout()
         self.labels.film_grain = QtWidgets.QLabel(t("Film Grain"))
@@ -234,6 +323,30 @@ def init_film_grain_denoise(self):
             opt="film_grain_denoise",
         )
 
+    def init_lossless(self):
+        layout = self._add_check_box(
+            label="Lossless",
+            widget_name="lossless",
+            tooltip=(
+                "Enable lossless encoding mode (requires SVT-AV1 3.0+; 3.1.1+ recommended for 10-bit).\n"
+                "Produces bit-exact output with no quality loss.\n"
+                "Rate control and film grain options are ignored in lossless mode."
+            ),
+            opt="lossless",
+            connect=lambda: (self._toggle_lossless(), self.main.page_update(build_thumbnail=False)),
+        )
+        return layout
+
+    def _toggle_lossless(self):
+        enabled = not self.widgets.lossless.isChecked()
+        self.qp_radio.setEnabled(enabled)
+        self.bitrate_radio.setEnabled(enabled)
+        self.widgets.qp.setEnabled(enabled)
+        self.widgets.custom_qp.setEnabled(enabled)
+        self.widgets.bitrate.setEnabled(enabled)
+        self.widgets.custom_bitrate.setEnabled(enabled)
+        self.widgets.qp_mode.setEnabled(enabled)
+
     def init_qp_or_crf(self):
         return self._add_combo_box(
             label="Quantization Mode",
@@ -301,7 +414,7 @@ def update_video_encoder_settings(self):
         film_grain_text = self.widgets.film_grain.currentText()
         if film_grain_text == "Custom":
             try:
-                film_grain = int(self.widgets.custom_film_grain.text())
+                film_grain = max(0, min(50, int(self.widgets.custom_film_grain.text())))
             except (ValueError, TypeError):
                 film_grain = 0
         else:
@@ -324,9 +437,18 @@ def update_video_encoder_settings(self):
             film_grain_denoise=self.widgets.film_grain_denoise.isChecked(),
             sharpness=self.widgets.sharpness.currentText(),
             fast_decode=self.widgets.fast_decode.currentText().split(" ")[0],
+            enable_variance_boost=self.widgets.enable_variance_boost.isChecked(),
+            variance_boost_strength=self.widgets.variance_boost_strength.currentText().split(" ")[0],
+            variance_octile=self.widgets.variance_octile.currentText(),
+            enable_tf=self.widgets.enable_tf.currentText().split(" ")[0],
+            startup_mg_size=self.widgets.startup_mg_size.currentText().split(" ")[0],
+            enable_qm=self.widgets.enable_qm.isChecked(),
+            qm_min=self.widgets.qm_min.currentText(),
+            qm_max=self.widgets.qm_max.currentText(),
             extra=self.ffmpeg_extras,
             extra_both_passes=self.widgets.extra_both_passes.isChecked(),
             svtav1_params=svtav1_params_text.split(":") if svtav1_params_text else [],
+            lossless=self.widgets.lossless.isChecked(),
         )
         encode_type, q_value = self.get_mode_settings()
         settings.qp = q_value if encode_type == "qp" else None
diff --git a/fastflix/encoders/svt_av1_avif/command_builder.py b/fastflix/encoders/svt_av1_avif/command_builder.py
index 12e185d3..74ffaeaf 100644
--- a/fastflix/encoders/svt_av1_avif/command_builder.py
+++ b/fastflix/encoders/svt_av1_avif/command_builder.py
@@ -6,6 +6,7 @@
 
 import reusables
 
+from fastflix.encoders.common.hdr_metadata import is_hdr_bit_depth
 from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details
 from fastflix.models.encode import SVTAVIFSettings
 from fastflix.models.fastflix import FastFlix
@@ -48,7 +49,7 @@ def build(fastflix: FastFlix):
             svtav1_params.append("matrix-coefficients=9")
 
         enable_hdr = False
-        if settings.pix_fmt in ("yuv420p10le", "yuv420p12le"):
+        if is_hdr_bit_depth(settings.pix_fmt):
 
             def convert_me(two_numbers, conversion_rate=50_000) -> str:
                 try:
diff --git a/fastflix/encoders/svt_av1_avif/settings_panel.py b/fastflix/encoders/svt_av1_avif/settings_panel.py
index 027d4d32..ff4e462e 100644
--- a/fastflix/encoders/svt_av1_avif/settings_panel.py
+++ b/fastflix/encoders/svt_av1_avif/settings_panel.py
@@ -117,8 +117,17 @@ def init_tune(self):
         return self._add_combo_box(
             label="Tune",
             widget_name="tune",
-            options=["0 - VQ (Psychovisual)", "1 - PSNR", "2 - SSIM"],
-            tooltip="Optimize encoding for different quality metrics",
+            options=[
+                "0 - VQ (Psychovisual)",
+                "1 - PSNR",
+                "2 - SSIM",
+                "3 - IQ (still image)",
+                "4 - MS-SSIM",
+            ],
+            tooltip=(
+                "Optimize encoding for different quality metrics.\n"
+                "Tunes 3-4 require a recent SVT-AV1 build (3.0+); older builds will fail."
+            ),
             opt="tune",
         )
 
diff --git a/fastflix/encoders/vaapi_h264/command_builder.py b/fastflix/encoders/vaapi_h264/command_builder.py
index 9d3da157..626cd927 100644
--- a/fastflix/encoders/vaapi_h264/command_builder.py
+++ b/fastflix/encoders/vaapi_h264/command_builder.py
@@ -5,6 +5,7 @@
 import shlex
 
 from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details
+from fastflix.encoders.common.vaapi import vaapi_level_args, vaapi_rate_control_args
 from fastflix.models.encode import VAAPIH264Settings
 from fastflix.models.fastflix import FastFlix
 
@@ -13,6 +14,8 @@
 
 def build(fastflix: FastFlix):
     settings: VAAPIH264Settings = fastflix.current_video.video_settings.video_encoder_settings
+    # Frames are decoded (hardware when possible, otherwise software) into system memory, filtered in software and
+    # uploaded with hwupload, so a source the GPU cannot decode still works.
     start_extra = [
         "-init_hw_device",
         f"vaapi=hwdev:{settings.vaapi_device}",
@@ -20,8 +23,6 @@ def build(fastflix: FastFlix):
         "vaapi",
         "-hwaccel_device",
         "hwdev",
-        "-hwaccel_output_format",
-        "vaapi",
     ]
     beginning, ending, output_fps = generate_all(
         fastflix,
@@ -33,8 +34,6 @@ def build(fastflix: FastFlix):
 
     beginning.extend(
         [
-            "-rc_mode",
-            str(settings.rc_mode),
             "-async_depth",
             str(settings.async_depth),
             "-b_depth",
@@ -50,54 +49,12 @@ def build(fastflix: FastFlix):
         beginning.extend(["-aud", "1"])
 
     if settings.low_power:
-        beginning.extend(["-low-power", "1"])
-
-    if settings.level:
-        beginning.extend(["-level", str(settings.level)])
-
-    # ffmpeg -init_hw_device vaapi=foo:/dev/dri/renderD128  -hwaccel_device foo -i input.mp4 -filter_hw_device foo -vf 'format=nv12|vaapi,hwupload'
+        beginning.extend(["-low_power", "1"])
 
-    # if not fastflix.current_video.video_settings.remove_hdr:
-
-    # Currently unsupported https://github.com/xiph/rav1e/issues/2554
-    #         rav1e_options = []
-    # if side_data.master_display:
-    #     rav1e_options.append(
-    #         "mastering-display="
-    #         f"G{side_data.master_display.green}"
-    #         f"B{side_data.master_display.blue}"
-    #         f"R{side_data.master_display.red}"
-    #         f"WP{side_data.master_display.white}"
-    #         f"L{side_data.master_display.luminance}"
-    #     )
-    #
-    # if side_data.cll:
-    #     rav1e_options.append(f"content-light={side_data.cll}")
-    # if rav1e_options:
-    #     opts = ":".join(rav1e_options)
-    #     beginning += f'-rav1e-params "{opts}"'
-    #
-    # if not settings.single_pass:
-    #     pass_log_file = fastflix.current_video.work_path / f"pass_log_file_{secrets.token_hex(10)}"
-    #     beginning += f'-passlogfile "{pass_log_file}" '
+    beginning.extend(vaapi_level_args(settings))
 
+    rate_control = vaapi_rate_control_args(settings, explicit_qp=True)
     pass_type = "bitrate" if settings.bitrate else "QP"
 
-    if not settings.bitrate:
-        command_1 = (
-            beginning + ["-qp", str(settings.qp)] + (shlex.split(settings.extra) if settings.extra else []) + ending
-        )
-        return [Command(command=command_1, name=f"{pass_type}", exe="ffmpeg")]
-
-    # if settings.single_pass:
-    command_1 = (
-        beginning + ["-b:v", settings.bitrate] + (shlex.split(settings.extra) if settings.extra else []) + ending
-    )
+    command_1 = beginning + rate_control + (shlex.split(settings.extra) if settings.extra else []) + ending
     return [Command(command=command_1, name=f"{pass_type}", exe="ffmpeg")]
-    # else:
-    #     command_1 = f"{beginning} -b:v {settings.bitrate} -pass 1 {settings.extra if settings.extra_both_passes else ''} -an -f matroska {null}"
-    #     command_2 = f"{beginning} -b:v {settings.bitrate} -pass 2 {settings.extra} {ending}"
-    #     return [
-    #         Command(command=command_1, name=f"First pass {pass_type}", exe="ffmpeg"),
-    #         Command(command=command_2, name=f"Second pass {pass_type} ", exe="ffmpeg"),
-    #     ]
diff --git a/fastflix/encoders/vaapi_hevc/command_builder.py b/fastflix/encoders/vaapi_hevc/command_builder.py
index ec67a27e..d4bb85db 100644
--- a/fastflix/encoders/vaapi_hevc/command_builder.py
+++ b/fastflix/encoders/vaapi_hevc/command_builder.py
@@ -4,7 +4,8 @@
 import logging
 import shlex
 
-from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details
+from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details, hevc_tag_args
+from fastflix.encoders.common.vaapi import vaapi_level_args, vaapi_rate_control_args, vaapi_sw_format
 from fastflix.models.encode import VAAPIHEVCSettings
 from fastflix.models.fastflix import FastFlix
 
@@ -13,6 +14,8 @@
 
 def build(fastflix: FastFlix):
     settings: VAAPIHEVCSettings = fastflix.current_video.video_settings.video_encoder_settings
+    # Frames are decoded (hardware when possible, otherwise software) into system memory, filtered in software and
+    # uploaded with hwupload, so a source the GPU cannot decode still works.
     start_extra = [
         "-init_hw_device",
         f"vaapi=hwdev:{settings.vaapi_device}",
@@ -20,8 +23,6 @@ def build(fastflix: FastFlix):
         "vaapi",
         "-hwaccel_device",
         "hwdev",
-        "-hwaccel_output_format",
-        "vaapi",
     ]
     beginning, ending, output_fps = generate_all(
         fastflix,
@@ -29,12 +30,11 @@ def build(fastflix: FastFlix):
         start_extra=start_extra,
         enable_opencl=False,
         vaapi=True,
+        vaapi_format=vaapi_sw_format(settings.bit_depth),
     )
 
     beginning.extend(
         [
-            "-rc_mode",
-            str(settings.rc_mode),
             "-async_depth",
             str(settings.async_depth),
             "-b_depth",
@@ -43,6 +43,7 @@ def build(fastflix: FastFlix):
             str(settings.idr_interval),
         ]
     )
+    beginning.extend(hevc_tag_args(fastflix.current_video.video_settings.output_path))
     beginning.extend(generate_color_details(fastflix))
     beginning.extend(["-filter_hw_device", "hwdev"])
 
@@ -50,54 +51,14 @@ def build(fastflix: FastFlix):
         beginning.extend(["-aud", "1"])
 
     if settings.low_power:
-        beginning.extend(["-low-power", "1"])
-
-    if settings.level:
-        beginning.extend(["-level", str(settings.level)])
-
-    # ffmpeg -init_hw_device vaapi=foo:/dev/dri/renderD128  -hwaccel_device foo -i input.mp4 -filter_hw_device foo -vf 'format=nv12|vaapi,hwupload'
+        beginning.extend(["-low_power", "1"])
 
-    # if not fastflix.current_video.video_settings.remove_hdr:
+    beginning.extend(vaapi_level_args(settings))
 
-    # Currently unsupported https://github.com/xiph/rav1e/issues/2554
-    #         rav1e_options = []
-    # if side_data.master_display:
-    #     rav1e_options.append(
-    #         "mastering-display="
-    #         f"G{side_data.master_display.green}"
-    #         f"B{side_data.master_display.blue}"
-    #         f"R{side_data.master_display.red}"
-    #         f"WP{side_data.master_display.white}"
-    #         f"L{side_data.master_display.luminance}"
-    #     )
-    #
-    # if side_data.cll:
-    #     rav1e_options.append(f"content-light={side_data.cll}")
-    # if rav1e_options:
-    #     opts = ":".join(rav1e_options)
-    #     beginning += f'-rav1e-params "{opts}"'
-    #
-    # if not settings.single_pass:
-    #     pass_log_file = fastflix.current_video.work_path / f"pass_log_file_{secrets.token_hex(10)}"
-    #     beginning += f'-passlogfile "{pass_log_file}" '
+    beginning.extend(["-profile:v", "main10" if vaapi_sw_format(settings.bit_depth) == "p010le" else "main"])
 
+    rate_control = vaapi_rate_control_args(settings, explicit_qp=True)
     pass_type = "bitrate" if settings.bitrate else "QP"
 
-    if not settings.bitrate:
-        command_1 = (
-            beginning + ["-qp", str(settings.qp)] + (shlex.split(settings.extra) if settings.extra else []) + ending
-        )
-        return [Command(command=command_1, name=f"{pass_type}", exe="ffmpeg")]
-
-    # if settings.single_pass:
-    command_1 = (
-        beginning + ["-b:v", settings.bitrate] + (shlex.split(settings.extra) if settings.extra else []) + ending
-    )
+    command_1 = beginning + rate_control + (shlex.split(settings.extra) if settings.extra else []) + ending
     return [Command(command=command_1, name=f"{pass_type}", exe="ffmpeg")]
-    # else:
-    #     command_1 = f"{beginning} -b:v {settings.bitrate} -pass 1 {settings.extra if settings.extra_both_passes else ''} -an -f matroska {null}"
-    #     command_2 = f"{beginning} -b:v {settings.bitrate} -pass 2 {settings.extra} {ending}"
-    #     return [
-    #         Command(command=command_1, name=f"First pass {pass_type}", exe="ffmpeg"),
-    #         Command(command=command_2, name=f"Second pass {pass_type} ", exe="ffmpeg"),
-    #     ]
diff --git a/fastflix/encoders/vaapi_hevc/settings_panel.py b/fastflix/encoders/vaapi_hevc/settings_panel.py
index 4a4e25ab..70f110e7 100644
--- a/fastflix/encoders/vaapi_hevc/settings_panel.py
+++ b/fastflix/encoders/vaapi_hevc/settings_panel.py
@@ -41,6 +41,7 @@ def __init__(self, parent, main, app: FastFlixApp):
         # grid.addLayout(self.init_tile_rows(), 2, 0, 1, 2) # profile
         grid.addLayout(self.init_level(), 2, 0, 1, 2)
         grid.addLayout(self.init_max_mux(), 3, 0, 1, 2)
+        grid.addLayout(self.init_bit_depth(), 4, 0, 1, 2)
 
         grid.addLayout(self.init_modes(), 0, 2, 5, 4)
         # grid.addLayout(self.init_vaapi_device(), 5, 2, 1, 1)
@@ -88,6 +89,7 @@ def update_video_encoder_settings(self):
             b_depth=self.widgets.b_depth.text(),
             async_depth=self.widgets.async_depth.currentText(),
             aud=self.widgets.aud.isChecked(),
+            bit_depth=self.widgets.bit_depth.currentText(),
             level=None if self.widgets.level.currentIndex() == 0 else self.widgets.level.currentText(),
             rc_mode=self.widgets.rc_mode.currentText(),
         )
diff --git a/fastflix/encoders/vaapi_mpeg2/command_builder.py b/fastflix/encoders/vaapi_mpeg2/command_builder.py
index 77025762..3b269d50 100644
--- a/fastflix/encoders/vaapi_mpeg2/command_builder.py
+++ b/fastflix/encoders/vaapi_mpeg2/command_builder.py
@@ -5,6 +5,7 @@
 import shlex
 
 from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details
+from fastflix.encoders.common.vaapi import vaapi_rate_control_args
 from fastflix.models.encode import VAAPIMPEG2Settings
 from fastflix.models.fastflix import FastFlix
 
@@ -13,6 +14,8 @@
 
 def build(fastflix: FastFlix):
     settings: VAAPIMPEG2Settings = fastflix.current_video.video_settings.video_encoder_settings
+    # Frames are decoded (hardware when possible, otherwise software) into system memory, filtered in software and
+    # uploaded with hwupload, so a source the GPU cannot decode still works.
     start_extra = [
         "-init_hw_device",
         f"vaapi=hwdev:{settings.vaapi_device}",
@@ -20,8 +23,6 @@ def build(fastflix: FastFlix):
         "vaapi",
         "-hwaccel_device",
         "hwdev",
-        "-hwaccel_output_format",
-        "vaapi",
     ]
     beginning, ending, output_fps = generate_all(
         fastflix,
@@ -33,8 +34,6 @@ def build(fastflix: FastFlix):
 
     beginning.extend(
         [
-            "-rc_mode",
-            str(settings.rc_mode),
             "-b_depth",
             str(settings.b_depth),
             "-idr_interval",
@@ -45,51 +44,10 @@ def build(fastflix: FastFlix):
     beginning.extend(["-filter_hw_device", "hwdev"])
 
     if settings.low_power:
-        beginning.extend(["-low-power", "1"])
-
-    # ffmpeg -init_hw_device vaapi=foo:/dev/dri/renderD128  -hwaccel_device foo -i input.mp4 -filter_hw_device foo -vf 'format=nv12|vaapi,hwupload'
-
-    # if not fastflix.current_video.video_settings.remove_hdr:
-
-    # Currently unsupported https://github.com/xiph/rav1e/issues/2554
-    #         rav1e_options = []
-    # if side_data.master_display:
-    #     rav1e_options.append(
-    #         "mastering-display="
-    #         f"G{side_data.master_display.green}"
-    #         f"B{side_data.master_display.blue}"
-    #         f"R{side_data.master_display.red}"
-    #         f"WP{side_data.master_display.white}"
-    #         f"L{side_data.master_display.luminance}"
-    #     )
-    #
-    # if side_data.cll:
-    #     rav1e_options.append(f"content-light={side_data.cll}")
-    # if rav1e_options:
-    #     opts = ":".join(rav1e_options)
-    #     beginning += f'-rav1e-params "{opts}"'
-    #
-    # if not settings.single_pass:
-    #     pass_log_file = fastflix.current_video.work_path / f"pass_log_file_{secrets.token_hex(10)}"
-    #     beginning += f'-passlogfile "{pass_log_file}" '
+        beginning.extend(["-low_power", "1"])
 
+    rate_control = vaapi_rate_control_args(settings, explicit_qp=False)
     pass_type = "bitrate" if settings.bitrate else "QP"
 
-    if not settings.bitrate:
-        command_1 = (
-            beginning + ["-qp", str(settings.qp)] + (shlex.split(settings.extra) if settings.extra else []) + ending
-        )
-        return [Command(command=command_1, name=f"{pass_type}", exe="ffmpeg")]
-
-    # if settings.single_pass:
-    command_1 = (
-        beginning + ["-b:v", settings.bitrate] + (shlex.split(settings.extra) if settings.extra else []) + ending
-    )
+    command_1 = beginning + rate_control + (shlex.split(settings.extra) if settings.extra else []) + ending
     return [Command(command=command_1, name=f"{pass_type}", exe="ffmpeg")]
-    # else:
-    #     command_1 = f"{beginning} -b:v {settings.bitrate} -pass 1 {settings.extra if settings.extra_both_passes else ''} -an -f matroska {null}"
-    #     command_2 = f"{beginning} -b:v {settings.bitrate} -pass 2 {settings.extra} {ending}"
-    #     return [
-    #         Command(command=command_1, name=f"First pass {pass_type}", exe="ffmpeg"),
-    #         Command(command=command_2, name=f"Second pass {pass_type} ", exe="ffmpeg"),
-    #     ]
diff --git a/fastflix/encoders/vaapi_vp9/command_builder.py b/fastflix/encoders/vaapi_vp9/command_builder.py
index 5d84e9db..d19f5b2f 100644
--- a/fastflix/encoders/vaapi_vp9/command_builder.py
+++ b/fastflix/encoders/vaapi_vp9/command_builder.py
@@ -5,6 +5,7 @@
 import shlex
 
 from fastflix.encoders.common.helpers import Command, generate_all, generate_color_details
+from fastflix.encoders.common.vaapi import vaapi_rate_control_args, vaapi_sw_format
 from fastflix.models.encode import VAAPIVP9Settings
 from fastflix.models.fastflix import FastFlix
 
@@ -13,6 +14,8 @@
 
 def build(fastflix: FastFlix):
     settings: VAAPIVP9Settings = fastflix.current_video.video_settings.video_encoder_settings
+    # Frames are decoded (hardware when possible, otherwise software) into system memory, filtered in software and
+    # uploaded with hwupload, so a source the GPU cannot decode still works.
     start_extra = [
         "-init_hw_device",
         f"vaapi=hwdev:{settings.vaapi_device}",
@@ -20,8 +23,6 @@ def build(fastflix: FastFlix):
         "vaapi",
         "-hwaccel_device",
         "hwdev",
-        "-hwaccel_output_format",
-        "vaapi",
     ]
     beginning, ending, output_fps = generate_all(
         fastflix,
@@ -29,12 +30,11 @@ def build(fastflix: FastFlix):
         start_extra=start_extra,
         enable_opencl=False,
         vaapi=True,
+        vaapi_format=vaapi_sw_format(settings.bit_depth),
     )
 
     beginning.extend(
         [
-            "-rc_mode",
-            str(settings.rc_mode),
             "-b_depth",
             str(settings.b_depth),
             "-idr_interval",
@@ -45,51 +45,12 @@ def build(fastflix: FastFlix):
     beginning.extend(["-filter_hw_device", "hwdev"])
 
     if settings.low_power:
-        beginning.extend(["-low-power", "1"])
-
-    # ffmpeg -init_hw_device vaapi=foo:/dev/dri/renderD128  -hwaccel_device foo -i input.mp4 -filter_hw_device foo -vf 'format=nv12|vaapi,hwupload'
-
-    # if not fastflix.current_video.video_settings.remove_hdr:
+        beginning.extend(["-low_power", "1"])
 
-    # Currently unsupported https://github.com/xiph/rav1e/issues/2554
-    #         rav1e_options = []
-    # if side_data.master_display:
-    #     rav1e_options.append(
-    #         "mastering-display="
-    #         f"G{side_data.master_display.green}"
-    #         f"B{side_data.master_display.blue}"
-    #         f"R{side_data.master_display.red}"
-    #         f"WP{side_data.master_display.white}"
-    #         f"L{side_data.master_display.luminance}"
-    #     )
-    #
-    # if side_data.cll:
-    #     rav1e_options.append(f"content-light={side_data.cll}")
-    # if rav1e_options:
-    #     opts = ":".join(rav1e_options)
-    #     beginning += f'-rav1e-params "{opts}"'
-    #
-    # if not settings.single_pass:
-    #     pass_log_file = fastflix.current_video.work_path / f"pass_log_file_{secrets.token_hex(10)}"
-    #     beginning += f'-passlogfile "{pass_log_file}" '
+    beginning.extend(["-profile:v", "2" if vaapi_sw_format(settings.bit_depth) == "p010le" else "0"])
 
+    rate_control = vaapi_rate_control_args(settings, explicit_qp=False)
     pass_type = "bitrate" if settings.bitrate else "QP"
 
-    if not settings.bitrate:
-        command_1 = (
-            beginning + ["-qp", str(settings.qp)] + (shlex.split(settings.extra) if settings.extra else []) + ending
-        )
-        return [Command(command=command_1, name=f"{pass_type}", exe="ffmpeg")]
-
-    # if settings.single_pass:
-    command_1 = (
-        beginning + ["-b:v", settings.bitrate] + (shlex.split(settings.extra) if settings.extra else []) + ending
-    )
+    command_1 = beginning + rate_control + (shlex.split(settings.extra) if settings.extra else []) + ending
     return [Command(command=command_1, name=f"{pass_type}", exe="ffmpeg")]
-    # else:
-    #     command_1 = f"{beginning} -b:v {settings.bitrate} -pass 1 {settings.extra if settings.extra_both_passes else ''} -an -f matroska {null}"
-    #     command_2 = f"{beginning} -b:v {settings.bitrate} -pass 2 {settings.extra} {ending}"
-    #     return [
-    #         Command(command=command_1, name=f"First pass {pass_type}", exe="ffmpeg"),
-    #         Command(command=command_2, name=f"Second pass {pass_type} ", exe="ffmpeg"),
-    #     ]
diff --git a/fastflix/encoders/vaapi_vp9/settings_panel.py b/fastflix/encoders/vaapi_vp9/settings_panel.py
index 5bd88686..9d12899d 100644
--- a/fastflix/encoders/vaapi_vp9/settings_panel.py
+++ b/fastflix/encoders/vaapi_vp9/settings_panel.py
@@ -39,6 +39,7 @@ def __init__(self, parent, main, app: FastFlixApp):
 
         grid.addLayout(self.init_rc_mode(), 1, 0, 1, 2)
         grid.addLayout(self.init_max_mux(), 2, 0, 1, 2)
+        grid.addLayout(self.init_bit_depth(), 3, 0, 1, 2)
 
         grid.addLayout(self.init_modes(), 0, 2, 5, 4)
         # grid.addLayout(self.init_vaapi_device(), 5, 2, 1, 1)
@@ -79,6 +80,7 @@ def update_video_encoder_settings(self):
             low_power=self.widgets.low_power.isChecked(),
             idr_interval=self.widgets.idr_interval.text(),
             b_depth=self.widgets.b_depth.text(),
+            bit_depth=self.widgets.bit_depth.currentText(),
             rc_mode=self.widgets.rc_mode.currentText(),
         )
         encode_type, q_value = self.get_mode_settings()
diff --git a/fastflix/encoders/vceencc_av1/command_builder.py b/fastflix/encoders/vceencc_av1/command_builder.py
index 83657803..b710f7f9 100644
--- a/fastflix/encoders/vceencc_av1/command_builder.py
+++ b/fastflix/encoders/vceencc_av1/command_builder.py
@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 import logging
-import shlex
 
 from fastflix.encoders.common.helpers import Command
 from fastflix.models.encode import VCEEncCAV1Settings
@@ -13,7 +12,11 @@
     rigaya_auto_options,
     rigaya_avformat_reader,
     rigaya_trim_or_seek,
+    rigaya_extra_options,
+    split_extra_args,
+    rigaya_hdr_static_metadata,
     pa_builder,
+    qvbr_quality_value,
 )
 
 logger = logging.getLogger("fastflix")
@@ -52,7 +55,7 @@ def build(fastflix: FastFlix):
     command.extend(["--device", str(settings.device)])
     command.extend(["-i", str(video.source)])
 
-    if stream_id:
+    if stream_id is not None:
         command.extend(["--video-streamid", str(stream_id)])
     command.extend(rigaya_trim_or_seek(video))
     if video.video_settings.source_fps:
@@ -63,11 +66,11 @@ def build(fastflix: FastFlix):
         flip_x = "true" if video.video_settings.horizontal_flip else "false"
         flip_y = "true" if video.video_settings.vertical_flip else "false"
         command.extend(["--vpp-transform", f"flip_x={flip_x},flip_y={flip_y}"])
-    if video.scale:
-        command.extend(["--output-res", video.scale.replace(":", "x")])
     if video.video_settings.crop:
         crop = video.video_settings.crop
         command.extend(["--crop", f"{crop.left},{crop.top},{crop.right},{crop.bottom}"])
+    if video.output_width is not None and video.output_height is not None:
+        command.extend(["--output-res", f"{video.output_width}x{video.output_height}"])
 
     if video.video_settings.remove_metadata:
         command.extend(["--video-metadata", "clear", "--metadata", "clear"])
@@ -77,13 +80,18 @@ def build(fastflix: FastFlix):
         command.extend(["--video-metadata", "copy", "--metadata", "copy"])
 
     if video.video_settings.video_title:
-        command.extend(["--video-metadata", f"title={video.video_settings.video_title}"])
+        command.extend(["--metadata", f"title={video.video_settings.video_title}"])
     if video.video_settings.copy_chapters:
         command.append("--chapter-copy")
 
     command.extend(["-c", "av1"])
 
-    if settings.bitrate:
+    qvbr = qvbr_quality_value(settings)
+    if not qvbr and settings.bitrate_mode == "qvbr":
+        qvbr = "23"
+    if qvbr:
+        command.extend(["--qvbr", qvbr])
+    elif settings.bitrate:
         command.extend([f"--{settings.bitrate_mode}", settings.bitrate.rstrip("k")])
     else:
         command.extend(["--cqp", str(settings.cqp)])
@@ -91,10 +99,12 @@ def build(fastflix: FastFlix):
     if video.video_settings.maxrate:
         command.extend(["--max-bitrate", str(video.video_settings.maxrate)])
         command.extend(["--vbv-bufsize", str(video.video_settings.bufsize)])
-    if settings.min_q and settings.bitrate:
+    if settings.min_q and (settings.bitrate or qvbr):
         command.extend(["--qp-min", str(settings.min_q)])
-    if settings.max_q and settings.bitrate:
+    if settings.max_q and (settings.bitrate or qvbr):
         command.extend(["--qp-max", str(settings.max_q)])
+    if settings.b_frames:
+        command.extend(["--bframes", str(settings.b_frames)])
     if settings.ref:
         command.extend(["--ref", str(settings.ref)])
 
@@ -103,16 +113,7 @@ def build(fastflix: FastFlix):
 
     command.extend(rigaya_auto_options(fastflix))
 
-    if fastflix.current_video.master_display:
-        md = fastflix.current_video.master_display
-        command.extend(
-            [
-                "--master-display",
-                f"G{md.green}B{md.blue}R{md.red}WP{md.white}L{md.luminance}",
-            ]
-        )
-    if fastflix.current_video.cll:
-        command.extend(["--max-cll", str(fastflix.current_video.cll)])
+    command.extend(rigaya_hdr_static_metadata(fastflix))
     if settings.copy_hdr10 and not video.video_settings.remove_hdr:
         command.extend(["--dhdr10-info", "copy"])
     if settings.copy_dv and not video.video_settings.remove_hdr:
@@ -122,16 +123,12 @@ def build(fastflix: FastFlix):
             command.extend(["--dolby-vision-rpu-prm", "crop=true"])
 
     command.extend(["--output-depth", output_depth])
-    command.extend(["--motion-est", settings.mv_precision])
-
-    if settings.vbaq:
-        command.append("--vbaq")
     if settings.pre_encode:
         command.append("--pe")
 
     pa = pa_builder(settings)
     if pa:
-        command.append(pa)
+        command.extend(pa)
 
     command.extend(["--avsync", vsync_setting])
 
@@ -139,13 +136,17 @@ def build(fastflix: FastFlix):
         command.extend(["--interlace", video.interlaced])
     if video.video_settings.deinterlace:
         command.append("--vpp-nnedi")
+    hdr2sdr_param = None
     if video.video_settings.remove_hdr:
         remove_type = (
             video.video_settings.tone_map
             if video.video_settings.tone_map in ("mobius", "hable", "reinhard")
             else "mobius"
         )
-        command.extend(["--vpp-colorspace", f"hdr2sdr={remove_type}"])
+        hdr2sdr_param = f"hdr2sdr={remove_type}"
+
+    command.extend(rigaya_extra_options(video, hdr2sdr=hdr2sdr_param))
+
     if settings.split_mode == "parallel":
         command.extend(["--parallel", "auto"])
     if settings.metrics:
@@ -154,11 +155,16 @@ def build(fastflix: FastFlix):
     command.extend(build_audio(video.audio_tracks, video.streams.audio))
     command.extend(build_subtitle(video.subtitle_tracks, video.streams.subtitle, video_height=video.height))
     command.extend(
-        build_data(video.data_tracks, getattr(video.streams, "data", []), getattr(video.streams, "attachment", []))
+        build_data(
+            video.data_tracks,
+            getattr(video.streams, "data", []),
+            getattr(video.streams, "attachment", []),
+            video.video_settings.output_path,
+        )
     )
 
     if settings.extra:
-        command.extend(shlex.split(settings.extra))
+        command.extend(split_extra_args(settings.extra))
 
     command.extend(["-o", str(video.video_settings.output_path)])
 
diff --git a/fastflix/encoders/vceencc_av1/settings_panel.py b/fastflix/encoders/vceencc_av1/settings_panel.py
index 776d117e..4b018d2a 100644
--- a/fastflix/encoders/vceencc_av1/settings_panel.py
+++ b/fastflix/encoders/vceencc_av1/settings_panel.py
@@ -78,7 +78,6 @@ def __init__(self, parent, main, app: FastFlixApp):
         custom_layout = self._add_custom(title="Custom VCEEncC options", disable_both_passes=True)
         grid.addLayout(self.init_preset(), 0, 0, 1, 2)
         grid.addLayout(self.init_bitrate_mode(), 1, 0, 1, 2)
-        grid.addLayout(self.init_mv_precision(), 2, 0, 1, 2)
         grid.addLayout(self.init_output_depth(), 3, 0, 1, 2)
         grid.addLayout(self.init_pre(), 4, 0, 1, 2)
 
@@ -99,11 +98,15 @@ def __init__(self, parent, main, app: FastFlixApp):
         qp_line.addStretch(1)
         qp_line.addLayout(self.init_ref())
         qp_line.addStretch(1)
+        qp_line.addLayout(self.init_b_frames())
+        qp_line.addStretch(1)
         qp_line.addLayout(self.init_level())
         qp_line.addStretch(1)
         qp_line.addLayout(self.init_decoder())
         qp_line.addStretch(1)
         qp_line.addLayout(self.init_metrics())
+        qp_line.addStretch(1)
+        qp_line.addLayout(self.init_qvbr_quality())
         grid.addLayout(qp_line, 6, 0, 1, 6)
 
         self.init_pa_row()
@@ -155,11 +158,6 @@ def init_preset(self):
 
     def init_pre(self):
         layout = QtWidgets.QHBoxLayout()
-        layout.addLayout(
-            self._add_check_box(
-                label="VBAQ", widget_name="vbaq", opt="vbaq", tooltip="Variance Based Adaptive Quantization"
-            )
-        )
         layout.addLayout(self._add_check_box(label="Pre Encode", widget_name="pre_encode", opt="pre_encode"))
         layout.addLayout(
             self._add_check_box(
@@ -168,13 +166,23 @@ def init_pre(self):
         )
         return layout
 
-    def init_mv_precision(self):
+    def init_qvbr_quality(self):
         return self._add_combo_box(
-            label="Motion vector accuracy",
-            tooltip="Q-pel is highest precision",
-            widget_name="mv_precision",
-            options=["q-pel", "half-pel", "full-pel"],
-            opt="mv_precision",
+            label="QVBR Quality",
+            widget_name="qvbr_quality",
+            tooltip="Quality based VBR (--qvbr), lower is higher quality. Replaces the Bitrate or QP selection above.\nOff uses the selected rate control mode",
+            options=["off"] + [str(x) for x in range(1, 52)],
+            opt="qvbr_quality",
+            min_width=60,
+        )
+
+    def init_b_frames(self):
+        return self._add_combo_box(
+            widget_name="b_frames",
+            label="B Frames",
+            options=[t("Auto")] + [str(x) for x in range(3)],
+            opt="b_frames",
+            min_width=60,
         )
 
     def init_level(self):
@@ -229,7 +237,7 @@ def init_bitrate_mode(self):
         layout.addWidget(
             self._add_combo_box(
                 widget_name="bitrate_mode",
-                options=["vbr", "cbr", "cbrhq", "vbrhq", "qvbr"],
+                options=["vbr", "cbr", "cbrhq", "vbrhq"],
                 min_width=45,
                 opt="bitrate_mode",
             )
@@ -275,16 +283,16 @@ def setting_change(self, update=True):
     def update_video_encoder_settings(self):
         settings = VCEEncCAV1Settings(
             preset=self.widgets.preset.currentText().split("-")[0].strip(),
-            mv_precision=self.widgets.mv_precision.currentText(),
             max_q=self.widgets.max_q.currentText() if self.widgets.max_q.currentIndex() != 0 else None,
             min_q=self.widgets.min_q.currentText() if self.widgets.min_q.currentIndex() != 0 else None,
             extra=self.ffmpeg_extras,
+            qvbr_quality=self.widgets.qvbr_quality.currentText(),
             metrics=self.widgets.metrics.isChecked(),
             level=self.widgets.level.currentText() if self.widgets.level.currentIndex() != 0 else None,
             ref=self.widgets.ref.currentText() if self.widgets.ref.currentIndex() != 0 else None,
+            b_frames=self.widgets.b_frames.currentText() if self.widgets.b_frames.currentIndex() != 0 else None,
             pre_encode=self.widgets.pre_encode.isChecked(),
             pre_analysis=self.widgets.pre_analysis.isChecked(),
-            vbaq=self.widgets.vbaq.isChecked(),
             decoder=self.widgets.decoder.currentText(),
             copy_hdr10=self.widgets.copy_hdr10.isChecked(),
             copy_dv=self.widgets.copy_dv.isChecked(),
diff --git a/fastflix/encoders/vceencc_avc/command_builder.py b/fastflix/encoders/vceencc_avc/command_builder.py
index 933f2d88..130ff0f7 100644
--- a/fastflix/encoders/vceencc_avc/command_builder.py
+++ b/fastflix/encoders/vceencc_avc/command_builder.py
@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 import logging
-import shlex
 
 from fastflix.encoders.common.helpers import Command
 from fastflix.models.encode import VCEEncCAVCSettings
@@ -13,7 +12,10 @@
     rigaya_auto_options,
     rigaya_avformat_reader,
     rigaya_trim_or_seek,
+    rigaya_extra_options,
+    split_extra_args,
     pa_builder,
+    qvbr_quality_value,
 )
 
 logger = logging.getLogger("fastflix")
@@ -52,7 +54,7 @@ def build(fastflix: FastFlix):
     command.extend(["--device", str(settings.device)])
     command.extend(["-i", str(video.source)])
 
-    if stream_id:
+    if stream_id is not None:
         command.extend(["--video-streamid", str(stream_id)])
     command.extend(rigaya_trim_or_seek(video))
     if video.video_settings.source_fps:
@@ -63,11 +65,11 @@ def build(fastflix: FastFlix):
         flip_x = "true" if video.video_settings.horizontal_flip else "false"
         flip_y = "true" if video.video_settings.vertical_flip else "false"
         command.extend(["--vpp-transform", f"flip_x={flip_x},flip_y={flip_y}"])
-    if video.scale:
-        command.extend(["--output-res", video.scale.replace(":", "x")])
     if video.video_settings.crop:
         crop = video.video_settings.crop
         command.extend(["--crop", f"{crop.left},{crop.top},{crop.right},{crop.bottom}"])
+    if video.output_width is not None and video.output_height is not None:
+        command.extend(["--output-res", f"{video.output_width}x{video.output_height}"])
 
     if video.video_settings.remove_metadata:
         command.extend(["--video-metadata", "clear", "--metadata", "clear"])
@@ -75,13 +77,16 @@ def build(fastflix: FastFlix):
         command.extend(["--video-metadata", "copy", "--metadata", "copy"])
 
     if video.video_settings.video_title:
-        command.extend(["--video-metadata", f"title={video.video_settings.video_title}"])
+        command.extend(["--metadata", f"title={video.video_settings.video_title}"])
     if video.video_settings.copy_chapters:
         command.append("--chapter-copy")
 
     command.extend(["-c", "avc"])
 
-    if settings.bitrate:
+    qvbr = qvbr_quality_value(settings)
+    if qvbr:
+        command.extend(["--qvbr", qvbr])
+    elif settings.bitrate:
         command.extend(["--vbr", settings.bitrate.rstrip("k")])
     else:
         command.extend(["--cqp", str(settings.cqp)])
@@ -89,9 +94,9 @@ def build(fastflix: FastFlix):
     if video.video_settings.maxrate:
         command.extend(["--max-bitrate", str(video.video_settings.maxrate)])
         command.extend(["--vbv-bufsize", str(video.video_settings.bufsize)])
-    if settings.min_q and settings.bitrate:
+    if settings.min_q and (settings.bitrate or qvbr):
         command.extend(["--qp-min", str(settings.min_q)])
-    if settings.max_q and settings.bitrate:
+    if settings.max_q and (settings.bitrate or qvbr):
         command.extend(["--qp-max", str(settings.max_q)])
     if settings.b_frames:
         command.extend(["--bframes", str(settings.b_frames)])
@@ -117,7 +122,7 @@ def build(fastflix: FastFlix):
 
     pa = pa_builder(settings)
     if pa:
-        command.append(pa)
+        command.extend(pa)
 
     command.extend(["--avsync", vsync_setting])
 
@@ -125,13 +130,17 @@ def build(fastflix: FastFlix):
         command.extend(["--interlace", video.interlaced])
     if video.video_settings.deinterlace:
         command.append("--vpp-nnedi")
+    hdr2sdr_param = None
     if video.video_settings.remove_hdr:
         remove_type = (
             video.video_settings.tone_map
             if video.video_settings.tone_map in ("mobius", "hable", "reinhard")
             else "mobius"
         )
-        command.extend(["--vpp-colorspace", f"hdr2sdr={remove_type}"])
+        hdr2sdr_param = f"hdr2sdr={remove_type}"
+
+    command.extend(rigaya_extra_options(video, hdr2sdr=hdr2sdr_param))
+
     if settings.split_mode == "parallel":
         command.extend(["--parallel", "auto"])
     if settings.metrics:
@@ -140,11 +149,16 @@ def build(fastflix: FastFlix):
     command.extend(build_audio(video.audio_tracks, video.streams.audio))
     command.extend(build_subtitle(video.subtitle_tracks, video.streams.subtitle, video_height=video.height))
     command.extend(
-        build_data(video.data_tracks, getattr(video.streams, "data", []), getattr(video.streams, "attachment", []))
+        build_data(
+            video.data_tracks,
+            getattr(video.streams, "data", []),
+            getattr(video.streams, "attachment", []),
+            video.video_settings.output_path,
+        )
     )
 
     if settings.extra:
-        command.extend(shlex.split(settings.extra))
+        command.extend(split_extra_args(settings.extra))
 
     command.extend(["-o", str(video.video_settings.output_path)])
 
diff --git a/fastflix/encoders/vceencc_avc/settings_panel.py b/fastflix/encoders/vceencc_avc/settings_panel.py
index de142e1e..92d6a4b3 100644
--- a/fastflix/encoders/vceencc_avc/settings_panel.py
+++ b/fastflix/encoders/vceencc_avc/settings_panel.py
@@ -106,6 +106,8 @@ def __init__(self, parent, main, app: FastFlixApp):
         qp_line.addLayout(self.init_decoder())
         qp_line.addStretch(1)
         qp_line.addLayout(self.init_metrics())
+        qp_line.addStretch(1)
+        qp_line.addLayout(self.init_qvbr_quality())
         grid.addLayout(qp_line, 6, 0, 1, 6)
 
         self.init_pa_row()
@@ -225,6 +227,16 @@ def init_max_q(self):
         )
         return layout
 
+    def init_qvbr_quality(self):
+        return self._add_combo_box(
+            label="QVBR Quality",
+            widget_name="qvbr_quality",
+            tooltip="Quality based VBR (--qvbr), lower is higher quality. Replaces the Bitrate or QP selection above.\nOff uses the selected rate control mode",
+            options=["off"] + [str(x) for x in range(1, 52)],
+            opt="qvbr_quality",
+            min_width=60,
+        )
+
     def init_b_frames(self):
         return self._add_combo_box(
             widget_name="b_frames",
@@ -276,6 +288,7 @@ def update_video_encoder_settings(self):
             max_q=self.widgets.max_q.currentText() if self.widgets.max_q.currentIndex() != 0 else None,
             min_q=self.widgets.min_q.currentText() if self.widgets.min_q.currentIndex() != 0 else None,
             extra=self.ffmpeg_extras,
+            qvbr_quality=self.widgets.qvbr_quality.currentText(),
             metrics=self.widgets.metrics.isChecked(),
             level=self.widgets.level.currentText() if self.widgets.level.currentIndex() != 0 else None,
             b_frames=self.widgets.b_frames.currentText() if self.widgets.b_frames.currentIndex() != 0 else None,
diff --git a/fastflix/encoders/vceencc_hevc/command_builder.py b/fastflix/encoders/vceencc_hevc/command_builder.py
index 496cc54a..778432a1 100644
--- a/fastflix/encoders/vceencc_hevc/command_builder.py
+++ b/fastflix/encoders/vceencc_hevc/command_builder.py
@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 import logging
-import shlex
 
 from fastflix.encoders.common.helpers import Command
 from fastflix.models.encode import VCEEncCSettings
@@ -13,6 +12,9 @@
     rigaya_avformat_reader,
     rigaya_auto_options,
     rigaya_trim_or_seek,
+    rigaya_extra_options,
+    split_extra_args,
+    rigaya_hdr_static_metadata,
     pa_builder,
 )
 
@@ -52,7 +54,7 @@ def build(fastflix: FastFlix):
     command.extend(["--device", str(settings.device)])
     command.extend(["-i", str(video.source)])
 
-    if stream_id:
+    if stream_id is not None:
         command.extend(["--video-streamid", str(stream_id)])
     command.extend(rigaya_trim_or_seek(video))
     if video.video_settings.source_fps:
@@ -63,11 +65,11 @@ def build(fastflix: FastFlix):
         flip_x = "true" if video.video_settings.horizontal_flip else "false"
         flip_y = "true" if video.video_settings.vertical_flip else "false"
         command.extend(["--vpp-transform", f"flip_x={flip_x},flip_y={flip_y}"])
-    if video.scale:
-        command.extend(["--output-res", video.scale.replace(":", "x")])
     if video.video_settings.crop:
         crop = video.video_settings.crop
         command.extend(["--crop", f"{crop.left},{crop.top},{crop.right},{crop.bottom}"])
+    if video.output_width is not None and video.output_height is not None:
+        command.extend(["--output-res", f"{video.output_width}x{video.output_height}"])
 
     if video.video_settings.remove_metadata:
         command.extend(["--video-metadata", "clear", "--metadata", "clear"])
@@ -77,7 +79,7 @@ def build(fastflix: FastFlix):
         command.extend(["--video-metadata", "copy", "--metadata", "copy"])
 
     if video.video_settings.video_title:
-        command.extend(["--video-metadata", f"title={video.video_settings.video_title}"])
+        command.extend(["--metadata", f"title={video.video_settings.video_title}"])
     if video.video_settings.copy_chapters:
         command.append("--chapter-copy")
 
@@ -95,6 +97,8 @@ def build(fastflix: FastFlix):
         command.extend(["--qp-min", str(settings.min_q)])
     if settings.max_q and settings.bitrate:
         command.extend(["--qp-max", str(settings.max_q)])
+    if settings.b_frames:
+        command.extend(["--bframes", str(settings.b_frames)])
     if settings.ref:
         command.extend(["--ref", str(settings.ref)])
 
@@ -104,16 +108,7 @@ def build(fastflix: FastFlix):
 
     command.extend(rigaya_auto_options(fastflix))
 
-    if fastflix.current_video.master_display:
-        md = fastflix.current_video.master_display
-        command.extend(
-            [
-                "--master-display",
-                f"G{md.green}B{md.blue}R{md.red}WP{md.white}L{md.luminance}",
-            ]
-        )
-    if fastflix.current_video.cll:
-        command.extend(["--max-cll", str(fastflix.current_video.cll)])
+    command.extend(rigaya_hdr_static_metadata(fastflix))
     if settings.copy_hdr10 and not video.video_settings.remove_hdr:
         command.extend(["--dhdr10-info", "copy"])
     if settings.copy_dv and not video.video_settings.remove_hdr:
@@ -132,7 +127,7 @@ def build(fastflix: FastFlix):
 
     pa = pa_builder(settings)
     if pa:
-        command.append(pa)
+        command.extend(pa)
 
     command.extend(["--avsync", vsync_setting])
 
@@ -140,13 +135,17 @@ def build(fastflix: FastFlix):
         command.extend(["--interlace", video.interlaced])
     if video.video_settings.deinterlace:
         command.append("--vpp-nnedi")
+    hdr2sdr_param = None
     if video.video_settings.remove_hdr:
         remove_type = (
             video.video_settings.tone_map
             if video.video_settings.tone_map in ("mobius", "hable", "reinhard")
             else "mobius"
         )
-        command.extend(["--vpp-colorspace", f"hdr2sdr={remove_type}"])
+        hdr2sdr_param = f"hdr2sdr={remove_type}"
+
+    command.extend(rigaya_extra_options(video, hdr2sdr=hdr2sdr_param))
+
     if settings.split_mode == "parallel":
         command.extend(["--parallel", "auto"])
     if settings.metrics:
@@ -155,11 +154,16 @@ def build(fastflix: FastFlix):
     command.extend(build_audio(video.audio_tracks, video.streams.audio))
     command.extend(build_subtitle(video.subtitle_tracks, video.streams.subtitle, video_height=video.height))
     command.extend(
-        build_data(video.data_tracks, getattr(video.streams, "data", []), getattr(video.streams, "attachment", []))
+        build_data(
+            video.data_tracks,
+            getattr(video.streams, "data", []),
+            getattr(video.streams, "attachment", []),
+            video.video_settings.output_path,
+        )
     )
 
     if settings.extra:
-        command.extend(shlex.split(settings.extra))
+        command.extend(split_extra_args(settings.extra))
 
     command.extend(["-o", str(video.video_settings.output_path)])
 
diff --git a/fastflix/encoders/vceencc_hevc/settings_panel.py b/fastflix/encoders/vceencc_hevc/settings_panel.py
index eb287ccb..89a040f5 100644
--- a/fastflix/encoders/vceencc_hevc/settings_panel.py
+++ b/fastflix/encoders/vceencc_hevc/settings_panel.py
@@ -100,6 +100,8 @@ def __init__(self, parent, main, app: FastFlixApp):
         qp_line.addStretch(1)
         qp_line.addLayout(self.init_ref())
         qp_line.addStretch(1)
+        qp_line.addLayout(self.init_b_frames())
+        qp_line.addStretch(1)
         qp_line.addLayout(self.init_level())
         qp_line.addStretch(1)
         qp_line.addLayout(self.init_decoder())
@@ -184,6 +186,15 @@ def init_mv_precision(self):
             opt="mv_precision",
         )
 
+    def init_b_frames(self):
+        return self._add_combo_box(
+            widget_name="b_frames",
+            label="B Frames",
+            options=[t("Auto")] + [str(x) for x in range(3)],
+            opt="b_frames",
+            min_width=60,
+        )
+
     def init_level(self):
         layout = self._add_combo_box(
             label="Level",
@@ -277,6 +288,7 @@ def update_video_encoder_settings(self):
             metrics=self.widgets.metrics.isChecked(),
             level=self.widgets.level.currentText() if self.widgets.level.currentIndex() != 0 else None,
             ref=self.widgets.ref.currentText() if self.widgets.ref.currentIndex() != 0 else None,
+            b_frames=self.widgets.b_frames.currentText() if self.widgets.b_frames.currentIndex() != 0 else None,
             pre_encode=self.widgets.pre_encode.isChecked(),
             pre_analysis=self.widgets.pre_analysis.isChecked(),
             vbaq=self.widgets.vbaq.isChecked(),
diff --git a/fastflix/encoders/vp9/command_builder.py b/fastflix/encoders/vp9/command_builder.py
index 22f6dd29..dc8fdc69 100644
--- a/fastflix/encoders/vp9/command_builder.py
+++ b/fastflix/encoders/vp9/command_builder.py
@@ -39,6 +39,9 @@ def build(fastflix: FastFlix):
     if settings.sharpness >= 0:
         beginning.extend(["-sharpness", str(settings.sharpness)])
 
+    if settings.lossless:
+        beginning.extend(["-lossless", "1"])
+
     details = [
         "-quality:v",
         settings.quality,
@@ -53,6 +56,11 @@ def build(fastflix: FastFlix):
     extra = shlex.split(settings.extra) if settings.extra else []
     extra_both = shlex.split(settings.extra) if settings.extra and settings.extra_both_passes else []
 
+    if settings.lossless:
+        # Lossless mode — no rate control needed, VP9 forces quantizer to 0
+        command = beginning + ["-speed:v", str(settings.speed)] + details + extra + ending
+        return [Command(command=command, name="Single pass lossless", exe="ffmpeg")]
+
     if settings.bitrate:
         if settings.quality == "realtime":
             return [
@@ -90,7 +98,14 @@ def build(fastflix: FastFlix):
     elif settings.crf:
         command_1 = (
             beginning
-            + ["-b:v", "0", "-crf:v", str(settings.crf)]
+            + [
+                "-speed:v",
+                str("4" if settings.fast_first_pass else settings.speed),
+                "-b:v",
+                "0",
+                "-crf:v",
+                str(settings.crf),
+            ]
             + details
             + ["-pass", "1"]
             + extra_both
@@ -100,7 +115,7 @@ def build(fastflix: FastFlix):
         )
         command_2 = (
             beginning
-            + ["-b:v", "0", "-crf:v", str(settings.crf)]
+            + ["-speed:v", str(settings.speed), "-b:v", "0", "-crf:v", str(settings.crf)]
             + details
             + (["-pass", "2"] if not settings.single_pass else [])
             + extra
diff --git a/fastflix/encoders/vp9/settings_panel.py b/fastflix/encoders/vp9/settings_panel.py
index 2a5321ad..f839a339 100644
--- a/fastflix/encoders/vp9/settings_panel.py
+++ b/fastflix/encoders/vp9/settings_panel.py
@@ -83,6 +83,8 @@ def __init__(self, parent, main, app: FastFlixApp):
         checkboxes.addLayout(self.init_row_mt())
         checkboxes.addStretch(1)
         checkboxes.addLayout(self.init_fast_first_pass())
+        checkboxes.addStretch(1)
+        checkboxes.addLayout(self.init_lossless())
 
         grid.addLayout(checkboxes, 5, 2, 1, 4)
 
@@ -201,6 +203,31 @@ def init_fast_first_pass(self):
     def init_single_pass(self):
         return self._add_check_box(label="Single Pass (CRF)", tooltip="", widget_name="single_pass", opt="single_pass")
 
+    def init_lossless(self):
+        layout = self._add_check_box(
+            label="Lossless",
+            widget_name="lossless",
+            tooltip=(
+                "Enable lossless encoding mode.\n"
+                "Produces bit-exact output with no quality loss.\n"
+                "Rate control options are ignored in lossless mode."
+            ),
+            opt="lossless",
+            connect=lambda: (self._toggle_lossless(), self.main.page_update(build_thumbnail=False)),
+        )
+        return layout
+
+    def _toggle_lossless(self):
+        enabled = not self.widgets.lossless.isChecked()
+        self.qp_radio.setEnabled(enabled)
+        self.bitrate_radio.setEnabled(enabled)
+        self.widgets.crf.setEnabled(enabled)
+        self.widgets.custom_crf.setEnabled(enabled)
+        self.widgets.bitrate.setEnabled(enabled)
+        self.widgets.custom_bitrate.setEnabled(enabled)
+        self.widgets.single_pass.setEnabled(enabled)
+        self.widgets.fast_first_pass.setEnabled(enabled)
+
     def init_auto_alt_ref(self):
         return self._add_combo_box(
             label="Alt Ref Frames",
@@ -293,6 +320,7 @@ def update_video_encoder_settings(self):
             tune_content=self.widgets.tune_content.currentText(),
             aq_mode=aq_mode,
             sharpness=sharpness,
+            lossless=self.widgets.lossless.isChecked(),
         )
         encode_type, q_value = self.get_mode_settings()
         settings.crf = q_value if encode_type == "qp" else None
diff --git a/fastflix/encoders/vvc/command_builder.py b/fastflix/encoders/vvc/command_builder.py
index 8ec6d186..2f78743b 100644
--- a/fastflix/encoders/vvc/command_builder.py
+++ b/fastflix/encoders/vvc/command_builder.py
@@ -2,80 +2,20 @@
 import secrets
 import shlex
 
+from fastflix.encoders.common.hdr_metadata import (
+    chromaloc_mapping,
+    color_matrix_mapping,
+    color_primaries_mapping,
+    color_transfer_mapping,
+    is_hdr_bit_depth,
+    parse_master_display,
+    valid_color_matrix,
+    valid_color_primaries,
+    valid_color_transfers,
+)
 from fastflix.encoders.common.helpers import Command, generate_all, null
 from fastflix.models.encode import VVCSettings
 from fastflix.models.fastflix import FastFlix
-from fastflix.shared import clean_file_string, quoted_path
-
-vvc_valid_color_primaries = [
-    "bt709",
-    "unknown",
-    "reserved",
-    "bt470m",
-    "bt470bg",
-    "smpte170m",
-    "smpte240m",
-    "film",
-    "bt2020",
-    "smpte428",
-    "smpte431",
-    "smpte432",
-]
-
-vvc_valid_color_transfers = [
-    "bt709",
-    "unknown",
-    "reserved",
-    "bt470m",
-    "bt470bg",
-    "smpte170m",
-    "smpte240m",
-    "linear",
-    "log100",
-    "log316",
-    "iec61966-2-4",
-    "bt1361e",
-    "iec61966-2-1",
-    "bt2020-10",
-    "bt2020-12",
-    "smpte2084",
-    "smpte428",
-    "arib-std-b67",
-]
-
-vvc_valid_color_matrix = [
-    "gbr",
-    "bt709",
-    "unknown",
-    "reserved",
-    "fcc",
-    "bt470bg",
-    "smpte170m",
-    "smpte240m",
-    "ycgco",
-    "bt2020nc",
-    "bt2020c",
-    "smpte2085",
-    "chroma-derived-nc",
-    "chroma-derived-c",
-    "ictcp",
-]
-
-color_primaries_mapping = {"smpte428_1": "smpte428"}
-
-color_transfer_mapping = {
-    "iec61966_2_4": "iec61966-2-4",
-    "iec61966_2_1": "iec61966-2-1",
-    "bt2020_10": "bt2020-10",
-    "bt2020_10bit": "bt2020-10",
-    "bt2020_12": "bt2020-12",
-    "bt2020_12bit": "bt2020-12",
-    "smpte428_1": "smpte428",
-}
-
-color_matrix_mapping = {"bt2020_ncl": "bt2020nc", "bt2020_cl": "bt2020c"}
-
-chromaloc_mapping = {"left": 0, "center": 1, "topleft": 2, "top": 3, "bottomleft": 4, "bottom": 5}
 
 
 def build(fastflix: FastFlix):
@@ -103,10 +43,6 @@ def build(fastflix: FastFlix):
     if settings.ifp:
         vvc_params.append("ifp=1")
 
-    if fastflix.current_video.video_settings.maxrate:
-        vvc_params.append(f"vbv-maxrate={fastflix.current_video.video_settings.maxrate}")
-        vvc_params.append(f"vbv-bufsize={fastflix.current_video.video_settings.bufsize}")
-
     if not fastflix.current_video.video_settings.remove_hdr:
         # Color primaries/transfer/matrix via FFmpeg flags (libvvenc reads these for VUI)
         if fastflix.current_video.video_settings.color_primaries:
@@ -114,7 +50,7 @@ def build(fastflix: FastFlix):
         elif fastflix.current_video.color_primaries:
             cp = fastflix.current_video.color_primaries
             cp = color_primaries_mapping.get(cp, cp)
-            if cp in vvc_valid_color_primaries:
+            if cp in valid_color_primaries:
                 beginning.extend(["-color_primaries", cp])
 
         if fastflix.current_video.video_settings.color_transfer:
@@ -122,7 +58,7 @@ def build(fastflix: FastFlix):
         elif fastflix.current_video.color_transfer:
             ct = fastflix.current_video.color_transfer
             ct = color_transfer_mapping.get(ct, ct)
-            if ct in vvc_valid_color_transfers:
+            if ct in valid_color_transfers:
                 beginning.extend(["-color_trc", ct])
 
         if fastflix.current_video.video_settings.color_space:
@@ -130,15 +66,13 @@ def build(fastflix: FastFlix):
         elif fastflix.current_video.color_space:
             cs = fastflix.current_video.color_space
             cs = color_matrix_mapping.get(cs, cs)
-            if cs in vvc_valid_color_matrix:
+            if cs in valid_color_matrix:
                 beginning.extend(["-colorspace", cs])
 
-        if settings.pix_fmt in ("yuv420p10le",):
-            if fastflix.current_video.master_display:
-                # vvenc format: Gx,Gy,Bx,By,Rx,Ry,WPx,WPy,Lmax,Lmin (bare numbers, comma-separated)
-                md = fastflix.current_video.master_display
-                md_values = ",".join(v.strip("()") for v in [md.green, md.blue, md.red, md.white, md.luminance])
-                vvc_params.append(f"MasteringDisplayColourVolume={md_values}")
+        if is_hdr_bit_depth(settings.pix_fmt):
+            master_display = parse_master_display(fastflix.current_video.master_display)
+            if master_display:
+                vvc_params.append(f"MasteringDisplayColourVolume={master_display.to_vvenc()}")
 
             if fastflix.current_video.cll:
                 vvc_params.append(f"MaxContentLightLevel={fastflix.current_video.cll}")
@@ -149,31 +83,25 @@ def build(fastflix: FastFlix):
 
     pass_log_file = fastflix.current_video.work_path / f"pass_log_file_{secrets.token_hex(10)}"
 
-    def get_vvc_params(params=()):
-        if not isinstance(params, (list, tuple)):
-            params = [params]
-        all_params = vvc_params + list(params)
-        return ["-vvenc-params", ":".join(all_params)] if all_params else []
+    vvenc_params = ["-vvenc-params", ":".join(vvc_params)] if vvc_params else []
 
     extra = shlex.split(settings.extra) if settings.extra else []
     extra_both = shlex.split(settings.extra) if settings.extra and settings.extra_both_passes else []
 
     if settings.bitrate:
-        params = get_vvc_params(["pass=1", f"rcstatsfile={quoted_path(clean_file_string(str(pass_log_file)))}"])
         command_1 = (
             beginning
-            + params
-            + ["-passlogfile", str(pass_log_file), "-b:v", settings.bitrate, "-preset:v", settings.preset]
+            + vvenc_params
+            + ["-pass", "1", "-passlogfile", str(pass_log_file), "-b:v", settings.bitrate, "-preset:v", settings.preset]
             + extra_both
             + ["-an", "-sn", "-dn"]
             + output_fps
             + ["-f", "mp4", null]
         )
-        params2 = get_vvc_params(["pass=2", f"rcstatsfile={quoted_path(clean_file_string(str(pass_log_file)))}"])
         command_2 = (
             beginning
-            + params2
-            + ["-passlogfile", str(pass_log_file), "-b:v", settings.bitrate, "-preset:v", settings.preset]
+            + vvenc_params
+            + ["-pass", "2", "-passlogfile", str(pass_log_file), "-b:v", settings.bitrate, "-preset:v", settings.preset]
             + extra
             + ending
         )
@@ -185,7 +113,7 @@ def get_vvc_params(params=()):
     elif settings.qp:
         command = (
             beginning
-            + get_vvc_params()
+            + vvenc_params
             + ["-qp:v", str(settings.qp), "-b:v", "0", "-preset:v", settings.preset]
             + extra
             + ending
diff --git a/fastflix/ff_queue.py b/fastflix/ff_queue.py
index 027f4a1b..02173c99 100644
--- a/fastflix/ff_queue.py
+++ b/fastflix/ff_queue.py
@@ -3,6 +3,7 @@
 import logging
 import os
 import shutil
+from datetime import datetime
 import tempfile
 import threading
 import time
@@ -43,6 +44,7 @@ def queue_file_lock(queue_file: Path, timeout: float = 30.0):
     lock_file = queue_file.with_suffix(".lock")
     start_time = time.time()
     lock_acquired = False
+    lock_token = f"{os.getpid()}:{uuid.uuid4().hex}"
 
     # First acquire the in-process lock
     with _queue_file_lock:
@@ -52,7 +54,7 @@ def queue_file_lock(queue_file: Path, timeout: float = 30.0):
                 # Try to create lock file exclusively
                 # os.O_CREAT | os.O_EXCL fails if file exists
                 fd = os.open(str(lock_file), os.O_CREAT | os.O_EXCL | os.O_WRONLY)
-                os.write(fd, str(os.getpid()).encode())
+                os.write(fd, lock_token.encode())
                 os.close(fd)
                 lock_acquired = True
                 break
@@ -62,10 +64,15 @@ def queue_file_lock(queue_file: Path, timeout: float = 30.0):
                     if lock_file.exists():
                         age = time.time() - lock_file.stat().st_mtime
                         if age > 60:
-                            # Stale lock, remove it
-                            logger.warning(f"Removing stale queue lock file (age: {age:.1f}s)")
-                            lock_file.unlink(missing_ok=True)
-                            continue
+                            # Best effort: skip removal if the lock changed since we looked. Not atomic, but the release
+                            # path only deletes a lock that still carries its own token, which limits the damage.
+                            stale_content = lock_file.read_text()
+                            if lock_file.read_text() == stale_content and time.time() - lock_file.stat().st_mtime > 60:
+                                logger.warning(
+                                    f"Removing stale queue lock file (age: {age:.1f}s, owner: {stale_content!r})"
+                                )
+                                lock_file.unlink(missing_ok=True)
+                                continue
                 except OSError:
                     pass
                 time.sleep(0.1)
@@ -82,9 +89,12 @@ def queue_file_lock(queue_file: Path, timeout: float = 30.0):
         try:
             yield True
         finally:
-            # Release the lock
+            # Release the lock, but only if it is still ours
             try:
-                lock_file.unlink(missing_ok=True)
+                if lock_file.read_text() == lock_token:
+                    lock_file.unlink(missing_ok=True)
+                else:
+                    logger.warning("Queue lock file changed while held, leaving it in place")
             except OSError:
                 pass
 
@@ -245,10 +255,63 @@ def set_current_generation(queue_file: Path, generation: str):
     _generation_tracker[str(queue_file)] = generation
 
 
+def _settings_class_by_name(name):
+    for cls in setting_types.values():
+        if cls.model_fields["name"].default == name:
+            return cls
+    raise KeyError(f"Unknown encoder settings name: {name!r}")
+
+
+def _cleanup_stale_tmp_files(queue_file: Path, max_age: float = 600.0):
+    try:
+        for tmp_file in queue_file.parent.glob("queue_*.yaml.tmp"):
+            try:
+                if time.time() - tmp_file.stat().st_mtime > max_age:
+                    tmp_file.unlink()
+                    logger.info(f"Removed leftover temporary queue file {tmp_file}")
+            except OSError:
+                pass
+    except OSError:
+        pass
+
+
+def _load_queue_item(video) -> Video:
+    video["source"] = Path(video["source"])
+    video["work_path"] = Path(video["work_path"])
+    video["video_settings"]["output_path"] = Path(video["video_settings"]["output_path"])
+    encoder_settings = video["video_settings"]["video_encoder_settings"]
+    ves = _settings_class_by_name(encoder_settings["name"])(**encoder_settings)
+    attachments = []
+    for x in video["attachment_tracks"]:
+        try:
+            attachment_path = x.pop("file_path")
+        except KeyError:
+            attachment_path = None
+        attachment = AttachmentTrack(**x)
+        attachment.file_path = str(attachment_path) if attachment_path else None
+        attachments.append(attachment)
+    status = Status(**video["status"])
+    crop = None
+    if video["video_settings"]["crop"]:
+        crop = Crop(**video["video_settings"]["crop"])
+    del video["video_settings"]["video_encoder_settings"]
+    del video["status"]
+    del video["video_settings"]["crop"]
+    vs = VideoSettings(
+        **video["video_settings"],
+        crop=crop,
+    )
+    vs.video_encoder_settings = ves  # No idea why this has to be called after, otherwise reset to x265
+    del video["video_settings"]
+    return Video(**video, video_settings=vs, status=status)
+
+
 def get_queue(queue_file: Path) -> list[Video]:
     if not queue_file.exists():
         return []
 
+    _cleanup_stale_tmp_files(queue_file)
+
     try:
         loaded = Box.from_yaml(filename=queue_file)
     except (BoxError, YAMLError):
@@ -259,38 +322,38 @@ def get_queue(queue_file: Path) -> list[Video]:
     if "_generation" in loaded:
         set_current_generation(queue_file, loaded["_generation"])
 
+    if "queue" not in loaded:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        error_file = queue_file.parent / f"queue_error_{timestamp}.yaml"
+        try:
+            shutil.copy2(queue_file, error_file)
+            logger.warning(
+                f"Queue file is missing 'queue' key, cannot load. "
+                f"Saved copy to: {error_file} — "
+                f"please raise an issue at https://github.com/cdgriffith/FastFlix/issues and attach this file"
+            )
+        except OSError:
+            logger.warning("Queue file is missing 'queue' key, cannot load. Could not save a copy of the file.")
+        return []
+
     queue = []
-    for video in loaded["queue"]:
-        video["source"] = Path(video["source"])
-        video["work_path"] = Path(video["work_path"])
-        video["video_settings"]["output_path"] = Path(video["video_settings"]["output_path"])
-        encoder_settings = video["video_settings"]["video_encoder_settings"]
-        ves = [x(**encoder_settings) for x in setting_types.values() if x().name == encoder_settings["name"]][0]
-        # audio = [AudioTrack(**x) for x in video["audio_tracks"]]
-        # subtitles = [SubtitleTrack(**x) for x in video["subtitle_tracks"]]
-        attachments = []
-        for x in video["attachment_tracks"]:
-            try:
-                attachment_path = x.pop("file_path")
-            except KeyError:
-                attachment_path = None
-            attachment = AttachmentTrack(**x)
-            attachment.file_path = str(attachment_path) if attachment_path else None
-            attachments.append(attachment)
-        status = Status(**video["status"])
-        crop = None
-        if video["video_settings"]["crop"]:
-            crop = Crop(**video["video_settings"]["crop"])
-        del video["video_settings"]["video_encoder_settings"]
-        del video["status"]
-        del video["video_settings"]["crop"]
-        vs = VideoSettings(
-            **video["video_settings"],
-            crop=crop,
-        )
-        vs.video_encoder_settings = ves  # No idea why this has to be called after, otherwise reset to x265
-        del video["video_settings"]
-        queue.append(Video(**video, video_settings=vs, status=status))
+    skipped = 0
+    for index, video in enumerate(loaded["queue"]):
+        try:
+            queue.append(_load_queue_item(video))
+        except Exception:
+            skipped += 1
+            logger.exception(f"Skipping queue item #{index + 1} that could not be loaded")
+    if skipped:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        error_file = queue_file.parent / f"queue_error_{timestamp}.yaml"
+        try:
+            shutil.copy2(queue_file, error_file)
+            logger.warning(
+                f"Skipped {skipped} unreadable queue item(s). Saved a copy of the original queue to: {error_file}"
+            )
+        except OSError:
+            logger.warning(f"Skipped {skipped} unreadable queue item(s). Could not save a copy of the original queue.")
     del loaded
     return queue
 
@@ -378,8 +441,8 @@ def update_conversion_command(vid, old_path: str, new_path: str):
             current_file_generation = get_queue_generation(queue_file)
             if current_file_generation is not None and current_file_generation != expected_generation:
                 logger.error(
-                    f"Queue file generation mismatch! Expected '{expected_generation}', "
-                    f"but file has '{current_file_generation}'. "
+                    f"Queue save dropped: generation mismatch for {queue_file}! Expected '{expected_generation}', "
+                    f"but file has '{current_file_generation}' ({len(items)} item(s) not saved). "
                     "Another save completed between queue and execution. "
                     "Skipping this save to avoid overwriting newer data."
                 )
@@ -403,9 +466,7 @@ def update_conversion_command(vid, old_path: str, new_path: str):
                 tmp.to_yaml(filename=temp_path)
                 del tmp
 
-                # Atomic rename (on POSIX this is atomic, on Windows it replaces)
-                # Use shutil.move for cross-platform compatibility
-                shutil.move(temp_path, queue_file)
+                os.replace(temp_path, queue_file)
 
                 # Update the generation tracker after successful save
                 set_current_generation(queue_file, new_generation)
diff --git a/fastflix/flix.py b/fastflix/flix.py
index 63feff89..5c485883 100644
--- a/fastflix/flix.py
+++ b/fastflix/flix.py
@@ -5,7 +5,7 @@
 import re
 from pathlib import Path
 from subprocess import PIPE, CompletedProcess, Popen, TimeoutExpired, run, check_output
-from typing import List, Tuple, Union
+from typing import List, Optional, Tuple, Union
 from packaging import version
 import shlex
 
@@ -16,6 +16,7 @@
 from fastflix.language import t
 from fastflix.models.config import Config
 from fastflix.models.fastflix_app import FastFlixApp
+from fastflix.shared import clean_env
 
 here = os.path.abspath(os.path.dirname(__file__))
 re_tff = re.compile(r"TFF:\s+(\d+)")
@@ -151,6 +152,7 @@ def execute(command: List, work_dir: Union[Path, str] = None, timeout: int = Non
         cwd=work_dir,
         timeout=timeout,
         encoding="utf-8",
+        env=clean_env(),
     )
 
 
@@ -238,14 +240,40 @@ def probe(app: FastFlixApp, file: Path) -> Box:
         raise FlixError(result.stderr)
 
 
+def _unquote_concat_value(value: str) -> str:
+    """Parse a concat demuxer filename using ffmpeg's quoting rules (single quotes, backslash escapes)."""
+    value = value.strip()
+    if len(value) >= 2 and value[0] == value[-1] == '"':
+        return value[1:-1]
+    out = []
+    quoted = False
+    chars = iter(value)
+    for char in chars:
+        if quoted:
+            if char == "'":
+                quoted = False
+            else:
+                out.append(char)
+        elif char == "'":
+            quoted = True
+        elif char == "\\":
+            out.append(next(chars, ""))
+        else:
+            out.append(char)
+    return "".join(out)
+
+
 def get_all_concat_items(file):
     items = []
-    with open(file) as f:
+    list_dir = Path(file).parent
+    with open(file, encoding="utf-8") as f:
         for line in f:
             if line.strip().startswith("#"):
                 continue
-            elif line.strip().startswith("file"):
-                filename = Path(line.strip()[5:].strip("'\""))
+            elif re.match(r"^\s*file\s", line):
+                filename = Path(_unquote_concat_value(line.strip()[4:]))
+                if not filename.is_absolute():
+                    filename = list_dir / filename
                 if not filename.exists():
                     raise FlixError(f'No file "{filename}" exists')
                 items.append(filename)
@@ -304,7 +332,7 @@ def extract_attachments(app: FastFlixApp, **_):
     if app.fastflix.config.disable_cover_extraction:
         return
     for track in app.fastflix.current_video.streams.attachment:
-        filename = track.get("tags", {}).get("filename", "")
+        filename = Path(track.get("tags", {}).get("filename", "")).name
         if filename.rsplit(".", 1)[0] in ("cover", "small_cover", "cover_land", "small_cover_land"):
             extract_attachment(
                 app.fastflix.config.ffmpeg,
@@ -361,6 +389,7 @@ def extract_attachment(ffmpeg: Path, source: Path, stream: int, work_dir: Path,
             stderr=PIPE,
             stdin=PIPE,
             cwd=work_dir,
+            env=clean_env(),
         )
         try:
             stdout, _ = proc.communicate(timeout=3)
@@ -412,12 +441,51 @@ def generate_thumbnail_command(
         "unofficial",
         "-frames:v",
         "1",
+        "-update",
+        "1",
         clean_file_string(output),
     ]
 
     return command
 
 
+def parse_cropdetect_output(stderr: str, video_width: int, video_height: int) -> Optional[List[int]]:
+    """Parse FFmpeg cropdetect output and return crop margins [right, bottom, left, top].
+
+    Collects all detected crop rectangles as (w, h, x, y) tuples, discards invalid ones (cropdetect reports
+    negative sizes on fully black frames), and returns the union of the remaining content rectangles. Each edge is
+    therefore tracked independently, so mixed letterbox/pillarbox samples never over-crop.
+    Returns None if no valid detections found.
+    """
+    detections = []
+    for line in stderr.splitlines():
+        if line.startswith("[Parsed_cropdetect"):
+            try:
+                w, h, x, y = [int(v) for v in line.rsplit("=")[1].split(":")]
+            except (ValueError, IndexError):
+                continue
+            if w <= 0 or h <= 0 or x < 0 or y < 0:
+                continue
+            detections.append((w, h, x, y))
+
+    if not detections:
+        return None
+
+    left = min(x for _, _, x, _ in detections)
+    top = min(y for _, _, _, y in detections)
+    content_right = max(x + w for w, _, x, _ in detections)
+    content_bottom = max(y + h for _, h, _, y in detections)
+
+    x, y = left, top
+    right = video_width - content_right
+    bottom = video_height - content_bottom
+
+    if right < 0 or bottom < 0:
+        return None
+
+    return [right, bottom, x, y]
+
+
 def get_auto_crop(
     config: Config,
     source: Path,
@@ -441,7 +509,7 @@ def get_auto_crop(
             f"0:{input_track}",
             "-vf",
             "cropdetect=round=2",
-            "-vframes",
+            "-frames:v",
             "10",
             "-f",
             "null",
@@ -449,24 +517,12 @@ def get_auto_crop(
         ]
     )
 
-    width, height, x_crop, y_crop = None, None, None, None
     if not output.stderr:
-        return 0, 0, 0, 0
-
-    for line in output.stderr.splitlines():
-        if line.startswith("[Parsed_cropdetect"):
-            w, h, x, y = [int(x) for x in line.rsplit("=")[1].split(":")]
-            if (not x_crop or (x_crop and x > x_crop)) and (not width or (width and w < width)):
-                width = w
-                x_crop = x
-            if (not height or (height and h < height)) and (not y_crop or (y_crop and y > y_crop)):
-                height = h
-                y_crop = y
-
-    if None in (width, height, x_crop, y_crop):
-        return 0, 0, 0, 0
+        return
 
-    result_list.append([video_width - width - x_crop, video_height - height - y_crop, x_crop, y_crop])
+    crop_margins = parse_cropdetect_output(output.stderr, video_width, video_height)
+    if crop_margins is not None:
+        result_list.append(crop_margins)
 
 
 def detect_interlaced(app: FastFlixApp, config: Config, source: Path, **_):
@@ -668,7 +724,9 @@ def get_hdr10_parser_version(config: Config) -> version:
     global HDR10_parser_version
     if HDR10_parser_version:
         return HDR10_parser_version
-    HDR10_parser_version_output = check_output([str(config.hdr10plus_parser), "--version"], encoding="utf-8")
+    HDR10_parser_version_output = check_output(
+        [str(config.hdr10plus_parser), "--version"], encoding="utf-8", env=clean_env()
+    )
 
     _, version_string = HDR10_parser_version_output.rsplit(sep=" ", maxsplit=1)
     HDR10_parser_version = version.parse(version_string)
@@ -687,7 +745,7 @@ def _detect_hdr10_plus_ffprobe(app: FastFlixApp, config: Config, stream) -> bool
                 "-read_intervals",
                 "%+#1",
                 "-select_streams",
-                f"v:{stream.index}",
+                f"{stream.index}",
                 "-show_entries",
                 "frame=side_data_list",
                 "-of",
@@ -721,6 +779,8 @@ def _detect_hdr10_plus_tool(app: FastFlixApp, config: Config, stream) -> bool:
             f"0:{stream.index}",
             "-loglevel",
             "panic",
+            "-frames:v",
+            "60",
             "-c:v",
             "copy",
             "-bsf:v",
@@ -732,26 +792,41 @@ def _detect_hdr10_plus_tool(app: FastFlixApp, config: Config, stream) -> bool:
         stdout=PIPE,
         stderr=PIPE,
         stdin=PIPE,  # FFmpeg can try to read stdin and wrecks havoc
-    )
-
-    parser_version = get_hdr10_parser_version(config)
-    hdr10_parser_command = [str(config.hdr10plus_parser), "--verify", "-"]
-    if parser_version >= version.parse("1.0.0"):
-        hdr10_parser_command.insert(-1, "extract")
-
-    process_two = Popen(
-        hdr10_parser_command,
-        stdout=PIPE,
-        stderr=PIPE,
-        stdin=process.stdout,
-        encoding="utf-8",
+        env=clean_env(),
     )
 
     try:
-        stdout, stderr = process_two.communicate()
+        parser_version = get_hdr10_parser_version(config)
+        hdr10_parser_command = [str(config.hdr10plus_parser), "--verify", "-"]
+        if parser_version >= version.parse("1.0.0"):
+            hdr10_parser_command.insert(-1, "extract")
+
+        process_two = Popen(
+            hdr10_parser_command,
+            stdout=PIPE,
+            stderr=PIPE,
+            stdin=process.stdout,
+            encoding="utf-8",
+            env=clean_env(),
+        )
+        try:
+            stdout, stderr = process_two.communicate(timeout=60)
+        except Exception:
+            process_two.kill()
+            process_two.wait()
+            raise
     except Exception:
         logger.exception(f"Unexpected error while trying to detect HDR10+ metadata in stream {stream.index}")
         return False
+    finally:
+        if process.stdout:
+            process.stdout.close()
+        process.kill()
+        process.wait()
+        if process.stderr:
+            process.stderr.close()
+        if process.stdin:
+            process.stdin.close()
     return "Dynamic HDR10+ metadata detected." in stdout
 
 
diff --git a/fastflix/gpu_detect.py b/fastflix/gpu_detect.py
index 25217d3d..69143749 100644
--- a/fastflix/gpu_detect.py
+++ b/fastflix/gpu_detect.py
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 from dataclasses import dataclass
 import logging
+import re
 
 
 from fastflix.program_downloads import find_seven_zip_windows, download_rigaya, download_7zip
@@ -32,6 +33,20 @@ def __str__(self):
         return output
 
 
+def classify_vendor(name: str | None) -> str | None:
+    """Map a WMI AdapterCompatibility string to NVIDIA / AMD / INTEL, or None if unknown."""
+    if not name:
+        return None
+    lowered = name.lower()
+    if "nvidia" in lowered:
+        return "NVIDIA"
+    if "advanced micro devices" in lowered or "ati technologies" in lowered or re.search(r"\bamd\b", lowered):
+        return "AMD"
+    if "intel" in lowered:
+        return "INTEL"
+    return None
+
+
 def windows_gpu_detect():
     import wmi
 
@@ -40,17 +55,13 @@ def windows_gpu_detect():
     detected_gpus = DetectGPU()
     fingerprinter = set()
     for adapter in gpu_info:
-        adapter_type = adapter.AdapterCompatibility.split()[0].upper()
-        if adapter_type == "NVIDIA":
-            detected_gpus.NVIDIA = True
-            fingerprinter.add(adapter.VideoProcessor)
-        elif adapter_type == "AMD":
-            detected_gpus.AMD = True
+        vendor = classify_vendor(adapter.AdapterCompatibility)
+        if vendor is None:
+            continue
+        setattr(detected_gpus, vendor, True)
+        if adapter.VideoProcessor:
             fingerprinter.add(adapter.VideoProcessor)
-        elif adapter_type == "INTEL":
-            detected_gpus.INTEL = True
-            fingerprinter.add(adapter.VideoProcessor)
-    detected_gpus.fingerprint = "~~".join(sorted(list(fingerprinter)))
+    detected_gpus.fingerprint = "~~".join(sorted(fingerprinter))
     return detected_gpus
 
 
@@ -62,6 +73,39 @@ def gpu_detect():
         return DetectGPU()
 
 
+def _ensure_seven_zip(config, stop_signal) -> bool:
+    if not config.seven_zip or not config.seven_zip.exists():
+        config.seven_zip = find_seven_zip_windows() or download_7zip(stop_signal)
+    if not config.seven_zip:
+        logger.error("7-Zip is not available (download cancelled or failed), cannot download encoders")
+        return False
+    return True
+
+
+def _download_encoders(config, gpus, signal, stop_signal, only_missing: bool) -> bool:
+    """Download rigaya encoders for detected GPUs. Returns True only if every requested download succeeded."""
+    if not _ensure_seven_zip(config, stop_signal):
+        return False
+
+    ok = True
+    for percent, present, attr, app_name in (
+        (50, gpus.NVIDIA, "nvencc", "NVEnc"),
+        (70, gpus.AMD, "vceencc", "VCEEnc"),
+        (90, gpus.INTEL, "qsvencc", "QSVEnc"),
+    ):
+        signal.emit(percent)
+        if not present or (only_missing and getattr(config, attr)):
+            continue
+        logger.info(f"Going to download {app_name}")
+        result = download_rigaya(stop_signal, seven_zip_path=config.seven_zip, app_name=app_name)
+        if result:
+            setattr(config, attr, result)
+        else:
+            logger.error(f"Could not download {app_name}")
+            ok = False
+    return ok
+
+
 def automatic_rigaya_download(config, app, signal, stop_signal):
     if config.gpu_fingerprint:
         logger.debug(f"GPU fingerprint already set: {config.gpu_fingerprint}")
@@ -71,30 +115,10 @@ def automatic_rigaya_download(config, app, signal, stop_signal):
     logger.info(f"Detected GPUs: {gpus}")
     if not gpus.exist():
         return
-    config.gpu_fingerprint = gpus.fingerprint
 
     signal.emit(25)
-
-    if not config.seven_zip or not config.seven_zip.exists():
-        config.seven_zip = find_seven_zip_windows()
-        if not config.seven_zip:
-            config.seven_zip = download_7zip(stop_signal)
-
-    signal.emit(50)
-
-    if gpus.NVIDIA and not config.nvencc:
-        logger.info("Going to download NVEncC")
-        config.nvencc = download_rigaya(stop_signal, seven_zip_path=config.seven_zip, app_name="NVEnc")
-
-    signal.emit(70)
-    if gpus.AMD and not config.vceencc:
-        logger.info("Going to download VCEncC")
-        config.vceencc = download_rigaya(stop_signal, seven_zip_path=config.seven_zip, app_name="VCEEnc")
-
-    signal.emit(90)
-    if gpus.INTEL and not config.qsvencc:
-        logger.info("Going to download QSVEncC")
-        config.qsvencc = download_rigaya(stop_signal, seven_zip_path=config.seven_zip, app_name="QSVEnc")
+    if _download_encoders(config, gpus, signal, stop_signal, only_missing=True):
+        config.gpu_fingerprint = gpus.fingerprint
 
 
 def update_rigaya_encoders(config, app, signal, stop_signal):
@@ -103,28 +127,8 @@ def update_rigaya_encoders(config, app, signal, stop_signal):
     logger.info(f"Detected GPUs: {gpus}")
     if not gpus.exist():
         return
-    config.gpu_fingerprint = gpus.fingerprint
 
     signal.emit(25)
-
-    if not config.seven_zip or not config.seven_zip.exists():
-        config.seven_zip = find_seven_zip_windows()
-        if not config.seven_zip:
-            config.seven_zip = download_7zip(stop_signal)
-
-    signal.emit(50)
-
-    if gpus.NVIDIA:
-        logger.info("Going to download NVEncC")
-        config.nvencc = download_rigaya(stop_signal, seven_zip_path=config.seven_zip, app_name="NVEnc")
-
-    signal.emit(70)
-    if gpus.AMD:
-        logger.info("Going to download VCEncC")
-        config.vceencc = download_rigaya(stop_signal, seven_zip_path=config.seven_zip, app_name="VCEEnc")
-
-    signal.emit(90)
-    if gpus.INTEL:
-        logger.info("Going to download QSVEncC")
-        config.qsvencc = download_rigaya(stop_signal, seven_zip_path=config.seven_zip, app_name="QSVEnc")
+    if _download_encoders(config, gpus, signal, stop_signal, only_missing=False):
+        config.gpu_fingerprint = gpus.fingerprint
     signal.emit(100)
diff --git a/fastflix/models/config.py b/fastflix/models/config.py
index e9081662..5a093d30 100644
--- a/fastflix/models/config.py
+++ b/fastflix/models/config.py
@@ -1,16 +1,19 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
+import copy
 import logging
 import os
 import shutil
+import tempfile
+import time
 from packaging import version
 from pathlib import Path
 from typing import Literal
 import json
 
 from platformdirs import user_data_dir
-from box import Box, BoxError
-from pydantic import BaseModel, Field
+from box import Box
+from pydantic import BaseModel, Field, TypeAdapter
 from reusables import win_based
 
 from fastflix.exceptions import ConfigError, MissingFF
@@ -294,9 +297,12 @@ class Config(BaseModel):
     sticky_tabs: bool = False
     show_complete_message: bool = False
     show_error_message: bool = True
+    keep_source_after_encode: bool = False
 
     disable_cover_extraction: bool = False
     suppress_ffmpeg_version_warning: bool = False
+    suppress_video_speed_warning: bool = False
+    suppress_reverse_video_warning: bool = False
 
     # PGS to SRT OCR Settings
     enable_pgs_ocr: bool = False
@@ -381,7 +387,10 @@ def pre_load(self, portable_mode=False):
         self.config_path = get_config(portable_mode=portable_mode)
         try:
             data = Box.from_yaml(filename=self.config_path)
+        except FileNotFoundError:
+            data = Box()
         except Exception:
+            logger.exception(f"Could not read config file {self.config_path} for pre-load settings")
             data = Box()
 
         output = {"enable_scaling": True}
@@ -401,7 +410,8 @@ def load(self, portable_mode=False):
             self.work_path = Path(os.getenv("FF_WORKDIR", "fastflix_workspace"))
             self.work_path.mkdir(exist_ok=True)
 
-        if not self.config_path.exists() or self.config_path.stat().st_size < 10:
+        data = self._read_config_data()
+        if data is None:
             logger.debug(f"Creating new config file {self.config_path}")
             self.config_path.parent.mkdir(parents=True, exist_ok=True)
             self.save()
@@ -412,12 +422,6 @@ def load(self, portable_mode=False):
                 self.ffprobe = find_ffmpeg_file("ffmpeg.ffprobe", raise_on_missing=True)
             return
         logger.debug(f"Using config file {self.config_path}")
-        try:
-            data = Box.from_yaml(filename=self.config_path)
-        except BoxError as err:
-            raise ConfigError(f"{self.config_path}: {err}")
-        if "version" not in data:
-            raise ConfigError(f"Corrupt config file. Please fix or remove {self.config_path}")
 
         if version.parse(__version__) < version.parse(data.version):
             logger.warning(
@@ -443,12 +447,27 @@ def load(self, portable_mode=False):
             if key == "profiles":
                 self.profiles = {}
                 for k, v in value.items():
-                    if v.get("profile_version", 1) == 1:
-                        self.profiles[k] = self.profile_v1_to_v2(k, v)
-                    else:
-                        self.profiles[k] = Profile(**v)
+                    raw = copy.deepcopy(v)
+                    try:
+                        if v.get("profile_version", 1) == 1:
+                            self.profiles[k] = self.profile_v1_to_v2(k, v)
+                        else:
+                            self.profiles[k] = Profile(**v)
+                    except Exception:
+                        logger.exception(f'Skipping profile "{k}" that could not be loaded. Raw data: {raw}')
                 continue
-            if key in self and key not in ("config_path", "version"):
+            field = Config.model_fields.get(key)
+            if field is not None and key not in ("config_path", "version"):
+                if key in ("output_directory", "source_directory") and value is False:
+                    setattr(self, key, value)
+                    continue
+                if field.annotation is str and isinstance(value, (int, float)) and not isinstance(value, bool):
+                    value = str(value)
+                try:
+                    TypeAdapter(field.annotation).validate_python(value)
+                except Exception:
+                    logger.warning(f"Ignoring config value {key}={value!r}, it is not a valid {field.annotation}")
+                    continue
                 setattr(self, key, Path(value) if key in paths and value else value)
 
         # Migrate old disable_complete_message (inverted) to show_complete_message and show_error_message
@@ -549,7 +568,77 @@ def save(self):
         items["profiles"] = {
             k: json.loads(v.json()) for k, v in self.profiles.items() if k not in get_preset_defaults().keys()
         }
-        return Box(items).to_yaml(filename=self.config_path, default_flow_style=False)
+        config_path = Path(self.config_path)
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        fd, temp_path = tempfile.mkstemp(suffix=".tmp", prefix=f"{config_path.name}.", dir=config_path.parent)
+        try:
+            os.close(fd)
+            result = Box(items).to_yaml(filename=temp_path, default_flow_style=False)
+            if self._is_valid_config_file(config_path):
+                try:
+                    shutil.copy2(config_path, self._backup_path(config_path))
+                except OSError:
+                    logger.exception("Could not back up previous config file")
+            os.replace(temp_path, config_path)
+        except Exception:
+            try:
+                os.unlink(temp_path)
+            except OSError:
+                pass
+            raise
+        return result
+
+    @staticmethod
+    def _backup_path(path: Path) -> Path:
+        return path.with_name(path.name + ".bak")
+
+    @staticmethod
+    def _is_valid_config_file(path: Path) -> bool:
+        try:
+            if not path.exists() or path.stat().st_size < 10:
+                return False
+            return "version" in Box.from_yaml(filename=path)
+        except Exception:
+            return False
+
+    def _read_config_data(self):
+        """Returns the config data, or None if a new config should be created.
+        Falls back to the .bak file, and moves unreadable files aside rather than deleting them."""
+        path = Path(self.config_path)
+        backup = self._backup_path(path)
+        if not path.exists():
+            return None
+        problem = None
+        try:
+            if path.stat().st_size >= 10:
+                data = Box.from_yaml(filename=path)
+                if "version" in data:
+                    return data
+                problem = "missing version"
+            elif path.stat().st_size > 0 or backup.exists():
+                problem = "file is truncated"
+            else:
+                return None
+        except Exception as err:
+            problem = f"{err.__class__.__name__}: {err}"
+
+        logger.error(f"Config file {path} is unreadable ({problem}), trying backup {backup}")
+        corrupt = path.with_name(f"{path.name}.corrupt-{time.strftime('%Y%m%d_%H%M%S')}")
+        try:
+            shutil.move(str(path), str(corrupt))
+        except OSError as err:
+            raise ConfigError(f"{path}: {problem}. Could not move it aside: {err}") from None
+        logger.error(f"Moved unreadable config to {corrupt}")
+        if self._is_valid_config_file(backup):
+            try:
+                data = Box.from_yaml(filename=backup)
+                shutil.copy2(backup, path)
+                logger.error(f"Restored config from backup {backup}")
+                return data
+            except Exception:
+                logger.exception("Could not restore config from backup")
+        logger.error(f"No usable backup, starting with default settings. Old file kept at {corrupt}")
+        return None
 
     @property
     def profile(self):
@@ -567,7 +656,7 @@ def upgrade_check(self):
             if data.get("ffmpeg"):
                 self.ffmpeg = Path(data.ffmpeg)
             if data.get("ffprobe"):
-                self.ffmpeg = Path(data.ffprobe)
+                self.ffprobe = Path(data.ffprobe)
             self.disable_automatic_subtitle_burn_in = data.get("disable_automatic_subtitle_burn_in")
             self.disable_update_check = data.get("disable_update_check")
             self.disable_version_check = data.get("disable_update_check", self.disable_update_check)
diff --git a/fastflix/models/encode.py b/fastflix/models/encode.py
index 5746f661..d8974912 100644
--- a/fastflix/models/encode.py
+++ b/fastflix/models/encode.py
@@ -2,9 +2,11 @@
 # -*- coding: utf-8 -*-
 from typing import Optional, Union
 
-from pydantic import BaseModel, Field, field_validator, ConfigDict
+from pydantic import BaseModel, Field, field_validator, model_validator, ConfigDict
 from box import Box
 
+from fastflix.encoders.common.nvenc_options import migrate_legacy_options
+
 
 class AudioTrack(BaseModel):
     index: int
@@ -16,6 +18,7 @@ class AudioTrack(BaseModel):
     conversion_aq: Optional[int] = None
     conversion_bitrate: Optional[str] = None
     conversion_codec: str = ""
+    conversion_profile: Optional[str] = None
     profile: Optional[str] = None
     enabled: bool = True
     original: bool = False
@@ -69,6 +72,20 @@ class DataTrack(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
 
+QSVENC_TUNE_VALUES = ("default", "psnr", "ssim", "ms_ssim", "vmaf", "perceptual")
+
+
+def sanitize_qsv_tune(value) -> Optional[str]:
+    """Return a valid QSVEncC --tune value (comma separated list), or None.
+
+    Older configs stored NVEncC values (hq, ll, ull, lossless) which QSVEncC rejects; those are dropped.
+    """
+    if not value or not isinstance(value, str):
+        return None
+    parts = [p.strip() for p in value.split(",") if p.strip().lower() in QSVENC_TUNE_VALUES]
+    return ",".join(p.lower() for p in parts) or None
+
+
 class EncoderSettings(BaseModel):
     max_muxing_queue_size: str = "1024"
     pix_fmt: str = "yuv420p10le"
@@ -128,6 +145,7 @@ class x264Settings(EncoderSettings):
     bitrate: Optional[str] = None
     bitrate_passes: int = 2
     x264_params: list[str] = Field(default_factory=list)
+    lossless: bool = False
 
 
 class FFmpegNVENCSettings(EncoderSettings):
@@ -147,6 +165,20 @@ class FFmpegNVENCSettings(EncoderSettings):
     gpu: int = -1
     b_ref_mode: str = "disabled"
     hw_accel: bool = False
+    multipass: str = "fullres"
+    temporal_aq: int = 0
+    aq_strength: int = 8
+    tf_level: str = "default"
+    lookahead_level: str = "default"
+    split_encode_mode: str = "default"
+    weighted_pred: int = 0
+    unidir_b: bool = False
+    no_scenecut: bool = False
+
+    @model_validator(mode="before")
+    @classmethod
+    def migrate_legacy_nvenc(cls, data):
+        return migrate_legacy_options(data)
 
     @field_validator("qp", mode="before")
     @classmethod
@@ -174,6 +206,12 @@ class FFmpegAV1NVENCSettings(EncoderSettings):
     gpu: int = -1
     b_ref_mode: str = "middle"
     hw_accel: bool = False
+    cq: int = 0
+    tf_level: str = "default"
+    lookahead_level: str = "default"
+    split_encode_mode: str = "default"
+    weighted_pred: int = 0
+    no_scenecut: bool = False
 
     @field_validator("qp", mode="before")
     @classmethod
@@ -187,7 +225,9 @@ class NVEncCSettings(EncoderSettings):
     name: str = "HEVC (NVEncC)"
     preset: str = "quality"
     profile: str = "auto"
+    tune: str = "hq"
     bitrate: Optional[str] = "5000k"
+    qvbr_quality: str = "off"
     cqp: Optional[Union[int, float]] = None
     aq: str = "off"
     aq_strength: int = 0
@@ -230,7 +270,9 @@ class NVEncCAV1Settings(EncoderSettings):
     name: str = "AV1 (NVEncC)"
     preset: str = "quality"
     profile: str = "auto"
+    tune: str = "hq"
     bitrate: Optional[str] = "5000k"
+    qvbr_quality: str = "off"
     cqp: Optional[Union[int, float]] = None
     aq: str = "off"
     aq_strength: int = 0
@@ -273,6 +315,7 @@ class QSVEncCSettings(EncoderSettings):
     name: str = "HEVC (QSVEncC)"
     preset: str = "best"
     bitrate: Optional[str] = "5000k"
+    qvbr_quality: str = "off"
     cqp: Optional[Union[int, float]] = None
     lookahead: Optional[str] = None
     level: Optional[str] = None
@@ -295,6 +338,12 @@ class QSVEncCSettings(EncoderSettings):
     copy_hdr10: bool = False
     copy_dv: bool = False
     split_mode: str = "none"
+    tune: Optional[str] = None
+
+    @field_validator("tune", mode="before")
+    @classmethod
+    def validate_qsv_tune(cls, value):
+        return sanitize_qsv_tune(value)
 
     @field_validator("cqp", mode="before")
     @classmethod
@@ -308,6 +357,7 @@ class QSVEncCAV1Settings(EncoderSettings):
     name: str = "AV1 (QSVEncC)"
     preset: str = "best"
     bitrate: Optional[str] = "5000k"
+    qvbr_quality: str = "off"
     cqp: Optional[Union[int, float]] = None
     lookahead: Optional[str] = None
     level: Optional[str] = None
@@ -330,6 +380,12 @@ class QSVEncCAV1Settings(EncoderSettings):
     copy_hdr10: bool = False
     copy_dv: bool = False
     split_mode: str = "none"
+    tune: Optional[str] = None
+
+    @field_validator("tune", mode="before")
+    @classmethod
+    def validate_qsv_tune(cls, value):
+        return sanitize_qsv_tune(value)
 
     @field_validator("cqp", mode="before")
     @classmethod
@@ -344,6 +400,7 @@ class QSVEncCH264Settings(EncoderSettings):
     preset: str = "best"
     profile: str = "auto"
     bitrate: Optional[str] = "5000k"
+    qvbr_quality: str = "off"
     cqp: Optional[Union[int, float]] = None
     lookahead: Optional[str] = None
     level: Optional[str] = None
@@ -363,6 +420,12 @@ class QSVEncCH264Settings(EncoderSettings):
     adapt_cqm: bool = False
     adapt_ltr: bool = False
     split_mode: str = "none"
+    tune: Optional[str] = None
+
+    @field_validator("tune", mode="before")
+    @classmethod
+    def validate_qsv_tune(cls, value):
+        return sanitize_qsv_tune(value)
 
     @field_validator("cqp", mode="before")
     @classmethod
@@ -376,7 +439,9 @@ class NVEncCAVCSettings(EncoderSettings):
     name: str = "AVC (NVEncC)"
     preset: str = "quality"
     profile: str = "auto"
+    tune: str = "hq"
     bitrate: Optional[str] = "5000k"
+    qvbr_quality: str = "off"
     cqp: Optional[Union[int, float]] = None
     aq: str = "off"
     aq_strength: int = 0
@@ -460,6 +525,7 @@ class VCEEncCAV1Settings(EncoderSettings):
     name: str = "AV1 (VCEEncC)"
     preset: str = "slower"
     bitrate: Optional[str] = "5000k"
+    qvbr_quality: str = "off"
     cqp: Optional[Union[int, float]] = None
     level: Optional[str] = None
     hdr10plus_metadata: str = ""
@@ -505,6 +571,7 @@ class VCEEncCAVCSettings(EncoderSettings):
     preset: str = "slow"
     profile: str = "Auto"
     bitrate: Optional[str] = "5000k"
+    qvbr_quality: str = "off"
     cqp: Optional[Union[int, float]] = None
     tier: str = "high"
     level: Optional[str] = None
@@ -564,22 +631,31 @@ class SVTAV1Settings(EncoderSettings):
     scene_detection: bool = False
     single_pass: bool = False
     speed: str = "7"  # Renamed preset in svtav1 encoder
-    tune: str = "1"  # 0=VQ (Psychovisual), 1=PSNR, 2=SSIM
+    tune: str = "1"  # 0=VQ, 1=PSNR, 2=SSIM, 3=IQ, 4=MS-SSIM, 5=VMAF (video only)
     film_grain: int = 0  # 0-50, 0=off
     film_grain_denoise: bool = False
     sharpness: str = "0"  # -7 to 7
     fast_decode: str = "0"  # 0=off, 1=level 1, 2=level 2
+    enable_variance_boost: bool = False
+    variance_boost_strength: str = "2"  # 1-4
+    variance_octile: str = "5"  # 1-8
+    enable_tf: str = "1"  # 0=off, 1=on, 2=adaptive
+    startup_mg_size: str = "0"  # 0=off, 2-4
+    enable_qm: bool = False
+    qm_min: str = "8"  # 0-15
+    qm_max: str = "15"  # 0-15
     qp: Optional[Union[int, float]] = 24
     qp_mode: str = "crf"
     bitrate: Optional[str] = None
     svtav1_params: list[str] = Field(default_factory=list)
+    lossless: bool = False
 
 
 class SVTAVIFSettings(EncoderSettings):
     name: str = "AVIF (SVT AV1)"
     single_pass: bool = True
     speed: str = "7"  # Renamed preset in svtav1 encoder
-    tune: str = "1"  # 0=VQ (Psychovisual), 1=PSNR, 2=SSIM
+    tune: str = "1"  # 0=VQ, 1=PSNR, 2=SSIM, 3=IQ, 4=MS-SSIM, 5=VMAF (video only)
     sharpness: str = "0"  # -7 to 7
     qp: Optional[Union[int, float]] = 24
     qp_mode: str = "qp"
@@ -604,6 +680,7 @@ class VP9Settings(EncoderSettings):
     tune_content: str = "default"
     aq_mode: int = -1  # -1 = codec default
     sharpness: int = -1  # -1 = codec default, 0-7
+    lossless: bool = False
 
 
 class HEVCVideoToolboxSettings(EncoderSettings):
@@ -617,6 +694,7 @@ class HEVCVideoToolboxSettings(EncoderSettings):
     q: Optional[int] = 50
     bitrate: Optional[str] = None
     pix_fmt: str = "p010le"
+    constant_bit_rate: bool = False
 
 
 class H264VideoToolboxSettings(EncoderSettings):
@@ -630,6 +708,7 @@ class H264VideoToolboxSettings(EncoderSettings):
     q: Optional[int] = 50
     bitrate: Optional[str] = None
     pix_fmt: str = "yuv420p"
+    constant_bit_rate: bool = False
 
 
 class AOMAV1Settings(EncoderSettings):
@@ -644,7 +723,9 @@ class AOMAV1Settings(EncoderSettings):
     aq_mode: str = "default"  # default, 0=none, 1=variance, 2=complexity, 3=cyclic
     crf: Optional[Union[int, float]] = 26
     bitrate: Optional[str] = None
+    single_pass: bool = True
     aom_params: list[str] = Field(default_factory=list)
+    lossless: bool = False
 
 
 class WebPSettings(EncoderSettings):
@@ -745,6 +826,7 @@ class VAAPIHEVCSettings(EncoderSettings):
     qp: Optional[Union[int, float]] = 26
     bitrate: Optional[str] = None
     pix_fmt: str = "vaapi"
+    bit_depth: str = "8-bit"
 
 
 class VAAPIVP9Settings(EncoderSettings):
@@ -758,6 +840,7 @@ class VAAPIVP9Settings(EncoderSettings):
     qp: Optional[Union[int, float]] = 26
     bitrate: Optional[str] = None
     pix_fmt: str = "vaapi"
+    bit_depth: str = "8-bit"
 
 
 class VAAPIMPEG2Settings(EncoderSettings):
diff --git a/fastflix/models/history.py b/fastflix/models/history.py
index 3d8c95a9..08d80402 100644
--- a/fastflix/models/history.py
+++ b/fastflix/models/history.py
@@ -1,7 +1,10 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 import logging
+import os
 import shutil
+import tempfile
+import time
 from pathlib import Path
 from box import Box
 from pydantic import BaseModel, Field
@@ -45,15 +48,25 @@ def get_history_thumbnails_dir(data_path: Path) -> Path:
     return data_path / "history_thumbnails"
 
 
-def load_history(data_path: Path) -> list[HistoryEntry]:
+class HistoryLoadError(Exception):
+    pass
+
+
+class HistoryCorruptError(HistoryLoadError):
+    """The history file was read but its content is not valid YAML."""
+
+
+def load_history_strict(data_path: Path) -> list[HistoryEntry]:
+    """Like load_history, but raises HistoryLoadError if an existing history file cannot be read."""
     history_file = get_history_file(data_path)
     if not history_file.exists():
         return []
     try:
         data = Box.from_yaml(filename=history_file)
-    except Exception:
-        logger.exception("Failed to load history file")
-        return []
+    except OSError as err:
+        raise HistoryLoadError(f"Failed to read history file {history_file}: {err}") from err
+    except Exception as err:
+        raise HistoryCorruptError(f"Failed to parse history file {history_file}: {err}") from err
     entries = []
     for item in data.get("entries", []):
         try:
@@ -63,26 +76,78 @@ def load_history(data_path: Path) -> list[HistoryEntry]:
     return entries
 
 
+def load_history(data_path: Path) -> list[HistoryEntry]:
+    try:
+        return load_history_strict(data_path)
+    except HistoryLoadError:
+        logger.exception("Failed to load history file")
+        return []
+
+
 def save_history(data_path: Path, entries: list[HistoryEntry]):
     history_file = get_history_file(data_path)
+    temp_path = None
     try:
         data = Box(entries=[e.model_dump() for e in entries])
-        data.to_yaml(filename=history_file, default_flow_style=False)
+        history_file.parent.mkdir(parents=True, exist_ok=True)
+        fd, temp_path = tempfile.mkstemp(suffix=".yaml.tmp", prefix="history_", dir=history_file.parent)
+        os.close(fd)
+        data.to_yaml(filename=temp_path, default_flow_style=False)
+        os.replace(temp_path, history_file)
     except Exception:
         logger.exception("Failed to save history file")
+        if temp_path:
+            try:
+                os.unlink(temp_path)
+            except OSError:
+                pass
+
+
+def _delete_thumbnail(thumbs_dir: Path, filename: str):
+    if not filename:
+        return
+    name = Path(filename).name
+    if not name or name in (".", ".."):
+        return
+    thumb_path = thumbs_dir / name
+    try:
+        if thumb_path.resolve().parent != thumbs_dir.resolve():
+            logger.warning(f"Refusing to delete history thumbnail outside of {thumbs_dir}: {filename}")
+            return
+        thumb_path.unlink(missing_ok=True)
+    except OSError:
+        logger.exception(f"Could not delete history thumbnail {thumb_path}")
+
+
+def _load_for_update(data_path: Path) -> list[HistoryEntry] | None:
+    try:
+        return load_history_strict(data_path)
+    except HistoryCorruptError:
+        history_file = get_history_file(data_path)
+        aside = history_file.with_name(f"{history_file.name}.corrupt-{time.strftime('%Y%m%d-%H%M%S')}")
+        try:
+            os.replace(history_file, aside)
+        except OSError:
+            logger.exception("History file is corrupt and could not be moved aside, not modifying it")
+            return None
+        logger.exception(f"History file is corrupt, moved it to {aside} and starting a new history")
+        return []
+    except HistoryLoadError:
+        logger.exception("History file is unreadable, not modifying it to avoid losing existing history")
+        return None
 
 
 def add_history_entry(data_path: Path, entry: HistoryEntry, max_items: int = DEFAULT_MAX_HISTORY):
-    entries = load_history(data_path)
+    entries = _load_for_update(data_path)
+    if entries is None:
+        return
     entries.append(entry)
     if max_items > 0 and len(entries) > max_items:
         removed = entries[: len(entries) - max_items]
         entries = entries[len(entries) - max_items :]
         thumbs_dir = get_history_thumbnails_dir(data_path)
         for old_entry in removed:
-            if old_entry.thumbnail_filename:
-                thumb_path = thumbs_dir / old_entry.thumbnail_filename
-                thumb_path.unlink(missing_ok=True)
+            _delete_thumbnail(thumbs_dir, old_entry.thumbnail_filename)
     save_history(data_path, entries)
 
 
@@ -90,26 +155,26 @@ def trim_history(data_path: Path, max_items: int):
     """Trim history to max_items, removing oldest entries. Negative means unlimited."""
     if max_items <= 0:
         return
-    entries = load_history(data_path)
-    if len(entries) <= max_items:
+    entries = _load_for_update(data_path)
+    if entries is None or len(entries) <= max_items:
         return
     removed = entries[: len(entries) - max_items]
     entries = entries[len(entries) - max_items :]
     thumbs_dir = get_history_thumbnails_dir(data_path)
     for old_entry in removed:
-        if old_entry.thumbnail_filename:
-            (thumbs_dir / old_entry.thumbnail_filename).unlink(missing_ok=True)
+        _delete_thumbnail(thumbs_dir, old_entry.thumbnail_filename)
     save_history(data_path, entries)
 
 
 def delete_history_entry(data_path: Path, uuid: str):
-    entries = load_history(data_path)
+    entries = _load_for_update(data_path)
+    if entries is None:
+        return
     thumbs_dir = get_history_thumbnails_dir(data_path)
     entries_new = []
     for entry in entries:
         if entry.uuid == uuid:
-            if entry.thumbnail_filename:
-                (thumbs_dir / entry.thumbnail_filename).unlink(missing_ok=True)
+            _delete_thumbnail(thumbs_dir, entry.thumbnail_filename)
         else:
             entries_new.append(entry)
     save_history(data_path, entries_new)
diff --git a/fastflix/models/profiles.py b/fastflix/models/profiles.py
index 60c76fb1..10ed7d04 100644
--- a/fastflix/models/profiles.py
+++ b/fastflix/models/profiles.py
@@ -48,6 +48,8 @@ class MatchItem(Enum):
     TRACK = 3
     LANGUAGE = 4
     CHANNELS = 5
+    CODEC = 6
+    CODEC_PROFILE = 7
 
 
 class MatchType(Enum):
@@ -68,6 +70,7 @@ class AudioMatch(BaseModel):
     match_item: Union[MatchItem, list[MatchItem]]
     match_input: str = "*"
     conversion: Optional[str] = None
+    conversion_profile: Optional[str] = None
     bitrate: Optional[str] = None
     downmix: Optional[Union[str, int]] = None
     title_mode: Union[TitleMode, list[TitleMode]] = TitleMode.ORIGINAL
@@ -124,6 +127,7 @@ class SubtitleMatch(BaseModel):
 
 class AdvancedOptions(BaseModel):
     video_speed: float = 1
+    reverse_video: bool = False
     deblock: Optional[str] = None
     deblock_size: int = 16
     tone_map: str = "hable"
@@ -131,6 +135,14 @@ class AdvancedOptions(BaseModel):
     brightness: Optional[str] = None
     saturation: Optional[str] = None
     contrast: Optional[str] = None
+    gamma: Optional[str] = None
+    hue: Optional[str] = None
+    sharpen: Optional[str] = None
+    faststart: bool = True
+    deinterlace: bool = False
+    deinterlace_method_index: int = 0
+    deinterlace_mode_index: int = 0
+    gop_length: Optional[int] = None
     maxrate: Optional[int] = None
     bufsize: Optional[int] = None
     source_fps: Optional[str] = None
@@ -141,6 +153,20 @@ class AdvancedOptions(BaseModel):
     denoise: Optional[str] = None
     denoise_type_index: int = 0
     denoise_strength_index: int = 0
+    vibrance: Optional[str] = None
+    color_temperature: Optional[str] = None
+    curves_preset: Optional[str] = None
+    curves_preset_index: int = 0
+    colorbalance: Optional[str] = None
+    colorbalance_index: int = 0
+    unsharp: Optional[str] = None
+    unsharp_index: int = 0
+    deflicker: Optional[str] = None
+    deflicker_index: int = 0
+    pad_aspect: Optional[str] = None
+    pad_aspect_index: int = 0
+    pad_color: str = "black"
+    lut3d_path: Optional[str] = None
 
 
 class Profile(BaseModel):
@@ -173,6 +199,8 @@ class Profile(BaseModel):
     subtitle_select_preferred_language: Optional[bool] = None
     subtitle_automatic_burn_in: Optional[bool] = None
     subtitle_select_first_matching: Optional[bool] = None
+    subtitle_default_disposition: Optional[str] = None  # None=keep source, "clear", "first"
+    subtitle_forced_disposition: Optional[str] = None  # None=keep source, "clear", "first"
 
     advanced_options: AdvancedOptions = Field(default_factory=AdvancedOptions)
 
diff --git a/fastflix/models/video.py b/fastflix/models/video.py
index 08af2242..c5095e9e 100644
--- a/fastflix/models/video.py
+++ b/fastflix/models/video.py
@@ -104,11 +104,13 @@ class VideoSettings(BaseModel):
     resolution_method: str = "auto"
     resolution_custom: str | None = None
     deinterlace: bool = False
+    deinterlace_filter: str = "yadif"
     video_speed: Union[float, int] = 1
+    reverse_video: bool = False
     tone_map: str = "hable"
     denoise: Optional[str] = None
     deblock: Optional[str] = None
-    deblock_size: int = 4
+    deblock_size: int = 16
     color_space: Optional[str] = None
     color_transfer: Optional[str] = None
     color_primaries: Optional[str] = None
@@ -120,6 +122,20 @@ class VideoSettings(BaseModel):
     brightness: Optional[str] = None
     contrast: Optional[str] = None
     saturation: Optional[str] = None
+    gamma: Optional[str] = None
+    hue: Optional[str] = None
+    sharpen: Optional[str] = None
+    vibrance: Optional[str] = None
+    color_temperature: Optional[str] = None
+    curves_preset: Optional[str] = None
+    colorbalance: Optional[str] = None
+    unsharp: Optional[str] = None
+    deflicker: Optional[str] = None
+    pad_aspect: Optional[str] = None
+    pad_color: str = "black"
+    lut3d_path: Optional[str] = None
+    faststart: bool = True
+    gop_length: Optional[int] = None
     copy_data: bool = False
     template_generated_name: str = ""
     video_encoder_settings: Optional[
@@ -172,14 +188,49 @@ def brightness_to_str(cls, value):
     @classmethod
     def contrast_to_str(cls, value):
         if isinstance(value, (int, float)):
-            return float(value)
+            return str(value)
         return value
 
     @field_validator("saturation", mode="before")
     @classmethod
     def saturation_to_str(cls, value):
         if isinstance(value, (int, float)):
-            return float(value)
+            return str(value)
+        return value
+
+    @field_validator("gamma", mode="before")
+    @classmethod
+    def gamma_to_str(cls, value):
+        if isinstance(value, (int, float)):
+            return str(value)
+        return value
+
+    @field_validator("hue", mode="before")
+    @classmethod
+    def hue_to_str(cls, value):
+        if isinstance(value, (int, float)):
+            return str(value)
+        return value
+
+    @field_validator("sharpen", mode="before")
+    @classmethod
+    def sharpen_to_str(cls, value):
+        if isinstance(value, (int, float)):
+            return str(value)
+        return value
+
+    @field_validator("vibrance", mode="before")
+    @classmethod
+    def vibrance_to_str(cls, value):
+        if isinstance(value, (int, float)):
+            return str(value)
+        return value
+
+    @field_validator("color_temperature", mode="before")
+    @classmethod
+    def color_temperature_to_str(cls, value):
+        if isinstance(value, (int, float)):
+            return str(value)
         return value
 
 
@@ -327,20 +378,118 @@ def sar(self):
             return ""
         return stream.get("sample_aspect_ratio", "1:1")
 
+    @staticmethod
+    def compute_output_dimensions(
+        source_w: int,
+        source_h: int,
+        crop_top: int = 0,
+        crop_bottom: int = 0,
+        crop_left: int = 0,
+        crop_right: int = 0,
+        method: str = "auto",
+        custom: Optional[str] = None,
+    ) -> Tuple[Optional[int], Optional[int]]:
+        """Compute final output width and height after crop + scale + rounding.
+
+        Returns (None, None) if method is "auto" or inputs are invalid.
+        Returns (width, height) with the auto-calculated dimension rounded to the nearest multiple of 8
+        (or of N for a custom w:-N / -N:h value; -1 rounds to the nearest integer).
+        """
+        cropped_w = source_w - crop_left - crop_right
+        cropped_h = source_h - crop_top - crop_bottom
+
+        if cropped_w <= 0 or cropped_h <= 0:
+            return None, None
+
+        if method == "auto" or not custom:
+            return None, None
+
+        def snap(value: float, multiple: int = 8) -> int:
+            """Round to the nearest multiple (half up), never below one multiple."""
+            return max(int((value + multiple / 2) // multiple) * multiple, multiple)
+
+        try:
+            if method == "custom":
+                parts = custom.split(":")
+                if len(parts) != 2:
+                    return None, None
+                w, h = int(parts[0]), int(parts[1])
+                if w > 0 and h > 0:
+                    return w, h
+                if w > 0 and h < 0:
+                    # -1 nearest int, -2 even, -N multiple of N (FFmpeg scale semantics)
+                    return w, snap(cropped_h * w / cropped_w, -h)
+                if h > 0 and w < 0:
+                    return snap(cropped_w * h / cropped_h, -w), h
+                return None, None
+
+            pixels = int(custom)
+            if pixels <= 0:
+                return None, None
+
+            if method == "width":
+                return pixels, snap(cropped_h * pixels / cropped_w)
+
+            if method == "height":
+                return snap(cropped_w * pixels / cropped_h), pixels
+
+            if method == "long edge":
+                if cropped_w >= cropped_h:
+                    return pixels, snap(cropped_h * pixels / cropped_w)
+                return snap(cropped_w * pixels / cropped_h), pixels
+        except (ValueError, ZeroDivisionError):
+            return None, None
+
+        return None, None
+
+    @property
+    def cropped_width(self) -> int:
+        if not self.video_settings.crop:
+            return self.width
+        return self.width - self.video_settings.crop.left - self.video_settings.crop.right
+
+    @property
+    def cropped_height(self) -> int:
+        if not self.video_settings.crop:
+            return self.height
+        return self.height - self.video_settings.crop.top - self.video_settings.crop.bottom
+
+    @property
+    def output_width(self) -> Optional[int]:
+        crop = self.video_settings.crop
+        w, _ = self.compute_output_dimensions(
+            source_w=self.width,
+            source_h=self.height,
+            crop_top=crop.top if crop else 0,
+            crop_bottom=crop.bottom if crop else 0,
+            crop_left=crop.left if crop else 0,
+            crop_right=crop.right if crop else 0,
+            method=self.video_settings.resolution_method,
+            custom=self.video_settings.resolution_custom,
+        )
+        return w
+
+    @property
+    def output_height(self) -> Optional[int]:
+        crop = self.video_settings.crop
+        _, h = self.compute_output_dimensions(
+            source_w=self.width,
+            source_h=self.height,
+            crop_top=crop.top if crop else 0,
+            crop_bottom=crop.bottom if crop else 0,
+            crop_left=crop.left if crop else 0,
+            crop_right=crop.right if crop else 0,
+            method=self.video_settings.resolution_method,
+            custom=self.video_settings.resolution_custom,
+        )
+        return h
+
     @property
-    def scale(self):
-        if self.video_settings.resolution_method == "auto":
+    def scale(self) -> Optional[str]:
+        ow = self.output_width
+        oh = self.output_height
+        if ow is None or oh is None:
             return None
-        if self.video_settings.resolution_method == "custom":
-            return self.video_settings.resolution_custom
-        if self.video_settings.resolution_method == "long edge":
-            if self.width > self.height:
-                return f"{self.video_settings.resolution_custom}:-8"
-            else:
-                return f"-8:{self.video_settings.resolution_custom}"
-        if self.video_settings.resolution_method == "width":
-            return f"{self.video_settings.resolution_custom}:-8"
-        else:
-            return f"-8:{self.video_settings.resolution_custom}"
+        return f"{ow}:{oh}"
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
diff --git a/fastflix/naming.py b/fastflix/naming.py
index f4d58506..ec7ac41e 100644
--- a/fastflix/naming.py
+++ b/fastflix/naming.py
@@ -259,11 +259,10 @@ def resolve_pre_encode_variables(
 
     # Output resolution
     if video_settings is not None and video is not None:
-        scale = video.scale
-        if scale:
-            variables["resolution"] = scale.replace(":", "x").replace("-8", "auto")
+        if video.output_width is not None and video.output_height is not None:
+            variables["resolution"] = f"{video.output_width}x{video.output_height}"
         else:
-            variables["resolution"] = f"{video.width}x{video.height}"
+            variables["resolution"] = f"{video.cropped_width}x{video.cropped_height}"
     else:
         variables["resolution"] = variables.get("source_resolution", "N-A")
 
diff --git a/fastflix/program_downloads.py b/fastflix/program_downloads.py
index 412225c0..28507123 100644
--- a/fastflix/program_downloads.py
+++ b/fastflix/program_downloads.py
@@ -5,6 +5,7 @@
 import shutil
 import sys
 from pathlib import Path
+import hashlib
 import re
 import subprocess
 
@@ -47,7 +48,95 @@ def ask_for_ffmpeg():
         sys.exit(1)
 
 
-ffmpeg_version_re = re.compile(r"ffmpeg-n(\d+\.\d+)-latest-win64-gpl-")
+ffmpeg_version_re = re.compile(r"^ffmpeg-n(\d+)\.(\d+)-latest-win64-gpl-\d+(?:\.\d+)*\.zip$")
+latest_ffmpeg_name = "ffmpeg-master-latest-win64-gpl.zip"
+REQUEST_TIMEOUT = 15
+DOWNLOAD_TIMEOUT = 30
+
+
+def get_release_json(url: str) -> dict:
+    resp = requests.get(url, timeout=REQUEST_TIMEOUT)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def release_assets(data) -> list:
+    """Return the assets of a GitHub release response, with a clear error for API error payloads."""
+    if not isinstance(data, dict) or "assets" not in data:
+        detail = data.get("message", "") if isinstance(data, dict) else ""
+        hint = " (GitHub API rate limit reached, try again later)" if "rate limit" in detail.lower() else ""
+        raise FastFlixError(f"Unexpected response from GitHub: {detail or 'no assets listed'}{hint}")
+    return data["assets"]
+
+
+def select_stable_ffmpeg_asset(assets) -> dict | None:
+    best = None
+    best_version = None
+    for asset in assets:
+        if match := ffmpeg_version_re.match(asset["name"]):
+            version = (int(match.group(1)), int(match.group(2)))
+            if best_version is None or version > best_version:
+                best, best_version = asset, version
+    return best
+
+
+def select_latest_ffmpeg_asset(assets) -> dict | None:
+    for asset in assets:
+        if asset["name"] == latest_ffmpeg_name:
+            return asset
+    return None
+
+
+def expected_sha256(asset: dict, assets: list) -> str | None:
+    """Find a published SHA256 for an asset: GitHub's `digest` field, or a checksums.sha256 file in the release."""
+    digest = asset.get("digest")
+    if isinstance(digest, str) and digest.lower().startswith("sha256:"):
+        return digest.split(":", 1)[1].strip().lower()
+    for other in assets:
+        if other["name"] == "checksums.sha256":
+            try:
+                resp = requests.get(other["browser_download_url"], timeout=REQUEST_TIMEOUT)
+                resp.raise_for_status()
+            except Exception:
+                logger.warning("Could not download checksums.sha256")
+                return None
+            for line in resp.text.splitlines():
+                parts = line.split(maxsplit=1)
+                if len(parts) == 2 and parts[1].strip().lstrip("*") == asset["name"]:
+                    return parts[0].strip().lower()
+    return None
+
+
+def verify_sha256(path, expected: str | None):
+    if not expected:
+        logger.warning(f"No published checksum available for {Path(path).name}, skipping integrity verification")
+        return
+    sha = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b""):
+            sha.update(chunk)
+    if sha.hexdigest().lower() != expected.lower():
+        try:
+            Path(path).unlink()
+        except OSError:
+            pass
+        raise FastFlixError(f"SHA256 checksum mismatch for {Path(path).name}, download discarded")
+    logger.debug(f"SHA256 verified for {Path(path).name}")
+
+
+def download_file(url: str, filename, progress, is_stopped) -> bool:
+    """Stream url to filename. Returns False (and removes the partial file) if cancelled."""
+    req = requests.get(url, stream=True, timeout=DOWNLOAD_TIMEOUT)
+    req.raise_for_status()
+    with open(filename, "wb") as f:
+        for i, block in enumerate(req.iter_content(chunk_size=1024)):
+            progress(i)
+            f.write(block)
+            if is_stopped():
+                f.close()
+                Path(filename).unlink(missing_ok=True)
+                return False
+    return True
 
 
 def grab_stable_ffmpeg(signal, stop_signal, **_):
@@ -76,7 +165,8 @@ def stop_me():
     url = "https://api.github.com/repos/BtbN/FFmpeg-Builds/releases/latest"
 
     try:
-        data = requests.get(url, timeout=15).json()
+        data = get_release_json(url)
+        assets = release_assets(data)
     except Exception:
         shutil.rmtree(extract_folder, ignore_errors=True)
         message(t("Could not connect to github to check for newer versions."))
@@ -87,19 +177,10 @@ def stop_me():
         message(t("Download Cancelled"))
         return
 
-    gpl_ffmpeg = None
-
     if ffmpeg_version == "latest":
-        for asset in data["assets"]:
-            if "master-latest-win64-gpl.zip" in asset["name"]:
-                gpl_ffmpeg = asset
-                break
+        gpl_ffmpeg = select_latest_ffmpeg_asset(assets)
     else:
-        versions = []
-        for asset in data["assets"]:
-            if ver_match := ffmpeg_version_re.search(asset["name"]):
-                versions.append((float(ver_match.group(1)), asset))
-        gpl_ffmpeg = sorted(versions, key=lambda x: x[0], reverse=True)[0][1]
+        gpl_ffmpeg = select_stable_ffmpeg_asset(assets)
 
     if not gpl_ffmpeg:
         shutil.rmtree(extract_folder, ignore_errors=True)
@@ -108,25 +189,20 @@ def stop_me():
             + f" {t('latest release from')} <a href='https://github.com/BtbN/FFmpeg-Builds/releases/'>"
             "https://github.com/BtbN/FFmpeg-Builds/releases/</a> and reach out to FastFlix team about this issue if they exist."
         )
-        raise Exception()
+        raise FastFlixError("Could not find a matching FFmpeg build in the latest release")
 
     logger.debug(f"Downloading version {gpl_ffmpeg['name']}")
 
-    req = requests.get(gpl_ffmpeg["browser_download_url"], stream=True)
-
     filename = ffmpeg_folder / "ffmpeg-full.zip"
-    with open(filename, "wb") as f:
-        for i, block in enumerate(req.iter_content(chunk_size=1024)):
-            if i % 1000 == 0.0:
-                # logger.debug(f"Downloaded {i // 1000}MB")
-                signal.emit(int(((i * 1024) / gpl_ffmpeg["size"]) * 90))
-            f.write(block)
-            if stop:
-                f.close()
-                Path(filename).unlink()
-                shutil.rmtree(extract_folder, ignore_errors=True)
-                message(t("Download Cancelled"))
-                return
+
+    def progress(i):
+        if i % 1000 == 0:
+            signal.emit(int(((i * 1024) / gpl_ffmpeg["size"]) * 90))
+
+    if not download_file(gpl_ffmpeg["browser_download_url"], filename, progress, lambda: stop):
+        shutil.rmtree(extract_folder, ignore_errors=True)
+        message(t("Download Cancelled"))
+        return
 
     if filename.stat().st_size < 1000:
         message(t("FFmpeg was not properly downloaded as the file size is too small"))
@@ -134,7 +210,9 @@ def stop_me():
             Path(filename).unlink()
         except OSError:
             pass
-        raise
+        raise FastFlixError("FFmpeg was not properly downloaded as the file size is too small")
+
+    verify_sha256(filename, expected_sha256(gpl_ffmpeg, assets))
 
     try:
         reusables.extract(filename, path=extract_folder)
@@ -159,7 +237,9 @@ def stop_me():
         pass
 
     signal.emit(96)
-    sub_dir = next(Path(extract_folder).glob("ffmpeg-*"))
+    sub_dir = next(Path(extract_folder).glob("ffmpeg-*"), None)
+    if sub_dir is None:
+        raise FastFlixError("Could not find the FFmpeg folder in the extracted files")
 
     for item in os.listdir(sub_dir):
         dest = ffmpeg_folder / item
@@ -195,7 +275,8 @@ def stop_me():
     url = f"https://api.github.com/repos/rigaya/{app_name}/releases/latest"
 
     try:
-        data = requests.get(url, timeout=15).json()
+        data = get_release_json(url)
+        assets = release_assets(data)
     except Exception:
         logger.exception(t("Could not connect to GitHub to check for newer versions."))
         raise
@@ -205,7 +286,7 @@ def stop_me():
         return
 
     asset = None
-    for possible_asset in data["assets"]:
+    for possible_asset in assets:
         if "x64.7z" in possible_asset["name"]:
             asset = possible_asset
             break
@@ -217,21 +298,14 @@ def stop_me():
             f"https://github.com/rigaya/{app_name}/releases/</a> "
             f"and reach out to FastFlix team about this issue if they exist."
         )
-        raise Exception()
+        raise FastFlixError(f"Could not find a matching {app_name} release asset")
 
     logger.debug(f"Downloading version {asset['name']}")
 
-    req = requests.get(asset["browser_download_url"], stream=True)
-
     filename = asset_folder / "download-full.7z"
-    with open(filename, "wb") as f:
-        for i, block in enumerate(req.iter_content(chunk_size=1024)):
-            f.write(block)
-            if stop:
-                f.close()
-                Path(filename).unlink()
-                message(t("Download Cancelled"))
-                return
+    if not download_file(asset["browser_download_url"], filename, lambda i: None, lambda: stop):
+        message(t("Download Cancelled"))
+        return
 
     if filename.stat().st_size < 1000:
         logger.error(t("NVEnc was not properly downloaded as the file size is too small"))
@@ -239,7 +313,9 @@ def stop_me():
             Path(filename).unlink()
         except OSError:
             pass
-        raise
+        raise FastFlixError(f"{app_name} was not properly downloaded as the file size is too small")
+
+    verify_sha256(filename, expected_sha256(asset, assets))
 
     try:
         subprocess.run([seven_zip_path, "e", str(filename), "-o" + str(asset_folder), "-y"], check=True)
@@ -250,8 +326,8 @@ def stop_me():
     if stop:
         Path(filename).unlink()
         return
-    file = next(asset_folder.glob(f"{app_name}*64.exe"))
-    if not file.exists():
+    file = next(asset_folder.glob(f"{app_name}*64.exe"), None)
+    if not file or not file.exists():
         logger.error(t("Could not find the executable in the extracted files"))
         raise FastFlixError(t("Could not find the executable in the extracted files"))
     return file
@@ -272,15 +348,9 @@ def stop_me():
     url = "https://www.7-zip.org/a/7zr.exe"
 
     try:
-        req = requests.get(url, stream=True, timeout=15)
-        with open(filename, "wb") as f:
-            for i, block in enumerate(req.iter_content(chunk_size=1024)):
-                f.write(block)
-                if stop:
-                    f.close()
-                    Path(filename).unlink()
-                    message(t("Download Cancelled"))
-                    return
+        if not download_file(url, filename, lambda i: None, lambda: stop):
+            message(t("Download Cancelled"))
+            return
     except Exception as e:
         raise FastFlixError(f"Could not download 7-Zip: {e}")
 
@@ -289,8 +359,9 @@ def stop_me():
             Path(filename).unlink()
         except OSError:
             pass
-        raise FastFlixError("Could not download 7-Zip - filesize too msall")
+        raise FastFlixError("Could not download 7-Zip - filesize too small")
 
+    logger.warning("No published checksum for 7zr.exe, skipping integrity verification")
     return filename
 
 
@@ -316,7 +387,8 @@ def stop_me():
     url = "https://api.github.com/repos/quietvoid/hdr10plus_tool/releases/latest"
 
     try:
-        data = requests.get(url, timeout=15).json()
+        data = get_release_json(url)
+        assets = release_assets(data)
     except Exception:
         shutil.rmtree(extract_folder, ignore_errors=True)
         message(t("Could not connect to github to check for newer versions."))
@@ -328,7 +400,7 @@ def stop_me():
         return
 
     asset = None
-    for possible_asset in data.get("assets", []):
+    for possible_asset in assets:
         if "x86_64-pc-windows-msvc.zip" in possible_asset["name"]:
             asset = possible_asset
             break
@@ -340,24 +412,20 @@ def stop_me():
             + f" {t('latest release from')} <a href='https://github.com/quietvoid/hdr10plus_tool/releases/'>"
             "https://github.com/quietvoid/hdr10plus_tool/releases/</a>"
         )
-        raise Exception()
+        raise FastFlixError("Could not find a matching hdr10plus_tool release asset")
 
     logger.debug(f"Downloading version {asset['name']}")
 
-    req = requests.get(asset["browser_download_url"], stream=True)
-
     filename = ffmpeg_folder / "hdr10plus_tool.zip"
-    with open(filename, "wb") as f:
-        for i, block in enumerate(req.iter_content(chunk_size=1024)):
-            if i % 1000 == 0.0:
-                signal.emit(int(((i * 1024) / asset["size"]) * 90))
-            f.write(block)
-            if stop:
-                f.close()
-                Path(filename).unlink()
-                shutil.rmtree(extract_folder, ignore_errors=True)
-                message(t("Download Cancelled"))
-                return
+
+    def progress(i):
+        if i % 1000 == 0:
+            signal.emit(int(((i * 1024) / asset["size"]) * 90))
+
+    if not download_file(asset["browser_download_url"], filename, progress, lambda: stop):
+        shutil.rmtree(extract_folder, ignore_errors=True)
+        message(t("Download Cancelled"))
+        return
 
     if filename.stat().st_size < 1000:
         message(t("hdr10plus_tool was not properly downloaded as the file size is too small"))
@@ -367,6 +435,8 @@ def stop_me():
             pass
         raise FastFlixError("hdr10plus_tool download too small")
 
+    verify_sha256(filename, expected_sha256(asset, assets))
+
     try:
         reusables.extract(filename, path=extract_folder)
     except Exception:
diff --git a/fastflix/resources.py b/fastflix/resources.py
index 39ae9c2d..b0d76918 100644
--- a/fastflix/resources.py
+++ b/fastflix/resources.py
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 from pathlib import Path
 import os
+import sys
 from functools import lru_cache
 
 import importlib.resources
@@ -84,3 +85,21 @@ def get_bool_env(variable: str):
     if var.lower() in ("1", "on", "yes", "true", "t"):
         return True
     return False
+
+
+def clean_env() -> dict:
+    """Return a copy of os.environ that is safe for launching external tools (FFmpeg, FFprobe, rigaya, etc).
+
+    A PyInstaller onefile build points LD_LIBRARY_PATH at its bundled libraries, so system binaries such as
+    /usr/bin/ffmpeg would load those (e.g. an incompatible libass) instead of the system ones. PyInstaller keeps
+    the user's original value in LD_LIBRARY_PATH_ORIG, which is restored here (or the variable is removed).
+    Kept in this Qt-free module so the conversion worker process can use it without importing PySide6.
+    """
+    env = os.environ.copy()
+    if getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS"):
+        original = env.pop("LD_LIBRARY_PATH_ORIG", None)
+        if original is not None:
+            env["LD_LIBRARY_PATH"] = original
+        else:
+            env.pop("LD_LIBRARY_PATH", None)
+    return env
diff --git a/fastflix/rigaya_helpers.py b/fastflix/rigaya_helpers.py
index a971739b..bbc8920b 100644
--- a/fastflix/rigaya_helpers.py
+++ b/fastflix/rigaya_helpers.py
@@ -1,6 +1,13 @@
 # -*- coding: utf-8 -*-
 from dataclasses import dataclass, field
-from subprocess import run, PIPE
+import logging
+from subprocess import run, PIPE, TimeoutExpired
+
+from fastflix.resources import clean_env
+
+logger = logging.getLogger("fastflix")
+
+CHECK_FEATURES_TIMEOUT = 60
 
 
 @dataclass
@@ -69,17 +76,38 @@ def parse_qsv_devices(split_text: list[str]) -> QSVEncoder:
     return encoder
 
 
+def _check_features(executable, args, quiet_failure=False) -> list[str] | None:
+    command = [str(executable), "--check-features", *args]
+    try:
+        result = run(
+            command, stdout=PIPE, stderr=PIPE, encoding="utf-8", env=clean_env(), timeout=CHECK_FEATURES_TIMEOUT
+        )
+    except TimeoutExpired:
+        logger.warning(f"Timed out after {CHECK_FEATURES_TIMEOUT}s running {' '.join(command)}")
+        return None
+    except OSError as err:
+        logger.warning(f"Could not run {' '.join(command)}: {err}")
+        return None
+    if result.returncode != 0:
+        log = logger.debug if quiet_failure else logger.warning
+        log(f"{' '.join(command)} exited with code {result.returncode}: {(result.stderr or '').strip()[:500]}")
+        return None
+    return result.stdout.splitlines()
+
+
 def run_check_features(executable, is_qsv=False):
     outputs = []
     if is_qsv:
-        result = run([executable, "--check-features"], stdout=PIPE, stderr=PIPE, encoding="utf-8")
-        outputs.append(result.stdout.splitlines())
+        output = _check_features(executable, [])
+        if output is not None:
+            outputs.append(output)
     else:
         for i in range(10):
-            result = run([executable, "--check-features", str(i)], stdout=PIPE, stderr=PIPE, encoding="utf-8")
-            if result.stderr:
+            # Running past the last device is expected to fail, only the first device failing is worth a warning
+            output = _check_features(executable, [str(i)], quiet_failure=i > 0)
+            if output is None:
                 break
-            outputs.append(result.stdout.splitlines())
+            outputs.append(output)
 
     return outputs
 
diff --git a/fastflix/shared.py b/fastflix/shared.py
index c2d55239..c379035d 100644
--- a/fastflix/shared.py
+++ b/fastflix/shared.py
@@ -16,6 +16,11 @@
 from pathvalidate import sanitize_filepath
 
 
+from PySide6 import QtCore, QtGui, QtWidgets
+
+from fastflix.language import t
+from fastflix.resources import clean_env, get_bool_env  # noqa: F401 (clean_env re-exported)
+
 try:
     # PyInstaller creates a temp folder and stores path in _MEIPASS
     # noinspection PyUnresolvedReferences
@@ -25,10 +30,11 @@
     base_path = os.path.abspath(".")
     pyinstaller = False
 
-from PySide6 import QtGui, QtWidgets
+# Detect if running from the Go launcher (embeddable Python distribution)
+go_launcher = os.environ.get("FASTFLIX_BUNDLED") == "1"
 
-from fastflix.language import t
-from fastflix.resources import get_bool_env
+# True when running as any kind of packaged distribution (PyInstaller or Go launcher)
+bundled_mode = pyinstaller or go_launcher
 
 DEVMODE = get_bool_env("DEVMODE")
 
@@ -153,15 +159,18 @@ def yes_no_message(msg, title=None, yes_text=t("Yes"), no_text=t("No"), yes_acti
     dialog._button_clicked = None
 
     layout = QtWidgets.QVBoxLayout()
+    layout.setContentsMargins(20, 15, 20, 15)
+    layout.setSpacing(15)
     label = QtWidgets.QLabel(msg)
     label.setWordWrap(True)
+    label.setAlignment(QtCore.Qt.AlignCenter)
     layout.addWidget(label)
 
     button_layout = QtWidgets.QHBoxLayout()
 
     no_button = QtWidgets.QPushButton(no_text)
     no_button.setMinimumHeight(30)
-    no_button.setStyleSheet("QPushButton { background-color: #F44336; color: white; padding: 6px 20px; }")
+    no_button.setStyleSheet("QPushButton { background-color: #555555; color: white; padding: 6px 20px; }")
 
     def on_no():
         dialog._button_clicked = False
@@ -171,7 +180,7 @@ def on_no():
 
     yes_button = QtWidgets.QPushButton(yes_text)
     yes_button.setMinimumHeight(30)
-    yes_button.setStyleSheet("QPushButton { background-color: #4CAF50; color: white; padding: 6px 20px; }")
+    yes_button.setStyleSheet("QPushButton { background-color: #4a9eed; color: white; padding: 6px 20px; }")
 
     def on_yes():
         dialog._button_clicked = True
@@ -185,6 +194,9 @@ def on_yes():
     layout.addLayout(button_layout)
 
     dialog.setLayout(layout)
+    dialog.setWindowIcon(QtGui.QIcon(my_data))
+    dialog.setSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
+    dialog.adjustSize()
     dialog.exec()
 
     if dialog._button_clicked is True:
@@ -198,6 +210,35 @@ def on_yes():
     return None
 
 
+def parse_release_version(tag):
+    try:
+        return packaging_version.parse(str(tag).strip().lstrip("vV"))
+    except packaging_version.InvalidVersion:
+        return None
+
+
+def select_release(data, legacy_windows=False):
+    """Pick the newest stable release from the GitHub releases response; None if nothing usable."""
+    best, best_version = None, None
+    if not isinstance(data, list):
+        return None
+    for release in data:
+        if not isinstance(release, dict) or release.get("prerelease") or release.get("draft"):
+            continue
+        version = parse_release_version(release.get("tag_name", ""))
+        if version is None or version.is_prerelease:
+            continue
+        if legacy_windows and version.major != 4:
+            continue
+        if best_version is None or version > best_version:
+            best, best_version = release, version
+    return best
+
+
+def safe_release_url(url):
+    return isinstance(url, str) and url.startswith("https://github.com/cdgriffith/FastFlix/")
+
+
 def latest_fastflix(app, show_new_dialog=False):
     from fastflix.version import __version__
 
@@ -211,7 +252,7 @@ def latest_fastflix(app, show_new_dialog=False):
     logger.debug("Checking for newer versions of FastFlix")
 
     try:
-        response = requests.get(url, timeout=15 if not show_new_dialog else 3)
+        response = requests.get(url, timeout=15 if show_new_dialog else 3)
         response.raise_for_status()
         data = response.json()
     except Exception:
@@ -220,12 +261,7 @@ def latest_fastflix(app, show_new_dialog=False):
             message(t("Could not connect to github to check for newer versions"))
         return
 
-    versions = sorted(
-        (tuple(int(y) for y in x["tag_name"].split(".")) for x in data if not x["prerelease"] and not x["draft"]),
-        reverse=True,
-    )
-
-    use_version = ".".join(str(x) for x in versions[0])
+    legacy_windows = False
     if reusables.win_based:
         try:
             win_ver = int(platform.platform().lower().split("-")[1])
@@ -233,21 +269,29 @@ def latest_fastflix(app, show_new_dialog=False):
             logger.warning(f"Could not extract Windows version from {platform.platform()}, please report this message")
             win_ver = 0
 
-        if win_ver < 10:
+        legacy_windows = win_ver < 10
+        if legacy_windows:
             logger.debug(f"Detected legacy Windows version {win_ver}, looking for 4.x builds only")
-            for version in versions:
-                if version[0] == 4:
-                    use_version = ".".join(str(x) for x in version)
-                    break
-            else:
-                logger.warning("No 4.x Versions found for legacy Windows")
-                return
 
-    release = [x for x in data if x["tag_name"] == use_version][0]
+    release = select_release(data, legacy_windows=legacy_windows)
+    if release is None:
+        logger.warning("No usable FastFlix releases found in the GitHub response")
+        if show_new_dialog:
+            message(t("Could not connect to github to check for newer versions"))
+        return
+    use_version = str(parse_release_version(release["tag_name"]))
+
+    try:
+        current_version = packaging_version.parse(__version__)
+    except packaging_version.InvalidVersion:
+        logger.warning(f"Could not parse current FastFlix version {__version__}")
+        return
 
-    if use_version != __version__ and packaging_version.parse(use_version) > packaging_version.parse(__version__):
+    if packaging_version.parse(use_version) > current_version:
         portable, installer = None, None
         for asset in release["assets"]:
+            if not safe_release_url(asset.get("browser_download_url")):
+                continue
             if asset["name"].endswith("win64.zip"):
                 portable = asset["browser_download_url"]
             if asset["name"].endswith("installer.exe"):
@@ -269,7 +313,9 @@ def latest_fastflix(app, show_new_dialog=False):
             )
             download_link += "<br><br>"
         if (not portable and not installer) or not reusables.win_based:
-            html_link = release["html_url"]
+            html_link = release.get("html_url")
+            if not safe_release_url(html_link):
+                html_link = "https://github.com/cdgriffith/FastFlix/releases"
             download_link = link(
                 url=html_link, text=f"{t('View')} FastFlix {use_version}", theme=app.fastflix.config.theme
             )
@@ -325,7 +371,7 @@ def open_folder(path):
         elif sys.platform == "darwin":
             run(["open", path])
         else:
-            run(["xdg-open", path])
+            run(["xdg-open", path], env=clean_env())
     except FileNotFoundError:
         logger.error(f"Do not know which command to use to open: {path}")
 
@@ -406,10 +452,6 @@ def quoted_path(source):
         .replace("\n", "")
         .replace("\r", "")
     )
-    if " " in cleaned_string[0:4]:
-        logger.warning(f"Unexpected space at start of quoted path, attempting to fix: {cleaned_string}")
-        cleaned_string = cleaned_string[0:4].replace(" ", "") + cleaned_string[4:]
-        logger.warning(f"New path set to: {cleaned_string}")
     return cleaned_string
 
 
diff --git a/fastflix/ui_constants.py b/fastflix/ui_constants.py
index 4d331c62..6200397e 100644
--- a/fastflix/ui_constants.py
+++ b/fastflix/ui_constants.py
@@ -22,7 +22,6 @@ class BaseWidths:
     FLIP_DROPDOWN: int = 120
     ROTATE_DROPDOWN: int = 130
     PREVIEW_MIN: int = 330
-    OUTPUT_TYPE: int = 60
     VIDEO_TRACK_LABEL: int = 75
     ENCODER_LABEL: int = 50
     RESOLUTION_LABEL: int = 70
diff --git a/fastflix/ui_styles.py b/fastflix/ui_styles.py
index 333ccf9d..dbd910da 100644
--- a/fastflix/ui_styles.py
+++ b/fastflix/ui_styles.py
@@ -12,7 +12,7 @@
 # Onyx theme color constants
 ONYX_COLORS = {
     "primary": "#567781",  # Blue accent (borders, selected tabs)
-    "input_bg": "#4a555e",  # Input field backgrounds
+    "input_bg": "#434c54",  # Input field backgrounds
     "dropdown_bg": "#4e6172",  # Dropdown backgrounds
     "text": "#ffffff",  # White text
     "text_muted": "#b5b5b5",  # Muted/disabled text
@@ -42,12 +42,12 @@ def get_scaled_stylesheet(theme: str) -> str:
             QComboBox QAbstractItemView {{ background-color: #1d2023; border: 2px solid #76797c; }}
             QPushButton {{ border-radius: {border_radius}px; }}
             QLineEdit {{
-                background-color: #4a555e;
+                background-color: {ONYX_COLORS["input_bg"]};
                 color: white;
                 border-radius: {border_radius}px;
                 min-height: {input_min_height}px;
             }}
-            QTextEdit {{ background-color: #4a555e; color: white; }}
+            QTextEdit {{ background-color: {ONYX_COLORS["input_bg"]}; color: white; }}
             QTabBar::tab {{ background-color: #4f5962; }}
             QComboBox {{ border-radius: {border_radius}px; min-height: {input_min_height}px; }}
             QScrollArea {{ border: 1px solid #919191; }}
diff --git a/fastflix/version.py b/fastflix/version.py
index 5634478b..fd478625 100644
--- a/fastflix/version.py
+++ b/fastflix/version.py
@@ -1,4 +1,4 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-__version__ = "6.2.1"
+__version__ = "6.3.0"
 __author__ = "Chris Griffith"
diff --git a/fastflix/widgets/about.py b/fastflix/widgets/about.py
index 59125047..529db3aa 100644
--- a/fastflix/widgets/about.py
+++ b/fastflix/widgets/about.py
@@ -7,7 +7,7 @@
 from PySide6 import QtCore, QtGui, QtWidgets
 
 from fastflix.language import t
-from fastflix.shared import base_path, link, pyinstaller
+from fastflix.shared import base_path, bundled_mode, go_launcher, link
 from fastflix.version import __version__
 
 __all__ = ["About"]
@@ -63,14 +63,23 @@ def __init__(self, app):
         supporting_libraries_label.setOpenExternalLinks(True)
         layout.addWidget(supporting_libraries_label)
 
-        if pyinstaller:
-            pyinstaller_label = QtWidgets.QLabel(
-                f"{t('Packaged with')}: {link('https://www.pyinstaller.org/index.html', 'PyInstaller', app.fastflix.config.theme)}"
-            )
-            pyinstaller_label.setAlignment(QtCore.Qt.AlignCenter)
-            pyinstaller_label.setOpenExternalLinks(True)
+        if bundled_mode:
+            if go_launcher:
+                packaged_text = (
+                    f"{t('Packaged with')}: "
+                    f"{link('https://go.dev/', 'Go Launcher', app.fastflix.config.theme)} + "
+                    f"{link('https://www.python.org/', t('Embeddable Python'), app.fastflix.config.theme)}"
+                )
+            else:
+                packaged_text = (
+                    f"{t('Packaged with')}: "
+                    f"{link('https://www.pyinstaller.org/index.html', 'PyInstaller', app.fastflix.config.theme)}"
+                )
+            packaged_label = QtWidgets.QLabel(packaged_text)
+            packaged_label.setAlignment(QtCore.Qt.AlignCenter)
+            packaged_label.setOpenExternalLinks(True)
             layout.addWidget(QtWidgets.QLabel())
-            layout.addWidget(pyinstaller_label)
+            layout.addWidget(packaged_label)
 
         license_label = QtWidgets.QLabel(
             link(
diff --git a/fastflix/widgets/background_tasks.py b/fastflix/widgets/background_tasks.py
index 0641ae5f..12c0ae98 100644
--- a/fastflix/widgets/background_tasks.py
+++ b/fastflix/widgets/background_tasks.py
@@ -3,14 +3,16 @@
 import importlib.util
 import logging
 import os
+import time
 from pathlib import Path
-from subprocess import PIPE, STDOUT, Popen, run, check_output
+from subprocess import PIPE, STDOUT, Popen, TimeoutExpired, run, check_output
 from packaging import version
 
 from PySide6 import QtCore
 from ffmpeg_normalize import FFmpegNormalize
 
 from fastflix.flix import extract_attachments
+from fastflix.shared import clean_env
 from fastflix.language import t
 from fastflix.models.fastflix_app import FastFlixApp
 from fastflix.shared import clean_file_string
@@ -18,6 +20,34 @@
 logger = logging.getLogger("fastflix")
 
 
+def resolve_babel_language(code):
+    """Map a language code or name to a babelfish Language, defaulting to English.
+
+    FFprobe reports ISO 639-2/B codes (fre, ger, chi) which ``Language(code)`` rejects (it expects 639-3).
+    """
+    from babelfish import Language
+
+    code = (code or "").strip()
+    try:
+        if len(code) == 2:
+            return Language.fromalpha2(code.lower())
+        if len(code) == 3:
+            try:
+                return Language(code.lower())
+            except ValueError:
+                return Language.fromalpha3b(code.lower())
+        return Language.fromname(code)
+    except Exception:
+        return Language("eng")
+
+
+def pgsrip_srt_path(sup_path):
+    """Path pgsrip will write the OCR result to for the given .sup file."""
+    from pgsrip.media_path import MediaPath
+
+    return Path(str(MediaPath(str(sup_path)).translate(number=0, extension="srt")))
+
+
 def _format_command(command):
     """Format a command list as a copy-pastable shell string with proper quoting."""
     if isinstance(command, str):
@@ -42,17 +72,31 @@ def __init__(self, main, command=""):
 
     def run(self):
         self.main.thread_logging_signal.emit(f"DEBUG:{t('Generating thumbnail')}: {_format_command(self.command)}")
-        result = run(self.command, stdin=PIPE, stdout=PIPE, stderr=STDOUT)
+        try:
+            result = run(self.command, stdin=PIPE, stdout=PIPE, stderr=STDOUT, env=clean_env(), timeout=120)
+        except TimeoutExpired:
+            self.main.thread_logging_signal.emit(f"ERROR:{t('Could not generate thumbnail')}: timed out")
+            self.main.thumbnail_complete.emit(0)
+            return
         if result.returncode > 0:
-            if "No such filter: 'zscale'" in result.stdout.decode(encoding="utf-8", errors="ignore"):
+            output_text = result.stdout.decode(encoding="utf-8", errors="ignore")
+            if "No such filter: 'zscale'" in output_text:
                 self.main.thread_logging_signal.emit(
                     "ERROR:Could not generate thumbnail because you are using an outdated FFmpeg! "
                     "Please use FFmpeg 4.3+ built against the latest zimg libraries. "
                     "Static builds available at https://ffmpeg.org/download.html "
                 )
-            if "OpenCL mapping not usable" in result.stdout.decode(encoding="utf-8", errors="ignore"):
+            if "OpenCL mapping not usable" in output_text:
                 self.main.thread_logging_signal.emit("ERROR trying to use OpenCL for thumbnail generation")
                 self.main.thumbnail_complete.emit(2)
+                return
+            elif "no path between colorspaces" in output_text:
+                self.main.thread_logging_signal.emit(
+                    "WARNING:HDR tonemapping failed for thumbnail (video color metadata may be incomplete), "
+                    "retrying without HDR conversion"
+                )
+                self.main.thumbnail_complete.emit(3)
+                return
             else:
                 self.main.thread_logging_signal.emit(f"ERROR:{t('Could not generate thumbnail')}: {result.stdout}")
 
@@ -156,6 +200,7 @@ def run(self):
                 command,
                 stdout=PIPE,
                 stderr=STDOUT,
+                env=clean_env(),
             )
             stdout, _ = self._process.communicate()
             returncode = self._process.returncode
@@ -224,6 +269,7 @@ def _get_subtitle_format(self):
                 stdout=PIPE,
                 stderr=STDOUT,
                 text=True,
+                env=clean_env(),
             )
 
             if result.returncode != 0:
@@ -301,12 +347,7 @@ def _convert_sup_to_srt(self, sup_filepath: str) -> bool:
             from babelfish import Language as BabelLanguage
             import pytesseract
 
-            # Set environment variables for pgsrip to find tesseract
             if self.app.fastflix.config.tesseract_path:
-                tesseract_dir = str(Path(self.app.fastflix.config.tesseract_path).parent)
-                os.environ["PATH"] = f"{tesseract_dir}{os.pathsep}{os.environ.get('PATH', '')}"
-                os.environ["TESSERACT_CMD"] = str(self.app.fastflix.config.tesseract_path)
-                # pytesseract uses its own module-level variable, not the env var
                 pytesseract.pytesseract.tesseract_cmd = str(self.app.fastflix.config.tesseract_path)
 
             # pgsrip's MediaPath parses the filename for language codes and may transform them
@@ -326,16 +367,8 @@ def _convert_sup_to_srt(self, sup_filepath: str) -> bool:
 
             # Configure options for pgsrip
             try:
-                # Detect if language code is 2-letter or 3-letter
-                if len(self.language) == 2:
-                    babel_lang = BabelLanguage.fromalpha2(self.language)
-                elif len(self.language) == 3:
-                    babel_lang = BabelLanguage(self.language)
-                else:
-                    babel_lang = BabelLanguage.fromname(self.language)
-
                 options = Options(
-                    languages={babel_lang},
+                    languages={resolve_babel_language(self.language)},
                     overwrite=True,
                     one_per_lang=True,
                 )
@@ -347,24 +380,25 @@ def _convert_sup_to_srt(self, sup_filepath: str) -> bool:
                     one_per_lang=True,
                 )
 
-            # Get list of existing .srt files before conversion
-            existing_srts = set(sup_path.parent.glob("*.srt"))
-
-            # Run pgsrip conversion using Python API
-            pgsrip.rip(media, options)
-
-            # Find newly created .srt files
-            current_srts = set(sup_path.parent.glob("*.srt"))
-            new_srts = current_srts - existing_srts
+            # pgsrip writes next to the .sup, derive that path instead of diffing the directory listing
+            # (which misses results that overwrite an already existing .srt)
+            expected_srt = pgsrip_srt_path(sup_path)
+            started = time.time()
 
-            if not new_srts:
-                raise Exception(f"pgsrip completed but no .srt file found in {sup_path.parent}")
+            # The PATH is only extended for the OCR run itself, set right before the try so it is always restored
+            old_path = os.environ.get("PATH", "")
+            if self.app.fastflix.config.tesseract_path:
+                tesseract_dir = str(Path(self.app.fastflix.config.tesseract_path).parent)
+                os.environ["PATH"] = f"{tesseract_dir}{os.pathsep}{old_path}"
+            try:
+                pgsrip.rip(media, options)
+            finally:
+                os.environ["PATH"] = old_path
 
-            # Get the first new .srt file
-            srt_files = list(new_srts)
+            if not expected_srt.exists() or expected_srt.stat().st_mtime < started - 2:
+                raise Exception(f"pgsrip completed but no .srt file was written at {expected_srt}")
 
-            # Move the .srt file to the user's originally desired location
-            created_srt = srt_files[0]
+            created_srt = expected_srt
 
             if created_srt != desired_srt:
                 import shutil
@@ -468,6 +502,16 @@ def run(self):
             self.signal.emit("Failed")
 
 
+def follow_progress(is_running, f, emit, sleep=time.sleep, interval=0.1):
+    """Tail ffmpeg progress lines from f, sleeping when no new data is available."""
+    while is_running():
+        if line := f.readline().rstrip():
+            if line.startswith("frame"):
+                emit(line)
+        else:
+            sleep(interval)
+
+
 class ExtractHDR10(QtCore.QThread):
     def __init__(self, app: FastFlixApp, main, signal, ffmpeg_signal):
         super().__init__(main)
@@ -495,7 +539,9 @@ def run(self):
         self.ffmpeg_signal.emit("Extracting HDR10+ metadata")
 
         hdr10_parser_version_output = check_output(
-            [str(self.app.fastflix.config.hdr10plus_parser), "--version"], encoding="utf-8"
+            [str(self.app.fastflix.config.hdr10plus_parser), "--version"],
+            encoding="utf-8",
+            env=clean_env(),
         )
         _, version_string = hdr10_parser_version_output.rsplit(sep=" ", maxsplit=1)
         hdr10_parser_version = version.parse(version_string)
@@ -525,12 +571,15 @@ def run(self):
             f"Running command: {' '.join(ffmpeg_command)} | {' '.join(hdr10_parser_command)}"
         )
 
-        process = Popen(
-            ffmpeg_command,
-            stdout=PIPE,
-            stderr=open(self.app.fastflix.current_video.work_path / "hdr10extract_out.txt", "wb"),
-            # stdin=PIPE,  # FFmpeg can try to read stdin and wrecks havoc
-        )
+        progress_file = self.app.fastflix.current_video.work_path / "hdr10extract_out.txt"
+        with open(progress_file, "wb") as ffmpeg_stderr:
+            process = Popen(
+                ffmpeg_command,
+                stdout=PIPE,
+                stderr=ffmpeg_stderr,
+                # stdin=PIPE,  # FFmpeg can try to read stdin and wrecks havoc
+                env=clean_env(),
+            )
 
         process_two = Popen(
             hdr10_parser_command,
@@ -539,15 +588,11 @@ def run(self):
             stdin=process.stdout,
             encoding="utf-8",
             cwd=str(self.app.fastflix.current_video.work_path),
+            env=clean_env(),
         )
 
-        with open(self.app.fastflix.current_video.work_path / "hdr10extract_out.txt", "r", encoding="utf-8") as f:
-            while True:
-                if process.poll() is not None or process_two.poll() is not None:
-                    break
-                if line := f.readline().rstrip():
-                    if line.startswith("frame"):
-                        self.ffmpeg_signal.emit(line)
+        with open(progress_file, "r", encoding="utf-8") as f:
+            follow_progress(lambda: process.poll() is None and process_two.poll() is None, f, self.ffmpeg_signal.emit)
 
         stdout, stderr = process_two.communicate()
         self.main.thread_logging_signal.emit(f"DEBUG: HDR10+ Extract: {stdout}")
diff --git a/fastflix/widgets/container.py b/fastflix/widgets/container.py
index 22431b0a..242ffdd5 100644
--- a/fastflix/widgets/container.py
+++ b/fastflix/widgets/container.py
@@ -2,10 +2,8 @@
 # -*- coding: utf-8 -*-
 import logging
 import shutil
-import sys
 import time
 from pathlib import Path
-from subprocess import run
 
 import reusables
 from platformdirs import user_data_dir
@@ -14,6 +12,7 @@
 
 from fastflix.exceptions import FastFlixInternalException
 from fastflix.language import t
+from fastflix.version import __version__
 from fastflix.models.config import setting_types, get_preset_defaults
 from fastflix.models.fastflix_app import FastFlixApp
 from fastflix.program_downloads import latest_ffmpeg, grab_stable_ffmpeg, download_hdr10plus_tool
@@ -41,7 +40,6 @@
 from fastflix.widgets.windows.history_window import HistoryWindow
 from fastflix.widgets.windows.multiple_files import MultipleFilesWindow
 
-# from fastflix.widgets.windows.hdr10plus_inject import HDR10PlusInjectWindow
 
 logger = logging.getLogger("fastflix")
 
@@ -91,6 +89,12 @@ def __init__(self, app: FastFlixApp, **kwargs):
 
         self.init_menu()
 
+        self.version_label = QtWidgets.QLabel(f"{__version__}", self)
+        self.version_label.setStyleSheet("color: #808080; background: transparent;")
+        self.version_label.setAttribute(QtCore.Qt.WA_TransparentForMouseEvents)
+        self.version_label.adjustSize()
+        self.version_label.raise_()
+
         self.main = Main(self, app)
 
         self.status_bar = StatusBarWidget(self.app, parent=self)
@@ -213,9 +217,18 @@ def ensure_window_in_bounds(self):
         # Apply the constrained geometry
         self.setGeometry(new_x, new_y, new_width, new_height)
 
+    def _position_version_label(self):
+        menubar = self.menuBar()
+        menubar_height = menubar.height()
+        y = (menubar_height - self.version_label.height()) // 2
+        x = self.width() - self.version_label.width() - 8
+        self.version_label.move(x, y)
+        self.version_label.raise_()
+
     def resizeEvent(self, event: QtGui.QResizeEvent) -> None:
         """Handle resize events to ensure window stays within screen bounds and update scaling."""
         super().resizeEvent(event)
+        self._position_version_label()
 
         # Always update scale factors and styles so the UI adapts to any window size
         scaler.calculate_factors(event.size().width(), event.size().height())
@@ -383,12 +396,6 @@ def init_menu(self):
         concat_action.triggered.connect(self.show_concat)
         tools_menu.addAction(concat_action)
 
-        # hdr10p_inject_action = QAction(
-        #     QtGui.QIcon(get_icon("onyx-queue", self.app.fastflix.config.theme)), t("HDR10+ Inject"), self
-        # )
-        # hdr10p_inject_action.triggered.connect(self.show_hdr10p_inject)
-        # tools_menu.addAction(hdr10p_inject_action)
-
         if self.app.fastflix.config.enable_history:
             history_menu = menubar.addMenu(t("History"))
 
@@ -533,10 +540,6 @@ def show_concat(self):
         self.concat = ConcatWindow(app=self.app, main=self.main)
         self.concat.show()
 
-    # def show_hdr10p_inject(self):
-    #     self.hdr10p_inject = HDR10PlusInjectWindow(app=self.app, main=self.main)
-    #     self.hdr10p_inject.show()
-
     def show_about(self):
         self.about = About(app=self.app)
         self.about.show()
@@ -588,7 +591,7 @@ def open_issues(self):
         QtGui.QDesktopServices.openUrl(QtCore.QUrl("https://github.com/cdgriffith/FastFlix/issues"))
 
     def show_log_dir(self):
-        OpenFolder(self, str(self.app.fastflix.log_path)).run()
+        QtGui.QDesktopServices.openUrl(QtCore.QUrl.fromLocalFile(str(self.app.fastflix.log_path)))
 
     def download_stable_ffmpeg(self):
         self.download_ffmpeg(ffmpeg_version="stable")
@@ -703,24 +706,6 @@ def open_many(self):
         # self.main.open_many(paths=[x for x in Path(folder_name).glob("*") if x.name.lower().endswith(video_file_types)])
 
 
-class OpenFolder(QtCore.QThread):
-    def __init__(self, parent, path):
-        super().__init__(parent)
-        self.app = parent
-        self.path = str(path)
-
-    def run(self):
-        try:
-            if reusables.win_based:
-                run(["explorer", self.path])
-            elif sys.platform == "darwin":
-                run(["open", self.path])
-            else:
-                run(["xdg-open", self.path])
-        except FileNotFoundError:
-            logger.error(f"Do not know which command to use to open: {self.path}")
-
-
 class ProfileDetails(QtWidgets.QWidget):
     def profile_widget(self, settings):
         widget = QtWidgets.QWidget()
diff --git a/fastflix/widgets/main.py b/fastflix/widgets/main.py
index f417894c..a0f4b7a8 100644
--- a/fastflix/widgets/main.py
+++ b/fastflix/widgets/main.py
@@ -9,7 +9,7 @@
 import time
 from datetime import timedelta
 from pathlib import Path
-from typing import Tuple, Union
+from typing import Optional, Tuple, Union
 
 import importlib.resources
 import reusables
@@ -28,6 +28,7 @@
     get_concat_item,
 )
 from fastflix.language import t
+from fastflix.widgets.toggle_switch import ToggleSwitch
 from fastflix.models.fastflix_app import FastFlixApp
 from fastflix.models.video import Video, VideoSettings, Crop
 from fastflix.resources import (
@@ -66,14 +67,14 @@
     t("Width"): {"method": "width"},
     t("Height"): {"method": "height"},
     t("Custom (w:h)"): {"method": "custom"},
-    "4320 LE": {"method": "long edge", "pixels": 4320},
-    "2160 LE": {"method": "long edge", "pixels": 2160},
+    "8K (4320 LE)": {"method": "long edge", "pixels": 4320},
+    "4K (2160 LE)": {"method": "long edge", "pixels": 2160},
     "1920 LE": {"method": "long edge", "pixels": 1920},
     "1440 LE": {"method": "long edge", "pixels": 1440},
     "1280 LE": {"method": "long edge", "pixels": 1280},
-    "1080 LE": {"method": "long edge", "pixels": 1080},
-    "720 LE": {"method": "long edge", "pixels": 720},
-    "480 LE": {"method": "long edge", "pixels": 480},
+    "1080p (1080 LE)": {"method": "long edge", "pixels": 1080},
+    "720p (720 LE)": {"method": "long edge", "pixels": 720},
+    "480p (480 LE)": {"method": "long edge", "pixels": 480},
     "4320 H": {"method": "height", "pixels": 4320},
     "2160 H": {"method": "height", "pixels": 2160},
     "1920 H": {"method": "height", "pixels": 1920},
@@ -81,16 +82,26 @@
     "1080 H": {"method": "height", "pixels": 1080},
     "720 H": {"method": "height", "pixels": 720},
     "480 H": {"method": "height", "pixels": 480},
-    "7680 W": {"method": "width", "pixels": 7680},
-    "3840 W": {"method": "width", "pixels": 3840},
-    "2560 W": {"method": "width", "pixels": 2560},
-    "1920 W": {"method": "width", "pixels": 1920},
-    "1280 W": {"method": "width", "pixels": 1280},
+    "8K (7680 W)": {"method": "width", "pixels": 7680},
+    "4K (3840 W)": {"method": "width", "pixels": 3840},
+    "1440p (2560 W)": {"method": "width", "pixels": 2560},
+    "1080p (1920 W)": {"method": "width", "pixels": 1920},
+    "720p (1280 W)": {"method": "width", "pixels": 1280},
     "1024 W": {"method": "width", "pixels": 1024},
     "640 W": {"method": "width", "pixels": 640},
 }
 
 
+def dropped_local_path(mime_data) -> Optional[Path]:
+    """First local-file URL from a drop, or None."""
+    if not mime_data.hasUrls():
+        return None
+    for url in mime_data.urls():
+        if url.isLocalFile() and url.toLocalFile():
+            return Path(clean_file_string(url.toLocalFile()))
+    return None
+
+
 class CropWidgets(BaseModel):
     top: QtWidgets.QLineEdit = None
     bottom: QtWidgets.QLineEdit = None
@@ -114,15 +125,15 @@ class MainWidgets(BaseModel):
     flip: QtWidgets.QComboBox = None
     crop: CropWidgets = Field(default_factory=CropWidgets)
     scale: ScaleWidgets = Field(default_factory=ScaleWidgets)
-    remove_metadata: QtWidgets.QCheckBox = None
-    chapters: QtWidgets.QCheckBox = None
+    remove_metadata: ToggleSwitch = None
+    chapters: ToggleSwitch = None
     fast_time: QtWidgets.QComboBox = None
     preview: QtWidgets.QLabel = None
     convert_to: QtWidgets.QComboBox = None
     convert_button: QtWidgets.QPushButton = None
     queue_button: QtWidgets.QPushButton = None
-    deinterlace: QtWidgets.QCheckBox = None
-    remove_hdr: QtWidgets.QCheckBox = None
+    deinterlace: ToggleSwitch = None
+    remove_hdr: ToggleSwitch = None
     profile_box: QtWidgets.QComboBox = None
     thumb_time: QtWidgets.QSlider = None
     preview_time_label: QtWidgets.QLabel = None
@@ -172,6 +183,12 @@ def __init__(self, parent, app: FastFlixApp):
         self._top_bar_widgets = []  # widgets that share the same height in the top bar
         self._preview_buttons = []  # square icon buttons that must stay fixed on scale change
         self.last_thumb_hash = ""
+        self._thumb_worker: Optional[ThumbnailCreator] = None
+        self._thumb_pending = False
+        self._page_update_timer = QtCore.QTimer(self)
+        self._page_update_timer.setSingleShot(True)
+        self._page_update_timer.setInterval(300)
+        self._page_update_timer.timeout.connect(self.page_update)
         self.page_updating = False
         self.previous_encoder_no_audio = False
         self._cover_extract_thread = None
@@ -190,6 +207,7 @@ def __init__(self, parent, app: FastFlixApp):
         self.setAcceptDrops(True)
 
         self.input_video = None
+        self.skip_hdr_thumbnail = False
         self.video_path_widget = QtWidgets.QLineEdit(t("No Source Selected"))
         motto = ""
         if self.app.fastflix.config.language == "eng":
@@ -228,6 +246,7 @@ def __init__(self, parent, app: FastFlixApp):
         self.source_video_path_widget.setStyleSheet(
             f"padding: 0 0 -1px 5px; color: rgb({get_text_color(self.app.fastflix.config.theme)})"
         )
+        self.source_video_path_widget.textChanged.connect(self.source_video_path_widget.setToolTip)
 
         self.output_video_path_widget = QtWidgets.QLineEdit("")
         self.output_video_path_widget.setDisabled(True)
@@ -236,6 +255,7 @@ def __init__(self, parent, app: FastFlixApp):
             f"padding: 0 0 -1px 5px; color: rgb({get_text_color(self.app.fastflix.config.theme)})"
         )
         self.output_video_path_widget.setMaxLength(250)
+        self.output_video_path_widget.textChanged.connect(lambda: self.update_output_tooltip())
 
         self._filename_was_truncated = False
         self.filename_truncation_warning = QtWidgets.QLabel()
@@ -344,12 +364,9 @@ def fade_loop(self, percent=90):
             )
             return
         if percent > 0:
-            op = QtWidgets.QGraphicsOpacityEffect()
-            op.setOpacity(percent)
             self.source_video_path_widget.setStyleSheet(
                 f"color: rgba({get_text_color(self.app.fastflix.config.theme)}, {percent / 100}); padding: 0 0 -1px 5px;"
             )
-            self.source_video_path_widget.setGraphicsEffect(op)
             QtCore.QTimer.singleShot(200, lambda: self.fade_loop(percent - 10))
         else:
             self.source_video_path_widget.setStyleSheet(
@@ -612,8 +629,8 @@ def init_video_area(self):
         self.clear_source_button.setDisabled(True)
         if self.app.fastflix.config.theme == "onyx":
             self.clear_source_button.setStyleSheet(
-                "QPushButton { color: #F44336; border: none; font-weight: bold; }"
-                "QPushButton:hover { background-color: #3a3a3a; border-radius: 4px; }"
+                "QPushButton { color: #cccccc; border: none; font-weight: bold; }"
+                "QPushButton:hover { color: #ffffff; background-color: #3a3a3a; border-radius: 4px; }"
             )
         else:
             self.clear_source_button.setStyleSheet(
@@ -634,13 +651,15 @@ def init_video_area(self):
         output_layout.addWidget(output_label)
         output_layout.addWidget(self.output_video_path_widget, stretch=True)
 
-        self.widgets.output_type_combo.setFixedWidth(scaler.scale(WIDTHS.OUTPUT_TYPE))
+        self.widgets.output_type_combo.setSizeAdjustPolicy(QtWidgets.QComboBox.SizeAdjustPolicy.AdjustToContents)
+        self.widgets.output_type_combo.addItem(t("Source"))
         if self.current_encoder:
             self.widgets.output_type_combo.addItems(self.current_encoder.video_extensions)
         self.widgets.output_type_combo.setMinimumHeight(scaler.scale(HEIGHTS.COMBO_BOX))
         if self.app.fastflix.config.theme == "onyx":
             self.widgets.output_type_combo.setStyleSheet(get_onyx_combobox_style())
         self.widgets.output_type_combo.currentIndexChanged.connect(lambda: self.page_update(build_thumbnail=False))
+        self.widgets.output_type_combo.currentIndexChanged.connect(lambda: self.update_output_tooltip())
 
         output_layout.addWidget(self.widgets.output_type_combo)
 
@@ -834,7 +853,7 @@ def init_options_tabs(self):
             left_stretch=False,
             time_field=True,
         )
-        self.widgets.start_time.textChanged.connect(lambda: self.page_update())
+        self.widgets.start_time.textChanged.connect(self._field_changed)
 
         self.widgets.end_time, end_row = self.build_hoz_int_field(
             t("End"),
@@ -843,7 +862,7 @@ def init_options_tabs(self):
             right_stretch=False,
             time_field=True,
         )
-        self.widgets.end_time.textChanged.connect(lambda: self.page_update())
+        self.widgets.end_time.textChanged.connect(self._field_changed)
 
         time_col2.addLayout(start_row)
         time_col2.addLayout(end_row)
@@ -929,28 +948,28 @@ def init_options_tabs(self):
         self.widgets.crop.top.setFixedWidth(field_width)
         self.widgets.crop.top.setFixedHeight(field_height)
         self.widgets.crop.top.setAlignment(QtCore.Qt.AlignCenter)
-        self.widgets.crop.top.textChanged.connect(lambda: self.page_update())
+        self.widgets.crop.top.textChanged.connect(self._field_changed)
 
         self.widgets.crop.bottom = QtWidgets.QLineEdit("0")
         self.widgets.crop.bottom.setValidator(only_int)
         self.widgets.crop.bottom.setFixedWidth(field_width)
         self.widgets.crop.bottom.setFixedHeight(field_height)
         self.widgets.crop.bottom.setAlignment(QtCore.Qt.AlignCenter)
-        self.widgets.crop.bottom.textChanged.connect(lambda: self.page_update())
+        self.widgets.crop.bottom.textChanged.connect(self._field_changed)
 
         self.widgets.crop.left = QtWidgets.QLineEdit("0")
         self.widgets.crop.left.setValidator(only_int)
         self.widgets.crop.left.setFixedWidth(field_width)
         self.widgets.crop.left.setFixedHeight(field_height)
         self.widgets.crop.left.setAlignment(QtCore.Qt.AlignCenter)
-        self.widgets.crop.left.textChanged.connect(lambda: self.page_update())
+        self.widgets.crop.left.textChanged.connect(self._field_changed)
 
         self.widgets.crop.right = QtWidgets.QLineEdit("0")
         self.widgets.crop.right.setValidator(only_int)
         self.widgets.crop.right.setFixedWidth(field_width)
         self.widgets.crop.right.setFixedHeight(field_height)
         self.widgets.crop.right.setAlignment(QtCore.Qt.AlignCenter)
-        self.widgets.crop.right.textChanged.connect(lambda: self.page_update())
+        self.widgets.crop.right.textChanged.connect(self._field_changed)
 
         # Row 0, Cols 1-2: Top (centered)
         top_row = QtWidgets.QHBoxLayout()
@@ -990,26 +1009,27 @@ def init_options_tabs(self):
         opts_layout.setSpacing(scaler.scale(4))
         opts_layout.setContentsMargins(scaler.scale(8), scaler.scale(8), scaler.scale(8), scaler.scale(8))
 
-        self.widgets.remove_metadata = QtWidgets.QCheckBox(t("Remove Metadata"))
+        self.widgets.remove_metadata = ToggleSwitch(t("Remove Metadata"))
         self.widgets.remove_metadata.setChecked(True)
         self.widgets.remove_metadata.toggled.connect(self.page_update)
         self.widgets.remove_metadata.setToolTip(
             t("Scrub away all incoming metadata, like video titles, unique markings and so on.")
         )
 
-        self.widgets.chapters = QtWidgets.QCheckBox(t("Copy Chapters"))
+        self.widgets.chapters = ToggleSwitch(t("Copy Chapters"))
         self.widgets.chapters.setChecked(True)
         self.widgets.chapters.toggled.connect(self.page_update)
         self.widgets.chapters.setToolTip(t("Copy the chapter markers as is from incoming source."))
 
-        self.widgets.deinterlace = QtWidgets.QCheckBox(t("Deinterlace"))
+        self.widgets.deinterlace = ToggleSwitch(t("Deinterlace"))
         self.widgets.deinterlace.setChecked(False)
         self.widgets.deinterlace.toggled.connect(self.interlace_update)
         self.widgets.deinterlace.setToolTip(
-            f"{t('Enables the yadif filter.')}\n{t('Automatically enabled when an interlaced video is detected')}"
+            f"{t('Enables deinterlacing (method selectable in Advanced panel).')}\n"
+            f"{t('Automatically enabled when an interlaced video is detected')}"
         )
 
-        self.widgets.remove_hdr = QtWidgets.QCheckBox(t("Remove HDR"))
+        self.widgets.remove_hdr = ToggleSwitch(t("Remove HDR"))
         self.widgets.remove_hdr.setChecked(False)
         self.widgets.remove_hdr.toggled.connect(self.hdr_update)
         self.widgets.remove_hdr.setToolTip(
@@ -1103,7 +1123,15 @@ def set_profile(self):
                 )
 
             self.widgets.remove_hdr.setChecked(self.app.fastflix.config.opt("remove_hdr"))
-            # self.widgets.deinterlace.setChecked(self.app.fastflix.config.opt("deinterlace"))
+            self.widgets.deinterlace.setChecked(
+                bool(
+                    self.app.fastflix.config.advanced_opt("deinterlace")
+                    or (
+                        self.app.fastflix.current_video
+                        and self.app.fastflix.current_video.interlaced not in (False, "False", "", None)
+                    )
+                )
+            )
             self.widgets.chapters.setChecked(self.app.fastflix.config.opt("copy_chapters"))
             self.widgets.remove_metadata.setChecked(self.app.fastflix.config.opt("remove_metadata"))
 
@@ -1252,8 +1280,45 @@ def update_output_type(self):
         self.widgets.output_type_combo.clear()
         if not self.current_encoder:
             return
+        self.widgets.output_type_combo.addItem(t("Source"))
         self.widgets.output_type_combo.addItems(self.current_encoder.video_extensions)
-        self.widgets.output_type_combo.setCurrentText(self.app.fastflix.config.opt("output_type"))
+        saved = self.app.fastflix.config.opt("output_type")
+        if saved == "same_as_source":
+            self.widgets.output_type_combo.setCurrentIndex(0)
+        else:
+            self.widgets.output_type_combo.setCurrentText(saved)
+
+    def resolve_output_extension(self) -> str:
+        """Resolve the actual output file extension, handling 'Source' option."""
+        combo_text = self.widgets.output_type_combo.currentText()
+        if combo_text == t("Source"):
+            if self.app.fastflix.current_video:
+                source_ext = self.app.fastflix.current_video.source.suffix.lower()
+                if self.current_encoder and source_ext in self.current_encoder.video_extensions:
+                    return source_ext
+            # Source ext not supported by encoder — fall back to first supported
+            if self.current_encoder and self.current_encoder.video_extensions:
+                return self.current_encoder.video_extensions[0]
+            return ".mkv"
+        return combo_text
+
+    def update_output_tooltip(self):
+        directory = self.widgets.output_directory.text()
+        name = self.output_video_path_widget.text()
+        if directory and name:
+            try:
+                ext = self.resolve_output_extension()
+            except Exception:
+                ext = ""
+            self.output_video_path_widget.setToolTip(str(Path(directory) / f"{name}{ext}"))
+        else:
+            self.output_video_path_widget.setToolTip("")
+
+    def output_type_for_profile(self) -> str:
+        """Return the output type value to store in profiles."""
+        if self.widgets.output_type_combo.currentText() == t("Source"):
+            return "same_as_source"
+        return self.widgets.output_type_combo.currentText()
 
     @property
     def current_encoder(self):
@@ -1320,53 +1385,33 @@ def update_resolution_labels(self):
         src_h = self.app.fastflix.current_video.height
         self.widgets.video_res_label.setText(t("Video Resolution") + f": {src_w}w {src_h}h")
 
-        # Start with source dimensions, apply crop
-        out_w = src_w
-        out_h = src_h
         try:
             crop_top = int(self.widgets.crop.top.text() or 0)
             crop_bottom = int(self.widgets.crop.bottom.text() or 0)
             crop_left = int(self.widgets.crop.left.text() or 0)
             crop_right = int(self.widgets.crop.right.text() or 0)
-            out_w -= crop_left + crop_right
-            out_h -= crop_top + crop_bottom
         except (ValueError, AttributeError):
-            pass
+            crop_top = crop_bottom = crop_left = crop_right = 0
 
-        if out_w <= 0 or out_h <= 0:
+        cropped_w = src_w - crop_left - crop_right
+        cropped_h = src_h - crop_top - crop_bottom
+        if cropped_w <= 0 or cropped_h <= 0:
             self.widgets.output_res_label.setText(t("Output Resolution") + ": --")
             return
 
-        # Apply scale based on resolution method
-        method = self.resolution_method()
-        custom = self.resolution_custom()
+        out_w, out_h = Video.compute_output_dimensions(
+            source_w=src_w,
+            source_h=src_h,
+            crop_top=crop_top,
+            crop_bottom=crop_bottom,
+            crop_left=crop_left,
+            crop_right=crop_right,
+            method=self.resolution_method(),
+            custom=self.resolution_custom(),
+        )
 
-        if method != "auto" and custom:
-            try:
-                if method == "custom":
-                    parts = custom.split(":")
-                    if len(parts) == 2:
-                        cw, ch = int(parts[0]), int(parts[1])
-                        if cw > 0 and ch > 0:
-                            out_w, out_h = cw, ch
-                elif method == "width":
-                    new_w = int(custom)
-                    out_h = ((out_h * new_w // out_w) // 8) * 8
-                    out_w = new_w
-                elif method == "height":
-                    new_h = int(custom)
-                    out_w = ((out_w * new_h // out_h) // 8) * 8
-                    out_h = new_h
-                elif method == "long edge":
-                    pixels = int(custom)
-                    if out_w >= out_h:
-                        out_h = ((out_h * pixels // out_w) // 8) * 8
-                        out_w = pixels
-                    else:
-                        out_w = ((out_w * pixels // out_h) // 8) * 8
-                        out_h = pixels
-            except (ValueError, ZeroDivisionError):
-                pass
+        if out_w is None or out_h is None:
+            out_w, out_h = cropped_w, cropped_h
 
         self.widgets.output_res_label.setText(t("Output Resolution") + f": {out_w}w {out_h}h")
 
@@ -1541,6 +1586,19 @@ def showEvent(self, event):
         )
         self.crop_preview_button.raise_()
 
+        # Thumbnail warning indicator at top left
+        self.thumb_warning_label = QtWidgets.QLabel(self.preview_container)
+        warn_size = scaler.scale(24)
+        self.thumb_warning_label.setFixedSize(warn_size, warn_size)
+        self.thumb_warning_label.setPixmap(
+            QtGui.QIcon(get_icon("onyx-warning", self.app.fastflix.config.theme)).pixmap(warn_size, warn_size)
+        )
+        self.thumb_warning_label.setStyleSheet(
+            "QLabel { background: rgba(0,0,0,128); border: none; border-radius: 4px; padding: 2px; }"
+        )
+        self.thumb_warning_label.hide()
+        self.thumb_warning_label.raise_()
+
         return self.preview_container
 
     def open_crop_preview(self):
@@ -1568,6 +1626,9 @@ def reposition_thumb_overlay(self):
                 self.preview_container.width() - btn_size - btn_margin,
                 btn_margin,
             )
+        if hasattr(self, "thumb_warning_label") and hasattr(self, "preview_container"):
+            warn_margin = scaler.scale(15)
+            self.thumb_warning_label.move(warn_margin, warn_margin)
 
     def modify_int(self, widget, method="add", time_field=False):
         modifier = 1
@@ -1623,7 +1684,7 @@ def generate_output_filename(self):
         extension = ""
         if self.current_encoder:
             try:
-                extension = self.widgets.output_type_combo.currentText()
+                extension = self.resolve_output_extension()
             except Exception:
                 extension = self.current_encoder.video_extensions[0] if self.current_encoder.video_extensions else ""
         name, was_truncated = truncate_filename(name, out_loc, extension)
@@ -1646,17 +1707,18 @@ def output_video(self):
         return clean_file_string(
             Path(
                 self.widgets.output_directory.text(),
-                f"{self.output_video_path_widget.text()}{self.widgets.output_type_combo.currentText()}",
+                f"{self.output_video_path_widget.text()}{self.resolve_output_extension()}",
             )
         )
 
     @reusables.log_exception("fastflix", show_traceback=False)
     def save_file(self, extension="mkv"):
+        resolved_ext = self.resolve_output_extension()
         filename = QtWidgets.QFileDialog.getSaveFileName(
             self,
             caption="Save Video As",
-            dir=str(Path(*self.generate_output_filename)) + f"{self.widgets.output_type_combo.currentText()}",
-            filter=f"Save File (*.{extension})",
+            dir=str(Path(*self.generate_output_filename)) + resolved_ext,
+            filter=f"Save File (*{resolved_ext})",
         )
         if filename and filename[0]:
             fn = Path(filename[0])
@@ -1671,6 +1733,7 @@ def save_directory(self):
         )
         if dirname:
             self.widgets.output_directory.setText(dirname.rstrip("/").rstrip("\\"))
+            self.update_output_tooltip()
 
     def get_auto_crop(self):
         if not self.input_video or not self.initialized or self.loading_video:
@@ -1716,12 +1779,8 @@ def get_auto_crop(self):
             logger.warning("Autocrop did not return crop points, please use a ffmpeg version with cropdetect filter")
             return
 
-        smallest = (self.app.fastflix.current_video.height + self.app.fastflix.current_video.width) * 2
-        selected = result_list[0]
-        for result in result_list:
-            if (total := sum(result)) < smallest:
-                selected = result
-                smallest = total
+        # Union of content areas across samples: the smallest crop per edge (results are [right, bottom, left, top])
+        selected = [min(result[i] for result in result_list) for i in range(4)]
 
         r, b, l, tp = selected  # noqa: E741
 
@@ -1885,14 +1944,20 @@ def generate_thumbnail(self):
             return
 
         settings = self.app.fastflix.current_video.video_settings.model_dump()
+        settings.pop("reverse_video", None)
 
         if (
-            self.app.fastflix.current_video.video_settings.video_encoder_settings.pix_fmt == "yuv420p10le"
+            not self.skip_hdr_thumbnail
+            and self.app.fastflix.current_video.video_settings.video_encoder_settings.pix_fmt == "yuv420p10le"
             and self.app.fastflix.current_video.color_space.startswith("bt2020")
         ):
             settings["remove_hdr"] = True
             if not settings.get("color_transfer"):
                 settings["color_transfer"] = self.app.fastflix.current_video.color_transfer
+            if not settings.get("color_primaries"):
+                settings["color_primaries"] = self.app.fastflix.current_video.color_primaries
+            if not settings.get("color_space"):
+                settings["color_space"] = self.app.fastflix.current_video.color_space
 
         custom_filters = "scale='min(440\\,iw):-8'"
         if self.resolution_method() == "custom":
@@ -1919,13 +1984,37 @@ def generate_thumbnail(self):
             start_time=self.preview_place if not self.app.fastflix.current_video.concat else None,
             input_track=self.app.fastflix.current_video.video_settings.selected_track,
         )
+        self._start_thumbnail_worker(thumb_command)
+
+    def _field_changed(self):
+        """Debounce page updates while the user is typing; programmatic changes update immediately."""
+        sender = self.sender()
+        if sender is not None and sender.hasFocus():
+            self._page_update_timer.start()
+        else:
+            self.page_update()
+
+    def _start_thumbnail_worker(self, thumb_command):
+        if self._thumb_worker is not None:
+            self._thumb_pending = True
+            return
         try:
             self.thumb_file.unlink()
         except OSError:
             pass
         worker = ThumbnailCreator(self, thumb_command)
+        self._thumb_worker = worker
+        worker.finished.connect(self._thumbnail_worker_finished)
         worker.start()
 
+    def _thumbnail_worker_finished(self):
+        worker, self._thumb_worker = self._thumb_worker, None
+        if worker is not None:
+            worker.deleteLater()
+        if self._thumb_pending:
+            self._thumb_pending = False
+            self.generate_thumbnail()
+
     @property
     def source_material(self):
         if self.app.fastflix.current_video.concat:
@@ -1940,16 +2029,39 @@ def thread_logger(text):
         except Exception:
             logger.warning(text)
 
+    def set_thumb_warning(self, message: str):
+        """Show a warning icon overlay on the thumbnail with a tooltip."""
+        self.thumb_warning_label.setToolTip(message)
+        self.thumb_warning_label.show()
+        self.thumb_warning_label.raise_()
+
+    def clear_thumb_warning(self):
+        """Hide the thumbnail warning overlay."""
+        self.thumb_warning_label.setToolTip("")
+        self.thumb_warning_label.hide()
+
     @reusables.log_exception("fastflix", show_traceback=False)
     def thumbnail_generated(self, status=0):
         if status == 2:
             self.app.fastflix.opencl_support = False
             self.generate_thumbnail()
             return
+        if status == 3:
+            self.skip_hdr_thumbnail = True
+            self.generate_thumbnail()
+            return
         if status == 0 or not status or not self.thumb_file.exists():
+            self.set_thumb_warning(t("Thumbnail generation failed - preview may not be available"))
             self.widgets.preview.setText(t("Error Updating Thumbnail"))
             return
 
+        if self.skip_hdr_thumbnail:
+            self.set_thumb_warning(
+                t("HDR tonemapping unavailable for preview - colors in output will differ from this thumbnail")
+            )
+        else:
+            self.clear_thumb_warning()
+
         pixmap = QtGui.QPixmap(str(self.thumb_file))
         pixmap = pixmap.scaled(420, 260, QtCore.Qt.KeepAspectRatio)
         self.widgets.preview.setPixmap(pixmap)
@@ -1990,6 +2102,7 @@ def get_all_settings(self):
             horizontal_flip=h_flip,
             output_path=Path(clean_file_string(self.output_video)),
             deinterlace=self.widgets.deinterlace.isChecked(),
+            deinterlace_filter=self.video_options.advanced.get_deinterlace_filter(),
             remove_metadata=self.remove_metadata,
             copy_chapters=self.copy_chapters,
             video_title=self.video_options.advanced.video_title.text(),
@@ -2126,7 +2239,8 @@ def get_icon(self, name):
 
     @reusables.log_exception("fastflix", show_traceback=True)
     def dropEvent(self, event):
-        if not event.mimeData().hasUrls:
+        location = dropped_local_path(event.mimeData())
+        if location is None:
             return event.ignore()
 
         event.setDropAction(QtCore.Qt.CopyAction)
@@ -2140,12 +2254,7 @@ def dropEvent(self, event):
             if not discard:
                 return
 
-        location = Path(clean_file_string(event.mimeData().urls()[0].toLocalFile()))
-
-        try:
-            self.input_video = location
-        except (ValueError, IndexError):
-            return event.ignore()
+        self.input_video = location
         if not self.input_video.exists():
             logger.error(f"File does not exist {self.input_video}")
             return event.ignore()
@@ -2155,7 +2264,7 @@ def dropEvent(self, event):
         QtCore.QTimer.singleShot(0, self._load_dropped_video)
 
     def dragEnterEvent(self, event):
-        event.accept() if event.mimeData().hasUrls else event.ignore()
+        event.accept() if event.mimeData().hasUrls() else event.ignore()
 
     def dragMoveEvent(self, event):
-        event.accept() if event.mimeData().hasUrls else event.ignore()
+        event.accept() if event.mimeData().hasUrls() else event.ignore()
diff --git a/fastflix/widgets/main_encoding.py b/fastflix/widgets/main_encoding.py
index c6f8f73e..ab47e8bc 100644
--- a/fastflix/widgets/main_encoding.py
+++ b/fastflix/widgets/main_encoding.py
@@ -4,6 +4,8 @@
 
 import datetime
 import logging
+import shutil
+import uuid as uuid_mod
 from collections import namedtuple
 from pathlib import Path
 from queue import Empty
@@ -36,6 +38,31 @@
 Response = namedtuple("Response", ["status", "video_uuid", "command_uuid"])
 
 
+def refresh_video_identity(video: Video, new_work_path: Path) -> None:
+    """Give a video a fresh uuid and work_path (seeded with the old work_path contents)."""
+    old_work_path = video.work_path
+    new_work_path.mkdir(parents=True, exist_ok=True)
+    if old_work_path and Path(old_work_path).is_dir():
+        try:
+            shutil.copytree(old_work_path, new_work_path, dirs_exist_ok=True)
+        except OSError as err:
+            logger.warning(f"Could not copy work files to new work path: {err}")
+    video.work_path = new_work_path
+    video.uuid = str(uuid_mod.uuid4())
+
+
+def build_overwrite_prompt(parent=None):
+    """Confirmation box where Cancel is the default and escape button; returns (box, cancel, overwrite)."""
+    box = QtWidgets.QMessageBox(parent)
+    box.setIcon(QtWidgets.QMessageBox.Icon.Warning)
+    box.setText(t("That output file already exists and is not empty!"))
+    cancel = box.addButton(t("Cancel"), QtWidgets.QMessageBox.ButtonRole.RejectRole)
+    overwrite = box.addButton(t("Overwrite"), QtWidgets.QMessageBox.ButtonRole.AcceptRole)
+    box.setDefaultButton(cancel)
+    box.setEscapeButton(cancel)
+    return box, cancel, overwrite
+
+
 class Notifier(QtCore.QThread):
     def __init__(self, parent, app, status_queue):
         super().__init__(parent)
@@ -55,13 +82,11 @@ def run(self):
                 status = self.status_queue.get(timeout=0.5)
             except Empty:
                 continue
-            self.app.processEvents()
             if status[0] == "exit":
                 logger.debug("GUI received ask to exit")
                 self.main.close_event.emit()
                 return
             self.main.status_update_signal.emit(status)
-            self.app.processEvents()
 
 
 class EncodingMixin:
@@ -86,12 +111,9 @@ def encoding_checks(self):
 
         out_file_path = Path(self.output_video)
         if out_file_path.exists() and out_file_path.stat().st_size > 0:
-            sm = QtWidgets.QMessageBox()
-            sm.setText("That output file already exists and is not empty!")
-            sm.addButton("Cancel", QtWidgets.QMessageBox.DestructiveRole)
-            sm.addButton("Overwrite", QtWidgets.QMessageBox.RejectRole)
+            sm, _cancel, overwrite = build_overwrite_prompt(self)
             sm.exec()
-            if sm.clickedButton().text() == "Cancel":
+            if sm.clickedButton() is not overwrite:
                 return False
         return True
 
@@ -158,7 +180,12 @@ def add_to_queue(self):
                 return code
         self.video_options.show_queue()
 
-        self.clear_current_video()
+        if not self.app.fastflix.config.keep_source_after_encode:
+            self.clear_current_video()
+        else:
+            # The queued copy owns the current uuid and work_path; the kept source needs its own so the
+            # next queue entry doesn't collide on status updates, removal, retry or temp file cleanup.
+            refresh_video_identity(self.app.fastflix.current_video, self.get_temp_work_path())
         return True
 
     def conversion_complete(self, success: bool):
@@ -173,6 +200,7 @@ def conversion_complete(self, success: bool):
             self.video_options.queue.new_source()
         else:
             self.encoding_status_signal.emit(t("All conversions complete"), STATE_COMPLETE)
+            self.video_options.queue.run_after_done()
             self.video_options.show_queue()
             if self.app.fastflix.config.show_complete_message:
                 message(t("All queue items have completed"), title=t("Success"))
@@ -261,10 +289,10 @@ def status_update(self, status_response):
     def end_encoding(self):
         self.app.fastflix.currently_encoding = False
         allow_sleep_mode()
-        self.video_options.queue.run_after_done()
         self.video_options.update_queue()
         self.set_convert_button()
         self.encoding_progress_signal.emit(0)
+        self.enable_all()
 
     def send_next_video(self) -> bool:
         if not self.app.fastflix.currently_encoding:
diff --git a/fastflix/widgets/main_post_encode.py b/fastflix/widgets/main_post_encode.py
index 38ce1b2e..4ef25912 100644
--- a/fastflix/widgets/main_post_encode.py
+++ b/fastflix/widgets/main_post_encode.py
@@ -5,6 +5,7 @@
 import datetime
 import logging
 import secrets
+import threading
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -16,6 +17,30 @@
 logger = logging.getLogger("fastflix")
 
 
+PROBE_TIMEOUT = 60
+THUMBNAIL_TIMEOUT = 60
+
+
+def call_with_timeout(func, timeout: float, *args, **kwargs):
+    """Run func in a daemon thread; raise TimeoutError if it has not finished in time."""
+    outcome: dict = {}
+
+    def target():
+        try:
+            outcome["value"] = func(*args, **kwargs)
+        except BaseException as err:
+            outcome["error"] = err
+
+    thread = threading.Thread(target=target, daemon=True)
+    thread.start()
+    thread.join(timeout)
+    if thread.is_alive():
+        raise TimeoutError(f"Timed out after {timeout}s")
+    if "error" in outcome:
+        raise outcome["error"]
+    return outcome.get("value")
+
+
 class PostEncodeMixin:
     """Mixin for Main: post-encode validation, history recording, and file renaming."""
 
@@ -35,7 +60,7 @@ def _post_encode_process(self, video: Video):
             try:
                 from fastflix.flix import probe
 
-                probe_data = probe(self.app, output_path)
+                probe_data = call_with_timeout(probe, PROBE_TIMEOUT, self.app, output_path)
             except Exception:
                 logger.exception(f"Post-encode: ffprobe failed on {output_path}")
                 probe_data = None
@@ -141,6 +166,7 @@ def _record_history(self, video: Video, success: bool = True):
             from subprocess import run as subprocess_run
 
             from fastflix.flix import generate_thumbnail_command
+            from fastflix.shared import clean_env
 
             thumb_command = generate_thumbnail_command(
                 config=self.app.fastflix.config,
@@ -150,7 +176,9 @@ def _record_history(self, video: Video, success: bool = True):
                 start_time=video.video_settings.start_time or 0,
                 input_track=video.video_settings.selected_track,
             )
-            result = subprocess_run(thumb_command, stdin=PIPE, stdout=PIPE, stderr=STDOUT)
+            result = subprocess_run(
+                thumb_command, stdin=PIPE, stdout=PIPE, stderr=STDOUT, env=clean_env(), timeout=THUMBNAIL_TIMEOUT
+            )
             if result.returncode != 0 or not thumb_output.exists():
                 logger.warning("Failed to generate thumbnail for history entry")
                 entry.thumbnail_filename = ""
diff --git a/fastflix/widgets/main_video_load.py b/fastflix/widgets/main_video_load.py
index 0b0022af..b69b2560 100644
--- a/fastflix/widgets/main_video_load.py
+++ b/fastflix/widgets/main_video_load.py
@@ -243,6 +243,9 @@ def reload_video_from_queue(self, video: Video):
     @reusables.log_exception("fastflix", show_traceback=False)
     def update_video_info(self, hide_progress=False):
         self.loading_video = True
+        self.skip_hdr_thumbnail = False
+        if hasattr(self, "thumb_warning_label"):
+            self.clear_thumb_warning()
         folder, name = self.generate_output_filename
         self.output_video_path_widget.setText(name)
         self.widgets.output_directory.setText(folder.rstrip("/").rstrip("\\"))
diff --git a/fastflix/widgets/panels/advanced_panel.py b/fastflix/widgets/panels/advanced_panel.py
index de2a59b0..09f17a47 100644
--- a/fastflix/widgets/panels/advanced_panel.py
+++ b/fastflix/widgets/panels/advanced_panel.py
@@ -7,12 +7,12 @@
 from PySide6 import QtCore, QtGui, QtWidgets
 
 from fastflix.language import t
-from fastflix.shared import shrink_text_to_fit
 from fastflix.models.fastflix_app import FastFlixApp
 from fastflix.models.video import VideoSettings
-from fastflix.resources import get_icon
 from fastflix.models.profiles import AdvancedOptions
+from fastflix.widgets.toggle_switch import ToggleSwitch
 from fastflix.ui_styles import get_onyx_label_style
+from fastflix.encoders.common.helpers import validate_ffmpeg_color
 from fastflix.flix import ffmpeg_valid_color_primaries, ffmpeg_valid_color_transfers, ffmpeg_valid_color_space
 
 logger = logging.getLogger("fastflix")
@@ -42,6 +42,11 @@
         "moderate": "nlmeans=s=1.0:p=7:r=15",
         "strong": "nlmeans=s=10.0:p=13:r=25",
     },
+    "nlmeans_opencl": {
+        "weak": "nlmeans_opencl=s=1.0:p=3:r=9",
+        "moderate": "nlmeans_opencl=s=1.0:p=7:r=15",
+        "strong": "nlmeans_opencl=s=10.0:p=13:r=25",
+    },
     "atadenoise": {
         "weak": "atadenoise=0a=0.01:0b=0.02:1a=0.01:1b=0.02:2a=0.01:2b=0.02:s=9",
         "moderate": "atadenoise=0a=0.02:0b=0.04:1a=0.02:1b=0.04:2a=0.02:2b=0.04:s=9",
@@ -59,9 +64,65 @@
     },
 }
 
+deinterlace_methods = ["yadif", "bwdif", "w3fdif", "estdif"]
+
+deinterlace_modes = ["send_frame", "send_field"]
+
+deinterlace_presets = {
+    # Note: bwdif, w3fdif and estdif default to one frame per field, so the mode must always be explicit
+    "yadif": {"send_frame": "yadif=mode=send_frame", "send_field": "yadif=mode=send_field"},
+    "bwdif": {"send_frame": "bwdif=mode=send_frame", "send_field": "bwdif=mode=send_field"},
+    "w3fdif": {"send_frame": "w3fdif=mode=frame", "send_field": "w3fdif=mode=field"},
+    "estdif": {"send_frame": "estdif=mode=frame", "send_field": "estdif=mode=field"},
+}
+
+# Filter strings saved by earlier versions, mapped to the (method, mode) they were selected as
+legacy_deinterlace_filters = {
+    f"{method}{suffix}": (method, mode)
+    for method in deinterlace_presets
+    for suffix, mode in (("", "send_frame"), ("=mode=1", "send_field"))
+}
+
 vsync = ["auto", "passthrough", "cfr", "vfr", "drop"]
 tone_map_items = ["none", "clip", "linear", "gamma", "reinhard", "hable", "mobius"]
 
+unsharp_presets = {
+    "light": "unsharp=5:5:0.5:5:5:0.0",
+    "medium": "unsharp=5:5:1.0:5:5:0.5",
+    "strong": "unsharp=7:7:1.5:7:7:1.0",
+}
+
+deflicker_presets = {
+    "light": "deflicker=mode=pm:size=3",
+    "medium": "deflicker=mode=pm:size=5",
+    "strong": "deflicker=mode=pm:size=11",
+}
+
+colorbalance_presets = {
+    "Warm Shadows": "colorbalance=rs=0.15:bs=-0.15",
+    "Cool Shadows": "colorbalance=rs=-0.15:bs=0.15",
+    "Warm Midtones": "colorbalance=rm=0.15:bm=-0.15",
+    "Cool Midtones": "colorbalance=rm=-0.15:bm=0.15",
+    "Warm Highlights": "colorbalance=rh=0.15:bh=-0.15",
+    "Cool Highlights": "colorbalance=rh=-0.15:bh=0.15",
+}
+
+curves_presets = [
+    "none",
+    "color_negative",
+    "cross_process",
+    "darker",
+    "increase_contrast",
+    "lighter",
+    "linear_contrast",
+    "medium_contrast",
+    "negative",
+    "strong_contrast",
+    "vintage",
+]
+
+pad_aspects = ["none", "16:9", "4:3", "1:1", "9:16", "21:9"]
+
 
 def non(value):
     if value.lower() in (
@@ -92,73 +153,80 @@ def __init__(self, parent, app: FastFlixApp):
         self.updating = False
         self.only_int = QtGui.QIntValidator()
 
-        self.layout = QtWidgets.QGridLayout()
-
-        self.last_row = 0
-
-        self.init_fps()
-        self.add_spacer()
-        self.init_video_speed()
-        self.add_spacer()
-        self.init_eq()
-        self.add_spacer()
-        self.init_denoise()
-        self.add_spacer()
-        self.init_deblock()
-        self.add_spacer()
-        self.init_color_info()
-        self.add_spacer()
-        self.init_vbv()
-        self.add_spacer()
-        self.layout.setRowStretch(self.last_row, True)
+        scroll = QtWidgets.QScrollArea()
+        scroll.setWidgetResizable(True)
+        scroll.setFrameShape(QtWidgets.QFrame.NoFrame)
+
+        container = QtWidgets.QWidget()
+        container.setMinimumHeight(860)
+        self.inner_layout = QtWidgets.QVBoxLayout(container)
+        self.inner_layout.setSpacing(6)
+
+        self.inner_layout.addWidget(self.init_video_details_group())
+        self.inner_layout.addWidget(self.init_fps_group())
+        self.inner_layout.addWidget(self.init_video_processing_group())
+        self.inner_layout.addWidget(self.init_color_appearance_group())
+        self.inner_layout.addWidget(self.init_color_group())
+        self.inner_layout.addWidget(self.init_output_group())
+        self.inner_layout.addStretch()
         self.init_hw_message()
-        self.init_titles()
-        # self.add_spacer()
-        # self.init_custom_filters()
 
-        # self.last_row += 1
+        scroll.setWidget(container)
 
-        # self.layout.setColumnStretch(6, True)
-        self.last_row += 1
+        self.layout = QtWidgets.QVBoxLayout()
+        self.layout.setContentsMargins(0, 0, 0, 0)
+        self.layout.addWidget(scroll)
+        self.setLayout(self.layout)
 
-        warning_label = QtWidgets.QLabel()
-        ico = QtGui.QIcon(get_icon("onyx-warning", app.fastflix.config.theme))
-        warning_label.setPixmap(ico.pixmap(22))
+    @staticmethod
+    def setup_grid(gl, cols=6):
+        for i in range(cols):
+            gl.setColumnMinimumWidth(i, 120)
+            gl.setColumnStretch(i, 1)
 
-        for i in range(1, 7):
-            self.layout.setColumnMinimumWidth(i, 155)
-        self.setLayout(self.layout)
+    @staticmethod
+    def setup_group(group, rows):
+        group.setMinimumHeight(rows * 40 + 30)
+        group.setSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
 
-    def add_spacer(self):
-        self.last_row += 1
-        spacer_widget = QtWidgets.QWidget(self)
-        spacer_widget.setFixedHeight(1)
-        spacer_widget.setStyleSheet("background-color: #ddd")
-        self.layout.addWidget(spacer_widget, self.last_row, 0, 1, 7)
+    def init_video_details_group(self):
+        group = QtWidgets.QGroupBox(t("Video Details"))
+        gl = QtWidgets.QGridLayout(group)
+        self.setup_grid(gl)
 
-    def add_row_label(self, label, row_number):
-        label = QtWidgets.QLabel(label)
-        label.setFixedWidth(140)
-        if self.app.fastflix.config.theme == "onyx":
-            label.setStyleSheet(get_onyx_label_style(muted=True))
-        shrink_text_to_fit(label, padding=4)
-        self.layout.addWidget(label, row_number, 0, alignment=QtCore.Qt.AlignLeft | QtCore.Qt.AlignTop)
+        self.video_title = QtWidgets.QLineEdit()
+        self.video_title.setPlaceholderText(t("Video Title"))
+        self.video_title.textChanged.connect(self.page_update)
+
+        self.video_track_title = QtWidgets.QLineEdit()
+        self.video_track_title.setPlaceholderText(t("Video Track Title"))
+        self.video_track_title.textChanged.connect(self.page_update)
+
+        gl.addWidget(QtWidgets.QLabel(t("Video Title")), 0, 0, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.video_title, 0, 1)
+        gl.addWidget(QtWidgets.QLabel(t("Video Track Title")), 0, 2, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.video_track_title, 0, 3)
+
+        self.setup_group(group, rows=1)
+        return group
+
+    def init_fps_group(self):
+        group = QtWidgets.QGroupBox(t("Frame Rate"))
+        gl = QtWidgets.QGridLayout(group)
+        self.setup_grid(gl)
 
-    def init_fps(self):
         self.incoming_fps_widget = QtWidgets.QLineEdit()
-        self.incoming_fps_widget.setFixedWidth(150)
         self.incoming_fps_widget.setDisabled(True)
         self.incoming_fps_widget.textChanged.connect(self.page_update)
         self.outgoing_fps_widget = QtWidgets.QLineEdit()
-        self.outgoing_fps_widget.setFixedWidth(150)
         self.outgoing_fps_widget.setDisabled(True)
         self.outgoing_fps_widget.textChanged.connect(self.page_update)
-        self.incoming_same_as_source = QtWidgets.QCheckBox(t("Same as Source"))
+        self.incoming_same_as_source = ToggleSwitch(t("Same as Source"))
         self.incoming_same_as_source.setChecked(True)
         self.incoming_same_as_source.toggled.connect(
             lambda: self.fps_update(self.incoming_same_as_source, self.incoming_fps_widget)
         )
-        self.outgoing_same_as_source = QtWidgets.QCheckBox(t("Same as Source"))
+        self.outgoing_same_as_source = ToggleSwitch(t("Same as Source"))
         self.outgoing_same_as_source.setChecked(True)
         self.outgoing_same_as_source.toggled.connect(
             lambda: self.fps_update(self.outgoing_same_as_source, self.outgoing_fps_widget)
@@ -170,100 +238,52 @@ def init_fps(self):
         self.vsync_widget.addItems(vsync)
         self.vsync_widget.currentIndexChanged.connect(self.page_update)
 
-        self.add_row_label(t("Frame Rate"), self.last_row)
+        gl.addWidget(QtWidgets.QLabel(t("Override Source FPS")), 0, 0, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.incoming_fps_widget, 0, 1)
+        gl.addWidget(self.incoming_same_as_source, 0, 2)
+        gl.addWidget(QtWidgets.QLabel(t("Source Frame Rate")), 0, 4, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.source_frame_rate, 0, 5)
 
-        self.layout.addWidget(
-            QtWidgets.QLabel(t("Override Source FPS")), self.last_row, 1, alignment=QtCore.Qt.AlignRight
-        )
-        self.layout.addWidget(self.incoming_fps_widget, self.last_row, 2)
-        self.layout.addWidget(self.incoming_same_as_source, self.last_row, 3)
-        self.layout.addWidget(
-            QtWidgets.QLabel(t("Source Frame Rate")), self.last_row, 5, alignment=QtCore.Qt.AlignRight
-        )
-        self.layout.addWidget(self.source_frame_rate, self.last_row, 6)
-
-        self.last_row += 1
-        self.layout.addWidget(
-            QtWidgets.QLabel(t("Output FPS") + " ʘ"), self.last_row, 1, alignment=QtCore.Qt.AlignRight
-        )
-        self.layout.addWidget(self.outgoing_fps_widget, self.last_row, 2)
-        self.layout.addWidget(self.outgoing_same_as_source, self.last_row, 3)
-
-        self.layout.addWidget(QtWidgets.QLabel(t("vsync")), self.last_row, 5, alignment=QtCore.Qt.AlignRight)
-        self.layout.addWidget(self.vsync_widget, self.last_row, 6)
+        gl.addWidget(QtWidgets.QLabel(t("Output FPS")), 1, 0, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.outgoing_fps_widget, 1, 1)
+        gl.addWidget(self.outgoing_same_as_source, 1, 2)
+        gl.addWidget(QtWidgets.QLabel(t("vsync")), 1, 4, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.vsync_widget, 1, 5)
 
-        self.last_row += 1
-
-    def fps_update(self, myself, widget):
-        widget.setDisabled(myself.isChecked())
-        self.page_update()
+        self.setup_group(group, rows=2)
+        return group
 
-    # def init_concat(self):
-    #     layout = QtWidgets.QHBoxLayout()
-    #     self.concat_widget = QtWidgets.QCheckBox(t("Combine Files"))
-    #     # TODO add "learn more" link
-    #
-    #     layout.addWidget(self.concat_widget)
-    #     return layout
+    def init_video_processing_group(self):
+        group = QtWidgets.QGroupBox(t("Video Processing"))
+        gl = QtWidgets.QGridLayout(group)
+        self.setup_grid(gl)
+        row = 0
 
-    def init_video_speed(self):
-        self.last_row += 1
+        # --- Video Speed / HDR row ---
         self.video_speed_widget = QtWidgets.QComboBox()
         self.video_speed_widget.addItems(video_speeds.keys())
-        self.video_speed_widget.currentIndexChanged.connect(self.page_update)
-        self.layout.addWidget(
-            QtWidgets.QLabel(t("Video Speed") + " ʘ"), self.last_row, 1, alignment=QtCore.Qt.AlignRight
-        )
-        self.layout.addWidget(self.video_speed_widget, self.last_row, 2)
-        self.layout.addWidget(QtWidgets.QLabel(t("Warning: Audio will not be modified")), self.last_row, 3, 1, 3)
+        self.video_speed_widget.currentIndexChanged.connect(self.on_video_speed_changed)
+        gl.addWidget(QtWidgets.QLabel(t("Video Speed") + " ʘ"), row, 0, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.video_speed_widget, row, 1)
+
+        self.reverse_video_widget = ToggleSwitch(t("Reverse Video") + " ʘ")
+        self.reverse_video_widget.stateChanged.connect(self.on_reverse_video_changed)
+        gl.addWidget(self.reverse_video_widget, row, 3)
 
-        # def init_tone_map(self):
-        #     self.last_row += 1
         self.tone_map_widget = QtWidgets.QComboBox()
         self.tone_map_widget.addItems(tone_map_items)
         self.tone_map_widget.setCurrentIndex(5)
         self.tone_map_widget.currentIndexChanged.connect(self.page_update)
-        self.layout.addWidget(
-            QtWidgets.QLabel(t("HDR -> SDR Tone Map")), self.last_row, 5, alignment=QtCore.Qt.AlignRight
-        )
-        self.layout.addWidget(self.tone_map_widget, self.last_row, 6)
-
-    def init_eq(self):
-        self.last_row += 1
-        self.brightness_widget = QtWidgets.QLineEdit()
-        brightness_validator = QtGui.QDoubleValidator()
-        brightness_validator.setLocale(QtCore.QLocale.c())  # Use C locale to force dot as decimal separator
-        self.brightness_widget.setValidator(brightness_validator)
-        self.brightness_widget.setToolTip("Default is: 0")
-        self.brightness_widget.textChanged.connect(lambda: self.page_update(build_thumbnail=True))
-
-        self.contrast_widget = QtWidgets.QLineEdit()
-        contrast_validator = QtGui.QDoubleValidator()
-        contrast_validator.setLocale(QtCore.QLocale.c())  # Use C locale to force dot as decimal separator
-        self.contrast_widget.setValidator(contrast_validator)
-        self.contrast_widget.setToolTip("Default is: 1")
-        self.contrast_widget.textChanged.connect(lambda: self.page_update(build_thumbnail=True))
+        gl.addWidget(QtWidgets.QLabel(t("HDR -> SDR Tone Map")), row, 4, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.tone_map_widget, row, 5)
 
-        self.saturation_widget = QtWidgets.QLineEdit()
-        saturation_validator = QtGui.QDoubleValidator()
-        saturation_validator.setLocale(QtCore.QLocale.c())  # Use C locale to force dot as decimal separator
-        self.saturation_widget.setValidator(saturation_validator)
-        self.saturation_widget.setToolTip("Default is: 1")
-        self.saturation_widget.textChanged.connect(lambda: self.page_update(build_thumbnail=True))
+        # --- Denoise row ---
+        row += 1
 
-        self.add_row_label(t("Equalizer") + " ʘ", self.last_row)
-
-        self.layout.addWidget(QtWidgets.QLabel(t("Brightness")), self.last_row, 1, alignment=QtCore.Qt.AlignRight)
-        self.layout.addWidget(self.brightness_widget, self.last_row, 2)
-        self.layout.addWidget(QtWidgets.QLabel(t("Contrast")), self.last_row, 3, alignment=QtCore.Qt.AlignRight)
-        self.layout.addWidget(self.contrast_widget, self.last_row, 4)
-        self.layout.addWidget(QtWidgets.QLabel(t("Saturation")), self.last_row, 5, alignment=QtCore.Qt.AlignRight)
-        self.layout.addWidget(self.saturation_widget, self.last_row, 6)
-
-    def init_denoise(self):
-        self.last_row += 1
         self.denoise_type_widget = QtWidgets.QComboBox()
-        self.denoise_type_widget.addItems(["none", "nlmeans", "atadenoise", "hqdn3d", "vaguedenoiser"])
+        self.denoise_type_widget.addItems(
+            ["none", "nlmeans", "nlmeans_opencl", "atadenoise", "hqdn3d", "vaguedenoiser"]
+        )
         self.denoise_type_widget.setCurrentIndex(0)
         self.denoise_type_widget.currentIndexChanged.connect(self.page_update)
 
@@ -272,14 +292,32 @@ def init_denoise(self):
         self.denoise_strength_widget.setCurrentIndex(0)
         self.denoise_strength_widget.currentIndexChanged.connect(self.page_update)
 
-        self.add_row_label(t("Denoise") + " ʘ", self.last_row)
-        self.layout.addWidget(QtWidgets.QLabel(t("Method")), self.last_row, 1, alignment=QtCore.Qt.AlignRight)
-        self.layout.addWidget(self.denoise_type_widget, self.last_row, 2)
-        self.layout.addWidget(QtWidgets.QLabel(t("Strength")), self.last_row, 3, alignment=QtCore.Qt.AlignRight)
-        self.layout.addWidget(self.denoise_strength_widget, self.last_row, 4)
+        gl.addWidget(QtWidgets.QLabel(t("Denoise")), row, 0, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.denoise_type_widget, row, 1)
+        gl.addWidget(QtWidgets.QLabel(t("Strength")), row, 2, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.denoise_strength_widget, row, 3)
+
+        # --- Deinterlace row ---
+        row += 1
+
+        self.deinterlace_method_widget = QtWidgets.QComboBox()
+        self.deinterlace_method_widget.addItems(deinterlace_methods)
+        self.deinterlace_method_widget.setCurrentIndex(0)
+        self.deinterlace_method_widget.currentIndexChanged.connect(self.page_update)
+
+        self.deinterlace_mode_widget = QtWidgets.QComboBox()
+        self.deinterlace_mode_widget.addItems(deinterlace_modes)
+        self.deinterlace_mode_widget.setCurrentIndex(0)
+        self.deinterlace_mode_widget.currentIndexChanged.connect(self.page_update)
+
+        gl.addWidget(QtWidgets.QLabel(t("Deinterlace")), row, 0, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.deinterlace_method_widget, row, 1)
+        gl.addWidget(QtWidgets.QLabel(t("Mode")), row, 2, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.deinterlace_mode_widget, row, 3)
+
+        # --- Deblock / Deflicker row ---
+        row += 1
 
-    def init_deblock(self):
-        self.last_row += 1
         self.deblock_widget = QtWidgets.QComboBox()
         self.deblock_widget.addItems(["none", "weak", "strong"])
         self.deblock_widget.setCurrentIndex(0)
@@ -292,14 +330,199 @@ def init_deblock(self):
         self.deblock_size_widget.currentIndexChanged.connect(self.page_update)
         self.deblock_size_widget.setCurrentIndex(2)
 
-        self.add_row_label(t("Deblock") + " ʘ", self.last_row)
-        self.layout.addWidget(QtWidgets.QLabel(t("Strength")), self.last_row, 1, alignment=QtCore.Qt.AlignRight)
-        self.layout.addWidget(self.deblock_widget, self.last_row, 2)
-        self.layout.addWidget(QtWidgets.QLabel(t("Block Size")), self.last_row, 3, alignment=QtCore.Qt.AlignRight)
-        self.layout.addWidget(self.deblock_size_widget, self.last_row, 4)
+        self.deflicker_widget = QtWidgets.QComboBox()
+        self.deflicker_widget.addItems(["none", "light", "medium", "strong"])
+        self.deflicker_widget.setCurrentIndex(0)
+        self.deflicker_widget.currentIndexChanged.connect(self.page_update)
+
+        gl.addWidget(QtWidgets.QLabel(t("Deblock")), row, 0, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.deblock_widget, row, 1)
+        gl.addWidget(QtWidgets.QLabel(t("Block Size")), row, 2, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.deblock_size_widget, row, 3)
+        gl.addWidget(QtWidgets.QLabel(t("Deflicker") + " ʘ"), row, 4, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.deflicker_widget, row, 5)
+
+        # --- Sharpen / Unsharp / GOP Length row ---
+        row += 1
+        c_locale = QtCore.QLocale.c()
+
+        self.sharpen_widget = QtWidgets.QLineEdit()
+        sharpen_validator = QtGui.QDoubleValidator(0.0, 1.0, 2)
+        sharpen_validator.setLocale(c_locale)
+        self.sharpen_widget.setValidator(sharpen_validator)
+        self.sharpen_widget.setToolTip("Default is: 0 (range: 0.0 - 1.0)")
+        self.sharpen_widget.textChanged.connect(lambda: self.page_update(build_thumbnail=True))
+
+        self.unsharp_widget = QtWidgets.QComboBox()
+        self.unsharp_widget.addItems(["none", "light", "medium", "strong"])
+        self.unsharp_widget.setCurrentIndex(0)
+        self.unsharp_widget.currentIndexChanged.connect(lambda: self.page_update(build_thumbnail=True))
+
+        self.gop_length_widget = QtWidgets.QLineEdit()
+        self.gop_length_widget.setValidator(QtGui.QIntValidator(1, 9999))
+        self.gop_length_widget.setToolTip(t("GOP length in frames (leave empty for encoder default)"))
+        self.gop_length_widget.textChanged.connect(self.page_update)
+
+        gl.addWidget(QtWidgets.QLabel(t("Sharpen")), row, 0, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.sharpen_widget, row, 1)
+        gl.addWidget(QtWidgets.QLabel(t("Unsharp Mask")), row, 2, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.unsharp_widget, row, 3)
+        gl.addWidget(QtWidgets.QLabel(t("GOP Length")), row, 4, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.gop_length_widget, row, 5)
+
+        # --- Pad row ---
+        row += 1
+
+        self.pad_aspect_widget = QtWidgets.QComboBox()
+        self.pad_aspect_widget.addItems(pad_aspects)
+        self.pad_aspect_widget.setCurrentIndex(0)
+        self.pad_aspect_widget.currentIndexChanged.connect(self.page_update)
+
+        self.pad_color_widget = QtWidgets.QLineEdit()
+        self.pad_color_widget.setPlaceholderText("black")
+        self.pad_color_widget.setToolTip(
+            t("Pad color (e.g. black, white, 0x000000). FFmpeg only — rigaya always uses black.")
+        )
+        self.pad_color_widget.textChanged.connect(self.page_update)
+
+        gl.addWidget(QtWidgets.QLabel(t("Pad Aspect")), row, 0, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.pad_aspect_widget, row, 1)
+        gl.addWidget(QtWidgets.QLabel(t("Pad Color")), row, 2, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.pad_color_widget, row, 3)
+
+        self.setup_group(group, rows=6)
+        return group
+
+    def init_color_appearance_group(self):
+        group = QtWidgets.QGroupBox(t("Color & Appearance"))
+        gl = QtWidgets.QGridLayout(group)
+        self.setup_grid(gl)
+        row = 0
+        c_locale = QtCore.QLocale.c()
+
+        # --- Equalizer row 1: Brightness / Contrast / Saturation ---
+        self.brightness_widget = QtWidgets.QLineEdit()
+        brightness_validator = QtGui.QDoubleValidator()
+        brightness_validator.setLocale(c_locale)
+        self.brightness_widget.setValidator(brightness_validator)
+        self.brightness_widget.setToolTip("Default is: 0")
+        self.brightness_widget.textChanged.connect(lambda: self.page_update(build_thumbnail=True))
+
+        self.contrast_widget = QtWidgets.QLineEdit()
+        contrast_validator = QtGui.QDoubleValidator()
+        contrast_validator.setLocale(c_locale)
+        self.contrast_widget.setValidator(contrast_validator)
+        self.contrast_widget.setToolTip("Default is: 1")
+        self.contrast_widget.textChanged.connect(lambda: self.page_update(build_thumbnail=True))
+
+        self.saturation_widget = QtWidgets.QLineEdit()
+        saturation_validator = QtGui.QDoubleValidator()
+        saturation_validator.setLocale(c_locale)
+        self.saturation_widget.setValidator(saturation_validator)
+        self.saturation_widget.setToolTip("Default is: 1")
+        self.saturation_widget.textChanged.connect(lambda: self.page_update(build_thumbnail=True))
+
+        gl.addWidget(QtWidgets.QLabel(t("Brightness")), row, 0, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.brightness_widget, row, 1)
+        gl.addWidget(QtWidgets.QLabel(t("Contrast")), row, 2, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.contrast_widget, row, 3)
+        gl.addWidget(QtWidgets.QLabel(t("Saturation")), row, 4, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.saturation_widget, row, 5)
+
+        # --- Equalizer row 2: Gamma / Hue / Vibrance ---
+        row += 1
+
+        self.gamma_widget = QtWidgets.QLineEdit()
+        gamma_validator = QtGui.QDoubleValidator(0.1, 10.0, 2)
+        gamma_validator.setLocale(c_locale)
+        self.gamma_widget.setValidator(gamma_validator)
+        self.gamma_widget.setToolTip("Default is: 1 (range: 0.1 - 10.0)")
+        self.gamma_widget.textChanged.connect(lambda: self.page_update(build_thumbnail=True))
+
+        self.hue_widget = QtWidgets.QLineEdit()
+        hue_validator = QtGui.QDoubleValidator(-180.0, 180.0, 2)
+        hue_validator.setLocale(c_locale)
+        self.hue_widget.setValidator(hue_validator)
+        self.hue_widget.setToolTip("Default is: 0 (range: -180 - 180 degrees)")
+        self.hue_widget.textChanged.connect(lambda: self.page_update(build_thumbnail=True))
+
+        self.vibrance_widget = QtWidgets.QLineEdit()
+        vibrance_validator = QtGui.QDoubleValidator(-2.0, 2.0, 2)
+        vibrance_validator.setLocale(c_locale)
+        self.vibrance_widget.setValidator(vibrance_validator)
+        self.vibrance_widget.setToolTip("Default is: 0 (range: -2.0 - 2.0)")
+        self.vibrance_widget.textChanged.connect(lambda: self.page_update(build_thumbnail=True))
+
+        gl.addWidget(QtWidgets.QLabel(t("Gamma")), row, 0, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.gamma_widget, row, 1)
+        gl.addWidget(QtWidgets.QLabel(t("Hue")), row, 2, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.hue_widget, row, 3)
+        gl.addWidget(QtWidgets.QLabel(t("Vibrance") + " ʘ"), row, 4, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.vibrance_widget, row, 5)
+
+        # --- Color Temperature / Curves / Colorbalance row ---
+        row += 1
+
+        self.color_temperature_widget = QtWidgets.QLineEdit()
+        color_temp_validator = QtGui.QIntValidator(1000, 40000)
+        self.color_temperature_widget.setValidator(color_temp_validator)
+        self.color_temperature_widget.setToolTip("Default is: 6500 Kelvin (range: 1000 - 40000)")
+        self.color_temperature_widget.textChanged.connect(lambda: self.page_update(build_thumbnail=True))
+
+        self.curves_preset_widget = QtWidgets.QComboBox()
+        self.curves_preset_widget.addItems(curves_presets)
+        self.curves_preset_widget.setCurrentIndex(0)
+        self.curves_preset_widget.currentIndexChanged.connect(lambda: self.page_update(build_thumbnail=True))
+
+        self.colorbalance_widget = QtWidgets.QComboBox()
+        self.colorbalance_widget.addItems(["none"] + list(colorbalance_presets.keys()))
+        self.colorbalance_widget.setCurrentIndex(0)
+        self.colorbalance_widget.currentIndexChanged.connect(lambda: self.page_update(build_thumbnail=True))
+
+        gl.addWidget(QtWidgets.QLabel(t("Color Temperature") + " ʘ"), row, 0, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.color_temperature_widget, row, 1)
+        gl.addWidget(QtWidgets.QLabel(t("Curves Preset")), row, 2, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.curves_preset_widget, row, 3)
+        gl.addWidget(QtWidgets.QLabel(t("Colorbalance") + " ʘ"), row, 4, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.colorbalance_widget, row, 5)
+
+        # --- LUT3D row ---
+        row += 1
+
+        self.lut3d_path_widget = QtWidgets.QLineEdit()
+        self.lut3d_path_widget.setPlaceholderText(t("No LUT file selected"))
+        self.lut3d_path_widget.setReadOnly(True)
+        self.lut3d_path_widget.textChanged.connect(self.page_update)
+
+        self.lut3d_browse_button = QtWidgets.QPushButton(t("Browse"))
+        self.lut3d_browse_button.clicked.connect(self.browse_lut3d)
+
+        self.lut3d_clear_button = QtWidgets.QPushButton(t("Clear"))
+        self.lut3d_clear_button.clicked.connect(lambda: self.lut3d_path_widget.setText(""))
+
+        gl.addWidget(QtWidgets.QLabel(t("LUT3D")), row, 0, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.lut3d_path_widget, row, 1, 1, 3)
+        gl.addWidget(self.lut3d_browse_button, row, 4)
+        gl.addWidget(self.lut3d_clear_button, row, 5)
+
+        self.setup_group(group, rows=4)
+        return group
+
+    def browse_lut3d(self):
+        file_path, _ = QtWidgets.QFileDialog.getOpenFileName(
+            self,
+            t("Select LUT File"),
+            "",
+            t("LUT Files") + " (*.cube *.3dl *.dat *.m3d);;All Files (*)",
+        )
+        if file_path:
+            self.lut3d_path_widget.setText(file_path)
+
+    def init_color_group(self):
+        group = QtWidgets.QGroupBox(t("Color"))
+        gl = QtWidgets.QGridLayout(group)
+        self.setup_grid(gl)
 
-    def init_color_info(self):
-        self.last_row += 1
         self.color_primaries_widget = QtWidgets.QComboBox()
         self.color_primaries_widget.addItem(t("Unspecified"))
         self.color_primaries_widget.addItems(ffmpeg_valid_color_primaries)
@@ -315,126 +538,245 @@ def init_color_info(self):
         self.color_space_widget.addItems(ffmpeg_valid_color_space)
         self.color_space_widget.currentIndexChanged.connect(self.page_update)
 
-        self.add_row_label(t("Color Formats"), self.last_row)
-        self.layout.addWidget(QtWidgets.QLabel(t("Color Primaries")), self.last_row, 1, alignment=QtCore.Qt.AlignRight)
-        self.layout.addWidget(self.color_primaries_widget, self.last_row, 2)
-        self.layout.addWidget(QtWidgets.QLabel(t("Color Transfer")), self.last_row, 3, alignment=QtCore.Qt.AlignRight)
-        self.layout.addWidget(self.color_transfer_widget, self.last_row, 4)
-        self.layout.addWidget(QtWidgets.QLabel(t("Color Space")), self.last_row, 5, alignment=QtCore.Qt.AlignRight)
-        self.layout.addWidget(self.color_space_widget, self.last_row, 6)
+        gl.addWidget(QtWidgets.QLabel(t("Color Primaries")), 0, 0, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.color_primaries_widget, 0, 1)
+        gl.addWidget(QtWidgets.QLabel(t("Color Transfer")), 0, 2, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.color_transfer_widget, 0, 3)
+        gl.addWidget(QtWidgets.QLabel(t("Color Space")), 0, 4, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.color_space_widget, 0, 5)
+
+        self.setup_group(group, rows=1)
+        return group
+
+    def init_output_group(self):
+        group = QtWidgets.QGroupBox(t("Output"))
+        gl = QtWidgets.QGridLayout(group)
+        self.setup_grid(gl)
 
-    def init_vbv(self):
-        self.last_row += 1
         self.maxrate_widget = QtWidgets.QLineEdit()
-        # self.maxrate_widget.setPlaceholderText("3000")
         self.maxrate_widget.setValidator(self.only_int)
         self.maxrate_widget.textChanged.connect(self.page_update)
 
         self.bufsize_widget = QtWidgets.QLineEdit()
-        # self.bufsize_widget.setPlaceholderText("3000")
         self.bufsize_widget.setValidator(self.only_int)
         self.bufsize_widget.textChanged.connect(self.page_update)
 
-        # self.vbv_checkbox = QtWidgets.QCheckBox(t("Enable VBV"))
-        # self.vbv_checkbox.toggled.connect(self.vbv_check_changed)
+        gl.addWidget(QtWidgets.QLabel(f"{t('Maxrate')} (kbps)"), 0, 0, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.maxrate_widget, 0, 1)
+        gl.addWidget(QtWidgets.QLabel(f"{t('Bufsize')} (kbps)"), 0, 2, alignment=QtCore.Qt.AlignRight)
+        gl.addWidget(self.bufsize_widget, 0, 3)
+        gl.addWidget(QtWidgets.QLabel(t("Both must have values to be enabled")), 0, 4, 1, 2)
 
-        self.add_row_label(f"{t('Video Buffering')}\n{t('Verifier')} (VBV)", self.last_row)
-        self.layout.addWidget(
-            QtWidgets.QLabel(f"{t('Maxrate')} (kbps)"), self.last_row, 1, alignment=QtCore.Qt.AlignRight
-        )
-        self.layout.addWidget(self.maxrate_widget, self.last_row, 2)
-        self.layout.addWidget(
-            QtWidgets.QLabel(f"{t('Bufsize')} (kbps)"), self.last_row, 3, alignment=QtCore.Qt.AlignRight
-        )
-        self.layout.addWidget(self.bufsize_widget, self.last_row, 4)
-        self.layout.addWidget(QtWidgets.QLabel(t("Both must have values to be enabled")), self.last_row, 5, 1, 2)
+        self.faststart_widget = ToggleSwitch(t("Fast Start (MP4/MOV)"))
+        self.faststart_widget.setChecked(True)
+        self.faststart_widget.setToolTip(t("Moves metadata to the beginning of the file for faster streaming start"))
+        self.faststart_widget.stateChanged.connect(self.page_update)
+        self.faststart_widget.setVisible(False)
+        gl.addWidget(self.faststart_widget, 1, 0, 1, 2)
 
-    # def vbv_check_changed(self):
-    #     self.bufsize_widget.setEnabled(self.vbv_checkbox.isChecked())
-    #     self.maxrate_widget.setEnabled(self.vbv_checkbox.isChecked())
-    #     self.page_update()
-
-    # def init_subtitle_overlay_fix(self):
-    #     self.last_row += 1
-    # TODO figure out overlay for subtitles move up
-    # overlay=y=-140
-    # crop=1904:800:6:140
-    # (800 + 140) - 1080 == -140
+        self.setup_group(group, rows=2)
+        return group
 
     def init_hw_message(self):
-        self.last_row += 1
-        label = QtWidgets.QLabel("ʘ " + t("Not supported by rigaya's hardware encoders"))
+        label = QtWidgets.QLabel(
+            "ʘ "
+            + t(
+                "Not supported by rigaya's hardware encoders"
+                " (Video Speed, Reverse Video, Deflicker, Vibrance, Color Temperature, Colorbalance)"
+            )
+        )
         if self.app.fastflix.config.theme == "onyx":
             label.setStyleSheet(get_onyx_label_style(muted=True))
+        self.inner_layout.addWidget(label)
 
-        self.layout.addWidget(label, self.last_row, 0, 1, 2)
-
-    def init_titles(self):
-        self.video_title = QtWidgets.QLineEdit()
-        self.video_title.setPlaceholderText(t("Video Title"))
-        self.video_title.textChanged.connect(self.page_update)
-
-        self.video_track_title = QtWidgets.QLineEdit()
-        self.video_track_title.setPlaceholderText(t("Video Track Title") + " ʘ")
-        self.video_track_title.textChanged.connect(self.page_update)
-
-        self.layout.addWidget(QtWidgets.QLabel(t("Video Title")), self.last_row, 3, alignment=QtCore.Qt.AlignRight)
-        self.layout.addWidget(self.video_title, self.last_row, 4)
-        self.layout.addWidget(
-            QtWidgets.QLabel(t("Video Track Title") + " ʘ"), self.last_row, 5, alignment=QtCore.Qt.AlignRight
-        )
-        self.layout.addWidget(self.video_track_title, self.last_row, 6)
-
-    def init_custom_filters(self):
-        self.last_row += 1
-
-        self.first_filters = QtWidgets.QLineEdit()
-        self.first_filters.textChanged.connect(self.page_update)
+    def fps_update(self, myself, widget):
+        widget.setDisabled(myself.isChecked())
+        self.page_update()
 
-        self.second_filters = QtWidgets.QLineEdit()
-        self.second_filters.textChanged.connect(self.page_update)
+    def get_gop_length(self):
+        """GOP length in frames, or None when empty/invalid/less than 1 (encoder default)"""
+        text = self.gop_length_widget.text().strip()
+        if not text:
+            return None
+        try:
+            value = int(text)
+        except ValueError:
+            logger.warning("Invalid GOP length value")
+            return None
+        return value if value >= 1 else None
+
+    def _is_programmatic_change(self) -> bool:
+        return self.updating or getattr(self.main, "loading_video", False)
+
+    def on_video_speed_changed(self):
+        if self._is_programmatic_change():
+            self.page_update()
+            return
+        if not self.app.fastflix.config.suppress_video_speed_warning:
+            current_speed = video_speeds[self.video_speed_widget.currentText()]
+            if current_speed != 1:
+                msg = QtWidgets.QMessageBox()
+                msg.setIcon(QtWidgets.QMessageBox.Warning)
+                msg.setWindowTitle(t("Video Speed Warning"))
+                msg.setText(t("Warning: Audio will not be modified when changing video speed."))
+                cb = QtWidgets.QCheckBox(t("Don't show this warning again"))
+                msg.setCheckBox(cb)
+                msg.addButton(t("OK"), QtWidgets.QMessageBox.AcceptRole)
+                msg.exec()
+                if cb.isChecked():
+                    self.app.fastflix.config.suppress_video_speed_warning = True
+                    self.app.fastflix.config.save()
+        self.page_update()
 
-        self.add_row_label(t("Custom Filters"), self.last_row)
-        self.layout.addWidget(QtWidgets.QLabel(t("First Pass")), self.last_row, 1, alignment=QtCore.Qt.AlignRight)
-        self.layout.addWidget(self.first_filters, self.last_row, 2, 1, 2)
-        self.layout.addWidget(QtWidgets.QLabel(t("Second Pass")), self.last_row, 4, alignment=QtCore.Qt.AlignRight)
-        self.layout.addWidget(self.second_filters, self.last_row, 5, 1, 2)
+    def on_reverse_video_changed(self):
+        if self._is_programmatic_change():
+            self.page_update()
+            return
+        if self.reverse_video_widget.isChecked() and not self.app.fastflix.config.suppress_reverse_video_warning:
+            msg = QtWidgets.QMessageBox()
+            msg.setIcon(QtWidgets.QMessageBox.Warning)
+            msg.setWindowTitle(t("Reverse Video Warning"))
+            msg.setText(
+                t("The reverse filter buffers all video frames in memory.")
+                + " "
+                + t("This may require significant RAM for long or high-resolution videos.")
+                + "\n\n"
+                + t("Audio on converted (non-copy) tracks will also be reversed.")
+            )
+            cb = QtWidgets.QCheckBox(t("Don't show this warning again"))
+            msg.setCheckBox(cb)
+            msg.addButton(t("OK"), QtWidgets.QMessageBox.AcceptRole)
+            msg.exec()
+            if cb.isChecked():
+                self.app.fastflix.config.suppress_reverse_video_warning = True
+                self.app.fastflix.config.save()
+        self.page_update()
 
     def update_settings(self):
         if self.updating or not self.app.fastflix.current_video:
             return False
         self.updating = True
         self.app.fastflix.current_video.video_settings.video_speed = video_speeds[self.video_speed_widget.currentText()]
+        self.app.fastflix.current_video.video_settings.reverse_video = self.reverse_video_widget.isChecked()
         self.app.fastflix.current_video.video_settings.deblock = non(self.deblock_widget.currentText())
         self.app.fastflix.current_video.video_settings.deblock_size = int(self.deblock_size_widget.currentText())
         self.app.fastflix.current_video.video_settings.tone_map = self.tone_map_widget.currentText()
         self.app.fastflix.current_video.video_settings.vsync = non(self.vsync_widget.currentText())
 
-        try:
-            if self.brightness_widget.text().strip() != "":
+        if self.brightness_widget.text().strip():
+            try:
                 self.app.fastflix.current_video.video_settings.brightness = str(float(self.brightness_widget.text()))
-        except ValueError:
-            logger.warning("Invalid brightness value")
+            except ValueError:
+                logger.warning("Invalid brightness value")
+        else:
+            self.app.fastflix.current_video.video_settings.brightness = None
 
-        try:
-            if self.saturation_widget.text().strip() != "":
+        if self.saturation_widget.text().strip():
+            try:
                 self.app.fastflix.current_video.video_settings.saturation = str(float(self.saturation_widget.text()))
-        except ValueError:
-            logger.warning("Invalid saturation value")
+            except ValueError:
+                logger.warning("Invalid saturation value")
+        else:
+            self.app.fastflix.current_video.video_settings.saturation = None
 
-        try:
-            if self.contrast_widget.text().strip() != "":
+        if self.contrast_widget.text().strip():
+            try:
                 self.app.fastflix.current_video.video_settings.contrast = str(float(self.contrast_widget.text()))
-        except ValueError:
-            logger.warning("Invalid contrast value")
+            except ValueError:
+                logger.warning("Invalid contrast value")
+        else:
+            self.app.fastflix.current_video.video_settings.contrast = None
+
+        if self.gamma_widget.text().strip():
+            try:
+                self.app.fastflix.current_video.video_settings.gamma = str(float(self.gamma_widget.text()))
+            except ValueError:
+                logger.warning("Invalid gamma value")
+        else:
+            self.app.fastflix.current_video.video_settings.gamma = None
+
+        if self.hue_widget.text().strip():
+            try:
+                self.app.fastflix.current_video.video_settings.hue = str(float(self.hue_widget.text()))
+            except ValueError:
+                logger.warning("Invalid hue value")
+        else:
+            self.app.fastflix.current_video.video_settings.hue = None
+
+        if self.sharpen_widget.text().strip():
+            try:
+                self.app.fastflix.current_video.video_settings.sharpen = str(float(self.sharpen_widget.text()))
+            except ValueError:
+                logger.warning("Invalid sharpen value")
+        else:
+            self.app.fastflix.current_video.video_settings.sharpen = None
+
+        if self.vibrance_widget.text().strip():
+            try:
+                self.app.fastflix.current_video.video_settings.vibrance = str(float(self.vibrance_widget.text()))
+            except ValueError:
+                logger.warning("Invalid vibrance value")
+        else:
+            self.app.fastflix.current_video.video_settings.vibrance = None
+
+        if self.color_temperature_widget.text().strip():
+            try:
+                self.app.fastflix.current_video.video_settings.color_temperature = str(
+                    int(self.color_temperature_widget.text())
+                )
+            except ValueError:
+                logger.warning("Invalid color temperature value")
+        else:
+            self.app.fastflix.current_video.video_settings.color_temperature = None
+
+        if self.curves_preset_widget.currentIndex() == 0:
+            self.app.fastflix.current_video.video_settings.curves_preset = None
+        else:
+            self.app.fastflix.current_video.video_settings.curves_preset = self.curves_preset_widget.currentText()
+
+        if self.colorbalance_widget.currentIndex() == 0:
+            self.app.fastflix.current_video.video_settings.colorbalance = None
+        else:
+            preset_name = self.colorbalance_widget.currentText()
+            self.app.fastflix.current_video.video_settings.colorbalance = colorbalance_presets[preset_name]
+
+        if self.unsharp_widget.currentIndex() == 0:
+            self.app.fastflix.current_video.video_settings.unsharp = None
+        else:
+            self.app.fastflix.current_video.video_settings.unsharp = unsharp_presets[self.unsharp_widget.currentText()]
+
+        if self.deflicker_widget.currentIndex() == 0:
+            self.app.fastflix.current_video.video_settings.deflicker = None
+        else:
+            self.app.fastflix.current_video.video_settings.deflicker = deflicker_presets[
+                self.deflicker_widget.currentText()
+            ]
+
+        if self.pad_aspect_widget.currentIndex() == 0:
+            self.app.fastflix.current_video.video_settings.pad_aspect = None
+        else:
+            self.app.fastflix.current_video.video_settings.pad_aspect = self.pad_aspect_widget.currentText()
+        self.app.fastflix.current_video.video_settings.pad_color = validate_ffmpeg_color(
+            self.pad_color_widget.text().strip() or "black"
+        )
+
+        self.app.fastflix.current_video.video_settings.lut3d_path = self.lut3d_path_widget.text().strip() or None
+
+        self.app.fastflix.current_video.video_settings.faststart = self.faststart_widget.isChecked()
+
+        self.app.fastflix.current_video.video_settings.gop_length = self.get_gop_length()
 
         # self.app.fastflix.current_video.video_settings.first_pass_filters = self.first_filters.text() or None
         # self.app.fastflix.current_video.video_settings.second_filters = self.second_filters.text() or None
 
         if not self.incoming_same_as_source.isChecked():
             self.app.fastflix.current_video.video_settings.source_fps = self.incoming_fps_widget.text()
+        else:
+            self.app.fastflix.current_video.video_settings.source_fps = None
         if not self.outgoing_same_as_source.isChecked():
             self.app.fastflix.current_video.video_settings.output_fps = self.outgoing_fps_widget.text()
+        else:
+            self.app.fastflix.current_video.video_settings.output_fps = None
 
         if self.denoise_type_widget.currentIndex() == 0:
             self.app.fastflix.current_video.video_settings.denoise = None
@@ -443,6 +785,10 @@ def update_settings(self):
                 self.denoise_type_widget.currentText()
             ][self.denoise_strength_widget.currentText()]
 
+        self.app.fastflix.current_video.video_settings.deinterlace_filter = deinterlace_presets[
+            self.deinterlace_method_widget.currentText()
+        ][self.deinterlace_mode_widget.currentText()]
+
         if self.color_primaries_widget.currentIndex() == 0:
             self.app.fastflix.current_video.video_settings.color_primaries = None
         else:
@@ -465,8 +811,14 @@ def update_settings(self):
             self.app.fastflix.current_video.video_settings.maxrate = None
             self.app.fastflix.current_video.video_settings.bufsize = None
 
+        self.update_faststart_visibility()
         self.updating = False
 
+    def get_deinterlace_filter(self):
+        return deinterlace_presets[self.deinterlace_method_widget.currentText()][
+            self.deinterlace_mode_widget.currentText()
+        ]
+
     def get_settings(self):
         denoise = None
         if self.denoise_type_widget.currentIndex() != 0:
@@ -501,8 +853,63 @@ def get_settings(self):
             except ValueError:
                 logger.warning("Invalid brightness value")
 
+        gamma = None
+        if self.gamma_widget.text().strip() != "":
+            try:
+                gamma = str(float(self.gamma_widget.text()))
+            except ValueError:
+                logger.warning("Invalid gamma value")
+
+        hue = None
+        if self.hue_widget.text().strip() != "":
+            try:
+                hue = str(float(self.hue_widget.text()))
+            except ValueError:
+                logger.warning("Invalid hue value")
+
+        sharpen = None
+        if self.sharpen_widget.text().strip() != "":
+            try:
+                sharpen = str(float(self.sharpen_widget.text()))
+            except ValueError:
+                logger.warning("Invalid sharpen value")
+
+        gop_length = self.get_gop_length()
+
+        vibrance = None
+        if self.vibrance_widget.text().strip():
+            try:
+                vibrance = str(float(self.vibrance_widget.text()))
+            except ValueError:
+                logger.warning("Invalid vibrance value")
+
+        color_temperature = None
+        if self.color_temperature_widget.text().strip():
+            try:
+                color_temperature = str(int(self.color_temperature_widget.text()))
+            except ValueError:
+                logger.warning("Invalid color temperature value")
+
+        curves_preset = None
+        if self.curves_preset_widget.currentIndex() != 0:
+            curves_preset = self.curves_preset_widget.currentText()
+
+        colorbalance = None
+        if self.colorbalance_widget.currentIndex() != 0:
+            preset_name = self.colorbalance_widget.currentText()
+            colorbalance = colorbalance_presets[preset_name]
+
+        unsharp = None
+        if self.unsharp_widget.currentIndex() != 0:
+            unsharp = unsharp_presets[self.unsharp_widget.currentText()]
+
+        deflicker = None
+        if self.deflicker_widget.currentIndex() != 0:
+            deflicker = deflicker_presets[self.deflicker_widget.currentText()]
+
         return AdvancedOptions(
             video_speed=video_speeds[self.video_speed_widget.currentText()],
+            reverse_video=self.reverse_video_widget.isChecked(),
             deblock=non(self.deblock_widget.currentText()),
             deblock_size=int(self.deblock_size_widget.currentText()),
             tone_map=self.tone_map_widget.currentText(),
@@ -510,6 +917,26 @@ def get_settings(self):
             brightness=brightness,
             saturation=saturation,
             contrast=contrast,
+            gamma=gamma,
+            hue=hue,
+            sharpen=sharpen,
+            vibrance=vibrance,
+            color_temperature=color_temperature,
+            curves_preset=curves_preset,
+            curves_preset_index=self.curves_preset_widget.currentIndex(),
+            colorbalance=colorbalance,
+            colorbalance_index=self.colorbalance_widget.currentIndex(),
+            unsharp=unsharp,
+            unsharp_index=self.unsharp_widget.currentIndex(),
+            deflicker=deflicker,
+            deflicker_index=self.deflicker_widget.currentIndex(),
+            pad_aspect=(None if self.pad_aspect_widget.currentIndex() == 0 else self.pad_aspect_widget.currentText()),
+            pad_aspect_index=self.pad_aspect_widget.currentIndex(),
+            pad_color=self.pad_color_widget.text().strip() or "black",
+            lut3d_path=self.lut3d_path_widget.text().strip() or None,
+            faststart=self.faststart_widget.isChecked(),
+            deinterlace=self.main.widgets.deinterlace.isChecked(),
+            gop_length=gop_length,
             maxrate=maxrate,
             bufsize=bufsize,
             source_fps=(None if self.incoming_same_as_source.isChecked() else self.incoming_fps_widget.text()),
@@ -526,8 +953,8 @@ def get_settings(self):
             denoise=denoise,
             denoise_type_index=self.denoise_type_widget.currentIndex(),
             denoise_strength_index=self.denoise_strength_widget.currentIndex(),
-            # first_pass_filters=self.first_filters.text() or None,
-            # second_pass_filters=self.second_filters.text() or None,
+            deinterlace_method_index=self.deinterlace_method_widget.currentIndex(),
+            deinterlace_mode_index=self.deinterlace_mode_widget.currentIndex(),
         )
 
     def hdr_settings(self):
@@ -576,17 +1003,89 @@ def hdr_settings(self):
                     self.color_primaries_widget.setCurrentIndex(0)
 
     def page_update(self, build_thumbnail=False):
+        self.update_faststart_visibility()
         self.main.page_update(build_thumbnail=build_thumbnail)
 
+    def update_faststart_visibility(self):
+        if not hasattr(self, "faststart_widget"):
+            return
+        ext = ""
+        # Use resolve_output_extension() which handles "Source" → actual extension
+        try:
+            result = self.main.resolve_output_extension()
+            if isinstance(result, str):
+                ext = result
+        except Exception:
+            pass
+        # Fall back to reading combo directly (e.g. in tests with mock main)
+        if not ext:
+            try:
+                combo_text = self.main.widgets.output_type_combo.currentText().lower()
+                if isinstance(combo_text, str) and combo_text.startswith("."):
+                    ext = combo_text
+            except Exception:
+                pass
+        # Fall back to output_path if available
+        if not ext and self.app.fastflix.current_video and self.app.fastflix.current_video.video_settings.output_path:
+            ext = self.app.fastflix.current_video.video_settings.output_path.suffix.lower()
+        self.faststart_widget.setVisible(ext in (".mp4", ".mov", ".m4v"))
+
     def reset(self, settings: VideoSettings = None):
         if settings:
             self.video_speed_widget.setCurrentText(get_key(video_speeds, settings.video_speed))
+            self.reverse_video_widget.setChecked(settings.reverse_video)
             self.brightness_widget.setText(settings.brightness or "")
             self.saturation_widget.setText(settings.saturation or "")
             self.contrast_widget.setText(settings.contrast or "")
+            self.gamma_widget.setText(settings.gamma or "")
+            self.hue_widget.setText(settings.hue or "")
+            self.sharpen_widget.setText(settings.sharpen or "")
+            self.vibrance_widget.setText(settings.vibrance or "")
+            self.color_temperature_widget.setText(settings.color_temperature or "")
+            if settings.curves_preset:
+                self.curves_preset_widget.setCurrentText(settings.curves_preset)
+            else:
+                self.curves_preset_widget.setCurrentIndex(0)
+            if settings.colorbalance:
+                for name, value in colorbalance_presets.items():
+                    if settings.colorbalance == value:
+                        self.colorbalance_widget.setCurrentText(name)
+                        break
+                else:
+                    self.colorbalance_widget.setCurrentIndex(0)
+            else:
+                self.colorbalance_widget.setCurrentIndex(0)
+            if settings.unsharp:
+                for name, value in unsharp_presets.items():
+                    if settings.unsharp == value:
+                        self.unsharp_widget.setCurrentText(name)
+                        break
+                else:
+                    self.unsharp_widget.setCurrentIndex(0)
+            else:
+                self.unsharp_widget.setCurrentIndex(0)
+            if settings.deflicker:
+                for name, value in deflicker_presets.items():
+                    if settings.deflicker == value:
+                        self.deflicker_widget.setCurrentText(name)
+                        break
+                else:
+                    self.deflicker_widget.setCurrentIndex(0)
+            else:
+                self.deflicker_widget.setCurrentIndex(0)
+            if settings.pad_aspect:
+                self.pad_aspect_widget.setCurrentText(settings.pad_aspect)
+            else:
+                self.pad_aspect_widget.setCurrentIndex(0)
+            self.pad_color_widget.setText(settings.pad_color if settings.pad_color != "black" else "")
+            self.lut3d_path_widget.setText(settings.lut3d_path or "")
+            self.gop_length_widget.setText(str(settings.gop_length) if settings.gop_length is not None else "")
+            self.faststart_widget.setChecked(settings.faststart if hasattr(settings, "faststart") else True)
 
             if settings.deblock:
                 self.deblock_widget.setCurrentText(settings.deblock)
+            else:
+                self.deblock_widget.setCurrentIndex(0)
             self.deblock_size_widget.setCurrentText(str(settings.deblock_size))
             self.tone_map_widget.setCurrentText(settings.tone_map)
 
@@ -610,6 +1109,23 @@ def reset(self, settings: VideoSettings = None):
                         if settings.denoise == value:
                             self.denoise_type_widget.setCurrentText(denoise_type)
                             self.denoise_strength_widget.setCurrentText(preset_name)
+            else:
+                self.denoise_type_widget.setCurrentIndex(0)
+                self.denoise_strength_widget.setCurrentIndex(0)
+
+            if settings.deinterlace_filter:
+                for method, modes in deinterlace_presets.items():
+                    for mode_name, value in modes.items():
+                        if settings.deinterlace_filter == value:
+                            self.deinterlace_method_widget.setCurrentText(method)
+                            self.deinterlace_mode_widget.setCurrentText(mode_name)
+                if legacy := legacy_deinterlace_filters.get(settings.deinterlace_filter):
+                    self.deinterlace_method_widget.setCurrentText(legacy[0])
+                    self.deinterlace_mode_widget.setCurrentText(legacy[1])
+            else:
+                self.deinterlace_method_widget.setCurrentIndex(0)
+                self.deinterlace_mode_widget.setCurrentIndex(0)
+
             if settings.vsync:
                 self.vsync_widget.setCurrentText(settings.vsync)
             else:
@@ -639,14 +1155,19 @@ def reset(self, settings: VideoSettings = None):
 
             if settings.video_title:
                 self.video_title.setText(settings.video_title)
+            else:
+                self.video_title.setText("")
 
             if settings.video_track_title:
                 self.video_track_title.setText(settings.video_track_title)
+            else:
+                self.video_track_title.setText("")
 
         else:
             self.video_speed_widget.setCurrentIndex(
                 list(video_speeds.values()).index(self.app.fastflix.config.advanced_opt("video_speed"))
             )
+            self.reverse_video_widget.setChecked(self.app.fastflix.config.advanced_opt("reverse_video"))
 
             deblock = self.app.fastflix.config.advanced_opt("deblock")
             if not deblock:
@@ -673,6 +1194,13 @@ def reset(self, settings: VideoSettings = None):
                 self.app.fastflix.config.advanced_opt("denoise_strength_index")
             )
 
+            self.deinterlace_method_widget.setCurrentIndex(
+                self.app.fastflix.config.advanced_opt("deinterlace_method_index")
+            )
+            self.deinterlace_mode_widget.setCurrentIndex(
+                self.app.fastflix.config.advanced_opt("deinterlace_mode_index")
+            )
+
             vsync_value = self.app.fastflix.config.advanced_opt("vsync")
             self.vsync_widget.setCurrentIndex(0 if not vsync_value else (vsync.index(vsync_value) + 1))
 
@@ -687,10 +1215,27 @@ def reset(self, settings: VideoSettings = None):
             self.brightness_widget.setText(self.app.fastflix.config.advanced_opt("brightness") or "")
             self.saturation_widget.setText(self.app.fastflix.config.advanced_opt("saturation") or "")
             self.contrast_widget.setText(self.app.fastflix.config.advanced_opt("contrast") or "")
+            self.gamma_widget.setText(self.app.fastflix.config.advanced_opt("gamma") or "")
+            self.hue_widget.setText(self.app.fastflix.config.advanced_opt("hue") or "")
+            self.sharpen_widget.setText(self.app.fastflix.config.advanced_opt("sharpen") or "")
+            self.vibrance_widget.setText(self.app.fastflix.config.advanced_opt("vibrance") or "")
+            self.color_temperature_widget.setText(self.app.fastflix.config.advanced_opt("color_temperature") or "")
+            self.curves_preset_widget.setCurrentIndex(self.app.fastflix.config.advanced_opt("curves_preset_index") or 0)
+            self.colorbalance_widget.setCurrentIndex(self.app.fastflix.config.advanced_opt("colorbalance_index") or 0)
+            self.unsharp_widget.setCurrentIndex(self.app.fastflix.config.advanced_opt("unsharp_index") or 0)
+            self.deflicker_widget.setCurrentIndex(self.app.fastflix.config.advanced_opt("deflicker_index") or 0)
+            self.pad_aspect_widget.setCurrentIndex(self.app.fastflix.config.advanced_opt("pad_aspect_index") or 0)
+            pad_color_val = self.app.fastflix.config.advanced_opt("pad_color")
+            self.pad_color_widget.setText(pad_color_val if pad_color_val and pad_color_val != "black" else "")
+            self.lut3d_path_widget.setText(self.app.fastflix.config.advanced_opt("lut3d_path") or "")
+            gop_val = self.app.fastflix.config.advanced_opt("gop_length")
+            self.gop_length_widget.setText(str(gop_val) if gop_val is not None else "")
+            faststart_val = self.app.fastflix.config.advanced_opt("faststart")
+            self.faststart_widget.setChecked(faststart_val if faststart_val is not None else True)
 
             self.hdr_settings()
-            # self.video_title.setText("")
-            # self.video_track_title.setText("")
+            self.video_title.setText("")
+            self.video_track_title.setText("")
 
         # Set the frame rate
         if self.app.fastflix.current_video:
@@ -758,6 +1303,8 @@ def new_source(self):
         if video_speed := advanced_options.video_speed:
             self.video_speed_widget.setCurrentText(get_key(video_speeds, video_speed))
 
+        self.reverse_video_widget.setChecked(advanced_options.reverse_video)
+
         if deblock := advanced_options.deblock:
             self.deblock_widget.setCurrentText(deblock)
 
@@ -779,6 +1326,28 @@ def new_source(self):
         if contrast := advanced_options.contrast:
             self.contrast_widget.setText(contrast)
 
+        if gamma := advanced_options.gamma:
+            self.gamma_widget.setText(gamma)
+
+        if hue := advanced_options.hue:
+            self.hue_widget.setText(hue)
+
+        if sharpen := advanced_options.sharpen:
+            self.sharpen_widget.setText(sharpen)
+
+        if advanced_options.gop_length is not None:
+            self.gop_length_widget.setText(str(advanced_options.gop_length))
+
+        self.faststart_widget.setChecked(advanced_options.faststart)
+
+        # A profile default must never clear auto-detected interlacing
+        self.main.widgets.deinterlace.setChecked(
+            bool(
+                advanced_options.deinterlace
+                or self.app.fastflix.current_video.interlaced not in (False, "False", "", None)
+            )
+        )
+
         if maxrate := advanced_options.maxrate:
             self.maxrate_widget.setText(str(maxrate))
 
@@ -797,7 +1366,12 @@ def new_source(self):
         else:
             self.outgoing_same_as_source.setChecked(True)
 
-        if denoise_type_index := advanced_options.denoise_type_index:
+        denoise_type_index = advanced_options.denoise_type_index
+        if denoise_type_index is not None:
             self.denoise_type_widget.setCurrentIndex(denoise_type_index)
-        if denoise_strength_index := advanced_options.denoise_strength_index:
+        denoise_strength_index = advanced_options.denoise_strength_index
+        if denoise_strength_index is not None:
             self.denoise_strength_widget.setCurrentIndex(denoise_strength_index)
+
+        self.deinterlace_method_widget.setCurrentIndex(advanced_options.deinterlace_method_index)
+        self.deinterlace_mode_widget.setCurrentIndex(advanced_options.deinterlace_mode_index)
diff --git a/fastflix/widgets/panels/audio_panel.py b/fastflix/widgets/panels/audio_panel.py
index e867c487..754de782 100644
--- a/fastflix/widgets/panels/audio_panel.py
+++ b/fastflix/widgets/panels/audio_panel.py
@@ -19,6 +19,7 @@
 from fastflix.widgets.panels.abstract_list import FlixList
 from fastflix.audio_processing import apply_audio_filters
 from fastflix.widgets.windows.audio_conversion import AudioConversion
+from fastflix.widgets.toggle_switch import ToggleSwitch
 from fastflix.widgets.windows.disposition import Disposition
 
 language_list = [v.name for v in iter_langs() if v.pt2b and v.pt1] + ["Undefined"]
@@ -52,6 +53,7 @@
     "vorbis": "Vorbis",
     "libvorbis": "Vorbis",
     "mp3": "MP3",
+    "libfdk_aac": "FDK AAC",
     "libmp3lame": "MP3",
     "pcm_s16le": "PCM",
     "pcm_s24le": "PCM",
@@ -93,6 +95,16 @@ def generate_audio_title(codec: str, channels: int, downmix: str | None = None)
 ]
 
 
+def reindex_after_delete(tracks, deleted_index: int) -> None:
+    """Shift widget indexes that pointed past a deleted audio_tracks entry."""
+    for track in tracks:
+        if track.index > deleted_index:
+            track.index -= 1
+            disposition = getattr(track, "disposition_widget", None)
+            if disposition is not None and hasattr(disposition, "track_index"):
+                disposition.track_index = track.index
+
+
 class Audio(QtWidgets.QTabWidget):
     def __init__(
         self,
@@ -118,7 +130,7 @@ def __init__(
             audio_info=QtWidgets.QLabel(audio_track.friendly_info),
             up_button=QtWidgets.QPushButton(QtGui.QIcon(get_icon("up-arrow", self.app.fastflix.config.theme)), ""),
             down_button=QtWidgets.QPushButton(QtGui.QIcon(get_icon("down-arrow", self.app.fastflix.config.theme)), ""),
-            enable_check=QtWidgets.QCheckBox(t("Enabled")),
+            enable_check=ToggleSwitch(t("Enabled")),
             dup_button=QtWidgets.QPushButton(QtGui.QIcon(get_icon("onyx-copy", self.app.fastflix.config.theme)), ""),
             delete_button=QtWidgets.QPushButton(QtGui.QIcon(get_icon("black-x", self.app.fastflix.config.theme)), ""),
             language=QtWidgets.QComboBox(),
@@ -128,6 +140,15 @@ def __init__(
             conversion=QtWidgets.QPushButton(t("Conversion")),
         )
 
+        for button, label in (
+            (self.widgets.up_button, "Move Up"),
+            (self.widgets.down_button, "Move Down"),
+            (self.widgets.dup_button, "Duplicate"),
+            (self.widgets.delete_button, "Delete"),
+        ):
+            button.setToolTip(t(label))
+            button.setAccessibleName(t(label))
+
         self.widgets.up_button.setStyleSheet(no_border)
         self.widgets.down_button.setStyleSheet(no_border)
         self.widgets.dup_button.setStyleSheet(no_border)
@@ -148,7 +169,8 @@ def __init__(
 
         self.widgets.language.currentIndexChanged.connect(self.page_update)
         self.widgets.title.setFixedWidth(scaler.scale(WIDTHS.AUDIO_TITLE))
-        self.widgets.title.textChanged.connect(self.page_update)
+        self.widgets.title.textChanged.connect(self.sync_title)
+        self.widgets.title.editingFinished.connect(self.page_update)
         # self.widgets.audio_info.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
         self.widgets.audio_info.setFixedWidth(scaler.scale(WIDTHS.AUDIO_INFO))
 
@@ -255,6 +277,12 @@ def update_enable(self):
         self.parent.reorder(update=True)
         # self.parent.parent.subtitles.reorder()
 
+    def sync_title(self):
+        """Keep the model's title current while typing; the full command rebuild waits for editingFinished."""
+        audio_tracks = self.app.fastflix.current_video.audio_tracks
+        if 0 <= self.index < len(audio_tracks):
+            audio_tracks[self.index].title = self.title
+
     def page_update(self):
         self.app.fastflix.current_video.audio_tracks[self.index].title = self.title
         self.app.fastflix.current_video.audio_tracks[self.index].language = self.language
@@ -310,8 +338,9 @@ def dup_me(self):
         self.parent.reorder()
 
     def del_me(self):
-        self.parent.remove_track(self)
         del self.app.fastflix.current_video.audio_tracks[self.index]
+        reindex_after_delete([x for x in self.parent.tracks if x is not self], self.index)
+        self.parent.remove_track(self)
         self.parent.reorder(update=True)
 
     def set_outdex(self, outdex):
@@ -324,13 +353,16 @@ def set_outdex(self, outdex):
             self.widgets.track_number.setText(f"{audio_track.index}:{audio_track.outdex}")
 
     def close(self) -> bool:
-        del self.widgets
+        if hasattr(self, "widgets"):
+            del self.widgets
         return super().close()
 
-    def update_track(self, conversion=None, bitrate=None, downmix=None, title=None):
+    def update_track(self, conversion=None, bitrate=None, downmix=None, title=None, conversion_profile=None):
         audio_track: AudioTrack = self.app.fastflix.current_video.audio_tracks[self.index]
         if conversion:
             audio_track.conversion_codec = conversion
+        if conversion_profile:
+            audio_track.conversion_profile = conversion_profile
         if bitrate:
             audio_track.conversion_bitrate = bitrate
         if downmix:
@@ -344,7 +376,10 @@ def check_conversion_button(self):
         audio_track: AudioTrack = self.app.fastflix.current_video.audio_tracks[self.index]
         if audio_track.conversion_codec:
             self.widgets.conversion.setStyleSheet(get_onyx_disposition_style(enabled=True))
-            self.widgets.conversion.setText(t("Conversion") + f": {audio_track.conversion_codec}")
+            profile_display = {"aac_he": " (HE-AAC)", "aac_he_v2": " (HE-AAC v2)"}.get(
+                audio_track.conversion_profile, ""
+            )
+            self.widgets.conversion.setText(t("Conversion") + f": {audio_track.conversion_codec}{profile_display}")
         else:
             self.widgets.conversion.setStyleSheet(get_onyx_disposition_style(enabled=False))
             self.widgets.conversion.setText(t("Conversion"))
@@ -476,6 +511,7 @@ def gen_track(
             enabled=True,
             downmix=None,
             conversion=None,
+            conversion_profile=None,
             bitrate=None,
             title_mode=None,
             custom_title=None,
@@ -510,6 +546,7 @@ def gen_track(
                     friendly_info=track_info,
                     downmix=downmix,
                     conversion_codec=conversion,
+                    conversion_profile=conversion_profile,
                     conversion_bitrate=bitrate,
                     dispositions={k: bool(v) for k, v in audio_track.disposition.items()},
                 )
@@ -577,6 +614,7 @@ def gen_track(
                     self.tracks[track_pos].update_track(
                         downmix=track[1].downmix,
                         conversion=track[1].conversion,
+                        conversion_profile=track[1].conversion_profile,
                         bitrate=track[1].bitrate,
                         title=title,
                     )
@@ -594,6 +632,7 @@ def gen_track(
                             enabled=True,
                             og=False,
                             conversion=track[1].conversion,
+                            conversion_profile=track[1].conversion_profile,
                             bitrate=track[1].bitrate,
                             downmix=track[1].downmix,
                             title_mode=track[1].title_mode,
diff --git a/fastflix/widgets/panels/cover_panel.py b/fastflix/widgets/panels/cover_panel.py
index 986c5d77..e3bb4065 100644
--- a/fastflix/widgets/panels/cover_panel.py
+++ b/fastflix/widgets/panels/cover_panel.py
@@ -12,6 +12,7 @@
 from fastflix.models.encode import AttachmentTrack
 from fastflix.models.fastflix_app import FastFlixApp
 from fastflix.shared import link
+from fastflix.widgets.toggle_switch import ToggleSwitch
 
 logger = logging.getLogger("fastflix")
 
@@ -43,15 +44,15 @@ def __init__(self, parent, app: FastFlixApp):
         layout.addWidget(info_label, 10, 0, 1, 9, QtCore.Qt.AlignLeft)
 
         poster_options_layout = QtWidgets.QHBoxLayout()
-        self.cover_passthrough_checkbox = QtWidgets.QCheckBox(t("Copy Cover"))
-        self.small_cover_passthrough_checkbox = QtWidgets.QCheckBox(t("Copy Small Cover (no preview)"))
+        self.cover_passthrough_checkbox = ToggleSwitch(t("Copy Cover"))
+        self.small_cover_passthrough_checkbox = ToggleSwitch(t("Copy Small Cover (no preview)"))
 
         poster_options_layout.addWidget(self.cover_passthrough_checkbox)
         poster_options_layout.addWidget(self.small_cover_passthrough_checkbox)
 
         land_options_layout = QtWidgets.QHBoxLayout()
-        self.cover_land_passthrough_checkbox = QtWidgets.QCheckBox(t("Copy Landscape Cover"))
-        self.small_cover_land_passthrough_checkbox = QtWidgets.QCheckBox(t("Copy Small Landscape Cover  (no preview)"))
+        self.cover_land_passthrough_checkbox = ToggleSwitch(t("Copy Landscape Cover"))
+        self.small_cover_land_passthrough_checkbox = ToggleSwitch(t("Copy Small Landscape Cover  (no preview)"))
 
         land_options_layout.addWidget(self.cover_land_passthrough_checkbox)
         land_options_layout.addWidget(self.small_cover_land_passthrough_checkbox)
@@ -231,6 +232,12 @@ def update_cover_settings(self):
                 subtitle_track.outdex = start_outdex
                 start_outdex += 1
 
+        # Data/attachment tracks use -map and occupy output stream slots
+        # before -attach streams (FFmpeg places -map before -attach in output)
+        for data_track in getattr(self.app.fastflix.current_video, "data_tracks", []) or []:
+            if data_track.enabled:
+                start_outdex += 1
+
         attachments: list[AttachmentTrack] = []
 
         for filename in ("cover", "cover_land", "small_cover", "small_cover_land"):
diff --git a/fastflix/widgets/panels/data_panel.py b/fastflix/widgets/panels/data_panel.py
index 16878595..35316f78 100644
--- a/fastflix/widgets/panels/data_panel.py
+++ b/fastflix/widgets/panels/data_panel.py
@@ -12,14 +12,15 @@
 from fastflix.shared import no_border, shrink_text_to_fit
 from fastflix.ui_scale import scaler
 from fastflix.widgets.panels.abstract_list import FlixList
+from fastflix.widgets.toggle_switch import ToggleSwitch
 
 logger = logging.getLogger("fastflix")
 
 COVER_NAMES = {"cover", "small_cover", "cover_land", "small_cover_land"}
 
 # Container support for data/attachment streams
-# MKV supports everything; MP4/M4V support timecodes but not font attachments
-NO_DATA_EXTENSIONS = {".gif", ".webm", ".webp", ".avif"}
+# MKV does not support data streams (attachments like fonts are fine)
+NO_DATA_EXTENSIONS = {".gif", ".webm", ".webp", ".avif", ".mkv", ".mka"}
 NO_ATTACHMENT_EXTENSIONS = {".gif", ".webm", ".webp", ".avif", ".mp4", ".m4v", ".mov", ".ts", ".mts", ".m2ts"}
 
 
@@ -43,21 +44,28 @@ def __init__(self, app, parent, index, enabled=True, first=False):
         else:
             type_badge = t("Data")
 
+        self.incompatible = False
+        # User's selection prior to being auto-disabled for container incompatibility
+        self._enabled_before_incompatible = enabled
+
         self.widgets = Box(
             track_number=QtWidgets.QLabel(f"{track.index}:{track.outdex}" if enabled else "❌"),
             info_label=QtWidgets.QLabel(f"  {track.friendly_info}"),
             type_badge=QtWidgets.QLabel(type_badge),
+            warning_label=QtWidgets.QLabel(""),
             up_button=QtWidgets.QPushButton(
                 QtGui.QIcon(get_icon("up-arrow", self.parent.app.fastflix.config.theme)), ""
             ),
             down_button=QtWidgets.QPushButton(
                 QtGui.QIcon(get_icon("down-arrow", self.parent.app.fastflix.config.theme)), ""
             ),
-            enable_check=QtWidgets.QCheckBox(t("Preserve")),
+            enable_check=ToggleSwitch(t("Preserve")),
         )
 
         self.widgets.up_button.setStyleSheet(no_border)
         self.widgets.down_button.setStyleSheet(no_border)
+        self.widgets.warning_label.setStyleSheet("color: #cc6600; font-size: 11px;")
+        self.widgets.warning_label.hide()
 
         self.widgets.enable_check.setChecked(enabled)
         self.widgets.enable_check.toggled.connect(self.update_enable)
@@ -81,32 +89,72 @@ def __init__(self, app, parent, index, enabled=True, first=False):
         self.grid.setColumnStretch(2, True)
         self.grid.addWidget(self.widgets.type_badge, 0, 3)
         self.grid.addWidget(self.widgets.enable_check, 0, 4)
+        self.grid.addWidget(self.widgets.warning_label, 1, 1, 1, 4)
 
         self.setLayout(self.grid)
         self.loading = False
 
-    def _check_compatibility(self, track: DataTrack):
-        output_path = self.app.fastflix.current_video.video_settings.output_path
-        if not output_path:
-            return
-        ext = str(output_path).rsplit(".", 1)[-1].lower() if "." in str(output_path) else ""
-        ext_with_dot = f".{ext}"
+    def _check_compatibility(self, track: DataTrack = None):
+        if track is None:
+            track = self.app.fastflix.current_video.data_tracks[self.index]
+
+        # Use resolve_output_extension() which handles "Source" → actual extension
+        try:
+            ext_with_dot = self.parent.main.resolve_output_extension()
+        except (AttributeError, RuntimeError):
+            ext_with_dot = ""
+
+        if not ext_with_dot:
+            output_path = self.app.fastflix.current_video.video_settings.output_path
+            if not output_path:
+                return
+            ext = str(output_path).rsplit(".", 1)[-1].lower() if "." in str(output_path) else ""
+            ext_with_dot = f".{ext}"
 
         incompatible = False
         reason = ""
 
-        if track.codec_type == "data" and ext_with_dot in NO_DATA_EXTENSIONS:
+        # Check if current encoder is a rigaya hardware encoder (NVEncC, QSVEncC, VCEEncC)
+        is_rigaya = False
+        try:
+            encoder_name = self.app.fastflix.current_video.video_settings.video_encoder_settings.name
+            is_rigaya = "encc" in encoder_name.lower()
+        except (AttributeError, RuntimeError):
+            pass
+
+        if is_rigaya and ext_with_dot not in {".mkv", ".mka"}:
+            incompatible = True
+            reason = t("Data and attachment streams are not supported by hardware encoders for this output format")
+        elif track.codec_type == "data" and ext_with_dot in NO_DATA_EXTENSIONS:
             incompatible = True
             reason = t("Data streams are not supported in this output format")
         elif track.codec_type == "attachment" and ext_with_dot in NO_ATTACHMENT_EXTENSIONS:
             incompatible = True
             reason = t("Attachment streams are not supported in this output format")
 
-        if incompatible:
+        if incompatible and not self.incompatible:
+            # Became incompatible — disable and dim
+            self.incompatible = True
+            self._enabled_before_incompatible = bool(track.enabled)
             self.widgets.enable_check.setChecked(False)
             self.widgets.enable_check.setEnabled(False)
             self.widgets.enable_check.setToolTip(reason)
+            self.widgets.warning_label.setText(f"⚠ {reason}")
+            self.widgets.warning_label.show()
+            self.setStyleSheet("QTabWidget#DataTrack { background-color: rgba(0, 0, 0, 30); }")
             track.enabled = False
+        elif not incompatible and self.incompatible:
+            # Was incompatible but now compatible — re-enable
+            self.incompatible = False
+            self.widgets.enable_check.setEnabled(True)
+            self.widgets.enable_check.setToolTip("")
+            self.widgets.warning_label.hide()
+            self.setStyleSheet("")
+            # Restore what the user had selected before the auto-disable
+            restore = self._enabled_before_incompatible
+            self.widgets.enable_check.setChecked(restore)
+            track.enabled = restore
+            self.widgets.track_number.setText(f"{track.index}:{track.outdex}" if restore else "❌")
 
     def init_move_buttons(self):
         layout = QtWidgets.QVBoxLayout()
@@ -300,6 +348,12 @@ def apply_profile_settings(self, profile):
         else:
             self.select_all(True)
 
+    def refresh(self):
+        """Recheck compatibility for all tracks when output format may have changed."""
+        for track_widget in self.tracks:
+            track_widget._check_compatibility()
+        super().refresh()
+
     def get_settings(self):
         # Widget state is already written to data_tracks via set_outdex / update_enable
         pass
diff --git a/fastflix/widgets/panels/info_panel.py b/fastflix/widgets/panels/info_panel.py
index ee873673..bad81d8e 100644
--- a/fastflix/widgets/panels/info_panel.py
+++ b/fastflix/widgets/panels/info_panel.py
@@ -1,15 +1,275 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+import html
+import json
 import logging
+from pathlib import Path
 
 from box import Box
-from PySide6 import QtWidgets
+from PySide6 import QtCore, QtGui, QtWidgets
 
+from fastflix.language import t
 from fastflix.models.fastflix_app import FastFlixApp
+from fastflix.resources import get_icon
+from fastflix.shared import error_message
+from fastflix.ui_scale import scaler
+from fastflix.ui_styles import ONYX_COLORS
 
 logger = logging.getLogger("fastflix")
 
+COLUMNS_PER_ROW = 3
+
+VIDEO_SECTIONS = [
+    (
+        "General",
+        [
+            ("index", "Index"),
+            ("codec_name", "Codec"),
+            ("codec_long_name", "Codec Full Name"),
+            ("profile", "Profile"),
+            ("level", "Level"),
+            ("width", "Resolution"),
+            ("r_frame_rate", "Frame Rate"),
+            ("avg_frame_rate", "Avg Frame Rate"),
+            ("duration", "Duration"),
+            ("bit_rate", "Bit Rate"),
+            ("nb_frames", "Frames"),
+        ],
+    ),
+    (
+        "Pixel Format",
+        [
+            ("pix_fmt", "Format"),
+            ("bit_depth", "Bit Depth"),
+            ("bits_per_raw_sample", "Bits/Raw Sample"),
+            ("has_b_frames", "B-Frames"),
+            ("field_order", "Field Order"),
+            ("chroma_location", "Chroma"),
+            ("sample_aspect_ratio", "Sample AR"),
+            ("display_aspect_ratio", "Display AR"),
+        ],
+    ),
+    (
+        "Color",
+        [
+            ("color_range", "Range"),
+            ("color_space", "Space"),
+            ("color_transfer", "Transfer"),
+            ("color_primaries", "Primaries"),
+        ],
+    ),
+]
+
+AUDIO_SECTIONS = [
+    (
+        "General",
+        [
+            ("index", "Index"),
+            ("codec_name", "Codec"),
+            ("codec_long_name", "Codec Full Name"),
+            ("profile", "Profile"),
+            ("sample_rate", "Sample Rate"),
+            ("channels", "Channels"),
+            ("channel_layout", "Layout"),
+            ("sample_fmt", "Sample Fmt"),
+            ("bit_rate", "Bit Rate"),
+            ("duration", "Duration"),
+            ("nb_frames", "Frames"),
+            ("bits_per_sample", "Bits/Sample"),
+        ],
+    ),
+]
+
+SUBTITLE_SECTIONS = [
+    (
+        "General",
+        [
+            ("index", "Index"),
+            ("codec_name", "Codec"),
+            ("codec_long_name", "Codec Full Name"),
+            ("duration", "Duration"),
+        ],
+    ),
+]
+
+DEFAULT_SECTIONS = [
+    (
+        "General",
+        [
+            ("index", "Index"),
+            ("codec_name", "Codec"),
+            ("codec_long_name", "Codec Full Name"),
+            ("codec_type", "Type"),
+        ],
+    ),
+]
+
+SECTION_MAP = {
+    "video": VIDEO_SECTIONS,
+    "audio": AUDIO_SECTIONS,
+    "subtitle": SUBTITLE_SECTIONS,
+}
+
+SPECIAL_KEYS = {"tags", "disposition", "side_data_list", "codec_type"}
+
+
+def format_value(key, value, stream):
+    if value is None or value == "":
+        return ""
+    if key == "bit_rate":
+        try:
+            bps = int(value)
+            if bps >= 1_000_000:
+                return f"{bps / 1_000_000:.2f} Mbps"
+            return f"{bps / 1_000:.0f} kbps"
+        except (ValueError, TypeError):
+            return str(value)
+    if key == "sample_rate":
+        try:
+            return f"{int(value) / 1_000:.1f} kHz"
+        except (ValueError, TypeError):
+            return str(value)
+    if key in ("r_frame_rate", "avg_frame_rate"):
+        try:
+            if "/" in str(value):
+                num, den = str(value).split("/")
+                num, den = int(num), int(den)
+                if den == 0:
+                    return str(value)
+                return f"{num / den:.3f} fps"
+            return f"{float(value):.3f} fps"
+        except (ValueError, TypeError, ZeroDivisionError):
+            return str(value)
+    if key == "duration":
+        try:
+            secs = float(value)
+            minutes, secs = divmod(secs, 60)
+            hours, minutes = divmod(int(minutes), 60)
+            if hours:
+                return f"{hours}:{minutes:02d}:{secs:06.3f}"
+            return f"{int(minutes):02d}:{secs:06.3f}"
+        except (ValueError, TypeError):
+            return str(value)
+    if key == "width":
+        height = stream.get("height", "")
+        return f"{value}x{height}" if height else str(value)
+    if key == "channels":
+        layout = stream.get("channel_layout", "")
+        return f"{value} ({layout})" if layout else str(value)
+    return str(value)
+
+
+def build_section_group(title, fields, is_onyx):
+    group = QtWidgets.QGroupBox(t(title))
+    if is_onyx:
+        group.setStyleSheet(
+            f"QGroupBox {{ color: {ONYX_COLORS['text']}; border: 1px solid #666; border-radius: 4px; "
+            f"margin-top: 8px; padding-top: 4px; }} "
+            f"QGroupBox::title {{ subcontrol-origin: margin; left: 8px; padding: 0 4px; }}"
+        )
+    grid = QtWidgets.QGridLayout()
+    grid.setContentsMargins(8, 2, 8, 4)
+    grid.setHorizontalSpacing(6)
+    grid.setVerticalSpacing(2)
+    row = 0
+    col = 0
+    for label_text, value_text in fields:
+        key_label = QtWidgets.QLabel(f"<b>{html.escape(str(label_text))}:</b>")
+        key_label.setTextFormat(QtCore.Qt.TextFormat.RichText)
+        val_label = QtWidgets.QLabel(str(value_text))
+        val_label.setTextFormat(QtCore.Qt.TextFormat.PlainText)
+        val_label.setTextInteractionFlags(QtCore.Qt.TextInteractionFlag.TextSelectableByMouse)
+        grid.addWidget(key_label, row, col * 2)
+        grid.addWidget(val_label, row, col * 2 + 1)
+        col += 1
+        if col >= COLUMNS_PER_ROW:
+            col = 0
+            row += 1
+    # Spread columns evenly across full width
+    for c in range(COLUMNS_PER_ROW):
+        grid.setColumnStretch(c * 2 + 1, 1)
+    group.setLayout(grid)
+    return group
+
+
+def build_stream_widget(stream, parent, theme):
+    codec_type = stream.get("codec_type", "")
+    sections = SECTION_MAP.get(codec_type, DEFAULT_SECTIONS)
+    is_onyx = theme.lower() in ("dark", "onyx")
+
+    shown_keys = set(SPECIAL_KEYS)
+    if codec_type == "video":
+        shown_keys.add("height")
+    if codec_type == "audio":
+        shown_keys.add("channel_layout")
+
+    scroll = QtWidgets.QScrollArea(parent)
+    scroll.setWidgetResizable(True)
+    scroll.setFrameShape(QtWidgets.QFrame.Shape.NoFrame)
+
+    container = QtWidgets.QWidget()
+    layout = QtWidgets.QVBoxLayout()
+    layout.setContentsMargins(4, 4, 4, 4)
+    layout.setSpacing(4)
+
+    # Defined sections
+    for section_name, field_defs in sections:
+        fields = []
+        for key, label in field_defs:
+            shown_keys.add(key)
+            value = stream.get(key)
+            if value is None or str(value) == "":
+                continue
+            fields.append((t(label), format_value(key, value, stream)))
+        if fields:
+            layout.addWidget(build_section_group(section_name, fields, is_onyx))
+
+    # Tags
+    tags = stream.get("tags", {})
+    if tags:
+        fields = [(k.replace("_", " ").title(), str(v)) for k, v in tags.items()]
+        layout.addWidget(build_section_group("Tags", fields, is_onyx))
+
+    # Disposition - only truthy values
+    disposition = stream.get("disposition", {})
+    active = [(k.replace("_", " ").title(), t("Yes")) for k, v in disposition.items() if v]
+    if active:
+        layout.addWidget(build_section_group("Disposition", active, is_onyx))
+
+    # Side Data / HDR
+    side_data = stream.get("side_data_list", [])
+    if side_data:
+        for entry in side_data:
+            if not isinstance(entry, dict):
+                continue
+            side_type = entry.get("side_data_type", t("Unknown"))
+            fields = [(k.replace("_", " ").title(), str(v)) for k, v in entry.items() if k != "side_data_type"]
+            if fields:
+                layout.addWidget(build_section_group(side_type, fields, is_onyx))
+
+    # Other - remaining keys
+    other_fields = []
+    for key in stream.keys():
+        if key in shown_keys:
+            continue
+        value = stream.get(key)
+        if value is None or str(value) == "" or isinstance(value, (dict, list)):
+            continue
+        other_fields.append((key.replace("_", " ").title(), format_value(key, value, stream)))
+    if other_fields:
+        layout.addWidget(build_section_group("Other", other_fields, is_onyx))
+
+    layout.addStretch()
+    container.setLayout(layout)
+
+    # Calculate the natural content size so the scroll area never squishes it
+    content_size = layout.sizeHint()
+    container.setMinimumSize(content_size)
+
+    scroll.setWidget(container)
+    return scroll
+
 
 class InfoPanel(QtWidgets.QTabWidget):
     def __init__(self, parent, app: FastFlixApp):
@@ -18,9 +278,39 @@ def __init__(self, parent, app: FastFlixApp):
         self.main = parent.main
         self.attachments = Box()
 
+        save_icon = QtGui.QIcon(get_icon("onyx-save", self.app.fastflix.config.theme))
+
+        # Expand the tab bar via stylesheet so corner widget buttons fit without clipping
+        self.tabBar().setStyleSheet(f"QTabBar::tab {{ min-height: {scaler.scale(28)}px; }}")
+
+        corner_widget = QtWidgets.QWidget()
+        corner_layout = QtWidgets.QHBoxLayout()
+        corner_layout.setContentsMargins(0, 0, 0, 0)
+        corner_layout.setSpacing(4)
+
+        self.hdr10_button = QtWidgets.QPushButton(save_icon, t("Download HDR10"))
+        self.hdr10_button.setToolTip(t("Download HDR10"))
+        self.hdr10_button.clicked.connect(self.save_hdr10)
+        self.hdr10_button.hide()
+        corner_layout.addWidget(self.hdr10_button)
+
+        self.download_button = QtWidgets.QPushButton(save_icon, t("Download JSON"))
+        self.download_button.setToolTip(t("Download JSON"))
+        self.download_button.clicked.connect(self.save_json)
+        corner_layout.addWidget(self.download_button)
+
+        corner_widget.setLayout(corner_layout)
+        self.setCornerWidget(corner_widget, QtCore.Qt.Corner.TopRightCorner)
+
     def reset(self):
         for i in range(self.count() - 1, -1, -1):
+            old_widget = self.widget(i)
             self.removeTab(i)
+            if old_widget is not None:
+                old_widget.deleteLater()
+
+        self.setMinimumHeight(0)
+        self.hdr10_button.hide()
 
         if not self.app.fastflix.current_video:
             return
@@ -29,9 +319,74 @@ def reset(self):
         for x in self.app.fastflix.current_video.streams.values():
             all_stream.extend(x)
 
+        theme = self.app.fastflix.config.theme
+        max_content_height = 0
         for stream in sorted(all_stream, key=lambda z: z["index"]):
-            widget = QtWidgets.QTextBrowser(self)
-            widget.setReadOnly(True)
-            widget.setDisabled(False)
-            widget.setText(Box(stream).to_yaml(default_flow_style=False))
+            widget = build_stream_widget(stream, self, theme)
             self.addTab(widget, f"{stream['index']}: {stream['codec_type'].title()} ({stream.get('codec_name', '')})")
+            inner = widget.widget()
+            if inner:
+                max_content_height = max(max_content_height, inner.minimumSizeHint().height())
+
+        if max_content_height > 0:
+            tab_bar_height = self.tabBar().sizeHint().height()
+            self.setMinimumHeight(max_content_height + tab_bar_height + 16)
+
+        video = self.app.fastflix.current_video
+        if video and (video.master_display or video.cll):
+            self.hdr10_button.show()
+
+    def save_hdr10(self):
+        video = self.app.fastflix.current_video
+        if not video:
+            return
+
+        lines = []
+        if video.master_display:
+            md = video.master_display
+            lines.append(f"master-display=G{md.green}B{md.blue}R{md.red}WP{md.white}L{md.luminance}")
+        if video.cll:
+            lines.append(f"max-cll={video.cll}")
+
+        if not lines:
+            return
+
+        source_name = video.source.stem
+        filename = QtWidgets.QFileDialog.getSaveFileName(
+            self,
+            caption=t("Download HDR10"),
+            dir=str(Path("~").expanduser() / f"{source_name}_hdr10.txt"),
+            filter=f"{t('Text Files')} (*.txt)",
+        )
+        if filename and filename[0]:
+            try:
+                Path(filename[0]).write_text("\n".join(lines) + "\n", encoding="utf-8")
+            except Exception:
+                logger.exception("Failed to save HDR10 metadata")
+                error_message(f"{t('Could not save file')}: {filename[0]}", traceback=True, parent=self)
+
+    def save_json(self):
+        if not self.app.fastflix.current_video:
+            return
+
+        all_streams = []
+        for x in self.app.fastflix.current_video.streams.values():
+            all_streams.extend(x)
+        all_streams.sort(key=lambda z: z["index"])
+
+        data = {"streams": [Box(s).to_dict() for s in all_streams]}
+        if self.app.fastflix.current_video.format:
+            data["format"] = Box(self.app.fastflix.current_video.format).to_dict()
+
+        source_name = self.app.fastflix.current_video.source.stem
+        filename = QtWidgets.QFileDialog.getSaveFileName(
+            self,
+            caption=t("Download JSON"),
+            dir=str(Path("~").expanduser() / f"{source_name}_info.json"),
+            filter=f"{t('JSON Files')} (*.json)",
+        )
+        if filename and filename[0]:
+            try:
+                Path(filename[0]).write_text(json.dumps(data, indent=2, default=str), encoding="utf-8")
+            except Exception:
+                logger.exception("Failed to save JSON")
diff --git a/fastflix/widgets/panels/queue_panel.py b/fastflix/widgets/panels/queue_panel.py
index 2d7aadb7..3b95090a 100644
--- a/fastflix/widgets/panels/queue_panel.py
+++ b/fastflix/widgets/panels/queue_panel.py
@@ -24,6 +24,7 @@
 from fastflix.exceptions import FastFlixInternalException
 from fastflix.windows_tools import allow_sleep_mode, prevent_sleep_mode
 from fastflix.command_runner import BackgroundRunner
+from fastflix.widgets.toggle_switch import ToggleSwitch
 
 logger = logging.getLogger("fastflix")
 
@@ -46,6 +47,49 @@
 after_done_path = Path(user_data_dir("FastFlix", appauthor=False, roaming=True)) / "after_done_logs"
 
 
+class ElidedLabel(QtWidgets.QLabel):
+    """A QLabel that elides text with an ellipsis when it doesn't fit.
+
+    The label always reports a small minimum width and ignores the text width in its size policy, so the full
+    text never forces its row wider; the displayed text is re-elided on every resize.
+    """
+
+    MIN_WIDTH = 24
+
+    def __init__(self, text="", parent=None):
+        super().__init__(text, parent)
+        self._full_text = text
+        self.setSizePolicy(QtWidgets.QSizePolicy.Ignored, QtWidgets.QSizePolicy.Preferred)
+
+    def setText(self, text):
+        self._full_text = text
+        self.setToolTip(text)
+        self._apply_elision()
+        self.updateGeometry()
+
+    def fullText(self):
+        return self._full_text
+
+    def minimumSizeHint(self):
+        hint = super().minimumSizeHint()
+        return QtCore.QSize(self.MIN_WIDTH, hint.height())
+
+    def sizeHint(self):
+        metrics = QtGui.QFontMetrics(self.font())
+        return QtCore.QSize(metrics.horizontalAdvance(self._full_text), super().sizeHint().height())
+
+    def elided_text(self, width=None):
+        metrics = QtGui.QFontMetrics(self.font())
+        return metrics.elidedText(self._full_text, QtCore.Qt.ElideRight, self.width() if width is None else width)
+
+    def _apply_elision(self):
+        super().setText(self.elided_text())
+
+    def resizeEvent(self, event):
+        self._apply_elision()
+        super().resizeEvent(event)
+
+
 class EncodeItem(QtWidgets.QTabWidget):
     def __init__(self, parent, video: Video, index, first=False):
         self.loading = True
@@ -78,22 +122,13 @@ def __init__(self, parent, video: Video, index, first=False):
         for widget in self.widgets.values():
             widget.setStyleSheet(no_border)
 
-        title = QtWidgets.QLabel(
+        title_text = (
             video.video_settings.video_title
             if video.video_settings.video_title
             else video.video_settings.output_path.name
         )
-        title.setFixedWidth(300)
-
-        settings = Box(copy.deepcopy(video.video_settings.model_dump()))
-        # settings.output_path = str(settings.output_path)
-        # for i, o in enumerate(video.attachment_tracks):
-        #     if o.file_path:
-        #         o["file_path"] = str(o["file_path"])
-        # del settings.conversion_commands
-
-        title.setToolTip(settings.video_encoder_settings.to_yaml())
-        del settings
+        title = ElidedLabel(title_text)
+        title.setToolTip(f"{t('Source')}: {video.source}\n{t('Output')}: {video.video_settings.output_path}")
 
         open_button = QtWidgets.QPushButton(
             self.parent.app.style().standardIcon(QtWidgets.QStyle.StandardPixmap.SP_DirOpenIcon), t("Open Directory")
@@ -210,7 +245,8 @@ def close(self) -> bool:
             item.close()
             self.widgets[widget] = None
         del self.video
-        del self.widgets
+        if hasattr(self, "widgets"):
+            del self.widgets
         del self.parent
         gc.collect()
         return super().close()
@@ -268,7 +304,7 @@ def __init__(self, parent, app: FastFlixApp):
         self.pause_encode.setFixedWidth(130)
         self.pause_encode.setToolTip(t("Pause / Resume the current command"))
 
-        self.ignore_errors = QtWidgets.QCheckBox(t("Ignore Errors"))
+        self.ignore_errors = ToggleSwitch(t("Ignore Errors"))
         self.ignore_errors.setFixedWidth(150)
 
         self.after_done_combo = QtWidgets.QComboBox()
@@ -392,10 +428,6 @@ def manually_load_queue(self):
                 self.queue_startup_check(filename)
 
     def reorder(self, update=True):
-        if self.app.fastflix.currently_encoding:
-            # TODO error?
-            logger.warning("Reorder queue called while encoding")
-            return
         super().reorder(update=update)
         # TODO find better reorder method
         for i in range(len(self.tracks) - 1, -1, -1):
@@ -405,12 +437,22 @@ def reorder(self, update=True):
         for track in self.tracks:
             self.app.fastflix.conversion_list.append(track.video)
 
-        for track in self.tracks:
-            track.widgets.up_button.setDisabled(False)
-            track.widgets.down_button.setDisabled(False)
-        if self.tracks:
-            self.tracks[0].widgets.up_button.setDisabled(True)
-            self.tracks[-1].widgets.down_button.setDisabled(True)
+        encoding = self.app.fastflix.currently_encoding
+        if encoding:
+            for track in self.tracks:
+                track.widgets.up_button.setDisabled(True)
+                track.widgets.down_button.setDisabled(True)
+                track.widgets.reload_button.setDisabled(True)
+        else:
+            for track in self.tracks:
+                track.widgets.up_button.setDisabled(False)
+                track.widgets.down_button.setDisabled(False)
+                track.widgets.reload_button.setDisabled(False)
+            if self.tracks:
+                self.tracks[0].widgets.up_button.setDisabled(True)
+                self.tracks[-1].widgets.down_button.setDisabled(True)
+
+        self.load_queue_button.setDisabled(encoding)
         save_queue_async(self.app.fastflix.conversion_list, self.app.fastflix.queue_path, self.app.fastflix.config)
 
     def new_source(self):
@@ -441,8 +483,7 @@ def clear_complete(self):
         self.new_source()
 
     def remove_item(self, video, part_of_clear=False):
-        if self.app.fastflix.currently_encoding:
-            # TODO error
+        if video.status.running:
             return
 
         for i, vid in enumerate(self.app.fastflix.conversion_list):
@@ -459,6 +500,8 @@ def remove_item(self, video, part_of_clear=False):
             # Queue is saved by new_source() -> reorder() -> save_queue_async()
 
     def reload_from_queue(self, video):
+        if self.app.fastflix.currently_encoding:
+            return
         try:
             self.main.reload_video_from_queue(video)
         except FastFlixInternalException:
diff --git a/fastflix/widgets/panels/status_panel.py b/fastflix/widgets/panels/status_panel.py
index f1f9c71f..ece3fcb0 100644
--- a/fastflix/widgets/panels/status_panel.py
+++ b/fastflix/widgets/panels/status_panel.py
@@ -16,6 +16,7 @@
 from fastflix.models.encode import GifskiSettings
 from fastflix.models.video import Video
 from fastflix.shared import time_to_number, timedelta_to_str
+from fastflix.widgets.toggle_switch import ToggleSwitch
 
 logger = logging.getLogger("fastflix")
 
@@ -39,7 +40,7 @@ def __init__(self, parent, app: FastFlixApp):
 
         layout = QtWidgets.QGridLayout()
 
-        self.hide_nal = QtWidgets.QCheckBox(t("Hide NAL unit messages"))
+        self.hide_nal = ToggleSwitch(t("Hide NAL unit messages"))
         self.hide_nal.setChecked(True)
 
         self.eta_label = QtWidgets.QLabel(f"{t('Time Left')}: N/A")
diff --git a/fastflix/widgets/panels/subtitle_panel.py b/fastflix/widgets/panels/subtitle_panel.py
index 972fa0ae..db12ea48 100644
--- a/fastflix/widgets/panels/subtitle_panel.py
+++ b/fastflix/widgets/panels/subtitle_panel.py
@@ -18,6 +18,7 @@
 from fastflix.ui_styles import get_onyx_disposition_style
 from fastflix.widgets.background_tasks import ExtractSubtitleSRT
 from fastflix.widgets.panels.abstract_list import FlixList
+from fastflix.widgets.toggle_switch import ToggleSwitch
 from fastflix.widgets.windows.disposition import Disposition
 
 logger = logging.getLogger("fastflix")
@@ -79,10 +80,10 @@ def __init__(self, app, parent, index, enabled=True, first=False):
             down_button=QtWidgets.QPushButton(
                 QtGui.QIcon(get_icon("down-arrow", self.parent.app.fastflix.config.theme)), ""
             ),
-            enable_check=QtWidgets.QCheckBox(t("Preserve")),
+            enable_check=ToggleSwitch(t("Preserve")),
             disposition=QtWidgets.QPushButton(t("Dispositions")),
             language=QtWidgets.QComboBox(),
-            burn_in=QtWidgets.QCheckBox(t("Burn In")),
+            burn_in=ToggleSwitch(t("Burn In")),
         )
 
         self.widgets.up_button.setStyleSheet(no_border)
@@ -480,10 +481,10 @@ def __init__(self, app, parent, index, enabled=True, first=False):
             down_button=QtWidgets.QPushButton(
                 QtGui.QIcon(get_icon("down-arrow", self.parent.app.fastflix.config.theme)), ""
             ),
-            enable_check=QtWidgets.QCheckBox(t("Preserve")),
+            enable_check=ToggleSwitch(t("Preserve")),
             disposition=QtWidgets.QPushButton(t("Dispositions")),
             language=QtWidgets.QComboBox(),
-            burn_in=QtWidgets.QCheckBox(t("Burn In")),
+            burn_in=ToggleSwitch(t("Burn In")),
             remove_button=QtWidgets.QPushButton(t("Remove")),
         )
 
@@ -866,6 +867,28 @@ def apply_profile_settings(self):
             sub_track.enabled = enabled
             track.widgets.enable_check.setChecked(enabled)
 
+        # Apply disposition overrides from profile
+        default_mode = self.app.fastflix.config.opt("subtitle_default_disposition", None)
+        forced_mode = self.app.fastflix.config.opt("subtitle_forced_disposition", None)
+        if default_mode or forced_mode:
+            first_default_set = False
+            first_forced_set = False
+            for track in self.tracks:
+                sub_track = self.app.fastflix.current_video.subtitle_tracks[track.index]
+                if not sub_track.enabled:
+                    continue
+                if default_mode == "clear":
+                    sub_track.dispositions["default"] = False
+                elif default_mode == "first":
+                    sub_track.dispositions["default"] = not first_default_set
+                    first_default_set = True
+                if forced_mode == "clear":
+                    sub_track.dispositions["forced"] = False
+                elif forced_mode == "first":
+                    sub_track.dispositions["forced"] = not first_forced_set
+                    first_forced_set = True
+                track.check_dis_button()
+
         if self.app.fastflix.config.opt("subtitle_automatic_burn_in"):
             # Reset any existing burn-in
             for track in self.tracks:
diff --git a/fastflix/widgets/settings.py b/fastflix/widgets/settings.py
index 28393389..a29bc0a1 100644
--- a/fastflix/widgets/settings.py
+++ b/fastflix/widgets/settings.py
@@ -20,6 +20,7 @@
 )
 from fastflix.shared import error_message, link, yes_no_message
 from fastflix.widgets.flow_layout import FlowLayout
+from fastflix.widgets.toggle_switch import ToggleSwitch
 
 logger = logging.getLogger("fastflix")
 language_list = [v.name for v in iter_langs() if v.pt2b and v.pt1]
@@ -168,61 +169,66 @@ def _build_settings_tab(self):
         row += 1
 
         # Checkboxes
-        self.use_sane_audio = QtWidgets.QCheckBox(t("Use Sane Audio Selection (updatable in config file)"))
+        self.use_sane_audio = ToggleSwitch(t("Use Sane Audio Selection (updatable in config file)"))
         if self.app.fastflix.config.use_sane_audio:
             self.use_sane_audio.setChecked(True)
         layout.addWidget(self.use_sane_audio, row, 0, 1, 2)
         row += 1
 
-        self.disable_version_check = QtWidgets.QCheckBox(t("Disable update check on startup"))
+        self.disable_version_check = ToggleSwitch(t("Disable update check on startup"))
         if self.app.fastflix.config.disable_version_check:
             self.disable_version_check.setChecked(True)
         layout.addWidget(self.disable_version_check, row, 0, 1, 2)
         row += 1
 
-        self.show_complete_message = QtWidgets.QCheckBox(t("Show completion popup message"))
+        self.show_complete_message = ToggleSwitch(t("Show completion popup message"))
         self.show_complete_message.setChecked(self.app.fastflix.config.show_complete_message)
         layout.addWidget(self.show_complete_message, row, 0, 1, 2)
         row += 1
 
-        self.show_error_message = QtWidgets.QCheckBox(t("Show error popup message"))
+        self.show_error_message = ToggleSwitch(t("Show error popup message"))
         self.show_error_message.setChecked(self.app.fastflix.config.show_error_message)
         layout.addWidget(self.show_error_message, row, 0, 1, 2)
         row += 1
 
-        self.clean_old_logs_button = QtWidgets.QCheckBox(
+        self.keep_source_after_encode = ToggleSwitch(t("Keep source loaded after adding to queue"))
+        self.keep_source_after_encode.setChecked(self.app.fastflix.config.keep_source_after_encode)
+        layout.addWidget(self.keep_source_after_encode, row, 0, 1, 2)
+        row += 1
+
+        self.clean_old_logs_button = ToggleSwitch(
             t("Remove GUI logs and compress conversion logs older than 30 days at exit")
         )
         self.clean_old_logs_button.setChecked(self.app.fastflix.config.clean_old_logs)
         layout.addWidget(self.clean_old_logs_button, row, 0, 1, 3)
         row += 1
 
-        self.disable_deinterlace_button = QtWidgets.QCheckBox(t("Disable interlace check"))
+        self.disable_deinterlace_button = ToggleSwitch(t("Disable interlace check"))
         self.disable_deinterlace_button.setChecked(self.app.fastflix.config.disable_deinterlace_check)
         layout.addWidget(self.disable_deinterlace_button, row, 0, 1, 3)
         row += 1
 
-        self.suppress_ffmpeg_version_warning = QtWidgets.QCheckBox(t("Suppress FFmpeg version warning on startup"))
+        self.suppress_ffmpeg_version_warning = ToggleSwitch(t("Suppress FFmpeg version warning on startup"))
         self.suppress_ffmpeg_version_warning.setChecked(self.app.fastflix.config.suppress_ffmpeg_version_warning)
         layout.addWidget(self.suppress_ffmpeg_version_warning, row, 0, 1, 3)
         row += 1
 
-        self.use_keyframes_for_preview = QtWidgets.QCheckBox(t("Use keyframes for preview images"))
+        self.use_keyframes_for_preview = ToggleSwitch(t("Use keyframes for preview images"))
         self.use_keyframes_for_preview.setChecked(self.app.fastflix.config.use_keyframes_for_preview)
         layout.addWidget(self.use_keyframes_for_preview, row, 0, 1, 3)
         row += 1
 
-        self.sticky_tabs = QtWidgets.QCheckBox(t("Disable Automatic Tab Switching"))
+        self.sticky_tabs = ToggleSwitch(t("Disable Automatic Tab Switching"))
         self.sticky_tabs.setChecked(self.app.fastflix.config.sticky_tabs)
         layout.addWidget(self.sticky_tabs, row, 0, 1, 2)
         row += 1
 
-        self.auto_detect_subtitles = QtWidgets.QCheckBox(t("Auto-detect external subtitle files"))
+        self.auto_detect_subtitles = ToggleSwitch(t("Auto-detect external subtitle files"))
         self.auto_detect_subtitles.setChecked(self.app.fastflix.config.auto_detect_subtitles)
         layout.addWidget(self.auto_detect_subtitles, row, 0, 1, 3)
         row += 1
 
-        self.enable_history = QtWidgets.QCheckBox(t("Enable encoding history"))
+        self.enable_history = ToggleSwitch(t("Enable encoding history"))
         self.enable_history.setChecked(bool(self.app.fastflix.config.enable_history))
         layout.addWidget(self.enable_history, row, 0, 1, 3)
         row += 1
@@ -253,7 +259,7 @@ def _build_settings_tab(self):
         row += 1
 
         # Default Output Directory
-        self.default_output_dir = QtWidgets.QCheckBox(t("Use same output directory as source file"))
+        self.default_output_dir = ToggleSwitch(t("Use same output directory as source file"))
         layout.addWidget(self.default_output_dir, row, 0, 1, 2)
         row += 1
 
@@ -283,7 +289,7 @@ def out_click():
         self.default_output_dir.clicked.connect(out_click)
 
         # Default Source Directory
-        self.default_source_dir = QtWidgets.QCheckBox(t("No Default Source Folder"))
+        self.default_source_dir = ToggleSwitch(t("No Default Source Folder"))
         layout.addWidget(self.default_source_dir, row, 0, 1, 2)
         row += 1
 
@@ -504,7 +510,7 @@ def _build_audio_encoders_tab(self):
 
         self.audio_encoder_checkboxes = {}
         for encoder_name in all_encoders:
-            cb = QtWidgets.QCheckBox(encoder_name)
+            cb = ToggleSwitch(encoder_name)
             cb.setChecked(encoder_name in sane_set)
             self.audio_encoder_checkboxes[encoder_name] = cb
             scroll_layout.addWidget(cb)
@@ -778,6 +784,7 @@ def save(self):
         self.app.fastflix.config.sticky_tabs = self.sticky_tabs.isChecked()
         self.app.fastflix.config.show_complete_message = self.show_complete_message.isChecked()
         self.app.fastflix.config.show_error_message = self.show_error_message.isChecked()
+        self.app.fastflix.config.keep_source_after_encode = self.keep_source_after_encode.isChecked()
         self.app.fastflix.config.disable_deinterlace_check = self.disable_deinterlace_button.isChecked()
         self.app.fastflix.config.suppress_ffmpeg_version_warning = self.suppress_ffmpeg_version_warning.isChecked()
         self.app.fastflix.config.use_keyframes_for_preview = self.use_keyframes_for_preview.isChecked()
diff --git a/fastflix/widgets/toggle_switch.py b/fastflix/widgets/toggle_switch.py
new file mode 100644
index 00000000..fb77610e
--- /dev/null
+++ b/fastflix/widgets/toggle_switch.py
@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+"""A modern sliding toggle switch widget, drop-in replacement for QCheckBox."""
+
+from PySide6 import QtCore, QtGui, QtWidgets
+
+
+class ToggleSwitch(QtWidgets.QCheckBox):
+    """A sliding toggle switch that subclasses QCheckBox.
+
+    Drop-in replacement — emits the same stateChanged/toggled signals,
+    works with isChecked()/setChecked(), and supports a text label.
+    """
+
+    def __init__(self, text="", parent=None, track_color="#444444", active_color="#4a9eed", knob_color="#ffffff"):
+        super().__init__(text, parent)
+        self.track_color = QtGui.QColor(track_color)
+        self.active_color = QtGui.QColor(active_color)
+        self.knob_color = QtGui.QColor(knob_color)
+
+        self._track_width = 24
+        self._track_height = 12
+        self._knob_diameter = 8
+        self._knob_margin = 2
+        self._label_spacing = 8
+
+        self._knob_position = 0.0
+        self._animation = QtCore.QPropertyAnimation(self, b"knob_position", self)
+        self._animation.setDuration(150)
+        self._animation.setEasingCurve(QtCore.QEasingCurve.InOutCubic)
+
+        self.stateChanged.connect(self._animate)
+
+    def _get_knob_position(self):
+        return self._knob_position
+
+    def _set_knob_position(self, value):
+        self._knob_position = value
+        self.update()
+
+    knob_position = QtCore.Property(float, _get_knob_position, _set_knob_position)
+
+    def _animate(self):
+        self._animation.stop()
+        self._animation.setStartValue(self._knob_position)
+        self._animation.setEndValue(1.0 if self.isChecked() else 0.0)
+        self._animation.start()
+
+    def sizeHint(self):
+        text_width = 0
+        if self.text():
+            fm = QtGui.QFontMetrics(self.font())
+            text_width = fm.horizontalAdvance(self.text()) + self._label_spacing
+        return QtCore.QSize(
+            self._track_width + text_width + 4,
+            max(self._track_height + 4, fm.height() if self.text() else self._track_height + 4),
+        )
+
+    def minimumSizeHint(self):
+        return self.sizeHint()
+
+    def hitButton(self, pos):
+        return self.rect().contains(pos)
+
+    def paintEvent(self, event):
+        painter = QtGui.QPainter(self)
+        painter.setRenderHint(QtGui.QPainter.Antialiasing)
+        if not self.isEnabled():
+            painter.setOpacity(0.4)
+
+        # Calculate track position (vertically centered)
+        track_y = (self.height() - self._track_height) // 2
+        track_rect = QtCore.QRectF(0, track_y, self._track_width, self._track_height)
+        track_radius = self._track_height / 2
+
+        # Interpolate track color
+        ratio = self._knob_position
+        r = self.track_color.red() + (self.active_color.red() - self.track_color.red()) * ratio
+        g = self.track_color.green() + (self.active_color.green() - self.track_color.green()) * ratio
+        b = self.track_color.blue() + (self.active_color.blue() - self.track_color.blue()) * ratio
+        current_color = QtGui.QColor(int(r), int(g), int(b))
+
+        # Draw track
+        painter.setPen(QtCore.Qt.NoPen)
+        painter.setBrush(current_color)
+        painter.drawRoundedRect(track_rect, track_radius, track_radius)
+
+        # Draw knob
+        knob_travel = self._track_width - self._knob_diameter - 2 * self._knob_margin
+        knob_x = self._knob_margin + self._knob_position * knob_travel
+        knob_y = track_y + (self._track_height - self._knob_diameter) / 2
+        painter.setBrush(self.knob_color)
+        painter.drawEllipse(QtCore.QRectF(knob_x, knob_y, self._knob_diameter, self._knob_diameter))
+
+        # Draw label text
+        if self.text():
+            painter.setPen(self.palette().color(QtGui.QPalette.WindowText))
+            text_x = self._track_width + self._label_spacing
+            text_rect = QtCore.QRectF(text_x, 0, self.width() - text_x, self.height())
+            painter.drawText(text_rect, QtCore.Qt.AlignVCenter | QtCore.Qt.AlignLeft, self.text())
+
+        painter.end()
diff --git a/fastflix/widgets/windows/audio_conversion.py b/fastflix/widgets/windows/audio_conversion.py
index 93d0e8b2..d1baa797 100644
--- a/fastflix/widgets/windows/audio_conversion.py
+++ b/fastflix/widgets/windows/audio_conversion.py
@@ -108,6 +108,23 @@ def __init__(self, app: FastFlixApp, track_index, encoders, audio_track_update):
         conversion_layout.addWidget(QtWidgets.QLabel(t("Codec")))
         conversion_layout.addWidget(self.conversion_codec, 2)
 
+        # AAC Profile
+
+        self.aac_profile_label = QtWidgets.QLabel(t("AAC Profile"))
+        self.aac_profile = QtWidgets.QComboBox()
+        self.aac_profile.addItems(["AAC-LC", "HE-AAC", "HE-AAC v2"])
+
+        profile_map = {"aac_he": 1, "aac_he_v2": 2}
+        self.aac_profile.setCurrentIndex(profile_map.get(self.audio_track.conversion_profile, 0))
+
+        show_profile = self.conversion_codec.currentText() == "libfdk_aac"
+        self.aac_profile_label.setVisible(show_profile)
+        self.aac_profile.setVisible(show_profile)
+
+        aac_profile_layout = QtWidgets.QHBoxLayout()
+        aac_profile_layout.addWidget(self.aac_profile_label)
+        aac_profile_layout.addWidget(self.aac_profile, 2)
+
         # AQ vs Bitrate
 
         self.aq = QtWidgets.QComboBox()
@@ -191,6 +208,7 @@ def __init__(self, app: FastFlixApp, track_index, encoders, audio_track_update):
 
         layout = QtWidgets.QVBoxLayout()
         layout.addLayout(conversion_layout)
+        layout.addLayout(aac_profile_layout)
         layout.addLayout(quality_layout)
         layout.addLayout(downmix_layout)
         layout.addLayout(yes_no_layout)
@@ -205,13 +223,19 @@ def set_aq(self):
             self.bitrate.setDisabled(True)
 
     def codec_changed(self):
-        if self.conversion_codec.currentText() in ["libopus"]:
+        codec = self.conversion_codec.currentText()
+        if codec in ["libopus"]:
             self.aq.setCurrentIndex(10)
             self.aq.setDisabled(True)
-            # self.bitrate.setEnabled(True)
         else:
             self.aq.setEnabled(True)
-            # self.bitrate.setDisabled(True)
+
+        # HE-AAC profiles are only supported by libfdk_aac (the native FFmpeg/rigaya aac encoder rejects them)
+        show_profile = codec == "libfdk_aac"
+        self.aac_profile_label.setVisible(show_profile)
+        self.aac_profile.setVisible(show_profile)
+        if not show_profile:
+            self.aac_profile.setCurrentIndex(0)
 
     def save(self):
         if self.conversion_codec.currentIndex() != 0:
@@ -219,6 +243,10 @@ def save(self):
         else:
             self.audio_track.conversion_codec = ""
 
+        profile_values = {0: None, 1: "aac_he", 2: "aac_he_v2"}
+        profile = profile_values.get(self.aac_profile.currentIndex())
+        self.audio_track.conversion_profile = profile if self.audio_track.conversion_codec == "libfdk_aac" else None
+
         if self.aq.currentIndex() != 10:
             self.audio_track.conversion_aq = self.aq.currentIndex()
             self.audio_track.conversion_bitrate = None
diff --git a/fastflix/widgets/windows/concat.py b/fastflix/widgets/windows/concat.py
index a7e87c40..87c09374 100644
--- a/fastflix/widgets/windows/concat.py
+++ b/fastflix/widgets/windows/concat.py
@@ -4,11 +4,11 @@
 import logging
 import secrets
 
-from PySide6 import QtWidgets, QtGui
+from PySide6 import QtCore, QtWidgets, QtGui
 from PySide6.QtWidgets import QAbstractItemView
 
 from fastflix.language import t
-from fastflix.flix import probe
+from fastflix.flix import probe, clean_file_string
 from fastflix.shared import yes_no_message, error_message
 from fastflix.widgets.status_bar import Task
 
@@ -235,23 +235,20 @@ def __init__(self, app, main, items=None):
         super().__init__(None)
         self.app = app
         self.main = main
-        self.folder_name = str(self.app.fastflix.config.source_directory) or str(Path.home())
+        source_dir = self.app.fastflix.config.source_directory
+        videos_dir = Path.home() / "Videos"
+        self.folder_name = str(source_dir) if source_dir else str(videos_dir if videos_dir.exists() else Path.home())
         self.setWindowTitle(t("Concatenation Builder"))
+        self.setAcceptDrops(True)
 
         self.concat_area = ConcatScroll(self)
         self.base_folder_label = QtWidgets.QLabel()
+        self.base_folder_label.setTextFormat(QtCore.Qt.TextFormat.PlainText)
         self.set_folder_name(self.folder_name)
         layout = QtWidgets.QVBoxLayout()
         folder_button = QtWidgets.QPushButton(t("Open Folder"))
         folder_button.clicked.connect(self.select_folder)
 
-        # manual_layout = QtWidgets.QHBoxLayout()
-        # manual_text = QtWidgets.QLineEdit()
-        # manual_button = QtWidgets.QPushButton("+")
-        # manual_button.clicked.connect(lambda: self.concat_area.table.add_item(manual_text.text()))
-        # manual_layout.addWidget(manual_text)
-        # manual_layout.addWidget(manual_button)
-
         save_buttom = QtWidgets.QPushButton(t("Load"))
         save_buttom.clicked.connect(self.save)
 
@@ -265,13 +262,50 @@ def __init__(self, app, main, items=None):
         layout.addLayout(top_bar)
 
         layout.addWidget(self.concat_area)
-        layout.addWidget(QtWidgets.QLabel(t("Drag and Drop to reorder - All items need to be same dimensions")))
+        layout.addWidget(
+            QtWidgets.QLabel(
+                t("Drag and Drop to reorder, or drop a folder to load files - All items need to be same dimensions")
+            )
+        )
         self.setLayout(layout)
 
     def set_folder_name(self, name):
         self.base_folder_label.setText(f"{t('Base Folder')}: {name}")
 
+    def dragEnterEvent(self, event):
+        if event.mimeData().hasUrls():
+            event.accept()
+        else:
+            event.ignore()
+
+    def dragMoveEvent(self, event):
+        if event.mimeData().hasUrls():
+            event.accept()
+        else:
+            event.ignore()
+
+    def dropEvent(self, event):
+        if not event.mimeData().hasUrls():
+            return event.ignore()
+
+        event.setDropAction(QtCore.Qt.CopyAction)
+        event.accept()
+
+        location = Path(clean_file_string(event.mimeData().urls()[0].toLocalFile()))
+        if not location.is_dir():
+            return
+
+        # Defer heavy folder loading so dropEvent returns immediately,
+        # releasing the Windows drag-drop COM lock (unfreezes Explorer).
+        QtCore.QTimer.singleShot(0, lambda: self.load_folder(str(location)))
+
     def select_folder(self):
+        folder_name = QtWidgets.QFileDialog.getExistingDirectory(self, dir=self.folder_name)
+        if not folder_name:
+            return
+        self.load_folder(folder_name)
+
+    def load_folder(self, folder_name):
         if self.concat_area.table.model.rowCount() > 0:
             if not yes_no_message(
                 f"{t('There are already items in this list')},\n"
@@ -280,9 +314,7 @@ def select_folder(self):
                 "Confirm Change Folder",
             ):
                 return
-        folder_name = QtWidgets.QFileDialog.getExistingDirectory(self, dir=self.folder_name)
-        if not folder_name:
-            return
+
         self.folder_name = folder_name
         self.set_folder_name(folder_name)
 
diff --git a/fastflix/widgets/windows/crop_window.py b/fastflix/widgets/windows/crop_window.py
index c493dc63..6ae6886a 100644
--- a/fastflix/widgets/windows/crop_window.py
+++ b/fastflix/widgets/windows/crop_window.py
@@ -2,13 +2,14 @@
 import logging
 import secrets
 from pathlib import Path
-from subprocess import run, PIPE
+from subprocess import run, PIPE, TimeoutExpired
 from typing import Optional, TYPE_CHECKING
 
 from PySide6 import QtWidgets, QtCore, QtGui
 
 from fastflix.encoders.common import helpers
 from fastflix.flix import generate_thumbnail_command
+from fastflix.shared import clean_env
 from fastflix.language import t
 from fastflix.shared import time_to_number
 from fastflix.ui_scale import scaler
@@ -21,6 +22,18 @@
 logger = logging.getLogger("fastflix")
 
 
+PREVIEW_TIMEOUT = 60
+
+
+def run_preview_command(command: list, timeout: int = PREVIEW_TIMEOUT):
+    """Run a thumbnail command without a shell; returns None if it timed out."""
+    try:
+        return run(command, stderr=PIPE, stdout=PIPE, env=clean_env(), timeout=timeout)
+    except TimeoutExpired:
+        logger.warning(f"Preview generation timed out after {timeout}s")
+        return None
+
+
 class CropImageWidget(QtWidgets.QWidget):
     """Interactive widget that displays a video frame and allows dragging crop edges."""
 
@@ -333,6 +346,11 @@ def __init__(self, parent: "Main"):
             self.setMaximumWidth(size.width())
             self.setMaximumHeight(size.height())
 
+        self._slider_timer = QtCore.QTimer(self)
+        self._slider_timer.setSingleShot(True)
+        self._slider_timer.setInterval(200)
+        self._slider_timer.timeout.connect(self._regenerate_for_slider)
+
         self._build_ui()
 
     def _build_ui(self):
@@ -640,6 +658,7 @@ def generate_image(self, with_crop=False):
             return
 
         settings = video.video_settings.model_dump()
+        settings.pop("reverse_video", None)
 
         if video.video_settings.video_encoder_settings.pix_fmt == "yuv420p10le" and video.color_space.startswith(
             "bt2020"
@@ -647,6 +666,10 @@ def generate_image(self, with_crop=False):
             settings["remove_hdr"] = True
             if not settings.get("color_transfer"):
                 settings["color_transfer"] = video.color_transfer
+            if not settings.get("color_primaries"):
+                settings["color_primaries"] = video.color_primaries
+            if not settings.get("color_space"):
+                settings["color_space"] = video.color_space
 
         if with_crop:
             # Transform rotated crop values to unrotated space for FFmpeg
@@ -669,13 +692,9 @@ def generate_image(self, with_crop=False):
         settings["vertical_flip"] = self.vertical_flip
         settings["horizontal_flip"] = self.horizontal_flip
 
-        filters = helpers.generate_filters(
-            enable_opencl=False,
-            start_filters="select=eq(pict_type\\,I)"
-            if self.main.app.fastflix.config.use_keyframes_for_preview
-            else None,
-            **settings,
-        )
+        start_filters = "select=eq(pict_type\\,I)" if self.main.app.fastflix.config.use_keyframes_for_preview else None
+
+        filters = helpers.generate_filters(enable_opencl=False, start_filters=start_filters, **settings)
 
         output = self.main.app.fastflix.config.work_path / f"crop_preview_{secrets.token_hex(16)}.tiff"
 
@@ -690,10 +709,33 @@ def generate_image(self, with_crop=False):
 
         logger.info(f"Generating crop preview: {thumb_command}")
 
-        thumb_run = run(thumb_command, shell=True, stderr=PIPE, stdout=PIPE)
-        if thumb_run.returncode > 0:
-            logger.warning(f"Could not generate crop preview: {thumb_run.stdout} |----| {thumb_run.stderr}")
+        thumb_run = run_preview_command(thumb_command)
+        if thumb_run is None:
             return
+        if thumb_run.returncode > 0:
+            stderr_text = thumb_run.stderr.decode(encoding="utf-8", errors="ignore")
+            if settings.get("remove_hdr") and "no path between colorspaces" in stderr_text:
+                logger.warning(
+                    "HDR tonemapping failed for crop preview (video color metadata may be incomplete), "
+                    "retrying without HDR conversion"
+                )
+                settings["remove_hdr"] = False
+                filters = helpers.generate_filters(enable_opencl=False, start_filters=start_filters, **settings)
+                output = self.main.app.fastflix.config.work_path / f"crop_preview_{secrets.token_hex(16)}.tiff"
+                thumb_command = generate_thumbnail_command(
+                    config=self.main.app.fastflix.config,
+                    source=self.main.source_material,
+                    output=output,
+                    filters=filters,
+                    start_time=self._get_preview_time(),
+                    input_track=video.video_settings.selected_track,
+                )
+                thumb_run = run_preview_command(thumb_command)
+            if thumb_run is None:
+                return
+            if thumb_run.returncode > 0:
+                logger.warning(f"Could not generate crop preview: {thumb_run.stdout} |----| {thumb_run.stderr}")
+                return
 
         pixmap = QtGui.QPixmap(str(output))
 
@@ -718,6 +760,9 @@ def switch_mode(self, mode: str):
         self.image_widget.update()
 
     def slider_changed(self):
+        self._slider_timer.start()
+
+    def _regenerate_for_slider(self):
         self.generate_image(with_crop=False)
         if self.mode == "preview":
             self.generate_image(with_crop=True)
diff --git a/fastflix/widgets/windows/disposition.py b/fastflix/widgets/windows/disposition.py
index d61e847f..14077e21 100644
--- a/fastflix/widgets/windows/disposition.py
+++ b/fastflix/widgets/windows/disposition.py
@@ -5,6 +5,7 @@
 
 from fastflix.language import t
 from fastflix.models.fastflix_app import FastFlixApp
+from fastflix.widgets.toggle_switch import ToggleSwitch
 
 __all__ = ["Disposition"]
 
@@ -38,9 +39,9 @@ def __init__(self, app: FastFlixApp, parent, track_name, track_index, audio=True
 
         self.setMinimumWidth(200)
 
-        self.forced = QtWidgets.QCheckBox(t("Forced"))
+        self.forced = ToggleSwitch(t("Forced"))
 
-        self.default = QtWidgets.QCheckBox(t("Default"))
+        self.default = ToggleSwitch(t("Default"))
 
         track = self.get_track()
         self.forced.setChecked(track.dispositions.get("forced", False))
diff --git a/fastflix/widgets/windows/hdr10plus_inject.py b/fastflix/widgets/windows/hdr10plus_inject.py
deleted file mode 100644
index 5f689067..00000000
--- a/fastflix/widgets/windows/hdr10plus_inject.py
+++ /dev/null
@@ -1,142 +0,0 @@
-# -*- coding: utf-8 -*-
-import logging
-from subprocess import run
-
-from PySide6 import QtWidgets, QtGui
-
-from fastflix.flix import probe
-from fastflix.shared import error_message
-from fastflix.resources import get_icon
-
-logger = logging.getLogger("fastflix")
-
-
-class HDR10PlusInjectWindow(QtWidgets.QWidget):
-    def __init__(self, app, main, items=None):
-        super().__init__(None)
-        self.app = app
-        self.main = main
-        self.selected_stream = None
-
-        self.movie_file = QtWidgets.QLineEdit()
-        self.movie_file.setEnabled(False)
-        self.movie_file.setFixedWidth(400)
-        self.movie_file_button = QtWidgets.QPushButton(
-            icon=QtGui.QIcon(get_icon("onyx-output", self.app.fastflix.config.theme))
-        )
-        self.movie_file_button.clicked.connect(self.movie_open)
-
-        self.hdr10p_file = QtWidgets.QLineEdit()
-        self.hdr10p_file.setEnabled(False)
-        self.hdr10p_file_button = QtWidgets.QPushButton(
-            icon=QtGui.QIcon(get_icon("onyx-output", self.app.fastflix.config.theme))
-        )
-        self.hdr10p_file_button.clicked.connect(self.hdr10p_open)
-
-        self.output_file = QtWidgets.QLineEdit()
-        self.output_file.setFixedWidth(400)
-        self.output_file_button = QtWidgets.QPushButton(
-            icon=QtGui.QIcon(get_icon("onyx-output", self.app.fastflix.config.theme))
-        )
-        self.output_file_button.clicked.connect(self.set_output_file)
-        self.output_file.textChanged.connect(self.prep_command)
-
-        line_1 = QtWidgets.QHBoxLayout()
-        line_1.addWidget(QtWidgets.QLabel("Movie File"))
-        line_1.addWidget(self.movie_file)
-        line_1.addWidget(self.movie_file_button)
-
-        line_3 = QtWidgets.QHBoxLayout()
-        line_3.addWidget(QtWidgets.QLabel("HDR10+ File"))
-        line_3.addWidget(self.hdr10p_file)
-        line_3.addWidget(self.hdr10p_file_button)
-
-        self.info_bubble = QtWidgets.QLabel("")
-        self.command_bubble = QtWidgets.QLineEdit("")
-        self.command_bubble.setFixedWidth(400)
-        # self.command_bubble.setWordWrap(True)
-        # self.command_bubble.setFixedHeight(400)
-
-        layout = QtWidgets.QVBoxLayout()
-
-        output_lin = QtWidgets.QHBoxLayout()
-        output_lin.addWidget(QtWidgets.QLabel("Output File"))
-        output_lin.addWidget(self.output_file)
-        output_lin.addWidget(self.output_file_button)
-
-        bottom_line = QtWidgets.QHBoxLayout()
-        cancel = QtWidgets.QPushButton("Cancel")
-        cancel.clicked.connect(self.hide)
-        bottom_line.addWidget(cancel)
-        start = QtWidgets.QPushButton("Start")
-        start.clicked.connect(self.start)
-        bottom_line.addWidget(start)
-
-        layout.addLayout(line_1)
-        layout.addWidget(self.info_bubble)
-        layout.addLayout(line_3)
-        layout.addLayout(output_lin)
-        layout.addWidget(self.command_bubble)
-        layout.addLayout(bottom_line)
-        self.setLayout(layout)
-
-    def movie_open(self):
-        self.selected_stream = None
-        self.movie_file.setText("")
-        movie_name = QtWidgets.QFileDialog.getOpenFileName(self)
-        if not movie_name or not movie_name[0]:
-            return
-        try:
-            results = probe(self.app, movie_name[0])
-        except Exception as err:
-            error_message(f"Invalid file: {err}")
-            return
-        for result in results["streams"]:
-            if result["codec_type"] == "video":
-                if result["codec_name"] == "hevc":
-                    self.selected_stream = result
-                    break
-        if not self.selected_stream:
-            error_message("No HEVC video stream found")
-            return
-        self.info_bubble.setText(f"Selected stream index: {self.selected_stream['index']}")
-        self.movie_file.setText(movie_name[0])
-        self.prep_command()
-
-    def hdr10p_open(self):
-        hdr10p_file = QtWidgets.QFileDialog.getOpenFileName(self)
-        if not hdr10p_file or not hdr10p_file[0]:
-            return
-        self.hdr10p_file.setText(hdr10p_file[0])
-        self.prep_command()
-
-    def set_output_file(self):
-        filename = QtWidgets.QFileDialog.getSaveFileName(
-            self,
-            caption="Save Video As",
-            # dir=str(Path(*self.generate_output_filename)) + f"{self.widgets.output_type_combo.currentText()}",
-            # filter=f"Save File (*.{extension})",
-        )
-        if filename and filename[0]:
-            self.output_file.setText(filename[0])
-        self.prep_command()
-
-    def prep_command(self):
-        print("called prep")
-        if not self.movie_file.text() or not self.hdr10p_file.text() or not self.output_file.text():
-            print("Nope", "1", self.movie_file.text(), "2", self.hdr10p_file.text(), "3", self.output_file.text())
-            return
-
-        command = (
-            f'{self.app.fastflix.config.ffmpeg} -loglevel panic -i "{self.movie_file.text()}" '
-            f"-map 0:{self.selected_stream['index']} -c:v copy -bsf:v hevc_mp4toannexb -f hevc - | "
-            f"{self.app.fastflix.config.hdr10plus_parser} inject -i - -j {self.hdr10p_file.text()} -o - | "
-            f'{self.app.fastflix.config.ffmpeg} -loglevel panic -i - -i {self.movie_file.text()} -map 0:0 -c:0 copy -map 1:a -map 1:s -map 1:d -c:1 copy "{self.output_file.text()}"'
-        )
-
-        print(command)
-        self.command_bubble.setText(command)
-
-    def start(self):
-        run(self.command_bubble.text(), shell=True)
-        error_message("Done")
diff --git a/fastflix/widgets/windows/large_preview.py b/fastflix/widgets/windows/large_preview.py
index 14c80cce..5f1c897c 100644
--- a/fastflix/widgets/windows/large_preview.py
+++ b/fastflix/widgets/windows/large_preview.py
@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
 import logging
 from pathlib import Path
-from subprocess import run, PIPE
 from typing import Optional, TYPE_CHECKING
 import secrets
 
@@ -12,6 +11,7 @@
 )
 from fastflix.encoders.common import helpers
 from fastflix.resources import get_icon
+from fastflix.widgets.windows.crop_window import run_preview_command
 from fastflix.language import t
 
 if TYPE_CHECKING:
@@ -58,6 +58,7 @@ def keyPressEvent(self, a0: QtGui.QKeyEvent) -> None:
 
     def generate_image(self):
         settings = self.main.app.fastflix.current_video.video_settings.model_dump()
+        settings.pop("reverse_video", None)
         if not self.main.app.fastflix.current_video.video_settings.video_encoder_settings:
             return
 
@@ -93,7 +94,9 @@ def generate_image(self):
 
         logger.info(f"Generating large thumbnail: {thumb_command}")
 
-        thumb_run = run(thumb_command, shell=True, stderr=PIPE, stdout=PIPE)
+        thumb_run = run_preview_command(thumb_command)
+        if thumb_run is None:
+            return
         if thumb_run.returncode > 0:
             logger.warning(f"Could not generate large thumbnail: {thumb_run.stdout} |----| {thumb_run.stderr}")
             return
diff --git a/fastflix/widgets/windows/multiple_files.py b/fastflix/widgets/windows/multiple_files.py
index 1df28a78..018bf175 100644
--- a/fastflix/widgets/windows/multiple_files.py
+++ b/fastflix/widgets/windows/multiple_files.py
@@ -2,7 +2,7 @@
 from pathlib import Path
 import logging
 
-from PySide6 import QtWidgets, QtGui
+from PySide6 import QtCore, QtWidgets, QtGui
 from PySide6.QtWidgets import QAbstractItemView
 
 from fastflix.language import t
@@ -160,6 +160,7 @@ def __init__(self, app, main, items=None):
 
         self.files_area = MultipleFilesScroll(self)
         self.base_folder_label = QtWidgets.QLabel()
+        self.base_folder_label.setTextFormat(QtCore.Qt.TextFormat.PlainText)
         self.set_folder_name(self.folder_name)
         layout = QtWidgets.QVBoxLayout()
         folder_button = QtWidgets.QPushButton(t("Open Folder"))
diff --git a/fastflix/widgets/windows/profile_window.py b/fastflix/widgets/windows/profile_window.py
index 87e3a3df..86c5a3ff 100644
--- a/fastflix/widgets/windows/profile_window.py
+++ b/fastflix/widgets/windows/profile_window.py
@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 
+import html
 import logging
 
 from box import Box
@@ -14,6 +15,7 @@
 from fastflix.models.encode import x265Settings, setting_types
 from fastflix.models.profiles import AudioMatch, Profile, MatchItem, MatchType, TitleMode, AdvancedOptions
 from fastflix.shared import error_message
+from fastflix.widgets.toggle_switch import ToggleSwitch
 from fastflix.encoders.common.audio import channel_list
 
 language_list = [v.name for v in iter_langs() if v.pt2b and v.pt1] + ["Undefined"]
@@ -23,8 +25,24 @@
 match_type_eng = [MatchType.ALL, MatchType.FIRST, MatchType.LAST]
 match_type_locale = [t("All"), t("First"), t("Last")]
 
-match_item_enums = [MatchItem.ALL, MatchItem.TITLE, MatchItem.TRACK, MatchItem.LANGUAGE, MatchItem.CHANNELS]
-match_item_locale = [t("All"), t("Title"), t("Track Number"), t("Language"), t("Channels")]
+match_item_enums = [
+    MatchItem.ALL,
+    MatchItem.TITLE,
+    MatchItem.TRACK,
+    MatchItem.LANGUAGE,
+    MatchItem.CHANNELS,
+    MatchItem.CODEC,
+    MatchItem.CODEC_PROFILE,
+]
+match_item_locale = [
+    t("All"),
+    t("Title"),
+    t("Track Number"),
+    t("Language"),
+    t("Channels"),
+    t("Codec"),
+    t("Codec & Profile"),
+]
 
 sub_match_item_enums = [MatchItem.ALL, MatchItem.TRACK, MatchItem.LANGUAGE]
 sub_match_item_locale = [t("All"), t("Track Number"), t("Language")]
@@ -57,6 +75,8 @@ def __init__(self, parent_list, app, main, parent, index):
             QtWidgets.QComboBox(),
             QtWidgets.QComboBox(),
             QtWidgets.QComboBox(),
+            QtWidgets.QLineEdit(""),
+            QtWidgets.QLineEdit(""),
         ]
         self.match_input = self.match_input_boxes[0]
         self.match_input_boxes[0].setDisabled(True)
@@ -67,6 +87,8 @@ def __init__(self, parent_list, app, main, parent, index):
         self.match_input_boxes[4].addItems(
             ["none | unknown", "mono", "stereo", "3 | 2.1", "4", "5", "6 | 5.1", "7", "8 | 7.1", "9", "10"]
         )
+        self.match_input_boxes[5].setPlaceholderText(t("e.g. dts, truehd, aac"))
+        self.match_input_boxes[6].setPlaceholderText(t("e.g. dts:DTS-HD MA"))
 
         self.match_input_boxes[2].view().setFixedWidth(self.match_input_boxes[2].minimumSizeHint().width() + 50)
         self.match_input_boxes[3].view().setFixedWidth(self.match_input_boxes[3].minimumSizeHint().width() + 50)
@@ -109,11 +131,25 @@ def __init__(self, parent_list, app, main, parent, index):
         self.bitrate.setDisabled(True)
         self.downmix.setDisabled(True)
 
+        # Values passed to FFmpeg -profile:a (HE profiles are only supported by libfdk_aac)
+        self.aac_profile_values = [None, "aac_he", "aac_he_v2"]
+        self.aac_profile = QtWidgets.QComboBox()
+        self.aac_profile.addItems(
+            [
+                t("AAC-LC (default)"),
+                f"HE-AAC ({t('libfdk_aac only')})",
+                f"HE-AAC v2 ({t('libfdk_aac only')})",
+            ]
+        )
+        self.aac_profile.setToolTip(t("HE-AAC profiles require the libfdk_aac encoder"))
+        self.aac_profile.setDisabled(True)
+
         self.grid.addWidget(QtWidgets.QLabel(t("Conversion")), 1, 0)
         self.grid.addWidget(self.convert_to, 1, 1)
         self.grid.addWidget(QtWidgets.QLabel(t("Bitrate")), 1, 2)
         self.grid.addWidget(self.bitrate, 1, 3)
         self.grid.addWidget(self.downmix, 1, 4)
+        self.grid.addWidget(self.aac_profile, 1, 5)
 
         self.grid.addWidget(QtWidgets.QLabel(t("Title")), 2, 0)
         self.grid.addWidget(self.title_mode, 2, 1)
@@ -148,6 +184,11 @@ def update_conversion(self):
         else:
             self.bitrate.setEnabled(True)
             self.downmix.setEnabled(True)
+        if self.convert_to.currentIndex() > 0 and "aac" in self.convert_to.currentText().lower():
+            self.aac_profile.setEnabled(True)
+        else:
+            self.aac_profile.setDisabled(True)
+            self.aac_profile.setCurrentIndex(0)
 
     def update_title_mode_availability(self):
         """Add/remove the Custom Title option based on match type."""
@@ -197,6 +238,8 @@ def get_settings(self):
             match_input_value = Language(self.match_input.currentText()).pt2b
         elif match_item_enum == MatchItem.CHANNELS:
             match_input_value = str(self.match_input.currentIndex())
+        elif match_item_enum in (MatchItem.CODEC, MatchItem.CODEC_PROFILE):
+            match_input_value = self.match_input.text().strip()
         else:
             raise Exception("Internal error, what do we do sir?")
 
@@ -213,6 +256,9 @@ def get_settings(self):
             match_item=match_item_enum,
             match_input=match_input_value,
             conversion=self.convert_to.currentText() if self.convert_to.currentIndex() > 0 else None,
+            conversion_profile=self.aac_profile_values[self.aac_profile.currentIndex()]
+            if self.aac_profile.isEnabled()
+            else None,
             bitrate=self.bitrate.text(),
             downmix=self.downmix.currentText() if self.downmix.currentIndex() > 0 else None,
             title_mode=selected_title_mode,
@@ -337,20 +383,44 @@ def __init__(self, app, parent):
         self.sub_language.insertSeparator(1)
         self.sub_language.insertSeparator(3)
         self.sub_language.setFixedWidth(250)
-        self.sub_first_only = QtWidgets.QCheckBox(t("Only select first matching Subtitle Track"))
+        self.sub_first_only = ToggleSwitch(t("Only select first matching Subtitle Track"))
         self.sub_language.view().setFixedWidth(self.sub_language.minimumSizeHint().width() + 50)
 
-        self.sub_burn_in = QtWidgets.QCheckBox(t("Auto Burn-in first forced or default subtitle track"))
+        self.sub_burn_in = ToggleSwitch(t("Auto Burn-in first forced or default subtitle track"))
+
+        disposition_options = [t("Keep Source"), t("Clear All"), t("Set on First Track")]
+
+        default_disp_label = QtWidgets.QLabel(t("Default flag"))
+        self.default_disposition = QtWidgets.QComboBox()
+        self.default_disposition.addItems(disposition_options)
+        self.default_disposition.setFixedWidth(250)
+
+        forced_disp_label = QtWidgets.QLabel(t("Forced flag"))
+        self.forced_disposition = QtWidgets.QComboBox()
+        self.forced_disposition.addItems(disposition_options)
+        self.forced_disposition.setFixedWidth(250)
 
         layout = QtWidgets.QGridLayout()
         layout.addWidget(sub_language_label, 0, 0)
         layout.addWidget(self.sub_language, 0, 1)
         layout.addWidget(self.sub_first_only, 1, 0)
         layout.addWidget(self.sub_burn_in, 2, 0, 1, 2)
-        layout.addWidget(QtWidgets.QWidget(), 3, 0, 1, 2)
-        layout.setRowStretch(3, True)
+        layout.addWidget(default_disp_label, 3, 0)
+        layout.addWidget(self.default_disposition, 3, 1)
+        layout.addWidget(forced_disp_label, 4, 0)
+        layout.addWidget(self.forced_disposition, 4, 1)
+        layout.addWidget(QtWidgets.QWidget(), 5, 0, 1, 2)
+        layout.setRowStretch(5, True)
         self.setLayout(layout)
 
+    def get_default_disposition(self) -> str | None:
+        idx = self.default_disposition.currentIndex()
+        return [None, "clear", "first"][idx]
+
+    def get_forced_disposition(self) -> str | None:
+        idx = self.forced_disposition.currentIndex()
+        return [None, "clear", "first"][idx]
+
 
 class DataSelect(QtWidgets.QWidget):
     def __init__(self, app, parent):
@@ -428,7 +498,7 @@ def __init__(self, advanced_settings):
     def text_update(self, advanced_settings):
         ignored = ("color_primaries", "color_transfer", "color_space", "denoise_type_index", "denoise_strength_index")
         settings = "\n".join(f"{k:<30} {v}" for k, v in advanced_settings.model_dump().items() if k not in ignored)
-        self.label.setText(f"<pre>{settings}</pre>")
+        self.label.setText(f"<pre>{html.escape(settings)}</pre>")
 
 
 class PrimaryOptions(QtWidgets.QTabWidget):
@@ -438,9 +508,9 @@ def __init__(self, main_options):
         layout = QtWidgets.QVBoxLayout()
         self.label = QtWidgets.QLabel()
         settings = "\n".join(f"{k:<30} {v}" for k, v in main_options.items())
-        self.label.setText(f"<pre>{settings}</pre>")
+        self.label.setText(f"<pre>{html.escape(settings)}</pre>")
 
-        self.auto_crop = QtWidgets.QCheckBox(t("Auto Crop"))
+        self.auto_crop = ToggleSwitch(t("Auto Crop"))
 
         layout.addWidget(self.auto_crop)
         layout.addStretch(1)
@@ -467,7 +537,7 @@ def __init__(self, app, main):
 
     def update_settings(self):
         settings = "\n".join(f"{k:<30} {v}" for k, v in self.main.encoder.model_dump().items())
-        self.label.setText(f"<pre>{settings}</pre>")
+        self.label.setText(f"<pre>{html.escape(settings)}</pre>")
 
 
 class ProfileWindow(QtWidgets.QWidget):
@@ -520,7 +590,7 @@ def __init__(self, app: FastFlixApp, main, container, *args, **kwargs):
             remove_hdr=self.main.remove_hdr,
             resolution_method=self.main.resolution_method(),
             resolution_custom=self.main.resolution_custom(),
-            output_type=self.main.widgets.output_type_combo.currentText(),
+            output_type=self.main.output_type_for_profile(),
         )
 
         self.tab_area = QtWidgets.QTabWidget()
@@ -624,13 +694,15 @@ def save(self):
             data_passthrough=self.data_select.get_settings(),
             resolution_method=self.main_settings.resolution_method,
             resolution_custom=self.main_settings.resolution_custom,
-            output_type=self.main.widgets.output_type_combo.currentText(),
+            output_type=self.main.output_type_for_profile(),
             # subtitle_filters=self.subtitle_select.get_settings(),
             subtitle_language=sub_lang,
             subtitle_select=subtitle_enabled,
             subtitle_automatic_burn_in=self.subtitle_select.sub_burn_in.isChecked(),
             subtitle_select_preferred_language=subtitle_select_preferred_language,
             subtitle_select_first_matching=self.subtitle_select.sub_first_only.isChecked(),
+            subtitle_default_disposition=self.subtitle_select.get_default_disposition(),
+            subtitle_forced_disposition=self.subtitle_select.get_forced_disposition(),
             encoder=self.encoder.name,
             advanced_options=self.advanced_options,
         )
diff --git a/go.mod b/go.mod
new file mode 100644
index 00000000..a4270485
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,8 @@
+module github.com/cdgriffith/fastflix-installer
+
+go 1.22
+
+require (
+	github.com/klauspost/compress v1.17.11
+	golang.org/x/sys v0.28.0
+)
diff --git a/go.sum b/go.sum
new file mode 100644
index 00000000..7ed56178
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,4 @@
+github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
+github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
+golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
diff --git a/pyproject.toml b/pyproject.toml
index 03e6d3ce..7624bb58 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -53,6 +53,7 @@ dev = [
     "pre-commit>=4.2.0",
     "pyinstaller>=6.13.0",
     "pytest>=9.0",
+    "pytest-xdist>=3.5",
     "ruff>=0.14",
     "types-requests>=2.32",
     "types-setuptools>=80.9",
@@ -63,6 +64,12 @@ dev = [
 [tool.setuptools.dynamic]
 version = { attr = "fastflix.version.__version__" }
 
+[tool.pytest.ini_options]
+markers = [
+    "local_only: Tests that require local tools (FFmpeg, encoders) and skip on CI",
+    "e2e: End-to-end encode tests that run real FFmpeg encodes (local only, skip on CI)",
+]
+
 [tool.ruff]
 # Exclude a variety of commonly ignored directories.
 exclude = [
diff --git a/scripts/build_distribution.py b/scripts/build_distribution.py
new file mode 100644
index 00000000..76552317
--- /dev/null
+++ b/scripts/build_distribution.py
@@ -0,0 +1,651 @@
+#!/usr/bin/env python3
+"""
+Build script for FastFlix distribution using embeddable Python.
+
+Replaces PyInstaller by bundling the official Python embeddable distribution
+with the pinned dependencies. The output is a self-contained directory
+that can be launched via the Go launcher.
+
+Usage:
+    python scripts/build_distribution.py [--python-version 3.13.16] [--arch amd64] [--output dist/FastFlix]
+        [--archive] [--installer]
+
+Requirements:
+    - Go and go-winres (go install github.com/tc-hib/go-winres@v0.3.3) on PATH
+    - uv on PATH (dependencies are pinned from uv.lock via `uv export`)
+    - Internet access (downloads Python embeddable distribution and wheels)
+    - Or: pre-downloaded embeddable Python in scripts/cache/
+"""
+
+import argparse
+import json
+import platform
+import re
+import shutil
+import subprocess
+import sys
+import urllib.request
+import zipfile
+from datetime import datetime
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+CACHE_DIR = PROJECT_ROOT / "scripts" / "cache"
+
+# Single source of truth for the bundled interpreter. Must be a 3.13.x patch release that
+# has python-<ver>-embed-<arch>.zip published on python.org. Wheels are resolved for its minor version.
+DEFAULT_PYTHON_VERSION = "3.13.16"
+
+# Go commands that get built (directories under cmd/)
+GO_CMDS = ("installer", "launcher", "uninstaller")
+
+# Packages whose "tests" directory is known to be safe to delete (never imported at runtime).
+SAFE_TEST_DIR_PACKAGES = ("numpy", "cv2", "psutil", "pydantic", "pydantic_core", "requests", "chardet")
+
+
+def detect_arch():
+    machine = platform.machine().lower()
+    if machine in ("amd64", "x86_64", "x64"):
+        return "amd64"
+    if machine in ("arm64", "aarch64"):
+        return "arm64"
+    return "amd64"
+
+
+def download_file(url, dest):
+    """Download a file with progress indication."""
+    print(f"  Downloading {url}")
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    urllib.request.urlretrieve(url, dest)
+    print(f"  Saved to {dest} ({dest.stat().st_size / 1024 / 1024:.1f} MB)")
+
+
+def get_python_url(version, arch):
+    """Get the download URL for the Python embeddable distribution."""
+    return f"https://www.python.org/ftp/python/{version}/python-{version}-embed-{arch}.zip"
+
+
+def extract_python(python_zip, target_dir):
+    """Extract the embeddable Python distribution."""
+    print(f"  Extracting Python to {target_dir}")
+    target_dir.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(python_zip) as zf:
+        zf.extractall(target_dir)
+
+
+def configure_pth_file(python_dir):
+    """Configure the ._pth file to enable site packages and find our lib directory.
+
+    The embeddable distribution uses a ._pth file to restrict imports.
+    We need to:
+    1. Uncomment 'import site' to enable pip/site-packages
+    2. Add '../lib' so Python can find our installed packages
+    """
+    pth_files = list(python_dir.glob("python*._pth"))
+    if not pth_files:
+        print("  WARNING: No ._pth file found in Python distribution")
+        return
+
+    pth_file = pth_files[0]
+    print(f"  Configuring {pth_file.name}")
+
+    lines = pth_file.read_text().splitlines()
+    new_lines = []
+    for line in lines:
+        # Uncomment 'import site'
+        if line.strip() == "#import site":
+            new_lines.append("import site")
+        else:
+            new_lines.append(line)
+
+    # Add our lib directory
+    new_lines.append("../lib")
+
+    pth_file.write_text("\n".join(new_lines) + "\n")
+
+
+def get_version():
+    """Return fastflix.version.__version__ (parsed from the file so there are no import side effects)."""
+    text = (PROJECT_ROOT / "fastflix" / "version.py").read_text(encoding="utf-8")
+    match = re.search(r'__version__\s*=\s*"([^"]+)"', text)
+    if not match:
+        print("  ERROR: could not read __version__ from fastflix/version.py")
+        sys.exit(1)
+    return match.group(1)
+
+
+def four_part_version(version):
+    """Convert a PEP 440 version (6.3.0, 6.3.0b1) to the X.X.X.X form used by Windows resources."""
+    match = re.match(r"^(\d+)\.(\d+)\.(\d+)(?:(?:a|b|rc)(\d+))?", version)
+    if not match:
+        return f"{version}.0"
+    major, minor, patch, pre = match.groups()
+    return f"{major}.{minor}.{patch}.{pre or 0}"
+
+
+def require_tool(name, hint):
+    if shutil.which(name) is None:
+        print(f"  ERROR: '{name}' not found on PATH. {hint}")
+        sys.exit(1)
+
+
+def patch_winres(version):
+    """Sync version numbers and copyright year in every cmd/*/winres/winres.json with fastflix/version.py."""
+    four = four_part_version(version)
+    year = datetime.now().year
+    for cmd in GO_CMDS:
+        path = PROJECT_ROOT / "cmd" / cmd / "winres" / "winres.json"
+        old_text = path.read_text(encoding="utf-8")
+        data = json.loads(old_text)
+        data["RT_MANIFEST"]["#1"]["0409"]["identity"]["version"] = four
+        ver = data["RT_VERSION"]["#1"]["0000"]
+        ver["fixed"]["file_version"] = four
+        ver["fixed"]["product_version"] = four
+        info = ver["info"]["0409"]
+        info["FileVersion"] = version
+        info["ProductVersion"] = version
+        info["LegalCopyright"] = re.sub(r"2019-\d{4}", f"2019-{year}", info["LegalCopyright"])
+        new_text = json.dumps(data, indent=2) + "\n"
+        if new_text != old_text:
+            path.write_text(new_text, encoding="utf-8", newline="\n")
+            print(f"  Updated {path.relative_to(PROJECT_ROOT)} -> {version}")
+
+
+def run_winres(cmd):
+    """Generate the .syso resource (icon, manifest, version info) for cmd/<cmd>."""
+    subprocess.run(["go-winres", "make"], check=True, cwd=PROJECT_ROOT / "cmd" / cmd)
+
+
+def go_build(cmd, output, version, gui):
+    """Build cmd/<cmd> with version and build date injected."""
+    ldflags = f"-s -w -X main.Version={version} -X main.BuildDate={datetime.now().strftime('%Y-%m-%d')}"
+    if gui:
+        ldflags += " -H windowsgui"
+    subprocess.run(
+        ["go", "build", f"-ldflags={ldflags}", "-o", str(output), f"./cmd/{cmd}"],
+        check=True,
+        cwd=PROJECT_ROOT,
+    )
+    print(f"  Built {output.name} ({output.stat().st_size / 1024 / 1024:.1f} MB)")
+
+
+def build_wheel(project_root):
+    """Build a wheel of FastFlix with `uv build` (the uv-managed venv has no pip).
+
+    The wheel directory is wiped first so a stale wheel can never be bundled.
+    """
+    wheel_dir = project_root / "dist" / "wheels"
+    if wheel_dir.exists():
+        shutil.rmtree(wheel_dir)
+    wheel_dir.mkdir(parents=True, exist_ok=True)
+
+    print("  Building FastFlix wheel...")
+    require_tool("uv", "Install uv: https://docs.astral.sh/uv/")
+    subprocess.run(["uv", "build", "--wheel", "--out-dir", str(wheel_dir), str(project_root)], check=True)
+
+    wheels = list(wheel_dir.glob("fastflix-*.whl"))
+    if len(wheels) != 1:
+        print(f"  ERROR: expected exactly one fastflix wheel in {wheel_dir}, found {len(wheels)}: {wheels}")
+        sys.exit(1)
+    print(f"  Built {wheels[0].name} (fastflix/version.py says {get_version()})")
+    return wheels[0]
+
+
+def export_requirements(project_root, dest):
+    """Write the exact dependency pins from uv.lock (runtime deps only, not the project itself)."""
+    require_tool("uv", "Install uv: https://docs.astral.sh/uv/")
+    result = subprocess.run(
+        ["uv", "export", "--frozen", "--no-dev", "--no-hashes", "--no-emit-project", "--format", "requirements.txt"],
+        check=True,
+        capture_output=True,
+        text=True,
+        cwd=project_root,
+    )
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_text(result.stdout, encoding="utf-8")
+    return dest
+
+
+def install_dependencies(lib_dir, project_root, python_version, arch):
+    """Install FastFlix and all dependencies into the lib directory.
+
+    Uses `uv pip install --target` with an explicit target platform/interpreter, so wheels are resolved for the
+    *bundled* CPython 3.13 (win_amd64/win_arm64) rather than for whatever Python runs this script. (Plain
+    `pip --platform` cannot be used because a few pure-Python dependencies are sdist-only.) Dependency versions
+    are pinned to uv.lock via `uv export`.
+    """
+    lib_dir.mkdir(parents=True, exist_ok=True)
+
+    wheel_path = build_wheel(project_root)
+    requirements = export_requirements(project_root, project_root / "dist" / "requirements-build.txt")
+
+    py_minor = ".".join(python_version.split(".")[:2])
+    uv_platform = "aarch64-pc-windows-msvc" if arch == "arm64" else "x86_64-pc-windows-msvc"
+    target_args = [
+        "--target",
+        str(lib_dir),
+        "--python-version",
+        py_minor,
+        "--python-platform",
+        uv_platform,
+        "--no-deps",  # the requirements file is fully resolved and pinned by uv
+    ]
+
+    print(f"  Installing pinned dependencies for CPython {py_minor} / {uv_platform}...")
+    subprocess.run(["uv", "pip", "install", "-r", str(requirements), *target_args], check=True, cwd=project_root)
+
+    print("  Installing FastFlix wheel...")
+    subprocess.run(["uv", "pip", "install", str(wheel_path), *target_args], check=True, cwd=project_root)
+
+
+def prepare_installer_resources():
+    """Copy files needed by the Go installer for embedding (licenses, terms, etc.)."""
+    installer_dir = PROJECT_ROOT / "cmd" / "installer"
+
+    # Copy licenses for go:embed
+    licenses_src = PROJECT_ROOT / "docs" / "build-licenses.txt"
+    licenses_dst = installer_dir / "licenses.txt"
+    if licenses_src.exists():
+        shutil.copy2(licenses_src, licenses_dst)
+        print(f"  Copied {licenses_src.name} -> {licenses_dst}")
+
+    # Generate translated terms JSON for installer embedding
+    generate_terms_json(installer_dir)
+
+
+def generate_terms_json(installer_dir):
+    """Generate translated terms text for all supported languages.
+
+    Reads TERMS_SECTIONS from terms_agreement.py and translations from languages.yaml,
+    then writes a JSON file mapping language codes to rendered terms text.
+    """
+    import json
+
+    import yaml
+
+    from fastflix.widgets.terms_agreement import TERMS_SECTIONS
+
+    lang_file = PROJECT_ROOT / "fastflix" / "data" / "languages.yaml"
+    with open(lang_file, encoding="utf-8") as f:
+        lang_data = yaml.safe_load(f)
+
+    languages = ["eng", "deu", "fra", "ita", "spa", "chs", "jpn", "rus", "por", "swe", "pol", "ukr", "kor", "ron"]
+
+    result = {}
+    for lang in languages:
+        parts = []
+        for header, body in TERMS_SECTIONS:
+            translated_header = lang_data.get(header, {}).get(lang, header)
+            if body:
+                translated_body = lang_data.get(body, {}).get(lang, body)
+                parts.append(f"{translated_header}\r\n{translated_body}")
+            else:
+                parts.append(translated_header)
+        result[lang] = "\r\n\r\n".join(parts)
+
+    out = installer_dir / "terms_translations.json"
+    out.write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(f"  Generated terms_translations.json ({len(languages)} languages)")
+
+
+def build_go_launcher(output_dir):
+    """Build the Go launcher and uninstaller and place them in the distribution."""
+    version = get_version()
+    require_tool("go", "Install Go: https://go.dev/dl/")
+    require_tool("go-winres", "Install it: go install github.com/tc-hib/go-winres@v0.3.3")
+
+    patch_winres(version)
+    for cmd in ("launcher", "uninstaller"):
+        run_winres(cmd)
+
+    print(f"  Building launcher -> {output_dir / 'FastFlix.exe'}")
+    go_build("launcher", output_dir / "FastFlix.exe", version, gui=False)
+
+    print(f"  Building uninstaller -> {output_dir / 'uninstall.exe'}")
+    go_build("uninstaller", output_dir / "uninstall.exe", version, gui=True)
+
+
+def build_go_installer(output_exe):
+    """Build the installer. Requires cmd/installer/fastflix_dist.tar.zst (see --archive)."""
+    version = get_version()
+    require_tool("go", "Install Go: https://go.dev/dl/")
+    require_tool("go-winres", "Install it: go install github.com/tc-hib/go-winres@v0.3.3")
+    patch_winres(version)
+    run_winres("installer")
+    output_exe.parent.mkdir(parents=True, exist_ok=True)
+    print(f"  Building installer -> {output_exe}")
+    go_build("installer", output_exe, version, gui=True)
+
+
+def copy_data_files(output_dir, project_root):
+    """Copy additional data files that aren't part of the Python package."""
+    print("  Copying additional data files...")
+
+    # CHANGES file
+    changes = project_root / "CHANGES"
+    if changes.exists():
+        shutil.copy2(changes, output_dir / "CHANGES")
+
+    # Build licenses
+    licenses = project_root / "docs" / "build-licenses.txt"
+    if licenses.exists():
+        shutil.copy2(licenses, output_dir / "build-licenses.txt")
+
+    # Create build version file
+    version_file = output_dir / "build_version"
+    branch = "unknown"
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True,
+            text=True,
+            cwd=project_root,
+        )
+        if result.returncode == 0:
+            branch = result.stdout.strip()
+    except FileNotFoundError:
+        pass
+
+    timestamp = datetime.now().strftime("%Y.%m.%d-%H.%M")
+    version_file.write_text(f"{get_version()}-{branch}-{timestamp}")
+
+
+def create_dist_archive(output_dir, archive_path):
+    """Create a tar.zst archive of the distribution for the installer to embed.
+
+    Uses Zstandard compression for better ratio than ZIP Deflate (~20-25% smaller)
+    while maintaining fast decompression during installation.
+    """
+    import tarfile
+
+    try:
+        import zstandard
+    except ImportError:
+        print("  ERROR: zstandard package not installed. Run this script via: uv run --with zstandard python ...")
+        sys.exit(1)
+
+    print(f"  Creating distribution archive: {archive_path}")
+    archive_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Create tar in memory, then compress with zstd
+    tar_path = archive_path.with_suffix(".tar")
+    with tarfile.open(tar_path, "w") as tf:
+        for file in output_dir.rglob("*"):
+            if file.is_file():
+                arcname = str(file.relative_to(output_dir))
+                tf.add(file, arcname=arcname)
+
+    # Compress with zstandard at level 22 (high compression, still fast decompress)
+    cctx = zstandard.ZstdCompressor(level=22, threads=-1)
+    with open(tar_path, "rb") as f_in, open(archive_path, "wb") as f_out:
+        cctx.copy_stream(f_in, f_out)
+
+    tar_path.unlink()  # Remove intermediate tar
+
+    print(f"  Archive size: {archive_path.stat().st_size / 1024 / 1024:.1f} MB")
+
+
+def trim_pyside6(lib_dir):
+    """Remove unused PySide6 modules to dramatically reduce distribution size.
+
+    FastFlix only uses QtCore, QtGui, QtWidgets (and QtSvg for icon rendering).
+    Uses a BLACKLIST approach: remove known-unnecessary large modules while
+    keeping all runtime DLL dependencies intact (pyside6.abi3.dll, VC runtime, etc.).
+    """
+    print("  Trimming unused PySide6 modules...")
+    pyside6_dir = lib_dir / "PySide6"
+    if not pyside6_dir.exists():
+        print("  WARNING: PySide6 directory not found")
+        return 0
+
+    removed_size = 0
+
+    # Large DLL modules to REMOVE (prefixes matched case-insensitively)
+    # These are Qt modules FastFlix does not use
+    remove_dll_prefixes = (
+        "Qt6WebEngine",  # Chromium browser engine (~193 MB)
+        "Qt6Quick",  # QML/Quick UI framework (~35 MB)
+        "Qt6Qml",  # QML engine (~12 MB)
+        "Qt6Designer",  # Qt Designer (~7 MB)
+        "Qt63D",  # 3D rendering (~8 MB)
+        "Qt6Pdf",  # PDF rendering (~6 MB)
+        "Qt6Multimedia",  # Multimedia playback (~2 MB)
+        "Qt6ShaderTools",  # Shader compilation
+        "Qt6Bluetooth",
+        "Qt6Charts",
+        "Qt6DataVisualization",
+        "Qt6Graphs",
+        "Qt6HttpServer",
+        "Qt6Location",
+        "Qt6Nfc",
+        "Qt6Positioning",
+        "Qt6RemoteObjects",
+        "Qt6Scxml",
+        "Qt6Sensors",
+        "Qt6SerialBus",
+        "Qt6SerialPort",
+        "Qt6SpatialAudio",
+        "Qt6StateMachine",
+        "Qt6TextToSpeech",
+        "Qt6WebChannel",
+        "Qt6WebSockets",
+        "Qt6WebView",
+    )
+
+    # .pyd Python bindings to REMOVE
+    remove_pyd_prefixes = (
+        "Qt3D",
+        "QtAxContainer",
+        "QtBluetooth",
+        "QtCharts",
+        "QtDataVisualization",
+        "QtDBus",
+        "QtDesigner",
+        "QtGraphs",
+        "QtHelp",
+        "QtHttpServer",
+        "QtLocation",
+        "QtMultimedia",
+        "QtNfc",
+        "QtOpenGL",
+        "QtPdf",
+        "QtPositioning",
+        "QtQml",
+        "QtQuick",
+        "QtRemoteObjects",
+        "QtScxml",
+        "QtSensors",
+        "QtSerialBus",
+        "QtSerialPort",
+        "QtSpatialAudio",
+        "QtSql",
+        "QtStateMachine",
+        "QtTest",
+        "QtTextToSpeech",
+        "QtUiTools",
+        "QtWebChannel",
+        "QtWebEngine",
+        "QtWebSockets",
+        "QtWebView",
+        "QtXml",
+    )
+
+    # Also remove the large software OpenGL renderer
+    remove_exact = {"opengl32sw.dll"}
+
+    for f in pyside6_dir.iterdir():
+        if not f.is_file():
+            continue
+        name = f.name
+        should_remove = False
+
+        if name in remove_exact:
+            should_remove = True
+        elif f.suffix.lower() == ".dll" and any(name.startswith(p) for p in remove_dll_prefixes):
+            should_remove = True
+        elif f.suffix.lower() == ".pyd" and any(name.startswith(p) for p in remove_pyd_prefixes):
+            should_remove = True
+
+        if should_remove:
+            removed_size += f.stat().st_size
+            f.unlink()
+
+    # Plugins: remove unused plugin directories
+    plugins_dir = pyside6_dir / "plugins"
+    if plugins_dir.exists():
+        keep_plugin_dirs = {"iconengines", "imageformats", "platforms", "styles", "tls", "networkinformation"}
+        for plugin_dir in list(plugins_dir.iterdir()):
+            if plugin_dir.is_dir() and plugin_dir.name not in keep_plugin_dirs:
+                size = sum(f.stat().st_size for f in plugin_dir.rglob("*") if f.is_file())
+                shutil.rmtree(plugin_dir, ignore_errors=True)
+                removed_size += size
+
+        # Remove PDF plugin from imageformats (not needed)
+        pdf_plugin = plugins_dir / "imageformats" / "qpdf.dll"
+        if pdf_plugin.exists():
+            removed_size += pdf_plugin.stat().st_size
+            pdf_plugin.unlink()
+
+    # Remove subdirectories that are not needed at runtime
+    for dirname in ("qml", "resources", "translations", "typesystems"):
+        d = pyside6_dir / dirname
+        if d.exists():
+            size = sum(f.stat().st_size for f in d.rglob("*") if f.is_file())
+            shutil.rmtree(d, ignore_errors=True)
+            removed_size += size
+
+    # Remove executables we don't need (designer, linguist, assistant, etc.)
+    for f in pyside6_dir.glob("*.exe"):
+        removed_size += f.stat().st_size
+        f.unlink()
+
+    print(f"  Removed {removed_size / 1024 / 1024:.1f} MB of unused PySide6 modules")
+    return removed_size
+
+
+def cleanup_dist(lib_dir):
+    """Remove unnecessary files from the distribution to reduce size."""
+    print("  Cleaning up distribution...")
+    removed_size = 0
+
+    patterns_to_remove = [
+        # Python cache files
+        "**/__pycache__",
+        # Test directories: only for known-safe packages (a blanket **/test* delete can break packages
+        # that import from a "test" module at runtime)
+        *[f"{pkg}/tests" for pkg in SAFE_TEST_DIR_PACKAGES],
+        # Documentation
+        "**/*.md",
+        "**/*.rst",
+        # NOTE: dist-info LICENSE/NOTICE/AUTHORS files and licenses/ dirs are intentionally kept
+        # (license compliance for redistributed third-party packages).
+        # Type stubs (not needed at runtime)
+        "**/*.pyi",
+        # Pip itself (not needed at runtime)
+        "pip",
+        "pip-*",
+    ]
+
+    for pattern in patterns_to_remove:
+        for path in lib_dir.glob(pattern):
+            if path.is_dir():
+                size = sum(f.stat().st_size for f in path.rglob("*") if f.is_file())
+                shutil.rmtree(path, ignore_errors=True)
+                removed_size += size
+            elif path.is_file():
+                removed_size += path.stat().st_size
+                path.unlink(missing_ok=True)
+
+    # Trim PySide6 (biggest win)
+    removed_size += trim_pyside6(lib_dir)
+
+    print(f"  Total removed: {removed_size / 1024 / 1024:.1f} MB")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Build FastFlix distribution")
+    parser.add_argument("--python-version", default=DEFAULT_PYTHON_VERSION, help="Python version to embed")
+    parser.add_argument("--arch", default=None, help="Architecture: amd64 or arm64")
+    parser.add_argument("--output", default=None, help="Output directory")
+    parser.add_argument("--archive", action="store_true", help="Create tar.zst archive for installer embedding")
+    parser.add_argument(
+        "--installer", action="store_true", help="Also build dist/FastFlix_installer.exe (implies --archive)"
+    )
+    parser.add_argument("--skip-download", action="store_true", help="Use cached downloads only")
+    args = parser.parse_args()
+
+    arch = args.arch or detect_arch()
+    if arch not in ("amd64", "arm64"):
+        parser.error("--arch must be amd64 or arm64")
+    if args.installer:
+        args.archive = True
+    output_dir = Path(args.output) if args.output else PROJECT_ROOT / "dist" / "FastFlix"
+
+    print("Building FastFlix distribution")
+    print(f"  Python: {args.python_version}")
+    print(f"  Architecture: {arch}")
+    print(f"  Output: {output_dir}")
+    print()
+
+    # Clean output directory
+    if output_dir.exists():
+        print("Cleaning previous build...")
+        shutil.rmtree(output_dir)
+
+    python_dir = output_dir / "python"
+    lib_dir = output_dir / "lib"
+
+    # Step 1: Download embeddable Python
+    print("[1/6] Downloading embeddable Python...")
+    python_zip = CACHE_DIR / f"python-{args.python_version}-embed-{arch}.zip"
+    if not python_zip.exists() and not args.skip_download:
+        download_file(get_python_url(args.python_version, arch), python_zip)
+    elif not python_zip.exists():
+        print(f"  ERROR: {python_zip} not found and --skip-download is set")
+        sys.exit(1)
+    else:
+        print(f"  Using cached {python_zip.name}")
+
+    # Step 2: Extract Python
+    print("[2/6] Extracting Python...")
+    extract_python(python_zip, python_dir)
+
+    # Step 3: Configure ._pth file
+    print("[3/6] Configuring Python path...")
+    configure_pth_file(python_dir)
+
+    # Step 4: Bootstrap pip
+    print("[4/6] (pip bootstrap not needed)")
+
+    # Step 5: Install dependencies
+    print("[5/6] Installing FastFlix and dependencies...")
+    install_dependencies(lib_dir, PROJECT_ROOT, args.python_version, arch)
+
+    # Step 6: Build Go launcher
+    print("[6/7] Building Go launcher...")
+    build_go_launcher(output_dir)
+
+    # Step 7: Finalize
+    print("[7/7] Finalizing distribution...")
+    copy_data_files(output_dir, PROJECT_ROOT)
+    cleanup_dist(lib_dir)
+
+    # Calculate total size
+    total_size = sum(f.stat().st_size for f in output_dir.rglob("*") if f.is_file())
+    print(f"\nDistribution complete: {total_size / 1024 / 1024:.1f} MB total")
+    print(f"Output: {output_dir}")
+
+    # Optionally create archive for installer embedding
+    if args.archive:
+        print("Preparing installer resources...")
+        prepare_installer_resources()
+        archive_path = PROJECT_ROOT / "cmd" / "installer" / "fastflix_dist.tar.zst"
+        create_dist_archive(output_dir, archive_path)
+
+    if args.installer:
+        print("Building installer...")
+        build_go_installer(PROJECT_ROOT / "dist" / "FastFlix_installer.exe")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/e2e/__init__.py b/tests/e2e/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/e2e/conftest.py b/tests/e2e/conftest.py
new file mode 100644
index 00000000..fa242d2c
--- /dev/null
+++ b/tests/e2e/conftest.py
@@ -0,0 +1,703 @@
+# -*- coding: utf-8 -*-
+"""
+Shared infrastructure for E2E encode tests.
+
+These tests build real FastFlix instances, run real FFmpeg/Rigaya encodes,
+and verify output with ffprobe. They are local-only and skip on CI.
+
+Environment variables:
+    CI=true         Skip all E2E tests
+    SKIP_NVIDIA=1   Skip NVEncC + FFmpeg NVENC encoders
+    SKIP_INTEL=1    Skip QSVEncC encoders
+    SKIP_AMD=1      Skip VCEEncC encoders
+"""
+
+import json
+import os
+import shutil
+import subprocess
+from functools import lru_cache
+from pathlib import Path
+from typing import Optional
+
+import pytest
+from box import Box
+from platformdirs import user_data_dir
+
+from fastflix.flix import guess_bit_depth
+from fastflix.models.config import Config
+from fastflix.models.encode import (
+    AOMAV1Settings,
+    AttachmentTrack,
+    AudioTrack,
+    CopySettings,
+    DataTrack,
+    FFmpegAV1NVENCSettings,
+    SubtitleTrack,
+    FFmpegNVENCSettings,
+    GIFSettings,
+    GifskiSettings,
+    NVEncCAV1Settings,
+    NVEncCAVCSettings,
+    NVEncCSettings,
+    QSVEncCAV1Settings,
+    QSVEncCH264Settings,
+    QSVEncCSettings,
+    SVTAV1Settings,
+    SVTAVIFSettings,
+    VCEEncCAV1Settings,
+    H264VideoToolboxSettings,
+    HEVCVideoToolboxSettings,
+    VCEEncCAVCSettings,
+    VCEEncCSettings,
+    VP9Settings,
+    VVCSettings,
+    WebPSettings,
+    rav1eSettings,
+    x264Settings,
+    x265Settings,
+)
+from fastflix.models.fastflix import FastFlix
+from fastflix.models.video import Video, VideoSettings
+from fastflix.widgets.panels.data_panel import NO_ATTACHMENT_EXTENSIONS, NO_DATA_EXTENSIONS
+
+# ---------------------------------------------------------------------------
+# CI / hardware skip flags
+# ---------------------------------------------------------------------------
+ON_CI = os.environ.get("CI", "").lower() in ("true", "1", "yes")
+SKIP_NVIDIA = os.environ.get("SKIP_NVIDIA", "").lower() in ("1", "true", "yes")
+SKIP_INTEL = os.environ.get("SKIP_INTEL", "").lower() in ("1", "true", "yes")
+SKIP_AMD = os.environ.get("SKIP_AMD", "").lower() in ("1", "true", "yes")
+SKIP_MAC = os.environ.get("SKIP_MAC", "").lower() in ("1", "true", "yes")
+
+# ---------------------------------------------------------------------------
+# Tool detection
+# ---------------------------------------------------------------------------
+FFMPEG = shutil.which("ffmpeg")
+FFPROBE = shutil.which("ffprobe")
+
+
+def _find_rigaya(app_name: str, binary_base: str) -> Optional[str]:
+    for name in (f"{binary_base}64", binary_base):
+        found = shutil.which(name)
+        if found:
+            return found
+    asset_folder = Path(user_data_dir(app_name, appauthor=False, roaming=True))
+    if asset_folder.exists():
+        for exe in asset_folder.glob(f"{binary_base}*64.exe"):
+            if exe.is_file():
+                return str(exe)
+        for exe in asset_folder.glob(f"{binary_base}*.exe"):
+            if exe.is_file():
+                return str(exe)
+    return None
+
+
+NVENCC = _find_rigaya("NVEnc", "NVEncC")
+QSVENCC = _find_rigaya("QSVEnc", "QSVEncC")
+VCEENCC = _find_rigaya("VCEEnc", "VCEEncC")
+GIFSKI = shutil.which("gifski")
+
+
+def _get_ffmpeg_encoders() -> set[str]:
+    if not FFMPEG:
+        return set()
+    try:
+        result = subprocess.run(
+            [FFMPEG, "-encoders", "-hide_banner"],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        encoders = set()
+        for line in result.stdout.splitlines():
+            parts = line.strip().split()
+            if len(parts) >= 2 and len(parts[0]) == 6:
+                encoders.add(parts[1])
+        return encoders
+    except Exception:
+        return set()
+
+
+_ffmpeg_encoders = _get_ffmpeg_encoders()
+
+
+def has_ffmpeg_encoder(name: str) -> bool:
+    return name in _ffmpeg_encoders
+
+
+# ---------------------------------------------------------------------------
+# Source files
+# ---------------------------------------------------------------------------
+MEDIA_DIR = Path(__file__).parent.parent / "media"
+
+SOURCES = {
+    "hdr10plus": MEDIA_DIR / "Beverly Hills Duck Pond - HDR10plus - Jessica Payne.mp4",
+    "attachments": MEDIA_DIR / "font_attachment_data.mkv",
+    "chapters": MEDIA_DIR / "chapters_timecode.mp4",
+}
+
+
+# ---------------------------------------------------------------------------
+# Probe helper (cached)
+# ---------------------------------------------------------------------------
+@lru_cache(maxsize=8)
+def probe_source(source_path: str) -> Optional[dict]:
+    if not FFPROBE or not Path(source_path).exists():
+        return None
+    try:
+        result = subprocess.run(
+            [FFPROBE, "-v", "quiet", "-print_format", "json", "-show_streams", "-show_format", source_path],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        return json.loads(result.stdout)
+    except Exception:
+        return None
+
+
+# ---------------------------------------------------------------------------
+# FastFlix builder
+# ---------------------------------------------------------------------------
+def create_fastflix(
+    source_path: Path,
+    encoder_settings,
+    output_path: Path,
+    work_path: Path,
+    is_rigaya: bool = False,
+    include_audio: bool = True,
+    include_subtitles: bool = False,
+    include_data: bool = True,
+    include_attachments: bool = True,
+) -> FastFlix:
+    """Build a real FastFlix instance with tracks from the probed source."""
+    probe = probe_source(str(source_path))
+    assert probe is not None, f"Could not probe {source_path}"
+
+    ext_with_dot = output_path.suffix.lower()
+
+    # Parse streams by type
+    video_streams = [
+        s
+        for s in probe["streams"]
+        if s["codec_type"] == "video" and s.get("disposition", {}).get("attached_pic", 0) == 0
+    ]
+    audio_streams = [s for s in probe["streams"] if s["codec_type"] == "audio"]
+    subtitle_streams = [s for s in probe["streams"] if s["codec_type"] == "subtitle"]
+    data_streams = [s for s in probe["streams"] if s["codec_type"] == "data"]
+    attachment_streams = [s for s in probe["streams"] if s.get("codec_type") == "attachment"]
+
+    # Cover images are video streams with attached_pic disposition
+    cover_streams = [
+        s
+        for s in probe["streams"]
+        if s["codec_type"] == "video" and s.get("disposition", {}).get("attached_pic", 0) == 1
+    ]
+
+    for stream in video_streams:
+        if "bits_per_raw_sample" in stream:
+            stream["bit_depth"] = int(stream["bits_per_raw_sample"])
+        else:
+            stream["bit_depth"] = guess_bit_depth(stream.get("pix_fmt", ""), stream.get("color_primaries"))
+
+    streams = Box(
+        {
+            "video": [Box(v) for v in video_streams],
+            "audio": [Box(a) for a in audio_streams],
+            "subtitle": [Box(s) for s in subtitle_streams],
+            "data": [Box(d) for d in data_streams],
+            "attachment": [Box(a) for a in attachment_streams],
+        }
+    )
+
+    video_settings = VideoSettings(
+        remove_hdr=False,
+        output_path=output_path,
+        end_time=2,
+    )
+    video_settings.video_encoder_settings = encoder_settings
+
+    video = Video(
+        source=source_path,
+        duration=float(probe.get("format", {}).get("duration", 10)),
+        streams=streams,
+        format=Box(probe.get("format", {})),
+        video_settings=video_settings,
+        work_path=work_path,
+    )
+
+    # --- Audio tracks ---
+    if include_audio:
+        outdex = 1  # after video
+        for stream in audio_streams:
+            video.audio_tracks.append(
+                AudioTrack(
+                    index=stream["index"],
+                    outdex=outdex,
+                    codec=stream.get("codec_name", ""),
+                    enabled=True,
+                    raw_info=Box(stream),
+                )
+            )
+            outdex += 1
+
+    # --- Subtitle tracks ---
+    if include_subtitles:
+        sub_outdex = 1 + len(video.audio_tracks)
+        for stream in subtitle_streams:
+            dispositions = {k: bool(v) for k, v in stream.get("disposition", {}).items()}
+            video.subtitle_tracks.append(
+                SubtitleTrack(
+                    index=stream["index"],
+                    outdex=sub_outdex,
+                    language=stream.get("tags", {}).get("language", ""),
+                    title=stream.get("tags", {}).get("title", ""),
+                    subtitle_type=stream.get("codec_name", "text"),
+                    enabled=True,
+                    dispositions=dispositions,
+                    raw_info=Box(stream),
+                )
+            )
+            sub_outdex += 1
+
+    # --- Data / attachment tracks ---
+    data_outdex = 1 + len(video.audio_tracks) + len(video.subtitle_tracks)
+
+    if include_data:
+        for stream in data_streams:
+            codec_name = stream.get("codec_name", "")
+            title = stream.get("tags", {}).get("title", "")
+            enabled = ext_with_dot not in NO_DATA_EXTENSIONS
+            video.data_tracks.append(
+                DataTrack(
+                    index=stream["index"],
+                    outdex=data_outdex if enabled else 0,
+                    enabled=enabled,
+                    codec_name=codec_name,
+                    codec_type="data",
+                    title=title,
+                )
+            )
+            if enabled:
+                data_outdex += 1
+
+        for stream in attachment_streams:
+            mimetype = stream.get("tags", {}).get("mimetype", "")
+            filename = stream.get("tags", {}).get("filename", "")
+            # Skip cover images (handled separately)
+            if mimetype.startswith("image"):
+                continue
+            enabled = ext_with_dot not in NO_ATTACHMENT_EXTENSIONS
+            video.data_tracks.append(
+                DataTrack(
+                    index=stream["index"],
+                    outdex=data_outdex if enabled else 0,
+                    enabled=enabled,
+                    codec_name=stream.get("codec_name", ""),
+                    codec_type="attachment",
+                    mimetype=mimetype,
+                    filename=filename,
+                )
+            )
+            if enabled:
+                data_outdex += 1
+
+    # --- Cover attachment (extract from source if present) ---
+    if include_attachments and cover_streams:
+        cover_stream = cover_streams[0]
+        cover_ext = "png" if "png" in cover_stream.get("codec_name", "") else "jpg"
+        cover_path = work_path / f"cover.{cover_ext}"
+        subprocess.run(
+            [FFMPEG, "-y", "-i", str(source_path), "-map", f"0:{cover_stream['index']}", "-c", "copy", str(cover_path)],
+            capture_output=True,
+            timeout=30,
+        )
+        if cover_path.exists():
+            video.attachment_tracks.append(
+                AttachmentTrack(
+                    index=cover_stream["index"],
+                    outdex=data_outdex,
+                    file_path=str(cover_path),
+                    filename="cover",
+                    attachment_type="cover",
+                )
+            )
+
+    # --- Config ---
+    config = Config(
+        version="4.0.0",
+        ffmpeg=Path(FFMPEG),
+        ffprobe=Path(FFPROBE),
+        work_path=work_path,
+    )
+    if is_rigaya:
+        if NVENCC:
+            config.nvencc = Path(NVENCC)
+        if QSVENCC:
+            config.qsvencc = Path(QSVENCC)
+        if VCEENCC:
+            config.vceencc = Path(VCEENCC)
+    if GIFSKI:
+        config.gifski = Path(GIFSKI)
+
+    return FastFlix(
+        config=config,
+        encoders={},
+        audio_encoders=[],
+        current_video=video,
+        ffmpeg_version="n5.0",
+    )
+
+
+# ---------------------------------------------------------------------------
+# Command runner
+# ---------------------------------------------------------------------------
+def run_commands(commands, work_path: Path):
+    for cmd in commands:
+        cmd_to_run = cmd.to_string() if cmd.shell else cmd.to_list()
+        result = subprocess.run(
+            cmd_to_run,
+            capture_output=True,
+            text=True,
+            timeout=120,
+            shell=cmd.shell,
+            cwd=str(work_path),
+        )
+        assert result.returncode == 0, (
+            f"Command '{cmd.name}' failed (exit {result.returncode}):\n"
+            f"CMD: {cmd.to_string()}\n"
+            f"STDERR: {result.stderr[-2000:]}"
+        )
+
+
+# ---------------------------------------------------------------------------
+# Output verifier
+# ---------------------------------------------------------------------------
+def verify_output(output_path: Path, expected_codec: str) -> dict:
+    assert output_path.exists(), f"Output file does not exist: {output_path}"
+    assert output_path.stat().st_size > 0, f"Output file is empty: {output_path}"
+
+    result = subprocess.run(
+        [FFPROBE, "-v", "quiet", "-print_format", "json", "-show_streams", "-show_format", str(output_path)],
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    assert result.returncode == 0, f"ffprobe failed: {result.stderr}"
+
+    data = json.loads(result.stdout)
+    video_streams = [
+        s
+        for s in data["streams"]
+        if s["codec_type"] == "video" and s.get("disposition", {}).get("attached_pic", 0) == 0
+    ]
+    assert len(video_streams) >= 1, "No video stream in output"
+    actual_codec = video_streams[0]["codec_name"]
+    assert actual_codec == expected_codec, f"Expected codec {expected_codec}, got {actual_codec}"
+    return data
+
+
+def verify_lossless_quality(source_path: Path, output_path: Path, end_time: float = 2):
+    """Verify lossless encode by comparing per-frame MD5 checksums.
+
+    Decodes both the source (trimmed to end_time) and the lossless output to raw
+    video frames and computes MD5 per frame. Every frame MD5 must match, proving
+    the encoder preserved pixels exactly with zero quality loss.
+    """
+    source_result = subprocess.run(
+        [FFMPEG, "-to", str(end_time), "-i", str(source_path), "-map", "0:v", "-f", "framemd5", "-"],
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+    assert source_result.returncode == 0, f"framemd5 on source failed: {source_result.stderr[-1000:]}"
+
+    output_result = subprocess.run(
+        [FFMPEG, "-i", str(output_path), "-map", "0:v", "-f", "framemd5", "-"],
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+    assert output_result.returncode == 0, f"framemd5 on output failed: {output_result.stderr[-1000:]}"
+
+    # Parse frame lines (skip comment lines starting with #)
+    source_frames = [line for line in source_result.stdout.splitlines() if line and not line.startswith("#")]
+    output_frames = [line for line in output_result.stdout.splitlines() if line and not line.startswith("#")]
+
+    assert len(source_frames) > 0, "No frames decoded from source"
+    assert len(output_frames) > 0, "No frames decoded from output"
+    assert len(source_frames) == len(output_frames), (
+        f"Frame count mismatch: source={len(source_frames)}, output={len(output_frames)}"
+    )
+
+    # Extract MD5 hashes (last field in each framemd5 line)
+    mismatched = []
+    for i, (src_line, out_line) in enumerate(zip(source_frames, output_frames)):
+        src_md5 = src_line.split(",")[-1].strip()
+        out_md5 = out_line.split(",")[-1].strip()
+        if src_md5 != out_md5:
+            mismatched.append(f"Frame {i}: source={src_md5} output={out_md5}")
+
+    assert not mismatched, (
+        f"Lossless verification failed — {len(mismatched)}/{len(source_frames)} frames differ:\n"
+        + "\n".join(mismatched[:10])
+    )
+
+
+# ---------------------------------------------------------------------------
+# Encoder definitions
+# ---------------------------------------------------------------------------
+def _skip_if(*conditions):
+    """Return True if ANY condition is True (meaning test should skip)."""
+    return lambda: any(c() if callable(c) else c for c in conditions)
+
+
+# (encoder_id, settings, output_ext, expected_codec, skip_condition, is_rigaya)
+FFMPEG_ENCODERS = [
+    (
+        "hevc_x265",
+        x265Settings(preset="ultrafast", crf=51),
+        ".mkv",
+        "hevc",
+        lambda: not has_ffmpeg_encoder("libx265"),
+        False,
+    ),
+    (
+        "avc_x264",
+        x264Settings(preset="ultrafast", crf=51, pix_fmt="yuv420p"),
+        ".mkv",
+        "h264",
+        lambda: not has_ffmpeg_encoder("libx264"),
+        False,
+    ),
+    ("svt_av1", SVTAV1Settings(speed="13", qp=63), ".mkv", "av1", lambda: not has_ffmpeg_encoder("libsvtav1"), False),
+    (
+        "av1_aom",
+        AOMAV1Settings(cpu_used="8", usage="realtime", crf=63),
+        ".mkv",
+        "av1",
+        lambda: not has_ffmpeg_encoder("libaom-av1"),
+        False,
+    ),
+    ("rav1e", rav1eSettings(speed="10", qp=255), ".mkv", "av1", lambda: not has_ffmpeg_encoder("librav1e"), False),
+    (
+        "vp9",
+        VP9Settings(speed="5", quality="realtime", crf=63, single_pass=True),
+        ".mkv",
+        "vp9",
+        lambda: not has_ffmpeg_encoder("libvpx-vp9"),
+        False,
+    ),
+    ("vvc", VVCSettings(preset="faster", qp=51), ".mkv", "vvc", lambda: not has_ffmpeg_encoder("libvvenc"), False),
+    ("copy", CopySettings(), ".mkv", "h264", lambda: False, False),
+]
+
+NVIDIA_ENCODERS = [
+    (
+        "ffmpeg_hevc_nvenc",
+        FFmpegNVENCSettings(preset="p1", bitrate="1000k"),
+        ".mkv",
+        "hevc",
+        _skip_if(lambda: not has_ffmpeg_encoder("hevc_nvenc"), lambda: SKIP_NVIDIA),
+        False,
+    ),
+    (
+        "ffmpeg_av1_nvenc",
+        FFmpegAV1NVENCSettings(preset="p1", bitrate="1000k"),
+        ".mkv",
+        "av1",
+        _skip_if(lambda: not has_ffmpeg_encoder("av1_nvenc"), lambda: SKIP_NVIDIA),
+        False,
+    ),
+    (
+        "nvencc_hevc",
+        NVEncCSettings(preset="performance", bitrate="1000k"),
+        ".mkv",
+        "hevc",
+        _skip_if(lambda: not NVENCC, lambda: SKIP_NVIDIA),
+        True,
+    ),
+    (
+        "nvencc_avc",
+        NVEncCAVCSettings(preset="performance", bitrate="1000k"),
+        ".mkv",
+        "h264",
+        _skip_if(lambda: not NVENCC, lambda: SKIP_NVIDIA),
+        True,
+    ),
+    (
+        "nvencc_av1",
+        NVEncCAV1Settings(preset="performance", bitrate="1000k"),
+        ".mkv",
+        "av1",
+        _skip_if(lambda: not NVENCC, lambda: SKIP_NVIDIA),
+        True,
+    ),
+]
+
+INTEL_ENCODERS = [
+    (
+        "qsvencc_hevc",
+        QSVEncCSettings(preset="fastest", bitrate="1000k"),
+        ".mkv",
+        "hevc",
+        _skip_if(lambda: not QSVENCC, lambda: SKIP_INTEL),
+        True,
+    ),
+    (
+        "qsvencc_avc",
+        QSVEncCH264Settings(preset="fastest", bitrate="1000k"),
+        ".mkv",
+        "h264",
+        _skip_if(lambda: not QSVENCC, lambda: SKIP_INTEL),
+        True,
+    ),
+    (
+        "qsvencc_av1",
+        QSVEncCAV1Settings(preset="fastest", bitrate="1000k"),
+        ".mkv",
+        "av1",
+        _skip_if(lambda: not QSVENCC, lambda: SKIP_INTEL),
+        True,
+    ),
+]
+
+AMD_ENCODERS = [
+    (
+        "vceencc_hevc",
+        VCEEncCSettings(preset="fast", bitrate="1000k"),
+        ".mkv",
+        "hevc",
+        _skip_if(lambda: not VCEENCC, lambda: SKIP_AMD),
+        True,
+    ),
+    (
+        "vceencc_avc",
+        VCEEncCAVCSettings(preset="fast", bitrate="1000k"),
+        ".mkv",
+        "h264",
+        _skip_if(lambda: not VCEENCC, lambda: SKIP_AMD),
+        True,
+    ),
+    (
+        "vceencc_av1",
+        VCEEncCAV1Settings(preset="fast", bitrate="1000k"),
+        ".mkv",
+        "av1",
+        _skip_if(lambda: not VCEENCC, lambda: SKIP_AMD),
+        True,
+    ),
+]
+
+GIF_ENCODERS = [
+    ("gif", GIFSettings(fps="5"), ".gif", "gif", lambda: False, False),
+    ("gifski", GifskiSettings(fps="5", fast=True, quality="1"), ".gif", "gif", lambda: not GIFSKI, False),
+    (
+        "webp",
+        WebPSettings(compression="0", qscale=1),
+        ".webp",
+        "webp",
+        lambda: not has_ffmpeg_encoder("libwebp"),
+        False,
+    ),
+    (
+        "svt_av1_avif",
+        SVTAVIFSettings(speed="13", qp=63),
+        ".avif",
+        "av1",
+        lambda: not has_ffmpeg_encoder("libsvtav1"),
+        False,
+    ),
+]
+
+LOSSLESS_ENCODERS = [
+    (
+        "hevc_x265",
+        x265Settings(preset="ultrafast", lossless=True),
+        ".mkv",
+        "hevc",
+        lambda: not has_ffmpeg_encoder("libx265"),
+        False,
+    ),
+    (
+        "avc_x264",
+        x264Settings(preset="ultrafast", lossless=True, pix_fmt="yuv420p10le"),
+        ".mkv",
+        "h264",
+        lambda: not has_ffmpeg_encoder("libx264"),
+        False,
+    ),
+    (
+        "av1_aom",
+        AOMAV1Settings(cpu_used="8", usage="realtime", lossless=True),
+        ".mkv",
+        "av1",
+        lambda: not has_ffmpeg_encoder("libaom-av1"),
+        False,
+    ),
+    (
+        "vp9",
+        VP9Settings(speed="5", quality="realtime", lossless=True, single_pass=True),
+        ".mkv",
+        "vp9",
+        lambda: not has_ffmpeg_encoder("libvpx-vp9"),
+        False,
+    ),
+    (
+        "svt_av1",
+        SVTAV1Settings(speed="13", lossless=True),
+        ".mkv",
+        "av1",
+        lambda: not has_ffmpeg_encoder("libsvtav1"),
+        False,
+    ),
+    (
+        "webp",
+        WebPSettings(lossless="yes", compression="0"),
+        ".webp",
+        "webp",
+        lambda: not has_ffmpeg_encoder("libwebp"),
+        False,
+    ),
+]
+
+MAC_ENCODERS = [
+    (
+        "hevc_videotoolbox",
+        HEVCVideoToolboxSettings(q=50),
+        ".mp4",
+        "hevc",
+        _skip_if(lambda: not has_ffmpeg_encoder("hevc_videotoolbox"), lambda: SKIP_MAC),
+        False,
+    ),
+    (
+        "h264_videotoolbox",
+        H264VideoToolboxSettings(q=50),
+        ".mp4",
+        "h264",
+        _skip_if(lambda: not has_ffmpeg_encoder("h264_videotoolbox"), lambda: SKIP_MAC),
+        False,
+    ),
+]
+
+ALL_ENCODERS = FFMPEG_ENCODERS + NVIDIA_ENCODERS + INTEL_ENCODERS + AMD_ENCODERS + MAC_ENCODERS + GIF_ENCODERS
+
+# Encoders that support audio/subtitles/data/attachments (not GIF/image formats)
+FULL_FEATURE_ENCODERS = FFMPEG_ENCODERS + NVIDIA_ENCODERS + INTEL_ENCODERS + AMD_ENCODERS + MAC_ENCODERS
+
+
+def make_params(encoder_list):
+    """Convert encoder tuples into pytest.param entries with proper skip marks."""
+    return [
+        pytest.param(
+            enc_id,
+            settings,
+            ext,
+            codec,
+            is_rigaya,
+            id=enc_id,
+            marks=pytest.mark.skipif(skip_fn(), reason=f"{enc_id}: required tool not available"),
+        )
+        for enc_id, settings, ext, codec, skip_fn, is_rigaya in encoder_list
+    ]
diff --git a/tests/e2e/lossless_investigation.py b/tests/e2e/lossless_investigation.py
new file mode 100644
index 00000000..473e8c0c
--- /dev/null
+++ b/tests/e2e/lossless_investigation.py
@@ -0,0 +1,352 @@
+#!/usr/bin/env python
+"""
+Investigation script: verify which encoders produce truly bit-exact lossless output.
+
+Run: uv run python tests/e2e/test_lossless_investigation.py
+"""
+
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+FFMPEG = shutil.which("ffmpeg")
+FFPROBE = shutil.which("ffprobe")
+MEDIA_DIR = Path(__file__).parent.parent / "media"
+HDR_SOURCE = MEDIA_DIR / "Beverly Hills Duck Pond - HDR10plus - Jessica Payne.mp4"
+
+
+def run(cmd, timeout=120):
+    return subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+
+
+def get_pix_fmt(path):
+    r = run([FFPROBE, "-v", "quiet", "-show_entries", "stream=pix_fmt", "-of", "csv=p=0", str(path)])
+    return r.stdout.strip().split("\n")[0].strip().rstrip(",")
+
+
+def get_framemd5(path, pix_fmt=None, to=None):
+    cmd = [FFMPEG]
+    if to:
+        cmd += ["-to", str(to)]
+    cmd += ["-i", str(path), "-map", "0:v"]
+    if pix_fmt:
+        cmd += ["-pix_fmt", pix_fmt]
+    cmd += ["-f", "framemd5", "-"]
+    r = run(cmd)
+    return [line for line in r.stdout.splitlines() if line and not line.startswith("#")]
+
+
+def get_psnr(path1, path2, to1=None, to2=None):
+    cmd = [FFMPEG]
+    if to1:
+        cmd += ["-to", str(to1)]
+    cmd += ["-i", str(path1)]
+    if to2:
+        cmd += ["-to", str(to2)]
+    cmd += ["-i", str(path2), "-lavfi", "[0:v][1:v]psnr", "-f", "null", "-"]
+    r = run(cmd)
+    for line in r.stderr.splitlines():
+        if "average:" in line and "PSNR" in line:
+            return line
+    return f"PSNR not found in: {r.stderr[-500:]}"
+
+
+def compare_framemd5(frames_a, frames_b):
+    if len(frames_a) != len(frames_b):
+        return f"Frame count mismatch: {len(frames_a)} vs {len(frames_b)}"
+    mismatched = 0
+    for a, b in zip(frames_a, frames_b):
+        md5_a = a.split(",")[-1].strip()
+        md5_b = b.split(",")[-1].strip()
+        if md5_a != md5_b:
+            mismatched += 1
+    if mismatched == 0:
+        return "EXACT MATCH (all frames identical)"
+    return f"MISMATCH: {mismatched}/{len(frames_a)} frames differ"
+
+
+def test_encoder(name, encode_cmd, source, tmp_dir, end_time=2):
+    """Test a single encoder's lossless mode."""
+    output = tmp_dir / f"lossless_{name}.mkv"
+    cmd = [FFMPEG, "-y", "-to", str(end_time), "-i", str(source)] + encode_cmd + [str(output)]
+    r = run(cmd)
+    if r.returncode != 0:
+        return {"status": "ENCODE FAILED", "error": r.stderr[-500:]}
+
+    src_fmt = get_pix_fmt(source)
+    out_fmt = get_pix_fmt(output)
+
+    results = {
+        "status": "OK",
+        "source_pix_fmt": src_fmt,
+        "output_pix_fmt": out_fmt,
+    }
+
+    # Test 1: Direct framemd5 comparison (native pixel formats)
+    src_frames = get_framemd5(source, to=end_time)
+    out_frames = get_framemd5(output)
+    results["native_comparison"] = compare_framemd5(src_frames, out_frames)
+
+    # Test 2: Force both to same pix_fmt (source's format)
+    src_frames_forced = get_framemd5(source, pix_fmt=src_fmt, to=end_time)
+    out_frames_forced = get_framemd5(output, pix_fmt=src_fmt)
+    results["forced_src_fmt"] = compare_framemd5(src_frames_forced, out_frames_forced)
+
+    # Test 3: Force both to output's pix_fmt
+    if src_fmt != out_fmt:
+        src_frames_out_fmt = get_framemd5(source, pix_fmt=out_fmt, to=end_time)
+        out_frames_out_fmt = get_framemd5(output, pix_fmt=out_fmt)
+        results["forced_out_fmt"] = compare_framemd5(src_frames_out_fmt, out_frames_out_fmt)
+
+    # Test 4: Round-trip (re-encode output losslessly, compare decoded frames)
+    reencoded = tmp_dir / f"reencoded_{name}.mkv"
+    re_cmd = [FFMPEG, "-y", "-i", str(output)] + encode_cmd + [str(reencoded)]
+    r2 = run(re_cmd)
+    if r2.returncode == 0:
+        out1_frames = get_framemd5(output)
+        out2_frames = get_framemd5(reencoded)
+        results["round_trip"] = compare_framemd5(out1_frames, out2_frames)
+    else:
+        results["round_trip"] = f"RE-ENCODE FAILED: {r2.stderr[-200:]}"
+
+    # Test 5: PSNR (for reference)
+    psnr_line = get_psnr(source, output, to1=end_time)
+    results["psnr"] = psnr_line.strip() if psnr_line else "N/A"
+
+    return results
+
+
+def main():
+    tmp_dir = Path(tempfile.mkdtemp())
+    print(f"Working in: {tmp_dir}\n")
+
+    # Create a simple synthetic 8-bit test source (avoids HDR/color issues)
+    synth_source = tmp_dir / "synth.mkv"
+    run(
+        [
+            FFMPEG,
+            "-y",
+            "-f",
+            "lavfi",
+            "-i",
+            "testsrc=duration=1:size=320x240:rate=10",
+            "-pix_fmt",
+            "yuv420p",
+            str(synth_source),
+        ]
+    )
+    synth_fmt = get_pix_fmt(synth_source)
+
+    # Define all lossless encoder configurations to test
+    encoders = {
+        # (name, encode_args, source, end_time)
+        "x265_synth": (
+            ["-map", "0:v", "-c:v", "libx265", "-x265-params", "lossless=1", "-preset", "ultrafast", "-an"],
+            synth_source,
+            1,
+        ),
+        "x264_synth": (
+            ["-map", "0:v", "-c:v", "libx264", "-x264-params", "lossless=1", "-preset", "ultrafast", "-an"],
+            synth_source,
+            1,
+        ),
+        "vp9_synth": (
+            ["-map", "0:v", "-c:v", "libvpx-vp9", "-lossless", "1", "-an"],
+            synth_source,
+            1,
+        ),
+        "aom_synth": (
+            ["-map", "0:v", "-c:v", "libaom-av1", "-lossless", "1", "-cpu-used", "8", "-an"],
+            synth_source,
+            1,
+        ),
+        "aom_synth_usage_good": (
+            ["-map", "0:v", "-c:v", "libaom-av1", "-lossless", "1", "-cpu-used", "8", "-usage", "good", "-an"],
+            synth_source,
+            1,
+        ),
+        "aom_synth_via_params": (
+            ["-map", "0:v", "-c:v", "libaom-av1", "-aom-params", "lossless=1", "-cpu-used", "8", "-an"],
+            synth_source,
+            1,
+        ),
+        "svt_synth": (
+            ["-map", "0:v", "-c:v", "libsvtav1", "-svtav1-params", "lossless=1", "-preset", "13", "-an"],
+            synth_source,
+            1,
+        ),
+    }
+
+    # Also test with the real HDR10+ source if available
+    if HDR_SOURCE.exists():
+        hdr_fmt = get_pix_fmt(HDR_SOURCE)
+        print(f"HDR source pixel format: {hdr_fmt}\n")
+        encoders.update(
+            {
+                "x265_hdr": (
+                    [
+                        "-map",
+                        "0:v",
+                        "-c:v",
+                        "libx265",
+                        "-pix_fmt",
+                        "yuv420p10le",
+                        "-x265-params",
+                        "lossless=1",
+                        "-preset",
+                        "ultrafast",
+                        "-an",
+                    ],
+                    HDR_SOURCE,
+                    2,
+                ),
+                "x264_hdr_10bit": (
+                    [
+                        "-map",
+                        "0:v",
+                        "-c:v",
+                        "libx264",
+                        "-pix_fmt",
+                        "yuv420p10le",
+                        "-x264-params",
+                        "lossless=1",
+                        "-preset",
+                        "ultrafast",
+                        "-an",
+                    ],
+                    HDR_SOURCE,
+                    2,
+                ),
+                "x264_hdr_8bit": (
+                    [
+                        "-map",
+                        "0:v",
+                        "-c:v",
+                        "libx264",
+                        "-pix_fmt",
+                        "yuv420p",
+                        "-x264-params",
+                        "lossless=1",
+                        "-preset",
+                        "ultrafast",
+                        "-an",
+                    ],
+                    HDR_SOURCE,
+                    2,
+                ),
+                "vp9_hdr": (
+                    ["-map", "0:v", "-c:v", "libvpx-vp9", "-pix_fmt", "yuv420p10le", "-lossless", "1", "-an"],
+                    HDR_SOURCE,
+                    2,
+                ),
+                "aom_hdr": (
+                    [
+                        "-map",
+                        "0:v",
+                        "-c:v",
+                        "libaom-av1",
+                        "-pix_fmt",
+                        "yuv420p10le",
+                        "-lossless",
+                        "1",
+                        "-cpu-used",
+                        "8",
+                        "-an",
+                    ],
+                    HDR_SOURCE,
+                    2,
+                ),
+                "aom_hdr_no_crf": (
+                    [
+                        "-map",
+                        "0:v",
+                        "-c:v",
+                        "libaom-av1",
+                        "-pix_fmt",
+                        "yuv420p10le",
+                        "-lossless",
+                        "1",
+                        "-cpu-used",
+                        "8",
+                        "-usage",
+                        "good",
+                        "-an",
+                    ],
+                    HDR_SOURCE,
+                    2,
+                ),
+                "aom_hdr_with_crf": (
+                    [
+                        "-map",
+                        "0:v",
+                        "-c:v",
+                        "libaom-av1",
+                        "-pix_fmt",
+                        "yuv420p10le",
+                        "-lossless",
+                        "1",
+                        "-cpu-used",
+                        "8",
+                        "-crf",
+                        "26",
+                        "-an",
+                    ],
+                    HDR_SOURCE,
+                    2,
+                ),
+                "svt_hdr": (
+                    [
+                        "-map",
+                        "0:v",
+                        "-c:v",
+                        "libsvtav1",
+                        "-pix_fmt",
+                        "yuv420p10le",
+                        "-svtav1-params",
+                        "lossless=1",
+                        "-preset",
+                        "13",
+                        "-an",
+                    ],
+                    HDR_SOURCE,
+                    2,
+                ),
+            }
+        )
+
+    print(f"Synthetic source pixel format: {synth_fmt}")
+    print(f"Testing {len(encoders)} encoder configurations...\n")
+    print("=" * 80)
+
+    for name, (encode_cmd, source, end_time) in sorted(encoders.items()):
+        print(f"\n### {name}")
+        results = test_encoder(name, encode_cmd, source, tmp_dir, end_time)
+
+        if results["status"] != "OK":
+            print(f"  STATUS: {results['status']}")
+            print(f"  ERROR: {results.get('error', 'unknown')[:300]}")
+            continue
+
+        print(f"  Pixel format: {results['source_pix_fmt']} -> {results['output_pix_fmt']}")
+        print(f"  Native framemd5:     {results['native_comparison']}")
+        print(f"  Forced source fmt:   {results['forced_src_fmt']}")
+        if "forced_out_fmt" in results:
+            print(f"  Forced output fmt:   {results['forced_out_fmt']}")
+        print(f"  Round-trip:          {results['round_trip']}")
+        psnr_short = results["psnr"]
+        if "average:" in psnr_short:
+            # Extract just the key PSNR values
+            import re
+
+            m = re.search(r"PSNR y:([\d.]+|inf).*average:([\d.]+|inf)", psnr_short)
+            if m:
+                psnr_short = f"Y={m.group(1)} Average={m.group(2)}"
+        print(f"  PSNR:                {psnr_short}")
+
+    print("\n" + "=" * 80)
+    print("DONE")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/e2e/test_e2e_encode.py b/tests/e2e/test_e2e_encode.py
new file mode 100644
index 00000000..d910fb18
--- /dev/null
+++ b/tests/e2e/test_e2e_encode.py
@@ -0,0 +1,923 @@
+# -*- coding: utf-8 -*-
+"""
+E2E encode tests — build real commands, run real FFmpeg/Rigaya encodes, verify output.
+
+Run locally:
+    uv run pytest tests/e2e -v
+    uv run pytest tests/e2e -v -k "x265"
+    SKIP_NVIDIA=1 uv run pytest tests/e2e -v
+
+Skipped on CI (GitHub Actions sets CI=true).
+"""
+
+import json
+import subprocess
+
+import pytest
+
+from tests.e2e.conftest import (
+    ALL_ENCODERS,
+    FFMPEG,
+    FFMPEG_ENCODERS,
+    FFPROBE,
+    LOSSLESS_ENCODERS,
+    MEDIA_DIR,
+    NVENCC,
+    ON_CI,
+    SKIP_NVIDIA,
+    SOURCES,
+    create_fastflix,
+    has_ffmpeg_encoder,
+    make_params,
+    run_commands,
+    verify_lossless_quality,
+    verify_output,
+)
+from fastflix.models.encode import NVEncCSettings, x264Settings
+
+pytestmark = [pytest.mark.e2e]
+
+if ON_CI:
+    pytestmark.append(pytest.mark.skip(reason="E2E tests skipped on CI"))
+if not FFMPEG or not FFPROBE:
+    pytestmark.append(pytest.mark.skip(reason="ffmpeg/ffprobe not found"))
+
+
+# ===========================================================================
+# Test 1: Basic encode — every encoder x HDR10+ source
+# ===========================================================================
+@pytest.mark.parametrize("encoder_id,settings,output_ext,expected_codec,is_rigaya", make_params(ALL_ENCODERS))
+def test_encode_basic(encoder_id, settings, output_ext, expected_codec, is_rigaya, tmp_path):
+    """Every encoder can encode the HDR10+ test source."""
+    source = SOURCES["hdr10plus"]
+    if not source.exists():
+        pytest.skip("HDR10+ test source not found")
+
+    output_path = tmp_path / f"basic_{encoder_id}{output_ext}"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    # copy encoder uses source codec — HDR10+ source is HEVC
+    if encoder_id == "copy":
+        expected_codec = "hevc"
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=settings,
+        output_path=output_path,
+        work_path=work_path,
+        is_rigaya=is_rigaya,
+        include_data=False,
+        include_attachments=False,
+    )
+
+    module = __import__(f"fastflix.encoders.{encoder_id}.command_builder", fromlist=["build"])
+    commands = module.build(fastflix)
+    assert commands, f"Encoder {encoder_id} returned no commands"
+
+    run_commands(commands, work_path)
+    verify_output(output_path, expected_codec)
+
+
+# ===========================================================================
+# Test 2: Attachments — FFmpeg encoders x MKV source with fonts/cover
+# ===========================================================================
+@pytest.mark.parametrize("encoder_id,settings,output_ext,expected_codec,is_rigaya", make_params(FFMPEG_ENCODERS))
+def test_encode_with_attachments(encoder_id, settings, output_ext, expected_codec, is_rigaya, tmp_path):
+    """FFmpeg encoders preserve font attachments and cover when encoding MKV."""
+    source = SOURCES["attachments"]
+    if not source.exists():
+        pytest.skip("Attachment test source not found")
+
+    # copy encoder: source is h264
+    if encoder_id == "copy":
+        expected_codec = "h264"
+
+    output_path = tmp_path / f"attach_{encoder_id}.mkv"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=settings,
+        output_path=output_path,
+        work_path=work_path,
+        is_rigaya=is_rigaya,
+    )
+
+    module = __import__(f"fastflix.encoders.{encoder_id}.command_builder", fromlist=["build"])
+    commands = module.build(fastflix)
+    assert commands
+
+    run_commands(commands, work_path)
+    data = verify_output(output_path, expected_codec)
+
+    # Check font attachment preserved with mimetype
+    attachments = [s for s in data["streams"] if s["codec_type"] == "attachment"]
+    font_attachments = [s for s in attachments if s.get("tags", {}).get("mimetype") == "application/x-truetype-font"]
+    assert len(font_attachments) >= 1, f"Font attachment missing. Found: {attachments}"
+
+    # Check cover image preserved
+    covers = [
+        s
+        for s in data["streams"]
+        if s["codec_type"] == "video" and s.get("disposition", {}).get("attached_pic", 0) == 1
+    ]
+    assert len(covers) >= 1, f"Cover image missing. Streams: {[s['codec_type'] for s in data['streams']]}"
+
+
+# ===========================================================================
+# Test 3: Data streams excluded for MKV output
+# ===========================================================================
+@pytest.mark.parametrize("encoder_id,settings,output_ext,expected_codec,is_rigaya", make_params(FFMPEG_ENCODERS))
+def test_encode_data_excluded_for_mkv(encoder_id, settings, output_ext, expected_codec, is_rigaya, tmp_path):
+    """Data streams from MP4 source are excluded when encoding to MKV."""
+    source = SOURCES["chapters"]
+    if not source.exists():
+        pytest.skip("Chapters test source not found")
+
+    if encoder_id == "copy":
+        expected_codec = "h264"
+
+    output_path = tmp_path / f"nodata_{encoder_id}.mkv"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=settings,
+        output_path=output_path,
+        work_path=work_path,
+        is_rigaya=is_rigaya,
+    )
+
+    module = __import__(f"fastflix.encoders.{encoder_id}.command_builder", fromlist=["build"])
+    commands = module.build(fastflix)
+    assert commands
+
+    # Verify -dn is in the final command (multi-pass encoders have it in the last pass)
+    final_cmd_str = commands[-1].to_string()
+    assert "-dn" in final_cmd_str, f"Expected -dn to exclude data streams for MKV: {final_cmd_str}"
+
+    run_commands(commands, work_path)
+    data = verify_output(output_path, expected_codec)
+
+    # No data streams in output
+    out_data = [s for s in data["streams"] if s["codec_type"] == "data"]
+    assert len(out_data) == 0, f"Data streams should be excluded from MKV. Found: {out_data}"
+
+
+# ===========================================================================
+# Test 4: Data streams mapped for MP4 output
+# ===========================================================================
+@pytest.mark.parametrize("encoder_id,settings,output_ext,expected_codec,is_rigaya", make_params(FFMPEG_ENCODERS))
+def test_encode_data_mapped_for_mp4(encoder_id, settings, output_ext, expected_codec, is_rigaya, tmp_path):
+    """Data streams from MP4 source are mapped (not excluded) when encoding to MP4."""
+    source = SOURCES["chapters"]
+    if not source.exists():
+        pytest.skip("Chapters test source not found")
+
+    # Skip encoders that can't output MP4
+    if encoder_id in ("vp9", "vvc"):
+        pytest.skip(f"{encoder_id} doesn't typically output MP4")
+    if encoder_id == "copy":
+        expected_codec = "h264"
+
+    output_path = tmp_path / f"data_{encoder_id}.mp4"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=settings,
+        output_path=output_path,
+        work_path=work_path,
+        is_rigaya=is_rigaya,
+    )
+
+    module = __import__(f"fastflix.encoders.{encoder_id}.command_builder", fromlist=["build"])
+    commands = module.build(fastflix)
+    assert commands
+
+    # Verify the final command maps the data stream and sets title/handler metadata
+    final_cmd_str = commands[-1].to_string()
+    assert "-map 0:2" in final_cmd_str, f"Data stream should be mapped for MP4: {final_cmd_str}"
+    assert "-c:d copy" in final_cmd_str, f"Data stream should use copy codec: {final_cmd_str}"
+    assert "title=" in final_cmd_str, f"Data track should have title metadata: {final_cmd_str}"
+    assert "handler=" in final_cmd_str, f"Data track should have handler metadata: {final_cmd_str}"
+    assert "-dn" not in final_cmd_str, f"Should NOT have -dn when data is mapped: {final_cmd_str}"
+
+    # Encode must succeed (even if FFmpeg silently drops the data stream)
+    run_commands(commands, work_path)
+    verify_output(output_path, expected_codec)
+
+
+# ===========================================================================
+# Test 5: "Same as Source" extension — MKV source → .mkv output
+# ===========================================================================
+@pytest.mark.parametrize("encoder_id,settings,output_ext,expected_codec,is_rigaya", make_params(FFMPEG_ENCODERS))
+def test_encode_same_as_source_mkv(encoder_id, settings, output_ext, expected_codec, is_rigaya, tmp_path):
+    """'Same as Source' with MKV source resolves to .mkv output."""
+    source = SOURCES["attachments"]  # MKV source
+    if not source.exists():
+        pytest.skip("Attachment MKV test source not found")
+
+    if encoder_id == "copy":
+        expected_codec = "h264"
+
+    # Use .mkv extension (simulating "Same as Source" resolution for MKV input)
+    output_path = tmp_path / f"same_mkv_{encoder_id}.mkv"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=settings,
+        output_path=output_path,
+        work_path=work_path,
+        is_rigaya=is_rigaya,
+    )
+
+    # Verify the resolved extension matches source
+    assert source.suffix.lower() == ".mkv"
+    assert output_path.suffix.lower() == ".mkv"
+
+    module = __import__(f"fastflix.encoders.{encoder_id}.command_builder", fromlist=["build"])
+    commands = module.build(fastflix)
+    assert commands
+
+    run_commands(commands, work_path)
+    verify_output(output_path, expected_codec)
+
+
+# ===========================================================================
+# Test 6: "Same as Source" extension — MP4 source → .mp4 output
+# ===========================================================================
+@pytest.mark.parametrize("encoder_id,settings,output_ext,expected_codec,is_rigaya", make_params(FFMPEG_ENCODERS))
+def test_encode_same_as_source_mp4(encoder_id, settings, output_ext, expected_codec, is_rigaya, tmp_path):
+    """'Same as Source' with MP4 source resolves to .mp4 output."""
+    source = SOURCES["chapters"]  # MP4 source
+    if not source.exists():
+        pytest.skip("Chapters MP4 test source not found")
+
+    # Skip encoders that can't output MP4
+    if encoder_id in ("vp9", "vvc"):
+        pytest.skip(f"{encoder_id} doesn't typically output MP4")
+    if encoder_id == "copy":
+        expected_codec = "h264"
+
+    # Use .mp4 extension (simulating "Same as Source" resolution for MP4 input)
+    output_path = tmp_path / f"same_mp4_{encoder_id}.mp4"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=settings,
+        output_path=output_path,
+        work_path=work_path,
+        is_rigaya=is_rigaya,
+    )
+
+    # Verify the resolved extension matches source
+    assert source.suffix.lower() == ".mp4"
+    assert output_path.suffix.lower() == ".mp4"
+
+    module = __import__(f"fastflix.encoders.{encoder_id}.command_builder", fromlist=["build"])
+    commands = module.build(fastflix)
+    assert commands
+
+    run_commands(commands, work_path)
+    verify_output(output_path, expected_codec)
+
+
+# ===========================================================================
+# Test 7: Subtitle disposition flags in encode output
+# ===========================================================================
+def test_encode_subtitle_default_disposition(tmp_path):
+    """Encode MKV with subtitles, verify default disposition flag appears in command."""
+    source = SOURCES["attachments"]  # MKV with ASS subtitle
+    if not source.exists():
+        pytest.skip("Attachment MKV test source not found")
+
+    output_path = tmp_path / "sub_disp.mkv"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    from fastflix.models.encode import x265Settings
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=x265Settings(preset="ultrafast", crf=51),
+        output_path=output_path,
+        work_path=work_path,
+        include_subtitles=True,
+    )
+
+    # Set default disposition on first subtitle (simulating "first" profile mode)
+    assert len(fastflix.current_video.subtitle_tracks) >= 1, "Source should have subtitles"
+    fastflix.current_video.subtitle_tracks[0].dispositions["default"] = True
+
+    from fastflix.encoders.hevc_x265 import command_builder
+
+    commands = command_builder.build(fastflix)
+    assert commands
+
+    # Final command should contain disposition with "default"
+    final_cmd = commands[-1].to_string()
+    assert "-disposition:" in final_cmd, f"Expected disposition flag in command: {final_cmd}"
+    assert "default" in final_cmd, f"Expected 'default' disposition: {final_cmd}"
+
+    run_commands(commands, work_path)
+    data = verify_output(output_path, "hevc")
+
+    # Verify subtitle stream exists in output
+    out_subs = [s for s in data["streams"] if s["codec_type"] == "subtitle"]
+    assert len(out_subs) >= 1, f"Subtitle should be in output. Streams: {[s['codec_type'] for s in data['streams']]}"
+
+
+# ===========================================================================
+# Test 8: AOM AV1 2-pass CRF encode
+# ===========================================================================
+def test_encode_aom_av1_two_pass_crf(tmp_path):
+    """AOM AV1 2-pass CRF produces two commands and encodes successfully."""
+    if not has_ffmpeg_encoder("libaom-av1"):
+        pytest.skip("libaom-av1 not available")
+
+    source = SOURCES["hdr10plus"]
+    if not source.exists():
+        pytest.skip("HDR10+ test source not found")
+
+    output_path = tmp_path / "aom_2pass_crf.mkv"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    from fastflix.models.encode import AOMAV1Settings
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=AOMAV1Settings(cpu_used="8", usage="realtime", crf=63, single_pass=False),
+        output_path=output_path,
+        work_path=work_path,
+        include_data=False,
+        include_attachments=False,
+    )
+
+    from fastflix.encoders.av1_aom import command_builder
+
+    commands = command_builder.build(fastflix)
+    assert len(commands) == 2, f"Expected 2-pass (2 commands), got {len(commands)}"
+    assert "First Pass CRF" in commands[0].name
+    assert "Second Pass CRF" in commands[1].name
+
+    # Verify pass flags in commands
+    cmd1_str = commands[0].to_string()
+    cmd2_str = commands[1].to_string()
+    assert "-pass 1" in cmd1_str
+    assert "-pass 2" in cmd2_str
+    assert "-crf 63" in cmd1_str
+    assert "-crf 63" in cmd2_str
+
+    run_commands(commands, work_path)
+    verify_output(output_path, "av1")
+
+
+# ===========================================================================
+# Test 9: Lossless command flags — verify lossless flag in generated commands
+# ===========================================================================
+# Rate control flags that must NOT appear in lossless commands (per encoder)
+_LOSSLESS_FORBIDDEN_FLAGS = {
+    "hevc_x265": ["-crf:v", "-b:v"],
+    "avc_x264": ["-crf:v", "-b:v"],
+    "av1_aom": ["-crf", "-b:v"],
+    "vp9": ["-crf:v", "-b:v"],
+    "svt_av1": ["-crf", "-qp", "-b:v"],
+    "webp": [],  # WebP has its own quality model, no CRF/bitrate flags to check
+}
+
+
+@pytest.mark.parametrize("encoder_id,settings,output_ext,expected_codec,is_rigaya", make_params(LOSSLESS_ENCODERS))
+def test_lossless_command_flags(encoder_id, settings, output_ext, expected_codec, is_rigaya, tmp_path):
+    """Lossless encoders include the lossless flag and exclude rate control flags."""
+    source = SOURCES["hdr10plus"]
+    if not source.exists():
+        pytest.skip("HDR10+ test source not found")
+
+    output_path = tmp_path / f"lossless_{encoder_id}{output_ext}"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=settings,
+        output_path=output_path,
+        work_path=work_path,
+        is_rigaya=is_rigaya,
+        include_data=False,
+        include_attachments=False,
+    )
+
+    module = __import__(f"fastflix.encoders.{encoder_id}.command_builder", fromlist=["build"])
+    commands = module.build(fastflix)
+    assert commands, f"Encoder {encoder_id} returned no commands"
+
+    # Verify lossless flag is present in at least one command
+    all_cmd_str = " ".join(cmd.to_string() for cmd in commands)
+    assert "lossless" in all_cmd_str.lower(), f"Expected 'lossless' in command for {encoder_id}: {all_cmd_str}"
+
+    # Verify rate control flags are NOT present — lossless must skip CRF/bitrate/QP
+    for flag in _LOSSLESS_FORBIDDEN_FLAGS.get(encoder_id, []):
+        for cmd in commands:
+            cmd_list = cmd.to_list()
+            assert flag not in cmd_list, (
+                f"Lossless {encoder_id} must not include '{flag}' in command: {cmd.to_string()}"
+            )
+
+
+# ===========================================================================
+# Test 10: Lossless encode — full encode with framemd5 quality verification
+# ===========================================================================
+# Encoders confirmed to produce bit-exact lossless output with 10-bit HDR content
+BIT_EXACT_LOSSLESS = {"hevc_x265", "avc_x264", "vp9"}
+
+
+@pytest.mark.parametrize("encoder_id,settings,output_ext,expected_codec,is_rigaya", make_params(LOSSLESS_ENCODERS))
+def test_lossless_encode(encoder_id, settings, output_ext, expected_codec, is_rigaya, tmp_path):
+    """Lossless encoders produce valid output with zero quality loss."""
+    source = SOURCES["hdr10plus"]
+    if not source.exists():
+        pytest.skip("HDR10+ test source not found")
+
+    output_path = tmp_path / f"lossless_{encoder_id}{output_ext}"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=settings,
+        output_path=output_path,
+        work_path=work_path,
+        is_rigaya=is_rigaya,
+        include_data=False,
+        include_attachments=False,
+    )
+
+    module = __import__(f"fastflix.encoders.{encoder_id}.command_builder", fromlist=["build"])
+    commands = module.build(fastflix)
+    assert commands, f"Encoder {encoder_id} returned no commands"
+
+    run_commands(commands, work_path)
+    verify_output(output_path, expected_codec)
+
+    # Verify true lossless via per-frame MD5 comparison for bit-exact encoders
+    if encoder_id in BIT_EXACT_LOSSLESS:
+        verify_lossless_quality(source, output_path)
+
+
+# ===========================================================================
+# Filter E2E test helpers
+# ===========================================================================
+
+
+def sample_positions_5(h, w):
+    return [
+        (h // 4, w // 4),
+        (h // 4, 3 * w // 4),
+        (h // 2, w // 2),
+        (3 * h // 4, w // 4),
+        (3 * h // 4, 3 * w // 4),
+    ]
+
+
+def _get_frame_rgb(video_path):
+    """Decode first frame to raw RGB24 bytes, returning (pixels, width, height)."""
+    probe = subprocess.run(
+        [FFPROBE, "-v", "quiet", "-print_format", "json", "-show_streams", str(video_path)],
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    data = json.loads(probe.stdout)
+    vs = [s for s in data["streams"] if s["codec_type"] == "video"][0]
+    w, h = int(vs["width"]), int(vs["height"])
+
+    result = subprocess.run(
+        [FFMPEG, "-i", str(video_path), "-frames:v", "1", "-pix_fmt", "rgb24", "-f", "rawvideo", "-"],
+        capture_output=True,
+        timeout=30,
+    )
+    assert result.returncode == 0, f"Failed to decode {video_path}"
+    assert len(result.stdout) >= w * h * 3
+    return result.stdout, w, h
+
+
+def _avg_rgb(pixels, w, h):
+    """Compute average R, G, B across the entire frame."""
+    r_sum = g_sum = b_sum = 0
+    count = w * h
+    for i in range(0, count * 3, 3):
+        r_sum += pixels[i]
+        g_sum += pixels[i + 1]
+        b_sum += pixels[i + 2]
+    return r_sum / count, g_sum / count, b_sum / count
+
+
+def _avg_luma(pixels, w, h):
+    """Approximate average luma (BT.601) across the frame."""
+    total = 0.0
+    count = w * h
+    for i in range(0, count * 3, 3):
+        total += 0.299 * pixels[i] + 0.587 * pixels[i + 1] + 0.114 * pixels[i + 2]
+    return total / count
+
+
+def _encode_pair(tmp_path, apply_filter, encoder_id="avc_x264", is_rigaya=False):
+    """Encode the HDR10+ source twice: once baseline, once with apply_filter applied.
+
+    Returns (baseline_pixels, filtered_pixels, width, height).
+    """
+    source = SOURCES["hdr10plus"]
+    if not source.exists():
+        pytest.skip("HDR10+ test source not found")
+
+    if is_rigaya:
+        settings = NVEncCSettings(preset="performance", bitrate="1000k")
+        module_path = f"fastflix.encoders.{encoder_id}.command_builder"
+        expected_codec = "hevc"
+    else:
+        settings = x264Settings(preset="ultrafast", crf=28, pix_fmt="yuv420p")
+        module_path = f"fastflix.encoders.{encoder_id}.command_builder"
+        expected_codec = "h264"
+
+    module = __import__(module_path, fromlist=["build"])
+    work_path = tmp_path / "work"
+    work_path.mkdir(exist_ok=True)
+
+    # Baseline
+    out_base = tmp_path / "baseline.mkv"
+    ff_base = create_fastflix(
+        source_path=source,
+        encoder_settings=settings.model_copy(),
+        output_path=out_base,
+        work_path=work_path,
+        is_rigaya=is_rigaya,
+        include_data=False,
+        include_attachments=False,
+    )
+    run_commands(module.build(ff_base), work_path)
+    verify_output(out_base, expected_codec)
+
+    # Filtered
+    out_filt = tmp_path / "filtered.mkv"
+    ff_filt = create_fastflix(
+        source_path=source,
+        encoder_settings=settings.model_copy(),
+        output_path=out_filt,
+        work_path=work_path,
+        is_rigaya=is_rigaya,
+        include_data=False,
+        include_attachments=False,
+    )
+    apply_filter(ff_filt)
+    run_commands(module.build(ff_filt), work_path)
+    verify_output(out_filt, expected_codec)
+
+    base_px, w, h = _get_frame_rgb(out_base)
+    filt_px, _, _ = _get_frame_rgb(out_filt)
+    return base_px, filt_px, w, h
+
+
+# ===========================================================================
+# Filter tests: Brightness
+# ===========================================================================
+@pytest.mark.parametrize(
+    "encoder_id,is_rigaya",
+    [
+        pytest.param(
+            "avc_x264",
+            False,
+            id="x264",
+            marks=pytest.mark.skipif(not has_ffmpeg_encoder("libx264"), reason="libx264 not available"),
+        ),
+        pytest.param(
+            "nvencc_hevc",
+            True,
+            id="nvencc",
+            marks=pytest.mark.skipif(not NVENCC or SKIP_NVIDIA, reason="NVEncC not available"),
+        ),
+    ],
+)
+def test_filter_brightness(encoder_id, is_rigaya, tmp_path):
+    """Positive brightness makes pixels brighter (higher luma)."""
+    base_px, filt_px, w, h = _encode_pair(
+        tmp_path,
+        lambda ff: setattr(ff.current_video.video_settings, "brightness", "0.3"),
+        encoder_id=encoder_id,
+        is_rigaya=is_rigaya,
+    )
+    base_luma = _avg_luma(base_px, w, h)
+    filt_luma = _avg_luma(filt_px, w, h)
+    assert filt_luma > base_luma + 5, (
+        f"Brightness filter should increase luma: base={base_luma:.1f}, filtered={filt_luma:.1f}"
+    )
+
+
+# ===========================================================================
+# Filter tests: Vibrance (FFmpeg only — ʘ)
+# ===========================================================================
+@pytest.mark.skipif(not has_ffmpeg_encoder("libx264"), reason="libx264 not available")
+def test_filter_vibrance(tmp_path):
+    """Positive vibrance increases color saturation (R-B spread widens for colorful pixels)."""
+    base_px, filt_px, w, h = _encode_pair(
+        tmp_path,
+        lambda ff: setattr(ff.current_video.video_settings, "vibrance", "2.0"),
+    )
+
+    # Saturation proxy: average absolute difference between max and min channel per pixel
+    def avg_saturation(pixels, w, h):
+        total = 0.0
+        count = w * h
+        for i in range(0, count * 3, 3):
+            total += max(pixels[i], pixels[i + 1], pixels[i + 2]) - min(pixels[i], pixels[i + 1], pixels[i + 2])
+        return total / count
+
+    base_sat = avg_saturation(base_px, w, h)
+    filt_sat = avg_saturation(filt_px, w, h)
+    assert filt_sat > base_sat + 1, f"Vibrance should increase saturation: base={base_sat:.1f}, filtered={filt_sat:.1f}"
+
+
+# ===========================================================================
+# Filter tests: Color Temperature (FFmpeg only — ʘ)
+# ===========================================================================
+@pytest.mark.skipif(not has_ffmpeg_encoder("libx264"), reason="libx264 not available")
+def test_filter_color_temperature(tmp_path):
+    """Warm color temperature (low Kelvin) shifts pixels toward red, away from blue."""
+    base_px, filt_px, w, h = _encode_pair(
+        tmp_path,
+        lambda ff: setattr(ff.current_video.video_settings, "color_temperature", "2000"),
+    )
+    base_r, _, base_b = _avg_rgb(base_px, w, h)
+    filt_r, _, filt_b = _avg_rgb(filt_px, w, h)
+    # Warm temp: R should increase relative to B
+    base_rb_diff = base_r - base_b
+    filt_rb_diff = filt_r - filt_b
+    assert filt_rb_diff > base_rb_diff + 3, (
+        f"Warm color temp should shift R-B balance warmer: base R-B={base_rb_diff:.1f}, filtered R-B={filt_rb_diff:.1f}"
+    )
+
+
+# ===========================================================================
+# Filter tests: Curves Preset
+# ===========================================================================
+@pytest.mark.parametrize(
+    "encoder_id,is_rigaya",
+    [
+        pytest.param(
+            "avc_x264",
+            False,
+            id="x264",
+            marks=pytest.mark.skipif(not has_ffmpeg_encoder("libx264"), reason="libx264 not available"),
+        ),
+        pytest.param(
+            "nvencc_hevc",
+            True,
+            id="nvencc",
+            marks=pytest.mark.skipif(not NVENCC or SKIP_NVIDIA, reason="NVEncC not available"),
+        ),
+    ],
+)
+def test_filter_curves_darker(encoder_id, is_rigaya, tmp_path):
+    """Curves preset 'darker' reduces average luma."""
+    base_px, filt_px, w, h = _encode_pair(
+        tmp_path,
+        lambda ff: setattr(ff.current_video.video_settings, "curves_preset", "darker"),
+        encoder_id=encoder_id,
+        is_rigaya=is_rigaya,
+    )
+    base_luma = _avg_luma(base_px, w, h)
+    filt_luma = _avg_luma(filt_px, w, h)
+    assert filt_luma < base_luma - 3, (
+        f"Curves 'darker' should reduce luma: base={base_luma:.1f}, filtered={filt_luma:.1f}"
+    )
+
+
+# ===========================================================================
+# Filter tests: Colorbalance (FFmpeg only — ʘ)
+# ===========================================================================
+@pytest.mark.skipif(not has_ffmpeg_encoder("libx264"), reason="libx264 not available")
+def test_filter_colorbalance_warm_shadows(tmp_path):
+    """Warm Shadows colorbalance shifts R higher in dark pixel regions."""
+    base_px, filt_px, w, h = _encode_pair(
+        tmp_path,
+        lambda ff: setattr(ff.current_video.video_settings, "colorbalance", "colorbalance=rs=0.15:bs=-0.15"),
+    )
+    # Average R channel in dark pixels (luma < 80) should increase
+    base_r_sum = filt_r_sum = 0
+    total_dark = 0
+    for i in range(0, w * h * 3, 3):
+        luma = 0.299 * base_px[i] + 0.587 * base_px[i + 1] + 0.114 * base_px[i + 2]
+        if luma < 80:
+            total_dark += 1
+            base_r_sum += base_px[i]
+            filt_r_sum += filt_px[i]
+    assert total_dark > 0, "No dark pixels found in source"
+    base_avg_r = base_r_sum / total_dark
+    filt_avg_r = filt_r_sum / total_dark
+    assert filt_avg_r > base_avg_r + 1, (
+        f"Warm Shadows should boost average R in dark pixels: base={base_avg_r:.1f}, filtered={filt_avg_r:.1f}"
+    )
+
+
+# ===========================================================================
+# Filter tests: Unsharp Mask
+# ===========================================================================
+@pytest.mark.parametrize(
+    "encoder_id,is_rigaya",
+    [
+        pytest.param(
+            "avc_x264",
+            False,
+            id="x264",
+            marks=pytest.mark.skipif(not has_ffmpeg_encoder("libx264"), reason="libx264 not available"),
+        ),
+        pytest.param(
+            "nvencc_hevc",
+            True,
+            id="nvencc",
+            marks=pytest.mark.skipif(not NVENCC or SKIP_NVIDIA, reason="NVEncC not available"),
+        ),
+    ],
+)
+def test_filter_unsharp(encoder_id, is_rigaya, tmp_path):
+    """Unsharp mask increases local contrast (pixel variance increases)."""
+    from fastflix.widgets.panels.advanced_panel import unsharp_presets
+
+    base_px, filt_px, w, h = _encode_pair(
+        tmp_path,
+        lambda ff: setattr(ff.current_video.video_settings, "unsharp", unsharp_presets["strong"]),
+        encoder_id=encoder_id,
+        is_rigaya=is_rigaya,
+    )
+
+    # Measure local contrast: average absolute difference between adjacent pixels
+    def local_contrast(pixels, w, h):
+        total = 0.0
+        count = 0
+        for row in range(h):
+            for col in range(w - 1):
+                i = (row * w + col) * 3
+                j = i + 3
+                total += abs(pixels[i] - pixels[j])  # R channel neighbor diff
+                count += 1
+        return total / count if count else 0
+
+    base_contrast = local_contrast(base_px, w, h)
+    filt_contrast = local_contrast(filt_px, w, h)
+    assert filt_contrast > base_contrast, (
+        f"Unsharp should increase local contrast: base={base_contrast:.2f}, filtered={filt_contrast:.2f}"
+    )
+
+
+# ===========================================================================
+# Filter tests: Deflicker (FFmpeg only — ʘ)
+# ===========================================================================
+@pytest.mark.skipif(not has_ffmpeg_encoder("libx264"), reason="libx264 not available")
+def test_filter_deflicker(tmp_path):
+    """Deflicker encodes successfully (temporal effect — verify encode completes)."""
+    from fastflix.widgets.panels.advanced_panel import deflicker_presets
+
+    source = SOURCES["hdr10plus"]
+    if not source.exists():
+        pytest.skip("HDR10+ test source not found")
+
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+    output = tmp_path / "deflicker.mkv"
+
+    ff = create_fastflix(
+        source_path=source,
+        encoder_settings=x264Settings(preset="ultrafast", crf=28, pix_fmt="yuv420p"),
+        output_path=output,
+        work_path=work_path,
+        include_data=False,
+        include_attachments=False,
+    )
+    ff.current_video.video_settings.deflicker = deflicker_presets["medium"]
+    module = __import__("fastflix.encoders.avc_x264.command_builder", fromlist=["build"])
+    commands = module.build(ff)
+    cmd_str = commands[0].to_string()
+    assert "deflicker" in cmd_str, f"deflicker filter not in command: {cmd_str}"
+    run_commands(commands, work_path)
+    verify_output(output, "h264")
+
+
+# ===========================================================================
+# Filter tests: Pad / Letterbox
+# ===========================================================================
+@pytest.mark.parametrize(
+    "encoder_id,is_rigaya",
+    [
+        pytest.param(
+            "avc_x264",
+            False,
+            id="x264",
+            marks=pytest.mark.skipif(not has_ffmpeg_encoder("libx264"), reason="libx264 not available"),
+        ),
+        pytest.param(
+            "nvencc_hevc",
+            True,
+            id="nvencc",
+            marks=pytest.mark.skipif(not NVENCC or SKIP_NVIDIA, reason="NVEncC not available"),
+        ),
+    ],
+)
+def test_filter_pad_letterbox(encoder_id, is_rigaya, tmp_path):
+    """Pad to 1:1 adds black bars — border pixels should be near-black."""
+
+    def apply_pad(ff):
+        ff.current_video.video_settings.pad_aspect = "1:1"
+        ff.current_video.video_settings.pad_color = "black"
+
+    source = SOURCES["hdr10plus"]
+    if not source.exists():
+        pytest.skip("HDR10+ test source not found")
+
+    if is_rigaya:
+        settings = NVEncCSettings(preset="performance", bitrate="1000k")
+        expected_codec = "hevc"
+    else:
+        settings = x264Settings(preset="ultrafast", crf=28, pix_fmt="yuv420p")
+        expected_codec = "h264"
+
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+    output = tmp_path / "padded.mkv"
+
+    ff = create_fastflix(
+        source_path=source,
+        encoder_settings=settings,
+        output_path=output,
+        work_path=work_path,
+        is_rigaya=is_rigaya,
+        include_data=False,
+        include_attachments=False,
+    )
+    apply_pad(ff)
+    module = __import__(f"fastflix.encoders.{encoder_id}.command_builder", fromlist=["build"])
+    run_commands(module.build(ff), work_path)
+    verify_output(output, expected_codec)
+
+    pixels, w, h = _get_frame_rgb(output)
+
+    # For 1:1 pad on a wider-than-tall source, black bars appear at top/bottom.
+    # For a taller-than-wide source, black bars at left/right.
+    # Either way, some border pixels should be near-black.
+    # Check top-left and bottom-right corner pixels.
+    corners = [(0, 0), (0, w - 1), (h - 1, 0), (h - 1, w - 1)]
+    black_corners = 0
+    for row, col in corners:
+        off = (row * w + col) * 3
+        r, g, b = pixels[off], pixels[off + 1], pixels[off + 2]
+        if r < 20 and g < 20 and b < 20:
+            black_corners += 1
+    assert black_corners >= 2, (
+        f"Pad to 1:1 should produce black bars — expected at least 2 near-black corners, got {black_corners}"
+    )
+
+
+# ===========================================================================
+# Filter tests: LUT3D
+# ===========================================================================
+@pytest.mark.parametrize(
+    "encoder_id,is_rigaya",
+    [
+        pytest.param(
+            "avc_x264",
+            False,
+            id="x264",
+            marks=pytest.mark.skipif(not has_ffmpeg_encoder("libx264"), reason="libx264 not available"),
+        ),
+    ],
+)
+def test_filter_lut3d(encoder_id, is_rigaya, tmp_path):
+    """LUT3D with R/B swap produces pixels with swapped red and blue channels."""
+    lut_path = MEDIA_DIR / "test_color_shift.cube"
+    assert lut_path.exists(), f"Test LUT not found: {lut_path}"
+
+    base_px, filt_px, w, h = _encode_pair(
+        tmp_path,
+        lambda ff: setattr(ff.current_video.video_settings, "lut3d_path", str(lut_path)),
+        encoder_id=encoder_id,
+        is_rigaya=is_rigaya,
+    )
+
+    tolerance = 30
+    swap_confirmed = 0
+    for row, col in sample_positions_5(h, w):
+        off = (row * w + col) * 3
+        r_orig, g_orig, b_orig = base_px[off], base_px[off + 1], base_px[off + 2]
+        r_lut, g_lut, b_lut = filt_px[off], filt_px[off + 1], filt_px[off + 2]
+        if abs(r_lut - b_orig) <= tolerance and abs(b_lut - r_orig) <= tolerance and abs(g_lut - g_orig) <= tolerance:
+            swap_confirmed += 1
+
+    assert swap_confirmed >= 3, f"LUT3D R/B swap not detected: only {swap_confirmed}/5 sample points matched"
diff --git a/tests/e2e/test_e2e_qsvencc_tune.py b/tests/e2e/test_e2e_qsvencc_tune.py
new file mode 100644
index 00000000..005553d0
--- /dev/null
+++ b/tests/e2e/test_e2e_qsvencc_tune.py
@@ -0,0 +1,301 @@
+# -*- coding: utf-8 -*-
+"""
+E2E tests for QSVEncC --tune parameter support.
+
+These tests verify that the --tune flag is correctly wired through to
+the generated commands and produces valid output when running on
+hardware with Intel QSV support.
+
+Run locally:
+    uv run pytest tests/e2e/test_e2e_qsvencc_tune.py -v
+    SKIP_INTEL=1 uv run pytest tests/e2e -v  # skip Intel tests
+
+Skipped on CI (GitHub Actions sets CI=true).
+"""
+
+import pytest
+
+from fastflix.models.encode import QSVEncCAV1Settings, QSVEncCH264Settings, QSVEncCSettings
+
+from tests.e2e.conftest import (
+    ON_CI,
+    QSVENCC,
+    SKIP_INTEL,
+    FFMPEG,
+    FFPROBE,
+    SOURCES,
+    create_fastflix,
+    run_commands,
+    verify_output,
+)
+
+pytestmark = [pytest.mark.e2e]
+
+if ON_CI:
+    pytestmark.append(pytest.mark.skip(reason="E2E tests skipped on CI"))
+if not FFMPEG or not FFPROBE:
+    pytestmark.append(pytest.mark.skip(reason="ffmpeg/ffprobe not found"))
+
+
+TUNE_VALUES = ["hq", "ll", "ull", "lossless"]
+
+
+def _skip_if_no_qsvencc():
+    if not QSVENCC:
+        pytest.skip("QSVEncC not found")
+    if SKIP_INTEL:
+        pytest.skip("Intel tests skipped via SKIP_INTEL")
+
+
+# ===========================================================================
+# Test 1: QSVEncC HEVC --tune flag in generated commands
+# ===========================================================================
+@pytest.mark.parametrize("tune_value", TUNE_VALUES)
+def test_qsvencc_hevc_tune_command(tune_value, tmp_path):
+    """QSVEncC HEVC encoder includes --tune flag with correct value in generated command."""
+    _skip_if_no_qsvencc()
+
+    source = SOURCES["hdr10plus"]
+    if not source.exists():
+        pytest.skip("HDR10+ test source not found")
+
+    output_path = tmp_path / f"hevc_tune_{tune_value}.mkv"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=QSVEncCSettings(preset="fastest", bitrate="1000k", tune=tune_value),
+        output_path=output_path,
+        work_path=work_path,
+        is_rigaya=True,
+        include_data=False,
+        include_attachments=False,
+    )
+
+    from fastflix.encoders.qsvencc_hevc import command_builder
+
+    commands = command_builder.build(fastflix)
+    assert commands, "QSVEncC HEVC returned no commands"
+
+    cmd = commands[0].command
+    assert "--tune" in cmd, f"--tune not found in command: {cmd}"
+    tune_idx = cmd.index("--tune")
+    assert cmd[tune_idx + 1] == tune_value, f"Expected tune={tune_value}, got {cmd[tune_idx + 1]}"
+
+
+# ===========================================================================
+# Test 2: QSVEncC AV1 --tune flag in generated commands
+# ===========================================================================
+@pytest.mark.parametrize("tune_value", TUNE_VALUES)
+def test_qsvencc_av1_tune_command(tune_value, tmp_path):
+    """QSVEncC AV1 encoder includes --tune flag with correct value in generated command."""
+    _skip_if_no_qsvencc()
+
+    source = SOURCES["hdr10plus"]
+    if not source.exists():
+        pytest.skip("HDR10+ test source not found")
+
+    output_path = tmp_path / f"av1_tune_{tune_value}.mkv"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=QSVEncCAV1Settings(preset="fastest", bitrate="1000k", tune=tune_value),
+        output_path=output_path,
+        work_path=work_path,
+        is_rigaya=True,
+        include_data=False,
+        include_attachments=False,
+    )
+
+    from fastflix.encoders.qsvencc_av1 import command_builder
+
+    commands = command_builder.build(fastflix)
+    assert commands, "QSVEncC AV1 returned no commands"
+
+    cmd = commands[0].command
+    assert "--tune" in cmd, f"--tune not found in command: {cmd}"
+    tune_idx = cmd.index("--tune")
+    assert cmd[tune_idx + 1] == tune_value, f"Expected tune={tune_value}, got {cmd[tune_idx + 1]}"
+
+
+# ===========================================================================
+# Test 3: QSVEncC AVC --tune flag in generated commands
+# ===========================================================================
+@pytest.mark.parametrize("tune_value", TUNE_VALUES)
+def test_qsvencc_avc_tune_command(tune_value, tmp_path):
+    """QSVEncC AVC encoder includes --tune flag with correct value in generated command."""
+    _skip_if_no_qsvencc()
+
+    source = SOURCES["hdr10plus"]
+    if not source.exists():
+        pytest.skip("HDR10+ test source not found")
+
+    output_path = tmp_path / f"avc_tune_{tune_value}.mkv"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=QSVEncCH264Settings(preset="fastest", bitrate="1000k", tune=tune_value),
+        output_path=output_path,
+        work_path=work_path,
+        is_rigaya=True,
+        include_data=False,
+        include_attachments=False,
+    )
+
+    from fastflix.encoders.qsvencc_avc import command_builder
+
+    commands = command_builder.build(fastflix)
+    assert commands, "QSVEncC AVC returned no commands"
+
+    cmd = commands[0].command
+    assert "--tune" in cmd, f"--tune not found in command: {cmd}"
+    tune_idx = cmd.index("--tune")
+    assert cmd[tune_idx + 1] == tune_value, f"Expected tune={tune_value}, got {cmd[tune_idx + 1]}"
+
+
+# ===========================================================================
+# Test 4: QSVEncC --tune omitted when not set
+# ===========================================================================
+@pytest.mark.parametrize(
+    "encoder_id,settings_cls,codec",
+    [
+        ("qsvencc_hevc", QSVEncCSettings, "hevc"),
+        ("qsvencc_av1", QSVEncCAV1Settings, "av1"),
+        ("qsvencc_avc", QSVEncCH264Settings, "h264"),
+    ],
+)
+def test_qsvencc_tune_omitted_when_none(encoder_id, settings_cls, codec, tmp_path):
+    """--tune is NOT in the command when tune is None (default)."""
+    _skip_if_no_qsvencc()
+
+    source = SOURCES["hdr10plus"]
+    if not source.exists():
+        pytest.skip("HDR10+ test source not found")
+
+    output_path = tmp_path / f"{encoder_id}_no_tune.mkv"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=settings_cls(preset="fastest", bitrate="1000k"),
+        output_path=output_path,
+        work_path=work_path,
+        is_rigaya=True,
+        include_data=False,
+        include_attachments=False,
+    )
+
+    module = __import__(f"fastflix.encoders.{encoder_id}.command_builder", fromlist=["build"])
+    commands = module.build(fastflix)
+    assert commands
+
+    cmd = commands[0].command
+    assert "--tune" not in cmd, f"--tune should not be present when tune is None: {cmd}"
+
+
+# ===========================================================================
+# Test 5: Full encode with --tune hq (HEVC)
+# ===========================================================================
+def test_qsvencc_hevc_tune_encode(tmp_path):
+    """QSVEncC HEVC with --tune hq produces valid output."""
+    _skip_if_no_qsvencc()
+
+    source = SOURCES["hdr10plus"]
+    if not source.exists():
+        pytest.skip("HDR10+ test source not found")
+
+    output_path = tmp_path / "hevc_tune_encode.mkv"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=QSVEncCSettings(preset="fastest", bitrate="1000k", tune="hq"),
+        output_path=output_path,
+        work_path=work_path,
+        is_rigaya=True,
+        include_data=False,
+        include_attachments=False,
+    )
+
+    from fastflix.encoders.qsvencc_hevc import command_builder
+
+    commands = command_builder.build(fastflix)
+    assert commands
+
+    run_commands(commands, work_path)
+    verify_output(output_path, "hevc")
+
+
+# ===========================================================================
+# Test 6: Full encode with --tune ll (AV1)
+# ===========================================================================
+def test_qsvencc_av1_tune_encode(tmp_path):
+    """QSVEncC AV1 with --tune ll produces valid output."""
+    _skip_if_no_qsvencc()
+
+    source = SOURCES["hdr10plus"]
+    if not source.exists():
+        pytest.skip("HDR10+ test source not found")
+
+    output_path = tmp_path / "av1_tune_encode.mkv"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=QSVEncCAV1Settings(preset="fastest", bitrate="1000k", tune="ll"),
+        output_path=output_path,
+        work_path=work_path,
+        is_rigaya=True,
+        include_data=False,
+        include_attachments=False,
+    )
+
+    from fastflix.encoders.qsvencc_av1 import command_builder
+
+    commands = command_builder.build(fastflix)
+    assert commands
+
+    run_commands(commands, work_path)
+    verify_output(output_path, "av1")
+
+
+# ===========================================================================
+# Test 7: Full encode with --tune hq (AVC)
+# ===========================================================================
+def test_qsvencc_avc_tune_encode(tmp_path):
+    """QSVEncC AVC with --tune hq produces valid output."""
+    _skip_if_no_qsvencc()
+
+    source = SOURCES["hdr10plus"]
+    if not source.exists():
+        pytest.skip("HDR10+ test source not found")
+
+    output_path = tmp_path / "avc_tune_encode.mkv"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    fastflix = create_fastflix(
+        source_path=source,
+        encoder_settings=QSVEncCH264Settings(preset="fastest", bitrate="1000k", tune="hq"),
+        output_path=output_path,
+        work_path=work_path,
+        is_rigaya=True,
+        include_data=False,
+        include_attachments=False,
+    )
+
+    from fastflix.encoders.qsvencc_avc import command_builder
+
+    commands = command_builder.build(fastflix)
+    assert commands
+
+    run_commands(commands, work_path)
+    verify_output(output_path, "h264")
diff --git a/tests/e2e/test_e2e_videotoolbox.py b/tests/e2e/test_e2e_videotoolbox.py
new file mode 100644
index 00000000..0a9e7c26
--- /dev/null
+++ b/tests/e2e/test_e2e_videotoolbox.py
@@ -0,0 +1,607 @@
+# -*- coding: utf-8 -*-
+"""
+E2E tests for VideoToolbox (Apple) encoders — HEVC and H264.
+
+These tests verify that commands are correctly generated and, on macOS
+hardware with VideoToolbox support, produce valid output files.
+
+Run locally (macOS only):
+    uv run pytest tests/e2e/test_e2e_videotoolbox.py -v
+    SKIP_MAC=1 uv run pytest tests/e2e -v  # skip Mac tests
+
+Skipped on CI (GitHub Actions sets CI=true).
+Skipped on non-Mac platforms (VideoToolbox is macOS-only).
+"""
+
+import pytest
+
+from fastflix.models.encode import H264VideoToolboxSettings, HEVCVideoToolboxSettings
+
+from tests.e2e.conftest import (
+    FFMPEG,
+    FFPROBE,
+    ON_CI,
+    SKIP_MAC,
+    SOURCES,
+    create_fastflix,
+    has_ffmpeg_encoder,
+    run_commands,
+    verify_output,
+)
+
+pytestmark = [pytest.mark.e2e]
+
+if ON_CI:
+    pytestmark.append(pytest.mark.skip(reason="E2E tests skipped on CI"))
+if not FFMPEG or not FFPROBE:
+    pytestmark.append(pytest.mark.skip(reason="ffmpeg/ffprobe not found"))
+
+
+def _skip_if_no_videotoolbox(encoder_name: str):
+    if not has_ffmpeg_encoder(encoder_name):
+        pytest.skip(f"{encoder_name} not available in this FFmpeg build")
+    if SKIP_MAC:
+        pytest.skip("Mac tests skipped via SKIP_MAC")
+
+
+# ===========================================================================
+# HEVC VideoToolbox
+# ===========================================================================
+
+
+class TestHEVCVideoToolbox:
+    """HEVC VideoToolbox encoder E2E tests."""
+
+    def _skip(self):
+        _skip_if_no_videotoolbox("hevc_videotoolbox")
+
+    # -- Command generation (no hardware needed, just needs FFmpeg awareness) --
+
+    def test_command_profile_auto(self, tmp_path):
+        """Profile Auto omits -profile:v from generated command."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "hevc_vtb_auto.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=HEVCVideoToolboxSettings(profile=0, q=50),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.hevc_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        assert commands
+        cmd = commands[0].command
+        assert "-profile:v" not in cmd
+        assert "hevc_videotoolbox" in cmd
+
+    def test_command_profile_main(self, tmp_path):
+        """Profile Main emits -profile:v main."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "hevc_vtb_main.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=HEVCVideoToolboxSettings(profile=1, q=50),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.hevc_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        cmd = commands[0].command
+        idx = cmd.index("-profile:v")
+        assert cmd[idx + 1] == "main"
+
+    def test_command_profile_main10(self, tmp_path):
+        """Profile Main10 emits -profile:v main10."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "hevc_vtb_main10.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=HEVCVideoToolboxSettings(profile=2, q=50, pix_fmt="p010le"),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.hevc_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        cmd = commands[0].command
+        idx = cmd.index("-profile:v")
+        assert cmd[idx + 1] == "main10"
+
+    def test_command_bitrate_two_pass(self, tmp_path):
+        """Bitrate mode produces two-pass commands."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "hevc_vtb_bitrate.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=HEVCVideoToolboxSettings(q=None, bitrate="3000k"),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.hevc_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        assert len(commands) == 2
+        assert "-pass" in commands[0].command
+        assert "-pass" in commands[1].command
+        assert "-b:v" in commands[0].command
+        assert "-b:v" in commands[1].command
+
+    def test_command_boolean_flags(self, tmp_path):
+        """Boolean options (allow_sw, realtime, etc.) appear as 'true'/'false'."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "hevc_vtb_bools.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=HEVCVideoToolboxSettings(q=50, allow_sw=True, realtime=True),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.hevc_videotoolbox import command_builder
+
+        cmd = command_builder.build(fastflix)[0].command
+        assert cmd[cmd.index("-allow_sw") + 1] == "true"
+        assert cmd[cmd.index("-realtime") + 1] == "true"
+        assert cmd[cmd.index("-require_sw") + 1] == "false"
+
+    # -- Full encode (needs VideoToolbox hardware) --
+
+    def test_encode_quality_auto_profile(self, tmp_path):
+        """Encode with Auto profile and constant quality produces valid HEVC output."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "hevc_vtb_encode_auto.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=HEVCVideoToolboxSettings(profile=0, q=50),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.hevc_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        run_commands(commands, work_path)
+        verify_output(output_path, "hevc")
+
+    def test_encode_quality_main_profile(self, tmp_path):
+        """Encode with Main profile and constant quality."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "hevc_vtb_encode_main.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=HEVCVideoToolboxSettings(profile=1, q=50, pix_fmt="yuv420p"),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.hevc_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        run_commands(commands, work_path)
+        verify_output(output_path, "hevc")
+
+    def test_encode_quality_main10_profile(self, tmp_path):
+        """Encode with Main10 profile (10-bit) and constant quality."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "hevc_vtb_encode_main10.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=HEVCVideoToolboxSettings(profile=2, q=50, pix_fmt="p010le"),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.hevc_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        run_commands(commands, work_path)
+        verify_output(output_path, "hevc")
+
+    def test_encode_bitrate_mode(self, tmp_path):
+        """Two-pass bitrate encode produces valid HEVC output."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "hevc_vtb_encode_bitrate.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=HEVCVideoToolboxSettings(q=None, bitrate="3000k"),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.hevc_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        assert len(commands) == 2
+        run_commands(commands, work_path)
+        verify_output(output_path, "hevc")
+
+    def test_encode_allow_sw(self, tmp_path):
+        """Encode with allow_sw=True (software fallback) produces valid output."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "hevc_vtb_allow_sw.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=HEVCVideoToolboxSettings(q=50, allow_sw=True),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.hevc_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        run_commands(commands, work_path)
+        verify_output(output_path, "hevc")
+
+    def test_encode_mkv_output(self, tmp_path):
+        """HEVC VideoToolbox can encode to MKV container."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "hevc_vtb_encode.mkv"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=HEVCVideoToolboxSettings(q=50),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.hevc_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        run_commands(commands, work_path)
+        verify_output(output_path, "hevc")
+
+
+# ===========================================================================
+# H264 VideoToolbox
+# ===========================================================================
+
+
+class TestH264VideoToolbox:
+    """H264 VideoToolbox encoder E2E tests."""
+
+    def _skip(self):
+        _skip_if_no_videotoolbox("h264_videotoolbox")
+
+    # -- Command generation --
+
+    def test_command_profile_auto(self, tmp_path):
+        """Profile Auto omits -profile:v from generated command."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "h264_vtb_auto.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=H264VideoToolboxSettings(profile=0, q=50),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.h264_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        assert commands
+        cmd = commands[0].command
+        assert "-profile:v" not in cmd
+        assert "h264_videotoolbox" in cmd
+
+    def test_command_profile_baseline(self, tmp_path):
+        """Profile baseline emits -profile:v baseline."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "h264_vtb_baseline.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=H264VideoToolboxSettings(profile=1, q=50),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.h264_videotoolbox import command_builder
+
+        cmd = command_builder.build(fastflix)[0].command
+        idx = cmd.index("-profile:v")
+        assert cmd[idx + 1] == "baseline"
+
+    def test_command_profile_high(self, tmp_path):
+        """Profile high emits -profile:v high."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "h264_vtb_high.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=H264VideoToolboxSettings(profile=3, q=50),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.h264_videotoolbox import command_builder
+
+        cmd = command_builder.build(fastflix)[0].command
+        idx = cmd.index("-profile:v")
+        assert cmd[idx + 1] == "high"
+
+    def test_command_bitrate_two_pass(self, tmp_path):
+        """Bitrate mode produces two-pass commands."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "h264_vtb_bitrate.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=H264VideoToolboxSettings(q=None, bitrate="3000k"),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.h264_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        assert len(commands) == 2
+
+    # -- Full encode --
+
+    def test_encode_quality_auto_profile(self, tmp_path):
+        """Encode with Auto profile produces valid H264 output."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "h264_vtb_encode_auto.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=H264VideoToolboxSettings(profile=0, q=50, pix_fmt="yuv420p"),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.h264_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        run_commands(commands, work_path)
+        verify_output(output_path, "h264")
+
+    def test_encode_quality_high_profile(self, tmp_path):
+        """Encode with High profile produces valid H264 output."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "h264_vtb_encode_high.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=H264VideoToolboxSettings(profile=3, q=50, pix_fmt="yuv420p"),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.h264_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        run_commands(commands, work_path)
+        verify_output(output_path, "h264")
+
+    def test_encode_bitrate_mode(self, tmp_path):
+        """Two-pass bitrate encode produces valid H264 output."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "h264_vtb_encode_bitrate.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=H264VideoToolboxSettings(q=None, bitrate="3000k", pix_fmt="yuv420p"),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.h264_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        assert len(commands) == 2
+        run_commands(commands, work_path)
+        verify_output(output_path, "h264")
+
+    def test_encode_allow_sw(self, tmp_path):
+        """Encode with allow_sw=True produces valid output."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "h264_vtb_allow_sw.mp4"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=H264VideoToolboxSettings(q=50, allow_sw=True, pix_fmt="yuv420p"),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.h264_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        run_commands(commands, work_path)
+        verify_output(output_path, "h264")
+
+    def test_encode_mkv_output(self, tmp_path):
+        """H264 VideoToolbox can encode to MKV container."""
+        self._skip()
+        source = SOURCES["hdr10plus"]
+        if not source.exists():
+            pytest.skip("HDR10+ test source not found")
+
+        output_path = tmp_path / "h264_vtb_encode.mkv"
+        work_path = tmp_path / "work"
+        work_path.mkdir()
+
+        fastflix = create_fastflix(
+            source_path=source,
+            encoder_settings=H264VideoToolboxSettings(q=50, pix_fmt="yuv420p"),
+            output_path=output_path,
+            work_path=work_path,
+            include_data=False,
+            include_attachments=False,
+        )
+
+        from fastflix.encoders.h264_videotoolbox import command_builder
+
+        commands = command_builder.build(fastflix)
+        run_commands(commands, work_path)
+        verify_output(output_path, "h264")
diff --git a/tests/encoders/test_aom_av1_command_builder.py b/tests/encoders/test_aom_av1_command_builder.py
index feb23700..2084d060 100644
--- a/tests/encoders/test_aom_av1_command_builder.py
+++ b/tests/encoders/test_aom_av1_command_builder.py
@@ -161,6 +161,37 @@ def test_aom_av1_row_mt_disabled():
     assert "-row-mt" not in cmd
 
 
+def test_aom_av1_two_pass_crf():
+    """Test 2-pass CRF encoding produces two commands."""
+    result = _build_with_settings(single_pass=False)
+    assert len(result) == 2
+    cmd1 = result[0].command
+    cmd2 = result[1].command
+    # First pass: CRF + pass 1 + null output
+    assert "-crf" in cmd1
+    assert "26" in cmd1
+    assert "-pass" in cmd1
+    assert "1" in cmd1
+    assert "-passlogfile" in cmd1
+    assert "-an" in cmd1
+    # Second pass: CRF + pass 2 + real output
+    assert "-crf" in cmd2
+    assert "26" in cmd2
+    assert "-pass" in cmd2
+    assert "2" in cmd2
+    assert "-passlogfile" in cmd2
+
+
+def test_aom_av1_single_pass_crf():
+    """Test single-pass CRF (default) produces one command."""
+    result = _build_with_settings(single_pass=True)
+    assert len(result) == 1
+    cmd = result[0].command
+    assert "-crf" in cmd
+    assert "-pass" not in cmd
+    assert "-passlogfile" not in cmd
+
+
 def test_aom_av1_all_elements_are_strings():
     """Test that all command elements are strings."""
     result = _build_with_settings()
diff --git a/tests/encoders/test_attachments.py b/tests/encoders/test_attachments.py
index 097f5d02..40cb6b6c 100644
--- a/tests/encoders/test_attachments.py
+++ b/tests/encoders/test_attachments.py
@@ -72,17 +72,17 @@ def test_build_attachments_with_cover(sample_attachment_tracks):
     # Verify the structure by checking index-based ordering for first attachment
     first_attach_idx = result.index("-attach")
     assert result[first_attach_idx + 1] == "cover.jpg"
-    assert result[first_attach_idx + 2] == "-metadata:s:0"
+    assert result[first_attach_idx + 2] == "-metadata:s:t:0"
     assert result[first_attach_idx + 3] == "mimetype=image/jpeg"
-    assert result[first_attach_idx + 4] == "-metadata:s:0"
+    assert result[first_attach_idx + 4] == "-metadata:s:t:0"
     assert result[first_attach_idx + 5] == "filename=cover.jpg"
 
     # Verify the structure for second attachment
     second_attach_idx = result.index("-attach", first_attach_idx + 1)
     assert result[second_attach_idx + 1] == "thumbnail.png"
-    assert result[second_attach_idx + 2] == "-metadata:s:1"
+    assert result[second_attach_idx + 2] == "-metadata:s:t:1"
     assert result[second_attach_idx + 3] == "mimetype=image/png"
-    assert result[second_attach_idx + 4] == "-metadata:s:1"
+    assert result[second_attach_idx + 4] == "-metadata:s:t:1"
     assert result[second_attach_idx + 5] == "filename=thumbnail.png"
 
 
@@ -110,17 +110,17 @@ def test_build_attachments_with_custom_paths():
     # Verify first attachment with custom path and filename
     first_attach_idx = result.index("-attach")
     assert result[first_attach_idx + 1] == "path/to/cover.jpg"
-    assert result[first_attach_idx + 2] == "-metadata:s:0"
+    assert result[first_attach_idx + 2] == "-metadata:s:t:0"
     assert result[first_attach_idx + 3] == "mimetype=image/jpeg"
-    assert result[first_attach_idx + 4] == "-metadata:s:0"
+    assert result[first_attach_idx + 4] == "-metadata:s:t:0"
     assert result[first_attach_idx + 5] == "filename=movie_cover.jpg"
 
     # Verify second attachment with spaces in path and custom filename
     second_attach_idx = result.index("-attach", first_attach_idx + 1)
     assert result[second_attach_idx + 1] == "path/with spaces/thumbnail.png"
-    assert result[second_attach_idx + 2] == "-metadata:s:1"
+    assert result[second_attach_idx + 2] == "-metadata:s:t:1"
     assert result[second_attach_idx + 3] == "mimetype=image/png"
-    assert result[second_attach_idx + 4] == "-metadata:s:1"
+    assert result[second_attach_idx + 4] == "-metadata:s:t:1"
     assert result[second_attach_idx + 5] == "filename=movie_thumbnail.png"
 
 
@@ -153,7 +153,16 @@ def test_build_attachments_non_cover_type():
     # Verify the structure of the single cover attachment
     attach_idx = result.index("-attach")
     assert result[attach_idx + 1] == "cover.jpg"
-    assert result[attach_idx + 2] == "-metadata:s:0"
+    assert result[attach_idx + 2] == "-metadata:s:t:0"
     assert result[attach_idx + 3] == "mimetype=image/jpeg"
-    assert result[attach_idx + 4] == "-metadata:s:0"
+    assert result[attach_idx + 4] == "-metadata:s:t:0"
     assert result[attach_idx + 5] == "filename=cover.jpg"
+
+
+def test_build_attachments_offset_by_mapped_attachments(sample_attachment_tracks):
+    """Cover attachments are indexed after attachment streams mapped from the source."""
+    result = build_attachments(sample_attachment_tracks, mapped_attachment_count=2)
+    first_attach_idx = result.index("-attach")
+    assert result[first_attach_idx + 2] == "-metadata:s:t:2"
+    second_attach_idx = result.index("-attach", first_attach_idx + 1)
+    assert result[second_attach_idx + 2] == "-metadata:s:t:3"
diff --git a/tests/encoders/test_audio.py b/tests/encoders/test_audio.py
index 3f536af2..5d36b5b2 100644
--- a/tests/encoders/test_audio.py
+++ b/tests/encoders/test_audio.py
@@ -97,7 +97,7 @@ def test_audio_quality_converter_ac3():
     """Test the audio_quality_converter function with ac3 codec."""
     # Test with different quality levels and channel counts
     result = audio_quality_converter(0, "ac3", channels=2, track_number=1)
-    assert result == "-b:1 960k"
+    assert result == "-b:1 640k"  # clamped to the AC-3 maximum
 
     result = audio_quality_converter(5, "ac3", channels=6, track_number=1)
     assert result == "-b:1 576k"
@@ -228,3 +228,65 @@ def test_build_audio_with_strict_codecs(sample_audio_tracks):
     assert "-strict" in result
     assert "-2" in result
     assert _has_consecutive(result, "-strict", "-2")
+
+
+def test_build_audio_with_conversion_profile(sample_audio_tracks):
+    """Test build_audio emits -profile:X when conversion_profile is set (libfdk_aac only)."""
+    sample_audio_tracks[0].conversion_codec = "libfdk_aac"
+    sample_audio_tracks[0].conversion_profile = "aac_he"
+    sample_audio_tracks[0].conversion_bitrate = "64k"
+
+    result = build_audio(sample_audio_tracks)
+
+    assert _has_consecutive(result, "-c:0", "libfdk_aac")
+    assert _has_consecutive(result, "-profile:0", "aac_he")
+    assert _has_consecutive(result, "-b:0", "64k")
+
+
+def test_build_audio_with_conversion_profile_he_v2(sample_audio_tracks):
+    """Test build_audio emits -profile:X aac_he_v2."""
+    sample_audio_tracks[0].conversion_codec = "libfdk_aac"
+    sample_audio_tracks[0].conversion_profile = "aac_he_v2"
+    sample_audio_tracks[0].conversion_bitrate = "48k"
+    sample_audio_tracks[0].downmix = "stereo"
+
+    result = build_audio(sample_audio_tracks)
+
+    assert _has_consecutive(result, "-c:0", "libfdk_aac")
+    assert _has_consecutive(result, "-profile:0", "aac_he_v2")
+
+
+def test_build_audio_he_v2_falls_back_to_he_for_surround(sample_audio_tracks):
+    """HE-AACv2 needs stereo; a 5.1 output falls back to HE-AAC."""
+    sample_audio_tracks[0].conversion_codec = "libfdk_aac"
+    sample_audio_tracks[0].conversion_profile = "aac_he_v2"
+    sample_audio_tracks[0].conversion_bitrate = "96k"
+    sample_audio_tracks[0].downmix = "No Downmix"
+
+    result = build_audio(sample_audio_tracks)
+
+    assert _has_consecutive(result, "-profile:0", "aac_he")
+
+
+def test_build_audio_native_aac_ignores_he_profile(sample_audio_tracks):
+    """FFmpeg's native aac encoder fails on HE profiles, so they must not be emitted."""
+    for profile in ("aac_he", "aac_he_v2"):
+        sample_audio_tracks[0].conversion_codec = "aac"
+        sample_audio_tracks[0].conversion_profile = profile
+        sample_audio_tracks[0].conversion_bitrate = "128k"
+
+        result = build_audio(sample_audio_tracks)
+
+        assert "-profile:0" not in result
+
+
+def test_build_audio_no_profile_when_none(sample_audio_tracks):
+    """Test build_audio does NOT emit -profile:X when conversion_profile is None."""
+    sample_audio_tracks[0].conversion_codec = "aac"
+    sample_audio_tracks[0].conversion_profile = None
+    sample_audio_tracks[0].conversion_bitrate = "128k"
+
+    result = build_audio(sample_audio_tracks)
+
+    assert _has_consecutive(result, "-c:0", "aac")
+    assert "-profile:0" not in result
diff --git a/tests/encoders/test_avc_x264_command_builder.py b/tests/encoders/test_avc_x264_command_builder.py
index ec0e074b..b4c60bbb 100644
--- a/tests/encoders/test_avc_x264_command_builder.py
+++ b/tests/encoders/test_avc_x264_command_builder.py
@@ -421,3 +421,36 @@ def test_avc_x264_defaults_no_extra():
             assert "-psy-rd" not in cmd
             assert "-level" not in cmd
             assert "-x264-params" not in cmd
+
+
+def _x264_hdr_params(pix_fmt, remove_hdr=False, hdr10=True):
+    fastflix = create_fastflix_instance(
+        encoder_settings=x264Settings(crf=23, preset="medium", pix_fmt=pix_fmt, bitrate=None),
+        video_settings=VideoSettings(remove_hdr=remove_hdr, maxrate=None, bufsize=None),
+        hdr10_metadata=hdr10,
+    )
+    with mock.patch("fastflix.encoders.avc_x264.command_builder.generate_all") as mock_gen:
+        mock_gen.return_value = (["ffmpeg", "-y", "-i", "input.mkv"], ["output.mkv"], [])
+        cmd = build(fastflix)[0].command
+    return cmd[cmd.index("-x264-params") + 1] if "-x264-params" in cmd else ""
+
+
+def test_avc_x264_10bit_master_display_and_cll():
+    params = _x264_hdr_params("yuv420p10le")
+    assert "mastering-display=G(" in params
+    assert "cll=1000,300" in params
+
+
+def test_avc_x264_10bit_422_master_display():
+    assert "mastering-display=G(" in _x264_hdr_params("yuv422p10le")
+
+
+def test_avc_x264_8bit_no_hdr_metadata():
+    params = _x264_hdr_params("yuv420p")
+    assert "mastering-display" not in params
+    assert "cll=" not in params
+
+
+def test_avc_x264_remove_hdr_no_hdr_metadata():
+    params = _x264_hdr_params("yuv420p10le", remove_hdr=True)
+    assert "mastering-display" not in params
diff --git a/tests/encoders/test_encc_helpers.py b/tests/encoders/test_encc_helpers.py
index 47464bba..c85f8f17 100644
--- a/tests/encoders/test_encc_helpers.py
+++ b/tests/encoders/test_encc_helpers.py
@@ -8,7 +8,9 @@
     rigaya_avformat_reader,
     rigaya_auto_options,
     rigaya_trim_or_seek,
-    _parse_frame_rate,
+    rigaya_extra_options,
+    RIGAYA_DENOISE_MAP,
+    parse_frame_rate,
     pa_builder,
     get_stream_pos,
     build_audio,
@@ -17,6 +19,10 @@
 from fastflix.models.encode import VCEEncCSettings
 
 
+def value_after(cmd, flag):
+    return cmd[cmd.index(flag) + 1]
+
+
 @pytest.fixture
 def encc_fastflix_instance(fastflix_instance):
     """
@@ -233,7 +239,7 @@ def test_pa_builder_disabled():
 
     # Test the function
     result = pa_builder(settings)
-    assert result == ""
+    assert result == []
 
 
 def test_pa_builder_basic():
@@ -245,7 +251,7 @@ def test_pa_builder_basic():
 
     # Test the function
     result = pa_builder(settings)
-    assert result == "--pa sc=medium,ss=high,activity-type=y,caq-strength=medium,ltr=true,fskip-maxqp=35"
+    assert result == ["--pa", "sc=medium,ss=high,activity-type=y,caq-strength=medium,ltr=true,fskip-maxqp=35"]
 
 
 def test_pa_builder_with_optional_params():
@@ -268,6 +274,9 @@ def test_pa_builder_with_optional_params():
 
     # Test the function
     result = pa_builder(settings)
+    assert result[0] == "--pa"
+    assert len(result) == 2
+    result = result[1]
     assert "sc=medium" in result
     assert "ss=high" in result
     assert "activity-type=y" in result
@@ -521,40 +530,40 @@ def test_build_subtitle_with_4k_scaling(sample_subtitle_tracks):
     assert "--vpp-subburn" in result and "track=1,scale=2.0" in result
 
 
-# --- _parse_frame_rate tests ---
+# --- parse_frame_rate tests ---
 
 
-def test_parse_frame_rate_rational():
+def testparse_frame_rate_rational():
     """Test parsing a rational frame rate string like '24000/1001'."""
-    result = _parse_frame_rate("24000/1001")
+    result = parse_frame_rate("24000/1001")
     assert result == pytest.approx(23.976, rel=1e-3)
 
 
-def test_parse_frame_rate_integer_string():
+def testparse_frame_rate_integer_string():
     """Test parsing a plain integer frame rate string."""
-    result = _parse_frame_rate("30")
+    result = parse_frame_rate("30")
     assert result == 30.0
 
 
-def test_parse_frame_rate_float_string():
+def testparse_frame_rate_float_string():
     """Test parsing a plain float frame rate string."""
-    result = _parse_frame_rate("29.97")
+    result = parse_frame_rate("29.97")
     assert result == pytest.approx(29.97)
 
 
-def test_parse_frame_rate_empty():
+def testparse_frame_rate_empty():
     """Test parsing an empty string returns None."""
-    assert _parse_frame_rate("") is None
+    assert parse_frame_rate("") is None
 
 
-def test_parse_frame_rate_invalid():
+def testparse_frame_rate_invalid():
     """Test parsing an invalid string returns None."""
-    assert _parse_frame_rate("abc") is None
+    assert parse_frame_rate("abc") is None
 
 
-def test_parse_frame_rate_zero_denominator():
+def testparse_frame_rate_zero_denominator():
     """Test parsing a rational with zero denominator returns None."""
-    assert _parse_frame_rate("24000/0") is None
+    assert parse_frame_rate("24000/0") is None
 
 
 # --- rigaya_trim_or_seek tests ---
@@ -732,3 +741,331 @@ def test_rigaya_trim_or_seek_exact_mode_no_frame_rate_fallback(encc_fastflix_ins
     assert "--seek" in result
     assert "--seekto" in result
     assert "--trim" not in result
+
+
+# --- rigaya_extra_options tests ---
+
+
+def test_rigaya_extra_options_equalizer_all(encc_fastflix_instance):
+    """Test --vpp-tweak with all four equalizer values set."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.brightness = "0.1"
+    video.video_settings.contrast = "1.5"
+    video.video_settings.saturation = "1.2"
+    video.video_settings.gamma = "0.9"
+    result = rigaya_extra_options(video)
+    assert "--vpp-tweak" in result
+    tweak_value = result[result.index("--vpp-tweak") + 1]
+    assert "brightness=0.1" in tweak_value
+    assert "contrast=1.5" in tweak_value
+    assert "saturation=1.2" in tweak_value
+    assert "gamma=0.9" in tweak_value
+
+
+def test_rigaya_extra_options_equalizer_partial(encc_fastflix_instance):
+    """Test --vpp-tweak with only some values set."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.brightness = "0.2"
+    video.video_settings.gamma = "2.0"
+    result = rigaya_extra_options(video)
+    assert "--vpp-tweak" in result
+    tweak_value = result[result.index("--vpp-tweak") + 1]
+    assert "brightness=0.2" in tweak_value
+    assert "gamma=2.0" in tweak_value
+    assert "contrast" not in tweak_value
+    assert "saturation" not in tweak_value
+
+
+def test_rigaya_extra_options_equalizer_defaults_skipped(encc_fastflix_instance):
+    """Test that default values produce no --vpp-tweak."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.brightness = "0"
+    video.video_settings.contrast = "1.0"
+    video.video_settings.saturation = "1"
+    video.video_settings.gamma = "1.0"
+    result = rigaya_extra_options(video)
+    assert "--vpp-tweak" not in result
+
+
+def test_rigaya_extra_options_equalizer_none(encc_fastflix_instance):
+    """Test that None values produce no --vpp-tweak."""
+    video = encc_fastflix_instance.current_video
+    result = rigaya_extra_options(video)
+    assert "--vpp-tweak" not in result
+
+
+def test_rigaya_extra_options_equalizer_clamping(encc_fastflix_instance):
+    """Test that values are clamped to rigaya ranges."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.brightness = "5.0"  # exceeds 1.0
+    video.video_settings.saturation = "-1.0"  # below 0.0
+    result = rigaya_extra_options(video)
+    assert "--vpp-tweak" in result
+    tweak_value = result[result.index("--vpp-tweak") + 1]
+    assert "brightness=1.0" in tweak_value
+    assert "saturation=0.0" in tweak_value
+
+
+def test_rigaya_extra_options_denoise_nlmeans(encc_fastflix_instance):
+    """Test denoise mapping for nlmeans presets."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.denoise = "nlmeans=s=1.0:p=3:r=9"
+    result = rigaya_extra_options(video)
+    assert "--vpp-nlmeans" in result
+    assert "sigma=1.0,h=1.0,patch=3,search=9" in result
+
+
+def test_rigaya_extra_options_denoise_atadenoise(encc_fastflix_instance):
+    """Test denoise mapping for atadenoise -> knn."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.denoise = "atadenoise=0a=0.02:0b=0.04:1a=0.02:1b=0.04:2a=0.02:2b=0.04:s=9"
+    result = rigaya_extra_options(video)
+    assert "--vpp-knn" in result
+
+
+def test_rigaya_extra_options_denoise_hqdn3d(encc_fastflix_instance):
+    """Test denoise mapping for hqdn3d -> pmd."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.denoise = "hqdn3d=luma_spatial=4:chroma_spatial=3:luma_tmp=6:chroma_tmp=4.5"
+    result = rigaya_extra_options(video)
+    assert "--vpp-pmd" in result
+
+
+def test_rigaya_extra_options_denoise_vaguedenoiser(encc_fastflix_instance):
+    """Test denoise mapping for vaguedenoiser -> pmd."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.denoise = "vaguedenoiser=threshold=3:method=soft:nsteps=5"
+    result = rigaya_extra_options(video)
+    assert "--vpp-pmd" in result
+
+
+def test_rigaya_extra_options_denoise_all_presets_mapped():
+    """Test that all 15 known denoise presets have mappings (12 original + 3 nlmeans_opencl)."""
+    assert len(RIGAYA_DENOISE_MAP) == 15
+
+
+def test_rigaya_extra_options_denoise_unknown(encc_fastflix_instance):
+    """Test that unknown denoise strings are skipped."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.denoise = "unknown_filter=strength=5"
+    result = rigaya_extra_options(video)
+    assert "--vpp-nlmeans" not in result
+    assert "--vpp-knn" not in result
+    assert "--vpp-pmd" not in result
+
+
+def test_rigaya_extra_options_deblock_weak(encc_fastflix_instance):
+    """Test deblock weak mapping."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.deblock = "weak"
+    result = rigaya_extra_options(video)
+    assert value_after(result, "--vpp-deblock") == "qp=24"
+    assert "strength=30" not in result
+
+
+def test_rigaya_extra_options_deblock_strong(encc_fastflix_instance):
+    """Test deblock strong mapping."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.deblock = "strong"
+    result = rigaya_extra_options(video)
+    assert value_after(result, "--vpp-deblock") == "qp=36,alpha=2,beta=2"
+
+
+def test_rigaya_extra_options_output_fps(encc_fastflix_instance):
+    """Test output FPS mapping."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.output_fps = "24"
+    result = rigaya_extra_options(video, fruc=True)
+    assert value_after(result, "--vpp-fruc") == "fps=24/1"
+    assert "--vpp-fps" not in result
+
+
+@pytest.mark.parametrize(
+    "value,expected", [("30", "30/1"), ("23.976", "2997/125"), ("24000/1001", "24000/1001"), ("59.94", "2997/50")]
+)
+def test_rigaya_extra_options_output_fps_fraction(encc_fastflix_instance, value, expected):
+    video = encc_fastflix_instance.current_video
+    video.video_settings.output_fps = value
+    assert value_after(rigaya_extra_options(video, fruc=True), "--vpp-fruc") == f"fps={expected}"
+
+
+def test_rigaya_extra_options_output_fps_invalid(encc_fastflix_instance):
+    video = encc_fastflix_instance.current_video
+    video.video_settings.output_fps = "fast"
+    assert "--vpp-fruc" not in rigaya_extra_options(video, fruc=True)
+
+
+def test_rigaya_extra_options_output_fps_unsupported_vendor_skipped(encc_fastflix_instance, caplog):
+    """QSVEncC and VCEEncC have no output-fps filter (VCE --vpp-frc takes no fps), so nothing is emitted."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.output_fps = "24"
+    with caplog.at_level("WARNING", logger="fastflix"):
+        result = rigaya_extra_options(video)
+    assert "--vpp-fps" not in result
+    assert "--vpp-fruc" not in result
+    assert "--vpp-frc" not in result
+    assert "output frame rate" in caplog.text.lower()
+
+
+def test_rigaya_extra_options_video_track_title(encc_fastflix_instance):
+    """Test video track title mapping."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.video_track_title = "My Video"
+    result = rigaya_extra_options(video)
+    assert "--video-metadata" in result
+    assert "title=My Video" in result
+
+
+def test_rigaya_extra_options_combined(encc_fastflix_instance):
+    """Test multiple features combined in a single call."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.brightness = "0.1"
+    video.video_settings.gamma = "1.5"
+    video.video_settings.denoise = "nlmeans=s=10.0:p=13:r=25"
+    video.video_settings.deblock = "strong"
+    video.video_settings.output_fps = "30"
+    video.video_settings.video_track_title = "Test"
+    result = rigaya_extra_options(video, fruc=True)
+    assert "--vpp-tweak" in result
+    assert "--vpp-nlmeans" in result
+    assert "--vpp-deblock" in result
+    assert "--vpp-fruc" in result
+    assert "--video-metadata" in result
+
+
+def test_rigaya_extra_options_sharpen(encc_fastflix_instance):
+    """Test that sharpen generates --vpp-unsharp with correct parameters."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.sharpen = "0.7"
+    result = rigaya_extra_options(video)
+    assert "--vpp-unsharp" in result
+    idx = result.index("--vpp-unsharp")
+    assert "radius=3,weight=0.7" in result[idx + 1]
+
+
+def test_rigaya_extra_options_sharpen_zero(encc_fastflix_instance):
+    """Test that sharpen value of 0 does not add --vpp-unsharp."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.sharpen = "0"
+    result = rigaya_extra_options(video)
+    assert "--vpp-unsharp" not in result
+
+
+def test_rigaya_extra_options_sharpen_clamped(encc_fastflix_instance):
+    """Test that sharpen value is clamped to 1.0 max."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.sharpen = "1.5"
+    result = rigaya_extra_options(video)
+    assert "--vpp-unsharp" in result
+    idx = result.index("--vpp-unsharp")
+    assert "radius=3,weight=1.0" in result[idx + 1]
+
+
+def test_rigaya_extra_options_gop_length(encc_fastflix_instance):
+    """Test that gop_length generates --gop-len."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.gop_length = 250
+    result = rigaya_extra_options(video)
+    assert "--gop-len" in result
+    idx = result.index("--gop-len")
+    assert result[idx + 1] == "250"
+
+
+def test_rigaya_extra_options_gop_length_none(encc_fastflix_instance):
+    """Test that no gop_length does not add --gop-len."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.gop_length = None
+    result = rigaya_extra_options(video)
+    assert "--gop-len" not in result
+
+
+def test_rigaya_extra_options_curves_preset(encc_fastflix_instance):
+    """Test that curves_preset generates --vpp-curves."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.curves_preset = "vintage"
+    result = rigaya_extra_options(video)
+    assert "--vpp-curves" in result
+    idx = result.index("--vpp-curves")
+    assert result[idx + 1] == "preset=vintage"
+
+
+def test_rigaya_extra_options_curves_preset_none(encc_fastflix_instance):
+    """Test that no curves_preset does not add --vpp-curves."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.curves_preset = None
+    result = rigaya_extra_options(video)
+    assert "--vpp-curves" not in result
+
+
+def test_rigaya_extra_options_lut3d(encc_fastflix_instance):
+    """Test that lut3d_path generates --vpp-colorspace with lut3d."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.lut3d_path = "/path/to/my.cube"
+    result = rigaya_extra_options(video)
+    assert "--vpp-colorspace" in result
+    idx = result.index("--vpp-colorspace")
+    assert "lut3d=/path/to/my.cube" in result[idx + 1]
+    assert "lut3d_interp=tetrahedral" in result[idx + 1]
+
+
+def test_rigaya_extra_options_lut3d_none(encc_fastflix_instance):
+    """Test that no lut3d_path does not add --vpp-colorspace."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.lut3d_path = None
+    result = rigaya_extra_options(video)
+    assert "--vpp-colorspace" not in result
+
+
+def test_rigaya_extra_options_unsharp_preset(encc_fastflix_instance):
+    """Test that unsharp preset generates --vpp-unsharp with correct parameters."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.unsharp = "unsharp=5:5:1.0:5:5:0.5"
+    result = rigaya_extra_options(video)
+    assert "--vpp-unsharp" in result
+    idx = result.index("--vpp-unsharp")
+    assert "radius=3,weight=0.6" in result[idx + 1]
+
+
+def test_rigaya_extra_options_unsharp_overrides_sharpen(encc_fastflix_instance):
+    """Test that when both unsharp and sharpen are set, unsharp takes priority."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.unsharp = "unsharp=5:5:0.5:5:5:0.0"
+    video.video_settings.sharpen = "0.8"
+    result = rigaya_extra_options(video)
+    # Should only have one --vpp-unsharp (from unsharp, not sharpen)
+    count = result.count("--vpp-unsharp")
+    assert count == 1
+    idx = result.index("--vpp-unsharp")
+    assert "radius=3,weight=0.3" in result[idx + 1]
+
+
+def test_rigaya_extra_options_pad_16_9(encc_fastflix_instance):
+    """Test that pad aspect 16:9 generates --vpp-pad for 4:3 source."""
+    video = encc_fastflix_instance.current_video
+    # Set up a 4:3 source (1440x1080) via streams
+    video.streams.video[0].width = 1440
+    video.streams.video[0].height = 1080
+    video.video_settings.pad_aspect = "16:9"
+    result = rigaya_extra_options(video)
+    assert "--vpp-pad" in result
+    idx = result.index("--vpp-pad")
+    # 1080 * 16/9 = 1920, pad_left = (1920-1440)/2 = 240
+    assert "240,0,240,0" in result[idx + 1]
+
+
+def test_rigaya_extra_options_pad_none(encc_fastflix_instance):
+    """Test that no pad_aspect does not add --vpp-pad."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.pad_aspect = None
+    result = rigaya_extra_options(video)
+    assert "--vpp-pad" not in result
+
+
+def test_rigaya_extra_options_nlmeans_opencl(encc_fastflix_instance):
+    """Test that nlmeans_opencl denoise maps to rigaya --vpp-nlmeans."""
+    video = encc_fastflix_instance.current_video
+    video.video_settings.denoise = "nlmeans_opencl=s=1.0:p=3:r=9"
+    result = rigaya_extra_options(video)
+    assert "--vpp-nlmeans" in result
+    idx = result.index("--vpp-nlmeans")
+    assert "sigma=1.0,h=1.0,patch=3,search=9" in result[idx + 1]
diff --git a/tests/encoders/test_ffmpeg_av1_nvenc_command_builder.py b/tests/encoders/test_ffmpeg_av1_nvenc_command_builder.py
index 752c20ba..ca1cd0df 100644
--- a/tests/encoders/test_ffmpeg_av1_nvenc_command_builder.py
+++ b/tests/encoders/test_ffmpeg_av1_nvenc_command_builder.py
@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
 from unittest import mock
 
-from fastflix.encoders.common.helpers import null
 from fastflix.encoders.ffmpeg_av1_nvenc.command_builder import build
 from fastflix.models.encode import FFmpegAV1NVENCSettings
 from fastflix.models.video import VideoSettings
@@ -114,38 +113,19 @@ def test_ffmpeg_av1_nvenc_bitrate():
         ) as mock_generate_color_details:
             mock_generate_color_details.return_value = ["-color_primaries", "bt2020"]
 
-            with mock.patch("fastflix.encoders.ffmpeg_av1_nvenc.command_builder.secrets.token_hex") as mock_token_hex:
-                mock_token_hex.return_value = "abcdef1234"
-
-                result = build(fastflix)
-
-                assert isinstance(result, list)
-                assert len(result) == 2
-
-                cmd1 = result[0].command
-                cmd2 = result[1].command
-                assert isinstance(cmd1, list)
-                assert isinstance(cmd2, list)
+            result = build(fastflix)
 
-                # First pass
-                assert "-pass" in cmd1
-                assert "1" in cmd1[cmd1.index("-pass") + 1 :][:1]
-                assert "-b:v" in cmd1
-                assert "5000k" in cmd1
-                assert "-2pass" in cmd1
-                assert "-an" in cmd1
-                assert "-sn" in cmd1
-                assert "-dn" in cmd1
-                assert "-f" in cmd1
-                assert "mp4" in cmd1
-                assert null in cmd1
+            assert isinstance(result, list), f"Expected a list of Command objects, got {type(result)}"
+            assert len(result) == 1, f"Expected 1 Command object, got {len(result)}"
 
-                # Second pass
-                assert "-pass" in cmd2
-                assert "2" in cmd2[cmd2.index("-pass") + 1 :][:1]
-                assert "-b:v" in cmd2
-                assert "5000k" in cmd2
-                assert "output.mkv" in cmd2
+            cmd = result[0].command
+            assert "-b:v" in cmd
+            assert "5000k" in cmd
+            # FFmpeg NVENC does not support -pass/-2pass; two-pass is done internally via -multipass
+            assert "-pass" not in cmd
+            assert "-2pass" not in cmd
+            assert "-multipass:v" in cmd
+            assert "output.mkv" in cmd
 
 
 def test_ffmpeg_av1_nvenc_with_rc_level():
diff --git a/tests/encoders/test_ffmpeg_hevc_nvenc_command_builder.py b/tests/encoders/test_ffmpeg_hevc_nvenc_command_builder.py
index 393d066c..76b836a1 100644
--- a/tests/encoders/test_ffmpeg_hevc_nvenc_command_builder.py
+++ b/tests/encoders/test_ffmpeg_hevc_nvenc_command_builder.py
@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
 from unittest import mock
 
-from fastflix.encoders.common.helpers import null
 from fastflix.encoders.ffmpeg_hevc_nvenc.command_builder import build
 from fastflix.models.encode import FFmpegNVENCSettings
 from fastflix.models.video import VideoSettings
@@ -63,7 +62,7 @@ def test_ffmpeg_hevc_nvenc_qp():
             assert "28" in cmd
             assert "-preset:v" in cmd
             assert "slow" in cmd
-            assert "-spatial_aq:v" in cmd
+            assert "-spatial-aq:v" in cmd
             assert "-tier:v" in cmd
             assert "main" in cmd
             assert "-profile:v" in cmd
@@ -109,39 +108,19 @@ def test_ffmpeg_hevc_nvenc_bitrate():
         ) as mock_generate_color_details:
             mock_generate_color_details.return_value = ["-color_primaries", "bt2020"]
 
-            # Mock the secrets.token_hex function to return a predictable result
-            with mock.patch("fastflix.encoders.ffmpeg_hevc_nvenc.command_builder.secrets.token_hex") as mock_token_hex:
-                mock_token_hex.return_value = "abcdef1234"
-
-                result = build(fastflix)
-
-                assert isinstance(result, list), f"Expected a list of Command objects, got {type(result)}"
-                assert len(result) == 2, f"Expected 2 Command objects, got {len(result)}"
-
-                cmd1 = result[0].command
-                cmd2 = result[1].command
-                assert isinstance(cmd1, list), f"Expected command to be a list, got {type(cmd1)}"
-                assert isinstance(cmd2, list), f"Expected command to be a list, got {type(cmd2)}"
-
-                # First pass
-                assert "-pass" in cmd1
-                assert "1" in cmd1[cmd1.index("-pass") + 1 :][:1]
-                assert "-b:v" in cmd1
-                assert "6000k" in cmd1
-                assert "-2pass" in cmd1
-                assert "-an" in cmd1
-                assert "-sn" in cmd1
-                assert "-dn" in cmd1
-                assert "-f" in cmd1
-                assert "mp4" in cmd1
-                assert null in cmd1
-
-                # Second pass
-                assert "-pass" in cmd2
-                assert "2" in cmd2[cmd2.index("-pass") + 1 :][:1]
-                assert "-b:v" in cmd2
-                assert "6000k" in cmd2
-                assert "output.mkv" in cmd2
+            result = build(fastflix)
+
+            assert isinstance(result, list), f"Expected a list of Command objects, got {type(result)}"
+            assert len(result) == 1, f"Expected 1 Command object, got {len(result)}"
+
+            cmd = result[0].command
+            assert "-b:v" in cmd
+            assert "6000k" in cmd
+            # FFmpeg NVENC does not support -pass/-2pass; two-pass is done internally via -multipass
+            assert "-pass" not in cmd
+            assert "-2pass" not in cmd
+            assert "-multipass:v" in cmd
+            assert "output.mkv" in cmd
 
 
 def test_ffmpeg_hevc_nvenc_with_rc_level():
@@ -199,7 +178,7 @@ def test_ffmpeg_hevc_nvenc_with_rc_level():
             assert "vbr" in cmd
             assert "-level:v" in cmd
             assert "5.1" in cmd
-            assert "-spatial_aq:v" in cmd
+            assert "-spatial-aq:v" in cmd
             assert "1" in cmd
             assert "-tier:v" in cmd
             assert "high" in cmd
diff --git a/tests/encoders/test_filter_review_fixes.py b/tests/encoders/test_filter_review_fixes.py
new file mode 100644
index 00000000..2ce40bf3
--- /dev/null
+++ b/tests/encoders/test_filter_review_fixes.py
@@ -0,0 +1,257 @@
+# -*- coding: utf-8 -*-
+from pathlib import Path
+from unittest import mock
+
+import pytest
+from box import Box
+
+from fastflix.encoders.common.audio import audio_quality_converter, build_audio, channels_for_layout
+from fastflix.encoders.common.helpers import (
+    generate_all,
+    generate_color_details,
+    generate_ffmpeg_start,
+    generate_filters,
+    validate_ffmpeg_color,
+)
+from fastflix.encoders.common.subtitles import build_subtitle
+from fastflix.models.encode import AudioTrack, SubtitleTrack, x265Settings
+
+
+def _sub(index, outdex, kind="text", **kw):
+    return SubtitleTrack(index=index, outdex=outdex, language="eng", subtitle_type=kind, **kw)
+
+
+# ---- item 1: PGS burn-in
+@pytest.mark.parametrize("kind", ["picture", "pgs"])
+def test_bitmap_burn_in_uses_overlay(kind):
+    result = generate_filters(
+        selected_track=0, source=Path("in.mkv"), burn_in_subtitle_track=2, burn_in_subtitle_type=kind
+    )
+    assert "[0:0][0:2]overlay" in result[1]
+    assert "subtitles=" not in result[1]
+
+
+def test_text_burn_in_still_uses_subtitles_filter():
+    result = generate_filters(
+        selected_track=0, source=Path("in.mkv"), burn_in_subtitle_track=0, burn_in_subtitle_type="text"
+    )
+    assert "subtitles=" in result[1]
+
+
+# ---- item 2: bitmap subs in MP4, default_mode gating
+@pytest.mark.parametrize("kind", ["picture", "pgs"])
+def test_mp4_drops_bitmap_tracks_and_shifts_outdex(kind):
+    tracks = [_sub(3, 1, kind), _sub(4, 2, "text")]
+    cmd, _, _ = build_subtitle(tracks, output_path="out.mp4")
+    assert "0:3" not in cmd
+    assert "0:4" in cmd
+    assert "-c:1" in cmd and "-c:2" not in cmd
+    assert "mov_text" in cmd
+
+
+def test_mkv_keeps_bitmap_tracks_with_copy():
+    cmd, _, _ = build_subtitle([_sub(3, 1, "pgs")], output_path="out.mkv")
+    assert cmd[:4] == ["-map", "0:3", "-c:1", "copy"]
+
+
+@pytest.mark.parametrize(
+    "path,expected",
+    [("out.mkv", True), ("out.webm", True), ("out.MKV", True), ("out.mp4", False), ("out.avi", False), (None, True)],
+)
+def test_default_mode_only_for_matroska(path, expected):
+    cmd, _, _ = build_subtitle([], output_path=path)
+    assert (cmd[-2:] == ["-default_mode", "infer_no_subs"]) is expected
+
+
+# ---- item 3: burn-in index 0
+def test_burn_in_track_zero_shifts_later_outdex():
+    tracks = [_sub(0, 1, "text", burn_in=True), _sub(1, 2, "text")]
+    cmd, burn, kind = build_subtitle(tracks, output_path="out.mkv")
+    assert burn == 0 and kind == "text"
+    assert "-c:1" in cmd and "-c:2" not in cmd
+
+
+def test_external_burn_in_si_not_remapped_through_source_streams(fastflix_instance):
+    fastflix_instance.current_video.streams["subtitle"] = [Box({"index": 3}), Box({"index": 0})]
+    fastflix_instance.current_video.subtitle_tracks = [
+        _sub(0, 1, "text", burn_in=True, external=True, file_path="/p/x.srt")
+    ]
+    fastflix_instance.current_video.video_settings.video_encoder_settings = x265Settings()
+    with mock.patch("fastflix.encoders.common.helpers.build_subtitle") as bs:
+        bs.return_value = ([], 0, "text")
+        beginning, ending, _ = generate_all(fastflix_instance, "libx265")
+    assert ":si=0" in " ".join(beginning)
+
+
+# ---- item 4: audio
+@pytest.mark.parametrize(
+    "layout,count",
+    [("5.1(side)", 6), ("5.1.2", 8), ("7.1.2", 10), ("7.1.4", 12), ("6.1(back)", 7), ("octagonal", 8), ("stereo", 2)],
+)
+def test_channels_for_layout_known(layout, count):
+    assert channels_for_layout(layout, None) == count
+
+
+def test_channels_for_layout_unknown_uses_channels_field():
+    assert channels_for_layout("weird", 5) == 5
+    assert channels_for_layout("", 3) == 3
+    assert channels_for_layout("weird", None) is None
+
+
+def _audio(raw, downmix=None, codec="aac", **kw):
+    return AudioTrack(
+        index=1,
+        outdex=0,
+        codec="dts",
+        raw_info=Box(raw),
+        conversion_codec=codec,
+        conversion_bitrate="128k",
+        downmix=downmix,
+        **kw,
+    )
+
+
+def test_unknown_layout_does_not_force_stereo_or_raise():
+    cmd = build_audio([_audio({"channel_layout": "7.1.4", "channels": 12})])
+    assert "-c:0" in cmd
+    assert not any("channel_layouts=stereo" in x for x in cmd)
+
+
+def test_unknown_layout_skips_aformat():
+    cmd = build_audio([_audio({"channel_layout": "mystery", "channels": 4})])
+    assert not any("aformat" in x for x in cmd)
+
+
+def test_missing_layout_skips_aformat():
+    cmd = build_audio([_audio({"channels": 2})])
+    assert not any("aformat" in x for x in cmd)
+
+
+def test_downmix_still_sets_ac_and_aformat():
+    cmd = build_audio([_audio({"channel_layout": "5.1", "channels": 6}, downmix="stereo")])
+    assert "-ac:0" in cmd and "aformat=channel_layouts=stereo" in cmd
+
+
+def test_known_layout_keeps_aformat():
+    cmd = build_audio([_audio({"channel_layout": "5.1(side)", "channels": 6})])
+    assert "aformat=channel_layouts=5.1(side)" in cmd
+
+
+@pytest.mark.parametrize(
+    "codec,quality,channels,expected",
+    [
+        ("ac3", 0, 6, "-b:1 640k"),
+        ("ac3", 0, 2, "-b:1 640k"),
+        ("ac3", 9, 2, "-b:1 64k"),
+        ("eac3", 0, 8, "-b:1 3840k"),
+        ("eac3", 0, 32, "-b:1 6144k"),
+        ("libopus", 0, None, "-vbr:1 on -b:1 240k"),
+        ("aac", 0, None, "-q:1 2"),
+        ("ac3", 0, None, "-b:1 640k"),
+    ],
+)
+def test_quality_converter_clamps_and_handles_none(codec, quality, channels, expected):
+    assert audio_quality_converter(quality, codec, channels=channels, track_number=1) == expected
+
+
+def test_build_audio_quality_path_with_none_channels():
+    t = AudioTrack(
+        index=1, outdex=0, raw_info=Box({"channel_layout": "stereo"}), conversion_codec="ac3", conversion_aq=0
+    )
+    t.raw_info = Box({"channel_layout": "stereo"})
+    cmd = build_audio([t])
+    assert "-b:0" in cmd
+
+
+# ---- item 5: tonemap order
+def test_tonemap_before_grading_and_overlay_after_tonemap():
+    result = generate_filters(
+        selected_track=0,
+        source=Path("in.mkv"),
+        remove_hdr=True,
+        brightness="0.1",
+        colorbalance="colorbalance=rs=0.1",
+        curves_preset="vintage",
+        lut3d_path="a.cube",
+        sharpen="0.5",
+        burn_in_subtitle_track=2,
+        burn_in_subtitle_type="pgs",
+    )
+    fc = result[1]
+    tm = fc.index("tonemap=tonemap")
+    for token in ("eq=", "colorbalance", "curves=", "lut3d=", "cas="):
+        assert tm < fc.index(token), token
+    assert tm < fc.index("overlay")
+    assert "[0:2]overlay" in fc
+
+
+def test_denoise_before_tonemap_before_grading_without_subtitles():
+    fc = generate_filters(
+        selected_track=0, source=Path("in.mkv"), remove_hdr=True, denoise="hqdn3d", brightness="0.1", sharpen="0.5"
+    )[1]
+    assert fc.index("hqdn3d") < fc.index("tonemap=tonemap") < fc.index("eq=") < fc.index("cas=")
+
+
+def test_tonemap_keeps_10bit_when_target_is_10bit():
+    r = generate_filters(selected_track=0, source=Path("in.mkv"), remove_hdr=True, target_pix_fmt="yuv420p10le")
+    assert r[1].endswith("format=yuv420p10le[v]")
+    r = generate_filters(selected_track=0, source=Path("in.mkv"), remove_hdr=True, target_pix_fmt="yuv420p")
+    assert r[1].endswith("format=yuv420p[v]")
+    r = generate_filters(selected_track=0, source=Path("in.mkv"), remove_hdr=True)
+    assert r[1].endswith("format=yuv420p[v]")
+
+
+def test_opencl_and_vaapi_branches_unchanged():
+    r = generate_filters(selected_track=0, source=Path("in.mkv"), remove_hdr=True, enable_opencl=True)
+    assert "tonemap_opencl" in r[1]
+    r = generate_filters(selected_track=0, source=Path("in.mkv"), remove_hdr=True, vaapi=True)
+    assert "tonemap_vaapi" in r[1]
+
+
+# ---- item 6: tag bt709 when tonemapping
+def test_color_details_tag_bt709_when_tonemapping(fastflix_instance):
+    fastflix_instance.current_video.video_settings.remove_hdr = True
+    assert generate_color_details(fastflix_instance) == [
+        "-color_primaries",
+        "bt709",
+        "-color_trc",
+        "bt709",
+        "-colorspace",
+        "bt709",
+    ]
+
+
+# ---- item 7
+@pytest.mark.parametrize(
+    "value", ["black", "white", "Red", "0xFF00AA", "#00ff00", "red@0.5", "0x00FF00@0xAA", "random"]
+)
+def test_pad_color_valid(value):
+    assert validate_ffmpeg_color(value) == value
+
+
+@pytest.mark.parametrize("value", ["black,scale=1:1", "a:b", "red;x", "x'y", "", "#12", "0xGG0000"])
+def test_pad_color_invalid_falls_back(value):
+    assert validate_ffmpeg_color(value) == "black"
+
+
+def test_pad_filter_uses_validated_color():
+    r = generate_filters(selected_track=0, source=Path("in.mkv"), pad_aspect="16:9", pad_color="red,scale=1:1")
+    assert "color=black" in r[1] and "scale=1:1" not in r[1]
+
+
+def test_start_extra_keeps_windows_backslashes():
+    with mock.patch("fastflix.encoders.common.helpers.sys.platform", "win32"):
+        cmd = generate_ffmpeg_start(
+            source=Path("a.mkv"),
+            ffmpeg=Path("ffmpeg"),
+            encoder="libx265",
+            selected_track=0,
+            start_extra=r"-hwaccel d3d11va -i C:\dir\file.png",
+        )
+    assert r"C:\dir\file.png" in cmd
+
+
+def test_eq_has_no_eval_frame():
+    r = generate_filters(selected_track=0, source=Path("in.mkv"), brightness="0.1")
+    assert "eq=brightness=0.1" in r[1]
+    assert "eval=frame" not in r[1]
diff --git a/tests/encoders/test_gif_command_builder.py b/tests/encoders/test_gif_command_builder.py
new file mode 100644
index 00000000..cd5ce13a
--- /dev/null
+++ b/tests/encoders/test_gif_command_builder.py
@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+from pathlib import Path
+
+from fastflix.encoders.gif.command_builder import build
+from fastflix.models.encode import GIFSettings
+from fastflix.models.video import VideoSettings
+
+from tests.conftest import create_fastflix_instance
+
+
+def _build(remove_hdr=False, video_speed=1, scale_fps="15", tone_map="hable", **vs):
+    fastflix = create_fastflix_instance(
+        encoder_settings=GIFSettings(fps=scale_fps),
+        video_settings=VideoSettings(
+            remove_hdr=remove_hdr,
+            tone_map=tone_map,
+            video_speed=video_speed,
+            maxrate=None,
+            bufsize=None,
+            output_path=Path("output.gif"),
+            **vs,
+        ),
+    )
+    fastflix.config.ffmpeg = Path("ffmpeg")
+    return build(fastflix)
+
+
+def _graph(cmd):
+    return cmd[cmd.index("-filter_complex") + 1]
+
+
+def test_gif_two_commands():
+    result = _build()
+    assert [c.name for c in result] == ["Palette generation", "GIF creation"]
+
+
+def test_gif_fps_is_first_filter_before_scale():
+    result = _build(scale_fps="10")
+    for res in result:
+        graph = _graph(res.command)
+        assert "[0:0]fps=10" in graph, graph
+
+
+def test_gif_fps_before_scale_when_scaling():
+    result = _build(resolution_method="width", resolution_custom="320")
+    for res in result:
+        graph = _graph(res.command)
+        assert "scale=" in graph
+        assert graph.index("fps=") < graph.index("scale="), graph
+
+
+def test_gif_palettegen_follows_same_chain_as_paletteuse_input():
+    result = _build()
+    pal_graph = _graph(result[0].command)
+    gif_graph = _graph(result[1].command)
+    base = gif_graph.split(";")[0]
+    assert pal_graph.startswith(base + ";")
+    assert "palettegen=stats_mode=full" in pal_graph
+    assert "paletteuse=dither=sierra2_4a" in gif_graph
+
+
+def test_gif_hdr_tone_map_applied_when_remove_hdr():
+    result = _build(remove_hdr=True, tone_map="mobius")
+    for res in result:
+        graph = _graph(res.command)
+        assert "tonemap=tonemap=mobius" in graph
+
+
+def test_gif_no_tone_map_without_remove_hdr():
+    for res in _build(remove_hdr=False):
+        assert "tonemap" not in _graph(res.command)
+
+
+def test_gif_fps_stays_last_when_speed_changed():
+    result = _build(video_speed=2, scale_fps="10")
+    graph = _graph(result[1].command).split(";")[0]
+    assert graph.index("setpts=2*PTS") < graph.index("fps=10")
diff --git a/tests/encoders/test_h264_videotoolbox_command_builder.py b/tests/encoders/test_h264_videotoolbox_command_builder.py
new file mode 100644
index 00000000..cfb726e8
--- /dev/null
+++ b/tests/encoders/test_h264_videotoolbox_command_builder.py
@@ -0,0 +1,302 @@
+# -*- coding: utf-8 -*-
+
+from fastflix.encoders.h264_videotoolbox.command_builder import build
+from fastflix.models.encode import H264VideoToolboxSettings
+from fastflix.models.video import VideoSettings
+
+from tests.conftest import create_fastflix_instance
+
+
+def _make_fastflix(encoder_settings, video_settings=None):
+    """Create a FastFlix instance for H264 VideoToolbox testing."""
+    return create_fastflix_instance(encoder_settings=encoder_settings, video_settings=video_settings)
+
+
+# ---------------------------------------------------------------------------
+# Profile mapping — the fix for #741
+# ---------------------------------------------------------------------------
+def test_profile_auto_omitted():
+    """Profile 'Auto' (index 0) must NOT emit -profile:v — FFmpeg has no H264 profile 0."""
+    fastflix = _make_fastflix(encoder_settings=H264VideoToolboxSettings(profile=0, q=50))
+    cmd = build(fastflix)[0].command
+
+    assert "-profile:v" not in cmd
+
+
+def test_profile_baseline():
+    """Profile index 1 → -profile:v baseline."""
+    cmd = build(_make_fastflix(encoder_settings=H264VideoToolboxSettings(profile=1, q=50)))[0].command
+
+    idx = cmd.index("-profile:v")
+    assert cmd[idx + 1] == "baseline"
+
+
+def test_profile_main():
+    """Profile index 2 → -profile:v main."""
+    cmd = build(_make_fastflix(encoder_settings=H264VideoToolboxSettings(profile=2, q=50)))[0].command
+
+    idx = cmd.index("-profile:v")
+    assert cmd[idx + 1] == "main"
+
+
+def test_profile_high():
+    """Profile index 3 → -profile:v high."""
+    cmd = build(_make_fastflix(encoder_settings=H264VideoToolboxSettings(profile=3, q=50)))[0].command
+
+    idx = cmd.index("-profile:v")
+    assert cmd[idx + 1] == "high"
+
+
+def test_profile_extended():
+    """Profile index 4 → -profile:v extended."""
+    cmd = build(_make_fastflix(encoder_settings=H264VideoToolboxSettings(profile=4, q=50)))[0].command
+
+    idx = cmd.index("-profile:v")
+    assert cmd[idx + 1] == "extended"
+
+
+def test_profile_unknown_index_omitted():
+    """An index outside the known map (e.g. 99) should NOT emit -profile:v."""
+    cmd = build(_make_fastflix(encoder_settings=H264VideoToolboxSettings(profile=99, q=50)))[0].command
+
+    assert "-profile:v" not in cmd
+
+
+# ---------------------------------------------------------------------------
+# Quality (constant-Q) mode
+# ---------------------------------------------------------------------------
+def test_quality_mode_single_pass():
+    """Constant quality mode produces exactly one Command."""
+    result = build(_make_fastflix(encoder_settings=H264VideoToolboxSettings(q=35, bitrate=None)))
+
+    assert len(result) == 1
+    assert result[0].name == "Single pass constant quality"
+
+
+def test_quality_mode_q_value():
+    """-q:v must carry the stringified quality value."""
+    cmd = build(_make_fastflix(encoder_settings=H264VideoToolboxSettings(q=80, bitrate=None)))[0].command
+
+    idx = cmd.index("-q:v")
+    assert cmd[idx + 1] == "80"
+
+
+def test_quality_mode_boundary_low():
+    """Quality value 1 (lowest = best quality) is accepted."""
+    cmd = build(_make_fastflix(encoder_settings=H264VideoToolboxSettings(q=1, bitrate=None)))[0].command
+
+    idx = cmd.index("-q:v")
+    assert cmd[idx + 1] == "1"
+
+
+def test_quality_mode_boundary_high():
+    """Quality value 100 (highest = worst quality) is accepted."""
+    cmd = build(_make_fastflix(encoder_settings=H264VideoToolboxSettings(q=100, bitrate=None)))[0].command
+
+    idx = cmd.index("-q:v")
+    assert cmd[idx + 1] == "100"
+
+
+def test_quality_mode_no_bitrate_flags():
+    """Constant-Q must NOT contain -b:v or -pass flags."""
+    cmd = build(_make_fastflix(encoder_settings=H264VideoToolboxSettings(q=50, bitrate=None)))[0].command
+
+    assert "-b:v" not in cmd
+    assert "-pass" not in cmd
+
+
+# ---------------------------------------------------------------------------
+# Bitrate mode (VideoToolbox ignores -pass, so it is a single pass encode)
+# ---------------------------------------------------------------------------
+def test_bitrate_mode_single_command():
+    """videotoolboxenc.c has no multi-pass support, so bitrate mode must be one command."""
+    fastflix = _make_fastflix(encoder_settings=H264VideoToolboxSettings(q=None, bitrate="6000k"))
+    result = build(fastflix)
+
+    assert len(result) == 1
+    assert result[0].name == "Single pass bitrate"
+
+
+def test_bitrate_mode_no_pass_flags():
+    fastflix = _make_fastflix(encoder_settings=H264VideoToolboxSettings(q=None, bitrate="6000k"))
+    cmd = build(fastflix)[0].command
+
+    assert "-pass" not in cmd
+    assert "-passlogfile" not in cmd
+    assert "-an" not in cmd
+
+
+def test_bitrate_mode_bitrate_value():
+    """-b:v must carry the exact bitrate string."""
+    fastflix = _make_fastflix(encoder_settings=H264VideoToolboxSettings(q=None, bitrate="12000k"))
+    cmd = build(fastflix)[0].command
+
+    assert cmd[cmd.index("-b:v") + 1] == "12000k"
+    assert "-q:v" not in cmd
+
+
+def test_constant_bit_rate_off_by_default():
+    fastflix = _make_fastflix(encoder_settings=H264VideoToolboxSettings(q=None, bitrate="6000k"))
+    assert "-constant_bit_rate" not in build(fastflix)[0].command
+
+
+def test_constant_bit_rate_opt_in():
+    fastflix = _make_fastflix(
+        encoder_settings=H264VideoToolboxSettings(q=None, bitrate="6000k", constant_bit_rate=True)
+    )
+    cmd = build(fastflix)[0].command
+    assert cmd[cmd.index("-constant_bit_rate") + 1] == "true"
+
+
+def test_constant_bit_rate_ignored_in_quality_mode():
+    fastflix = _make_fastflix(encoder_settings=H264VideoToolboxSettings(q=50, bitrate=None, constant_bit_rate=True))
+    assert "-constant_bit_rate" not in build(fastflix)[0].command
+
+
+def test_extra_options_bitrate_mode():
+    fastflix = _make_fastflix(encoder_settings=H264VideoToolboxSettings(q=None, bitrate="6000k", extra="-tag:v xyz1"))
+    cmd = build(fastflix)[0].command
+
+    assert cmd[cmd.index("-tag:v") + 1] == "xyz1"
+
+
+# ---------------------------------------------------------------------------
+# Boolean options
+# ---------------------------------------------------------------------------
+def test_booleans_all_false():
+    """Default booleans must emit 'false'."""
+    cmd = build(_make_fastflix(encoder_settings=H264VideoToolboxSettings(q=50)))[0].command
+
+    for flag in ("-allow_sw", "-require_sw", "-realtime", "-frames_before", "-frames_after"):
+        idx = cmd.index(flag)
+        assert cmd[idx + 1] == "false", f"{flag} should be 'false'"
+
+
+def test_booleans_all_true():
+    """All booleans True must emit 'true'."""
+    cmd = build(
+        _make_fastflix(
+            encoder_settings=H264VideoToolboxSettings(
+                q=50, allow_sw=True, require_sw=True, realtime=True, frames_before=True, frames_after=True
+            )
+        )
+    )[0].command
+
+    for flag in ("-allow_sw", "-require_sw", "-realtime", "-frames_before", "-frames_after"):
+        idx = cmd.index(flag)
+        assert cmd[idx + 1] == "true", f"{flag} should be 'true'"
+
+
+# ---------------------------------------------------------------------------
+# Extra / custom FFmpeg options
+# ---------------------------------------------------------------------------
+def test_extra_options_quality():
+    """Custom extra options are appended in quality mode."""
+    cmd = build(_make_fastflix(encoder_settings=H264VideoToolboxSettings(q=50, extra="-tag:v avc1")))[0].command
+
+    assert "-tag:v" in cmd
+    assert "avc1" in cmd
+
+
+# ---------------------------------------------------------------------------
+# Encoder identification
+# ---------------------------------------------------------------------------
+def test_encoder_name():
+    """Command must contain h264_videotoolbox as the encoder."""
+    cmd = build(_make_fastflix(encoder_settings=H264VideoToolboxSettings(q=50)))[0].command
+
+    assert "h264_videotoolbox" in cmd
+
+
+def test_command_exe():
+    """All commands must declare exe='ffmpeg'."""
+    for cmd_obj in build(_make_fastflix(encoder_settings=H264VideoToolboxSettings(q=50))):
+        assert cmd_obj.exe == "ffmpeg"
+
+
+# ---------------------------------------------------------------------------
+# Pixel format
+# ---------------------------------------------------------------------------
+def test_default_pix_fmt():
+    """H264 VideoToolbox defaults to yuv420p (8-bit)."""
+    assert H264VideoToolboxSettings().pix_fmt == "yuv420p"
+
+
+def test_pix_fmt_in_command():
+    """The pix_fmt must appear in the generated command."""
+    cmd = build(_make_fastflix(encoder_settings=H264VideoToolboxSettings(q=50, pix_fmt="yuv420p")))[0].command
+
+    idx = cmd.index("-pix_fmt")
+    assert cmd[idx + 1] == "yuv420p"
+
+
+# ---------------------------------------------------------------------------
+# Start/end time
+# ---------------------------------------------------------------------------
+def test_start_end_time():
+    """Start and end times must be stringified in the command."""
+    fastflix = _make_fastflix(
+        encoder_settings=H264VideoToolboxSettings(q=50),
+        video_settings=VideoSettings(start_time=2.5, end_time=15.0, remove_hdr=False, maxrate=None, bufsize=None),
+    )
+    cmd = build(fastflix)[0].command
+
+    assert "-ss" in cmd
+    assert "2.5" in cmd
+    assert "-to" in cmd
+    assert "15.0" in cmd
+
+
+# ---------------------------------------------------------------------------
+# All-strings regression guard
+# ---------------------------------------------------------------------------
+def test_all_elements_are_strings_quality():
+    """Every element in quality-mode command must be a string."""
+    fastflix = _make_fastflix(
+        encoder_settings=H264VideoToolboxSettings(profile=3, q=50, allow_sw=True),
+        video_settings=VideoSettings(
+            start_time=5.0, end_time=30.0, remove_hdr=False, maxrate=8000, bufsize=16000, video_title="Test"
+        ),
+    )
+    for i, el in enumerate(build(fastflix)[0].command):
+        assert isinstance(el, str), f"Element at index {i} is {type(el).__name__}: {el!r}"
+
+
+def test_all_elements_are_strings_bitrate():
+    """Every element in both bitrate-mode commands must be a string."""
+    fastflix = _make_fastflix(
+        encoder_settings=H264VideoToolboxSettings(profile=2, q=None, bitrate="4000k"),
+        video_settings=VideoSettings(start_time=1.0, end_time=10.0, remove_hdr=False, maxrate=None, bufsize=None),
+    )
+    for cmd_obj in build(fastflix):
+        for i, el in enumerate(cmd_obj.command):
+            assert isinstance(el, str), f"Element at index {i} is {type(el).__name__}: {el!r}"
+
+
+# ---------------------------------------------------------------------------
+# Model defaults
+# ---------------------------------------------------------------------------
+def test_settings_defaults():
+    """Verify sensible defaults on the model."""
+    s = H264VideoToolboxSettings()
+    assert s.profile == 0
+    assert s.q == 50
+    assert s.bitrate is None
+    assert s.pix_fmt == "yuv420p"
+    assert s.allow_sw is False
+    assert s.require_sw is False
+    assert s.realtime is False
+    assert s.frames_before is False
+    assert s.frames_after is False
+
+
+# ---------------------------------------------------------------------------
+# Import correctness (regression for wrong import)
+# ---------------------------------------------------------------------------
+def test_uses_correct_settings_type():
+    """h264_videotoolbox must import H264VideoToolboxSettings, not HEVCVideoToolboxSettings."""
+    import fastflix.encoders.h264_videotoolbox.command_builder as mod
+
+    # The module should reference H264VideoToolboxSettings
+    assert hasattr(mod, "H264VideoToolboxSettings")
+    assert not hasattr(mod, "HEVCVideoToolboxSettings")
diff --git a/tests/encoders/test_hdr_metadata.py b/tests/encoders/test_hdr_metadata.py
new file mode 100644
index 00000000..02933fd4
--- /dev/null
+++ b/tests/encoders/test_hdr_metadata.py
@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+from box import Box
+import pytest
+
+from fastflix.encoders.common import hdr_metadata as hm
+
+# Real HDR10 sample, as stored by flix.convert_mastering_display
+SAMPLE = Box(
+    green="(13250,34500)",
+    blue="(7500,3000)",
+    red="(34000,16000)",
+    white="(15635,16450)",
+    luminance="(10000000,1)",
+)
+
+
+@pytest.mark.parametrize(
+    "pix_fmt",
+    ["yuv420p10le", "yuv420p12le", "yuv422p10le", "yuv422p12le", "yuv444p10le", "yuv444p12le", "p010le", "p012le"],
+)
+def test_high_bit_depth_formats_are_hdr_capable(pix_fmt):
+    assert hm.is_hdr_bit_depth(pix_fmt)
+
+
+@pytest.mark.parametrize("pix_fmt", ["yuv420p", "yuv422p", "yuv444p", "nv12", "vaapi", "", None, "gray"])
+def test_8bit_formats_are_not_hdr_capable(pix_fmt):
+    assert not hm.is_hdr_bit_depth(pix_fmt)
+
+
+def test_parse_master_display():
+    md = hm.parse_master_display(SAMPLE)
+    assert md.green == ("13250", "34500")
+    assert md.luminance == ("10000000", "1")
+
+
+def test_parse_none():
+    assert hm.parse_master_display(None) is None
+
+
+def test_x265_format():
+    md = hm.parse_master_display(SAMPLE)
+    assert md.to_x265() == "G(13250,34500)B(7500,3000)R(34000,16000)WP(15635,16450)L(10000000,1)"
+
+
+def test_svt_av1_format():
+    md = hm.parse_master_display(SAMPLE)
+    assert md.to_svt_av1() == "G(0.2650,0.6900)B(0.1500,0.0600)R(0.6800,0.3200)WP(0.3127,0.3290)L(1000.0000,0.0001)"
+
+
+def test_vvenc_format():
+    md = hm.parse_master_display(SAMPLE)
+    assert md.to_vvenc() == "13250,34500,7500,3000,34000,16000,15635,16450,10000000,1"
+
+
+def test_rav1e_format_unchanged_raw_x265_style():
+    md = hm.parse_master_display(SAMPLE)
+    assert md.to_rav1e() == md.to_x265()
diff --git a/tests/encoders/test_helpers.py b/tests/encoders/test_helpers.py
index 53150041..67796452 100644
--- a/tests/encoders/test_helpers.py
+++ b/tests/encoders/test_helpers.py
@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+import sys
 from pathlib import Path
 from unittest import mock
 
@@ -98,6 +99,22 @@ def test_generate_ffmpeg_start_with_options(fastflix_instance):
     assert "title=Main Track" in result
 
 
+def test_generate_ffmpeg_start_string_start_extra_strips_quotes(fastflix_instance):
+    """Quoted values in a user supplied start_extra string must not keep literal quote characters."""
+    result = generate_ffmpeg_start(
+        source=Path("input.mkv"),
+        ffmpeg=Path("ffmpeg"),
+        encoder="libx265",
+        selected_track=0,
+        pix_fmt="yuv420p",
+        start_extra=r'-metadata title="My Movie" -i "C:\my dir\a.srt"',
+    )
+    assert "title=My Movie" in result
+    assert not any('"' in token for token in result)
+    if sys.platform == "win32":
+        assert r"C:\my dir\a.srt" in result
+
+
 def test_generate_ffmpeg_start_with_list_start_extra(fastflix_instance):
     """Test generate_ffmpeg_start with start_extra as a list (VAAPI-style).
 
@@ -297,7 +314,9 @@ def test_generate_filters_with_multiple_options():
         brightness="0.1",
         contrast="1.1",
         saturation="1.2",
+        gamma="1.5",
         video_speed=0.5,
+        sharpen="0.5",
     )
 
     assert isinstance(result, list)
@@ -311,6 +330,8 @@ def test_generate_filters_with_multiple_options():
     assert "brightness=0.1" in filter_str
     assert "saturation=1.2" in filter_str
     assert "contrast=1.1" in filter_str
+    assert "gamma=1.5" in filter_str
+    assert "cas=strength=0.5" in filter_str
     assert result[2] == "-map"
     assert result[3] == "[v]"
 
@@ -346,12 +367,15 @@ def test_generate_all(fastflix_instance):
         assert output_fps == ["-r", "24"]
 
         # Verify the mock calls
-        mock_build_audio.assert_called_once_with(fastflix_instance.current_video.audio_tracks)
+        mock_build_audio.assert_called_once_with(
+            fastflix_instance.current_video.audio_tracks,
+            reverse_video=fastflix_instance.current_video.video_settings.reverse_video,
+        )
         mock_build_subtitle.assert_called_once_with(
             fastflix_instance.current_video.subtitle_tracks,
             output_path=fastflix_instance.current_video.video_settings.output_path,
         )
-        mock_build_attachments.assert_called_once_with(fastflix_instance.current_video.attachment_tracks)
+        mock_build_attachments.assert_called_once_with(fastflix_instance.current_video.attachment_tracks, 0)
 
 
 def test_generate_all_with_list_start_extra(fastflix_instance):
@@ -618,7 +642,7 @@ def test_generate_color_details(fastflix_instance):
     # Test with HDR removal enabled
     fastflix_instance.current_video.video_settings.remove_hdr = True
     result = generate_color_details(fastflix_instance)
-    assert result == []
+    assert result == ["-color_primaries", "bt709", "-color_trc", "bt709", "-colorspace", "bt709"]
 
     # Test with HDR removal disabled and color settings
     fastflix_instance.current_video.video_settings.remove_hdr = False
@@ -628,3 +652,266 @@ def test_generate_color_details(fastflix_instance):
 
     result = generate_color_details(fastflix_instance)
     assert result == ["-color_primaries", "bt2020", "-color_trc", "smpte2084", "-colorspace", "bt2020nc"]
+
+
+def test_generate_filters_with_vibrance():
+    """Test the generate_filters function with vibrance."""
+    result = generate_filters(
+        selected_track=0,
+        source=Path("input.mkv"),
+        vibrance="0.5",
+    )
+    assert isinstance(result, list)
+    assert result[0] == "-filter_complex"
+    assert "vibrance=intensity=0.5" in result[1]
+
+
+def test_generate_filters_with_color_temperature():
+    """Test the generate_filters function with color temperature."""
+    result = generate_filters(
+        selected_track=0,
+        source=Path("input.mkv"),
+        color_temperature="5000",
+    )
+    assert isinstance(result, list)
+    assert result[0] == "-filter_complex"
+    assert "colortemperature=temperature=5000" in result[1]
+
+
+def test_generate_filters_with_curves_preset():
+    """Test the generate_filters function with curves preset."""
+    result = generate_filters(
+        selected_track=0,
+        source=Path("input.mkv"),
+        curves_preset="vintage",
+    )
+    assert isinstance(result, list)
+    assert result[0] == "-filter_complex"
+    assert "curves=preset=vintage" in result[1]
+
+
+def test_generate_filters_with_colorbalance():
+    """Test the generate_filters function with colorbalance."""
+    result = generate_filters(
+        selected_track=0,
+        source=Path("input.mkv"),
+        colorbalance="colorbalance=rs=0.15:bs=-0.15",
+    )
+    assert isinstance(result, list)
+    assert result[0] == "-filter_complex"
+    assert "colorbalance=rs=0.15:bs=-0.15" in result[1]
+
+
+def test_generate_filters_with_unsharp():
+    """Test the generate_filters function with unsharp mask."""
+    result = generate_filters(
+        selected_track=0,
+        source=Path("input.mkv"),
+        unsharp="unsharp=5:5:1.0:5:5:0.5",
+    )
+    assert isinstance(result, list)
+    assert result[0] == "-filter_complex"
+    assert "unsharp=5:5:1.0:5:5:0.5" in result[1]
+
+
+def test_generate_filters_with_deflicker():
+    """Test the generate_filters function with deflicker."""
+    result = generate_filters(
+        selected_track=0,
+        source=Path("input.mkv"),
+        deflicker="deflicker=mode=pm:size=5",
+    )
+    assert isinstance(result, list)
+    assert result[0] == "-filter_complex"
+    assert "deflicker=mode=pm:size=5" in result[1]
+
+
+def test_generate_filters_with_pad():
+    """Test the generate_filters function with pad aspect ratio."""
+    result = generate_filters(
+        selected_track=0,
+        source=Path("input.mkv"),
+        pad_aspect="16:9",
+        pad_color="black",
+    )
+    assert isinstance(result, list)
+    assert result[0] == "-filter_complex"
+    assert "pad=" in result[1]
+    assert "color=black" in result[1]
+
+
+def test_generate_filters_with_lut3d():
+    """Test the generate_filters function with LUT3D file."""
+    result = generate_filters(
+        selected_track=0,
+        source=Path("input.mkv"),
+        lut3d_path="/path/to/my.cube",
+    )
+    assert isinstance(result, list)
+    assert result[0] == "-filter_complex"
+    assert "lut3d=" in result[1]
+    assert "my.cube" in result[1]
+
+
+def test_generate_filters_with_nlmeans_opencl():
+    """Test the generate_filters function with nlmeans_opencl denoise."""
+    result = generate_filters(
+        selected_track=0,
+        source=Path("input.mkv"),
+        denoise="nlmeans_opencl=s=1.0:p=3:r=9",
+        enable_opencl=True,
+    )
+    assert isinstance(result, list)
+    assert result[0] == "-filter_complex"
+    assert "hwupload" in result[1]
+    assert "nlmeans_opencl=s=1.0:p=3:r=9" in result[1]
+    assert "hwdownload" in result[1]
+
+
+def test_generate_filters_filter_chain_order():
+    """Test that filters are applied in the correct order."""
+    result = generate_filters(
+        selected_track=0,
+        source=Path("input.mkv"),
+        deinterlace=True,
+        crop={"width": 1920, "height": 1080, "left": 0, "top": 0},
+        scale="1920:-8",
+        denoise="nlmeans=s=1.0:p=3:r=9",
+        deflicker="deflicker=mode=pm:size=5",
+        unsharp="unsharp=5:5:1.0:5:5:0.5",
+        brightness="0.1",
+        hue="10",
+        vibrance="0.5",
+        colorbalance="colorbalance=rs=0.15:bs=-0.15",
+        color_temperature="5000",
+        curves_preset="vintage",
+        sharpen="0.5",
+    )
+    assert isinstance(result, list)
+    filter_str = result[1]
+    # Verify ordering: denoise before deflicker before unsharp before eq before hue before vibrance
+    assert filter_str.index("nlmeans") < filter_str.index("deflicker")
+    assert filter_str.index("deflicker") < filter_str.index("unsharp")
+    assert filter_str.index("unsharp") < filter_str.index("eq=brightness")
+    assert filter_str.index("eq=brightness") < filter_str.index("hue=h=")
+    assert filter_str.index("hue=h=") < filter_str.index("vibrance")
+    assert filter_str.index("vibrance") < filter_str.index("colorbalance")
+    assert filter_str.index("colorbalance") < filter_str.index("colortemperature")
+    assert filter_str.index("colortemperature") < filter_str.index("curves=preset")
+    assert filter_str.index("curves=preset") < filter_str.index("cas=strength")
+
+
+def test_reverse_forces_input_side_seek():
+    cmd = generate_ffmpeg_start(
+        source=Path("in.mkv"),
+        ffmpeg=Path("ffmpeg"),
+        encoder="libx265",
+        selected_track=0,
+        start_time=5,
+        end_time=10,
+        fast_seek=False,
+        reverse_video=True,
+        filters=["-filter_complex", "[0:0]reverse[v]", "-map", "[v]"],
+    )
+    assert cmd.index("-ss") < cmd.index("-i")
+    assert cmd.index("-to") < cmd.index("-i")
+
+
+def test_exact_seek_without_reverse_stays_after_input():
+    cmd = generate_ffmpeg_start(
+        source=Path("in.mkv"), ffmpeg=Path("ffmpeg"), encoder="libx265", selected_track=0, start_time=5, fast_seek=False
+    )
+    assert cmd.index("-ss") > cmd.index("-i")
+
+
+def test_nlmeans_opencl_inits_device_without_hdr_removal():
+    cmd = generate_ffmpeg_start(
+        source=Path("in.mkv"),
+        ffmpeg=Path("ffmpeg"),
+        encoder="libx265",
+        selected_track=0,
+        enable_opencl=True,
+        remove_hdr=False,
+        denoise="nlmeans_opencl=s=1.0:p=3:r=9",
+    )
+    assert "-init_hw_device" in cmd
+    assert "-filter_hw_device" in cmd
+
+
+def test_no_opencl_device_without_need():
+    cmd = generate_ffmpeg_start(
+        source=Path("in.mkv"),
+        ffmpeg=Path("ffmpeg"),
+        encoder="libx265",
+        selected_track=0,
+        enable_opencl=True,
+        remove_hdr=False,
+    )
+    assert "-init_hw_device" not in cmd
+
+
+def test_nlmeans_opencl_pix_fmt_matches_source():
+    f10 = generate_filters(0, denoise="nlmeans_opencl=s=1.0:p=3:r=9", enable_opencl=True, source_pix_fmt="yuv420p10le")
+    assert "format=p010,hwupload,nlmeans_opencl=s=1.0:p=3:r=9,hwdownload,format=p010" in f10[1]
+    f8 = generate_filters(0, denoise="nlmeans_opencl=s=1.0:p=3:r=9", enable_opencl=True, source_pix_fmt="yuv420p")
+    assert "format=yuv420p,hwupload" in f8[1]
+
+
+def test_nlmeans_opencl_falls_back_to_cpu_without_opencl():
+    f = generate_filters(0, denoise="nlmeans_opencl=s=1.0:p=3:r=9", enable_opencl=False)
+    assert "hwupload" not in f[1]
+    assert "nlmeans=s=1.0:p=3:r=9" in f[1]
+    assert "opencl" not in f[1]
+
+
+def test_copy_with_reverse_does_not_reverse_audio(fastflix_instance):
+    fastflix_instance.current_video.video_settings.reverse_video = True
+    fastflix_instance.current_video.video_settings.video_encoder_settings = x265Settings()
+    for t in fastflix_instance.current_video.audio_tracks:
+        t.conversion_codec = "aac"
+        t.conversion_bitrate = "128k"
+    beginning, ending, _ = generate_all(fastflix_instance, "copy", disable_filters=True, subs=False)
+    assert "areverse" not in " ".join(ending)
+    assert "reverse" not in " ".join(beginning)
+
+
+def test_pad_applied_after_rotation():
+    f = generate_filters(0, rotate=1, pad_aspect="16:9", pad_color="black")[1]
+    assert f.index("transpose=1") < f.index("pad=")
+
+
+def test_text_burn_in_before_reverse():
+    f = generate_filters(0, reverse_video=True, burn_in_subtitle_track=0, burn_in_subtitle_type="text", source="a.mkv")[
+        1
+    ]
+    assert f.index("subtitles=") < f.index("reverse")
+    assert f.count("subtitles=") == 1
+    f = generate_filters(0, burn_in_subtitle_track=0, burn_in_subtitle_type="text", source="a.mkv", scale="1280:-8")[1]
+    assert f.index("scale=") < f.index("subtitles=")
+
+
+def test_gop_length_zero_not_emitted():
+    base = dict(source=Path("in.mkv"), ffmpeg=Path("ffmpeg"), encoder="libx264", selected_track=0)
+    assert "-g" not in generate_ffmpeg_start(gop_length=0, **base)
+    assert "-g" not in generate_ffmpeg_start(gop_length=None, **base)
+    cmd = generate_ffmpeg_start(gop_length=48, **base)
+    assert cmd[cmd.index("-g") + 1] == "48"
+
+
+def test_data_track_metadata_uses_real_output_index():
+    from fastflix.models.encode import DataTrack
+
+    track = DataTrack(
+        index=5, outdex=99, codec_type="attachment", codec_name="ttf", mimetype="font/ttf", filename="a.ttf"
+    )
+    audio = ["-map", "0:1", "-c:1", "copy", "-map", "0:2"]
+    subs = ["-map", "0:3"]
+    cmd, _ = generate_ending(audio, subs, data_tracks=[track], output_video=Path("o.mkv"))
+    # video + 2 audio + 1 subtitle -> data stream is output index 4
+    assert "-metadata:s:4" in cmd
+    assert "-metadata:s:99" not in cmd
+    assert cmd[cmd.index("-metadata:s:4") + 1] in ("title=", "handler=")
+    assert "mimetype=font/ttf" in cmd
+    # Burned-in subtitle produces no map, so index shifts down
+    cmd, _ = generate_ending(audio, [], data_tracks=[track], output_video=Path("o.mkv"))
+    assert "-metadata:s:3" in cmd
diff --git a/tests/encoders/test_hevc_tag.py b/tests/encoders/test_hevc_tag.py
new file mode 100644
index 00000000..575b65fa
--- /dev/null
+++ b/tests/encoders/test_hevc_tag.py
@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+from pathlib import Path
+
+import pytest
+
+from fastflix.encoders.common.helpers import hevc_tag_args
+from fastflix.encoders.ffmpeg_hevc_nvenc.command_builder import build as nvenc_build
+from fastflix.encoders.hevc_videotoolbox.command_builder import build as vt_build
+from fastflix.encoders.hevc_x265.command_builder import build as x265_build
+from fastflix.encoders.vaapi_hevc.command_builder import build as vaapi_build
+from fastflix.models.encode import FFmpegNVENCSettings, HEVCVideoToolboxSettings, VAAPIHEVCSettings, x265Settings
+from fastflix.models.video import VideoSettings
+from tests.conftest import create_fastflix_instance
+
+TAG = ["-tag:v", "hvc1"]
+
+
+@pytest.mark.parametrize("name", ["out.mp4", "out.MP4", "out.m4v", "out.mov", Path("a/b/out.mp4")])
+def test_tag_for_apple_containers(name):
+    assert hevc_tag_args(name) == TAG
+
+
+@pytest.mark.parametrize("name", ["out.mkv", "out.webm", "out.ts", "", None])
+def test_no_tag_for_other_containers(name):
+    assert hevc_tag_args(name) == []
+
+
+def _fastflix(settings, output):
+    vs = VideoSettings(remove_hdr=False, maxrate=None, bufsize=None, output_path=Path(output))
+    return create_fastflix_instance(encoder_settings=settings, video_settings=vs)
+
+
+BUILDERS = [
+    (nvenc_build, lambda: FFmpegNVENCSettings(bitrate=None, qp=25)),
+    (vt_build, lambda: HEVCVideoToolboxSettings(q=50)),
+    (vaapi_build, lambda: VAAPIHEVCSettings(qp=26, bitrate=None)),
+    (x265_build, lambda: x265Settings(crf=22, bitrate=None)),
+]
+
+
+def _build(builder, settings, output):
+    return builder(_fastflix(settings, output))[-1].command
+
+
+@pytest.mark.parametrize("builder,make", BUILDERS)
+@pytest.mark.parametrize("output", ["out.mp4", "out.mov", "out.m4v"])
+def test_builders_add_hvc1_for_mp4_family(builder, make, output):
+    cmd = _build(builder, make(), output)
+    idx = cmd.index("-tag:v")
+    assert cmd[idx + 1] == "hvc1"
+    assert idx < len(cmd) - 1 and cmd.index(output) > idx
+
+
+@pytest.mark.parametrize("builder,make", BUILDERS)
+def test_builders_no_tag_for_mkv(builder, make):
+    cmd = _build(builder, make(), "out.mkv")
+    assert "-tag:v" not in cmd
diff --git a/tests/encoders/test_hevc_videotoolbox_command_builder.py b/tests/encoders/test_hevc_videotoolbox_command_builder.py
new file mode 100644
index 00000000..7ecb4116
--- /dev/null
+++ b/tests/encoders/test_hevc_videotoolbox_command_builder.py
@@ -0,0 +1,381 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+
+from fastflix.encoders.hevc_videotoolbox.command_builder import build
+from fastflix.models.encode import HEVCVideoToolboxSettings
+from fastflix.models.video import VideoSettings
+
+from tests.conftest import create_fastflix_instance
+
+
+def _make_fastflix(encoder_settings, video_settings=None):
+    """Create a FastFlix instance for HEVC VideoToolbox testing."""
+    return create_fastflix_instance(encoder_settings=encoder_settings, video_settings=video_settings)
+
+
+# ---------------------------------------------------------------------------
+# Profile mapping
+# ---------------------------------------------------------------------------
+def test_profile_auto_omitted():
+    """Profile 'Auto' (index 0) must NOT emit -profile:v — FFmpeg has no profile 0 for HEVC."""
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(profile=0, q=50))
+    result = build(fastflix)
+
+    cmd = result[0].command
+    assert "-profile:v" not in cmd
+
+
+def test_profile_main():
+    """Profile index 1 → -profile:v main."""
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(profile=1, q=50, pix_fmt="yuv420p"))
+    cmd = build(fastflix)[0].command
+
+    idx = cmd.index("-profile:v")
+    assert cmd[idx + 1] == "main"
+
+
+def test_profile_main10():
+    """Profile index 2 → -profile:v main10."""
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(profile=2, q=50, pix_fmt="p010le"))
+    cmd = build(fastflix)[0].command
+
+    idx = cmd.index("-profile:v")
+    assert cmd[idx + 1] == "main10"
+
+
+def test_profile_unknown_index_omitted():
+    """An index outside the known map (e.g. 99) should NOT emit -profile:v."""
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(profile=99, q=50))
+    cmd = build(fastflix)[0].command
+
+    assert "-profile:v" not in cmd
+
+
+# ---------------------------------------------------------------------------
+# Quality (constant-Q) mode
+# ---------------------------------------------------------------------------
+def test_quality_mode_single_pass():
+    """Constant quality mode produces exactly one Command."""
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(q=35, bitrate=None))
+    result = build(fastflix)
+
+    assert len(result) == 1
+    assert result[0].name == "Single pass constant quality"
+
+
+def test_quality_mode_q_value():
+    """-q:v must carry the stringified quality value."""
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(q=15, bitrate=None))
+    cmd = build(fastflix)[0].command
+
+    idx = cmd.index("-q:v")
+    assert cmd[idx + 1] == "15"
+
+
+def test_quality_mode_no_bitrate_flags():
+    """Constant-Q mode must NOT contain -b:v or -pass flags."""
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(q=50, bitrate=None))
+    cmd = build(fastflix)[0].command
+
+    assert "-b:v" not in cmd
+    assert "-pass" not in cmd
+
+
+# ---------------------------------------------------------------------------
+# Bitrate mode (VideoToolbox ignores -pass, so it is a single pass encode)
+# ---------------------------------------------------------------------------
+def test_bitrate_mode_single_command():
+    """videotoolboxenc.c has no multi-pass support, so bitrate mode must be one command."""
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(q=None, bitrate="6000k"))
+    result = build(fastflix)
+
+    assert len(result) == 1
+    assert result[0].name == "Single pass bitrate"
+
+
+def test_bitrate_mode_no_pass_flags():
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(q=None, bitrate="6000k"))
+    cmd = build(fastflix)[0].command
+
+    assert "-pass" not in cmd
+    assert "-passlogfile" not in cmd
+    assert "-an" not in cmd
+
+
+def test_bitrate_mode_bitrate_value():
+    """-b:v must carry the exact bitrate string."""
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(q=None, bitrate="12000k"))
+    cmd = build(fastflix)[0].command
+
+    assert cmd[cmd.index("-b:v") + 1] == "12000k"
+    assert "-q:v" not in cmd
+
+
+def test_constant_bit_rate_off_by_default():
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(q=None, bitrate="6000k"))
+    assert "-constant_bit_rate" not in build(fastflix)[0].command
+
+
+def test_constant_bit_rate_opt_in():
+    fastflix = _make_fastflix(
+        encoder_settings=HEVCVideoToolboxSettings(q=None, bitrate="6000k", constant_bit_rate=True)
+    )
+    cmd = build(fastflix)[0].command
+    assert cmd[cmd.index("-constant_bit_rate") + 1] == "true"
+
+
+def test_constant_bit_rate_ignored_in_quality_mode():
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(q=50, bitrate=None, constant_bit_rate=True))
+    assert "-constant_bit_rate" not in build(fastflix)[0].command
+
+
+def test_extra_options_bitrate_mode():
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(q=None, bitrate="6000k", extra="-tag:v xyz1"))
+    cmd = build(fastflix)[0].command
+
+    assert cmd[cmd.index("-tag:v") + 1] == "xyz1"
+
+
+# ---------------------------------------------------------------------------
+# Boolean options
+# ---------------------------------------------------------------------------
+def test_boolean_options_all_false():
+    """Default booleans (False) must emit 'false' strings."""
+    fastflix = _make_fastflix(
+        encoder_settings=HEVCVideoToolboxSettings(
+            q=50,
+            allow_sw=False,
+            require_sw=False,
+            realtime=False,
+            frames_before=False,
+            frames_after=False,
+        )
+    )
+    cmd = build(fastflix)[0].command
+
+    for flag in ("-allow_sw", "-require_sw", "-realtime", "-frames_before", "-frames_after"):
+        idx = cmd.index(flag)
+        assert cmd[idx + 1] == "false", f"{flag} should be 'false'"
+
+
+def test_boolean_options_all_true():
+    """All booleans set to True must emit 'true' strings."""
+    fastflix = _make_fastflix(
+        encoder_settings=HEVCVideoToolboxSettings(
+            q=50,
+            allow_sw=True,
+            require_sw=True,
+            realtime=True,
+            frames_before=True,
+            frames_after=True,
+        )
+    )
+    cmd = build(fastflix)[0].command
+
+    for flag in ("-allow_sw", "-require_sw", "-realtime", "-frames_before", "-frames_after"):
+        idx = cmd.index(flag)
+        assert cmd[idx + 1] == "true", f"{flag} should be 'true'"
+
+
+def test_boolean_mixed():
+    """Verify each boolean flag is independent."""
+    fastflix = _make_fastflix(
+        encoder_settings=HEVCVideoToolboxSettings(
+            q=50,
+            allow_sw=True,
+            require_sw=False,
+            realtime=True,
+            frames_before=False,
+            frames_after=True,
+        )
+    )
+    cmd = build(fastflix)[0].command
+
+    assert cmd[cmd.index("-allow_sw") + 1] == "true"
+    assert cmd[cmd.index("-require_sw") + 1] == "false"
+    assert cmd[cmd.index("-realtime") + 1] == "true"
+    assert cmd[cmd.index("-frames_before") + 1] == "false"
+    assert cmd[cmd.index("-frames_after") + 1] == "true"
+
+
+# ---------------------------------------------------------------------------
+# Extra / custom FFmpeg options
+# ---------------------------------------------------------------------------
+def test_extra_options_quality_mode():
+    """Custom extra options are appended in quality mode."""
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(q=50, extra="-tag:v hvc1"))
+    cmd = build(fastflix)[0].command
+
+    assert "-tag:v" in cmd
+    assert "hvc1" in cmd
+
+
+def test_empty_extra_no_crash():
+    """Empty extra string must not inject empty args."""
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(q=50, extra=""))
+    cmd = build(fastflix)[0].command
+
+    assert "" not in cmd  # no empty-string elements
+
+
+# ---------------------------------------------------------------------------
+# Pixel format
+# ---------------------------------------------------------------------------
+def test_default_pix_fmt_hevc():
+    """HEVC VideoToolbox defaults to p010le (10-bit for HDR)."""
+    settings = HEVCVideoToolboxSettings()
+    assert settings.pix_fmt == "p010le"
+
+
+def test_pix_fmt_in_command():
+    """The pix_fmt must appear in the generated command via generate_all."""
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(q=50, pix_fmt="yuv420p"))
+    cmd = build(fastflix)[0].command
+
+    assert "-pix_fmt" in cmd
+    idx = cmd.index("-pix_fmt")
+    assert cmd[idx + 1] == "yuv420p"
+
+
+# ---------------------------------------------------------------------------
+# Encoder identification
+# ---------------------------------------------------------------------------
+def test_encoder_name_in_command():
+    """Command must contain hevc_videotoolbox as the encoder."""
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(q=50))
+    cmd = build(fastflix)[0].command
+
+    assert "hevc_videotoolbox" in cmd
+
+
+def test_command_exe_is_ffmpeg():
+    """All commands must declare exe='ffmpeg'."""
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(q=50))
+    for cmd_obj in build(fastflix):
+        assert cmd_obj.exe == "ffmpeg"
+
+
+# ---------------------------------------------------------------------------
+# Start/end time
+# ---------------------------------------------------------------------------
+def test_start_end_time():
+    """Start and end times must be stringified in the command."""
+    fastflix = _make_fastflix(
+        encoder_settings=HEVCVideoToolboxSettings(q=50),
+        video_settings=VideoSettings(
+            start_time=5.5,
+            end_time=30.0,
+            remove_hdr=False,
+            maxrate=None,
+            bufsize=None,
+        ),
+    )
+    cmd = build(fastflix)[0].command
+
+    assert "-ss" in cmd
+    assert "5.5" in cmd
+    assert "-to" in cmd
+    assert "30.0" in cmd
+
+
+# ---------------------------------------------------------------------------
+# Color details
+# ---------------------------------------------------------------------------
+def test_color_details_preserved():
+    """Color primaries/transfer/space should be in the command when HDR is not removed."""
+    fastflix = _make_fastflix(
+        encoder_settings=HEVCVideoToolboxSettings(q=50),
+        video_settings=VideoSettings(
+            remove_hdr=False,
+            color_primaries="bt2020",
+            color_transfer="smpte2084",
+            color_space="bt2020nc",
+            maxrate=None,
+            bufsize=None,
+        ),
+    )
+    cmd = build(fastflix)[0].command
+
+    assert "-color_primaries" in cmd
+    assert "bt2020" in cmd
+    assert "-color_trc" in cmd
+    assert "smpte2084" in cmd
+    assert "-colorspace" in cmd
+    assert "bt2020nc" in cmd
+
+
+# ---------------------------------------------------------------------------
+# All elements are strings (regression guard)
+# ---------------------------------------------------------------------------
+def test_all_elements_are_strings_quality():
+    """Every element in the quality-mode command must be a string."""
+    fastflix = _make_fastflix(
+        encoder_settings=HEVCVideoToolboxSettings(profile=2, q=50, allow_sw=True),
+        video_settings=VideoSettings(
+            start_time=5.0,
+            end_time=30.0,
+            remove_hdr=False,
+            maxrate=8000,
+            bufsize=16000,
+            video_title="Test",
+        ),
+    )
+    cmd = build(fastflix)[0].command
+
+    for i, element in enumerate(cmd):
+        assert isinstance(element, str), f"Element at index {i} is {type(element).__name__}: {element!r}"
+
+
+def test_all_elements_are_strings_bitrate():
+    """Every element in both bitrate-mode commands must be a string."""
+    fastflix = _make_fastflix(
+        encoder_settings=HEVCVideoToolboxSettings(profile=1, q=None, bitrate="6000k", allow_sw=True),
+        video_settings=VideoSettings(
+            start_time=1.0,
+            end_time=10.0,
+            remove_hdr=False,
+            maxrate=None,
+            bufsize=None,
+        ),
+    )
+    for cmd_obj in build(fastflix):
+        for i, element in enumerate(cmd_obj.command):
+            assert isinstance(element, str), f"Element at index {i} is {type(element).__name__}: {element!r}"
+
+
+# ---------------------------------------------------------------------------
+# Model defaults
+# ---------------------------------------------------------------------------
+def test_settings_defaults():
+    """Verify sensible defaults on the model."""
+    s = HEVCVideoToolboxSettings()
+    assert s.profile == 0
+    assert s.q == 50
+    assert s.bitrate is None
+    assert s.pix_fmt == "p010le"
+    assert s.allow_sw is False
+    assert s.require_sw is False
+    assert s.realtime is False
+    assert s.frames_before is False
+    assert s.frames_after is False
+
+
+# ---------------------------------------------------------------------------
+# Profile must match the pixel format (videotoolboxenc.c rejects main10 with 8-bit input)
+# ---------------------------------------------------------------------------
+@pytest.mark.parametrize(
+    "profile,pix_fmt,expected",
+    [(1, "p010le", "main10"), (2, "yuv420p", "main"), (1, "yuv420p", "main"), (2, "p010le", "main10")],
+)
+def test_profile_follows_pix_fmt(profile, pix_fmt, expected):
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(profile=profile, q=50, pix_fmt=pix_fmt))
+    cmd = build(fastflix)[0].command
+
+    assert cmd[cmd.index("-profile:v") + 1] == expected
+
+
+@pytest.mark.parametrize("pix_fmt", ["p010le", "yuv420p"])
+def test_profile_auto_still_omitted(pix_fmt):
+    fastflix = _make_fastflix(encoder_settings=HEVCVideoToolboxSettings(profile=0, q=50, pix_fmt=pix_fmt))
+    assert "-profile:v" not in build(fastflix)[0].command
diff --git a/tests/encoders/test_hevc_x265_command_builder.py b/tests/encoders/test_hevc_x265_command_builder.py
index 48b8e388..d2084a5b 100644
--- a/tests/encoders/test_hevc_x265_command_builder.py
+++ b/tests/encoders/test_hevc_x265_command_builder.py
@@ -258,3 +258,80 @@ def test_hevc_x265_tune_profile():
         assert "animation" in cmd
         assert "-profile:v" in cmd
         assert "main10" in cmd
+
+
+def _x265_fastflix(pix_fmt="yuv420p10le", remove_hdr=False, hdr10=False, **kwargs):
+    defaults = dict(
+        crf=None,
+        bitrate="5000k",
+        bitrate_passes=2,
+        preset="medium",
+        profile="default",
+        tune="default",
+        hdr10=hdr10,
+        hdr10_opt=False,
+        repeat_headers=True,
+        aq_mode=2,
+        bframes=4,
+        b_adapt=2,
+        frame_threads=0,
+        intra_smoothing=True,
+        pix_fmt=pix_fmt,
+    )
+    defaults.update(kwargs)
+    return create_fastflix_instance(
+        encoder_settings=x265Settings(**defaults),
+        video_settings=VideoSettings(remove_hdr=remove_hdr, maxrate=None, bufsize=None),
+        hdr10_metadata=True,
+    )
+
+
+def _x265_build(fastflix):
+    with mock.patch("fastflix.encoders.hevc_x265.command_builder.generate_all") as mock_generate_all:
+        mock_generate_all.return_value = (["ffmpeg", "-y", "-i", "input.mkv"], ["output.mkv"], [])
+        return build(fastflix)
+
+
+def _x265_params(cmd):
+    return cmd[cmd.index("-x265-params") + 1]
+
+
+def test_hevc_x265_stats_file_in_work_path_and_quoted():
+    fastflix = _x265_fastflix()
+    result = _x265_build(fastflix)
+    work = fastflix.current_video.work_path.as_posix()
+    for cmd in (result[0].command, result[1].command):
+        params = _x265_params(cmd)
+        stats = [p for p in params.split(":") if p.startswith("stats=")]
+        assert stats, params
+        assert stats[0].startswith(f"stats='{work}/pass_log_file_"), stats[0]
+        assert stats[0].endswith(".log'")
+
+
+def test_hevc_x265_stats_file_quote_in_path_is_escaped():
+    from fastflix.encoders.hevc_x265.command_builder import quote_x265_value
+
+    assert quote_x265_value("a'b") == "'a'" + chr(92) + "''b'"
+
+
+def test_hevc_x265_does_not_mutate_settings_hdr10():
+    fastflix = _x265_fastflix(hdr10=False)
+    _x265_build(fastflix)
+    assert fastflix.current_video.video_settings.video_encoder_settings.hdr10 is False
+
+
+def test_hevc_x265_rebuild_after_remove_hdr_has_no_hdr10():
+    fastflix = _x265_fastflix(hdr10=False)
+    _x265_build(fastflix)
+    fastflix.current_video.video_settings.remove_hdr = True
+    params = _x265_params(_x265_build(fastflix)[0].command)
+    assert "hdr10=1" not in params
+    assert "master-display" not in params
+
+
+def test_hevc_x265_hdr_metadata_for_444_12bit():
+    fastflix = _x265_fastflix(pix_fmt="yuv444p12le", bitrate=None, crf=22)
+    params = _x265_params(_x265_build(fastflix)[0].command)
+    assert "master-display=G(" in params
+    assert "max-cll=1000,300" in params
+    assert "hdr10=1" in params
diff --git a/tests/encoders/test_nvenc_options.py b/tests/encoders/test_nvenc_options.py
new file mode 100644
index 00000000..f1313a2a
--- /dev/null
+++ b/tests/encoders/test_nvenc_options.py
@@ -0,0 +1,208 @@
+# -*- coding: utf-8 -*-
+from pathlib import Path
+
+import pytest
+
+from fastflix.encoders.ffmpeg_av1_nvenc.command_builder import build as av1_build
+from fastflix.encoders.ffmpeg_hevc_nvenc.command_builder import build as hevc_build
+from fastflix.encoders.ffmpeg_hevc_nvenc.settings_panel import presets as hevc_presets
+from fastflix.models.encode import FFmpegAV1NVENCSettings, FFmpegNVENCSettings
+from fastflix.models.profiles import Profile
+from fastflix.models.video import VideoSettings
+from tests.conftest import create_fastflix_instance
+
+SUPPORTED_PRESETS = {"slow", "medium", "fast", "p1", "p2", "p3", "p4", "p5", "p6", "p7"}
+SUPPORTED_RC = {"constqp", "vbr", "cbr"}
+
+
+def _cmd(builder, settings, output="out.mkv"):
+    vs = VideoSettings(remove_hdr=False, maxrate=None, bufsize=None, output_path=Path(output))
+    return builder(create_fastflix_instance(encoder_settings=settings, video_settings=vs))[0].command
+
+
+def _val(cmd, flag):
+    return cmd[cmd.index(flag) + 1]
+
+
+# ---- presets / legacy migration -------------------------------------------------------------
+def test_panel_presets_only_supported():
+    assert set(hevc_presets) == SUPPORTED_PRESETS
+
+
+def test_default_preset_is_supported():
+    assert FFmpegNVENCSettings().preset in SUPPORTED_PRESETS
+    assert FFmpegAV1NVENCSettings().preset in SUPPORTED_PRESETS
+
+
+@pytest.mark.parametrize(
+    "legacy,preset,tune",
+    [
+        ("default", "p4", "hq"),
+        ("hp", "p1", "hq"),
+        ("hq", "p7", "hq"),
+        ("bd", "p5", "hq"),
+        ("ll", "p4", "ll"),
+        ("llhp", "p1", "ll"),
+        ("llhq", "p7", "ll"),
+        ("lossless", "p4", "lossless"),
+        ("losslesshp", "p1", "lossless"),
+    ],
+)
+def test_legacy_presets_migrated(legacy, preset, tune):
+    s = FFmpegNVENCSettings(preset=legacy, tune="hq")
+    assert s.preset == preset
+    assert s.tune == tune
+
+
+@pytest.mark.parametrize("preset", sorted(SUPPORTED_PRESETS))
+def test_supported_presets_untouched(preset):
+    s = FFmpegNVENCSettings(preset=preset, tune="uhq")
+    assert (s.preset, s.tune) == (preset, "uhq")
+
+
+@pytest.mark.parametrize(
+    "legacy,rc",
+    [
+        ("vbr_minqp", "vbr"),
+        ("vbr_2pass", "vbr"),
+        ("vbr_hq", "vbr"),
+        ("ll_2pass_quality", "vbr"),
+        ("ll_2pass_size", "vbr"),
+        ("cbr_hq", "cbr"),
+        ("cbr_ld_hq", "cbr"),
+    ],
+)
+def test_legacy_rc_migrated(legacy, rc):
+    assert FFmpegNVENCSettings(rc=legacy).rc == rc
+
+
+@pytest.mark.parametrize("rc", [None, "constqp", "vbr", "cbr"])
+def test_valid_rc_untouched(rc):
+    assert FFmpegNVENCSettings(rc=rc).rc == rc
+
+
+def test_legacy_profile_loads_and_builds_valid_command():
+    profile = Profile(ffmpeg_hevc_nvenc={"preset": "llhq", "tune": "hq", "rc": "cbr_hq", "bitrate": "5000k"})
+    settings = profile.ffmpeg_hevc_nvenc
+    cmd = _cmd(hevc_build, settings)
+    assert _val(cmd, "-preset:v") == "p7"
+    assert _val(cmd, "-tune:v") == "ll"
+    assert _val(cmd, "-rc:v") == "cbr"
+    assert set(hevc_presets) >= {_val(cmd, "-preset:v")}
+
+
+def test_builder_never_emits_removed_values():
+    for preset in ["hp", "hq", "bd", "ll", "llhq", "llhp", "lossless", "losslesshp"]:
+        cmd = _cmd(hevc_build, FFmpegNVENCSettings(preset=preset, bitrate=None, qp=20))
+        assert _val(cmd, "-preset:v") in SUPPORTED_PRESETS
+
+
+# ---- multipass ------------------------------------------------------------------------------
+def test_hevc_multipass_default_fullres_bitrate():
+    cmd = _cmd(hevc_build, FFmpegNVENCSettings(bitrate="6000k"))
+    assert _val(cmd, "-multipass:v") == "fullres"
+
+
+@pytest.mark.parametrize("mode", ["qres", "fullres"])
+def test_hevc_multipass_selectable(mode):
+    cmd = _cmd(hevc_build, FFmpegNVENCSettings(bitrate="6000k", multipass=mode))
+    assert _val(cmd, "-multipass:v") == mode
+
+
+def test_hevc_multipass_disabled_omitted():
+    cmd = _cmd(hevc_build, FFmpegNVENCSettings(bitrate="6000k", multipass="disabled"))
+    assert "-multipass:v" not in cmd
+
+
+def test_hevc_multipass_not_in_qp_mode():
+    assert "-multipass:v" not in _cmd(hevc_build, FFmpegNVENCSettings(bitrate=None, qp=25))
+
+
+# ---- defaults are backward compatible ---------------------------------------------------------
+NEW_FLAGS = [
+    "-temporal-aq:v",
+    "-aq-strength:v",
+    "-tf_level",
+    "-lookahead_level",
+    "-split_encode_mode",
+    "-weighted_pred",
+    "-unidir_b",
+    "-no-scenecut",
+    "-cq:v",
+]
+
+
+def test_hevc_defaults_emit_no_new_flags():
+    for settings in (FFmpegNVENCSettings(), FFmpegNVENCSettings(bitrate=None, qp=25)):
+        cmd = _cmd(hevc_build, settings)
+        for flag in NEW_FLAGS:
+            assert flag not in cmd, flag
+
+
+def test_av1_defaults_do_not_gain_new_flags():
+    cmd = _cmd(av1_build, FFmpegAV1NVENCSettings())
+    for flag in ("-tf_level", "-lookahead_level", "-split_encode_mode", "-weighted_pred", "-no-scenecut", "-cq:v"):
+        assert flag not in cmd
+
+
+# ---- new HEVC options -------------------------------------------------------------------------
+def test_hevc_temporal_aq():
+    cmd = _cmd(hevc_build, FFmpegNVENCSettings(temporal_aq=1))
+    assert _val(cmd, "-temporal-aq:v") == "1"
+
+
+def test_hevc_aq_strength_only_when_changed():
+    cmd = _cmd(hevc_build, FFmpegNVENCSettings(spatial_aq=1, aq_strength=12))
+    assert _val(cmd, "-aq-strength:v") == "12"
+
+
+def test_hevc_tf_level_and_lookahead_level():
+    cmd = _cmd(hevc_build, FFmpegNVENCSettings(tf_level="4", lookahead_level="auto", rc_lookahead=32))
+    assert _val(cmd, "-tf_level") == "4"
+    assert _val(cmd, "-lookahead_level") == "auto"
+
+
+def test_hevc_split_weighted_unidir_scenecut():
+    cmd = _cmd(
+        hevc_build,
+        FFmpegNVENCSettings(split_encode_mode="forced", weighted_pred=1, unidir_b=True, no_scenecut=True),
+    )
+    assert _val(cmd, "-split_encode_mode") == "forced"
+    assert _val(cmd, "-weighted_pred") == "1"
+    assert _val(cmd, "-unidir_b") == "1"
+    assert _val(cmd, "-no-scenecut") == "1"
+
+
+def test_hevc_cq_mode():
+    cmd = _cmd(hevc_build, FFmpegNVENCSettings(bitrate=None, qp=25, cq=24))
+    assert _val(cmd, "-cq:v") == "24"
+    assert _val(cmd, "-rc:v") == "vbr"
+    assert _val(cmd, "-b:v") == "0"
+    assert "-qp:v" not in cmd
+
+
+def test_hevc_cq_ignored_in_bitrate_mode():
+    cmd = _cmd(hevc_build, FFmpegNVENCSettings(bitrate="5000k", cq=24))
+    assert "-cq:v" not in cmd
+
+
+# ---- AV1 mirror -------------------------------------------------------------------------------
+def test_av1_new_options():
+    cmd = _cmd(
+        av1_build,
+        FFmpegAV1NVENCSettings(
+            tf_level="0", lookahead_level="2", split_encode_mode="2", weighted_pred=1, no_scenecut=True
+        ),
+    )
+    assert _val(cmd, "-tf_level") == "0"
+    assert _val(cmd, "-lookahead_level") == "2"
+    assert _val(cmd, "-split_encode_mode") == "2"
+    assert _val(cmd, "-weighted_pred") == "1"
+    assert _val(cmd, "-no-scenecut") == "1"
+
+
+def test_av1_cq_mode():
+    cmd = _cmd(av1_build, FFmpegAV1NVENCSettings(bitrate=None, qp=28, cq=30))
+    assert _val(cmd, "-cq:v") == "30"
+    assert _val(cmd, "-rc:v") == "vbr"
+    assert "-qp:v" not in cmd
diff --git a/tests/encoders/test_nvenc_panels.py b/tests/encoders/test_nvenc_panels.py
new file mode 100644
index 00000000..77fa6045
--- /dev/null
+++ b/tests/encoders/test_nvenc_panels.py
@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+from unittest import mock
+
+import pytest
+from PySide6 import QtWidgets
+
+from fastflix.encoders.ffmpeg_av1_nvenc.settings_panel import AV1NVENC
+from fastflix.encoders.ffmpeg_hevc_nvenc.settings_panel import NVENC
+from fastflix.models.encode import FFmpegAV1NVENCSettings, FFmpegNVENCSettings
+
+PANELS = [(NVENC, FFmpegNVENCSettings, "ffmpeg_hevc_nvenc"), (AV1NVENC, FFmpegAV1NVENCSettings, "ffmpeg_av1_nvenc")]
+
+
+@pytest.fixture(scope="module")
+def qapp():
+    return QtWidgets.QApplication.instance() or QtWidgets.QApplication([])
+
+
+def _make_panel(panel_cls, settings_cls, saved, qapp):
+    app = mock.MagicMock()
+    app.fastflix.config.encoder_opt.side_effect = lambda _name, opt: getattr(saved, opt)
+    main = mock.MagicMock()
+    panel = panel_cls(None, main, app)
+    return panel, app
+
+
+@pytest.mark.parametrize("panel_cls,settings_cls,name", PANELS)
+def test_panel_round_trips_defaults(panel_cls, settings_cls, name, qapp):
+    defaults = settings_cls()
+    panel, app = _make_panel(panel_cls, settings_cls, defaults, qapp)
+    panel.update_video_encoder_settings()
+    result = app.fastflix.current_video.video_settings.video_encoder_settings
+    for field in (
+        "preset",
+        "aq_strength",
+        "tf_level",
+        "lookahead_level",
+        "split_encode_mode",
+        "weighted_pred",
+        "no_scenecut",
+        "temporal_aq",
+        "multipass",
+        "cq",
+    ):
+        if hasattr(defaults, field):
+            assert getattr(result, field) == getattr(defaults, field), field
+
+
+@pytest.mark.parametrize("panel_cls,settings_cls,name", PANELS)
+def test_panel_loads_saved_values(panel_cls, settings_cls, name, qapp):
+    saved = settings_cls(tf_level="4", lookahead_level="2", split_encode_mode="forced", weighted_pred=1, cq=30)
+    saved.aq_strength = 12
+    saved.no_scenecut = True
+    panel, app = _make_panel(panel_cls, settings_cls, saved, qapp)
+    panel.update_video_encoder_settings()
+    result = app.fastflix.current_video.video_settings.video_encoder_settings
+    assert (result.tf_level, result.lookahead_level, result.split_encode_mode) == ("4", "2", "forced")
+    assert (result.weighted_pred, result.cq, result.aq_strength, result.no_scenecut) == (1, 30, 12, True)
diff --git a/tests/encoders/test_nvencc_hevc_command_builder.py b/tests/encoders/test_nvencc_hevc_command_builder.py
index 514d532d..0fe2def7 100644
--- a/tests/encoders/test_nvencc_hevc_command_builder.py
+++ b/tests/encoders/test_nvencc_hevc_command_builder.py
@@ -145,7 +145,7 @@ def test_nvencc_hevc_with_crop_scale():
         video_settings=VideoSettings(
             crop=Crop(left=10, top=20, right=10, bottom=20, width=1900, height=1040),
             resolution_method="custom",
-            resolution_custom="1280x720",
+            resolution_custom="1280:720",
             remove_hdr=False,
             maxrate=None,
             bufsize=None,
diff --git a/tests/encoders/test_pr740_encoder_fixes.py b/tests/encoders/test_pr740_encoder_fixes.py
new file mode 100644
index 00000000..84bdc3d1
--- /dev/null
+++ b/tests/encoders/test_pr740_encoder_fixes.py
@@ -0,0 +1,258 @@
+# -*- coding: utf-8 -*-
+"""Regression tests for PR 740 review findings (encoders)."""
+
+from pathlib import Path
+from unittest import mock
+
+import pytest
+from box import Box
+
+from fastflix.encoders.common.encc_helpers import build_audio as encc_build_audio
+from fastflix.encoders.common.encc_helpers import rigaya_extra_options
+from fastflix.models.encode import (
+    AOMAV1Settings,
+    NVEncCSettings,
+    QSVEncCAV1Settings,
+    QSVEncCH264Settings,
+    QSVEncCSettings,
+    SVTAV1Settings,
+    sanitize_qsv_tune,
+    x264Settings,
+)
+from fastflix.models.video import AudioTrack, VideoSettings
+
+from tests.conftest import create_fastflix_instance
+
+
+# ---- 1. QSVEncC tune ----
+
+
+@pytest.mark.parametrize("old", ["hq", "ll", "ull", "lossless"])
+def test_qsv_tune_old_nvencc_values_dropped(old):
+    assert sanitize_qsv_tune(old) is None
+    assert QSVEncCSettings(tune=old).tune is None
+    assert QSVEncCH264Settings(tune=old).tune is None
+    assert QSVEncCAV1Settings(tune=old).tune is None
+
+
+def test_qsv_tune_valid_values_kept():
+    assert sanitize_qsv_tune("vmaf") == "vmaf"
+    assert sanitize_qsv_tune("psnr,ssim") == "psnr,ssim"
+    assert sanitize_qsv_tune("hq,perceptual") == "perceptual"
+    assert sanitize_qsv_tune("") is None
+
+
+def _qsv_fastflix(settings):
+    fastflix = create_fastflix_instance(encoder_settings=settings, video_settings=VideoSettings())
+    fastflix.current_video.streams = Box(
+        {
+            "video": [
+                Box(
+                    {
+                        "index": 0,
+                        "id": "0x1",
+                        "codec_name": "hevc",
+                        "codec_type": "video",
+                        "pix_fmt": "yuv420p10le",
+                        "bit_depth": 10,
+                        "r_frame_rate": "24/1",
+                        "avg_frame_rate": "24/1",
+                        "width": 1920,
+                        "height": 1080,
+                    }
+                )
+            ],
+            "audio": [],
+            "subtitle": [],
+        }
+    )
+    fastflix.config.qsvencc = Path("QSVEncC64")
+    return fastflix
+
+
+def test_qsv_builder_emits_valid_tune_only():
+    from fastflix.encoders.qsvencc_hevc.command_builder import build
+
+    with mock.patch("fastflix.encoders.qsvencc_hevc.command_builder.rigaya_auto_options", return_value=[]):
+        cmd = build(_qsv_fastflix(QSVEncCSettings(bitrate=None, cqp=22, preset="best", tune="vmaf")))[0].command
+        assert cmd[cmd.index("--tune") + 1] == "vmaf"
+        settings = QSVEncCSettings(bitrate=None, cqp=22, preset="best")
+        settings.tune = "hq"  # bypasses the validator, the builder must still guard
+        assert "--tune" not in build(_qsv_fastflix(settings))[0].command
+
+
+# ---- 7. single --vpp-colorspace ----
+
+
+def test_hdr2sdr_and_lut3d_merged():
+    fastflix = create_fastflix_instance(
+        encoder_settings=NVEncCSettings(), video_settings=VideoSettings(lut3d_path="/a/b.cube")
+    )
+    result = rigaya_extra_options(fastflix.current_video, hdr2sdr="hdr2sdr=hable")
+    assert result.count("--vpp-colorspace") == 1
+    assert result[result.index("--vpp-colorspace") + 1] == "hdr2sdr=hable,lut3d=/a/b.cube,lut3d_interp=tetrahedral"
+
+
+def test_hdr2sdr_alone():
+    fastflix = create_fastflix_instance(encoder_settings=NVEncCSettings(), video_settings=VideoSettings())
+    result = rigaya_extra_options(fastflix.current_video, hdr2sdr="hdr2sdr=mobius")
+    assert result[result.index("--vpp-colorspace") + 1] == "hdr2sdr=mobius"
+
+
+# ---- 8. pad with rotation ----
+
+
+def _pad(rotate, aspect="16:9", width=1000, height=500):
+    fastflix = create_fastflix_instance(
+        encoder_settings=NVEncCSettings(), video_settings=VideoSettings(pad_aspect=aspect, rotate=rotate)
+    )
+    video = fastflix.current_video
+    video.streams.video[0].width = width
+    video.streams.video[0].height = height
+    assert (video.width, video.height) == (width, height)
+    result = rigaya_extra_options(video)
+    return [int(x) for x in result[result.index("--vpp-pad") + 1].split(",")]
+
+
+def test_pad_accounts_for_rotation():
+    # 1000x500 is wider than 16:9 -> padded top/bottom
+    left, top, right, bottom = _pad(0)
+    assert left == 0 and right == 0 and top > 0 and bottom > 0
+    # rotated 90 degrees -> 500x1000 portrait -> padded left/right up to 16:9 at height 1000
+    left, top, right, bottom = _pad(1)
+    assert top == 0 and bottom == 0 and left > 0 and right > 0
+    assert 500 + left + right == 1778
+
+
+# ---- 9. GOP ----
+
+
+@pytest.mark.parametrize("gop", [None, 0, -1])
+def test_gop_unset_values(gop):
+    fastflix = create_fastflix_instance(encoder_settings=NVEncCSettings(), video_settings=VideoSettings(gop_length=gop))
+    assert "--gop-len" not in rigaya_extra_options(fastflix.current_video)
+
+
+# ---- 3. rigaya audio profile ----
+
+
+def _audio_track(codec, profile, downmix="stereo"):
+    return AudioTrack(
+        index=1,
+        outdex=1,
+        codec="eac3",
+        enabled=True,
+        conversion_codec=codec,
+        conversion_profile=profile,
+        conversion_bitrate="64k",
+        downmix=downmix,
+        raw_info=Box({"channels": 6, "channel_layout": "5.1"}),
+        dispositions={},
+    )
+
+
+def test_rigaya_audio_profile_names():
+    out = encc_build_audio([_audio_track("libfdk_aac", "aac_he")], [Box({"index": 1})])
+    assert "1?HE-AAC" in out
+    out = encc_build_audio([_audio_track("libfdk_aac", "aac_he_v2")], [Box({"index": 1})])
+    assert "1?HE-AACv2" in out
+    out = encc_build_audio([_audio_track("libfdk_aac", "aac_he_v2", downmix="5.1")], [Box({"index": 1})])
+    assert "1?HE-AAC" in out
+
+
+def test_rigaya_native_aac_no_profile():
+    out = encc_build_audio([_audio_track("aac", "aac_he")], [Box({"index": 1})])
+    assert "--audio-profile" not in out
+
+
+# ---- 4. x264 lossless ----
+
+
+def _build_x264(**kwargs):
+    from fastflix.encoders.avc_x264.command_builder import build
+
+    fastflix = create_fastflix_instance(
+        encoder_settings=x264Settings(crf=23, preset="medium", pix_fmt="yuv420p", bitrate=None, **kwargs),
+        video_settings=VideoSettings(),
+    )
+    with mock.patch("fastflix.encoders.avc_x264.command_builder.generate_all") as gen:
+        gen.return_value = (["ffmpeg", "-i", "in.mkv"], ["out.mkv"], [])
+        with mock.patch("fastflix.encoders.avc_x264.command_builder.generate_color_details", return_value=[]):
+            return build(fastflix)[0].command
+
+
+def test_x264_lossless_drops_incompatible_profile():
+    cmd = _build_x264(profile="high", lossless=True)
+    assert "-profile:v" not in cmd
+    assert "-qp" in cmd
+
+
+def test_x264_lossless_keeps_high444():
+    cmd = _build_x264(profile="high444", lossless=True)
+    assert cmd[cmd.index("-profile:v") + 1] == "high444"
+
+
+def test_x264_profile_kept_when_not_lossless():
+    assert "-profile:v" in _build_x264(profile="high", lossless=False)
+
+
+# ---- 5. SVT-AV1 lossless ----
+
+
+def _build_svt(**kwargs):
+    from fastflix.encoders.svt_av1.command_builder import build
+
+    fastflix = create_fastflix_instance(
+        encoder_settings=SVTAV1Settings(
+            qp=24, qp_mode="crf", speed="7", tile_columns="0", tile_rows="0", single_pass=True, bitrate=None, **kwargs
+        ),
+        video_settings=VideoSettings(),
+    )
+    with mock.patch("fastflix.encoders.svt_av1.command_builder.generate_all") as gen:
+        gen.return_value = (["ffmpeg", "-i", "in.mkv"], ["out.mkv"], [])
+        with mock.patch("fastflix.encoders.svt_av1.command_builder.generate_color_details", return_value=[]):
+            cmd = build(fastflix)[0].command
+    return cmd[cmd.index("-svtav1-params") + 1]
+
+
+def test_svt_lossless_no_film_grain():
+    params = _build_svt(lossless=True, film_grain=8, film_grain_denoise=True)
+    assert "lossless=1" in params
+    assert "film-grain" not in params
+
+
+def test_svt_film_grain_when_not_lossless():
+    assert "film-grain=8" in _build_svt(lossless=False, film_grain=8)
+
+
+# ---- 6. AOM lossless ----
+
+
+def _build_aom(**kwargs):
+    from fastflix.encoders.av1_aom.command_builder import build
+
+    fastflix = create_fastflix_instance(
+        encoder_settings=AOMAV1Settings(
+            crf=26,
+            cpu_used="4",
+            usage="good",
+            row_mt="enabled",
+            tile_rows="0",
+            tile_columns="0",
+            bitrate=None,
+            **kwargs,
+        ),
+        video_settings=VideoSettings(),
+    )
+    with mock.patch("fastflix.encoders.av1_aom.command_builder.generate_all") as gen:
+        gen.return_value = (["ffmpeg", "-i", "in.mkv"], ["out.mkv"], [])
+        with mock.patch("fastflix.encoders.av1_aom.command_builder.generate_color_details", return_value=[]):
+            return build(fastflix)[0].command
+
+
+def test_aom_lossless_skips_denoise():
+    assert "-denoise-noise-level" not in _build_aom(lossless=True, denoise_noise_level=10)
+
+
+def test_aom_denoise_when_not_lossless():
+    assert "-denoise-noise-level" in _build_aom(lossless=False, denoise_noise_level=10)
diff --git a/tests/encoders/test_qsvencc_av1_command_builder.py b/tests/encoders/test_qsvencc_av1_command_builder.py
new file mode 100644
index 00000000..084c6e32
--- /dev/null
+++ b/tests/encoders/test_qsvencc_av1_command_builder.py
@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+from pathlib import Path
+from unittest import mock
+
+from box import Box
+
+from fastflix.encoders.qsvencc_av1.command_builder import build
+from fastflix.models.encode import QSVEncCAV1Settings
+from fastflix.models.video import VideoSettings
+
+from tests.conftest import create_fastflix_instance
+
+
+def _make_fastflix(encoder_settings, video_settings=None, stream_extras=None):
+    """Create a FastFlix instance with QSVEncC AV1-compatible video stream data."""
+    fastflix = create_fastflix_instance(encoder_settings=encoder_settings, video_settings=video_settings)
+    stream_data = {
+        "index": 0,
+        "id": "0x1",
+        "codec_name": "hevc",
+        "codec_type": "video",
+        "pix_fmt": "yuv420p10le",
+        "color_space": "bt2020nc",
+        "color_transfer": "smpte2084",
+        "color_primaries": "bt2020",
+        "chroma_location": "left",
+        "bit_depth": 10,
+        "r_frame_rate": "24000/1001",
+        "avg_frame_rate": "24000/1001",
+        "width": 1920,
+        "height": 1080,
+    }
+    if stream_extras:
+        stream_data.update(stream_extras)
+    fastflix.current_video.streams = Box({"video": [Box(stream_data)], "audio": [], "subtitle": []})
+    fastflix.config.qsvencc = Path("QSVEncC64")
+    return fastflix
+
+
+def test_qsvencc_av1_basic_cqp():
+    """Test QSVEncC AV1 build with CQP mode produces all-string command list."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCAV1Settings(
+            bitrate=None,
+            cqp=22,
+            preset="best",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_av1.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    assert len(result) == 1
+    cmd = result[0].command
+    assert isinstance(cmd, list)
+    for i, element in enumerate(cmd):
+        assert isinstance(element, str), f"Element at index {i} is {type(element).__name__}: {element!r}"
+
+    assert "--cqp" in cmd
+    assert "22" in cmd
+    assert "-c" in cmd
+    assert "av1" in cmd
+    assert "QSVEncC64" in cmd
+
+
+def test_qsvencc_av1_tune_hq():
+    """Test that --tune hq is added to the command when tune is set."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCAV1Settings(
+            bitrate=None,
+            cqp=22,
+            tune="vmaf",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_av1.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert "--tune" in cmd
+    tune_idx = cmd.index("--tune")
+    assert cmd[tune_idx + 1] == "vmaf"
+
+
+def test_qsvencc_av1_tune_ll():
+    """Test that --tune ll (low latency) is added to the command."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCAV1Settings(
+            bitrate=None,
+            cqp=22,
+            tune="psnr",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_av1.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert "--tune" in cmd
+    tune_idx = cmd.index("--tune")
+    assert cmd[tune_idx + 1] == "psnr"
+
+
+def test_qsvencc_av1_tune_lossless():
+    """Test that --tune lossless is added to the command."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCAV1Settings(
+            bitrate=None,
+            cqp=22,
+            tune="perceptual",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_av1.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert "--tune" in cmd
+    tune_idx = cmd.index("--tune")
+    assert cmd[tune_idx + 1] == "perceptual"
+
+
+def test_qsvencc_av1_tune_none():
+    """Test that --tune is NOT in the command when tune is None."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCAV1Settings(
+            bitrate=None,
+            cqp=22,
+            tune=None,
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_av1.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert "--tune" not in cmd
+
+
+def test_qsvencc_av1_tune_default_is_none():
+    """Test that tune defaults to None when not specified."""
+    settings = QSVEncCAV1Settings(bitrate=None, cqp=22)
+    assert settings.tune is None
+
+
+def test_qsvencc_av1_with_bitrate():
+    """Test QSVEncC AV1 build with VBR bitrate mode."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCAV1Settings(
+            bitrate="6000k",
+            cqp=None,
+            preset="best",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_av1.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert isinstance(cmd, list)
+    assert "--vbr" in cmd
+    assert "6000" in cmd
+    assert "--cqp" not in cmd
+
+
+def test_qsvencc_av1_all_elements_are_strings():
+    """Comprehensive test: build with many options and verify all elements are strings."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCAV1Settings(
+            bitrate="5000k",
+            cqp=None,
+            preset="best",
+            level="5.1",
+            lookahead="32",
+            b_frames="3",
+            ref="4",
+            tune="psnr",
+        ),
+        video_settings=VideoSettings(
+            start_time=5.5,
+            end_time=60.0,
+            source_fps="24",
+            remove_hdr=False,
+            maxrate=8000,
+            bufsize=16000,
+            video_title="Test Title",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_av1.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert isinstance(cmd, list)
+    for i, element in enumerate(cmd):
+        assert isinstance(element, str), f"Element at index {i} is {type(element).__name__}: {element!r}"
+
+    assert "--tune" in cmd
+    assert "--quality" in cmd
diff --git a/tests/encoders/test_qsvencc_avc_command_builder.py b/tests/encoders/test_qsvencc_avc_command_builder.py
new file mode 100644
index 00000000..17888d34
--- /dev/null
+++ b/tests/encoders/test_qsvencc_avc_command_builder.py
@@ -0,0 +1,222 @@
+# -*- coding: utf-8 -*-
+from pathlib import Path
+from unittest import mock
+
+from box import Box
+
+from fastflix.encoders.qsvencc_avc.command_builder import build
+from fastflix.models.encode import QSVEncCH264Settings
+from fastflix.models.video import VideoSettings
+
+from tests.conftest import create_fastflix_instance
+
+
+def _make_fastflix(encoder_settings, video_settings=None, stream_extras=None):
+    """Create a FastFlix instance with QSVEncC AVC-compatible video stream data."""
+    fastflix = create_fastflix_instance(encoder_settings=encoder_settings, video_settings=video_settings)
+    stream_data = {
+        "index": 0,
+        "id": "0x1",
+        "codec_name": "h264",
+        "codec_type": "video",
+        "pix_fmt": "yuv420p",
+        "color_space": "bt709",
+        "color_transfer": "bt709",
+        "color_primaries": "bt709",
+        "chroma_location": "left",
+        "bit_depth": 8,
+        "r_frame_rate": "24000/1001",
+        "avg_frame_rate": "24000/1001",
+        "width": 1920,
+        "height": 1080,
+    }
+    if stream_extras:
+        stream_data.update(stream_extras)
+    fastflix.current_video.streams = Box({"video": [Box(stream_data)], "audio": [], "subtitle": []})
+    fastflix.config.qsvencc = Path("QSVEncC64")
+    return fastflix
+
+
+def test_qsvencc_avc_basic_cqp():
+    """Test QSVEncC AVC build with CQP mode produces all-string command list."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCH264Settings(
+            bitrate=None,
+            cqp=22,
+            preset="best",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_avc.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    assert len(result) == 1
+    cmd = result[0].command
+    assert isinstance(cmd, list)
+    for i, element in enumerate(cmd):
+        assert isinstance(element, str), f"Element at index {i} is {type(element).__name__}: {element!r}"
+
+    assert "--cqp" in cmd
+    assert "22" in cmd
+    assert "-c" in cmd
+    assert "h264" in cmd
+    assert "QSVEncC64" in cmd
+
+
+def test_qsvencc_avc_tune_hq():
+    """Test that --tune hq is added to the command when tune is set."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCH264Settings(
+            bitrate=None,
+            cqp=22,
+            tune="vmaf",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_avc.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert "--tune" in cmd
+    tune_idx = cmd.index("--tune")
+    assert cmd[tune_idx + 1] == "vmaf"
+
+
+def test_qsvencc_avc_tune_ll():
+    """Test that --tune ll (low latency) is added to the command."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCH264Settings(
+            bitrate=None,
+            cqp=22,
+            tune="psnr",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_avc.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert "--tune" in cmd
+    tune_idx = cmd.index("--tune")
+    assert cmd[tune_idx + 1] == "psnr"
+
+
+def test_qsvencc_avc_tune_lossless():
+    """Test that --tune lossless is added to the command."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCH264Settings(
+            bitrate=None,
+            cqp=22,
+            tune="perceptual",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_avc.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert "--tune" in cmd
+    tune_idx = cmd.index("--tune")
+    assert cmd[tune_idx + 1] == "perceptual"
+
+
+def test_qsvencc_avc_tune_none():
+    """Test that --tune is NOT in the command when tune is None."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCH264Settings(
+            bitrate=None,
+            cqp=22,
+            tune=None,
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_avc.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert "--tune" not in cmd
+
+
+def test_qsvencc_avc_tune_default_is_none():
+    """Test that tune defaults to None when not specified."""
+    settings = QSVEncCH264Settings(bitrate=None, cqp=22)
+    assert settings.tune is None
+
+
+def test_qsvencc_avc_with_profile():
+    """Test QSVEncC AVC build includes --profile flag."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCH264Settings(
+            bitrate=None,
+            cqp=22,
+            profile="high",
+            tune="vmaf",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_avc.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert "--profile" in cmd
+    profile_idx = cmd.index("--profile")
+    assert cmd[profile_idx + 1] == "high"
+    assert "--tune" in cmd
+
+
+def test_qsvencc_avc_with_bitrate():
+    """Test QSVEncC AVC build with VBR bitrate mode."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCH264Settings(
+            bitrate="6000k",
+            cqp=None,
+            preset="best",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_avc.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert isinstance(cmd, list)
+    assert "--vbr" in cmd
+    assert "6000" in cmd
+    assert "--cqp" not in cmd
+
+
+def test_qsvencc_avc_all_elements_are_strings():
+    """Comprehensive test: build with many options and verify all elements are strings."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCH264Settings(
+            bitrate="5000k",
+            cqp=None,
+            preset="best",
+            profile="high",
+            level="5.1",
+            lookahead="32",
+            b_frames="3",
+            ref="4",
+            tune="ssim",
+        ),
+        video_settings=VideoSettings(
+            start_time=5.5,
+            end_time=60.0,
+            source_fps="24",
+            remove_hdr=False,
+            maxrate=8000,
+            bufsize=16000,
+            video_title="Test Title",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_avc.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert isinstance(cmd, list)
+    for i, element in enumerate(cmd):
+        assert isinstance(element, str), f"Element at index {i} is {type(element).__name__}: {element!r}"
+
+    assert "--tune" in cmd
+    assert "--quality" in cmd
+    assert "--profile" in cmd
diff --git a/tests/encoders/test_qsvencc_hevc_command_builder.py b/tests/encoders/test_qsvencc_hevc_command_builder.py
new file mode 100644
index 00000000..3c98711f
--- /dev/null
+++ b/tests/encoders/test_qsvencc_hevc_command_builder.py
@@ -0,0 +1,220 @@
+# -*- coding: utf-8 -*-
+from pathlib import Path
+from unittest import mock
+
+from box import Box
+
+from fastflix.encoders.qsvencc_hevc.command_builder import build
+from fastflix.models.encode import QSVEncCSettings
+from fastflix.models.video import VideoSettings
+
+from tests.conftest import create_fastflix_instance
+
+
+def _make_fastflix(encoder_settings, video_settings=None, stream_extras=None):
+    """Create a FastFlix instance with QSVEncC-compatible video stream data."""
+    fastflix = create_fastflix_instance(encoder_settings=encoder_settings, video_settings=video_settings)
+    stream_data = {
+        "index": 0,
+        "id": "0x1",
+        "codec_name": "hevc",
+        "codec_type": "video",
+        "pix_fmt": "yuv420p10le",
+        "color_space": "bt2020nc",
+        "color_transfer": "smpte2084",
+        "color_primaries": "bt2020",
+        "chroma_location": "left",
+        "bit_depth": 10,
+        "r_frame_rate": "24000/1001",
+        "avg_frame_rate": "24000/1001",
+        "width": 1920,
+        "height": 1080,
+    }
+    if stream_extras:
+        stream_data.update(stream_extras)
+    fastflix.current_video.streams = Box({"video": [Box(stream_data)], "audio": [], "subtitle": []})
+    fastflix.config.qsvencc = Path("QSVEncC64")
+    return fastflix
+
+
+def test_qsvencc_hevc_basic_cqp():
+    """Test QSVEncC HEVC build with CQP mode produces all-string command list."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCSettings(
+            bitrate=None,
+            cqp=22,
+            preset="best",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_hevc.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    assert len(result) == 1
+    cmd = result[0].command
+    assert isinstance(cmd, list)
+    for i, element in enumerate(cmd):
+        assert isinstance(element, str), f"Element at index {i} is {type(element).__name__}: {element!r}"
+
+    assert "--cqp" in cmd
+    assert "22" in cmd
+    assert "--quality" in cmd
+    assert "best" in cmd
+    assert "-c" in cmd
+    assert "hevc" in cmd
+    assert "QSVEncC64" in cmd
+
+
+def test_qsvencc_hevc_tune_hq():
+    """Test that --tune hq is added to the command when tune is set."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCSettings(
+            bitrate=None,
+            cqp=22,
+            tune="vmaf",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_hevc.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert "--tune" in cmd
+    tune_idx = cmd.index("--tune")
+    assert cmd[tune_idx + 1] == "vmaf"
+
+
+def test_qsvencc_hevc_tune_ll():
+    """Test that --tune ll (low latency) is added to the command."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCSettings(
+            bitrate=None,
+            cqp=22,
+            tune="psnr",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_hevc.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert "--tune" in cmd
+    tune_idx = cmd.index("--tune")
+    assert cmd[tune_idx + 1] == "psnr"
+
+
+def test_qsvencc_hevc_tune_ull():
+    """Test that --tune ull (ultra low latency) is added to the command."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCSettings(
+            bitrate=None,
+            cqp=22,
+            tune="ssim",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_hevc.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert "--tune" in cmd
+    tune_idx = cmd.index("--tune")
+    assert cmd[tune_idx + 1] == "ssim"
+
+
+def test_qsvencc_hevc_tune_lossless():
+    """Test that --tune lossless is added to the command."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCSettings(
+            bitrate=None,
+            cqp=22,
+            tune="perceptual",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_hevc.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert "--tune" in cmd
+    tune_idx = cmd.index("--tune")
+    assert cmd[tune_idx + 1] == "perceptual"
+
+
+def test_qsvencc_hevc_tune_none():
+    """Test that --tune is NOT in the command when tune is None."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCSettings(
+            bitrate=None,
+            cqp=22,
+            tune=None,
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_hevc.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert "--tune" not in cmd
+
+
+def test_qsvencc_hevc_tune_default_is_none():
+    """Test that tune defaults to None when not specified."""
+    settings = QSVEncCSettings(bitrate=None, cqp=22)
+    assert settings.tune is None
+
+
+def test_qsvencc_hevc_with_bitrate():
+    """Test QSVEncC HEVC build with VBR bitrate mode."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCSettings(
+            bitrate="6000k",
+            cqp=None,
+            preset="best",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_hevc.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert isinstance(cmd, list)
+    assert "--vbr" in cmd
+    assert "6000" in cmd
+    assert "--cqp" not in cmd
+
+
+def test_qsvencc_hevc_all_elements_are_strings():
+    """Comprehensive test: build with many options and verify all elements are strings."""
+    fastflix = _make_fastflix(
+        encoder_settings=QSVEncCSettings(
+            bitrate="5000k",
+            cqp=None,
+            preset="best",
+            level="5.1",
+            lookahead="32",
+            b_frames="3",
+            ref="4",
+            tune="vmaf",
+        ),
+        video_settings=VideoSettings(
+            start_time=5.5,
+            end_time=60.0,
+            source_fps="24",
+            remove_hdr=False,
+            maxrate=8000,
+            bufsize=16000,
+            video_title="Test Title",
+        ),
+    )
+
+    with mock.patch("fastflix.encoders.qsvencc_hevc.command_builder.rigaya_auto_options", return_value=[]):
+        result = build(fastflix)
+
+    cmd = result[0].command
+    assert isinstance(cmd, list)
+    for i, element in enumerate(cmd):
+        assert isinstance(element, str), f"Element at index {i} is {type(element).__name__}: {element!r}"
+
+    assert "--tune" in cmd
+    assert "--quality" in cmd
diff --git a/tests/encoders/test_rav1e_command_builder.py b/tests/encoders/test_rav1e_command_builder.py
index e9a89dfb..6377a51d 100644
--- a/tests/encoders/test_rav1e_command_builder.py
+++ b/tests/encoders/test_rav1e_command_builder.py
@@ -204,3 +204,9 @@ def test_rav1e_combined_params():
     assert "tune" in param_keys
     assert "photon_noise" in param_keys
     assert "no_scene_detection" in param_keys
+
+
+def test_rav1e_hdr10_metadata_for_422_10bit():
+    result = _build_with_settings(hdr10=True, pix_fmt="yuv422p10le")
+    params = result[0].command[result[0].command.index("-rav1e-params") + 1]
+    assert "mastering_display=" in params
diff --git a/tests/encoders/test_rigaya_review_fixes.py b/tests/encoders/test_rigaya_review_fixes.py
new file mode 100644
index 00000000..91afef90
--- /dev/null
+++ b/tests/encoders/test_rigaya_review_fixes.py
@@ -0,0 +1,461 @@
+# -*- coding: utf-8 -*-
+"""Regression tests for the NVEncC / QSVEncC / VCEEncC review fixes (checked against rigaya's option docs)."""
+
+import importlib
+from pathlib import Path
+
+import pytest
+from box import Box
+
+from fastflix.encoders.common.encc_helpers import NVENC_PROFILES, NVENC_TUNES
+from fastflix.models import encode as enc
+from fastflix.models.video import VideoSettings
+
+from tests.conftest import create_fastflix_instance
+
+# (encoder module, settings class name, config attribute)
+BUILDERS = {
+    "nvencc_hevc": ("NVEncCSettings", "nvencc"),
+    "nvencc_av1": ("NVEncCAV1Settings", "nvencc"),
+    "nvencc_avc": ("NVEncCAVCSettings", "nvencc"),
+    "qsvencc_hevc": ("QSVEncCSettings", "qsvencc"),
+    "qsvencc_av1": ("QSVEncCAV1Settings", "qsvencc"),
+    "qsvencc_avc": ("QSVEncCH264Settings", "qsvencc"),
+    "vceencc_hevc": ("VCEEncCSettings", "vceencc"),
+    "vceencc_av1": ("VCEEncCAV1Settings", "vceencc"),
+    "vceencc_avc": ("VCEEncCAVCSettings", "vceencc"),
+}
+HDR_BUILDERS = [x for x in BUILDERS if not x.endswith("avc")]
+
+
+def make(name, video_settings=None, stream_id="0x1", hdr=False, **settings):
+    cls_name, config_attr = BUILDERS[name]
+    fastflix = create_fastflix_instance(
+        encoder_settings=getattr(enc, cls_name)(**settings), video_settings=video_settings, hdr10_metadata=hdr
+    )
+    fastflix.current_video.streams = Box(
+        {
+            "video": [
+                Box(
+                    {
+                        "index": 0,
+                        "id": stream_id,
+                        "codec_name": "hevc",
+                        "codec_type": "video",
+                        "pix_fmt": "yuv420p10le",
+                        "color_space": "bt2020nc",
+                        "color_transfer": "smpte2084",
+                        "color_primaries": "bt2020",
+                        "chroma_location": "left",
+                        "bit_depth": 10,
+                        "r_frame_rate": "24000/1001",
+                        "avg_frame_rate": "24000/1001",
+                        "width": 1920,
+                        "height": 1080,
+                    }
+                )
+            ],
+            "audio": [],
+            "subtitle": [],
+        }
+    )
+    setattr(fastflix.config, config_attr, Path("EncC64"))
+    return fastflix
+
+
+def build(name, **kwargs):
+    module = importlib.import_module(f"fastflix.encoders.{name}.command_builder")
+    return module.build(make(name, **kwargs))[0].command
+
+
+def vs(**kwargs):
+    kwargs.setdefault("maxrate", None)
+    kwargs.setdefault("bufsize", None)
+    kwargs.setdefault("remove_hdr", False)
+    return VideoSettings(**kwargs)
+
+
+def value_after(cmd, flag):
+    return cmd[cmd.index(flag) + 1]
+
+
+# Item 4: HDR10 static metadata must not be written when tone mapping to SDR
+
+
+@pytest.mark.parametrize("name", HDR_BUILDERS)
+def test_hdr_metadata_emitted_when_not_removing_hdr(name):
+    cmd = build(name, hdr=True, video_settings=vs())
+    assert "--master-display" in cmd
+    assert "--max-cll" in cmd
+
+
+@pytest.mark.parametrize("name", HDR_BUILDERS)
+def test_hdr_metadata_not_emitted_when_removing_hdr(name):
+    cmd = build(name, hdr=True, video_settings=vs(remove_hdr=True))
+    assert "--master-display" not in cmd
+    assert "--max-cll" not in cmd
+    assert "hdr2sdr=hable" in " ".join(cmd)
+
+
+# Item 5: custom args are split like a shell, so quoted values stay one argument
+
+
+@pytest.mark.parametrize("name", list(BUILDERS))
+def test_extra_args_respect_quotes(name):
+    cmd = build(name, extra='--output-buf 8 --log "C:\\my logs\\enc.log"')
+    assert "C:\\my logs\\enc.log" in cmd
+    assert "--output-buf" in cmd
+
+
+# Item 9: video stream id 0 is a real id
+
+
+@pytest.mark.parametrize("name", list(BUILDERS))
+def test_video_streamid_zero_is_emitted(name):
+    cmd = build(name, stream_id="0x0")
+    assert value_after(cmd, "--video-streamid") == "0"
+
+
+@pytest.mark.parametrize("name", list(BUILDERS))
+def test_video_streamid_nonzero(name):
+    cmd = build(name, stream_id="0x1")
+    assert value_after(cmd, "--video-streamid") == "1"
+
+
+def test_split_extra_args_keeps_windows_backslashes(monkeypatch):
+    from fastflix.encoders.common import helpers
+
+    monkeypatch.setattr(helpers.sys, "platform", "win32")
+    assert helpers.split_extra_args(r"--log C:\logs\enc.log --x 'a b'") == [
+        "--log",
+        r"C:\logs\enc.log",
+        "--x",
+        "a b",
+    ]
+
+
+# Item 1: --pa and its parameters are separate argv tokens
+
+
+@pytest.mark.parametrize("name", ["vceencc_hevc", "vceencc_av1", "vceencc_avc"])
+def test_vce_pre_analysis_is_two_tokens(name):
+    cmd = build(name, pre_analysis=True)
+    assert all(" " not in x for x in cmd if x.startswith("--"))
+    assert value_after(cmd, "--pa").startswith("sc=medium,ss=high")
+
+
+# Item 3: output fps is only available via NVEncC's --vpp-fruc
+
+
+@pytest.mark.parametrize("name", ["nvencc_hevc", "nvencc_av1", "nvencc_avc"])
+def test_nvenc_output_fps_uses_fruc(name):
+    cmd = build(name, video_settings=vs(output_fps="60"))
+    assert value_after(cmd, "--vpp-fruc") == "fps=60/1"
+    assert "--vpp-fps" not in cmd
+
+
+@pytest.mark.parametrize("name", [x for x in BUILDERS if not x.startswith("nvenc")])
+def test_other_vendors_skip_output_fps(name):
+    cmd = build(name, video_settings=vs(output_fps="60"))
+    for flag in ("--vpp-fps", "--vpp-fruc", "--vpp-frc"):
+        assert flag not in cmd
+
+
+# Item 6: options the docs restrict to other codecs are not emitted
+
+
+def test_nvenc_tier_hevc_only():
+    assert value_after(build("nvencc_hevc", tier="main"), "--tier") == "main"
+    assert "--tier" not in build("nvencc_av1", tier="high")
+    assert "--tier" not in build("nvencc_avc")
+
+
+def test_vce_av1_has_no_hevc_avc_only_options():
+    cmd = build("vceencc_av1", vbaq=True, mv_precision="q-pel")
+    assert "--vbaq" not in cmd
+    assert "--motion-est" not in cmd
+
+
+@pytest.mark.parametrize("name", ["vceencc_hevc", "vceencc_avc"])
+def test_vce_hevc_avc_keep_vbaq_and_motion_est(name):
+    cmd = build(name, vbaq=True, mv_precision="half-pel")
+    assert "--vbaq" in cmd
+    assert value_after(cmd, "--motion-est") == "half-pel"
+
+
+# Item 8: QSV lookahead depth depends on the rate control mode
+
+
+def _qsv(name, **kwargs):
+    return build(name, lookahead="40", **kwargs)
+
+
+@pytest.mark.parametrize("name", ["qsvencc_hevc", "qsvencc_avc"])
+def test_qsv_la_depth_hevc_avc(name):
+    assert value_after(_qsv(name, bitrate="5000k"), "--la-depth") == "40"
+    assert value_after(_qsv(name, bitrate=None, cqp=23, qp_mode="la-icq"), "--la-depth") == "40"
+    assert "--la-depth" not in _qsv(name, bitrate=None, cqp=23, qp_mode="icq")
+    assert "--la-depth" not in _qsv(name, bitrate=None, cqp=23, qp_mode="cqp")
+    assert "--extbrc" not in _qsv(name, bitrate="5000k")
+
+
+def test_qsv_la_depth_av1_needs_extbrc_and_bitrate_control():
+    cmd = _qsv("qsvencc_av1", bitrate="5000k")
+    assert value_after(cmd, "--la-depth") == "40"
+    assert "--extbrc" in cmd
+    for qp_mode in ("cqp", "icq", "la-icq"):
+        cmd = _qsv("qsvencc_av1", bitrate=None, cqp=23, qp_mode=qp_mode)
+        assert "--la-depth" not in cmd
+        assert "--extbrc" not in cmd
+
+
+# Item 7: settings that were collected but never emitted
+
+
+@pytest.mark.parametrize(
+    "name,profile,emitted",
+    [
+        ("nvencc_hevc", "main10", True),
+        ("nvencc_hevc", "main444", True),
+        ("nvencc_hevc", "auto", False),
+        ("nvencc_hevc", "high", False),
+        ("nvencc_av1", "high", True),
+        ("nvencc_av1", "main10", False),
+        ("nvencc_avc", "high", True),
+        ("nvencc_avc", "baseline", True),
+        ("nvencc_avc", "main10", False),
+    ],
+)
+def test_nvenc_profile(name, profile, emitted):
+    cmd = build(name, profile=profile)
+    if emitted:
+        assert value_after(cmd, "--profile") == profile
+    else:
+        assert "--profile" not in cmd
+
+
+@pytest.mark.parametrize("name", ["vceencc_hevc", "vceencc_av1"])
+def test_vce_hevc_av1_b_frames(name):
+    assert value_after(build(name, b_frames="2"), "--bframes") == "2"
+    assert "--bframes" not in build(name)
+
+
+# Panels
+
+PANELS = {
+    "nvencc_hevc": ("NVENCC", "NVEncCSettings"),
+    "nvencc_av1": ("NVENCC", "NVEncCAV1Settings"),
+    "nvencc_avc": ("NVENCCAVC", "NVEncCAVCSettings"),
+    "qsvencc_hevc": ("QSVEnc", "QSVEncCSettings"),
+    "qsvencc_av1": ("QSVAV1Enc", "QSVEncCAV1Settings"),
+    "qsvencc_avc": ("QSVEncH264", "QSVEncCH264Settings"),
+    "vceencc_hevc": ("VCEENCC", "VCEEncCSettings"),
+    "vceencc_av1": ("VCEENCC", "VCEEncCAV1Settings"),
+    "vceencc_avc": ("VCEENCCAVC", "VCEEncCAVCSettings"),
+}
+
+
+@pytest.fixture(scope="module")
+def qapp():
+    from PySide6 import QtWidgets
+
+    return QtWidgets.QApplication.instance() or QtWidgets.QApplication([])
+
+
+@pytest.fixture
+def panel_factory(qapp):
+    from unittest import mock
+
+    from PySide6 import QtGui
+
+    def factory(name, **config_values):
+        cls_name, settings_name = PANELS[name]
+        settings_cls = getattr(enc, settings_name)
+        defaults = settings_cls(**config_values)
+        app = mock.MagicMock()
+        app.fastflix.config.theme = "onyx"
+        app.fastflix.config.encoder_opt = lambda profile, opt: getattr(defaults, opt)
+        for attr in ("nvencc_devices", "vceencc_devices", "qsvencc_devices"):
+            setattr(app.fastflix.config, attr, {0: {"name": "GPU", "encoders": []}})
+        app.font.return_value = QtGui.QFont()
+        app.fastflix.current_video.current_video_stream.bit_depth = 8
+        module = importlib.import_module(f"fastflix.encoders.{name}.settings_panel")
+        panel = getattr(module, cls_name)(None, mock.MagicMock(), app)
+        return panel, app
+
+    return factory
+
+
+def collected(panel, app):
+    panel.update_video_encoder_settings()
+    return app.fastflix.current_video.video_settings.video_encoder_settings
+
+
+def test_nvenc_av1_panel_has_no_tier(panel_factory):
+    panel, _ = panel_factory("nvencc_av1")
+    assert "tier" not in panel.widgets
+    for name in ("nvencc_hevc", "nvencc_avc"):
+        other, _ = panel_factory(name)
+        assert ("tier" in other.widgets) == (name == "nvencc_hevc")
+
+
+def test_vce_av1_panel_has_no_vbaq_or_motion_est(panel_factory):
+    panel, _ = panel_factory("vceencc_av1")
+    assert "vbaq" not in panel.widgets
+    assert "mv_precision" not in panel.widgets
+
+
+@pytest.mark.parametrize("name", ["nvencc_hevc", "nvencc_av1", "nvencc_avc"])
+def test_nvenc_panel_profile_roundtrip(panel_factory, name):
+    panel, app = panel_factory(name)
+    options = [panel.widgets.profile.itemText(i) for i in range(panel.widgets.profile.count())]
+    assert options[0] == "auto"
+    assert options[1:] == list(NVENC_PROFILES[name.split("_")[1]])
+    assert collected(panel, app).profile == "auto"
+    panel.widgets.profile.setCurrentText(options[-1])
+    assert collected(panel, app).profile == options[-1]
+
+
+@pytest.mark.parametrize("name", ["vceencc_hevc", "vceencc_av1"])
+def test_vce_panel_b_frames(panel_factory, name):
+    panel, app = panel_factory(name)
+    assert collected(panel, app).b_frames is None
+    panel.widgets.b_frames.setCurrentText("2")
+    assert collected(panel, app).b_frames == "2"
+
+
+# Item 11: NVEncC --tune
+
+
+@pytest.mark.parametrize(
+    "name,tune,emitted",
+    [
+        ("nvencc_hevc", "uhq", True),
+        ("nvencc_hevc", "lowlatency", True),
+        ("nvencc_hevc", "ultralowlatency", True),
+        ("nvencc_hevc", "lossless", True),
+        ("nvencc_hevc", "hq", False),
+        ("nvencc_av1", "uhq", True),
+        ("nvencc_av1", "lowlatency", True),
+        ("nvencc_av1", "lossless", False),
+        ("nvencc_avc", "lowlatency", True),
+        ("nvencc_avc", "lossless", True),
+        ("nvencc_avc", "uhq", False),
+        ("nvencc_hevc", "bogus", False),
+    ],
+)
+def test_nvenc_tune(name, tune, emitted):
+    cmd = build(name, tune=tune)
+    if emitted:
+        assert value_after(cmd, "--tune") == tune
+    else:
+        assert "--tune" not in cmd
+
+
+@pytest.mark.parametrize("settings_name", ["NVEncCSettings", "NVEncCAV1Settings", "NVEncCAVCSettings"])
+def test_nvenc_tune_defaults_and_old_profiles_load(settings_name):
+    cls = getattr(enc, settings_name)
+    assert cls().tune == "hq"
+    old = cls().model_dump()
+    del old["tune"]
+    assert cls.model_validate(old).tune == "hq"
+
+
+@pytest.mark.parametrize("name", ["nvencc_hevc", "nvencc_av1", "nvencc_avc"])
+def test_nvenc_panel_tune_roundtrip(panel_factory, name):
+    panel, app = panel_factory(name)
+    options = [panel.widgets.tune.itemText(i) for i in range(panel.widgets.tune.count())]
+    assert options == list(NVENC_TUNES[name.split("_")[1]])
+    assert options[0] == "hq"
+    assert collected(panel, app).tune == "hq"
+    panel.widgets.tune.setCurrentText(options[1])
+    assert collected(panel, app).tune == options[1]
+
+
+# Item 12: quality based VBR
+
+QVBR_NAMES = [
+    "nvencc_hevc",
+    "nvencc_av1",
+    "nvencc_avc",
+    "qsvencc_hevc",
+    "qsvencc_av1",
+    "qsvencc_avc",
+    "vceencc_av1",
+    "vceencc_avc",
+]
+
+
+@pytest.mark.parametrize("name", ["nvencc_hevc", "nvencc_av1", "nvencc_avc", "vceencc_av1", "vceencc_avc"])
+@pytest.mark.parametrize("mode", ["bitrate", "cqp"])
+def test_qvbr_quality_only_replaces_rate_control(name, mode):
+    """NVEncC and VCEEncC --qvbr takes the quality (equivalent to --vbr 0 --vbr-quality/--qvbr-quality)."""
+    kwargs = {"bitrate": "5000k"} if mode == "bitrate" else {"bitrate": None, "cqp": 22}
+    cmd = build(name, qvbr_quality="28", **kwargs)
+    assert value_after(cmd, "--qvbr") == "28"
+    for flag in ("--vbr", "--cqp", "--cbr"):
+        assert flag not in cmd
+
+
+@pytest.mark.parametrize("name", ["qsvencc_hevc", "qsvencc_av1", "qsvencc_avc"])
+def test_qsv_qvbr_uses_bitrate_and_quality(name):
+    cmd = build(name, qvbr_quality="28", bitrate="6000k")
+    assert value_after(cmd, "--qvbr") == "6000"
+    assert value_after(cmd, "--qvbr-quality") == "28"
+    assert "--vbr" not in cmd
+
+
+@pytest.mark.parametrize("name", ["qsvencc_hevc", "qsvencc_av1", "qsvencc_avc"])
+def test_qsv_qvbr_needs_bitrate_mode(name):
+    cmd = build(name, qvbr_quality="28", bitrate=None, cqp=23, qp_mode="icq")
+    assert "--qvbr" not in cmd
+    assert "--qvbr-quality" not in cmd
+    assert value_after(cmd, "--icq") == "23"
+
+
+@pytest.mark.parametrize("name", QVBR_NAMES)
+def test_qvbr_off_by_default(name):
+    cmd = build(name)
+    assert "--qvbr" not in cmd
+    assert "--qvbr-quality" not in cmd
+
+
+def test_vce_av1_legacy_qvbr_bitrate_mode_does_not_send_bitrate_as_quality():
+    cmd = build("vceencc_av1", bitrate_mode="qvbr", bitrate="5000k")
+    assert value_after(cmd, "--qvbr") == "23"
+
+
+def test_vce_av1_bitrate_modes():
+    assert value_after(build("vceencc_av1", bitrate_mode="cbr", bitrate="5000k"), "--cbr") == "5000"
+
+
+def test_vce_hevc_has_no_qvbr():
+    """VCEEncC documents --qvbr for H.264 and AV1 only."""
+    assert not hasattr(enc.VCEEncCSettings(), "qvbr_quality")
+
+
+@pytest.mark.parametrize("settings_name", ["NVEncCSettings", "QSVEncCSettings", "VCEEncCAV1Settings"])
+def test_qvbr_old_profiles_load(settings_name):
+    cls = getattr(enc, settings_name)
+    assert cls().qvbr_quality == "off"
+    old = cls().model_dump()
+    del old["qvbr_quality"]
+    assert cls.model_validate(old).qvbr_quality == "off"
+
+
+@pytest.mark.parametrize("name", QVBR_NAMES)
+def test_qvbr_panel_roundtrip(panel_factory, name):
+    panel, app = panel_factory(name)
+    options = [panel.widgets.qvbr_quality.itemText(i) for i in range(panel.widgets.qvbr_quality.count())]
+    assert options[0] == "off"
+    assert "23" in options
+    assert int(options[-1]) == (63 if name == "nvencc_av1" else 51)
+    assert collected(panel, app).qvbr_quality == "off"
+    panel.widgets.qvbr_quality.setCurrentText("30")
+    assert collected(panel, app).qvbr_quality == "30"
+
+
+def test_vce_av1_panel_no_longer_offers_qvbr_bitrate_mode(panel_factory):
+    panel, _ = panel_factory("vceencc_av1")
+    options = [panel.widgets.bitrate_mode.itemText(i) for i in range(panel.widgets.bitrate_mode.count())]
+    assert "qvbr" not in options
diff --git a/tests/encoders/test_subtitles.py b/tests/encoders/test_subtitles.py
index a44d980d..892f54f0 100644
--- a/tests/encoders/test_subtitles.py
+++ b/tests/encoders/test_subtitles.py
@@ -74,9 +74,10 @@ def test_build_subtitle_with_burn_in(sample_subtitle_tracks):
     # Check that the other tracks are mapped and copied with adjusted outdex
     assert "-map" in result
     assert "0:1" in result
-    assert "-c:1" in result
+    assert "-c:0" in result
     assert "0:2" in result
-    assert "-c:2" in result
+    assert "-c:1" in result
+    assert "-c:2" not in result
     assert "copy" in result
 
     # Check that languages are set
@@ -84,8 +85,8 @@ def test_build_subtitle_with_burn_in(sample_subtitle_tracks):
     assert "language=eng" in result
 
     # Check that dispositions are set correctly
+    assert "-disposition:0" in result
     assert "-disposition:1" in result
-    assert "-disposition:2" in result
     assert "forced" in result
 
     # Check that burn-in track and type are set correctly
@@ -248,3 +249,91 @@ def test_build_subtitle_external_defaults_no_break():
     # Default file_index is 0, so -map should be 0:3
     result, _, _ = build_subtitle([track])
     assert "0:3" in result
+
+
+def test_disposition_clear_default():
+    """When profile clears default, no track should have default disposition."""
+    tracks = [
+        SubtitleTrack(index=0, outdex=1, language="eng", enabled=True, dispositions={"default": True, "forced": False}),
+        SubtitleTrack(
+            index=1, outdex=2, language="jpn", enabled=True, dispositions={"default": False, "forced": False}
+        ),
+    ]
+    # Simulate "clear" mode — clear default from all tracks
+    for track in tracks:
+        track.dispositions["default"] = False
+
+    result, _, _ = build_subtitle(tracks)
+    # No default disposition means infer_no_subs should be added
+    assert "-default_mode" in result
+    assert "infer_no_subs" in result
+    # Verify disposition:1 is "0" (no flags)
+    disp_idx = result.index("-disposition:1")
+    assert result[disp_idx + 1] == "0"
+
+
+def test_disposition_set_first_default():
+    """When profile sets default on first, only first enabled track gets default."""
+    tracks = [
+        SubtitleTrack(
+            index=0, outdex=1, language="eng", enabled=True, dispositions={"default": False, "forced": False}
+        ),
+        SubtitleTrack(
+            index=1, outdex=2, language="jpn", enabled=True, dispositions={"default": False, "forced": False}
+        ),
+    ]
+    # Simulate "first" mode — set default on first enabled, clear rest
+    first_set = False
+    for track in tracks:
+        track.dispositions["default"] = not first_set
+        first_set = True
+
+    result, _, _ = build_subtitle(tracks)
+    # First track should have default, second should not
+    assert "-default_mode" not in result  # default is set, so no infer_no_subs
+    disp1_idx = result.index("-disposition:1")
+    assert "default" in result[disp1_idx + 1]
+    disp2_idx = result.index("-disposition:2")
+    assert result[disp2_idx + 1] == "0"
+
+
+def test_disposition_clear_forced():
+    """When profile clears forced, no track should have forced disposition."""
+    tracks = [
+        SubtitleTrack(index=0, outdex=1, language="eng", enabled=True, dispositions={"default": False, "forced": True}),
+        SubtitleTrack(
+            index=1, outdex=2, language="jpn", enabled=True, dispositions={"default": False, "forced": False}
+        ),
+    ]
+    # Simulate "clear" mode
+    for track in tracks:
+        track.dispositions["forced"] = False
+
+    result, _, _ = build_subtitle(tracks)
+    assert "-default_mode" in result
+    # First track should have disposition "0"
+    disp_idx = result.index("-disposition:1")
+    assert result[disp_idx + 1] == "0"
+
+
+def test_disposition_set_first_forced():
+    """When profile sets forced on first, only first enabled track gets forced."""
+    tracks = [
+        SubtitleTrack(
+            index=0, outdex=1, language="eng", enabled=True, dispositions={"default": False, "forced": False}
+        ),
+        SubtitleTrack(
+            index=1, outdex=2, language="jpn", enabled=True, dispositions={"default": False, "forced": False}
+        ),
+    ]
+    # Simulate "first" mode
+    first_set = False
+    for track in tracks:
+        track.dispositions["forced"] = not first_set
+        first_set = True
+
+    result, _, _ = build_subtitle(tracks)
+    disp1_idx = result.index("-disposition:1")
+    assert "forced" in result[disp1_idx + 1]
+    disp2_idx = result.index("-disposition:2")
+    assert result[disp2_idx + 1] == "0"
diff --git a/tests/encoders/test_svt_av1_avif_command_builder.py b/tests/encoders/test_svt_av1_avif_command_builder.py
index fcae2bc9..5bf8d432 100644
--- a/tests/encoders/test_svt_av1_avif_command_builder.py
+++ b/tests/encoders/test_svt_av1_avif_command_builder.py
@@ -82,3 +82,8 @@ def test_svt_av1_avif_bitrate():
     assert "2000k" in cmd
     assert "-f" in cmd
     assert "avif" in cmd
+
+
+def test_svt_av1_avif_tune_iq():
+    cmd = _build_with_settings(tune="3")[0].command
+    assert "tune=3" in cmd[cmd.index("-svtav1-params") + 1].split(":")
diff --git a/tests/encoders/test_svt_av1_command_builder.py b/tests/encoders/test_svt_av1_command_builder.py
index 27154ce4..30954363 100644
--- a/tests/encoders/test_svt_av1_command_builder.py
+++ b/tests/encoders/test_svt_av1_command_builder.py
@@ -101,7 +101,7 @@ def test_svt_av1_two_pass_qp():
     fastflix = create_fastflix_instance(
         encoder_settings=SVTAV1Settings(
             qp=24,
-            qp_mode="crf",
+            qp_mode="qp",
             speed="7",
             tile_columns="0",
             tile_rows="0",
@@ -301,3 +301,64 @@ def test_svt_av1_defaults_no_extra_params():
     assert "film-grain=" not in params
     assert "sharpness=" not in params
     assert "fast-decode=" not in params
+
+
+def test_svt_av1_new_options_default_output_unchanged():
+    _, params = _build_with_settings()
+    for key in ("variance", "enable-tf", "qm", "startup-mg-size"):
+        assert key not in params
+
+
+def test_svt_av1_variance_boost_enabled_defaults():
+    _, params = _build_with_settings(enable_variance_boost=True)
+    parts = params.split(":")
+    assert "enable-variance-boost=1" in parts
+    assert not any(p.startswith("variance-boost-strength") or p.startswith("variance-octile") for p in parts)
+
+
+def test_svt_av1_variance_boost_custom_values():
+    _, params = _build_with_settings(enable_variance_boost=True, variance_boost_strength="3", variance_octile="7")
+    parts = params.split(":")
+    assert "enable-variance-boost=1" in parts
+    assert "variance-boost-strength=3" in parts
+    assert "variance-octile=7" in parts
+
+
+def test_svt_av1_variance_values_ignored_when_disabled():
+    _, params = _build_with_settings(variance_boost_strength="3", variance_octile="7")
+    assert "variance" not in params
+
+
+def test_svt_av1_tune_new_values():
+    _, params = _build_with_settings(tune="3")
+    assert "tune=3" in params.split(":")
+
+
+def test_svt_av1_enable_tf_startup_mg_size():
+    _, params = _build_with_settings(enable_tf="2", startup_mg_size="3")
+    parts = params.split(":")
+    assert "enable-tf=2" in parts
+    assert "startup-mg-size=3" in parts
+
+
+def test_svt_av1_quant_matrices():
+    _, params = _build_with_settings(enable_qm=True, qm_min="2", qm_max="10")
+    parts = params.split(":")
+    assert "enable-qm=1" in parts
+    assert "qm-min=2" in parts
+    assert "qm-max=10" in parts
+    _, params = _build_with_settings(enable_qm=True)
+    assert params.split(":").count("enable-qm=1") == 1
+    assert "qm-min" not in params
+
+
+def test_svt_av1_user_params_merge_and_ui_wins():
+    _, params = _build_with_settings(svtav1_params=["enable-tf=0", "foo=1"], enable_tf="2")
+    parts = params.split(":")
+    assert parts[:2] == ["enable-tf=0", "foo=1"]
+    assert parts.index("enable-tf=2") > parts.index("enable-tf=0")
+
+
+def test_svt_av1_film_grain_full_range():
+    _, params = _build_with_settings(film_grain=50)
+    assert "film-grain=50" in params.split(":")
diff --git a/tests/encoders/test_vaapi_command_builders.py b/tests/encoders/test_vaapi_command_builders.py
new file mode 100644
index 00000000..480f3712
--- /dev/null
+++ b/tests/encoders/test_vaapi_command_builders.py
@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+import importlib
+from pathlib import Path
+
+import pytest
+
+from fastflix.encoders.common.helpers import generate_filters
+from fastflix.models import encode
+from fastflix.models.video import Crop, VideoSettings
+
+from tests.conftest import create_fastflix_instance
+
+ENCODERS = {
+    "vaapi_h264": ("VAAPIH264Settings", True),
+    "vaapi_hevc": ("VAAPIHEVCSettings", True),
+    "vaapi_vp9": ("VAAPIVP9Settings", False),
+    "vaapi_mpeg2": ("VAAPIMPEG2Settings", False),
+}
+ALL = list(ENCODERS)
+EXPLICIT_QP = [k for k, v in ENCODERS.items() if v[1]]
+GLOBAL_QUALITY_ONLY = [k for k, v in ENCODERS.items() if not v[1]]
+
+
+def run_build(name, settings_kwargs=None, **video_kwargs):
+    cls_name = ENCODERS[name][0]
+    settings = getattr(encode, cls_name)(**(settings_kwargs or {}))
+    video_kwargs.setdefault("remove_hdr", False)
+    fastflix = create_fastflix_instance(
+        encoder_settings=settings,
+        video_settings=VideoSettings(maxrate=None, bufsize=None, **video_kwargs),
+    )
+    module = importlib.import_module(f"fastflix.encoders.{name}.command_builder")
+    return module.build(fastflix)[0].command
+
+
+def filter_complex(cmd):
+    return cmd[cmd.index("-filter_complex") + 1]
+
+
+def opt(cmd, flag):
+    return cmd[cmd.index(flag) + 1]
+
+
+@pytest.mark.parametrize("name", ALL)
+def test_low_power_uses_underscore_option(name):
+    cmd = run_build(name, {"low_power": True})
+    assert "-low_power" in cmd
+    assert opt(cmd, "-low_power") == "1"
+    assert "-low-power" not in cmd
+
+
+@pytest.mark.parametrize("name", ALL)
+def test_software_frames_pipeline_is_robust(name):
+    """No forced hw output frames and no hwdownload, so a software-decode fallback still works."""
+    cmd = run_build(name)
+    assert "-hwaccel_output_format" not in cmd
+    assert "hwdownload" not in filter_complex(cmd)
+    assert filter_complex(cmd) == "[0:0]format=nv12,hwupload[v]"
+    assert "-filter_hw_device" in cmd
+    assert opt(cmd, "-filter_hw_device") == "hwdev"
+
+
+@pytest.mark.parametrize("name", ALL)
+def test_scale_is_applied(name):
+    cmd = run_build(name, resolution_method="custom", resolution_custom="1280:720")
+    fc = filter_complex(cmd)
+    assert fc.startswith("[0:0]scale=1280:720:flags=")
+    assert fc.endswith(",format=nv12,hwupload[v]")
+
+
+@pytest.mark.parametrize("name", ALL)
+def test_crop_and_rotate_run_before_upload(name):
+    cmd = run_build(name, crop=Crop(top=10, bottom=10, left=20, right=20), rotate=1)
+    fc = filter_complex(cmd)
+    assert fc.index("crop=") < fc.index("transpose=1") < fc.index("hwupload")
+    assert "hwdownload" not in fc
+
+
+@pytest.mark.parametrize("name", ALL)
+def test_level_auto_is_not_emitted(name):
+    cls = getattr(encode, ENCODERS[name][0])
+    if "level" not in cls.model_fields:
+        pytest.skip("no level")
+    cmd = run_build(name, {"level": "auto"})
+    assert "-level" not in cmd
+    cmd = run_build(name, {"level": "4.1"})
+    assert opt(cmd, "-level") == "4.1"
+
+
+@pytest.mark.parametrize("name", ["vaapi_hevc", "vaapi_vp9"])
+def test_ten_bit_uploads_p010_and_sets_profile(name):
+    cmd = run_build(name, {"bit_depth": "10-bit"})
+    assert filter_complex(cmd) == "[0:0]format=p010le,hwupload[v]"
+    assert opt(cmd, "-profile:v") == ("main10" if name == "vaapi_hevc" else "2")
+
+
+@pytest.mark.parametrize("name", ["vaapi_hevc", "vaapi_vp9"])
+def test_eight_bit_default_profile(name):
+    cmd = run_build(name)
+    assert filter_complex(cmd) == "[0:0]format=nv12,hwupload[v]"
+    assert opt(cmd, "-profile:v") == ("main" if name == "vaapi_hevc" else "0")
+
+
+@pytest.mark.parametrize("name", ["vaapi_h264", "vaapi_mpeg2"])
+def test_eight_bit_only_encoders_have_no_bit_depth_or_profile(name):
+    cmd = run_build(name)
+    assert "-profile:v" not in cmd
+    assert "p010le" not in filter_complex(cmd)
+
+
+def test_legacy_settings_without_bit_depth_default_to_8_bit():
+    restored = encode.VAAPIHEVCSettings.model_validate({"name": "VAAPI HEVC", "qp": 20})
+    assert restored.bit_depth == "8-bit"
+
+
+@pytest.mark.parametrize("name", ALL)
+def test_tonemap_vaapi_gets_p010_input(name):
+    cmd = run_build(name, remove_hdr=True)
+    assert filter_complex(cmd) == ("[0:0]format=p010le,hwupload,tonemap_vaapi=format=nv12:p=bt709:t=bt709:m=bt709[v]")
+
+
+def test_tonemap_vaapi_keeps_requested_10_bit_output():
+    cmd = run_build("vaapi_hevc", {"bit_depth": "10-bit"}, remove_hdr=True)
+    assert "tonemap_vaapi=format=p010:" in filter_complex(cmd)
+
+
+def test_vaapi_upload_comes_after_burned_in_text_subtitles():
+    result = generate_filters(
+        selected_track=0,
+        source=Path("input.mkv"),
+        vaapi=True,
+        burn_in_subtitle_track=0,
+        burn_in_subtitle_type="text",
+        custom_filters="hue=s=0.5",
+    )
+    fc = result[1]
+    assert fc.index("hue=") < fc.index("subtitles=") < fc.index("hwupload")
+
+
+@pytest.mark.parametrize("name", EXPLICIT_QP)
+def test_cqp_uses_qp(name):
+    cmd = run_build(name, {"rc_mode": "CQP", "qp": 24})
+    assert opt(cmd, "-rc_mode") == "CQP"
+    assert opt(cmd, "-qp") == "24"
+    assert "-global_quality" not in cmd
+
+
+@pytest.mark.parametrize("name", GLOBAL_QUALITY_ONLY)
+def test_encoders_without_qp_option_use_global_quality(name):
+    cmd = run_build(name, {"rc_mode": "CQP", "qp": 24})
+    assert "-qp" not in cmd
+    assert opt(cmd, "-global_quality") == "24"
+
+
+@pytest.mark.parametrize("name", ALL)
+def test_icq_uses_global_quality(name):
+    cmd = run_build(name, {"rc_mode": "ICQ", "qp": 22})
+    assert opt(cmd, "-rc_mode") == "ICQ"
+    assert opt(cmd, "-global_quality") == "22"
+    assert "-qp" not in cmd
+    assert "-b:v" not in cmd
+
+
+@pytest.mark.parametrize("name", ALL)
+def test_qvbr_uses_bitrate_and_global_quality(name):
+    cmd = run_build(name, {"rc_mode": "QVBR", "qp": 22, "bitrate": "4000k"})
+    assert opt(cmd, "-rc_mode") == "QVBR"
+    assert opt(cmd, "-global_quality") == "22"
+    assert opt(cmd, "-b:v") == "4000k"
+    assert "-qp" not in cmd
+
+
+@pytest.mark.parametrize("name", ALL)
+@pytest.mark.parametrize("mode", ["CQP", "ICQ"])
+def test_quality_modes_do_not_emit_bitrate(name, mode):
+    cmd = run_build(name, {"rc_mode": mode, "qp": None, "bitrate": "5000k"})
+    assert "-rc_mode" not in cmd
+    assert opt(cmd, "-b:v") == "5000k"
+
+
+@pytest.mark.parametrize("name", ALL)
+@pytest.mark.parametrize("mode", ["CBR", "VBR", "AVBR", "QVBR"])
+def test_bitrate_modes_with_bitrate(name, mode):
+    cmd = run_build(name, {"rc_mode": mode, "qp": None, "bitrate": "5000k"})
+    assert opt(cmd, "-rc_mode") == mode
+    assert opt(cmd, "-b:v") == "5000k"
+    assert "-qp" not in cmd
+
+
+@pytest.mark.parametrize("name", ALL)
+@pytest.mark.parametrize("mode", ["CBR", "VBR", "AVBR", "QVBR"])
+def test_bitrate_modes_without_bitrate_fall_back_to_auto(name, mode):
+    cmd = run_build(name, {"rc_mode": mode, "qp": 26, "bitrate": None})
+    assert "-rc_mode" not in cmd
+    assert "-b:v" not in cmd
+    assert "-qp" in cmd or "-global_quality" in cmd
+
+
+@pytest.mark.parametrize("name", ALL)
+def test_auto_with_qp_and_bitrate(name):
+    cmd = run_build(name, {"rc_mode": "auto", "qp": 26})
+    assert opt(cmd, "-rc_mode") == "auto"
+    assert "-b:v" not in cmd
diff --git a/tests/encoders/test_vaapi_hevc_command_builder.py b/tests/encoders/test_vaapi_hevc_command_builder.py
index eed3682f..e68909ed 100644
--- a/tests/encoders/test_vaapi_hevc_command_builder.py
+++ b/tests/encoders/test_vaapi_hevc_command_builder.py
@@ -114,8 +114,6 @@ def test_vaapi_hevc_start_extra_contains_hw_init():
                 "vaapi",
                 "-hwaccel_device",
                 "hwdev",
-                "-hwaccel_output_format",
-                "vaapi",
             ]
 
 
@@ -161,4 +159,4 @@ def test_vaapi_hevc_all_elements_are_strings():
     assert "-level" in cmd
     assert "5.1" in cmd
     assert "-aud" in cmd
-    assert "-low-power" in cmd
+    assert "-low_power" in cmd
diff --git a/tests/encoders/test_vp9_command_builder.py b/tests/encoders/test_vp9_command_builder.py
index b8479277..43c10606 100644
--- a/tests/encoders/test_vp9_command_builder.py
+++ b/tests/encoders/test_vp9_command_builder.py
@@ -189,3 +189,23 @@ def test_vp9_all_elements_are_strings():
         cmd = r.command
         for i, element in enumerate(cmd):
             assert isinstance(element, str), f"Element at index {i} is {type(element).__name__}: {element!r}"
+
+
+def test_vp9_crf_two_pass_has_speed_in_both_passes():
+    result = _build_with_settings(crf=31, speed="2", single_pass=False, fast_first_pass=False)
+    for res in result:
+        cmd = res.command
+        assert cmd[cmd.index("-speed:v") + 1] == "2"
+
+
+def test_vp9_crf_fast_first_pass_uses_speed_4_only_in_first_pass():
+    result = _build_with_settings(crf=31, speed="1", single_pass=False, fast_first_pass=True)
+    c1, c2 = result[0].command, result[1].command
+    assert c1[c1.index("-speed:v") + 1] == "4"
+    assert c2[c2.index("-speed:v") + 1] == "1"
+
+
+def test_vp9_crf_single_pass_has_speed():
+    result = _build_with_settings(crf=31, speed="3", single_pass=True)
+    cmd = result[0].command
+    assert cmd[cmd.index("-speed:v") + 1] == "3"
diff --git a/tests/encoders/test_vvc_command_builder.py b/tests/encoders/test_vvc_command_builder.py
index c9a7d551..fe63bcd4 100644
--- a/tests/encoders/test_vvc_command_builder.py
+++ b/tests/encoders/test_vvc_command_builder.py
@@ -249,3 +249,50 @@ def test_vvc_hdr10_all_elements_are_strings():
     cmd = result[0].command
     for i, element in enumerate(cmd):
         assert isinstance(element, str), f"Element at index {i} is {type(element).__name__}: {element!r}"
+
+
+def _params(cmd):
+    return cmd[cmd.index("-vvenc-params") + 1] if "-vvenc-params" in cmd else ""
+
+
+def _pass_value(cmd):
+    return cmd[cmd.index("-pass") + 1]
+
+
+def test_vvc_two_pass_uses_ffmpeg_pass_flags_not_vvenc_params():
+    """libvvenc.c rejects pass/passes/rcstatsfile inside vvenc-params; -pass and -passlogfile must be used."""
+    result = _build_with_settings(qp=None, bitrate="6000k")
+    cmd1, cmd2 = result[0].command, result[1].command
+    assert _pass_value(cmd1) == "1"
+    assert _pass_value(cmd2) == "2"
+    assert cmd1[cmd1.index("-passlogfile") + 1] == cmd2[cmd2.index("-passlogfile") + 1]
+    for cmd in (cmd1, cmd2):
+        params = _params(cmd).lower()
+        assert "pass=" not in params
+        assert "rcstatsfile" not in params
+
+
+def test_vvc_no_x265_vbv_keys_in_vvenc_params():
+    """vbv-maxrate/vbv-bufsize are unknown vvenc options (init fails); -maxrate/-bufsize come from generate_all."""
+    fastflix = create_fastflix_instance(
+        encoder_settings=VVCSettings(qp=22, bitrate=None, preset="medium", tier="main"),
+        video_settings=VideoSettings(remove_hdr=False, maxrate=5000, bufsize=10000),
+    )
+    with mock.patch("fastflix.encoders.vvc.command_builder.generate_all") as mock_gen:
+        mock_gen.return_value = (["ffmpeg", "-y", "-i", "input.mkv"], ["output.mkv"], [])
+        cmd = build(fastflix)[0].command
+    assert "vbv" not in _params(cmd)
+
+
+def test_vvc_mastering_display_uses_vvenc_integer_format():
+    result = _build_with_settings(hdr10=True, pix_fmt="yuv420p10le")
+    params = _params(result[0].command)
+    assert "MasteringDisplayColourVolume=" in params
+    assert "(" not in params
+
+
+def test_vvc_hdr_metadata_for_422_10bit():
+    result = _build_with_settings(hdr10=True, pix_fmt="yuv422p10le")
+    params = _params(result[0].command)
+    assert "MasteringDisplayColourVolume=" in params
+    assert "MaxContentLightLevel=1000,300" in params
diff --git a/tests/general.py b/tests/general.py
index 2f834e6f..ca907077 100644
--- a/tests/general.py
+++ b/tests/general.py
@@ -12,6 +12,7 @@
             "channels": 6,
             "codec_long_name": "TrueHD",
             "codec_name": "truehd",
+            "profile": "TrueHD+Atmos",
             "codec_tag": "0x0000",
             "codec_tag_string": "[0][0][0][0]",
             "codec_type": "audio",
@@ -200,5 +201,91 @@
             },
             "time_base": "1/1000",
         },
+        {
+            "avg_frame_rate": "0/0",
+            "bits_per_raw_sample": "24",
+            "bits_per_sample": 0,
+            "channel_layout": "5.1(side)",
+            "channels": 6,
+            "codec_long_name": "DCA (DTS Coherent Acoustics)",
+            "codec_name": "dts",
+            "profile": "DTS-HD MA",
+            "codec_tag": "0x0000",
+            "codec_tag_string": "[0][0][0][0]",
+            "codec_type": "audio",
+            "disposition": {
+                "attached_pic": 0,
+                "captions": 0,
+                "clean_effects": 0,
+                "comment": 0,
+                "default": 0,
+                "dependent": 0,
+                "descriptions": 0,
+                "dub": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "karaoke": 0,
+                "lyrics": 0,
+                "metadata": 0,
+                "original": 0,
+                "still_image": 0,
+                "timed_thumbnails": 0,
+                "visual_impaired": 0,
+            },
+            "index": 5,
+            "r_frame_rate": "0/0",
+            "sample_fmt": "s32p",
+            "sample_rate": "48000",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "tags": {
+                "language": "eng",
+                "title": "DTS-HD MA 5.1",
+            },
+            "time_base": "1/1000",
+        },
+        {
+            "avg_frame_rate": "0/0",
+            "bit_rate": "1536000",
+            "bits_per_sample": 0,
+            "channel_layout": "5.1(side)",
+            "channels": 6,
+            "codec_long_name": "DCA (DTS Coherent Acoustics)",
+            "codec_name": "dts",
+            "profile": "DTS",
+            "codec_tag": "0x0000",
+            "codec_tag_string": "[0][0][0][0]",
+            "codec_type": "audio",
+            "disposition": {
+                "attached_pic": 0,
+                "captions": 0,
+                "clean_effects": 0,
+                "comment": 0,
+                "default": 0,
+                "dependent": 0,
+                "descriptions": 0,
+                "dub": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "karaoke": 0,
+                "lyrics": 0,
+                "metadata": 0,
+                "original": 0,
+                "still_image": 0,
+                "timed_thumbnails": 0,
+                "visual_impaired": 0,
+            },
+            "index": 6,
+            "r_frame_rate": "0/0",
+            "sample_fmt": "fltp",
+            "sample_rate": "48000",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "tags": {
+                "language": "eng",
+                "title": "DTS 5.1",
+            },
+            "time_base": "1/1000",
+        },
     ]
 )
diff --git a/tests/media/chapters_timecode.mp4 b/tests/media/chapters_timecode.mp4
new file mode 100644
index 00000000..c955bd49
Binary files /dev/null and b/tests/media/chapters_timecode.mp4 differ
diff --git a/tests/media/font_attachment_data.mkv b/tests/media/font_attachment_data.mkv
new file mode 100644
index 00000000..ad332b5e
Binary files /dev/null and b/tests/media/font_attachment_data.mkv differ
diff --git a/tests/media/multi_stream.mp4 b/tests/media/multi_stream.mp4
new file mode 100644
index 00000000..093f3a85
Binary files /dev/null and b/tests/media/multi_stream.mp4 differ
diff --git a/tests/media/test_color_shift.cube b/tests/media/test_color_shift.cube
new file mode 100644
index 00000000..cb9ce0b7
--- /dev/null
+++ b/tests/media/test_color_shift.cube
@@ -0,0 +1,22 @@
+# Test LUT - swaps red and blue channels for obvious visual difference
+# Size 2: entries ordered R-fastest, then G, then B
+# Input (R,G,B) -> Output (B,G,R)
+TITLE "Test Red-Blue Swap"
+LUT_3D_SIZE 2
+
+# (0,0,0) -> (0,0,0)
+0.0 0.0 0.0
+# (1,0,0) -> (0,0,1)
+0.0 0.0 1.0
+# (0,1,0) -> (0,1,0)
+0.0 1.0 0.0
+# (1,1,0) -> (0,1,1)
+0.0 1.0 1.0
+# (0,0,1) -> (1,0,0)
+1.0 0.0 0.0
+# (1,0,1) -> (1,0,1)
+1.0 0.0 1.0
+# (0,1,1) -> (1,1,0)
+1.0 1.0 0.0
+# (1,1,1) -> (1,1,1)
+1.0 1.0 1.0
diff --git a/tests/test_advanced_panel_layout.py b/tests/test_advanced_panel_layout.py
new file mode 100644
index 00000000..94bac0a6
--- /dev/null
+++ b/tests/test_advanced_panel_layout.py
@@ -0,0 +1,245 @@
+# -*- coding: utf-8 -*-
+"""Tests for the Advanced panel QGroupBox layout.
+
+Verifies that the panel renders correctly at realistic sizes,
+the scroll area works, and groups don't compress.
+"""
+
+import pytest
+from unittest import mock
+from PySide6 import QtWidgets
+
+
+@pytest.fixture(scope="session")
+def qapp():
+    """Create or reuse a QApplication instance for the test session."""
+    app = QtWidgets.QApplication.instance()
+    if app is None:
+        app = QtWidgets.QApplication([])
+    return app
+
+
+@pytest.fixture
+def mock_app():
+    """Create a mock FastFlixApp with the minimum config needed by AdvancedPanel."""
+    app = mock.MagicMock()
+    app.fastflix.config.theme = "onyx"
+    app.fastflix.config.suppress_video_speed_warning = True
+    app.fastflix.config.suppress_reverse_video_warning = True
+    app.fastflix.current_video = None
+    return app
+
+
+@pytest.fixture
+def mock_parent(qapp):
+    """Create a real QWidget parent with a mocked .main attribute."""
+    parent = QtWidgets.QWidget()
+    parent.main = mock.MagicMock()
+    parent.main.page_update = mock.MagicMock()
+    parent.main.remove_hdr = False
+    return parent
+
+
+@pytest.fixture
+def advanced_panel(mock_parent, mock_app):
+    """Create a real AdvancedPanel instance with mocked dependencies."""
+    from fastflix.widgets.panels.advanced_panel import AdvancedPanel
+
+    panel = AdvancedPanel(mock_parent, mock_app)
+    return panel
+
+
+# --- Structure tests ---
+
+
+def test_panel_has_scroll_area(advanced_panel):
+    """The panel must contain a QScrollArea as its main child."""
+    scroll_areas = advanced_panel.findChildren(QtWidgets.QScrollArea)
+    assert len(scroll_areas) == 1, "Panel should have exactly one QScrollArea"
+
+
+def test_panel_has_six_groups(advanced_panel):
+    """The panel must contain exactly 6 QGroupBox sections."""
+    groups = advanced_panel.findChildren(QtWidgets.QGroupBox)
+    assert len(groups) == 6, f"Expected 6 QGroupBox, found {len(groups)}"
+    titles = sorted(g.title() for g in groups)
+    assert "Color" in titles
+    assert "Color & Appearance" in titles
+    assert "Frame Rate" in titles
+    assert "Output" in titles
+    assert "Video Details" in titles
+    assert "Video Processing" in titles
+
+
+def test_all_key_widgets_exist(advanced_panel):
+    """All key widget attributes must be present."""
+    widgets = [
+        "incoming_fps_widget",
+        "outgoing_fps_widget",
+        "incoming_same_as_source",
+        "outgoing_same_as_source",
+        "vsync_widget",
+        "video_speed_widget",
+        "reverse_video_widget",
+        "tone_map_widget",
+        "brightness_widget",
+        "contrast_widget",
+        "saturation_widget",
+        "gamma_widget",
+        "hue_widget",
+        "denoise_type_widget",
+        "denoise_strength_widget",
+        "deblock_widget",
+        "deblock_size_widget",
+        "color_primaries_widget",
+        "color_transfer_widget",
+        "color_space_widget",
+        "maxrate_widget",
+        "bufsize_widget",
+        "video_title",
+        "video_track_title",
+        "sharpen_widget",
+        "gop_length_widget",
+        "faststart_widget",
+        "vibrance_widget",
+        "color_temperature_widget",
+        "curves_preset_widget",
+        "colorbalance_widget",
+        "unsharp_widget",
+        "deflicker_widget",
+        "pad_aspect_widget",
+        "pad_color_widget",
+        "lut3d_path_widget",
+        "lut3d_browse_button",
+        "lut3d_clear_button",
+    ]
+    for name in widgets:
+        assert hasattr(advanced_panel, name), f"Missing widget: {name}"
+        assert getattr(advanced_panel, name) is not None, f"Widget is None: {name}"
+
+
+# --- Grid column stretch tests ---
+
+
+def test_groups_have_column_stretch(advanced_panel):
+    """Each group's grid layout must have column stretch set on all columns."""
+    groups = advanced_panel.findChildren(QtWidgets.QGroupBox)
+    for group in groups:
+        gl = group.layout()
+        assert isinstance(gl, QtWidgets.QGridLayout), f"{group.title()} should use QGridLayout"
+        col_count = gl.columnCount()
+        for col in range(col_count):
+            stretch = gl.columnStretch(col)
+            assert stretch > 0, f"{group.title()} column {col} has no stretch (stretch={stretch})"
+
+
+# --- Scroll behavior tests ---
+
+
+REALISTIC_PANEL_WIDTH = 1500
+REALISTIC_PANEL_HEIGHT = 400  # typical tab area height in FastFlix
+
+
+def test_container_has_minimum_height(advanced_panel):
+    """The scroll area's container widget must have a minimum height > the typical viewport."""
+    scroll = advanced_panel.findChild(QtWidgets.QScrollArea)
+    container = scroll.widget()
+    assert container.minimumHeight() >= 500, (
+        f"Container minimumHeight ({container.minimumHeight()}) must be >= 500 "
+        f"to prevent compression at typical viewport size ({REALISTIC_PANEL_HEIGHT}px)"
+    )
+
+
+def test_scroll_area_scrolls_at_small_size(advanced_panel):
+    """When the panel is small, the vertical scrollbar must be available."""
+    advanced_panel.resize(REALISTIC_PANEL_WIDTH, REALISTIC_PANEL_HEIGHT)
+    advanced_panel.show()
+    # Force layout recalculation
+    QtWidgets.QApplication.processEvents()
+
+    scroll = advanced_panel.findChild(QtWidgets.QScrollArea)
+    vbar = scroll.verticalScrollBar()
+
+    # The scrollbar should have a range > 0 (meaning content overflows viewport)
+    assert vbar.maximum() > 0, (
+        f"Scroll area should be scrollable at {REALISTIC_PANEL_WIDTH}x{REALISTIC_PANEL_HEIGHT}, "
+        f"but scrollbar max is {vbar.maximum()}"
+    )
+    advanced_panel.hide()
+
+
+def test_groups_not_compressed_at_small_size(advanced_panel):
+    """At small viewport size, groups must maintain usable height (not crushed)."""
+    advanced_panel.resize(REALISTIC_PANEL_WIDTH, REALISTIC_PANEL_HEIGHT)
+    advanced_panel.show()
+    QtWidgets.QApplication.processEvents()
+
+    groups = advanced_panel.findChildren(QtWidgets.QGroupBox)
+    min_usable_heights = {
+        "Video Details": 50,
+        "Frame Rate": 70,
+        "Video Processing": 160,
+        "Color": 50,
+        "Output": 50,
+    }
+    for group in groups:
+        expected_min = min_usable_heights.get(group.title(), 50)
+        actual_height = group.height()
+        assert actual_height >= expected_min, (
+            f"{group.title()} height is {actual_height}px, expected at least {expected_min}px for usability"
+        )
+    advanced_panel.hide()
+
+
+def test_page_update_does_not_crash(mock_parent, mock_app, qapp):
+    """page_update must not crash during or after init (widgets may not exist yet during init)."""
+    from fastflix.widgets.panels.advanced_panel import AdvancedPanel
+
+    # This would raise AttributeError if page_update references widgets before they're created
+    panel = AdvancedPanel(mock_parent, mock_app)
+    panel.page_update()
+    panel.page_update(build_thumbnail=True)
+
+
+def test_faststart_visible_for_mp4(advanced_panel):
+    """Fast Start toggle must not be hidden when output type is .mp4."""
+    combo = QtWidgets.QComboBox()
+    combo.addItems([".mp4", ".mkv"])
+    combo.setCurrentText(".mp4")
+    advanced_panel.main.widgets.output_type_combo = combo
+
+    advanced_panel.update_faststart_visibility()
+    assert not advanced_panel.faststart_widget.isHidden(), "Fast Start should not be hidden for .mp4"
+
+
+def test_faststart_visible_for_mov(advanced_panel):
+    """Fast Start toggle must not be hidden when output type is .mov."""
+    combo = QtWidgets.QComboBox()
+    combo.addItems([".mov", ".mkv"])
+    combo.setCurrentText(".mov")
+    advanced_panel.main.widgets.output_type_combo = combo
+
+    advanced_panel.update_faststart_visibility()
+    assert not advanced_panel.faststart_widget.isHidden(), "Fast Start should not be hidden for .mov"
+
+
+def test_faststart_hidden_for_mkv(advanced_panel):
+    """Fast Start toggle must be hidden when output type is .mkv."""
+    combo = QtWidgets.QComboBox()
+    combo.addItems([".mkv", ".mp4"])
+    combo.setCurrentText(".mkv")
+    advanced_panel.main.widgets.output_type_combo = combo
+
+    advanced_panel.update_faststart_visibility()
+    assert advanced_panel.faststart_widget.isHidden(), "Fast Start should be hidden for .mkv"
+
+
+def test_faststart_hidden_for_webm(advanced_panel):
+    """Fast Start toggle must be hidden when output type is .webm."""
+    combo = QtWidgets.QComboBox()
+    combo.addItems([".webm"])
+    combo.setCurrentText(".webm")
+    advanced_panel.main.widgets.output_type_combo = combo
+
+    advanced_panel.update_faststart_visibility()
+    assert advanced_panel.faststart_widget.isHidden(), "Fast Start should be hidden for .webm"
diff --git a/tests/test_application.py b/tests/test_application.py
index de25bcec..ed4c2244 100644
--- a/tests/test_application.py
+++ b/tests/test_application.py
@@ -49,3 +49,16 @@ def test_init_encoders():
 # Write a pytest for the Pyqt6 application defined in the fastflix/application.py file.
 # def test_application():
 #     app = create_app(enable_scaling=False)
+
+
+def test_refresh_ffmpeg_info_passes_config(monkeypatch):
+    from fastflix import application
+
+    calls = []
+    monkeypatch.setattr(application, "ffmpeg_configuration", lambda app, config, **_: calls.append(("conf", config)))
+    monkeypatch.setattr(application, "ffmpeg_audio_encoders", lambda app, config: calls.append(("audio", config)))
+    monkeypatch.setattr(application, "ffmpeg_video_encoders", lambda app, config: calls.append(("video", config)))
+    monkeypatch.setattr(application, "init_encoders", lambda app, **_: calls.append(("init", None)))
+    application._refresh_ffmpeg_info(fake_app)
+    assert [c[0] for c in calls] == ["conf", "audio", "video", "init"]
+    assert calls[0][1] is fake_app.fastflix.config
diff --git a/tests/test_audio.py b/tests/test_audio.py
index b020cb97..899ab3ab 100644
--- a/tests/test_audio.py
+++ b/tests/test_audio.py
@@ -41,254 +41,191 @@ def test_audio_filters():
 
     result = apply_audio_filters(audio_filters=test_filters, original_tracks=test_audio_tracks)
 
-    expected_result = [
-        (
-            Box(
-                {
-                    "avg_frame_rate": "0/0",
-                    "bits_per_raw_sample": "24",
-                    "bits_per_sample": 0,
-                    "channel_layout": "5.1(side)",
-                    "channels": 6,
-                    "codec_long_name": "TrueHD",
-                    "codec_name": "truehd",
-                    "codec_tag": "0x0000",
-                    "codec_tag_string": "[0][0][0][0]",
-                    "codec_type": "audio",
-                    "disposition": {
-                        "attached_pic": 0,
-                        "captions": 0,
-                        "clean_effects": 0,
-                        "comment": 0,
-                        "default": 0,
-                        "dependent": 0,
-                        "descriptions": 0,
-                        "dub": 0,
-                        "forced": 0,
-                        "hearing_impaired": 0,
-                        "karaoke": 0,
-                        "lyrics": 0,
-                        "metadata": 0,
-                        "original": 0,
-                        "still_image": 0,
-                        "timed_thumbnails": 0,
-                        "visual_impaired": 0,
-                    },
-                    "index": 1,
-                    "r_frame_rate": "0/0",
-                    "sample_fmt": "s32",
-                    "sample_rate": "48000",
-                    "start_pts": 0,
-                    "start_time": "0.000000",
-                    "tags": {
-                        "BPS-eng": "1921846",
-                        "DURATION-eng": "00:23:38.083333333",
-                        "NUMBER_OF_BYTES-eng": "340667312",
-                        "NUMBER_OF_FRAMES-eng": "1701700",
-                        "SOURCE_ID-eng": "001100",
-                        "_STATISTICS_TAGS-eng": "BPS DURATION NUMBER_OF_FRAMES NUMBER_OF_BYTES SOURCE_ID",
-                        "_STATISTICS_WRITING_DATE_UTC-eng": "2021-04-21 20:00:45",
-                        "language": "eng",
-                        "title": "Surround 5.1",
-                    },
-                    "time_base": "1/1000",
-                }
-            ),
-            AudioMatch(
-                match_type=MatchType.FIRST,
-                match_item=MatchItem.TITLE,
-                match_input="Surround 5",
-                conversion=None,
-                bitrate="32k",
-                downmix="No Downmix",
-            ),
+    # Results are sorted by index; verify track indices and their matched filters
+    result_indices = [track.index for track, _ in result]
+
+    # FIRST title "Surround 5" -> index 1 (truehd)
+    # LAST ALL -> index 6 (last track, dts)
+    # ALL language eng -> indices 1, 2, 5, 6
+    # Sorted by index (stable sort preserves insertion order for same index)
+    assert result_indices == [1, 1, 2, 5, 6, 6]
+
+    # First result: truehd track matched by TITLE
+    assert result[0][0].codec_name == "truehd"
+    assert result[0][1].match_item == MatchItem.TITLE
+
+    # Second result: truehd track matched by LANGUAGE eng
+    assert result[1][0].codec_name == "truehd"
+    assert result[1][1].match_item == MatchItem.LANGUAGE
+
+    # Third result: ac3 track matched by LANGUAGE eng
+    assert result[2][0].codec_name == "ac3"
+    assert result[2][0].index == 2
+    assert result[2][1].match_item == MatchItem.LANGUAGE
+
+    # Fourth result: dts DTS-HD MA track matched by LANGUAGE eng
+    assert result[3][0].codec_name == "dts"
+    assert result[3][0].index == 5
+    assert result[3][1].match_item == MatchItem.LANGUAGE
+
+    # Fifth result: dts track matched by LAST ALL (inserted before LANGUAGE for same index)
+    assert result[4][0].index == 6
+    assert result[4][1].match_item == MatchItem.ALL
+
+    # Sixth result: dts track matched by LANGUAGE eng
+    assert result[5][0].codec_name == "dts"
+    assert result[5][0].index == 6
+    assert result[5][1].match_item == MatchItem.LANGUAGE
+
+
+def test_audio_filters_codec_match():
+    """Test matching audio tracks by codec name."""
+    filters = [
+        AudioMatch(
+            match_type=MatchType.ALL,
+            match_item=MatchItem.CODEC,
+            match_input="truehd",
         ),
-        (
-            Box(
-                {
-                    "avg_frame_rate": "0/0",
-                    "bits_per_raw_sample": "24",
-                    "bits_per_sample": 0,
-                    "channel_layout": "5.1(side)",
-                    "channels": 6,
-                    "codec_long_name": "TrueHD",
-                    "codec_name": "truehd",
-                    "codec_tag": "0x0000",
-                    "codec_tag_string": "[0][0][0][0]",
-                    "codec_type": "audio",
-                    "disposition": {
-                        "attached_pic": 0,
-                        "captions": 0,
-                        "clean_effects": 0,
-                        "comment": 0,
-                        "default": 0,
-                        "dependent": 0,
-                        "descriptions": 0,
-                        "dub": 0,
-                        "forced": 0,
-                        "hearing_impaired": 0,
-                        "karaoke": 0,
-                        "lyrics": 0,
-                        "metadata": 0,
-                        "original": 0,
-                        "still_image": 0,
-                        "timed_thumbnails": 0,
-                        "visual_impaired": 0,
-                    },
-                    "index": 1,
-                    "r_frame_rate": "0/0",
-                    "sample_fmt": "s32",
-                    "sample_rate": "48000",
-                    "start_pts": 0,
-                    "start_time": "0.000000",
-                    "tags": {
-                        "BPS-eng": "1921846",
-                        "DURATION-eng": "00:23:38.083333333",
-                        "NUMBER_OF_BYTES-eng": "340667312",
-                        "NUMBER_OF_FRAMES-eng": "1701700",
-                        "SOURCE_ID-eng": "001100",
-                        "_STATISTICS_TAGS-eng": "BPS DURATION NUMBER_OF_FRAMES NUMBER_OF_BYTES SOURCE_ID",
-                        "_STATISTICS_WRITING_DATE_UTC-eng": "2021-04-21 20:00:45",
-                        "language": "eng",
-                        "title": "Surround 5.1",
-                    },
-                    "time_base": "1/1000",
-                }
-            ),
-            AudioMatch(
-                match_type=MatchType.ALL,
-                match_item=MatchItem.LANGUAGE,
-                match_input="eng",
-                conversion=None,
-                bitrate="32k",
-                downmix="No Downmix",
-            ),
+    ]
+    result = apply_audio_filters(audio_filters=filters, original_tracks=test_audio_tracks)
+    assert len(result) == 2
+    assert result[0][0].codec_name == "truehd"
+    assert result[0][0].index == 1
+    assert result[1][0].codec_name == "truehd"
+    assert result[1][0].index == 3
+
+
+def test_audio_filters_codec_match_first():
+    """Test matching first audio track by codec name."""
+    filters = [
+        AudioMatch(
+            match_type=MatchType.FIRST,
+            match_item=MatchItem.CODEC,
+            match_input="ac3",
         ),
-        (
-            Box(
-                {
-                    "avg_frame_rate": "0/0",
-                    "bit_rate": "448000",
-                    "bits_per_sample": 0,
-                    "channel_layout": "5.1(side)",
-                    "channels": 6,
-                    "codec_long_name": "ATSC A/52A (AC-3)",
-                    "codec_name": "ac3",
-                    "codec_tag": "0x0000",
-                    "codec_tag_string": "[0][0][0][0]",
-                    "codec_type": "audio",
-                    "disposition": {
-                        "attached_pic": 0,
-                        "captions": 0,
-                        "clean_effects": 0,
-                        "comment": 0,
-                        "default": 0,
-                        "dependent": 0,
-                        "descriptions": 0,
-                        "dub": 0,
-                        "forced": 0,
-                        "hearing_impaired": 0,
-                        "karaoke": 0,
-                        "lyrics": 0,
-                        "metadata": 0,
-                        "original": 0,
-                        "still_image": 0,
-                        "timed_thumbnails": 0,
-                        "visual_impaired": 0,
-                    },
-                    "index": 2,
-                    "r_frame_rate": "0/0",
-                    "sample_fmt": "fltp",
-                    "sample_rate": "48000",
-                    "start_pts": 0,
-                    "start_time": "0.000000",
-                    "tags": {
-                        "BPS-eng": "448000",
-                        "DURATION-eng": "00:23:38.112000000",
-                        "NUMBER_OF_BYTES-eng": "79414272",
-                        "NUMBER_OF_FRAMES-eng": "44316",
-                        "SOURCE_ID-eng": "001100",
-                        "_STATISTICS_TAGS-eng": "BPS DURATION NUMBER_OF_FRAMES NUMBER_OF_BYTES SOURCE_ID",
-                        "_STATISTICS_WRITING_DATE_UTC-eng": "2021-04-21 20:00:45",
-                        "language": "eng",
-                        "title": "Surround 5.1",
-                    },
-                    "time_base": "1/1000",
-                }
-            ),
-            AudioMatch(
-                match_type=MatchType.ALL,
-                match_item=MatchItem.LANGUAGE,
-                match_input="eng",
-                conversion=None,
-                bitrate="32k",
-                downmix="No Downmix",
-            ),
+    ]
+    result = apply_audio_filters(audio_filters=filters, original_tracks=test_audio_tracks)
+    assert len(result) == 1
+    assert result[0][0].codec_name == "ac3"
+    assert result[0][0].index == 2
+
+
+def test_audio_filters_codec_match_last():
+    """Test matching last audio track by codec name."""
+    filters = [
+        AudioMatch(
+            match_type=MatchType.LAST,
+            match_item=MatchItem.CODEC,
+            match_input="ac3",
         ),
-        (
-            Box(
-                {
-                    "avg_frame_rate": "0/0",
-                    "bit_rate": "192000",
-                    "bits_per_sample": 0,
-                    "channel_layout": "stereo",
-                    "channels": 2,
-                    "codec_long_name": "ATSC A/52A (AC-3)",
-                    "codec_name": "ac3",
-                    "codec_tag": "0x0000",
-                    "codec_tag_string": "[0][0][0][0]",
-                    "codec_type": "audio",
-                    "disposition": {
-                        "attached_pic": 0,
-                        "captions": 0,
-                        "clean_effects": 0,
-                        "comment": 0,
-                        "default": 0,
-                        "dependent": 0,
-                        "descriptions": 0,
-                        "dub": 0,
-                        "forced": 0,
-                        "hearing_impaired": 0,
-                        "karaoke": 0,
-                        "lyrics": 0,
-                        "metadata": 0,
-                        "original": 0,
-                        "still_image": 0,
-                        "timed_thumbnails": 0,
-                        "visual_impaired": 0,
-                    },
-                    "index": 4,
-                    "r_frame_rate": "0/0",
-                    "sample_fmt": "fltp",
-                    "sample_rate": "48000",
-                    "start_pts": 0,
-                    "start_time": "0.000000",
-                    "tags": {
-                        "BPS-eng": "192000",
-                        "DURATION-eng": "00:23:38.112000000",
-                        "NUMBER_OF_BYTES-eng": "34034688",
-                        "NUMBER_OF_FRAMES-eng": "44316",
-                        "SOURCE_ID-eng": "001101",
-                        "_STATISTICS_TAGS-eng": "BPS DURATION NUMBER_OF_FRAMES NUMBER_OF_BYTES SOURCE_ID",
-                        "_STATISTICS_WRITING_DATE_UTC-eng": "2021-04-21 20:00:45",
-                        "language": "jpn",
-                        "title": "Stereo",
-                    },
-                    "time_base": "1/1000",
-                }
-            ),
-            AudioMatch(
-                match_type=MatchType.LAST,
-                match_item=MatchItem.ALL,
-                match_input="*",
-                conversion=None,
-                bitrate="32k",
-                downmix="No Downmix",
-            ),
+    ]
+    result = apply_audio_filters(audio_filters=filters, original_tracks=test_audio_tracks)
+    assert len(result) == 1
+    assert result[0][0].codec_name == "ac3"
+    assert result[0][0].index == 4
+
+
+def test_audio_filters_codec_match_all_dts():
+    """Test matching all DTS tracks by codec name."""
+    filters = [
+        AudioMatch(
+            match_type=MatchType.ALL,
+            match_item=MatchItem.CODEC,
+            match_input="dts",
+        ),
+    ]
+    result = apply_audio_filters(audio_filters=filters, original_tracks=test_audio_tracks)
+    assert len(result) == 2
+    assert result[0][0].codec_name == "dts"
+    assert result[1][0].codec_name == "dts"
+
+
+def test_audio_filters_codec_match_case_insensitive():
+    """Test that codec matching is case insensitive."""
+    filters = [
+        AudioMatch(
+            match_type=MatchType.ALL,
+            match_item=MatchItem.CODEC,
+            match_input="TrueHD",
+        ),
+    ]
+    result = apply_audio_filters(audio_filters=filters, original_tracks=test_audio_tracks)
+    assert len(result) == 2
+    assert all(track.codec_name == "truehd" for track, _ in result)
+
+
+def test_audio_filters_codec_profile_match():
+    """Test matching audio tracks by codec and profile (e.g. DTS-HD MA vs DTS)."""
+    filters = [
+        AudioMatch(
+            match_type=MatchType.ALL,
+            match_item=MatchItem.CODEC_PROFILE,
+            match_input="dts:DTS-HD MA",
+        ),
+    ]
+    result = apply_audio_filters(audio_filters=filters, original_tracks=test_audio_tracks)
+    assert len(result) == 1
+    assert result[0][0].codec_name == "dts"
+    assert result[0][0].profile == "DTS-HD MA"
+    assert result[0][0].index == 5
+
+
+def test_audio_filters_codec_profile_match_regular_dts():
+    """Test matching regular DTS (not DTS-HD MA) by codec and profile."""
+    filters = [
+        AudioMatch(
+            match_type=MatchType.ALL,
+            match_item=MatchItem.CODEC_PROFILE,
+            match_input="dts:DTS",
+        ),
+    ]
+    result = apply_audio_filters(audio_filters=filters, original_tracks=test_audio_tracks)
+    assert len(result) == 1
+    assert result[0][0].codec_name == "dts"
+    assert result[0][0].profile == "DTS"
+    assert result[0][0].index == 6
+
+
+def test_audio_filters_codec_profile_case_insensitive():
+    """Test that codec:profile matching is case insensitive."""
+    filters = [
+        AudioMatch(
+            match_type=MatchType.ALL,
+            match_item=MatchItem.CODEC_PROFILE,
+            match_input="DTS:dts-hd ma",
+        ),
+    ]
+    result = apply_audio_filters(audio_filters=filters, original_tracks=test_audio_tracks)
+    assert len(result) == 1
+    assert result[0][0].profile == "DTS-HD MA"
+
+
+def test_audio_filters_codec_profile_no_match():
+    """Test codec:profile matching returns empty when no match."""
+    filters = [
+        AudioMatch(
+            match_type=MatchType.ALL,
+            match_item=MatchItem.CODEC_PROFILE,
+            match_input="dts:DTS-HD HRA",
         ),
     ]
+    result = apply_audio_filters(audio_filters=filters, original_tracks=test_audio_tracks)
+    assert len(result) == 0
+
 
-    assert result == expected_result, result
+def test_audio_filters_codec_profile_truehd_atmos():
+    """Test matching TrueHD+Atmos profile."""
+    filters = [
+        AudioMatch(
+            match_type=MatchType.ALL,
+            match_item=MatchItem.CODEC_PROFILE,
+            match_input="truehd:TrueHD+Atmos",
+        ),
+    ]
+    result = apply_audio_filters(audio_filters=filters, original_tracks=test_audio_tracks)
+    assert len(result) == 1
+    assert result[0][0].codec_name == "truehd"
+    assert result[0][0].profile == "TrueHD+Atmos"
 
 
 class TestAudioMatchValidator:
diff --git a/tests/test_auto_crop_parsing.py b/tests/test_auto_crop_parsing.py
new file mode 100644
index 00000000..10f1d58e
--- /dev/null
+++ b/tests/test_auto_crop_parsing.py
@@ -0,0 +1,150 @@
+# -*- coding: utf-8 -*-
+"""Tests for auto-crop detection parsing logic."""
+
+from fastflix.flix import parse_cropdetect_output
+
+
+def make_cropdetect_line(w, h, x, y):
+    """Generate a realistic FFmpeg cropdetect output line."""
+    return f"[Parsed_cropdetect_0 @ 0x55b8c0] x1:{x} x2:{x + w - 1} y1:{y} y2:{y + h - 1} w:{w} h:{h} x:{x} y:{y} pts:1001 t:1.001000 limit:0.094118 crop={w}:{h}:{x}:{y}"
+
+
+def make_stderr(*detections):
+    """Build a full stderr string from multiple (w, h, x, y) tuples."""
+    lines = ["Input #0, matroska,webm, from 'test.mkv':"]
+    for d in detections:
+        lines.append(make_cropdetect_line(*d))
+    return "\n".join(lines)
+
+
+class TestParseCropdetectOutput:
+    """Test parse_cropdetect_output with various aspect ratios and scenarios."""
+
+    def test_16_9_letterbox_235_1(self):
+        # 2.35:1 content in 1920x1080: top/bottom bars ~130px each
+        # Content is ~1920x820
+        stderr = make_stderr(
+            (1920, 820, 0, 130),
+            (1920, 818, 0, 131),
+            (1920, 820, 0, 130),
+        )
+        result = parse_cropdetect_output(stderr, 1920, 1080)
+        # Most conservative = largest area = 1920*820
+        assert result == [0, 130, 0, 130]  # [right, bottom, left, top]
+
+    def test_4_3_pillarbox_in_16_9(self):
+        # 4:3 content (1440x1080) in 1920x1080 frame with pillarboxing
+        stderr = make_stderr(
+            (1440, 1080, 240, 0),
+            (1438, 1080, 241, 0),
+            (1440, 1080, 240, 0),
+        )
+        result = parse_cropdetect_output(stderr, 1920, 1080)
+        # Most conservative = 1440*1080 (largest area)
+        assert result == [240, 0, 240, 0]
+
+    def test_ultrawide_276_1(self):
+        # 2.76:1 content (1920x696) in 1920x1080 frame
+        stderr = make_stderr(
+            (1920, 696, 0, 192),
+            (1920, 694, 0, 193),
+            (1920, 696, 0, 192),
+        )
+        result = parse_cropdetect_output(stderr, 1920, 1080)
+        assert result == [0, 192, 0, 192]
+
+    def test_no_crop_needed(self):
+        # Content fills entire frame
+        stderr = make_stderr(
+            (1920, 1080, 0, 0),
+            (1920, 1080, 0, 0),
+        )
+        result = parse_cropdetect_output(stderr, 1920, 1080)
+        assert result == [0, 0, 0, 0]
+
+    def test_zero_offset_preserved(self):
+        # x=0 and y=0 are valid offsets that should NOT be overwritten
+        stderr = make_stderr(
+            (1440, 1080, 240, 0),  # x=240, y=0 (y=0 is correct)
+            (1438, 1078, 241, 1),  # Noisy: y=1 is wrong
+            (1440, 1080, 240, 0),
+        )
+        result = parse_cropdetect_output(stderr, 1920, 1080)
+        # Should pick 1440*1080 (largest area), NOT mix y from frame 2
+        assert result == [240, 0, 240, 0]
+
+    def test_noisy_detections_picks_conservative(self):
+        # Varying detections — should pick largest content area
+        stderr = make_stderr(
+            (1900, 1060, 10, 10),  # Slightly aggressive
+            (1910, 1070, 5, 5),  # Less aggressive
+            (1920, 1080, 0, 0),  # No crop (most conservative)
+        )
+        result = parse_cropdetect_output(stderr, 1920, 1080)
+        assert result == [0, 0, 0, 0]  # Picks the full frame
+
+    def test_empty_stderr(self):
+        result = parse_cropdetect_output("", 1920, 1080)
+        assert result is None
+
+    def test_no_cropdetect_lines(self):
+        stderr = "Some other ffmpeg output\nNo cropdetect lines here"
+        result = parse_cropdetect_output(stderr, 1920, 1080)
+        assert result is None
+
+    def test_malformed_cropdetect_line(self):
+        # One bad line mixed with good ones
+        stderr = "[Parsed_cropdetect_0 @ 0x55b8c0] malformed=garbage\n" + make_cropdetect_line(1920, 800, 0, 140)
+        result = parse_cropdetect_output(stderr, 1920, 1080)
+        assert result == [0, 140, 0, 140]
+
+    def test_single_detection(self):
+        stderr = make_stderr((1440, 1080, 240, 0))
+        result = parse_cropdetect_output(stderr, 1920, 1080)
+        assert result == [240, 0, 240, 0]
+
+    def test_negative_margin_returns_none(self):
+        # Crop detection reports content larger than frame (shouldn't happen, but guard)
+        stderr = make_stderr((2000, 1080, 0, 0))
+        result = parse_cropdetect_output(stderr, 1920, 1080)
+        assert result is None  # right = 1920 - 2000 - 0 = -80
+
+    def test_4k_source(self):
+        # 4K with letterbox
+        stderr = make_stderr(
+            (3840, 1600, 0, 280),
+            (3840, 1602, 0, 279),
+        )
+        result = parse_cropdetect_output(stderr, 3840, 2160)
+        # Most conservative: 3840*1602 > 3840*1600
+        assert result == [0, 279, 0, 279]
+
+
+# Real FFmpeg 8 stderr: a fully black 320x240 frame (cropdetect reports negative sizes), followed by a
+# 320x160 picture letterboxed with 40px bars while the detected width ramps up from 302.
+BLACK_FRAME_STDERR = """\
+[Parsed_cropdetect_1 @ 00000297c31cf4c0] x1:319 x2:0 y1:239 y2:0 w:-318 h:-238 x:320 y:240 pts:80000 t:0.080000 limit:0.094118 crop=-318:-238:320:240
+[Parsed_cropdetect_1 @ 00000297c31cf4c0] x1:319 x2:0 y1:239 y2:0 w:-318 h:-238 x:320 y:240 pts:120000 t:0.120000 limit:0.094118 crop=-318:-238:320:240
+[Parsed_cropdetect_1 @ 00000297c31cf4c0] x1:18 x2:319 y1:40 y2:199 w:302 h:160 x:18 y:40 pts:200000 t:0.200000 limit:0.094118 crop=302:160:18:40
+[Parsed_cropdetect_1 @ 00000297c31cf4c0] x1:6 x2:319 y1:40 y2:199 w:314 h:160 x:6 y:40 pts:400000 t:0.400000 limit:0.094118 crop=314:160:6:40
+[Parsed_cropdetect_1 @ 00000297c31cf4c0] x1:0 x2:319 y1:40 y2:199 w:320 h:160 x:0 y:40 pts:520000 t:0.520000 limit:0.094118 crop=320:160:0:40
+"""
+
+
+class TestCropdetectBlackFramesAndUnion:
+    def test_negative_detections_are_ignored(self):
+        assert parse_cropdetect_output(BLACK_FRAME_STDERR, 320, 240) == [0, 40, 0, 40]
+
+    def test_only_black_frames_returns_none(self):
+        stderr = "\n".join(line for line in BLACK_FRAME_STDERR.splitlines() if "w:-318" in line)
+        assert parse_cropdetect_output(stderr, 320, 240) is None
+
+    def test_union_of_mixed_letterbox_and_pillarbox(self):
+        # Sample A has only top/bottom bars, sample B only left/right bars: nothing may be cropped
+        stderr = make_stderr((1920, 800, 0, 140), (1440, 1080, 240, 0))
+        assert parse_cropdetect_output(stderr, 1920, 1080) == [0, 0, 0, 0]
+
+    def test_union_tracks_each_edge_independently(self):
+        stderr = make_stderr((1800, 900, 60, 100), (1780, 920, 100, 80))
+        # left 60, top 80, content right = max(1860, 1880) = 1880, bottom = max(1000, 1000) = 1000
+        assert parse_cropdetect_output(stderr, 1920, 1080) == [40, 80, 60, 80]
diff --git a/tests/test_clean_env.py b/tests/test_clean_env.py
new file mode 100644
index 00000000..bd8734ff
--- /dev/null
+++ b/tests/test_clean_env.py
@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+import sys
+
+from fastflix.resources import clean_env
+
+
+def test_clean_env_unchanged_when_not_frozen(monkeypatch):
+    monkeypatch.delattr(sys, "frozen", raising=False)
+    monkeypatch.setenv("LD_LIBRARY_PATH", "/opt/custom/lib")
+    assert clean_env()["LD_LIBRARY_PATH"] == "/opt/custom/lib"
+
+
+def test_clean_env_restores_original_in_pyinstaller(monkeypatch):
+    monkeypatch.setattr(sys, "frozen", True, raising=False)
+    monkeypatch.setattr(sys, "_MEIPASS", "/tmp/_MEI123", raising=False)
+    monkeypatch.setenv("LD_LIBRARY_PATH", "/tmp/_MEI123")
+    monkeypatch.setenv("LD_LIBRARY_PATH_ORIG", "/opt/custom/lib")
+    env = clean_env()
+    assert env["LD_LIBRARY_PATH"] == "/opt/custom/lib"
+    assert "LD_LIBRARY_PATH_ORIG" not in env
+
+
+def test_clean_env_removes_bundled_path_in_pyinstaller(monkeypatch):
+    monkeypatch.setattr(sys, "frozen", True, raising=False)
+    monkeypatch.setattr(sys, "_MEIPASS", "/tmp/_MEI123", raising=False)
+    monkeypatch.setenv("LD_LIBRARY_PATH", "/tmp/_MEI123")
+    monkeypatch.delenv("LD_LIBRARY_PATH_ORIG", raising=False)
+    assert "LD_LIBRARY_PATH" not in clean_env()
diff --git a/tests/test_command_runner.py b/tests/test_command_runner.py
new file mode 100644
index 00000000..a2467842
--- /dev/null
+++ b/tests/test_command_runner.py
@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+import queue
+import sys
+import time
+
+import psutil
+import pytest
+
+from fastflix.command_runner import BackgroundRunner
+
+
+class FakeProc:
+    def __init__(self, returncode=None, children=(), pid=1):
+        self.returncode = returncode
+        self._children = list(children)
+        self.pid = pid
+        self.calls = []
+
+    def poll(self):
+        return self.returncode
+
+    def children(self, recursive=False):
+        self.calls.append(("children", recursive))
+        return list(self._children)
+
+    def terminate(self):
+        self.calls.append("terminate")
+
+    def kill(self):
+        self.calls.append("kill")
+        self.returncode = -9
+
+    def suspend(self):
+        self.calls.append("suspend")
+
+    def resume(self):
+        self.calls.append("resume")
+
+
+def make_runner(tmp_path, returncode):
+    runner = BackgroundRunner(log_queue=queue.Queue())
+    runner.process = FakeProc(returncode=returncode)
+    runner.output_file = tmp_path / "out.log"
+    runner.error_output_file = tmp_path / "err.log"
+    runner.output_file.write_text("")
+    runner.error_output_file.write_text("")
+    return runner
+
+
+@pytest.mark.parametrize("code,expected", [(0, False), (1, True), (-9, True), (-11, True)])
+def test_exit_code_marks_error(tmp_path, code, expected):
+    runner = make_runner(tmp_path, code)
+    runner.read_output()
+    assert runner.error_detected is expected
+
+
+def test_user_kill_is_not_an_error(tmp_path):
+    runner = make_runner(tmp_path, -9)
+    runner.killed = True
+    runner.read_output()
+    assert runner.error_detected is False
+
+
+def test_kill_acts_on_whole_tree():
+    grandchild = FakeProc(pid=3)
+    child = FakeProc(pid=2)
+    parent = FakeProc(children=[child, grandchild])
+    runner = BackgroundRunner(log_queue=queue.Queue())
+    runner.process = parent
+    runner.kill(log=False)
+    assert ("children", True) in parent.calls
+    assert "kill" in child.calls and "kill" in grandchild.calls and "kill" in parent.calls
+    assert runner.killed is True
+
+
+def test_pause_resume_act_on_whole_tree():
+    child = FakeProc(pid=2)
+    parent = FakeProc(children=[child])
+    runner = BackgroundRunner(log_queue=queue.Queue())
+    runner.process = parent
+    runner.pause()
+    assert "suspend" in child.calls and "suspend" in parent.calls
+    runner.resume()
+    assert "resume" in child.calls and "resume" in parent.calls
+
+
+def test_reader_survives_clean_race(tmp_path):
+    runner = BackgroundRunner(log_queue=queue.Queue())
+    runner.start_exec([sys.executable, "-c", "import time; time.sleep(0.3)"], work_dir=str(tmp_path))
+    runner.clean()  # sets process to None while reader may still be running
+    assert runner.process is None
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="posix shell pipe")
+def test_real_shell_tree_killed(tmp_path):
+    runner = BackgroundRunner(log_queue=queue.Queue())
+    runner.start_exec("sleep 30 | sleep 30", work_dir=str(tmp_path), shell=True)
+    time.sleep(0.5)
+    kids = runner.process.children(recursive=True)
+    assert kids
+    runner.kill(log=False)
+    time.sleep(0.3)
+    assert not any(k.is_running() and k.status() != psutil.STATUS_ZOMBIE for k in kids)
+
+
+def test_real_nonzero_exit_flagged(tmp_path):
+    runner = BackgroundRunner(log_queue=queue.Queue())
+    runner.start_exec([sys.executable, "-c", "import sys; sys.exit(3)"], work_dir=str(tmp_path))
+    runner.join_reader(timeout=5)
+    assert runner.error_detected is True
diff --git a/tests/test_config_robustness.py b/tests/test_config_robustness.py
new file mode 100644
index 00000000..41c08f93
--- /dev/null
+++ b/tests/test_config_robustness.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+import logging
+from pathlib import Path
+
+import pytest
+from box import Box
+
+from fastflix.exceptions import ConfigError
+from fastflix.models import config as config_module
+from fastflix.models.config import Config
+
+
+@pytest.fixture
+def cfg_env(tmp_path, monkeypatch):
+    fake_ff = tmp_path / "ffmpeg.exe"
+    fake_ff.write_text("x")
+    monkeypatch.setattr(config_module, "find_ffmpeg_file", lambda *a, **k: fake_ff)
+    path = tmp_path / "cfg" / "fastflix.yaml"
+    path.parent.mkdir()
+    monkeypatch.setenv("FF_CONFIG", str(path))
+    return path
+
+
+def _new_config():
+    c = Config()
+    return c
+
+
+def test_save_keeps_backup_of_previous_good_file(cfg_env):
+    c = _new_config()
+    c.config_path = cfg_env
+    c.theme = "first"
+    c.save()
+    assert not cfg_env.with_name(cfg_env.name + ".bak").exists()
+    c.theme = "second"
+    c.save()
+    bak = cfg_env.with_name(cfg_env.name + ".bak")
+    assert Box.from_yaml(filename=bak).theme == "first"
+    assert Box.from_yaml(filename=cfg_env).theme == "second"
+    assert [p.name for p in cfg_env.parent.iterdir() if p.name.endswith(".tmp")] == []
+
+
+def test_save_failure_leaves_original_intact(cfg_env, monkeypatch):
+    c = _new_config()
+    c.config_path = cfg_env
+    c.theme = "good"
+    c.save()
+
+    def boom(self, *a, **k):
+        raise OSError("disk full")
+
+    monkeypatch.setattr(Box, "to_yaml", boom)
+    with pytest.raises(OSError):
+        c.save()
+    assert Box.from_yaml(filename=cfg_env).theme == "good"
+    assert [p.name for p in cfg_env.parent.iterdir() if p.name.endswith(".tmp")] == []
+
+
+def test_load_truncated_main_recovers_from_bak(cfg_env, caplog):
+    c = _new_config()
+    c.config_path = cfg_env
+    c.theme = "keepme"
+    c.save()
+    c.theme = "latest"
+    c.save()
+    cfg_env.write_text("version: 6.\ntheme: [unclosed")
+    loaded = Config()
+    with caplog.at_level(logging.WARNING, logger="fastflix"):
+        loaded.load()
+    assert loaded.theme == "keepme"
+    assert list(cfg_env.parent.glob("fastflix.yaml.corrupt-*"))
+
+
+def test_load_corrupt_no_bak_moves_aside_and_uses_defaults(cfg_env):
+    cfg_env.write_text("version: 6.\ntheme: [unclosed")
+    loaded = Config()
+    loaded.load()
+    assert loaded.theme == Config().theme
+    corrupt = list(cfg_env.parent.glob("fastflix.yaml.corrupt-*"))
+    assert len(corrupt) == 1
+    assert "unclosed" in corrupt[0].read_text()
+    assert cfg_env.exists()
+
+
+def test_load_tiny_file_with_bak_uses_bak(cfg_env):
+    c = _new_config()
+    c.config_path = cfg_env
+    c.theme = "keepme"
+    c.save()
+    c.save()
+    cfg_env.write_text("abc")
+    loaded = Config()
+    loaded.load()
+    assert loaded.theme == "keepme"
+
+
+def test_bad_profile_is_skipped(cfg_env):
+    c = _new_config()
+    c.config_path = cfg_env
+    c.save()
+    data = Box.from_yaml(filename=cfg_env)
+    data.profiles = {"Broken": {"profile_version": 2, "x265": {"preset": {"nested": "bad"}}, "auto_crop": "zzz"}}
+    data.theme = "mine"
+    data.to_yaml(filename=cfg_env)
+    loaded = Config()
+    loaded.load()
+    assert "Broken" not in loaded.profiles
+    assert loaded.theme == "mine"
+
+
+def test_wrongly_typed_top_level_values_ignored(cfg_env):
+    c = _new_config()
+    c.config_path = cfg_env
+    c.save()
+    data = Box.from_yaml(filename=cfg_env)
+    data.logging_level = "abc"
+    data.flat_ui = [1, 2]
+    data.ui_scale = 2
+    data.to_yaml(filename=cfg_env)
+    loaded = Config()
+    loaded.load()
+    assert loaded.logging_level == Config().logging_level
+    assert loaded.flat_ui is True
+    assert loaded.ui_scale == "2"
+
+
+def test_upgrade_check_sets_ffprobe(cfg_env, tmp_path):
+    old = cfg_env.parent / "fastflix.json"
+    old.write_text('{"ffmpeg": "/a/ffmpeg", "ffprobe": "/a/ffprobe"}')
+    c = _new_config()
+    c.config_path = cfg_env
+    assert c.upgrade_check()
+    assert c.ffmpeg == Path("/a/ffmpeg")
+    assert c.ffprobe == Path("/a/ffprobe")
+
+
+def test_pre_load_logs_exception(cfg_env, caplog):
+    cfg_env.write_text("a: [unclosed")
+    with caplog.at_level(logging.WARNING, logger="fastflix"):
+        out = Config().pre_load()
+    assert out == {"enable_scaling": True}
+    assert any("config" in r.getMessage().lower() for r in caplog.records)
+
+
+def test_unrecoverable_raises_config_error(cfg_env, monkeypatch):
+    cfg_env.write_text("version: 6.\ntheme: [unclosed")
+
+    def nope(*a, **k):
+        raise OSError("locked")
+
+    monkeypatch.setattr(config_module.os, "replace", nope)
+    monkeypatch.setattr(config_module.shutil, "move", nope)
+    with pytest.raises(ConfigError):
+        Config().load()
diff --git a/tests/test_conversion_worker.py b/tests/test_conversion_worker.py
new file mode 100644
index 00000000..72261ae5
--- /dev/null
+++ b/tests/test_conversion_worker.py
@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+import queue
+
+import pytest
+
+from fastflix import conversion_worker
+
+
+class FakeRunner:
+    instances = []
+
+    def __init__(self, log_queue):
+        self.process = type("P", (), {"returncode": -9})()
+        self.error_detected = False
+        self.killed = False
+        self.kill_calls = 0
+        self.alive = True
+        self.joined = False
+        FakeRunner.instances.append(self)
+
+    def is_alive(self):
+        return self.alive
+
+    def start_exec(self, *a, **k):
+        self.alive = False
+
+    def change_priority(self, *_):
+        pass
+
+    def join_reader(self, timeout=1.0):
+        self.joined = True
+
+    def kill(self, log=True):
+        self.kill_calls += 1
+        self.killed = True
+
+
+class FakeGui:
+    def __init__(self, alive=True):
+        self.alive = alive
+
+    def is_alive(self):
+        return self.alive
+
+    def join(self):
+        pass
+
+
+class FakeLogQueue:
+    def __init__(self):
+        self.items = []
+        self.cancelled = False
+
+    def put(self, item, timeout=None):
+        self.items.append(item)
+
+    def cancel_join_thread(self):
+        self.cancelled = True
+
+
+@pytest.fixture(autouse=True)
+def patch_runner(monkeypatch):
+    FakeRunner.instances = []
+    monkeypatch.setattr(conversion_worker, "BackgroundRunner", FakeRunner)
+    monkeypatch.setattr(conversion_worker.reusables, "remove_file_handlers", lambda *_: None)
+    monkeypatch.setattr(
+        conversion_worker.reusables, "get_file_handler", lambda *a, **k: conversion_worker.logging.NullHandler()
+    )
+
+
+def run(requests, gui=None, log_queue=None):
+    wq, sq = queue.Queue(), queue.Queue()
+    for r in requests:
+        wq.put(r)
+    lq = log_queue or FakeLogQueue()
+    conversion_worker.queue_worker(gui or FakeGui(), wq, sq, lq)
+    out = []
+    while not sq.empty():
+        out.append(sq.get())
+    return out, lq
+
+
+def test_negative_return_code_reported_as_error():
+    out, _ = run([("execute", "v", "c", "cmd", "wd", "n", False), ("shutdown",)])
+    assert out[0][0] == "error"
+
+
+def test_killed_negative_code_not_error(monkeypatch):
+    class KilledRunner(FakeRunner):
+        def start_exec(self, *a, **k):
+            self.alive = False
+            self.killed = True
+
+    monkeypatch.setattr(conversion_worker, "BackgroundRunner", KilledRunner)
+    out, _ = run([("execute", "v", "c", "cmd", "wd", "n", False), ("shutdown",)])
+    assert out[0][0] == "complete"
+
+
+def test_runner_killed_if_worker_raises(monkeypatch):
+    class Boom(FakeGui):
+        def is_alive(self):
+            raise RuntimeError("boom")
+
+    with pytest.raises(RuntimeError):
+        run([], gui=Boom())
+    assert FakeRunner.instances[0].kill_calls >= 1
+
+
+def test_log_queue_join_cancelled_when_gui_dies(monkeypatch):
+    monkeypatch.setattr(FakeRunner, "is_alive", lambda self: False)
+    _, lq = run([], gui=FakeGui(alive=False))
+    assert lq.cancelled is True
diff --git a/tests/test_data_panel.py b/tests/test_data_panel.py
index d771fc6a..aa49cea0 100644
--- a/tests/test_data_panel.py
+++ b/tests/test_data_panel.py
@@ -114,14 +114,68 @@ def test_multiple_data_streams(self):
         assert result[idx + 1] == "1,2"
 
 
+class TestBuildDataRigayaOutputFormat:
+    """Rigaya encoders can only copy data/attachment streams to MKV containers."""
+
+    def test_mp4_output_skips_data_copy(self):
+        tracks = [DataTrack(index=5, outdex=3, enabled=True, codec_type="data")]
+        data_streams = [Box({"index": 5})]
+        result = build_data(tracks, data_streams, [], output_path=Path("output.mp4"))
+        assert result == []
+
+    def test_mov_output_skips_data_copy(self):
+        tracks = [DataTrack(index=5, outdex=3, enabled=True, codec_type="data")]
+        data_streams = [Box({"index": 5})]
+        result = build_data(tracks, data_streams, [], output_path=Path("output.mov"))
+        assert result == []
+
+    def test_mkv_output_allows_data_copy(self):
+        tracks = [DataTrack(index=5, outdex=3, enabled=True, codec_type="data")]
+        data_streams = [Box({"index": 5})]
+        result = build_data(tracks, data_streams, [], output_path=Path("output.mkv"))
+        assert "--data-copy" in result
+
+    def test_mkv_output_allows_attachment_copy(self):
+        tracks = [DataTrack(index=10, outdex=5, enabled=True, codec_type="attachment")]
+        attachment_streams = [Box({"index": 10})]
+        result = build_data(tracks, [], attachment_streams, output_path=Path("output.mkv"))
+        assert "--attachment-copy" in result
+
+    def test_mp4_output_skips_attachment_copy(self):
+        tracks = [DataTrack(index=10, outdex=5, enabled=True, codec_type="attachment")]
+        attachment_streams = [Box({"index": 10})]
+        result = build_data(tracks, [], attachment_streams, output_path=Path("output.mp4"))
+        assert result == []
+
+    def test_ts_output_skips_data_copy(self):
+        tracks = [DataTrack(index=5, outdex=3, enabled=True, codec_type="data")]
+        data_streams = [Box({"index": 5})]
+        result = build_data(tracks, data_streams, [], output_path=Path("output.ts"))
+        assert result == []
+
+    def test_no_output_path_allows_data_copy(self):
+        """Backward compatibility: no output_path means no filtering."""
+        tracks = [DataTrack(index=5, outdex=3, enabled=True, codec_type="data")]
+        data_streams = [Box({"index": 5})]
+        result = build_data(tracks, data_streams, [])
+        assert "--data-copy" in result
+
+
 class TestGenerateEndingWithDataTracks:
     def test_with_data_tracks(self):
         tracks = [
             DataTrack(index=5, outdex=3, enabled=True, codec_type="data"),
-            DataTrack(index=10, outdex=4, enabled=True, codec_type="attachment"),
+            DataTrack(
+                index=10,
+                outdex=4,
+                enabled=True,
+                codec_type="attachment",
+                mimetype="application/x-truetype-font",
+                filename="test_font.ttf",
+            ),
         ]
         result, _ = generate_ending(
-            audio=[],
+            audio=["-map", "0:1", "-map", "0:2"],
             subtitles=[],
             output_video=Path("output.mkv"),
             data_tracks=tracks,
@@ -132,6 +186,35 @@ def test_with_data_tracks(self):
         assert "-c:d" in result
         assert "copy" in result
         assert "-c:t" in result
+        assert "-metadata:s:4" in result
+        assert "mimetype=application/x-truetype-font" in result
+        assert "filename=test_font.ttf" in result
+        # Both tracks should have title/handler cleared
+        assert "-metadata:s:3" in result
+        assert "title=" in result
+        assert "handler=" in result
+
+    def test_data_track_title_and_handler_metadata(self):
+        """Data/attachment tracks must set title and handler metadata (empty string when not set)."""
+        tracks = [
+            DataTrack(index=5, outdex=2, enabled=True, codec_type="data", title="Timecode"),
+            DataTrack(index=6, outdex=3, enabled=True, codec_type="data", title=""),
+        ]
+        result, _ = generate_ending(
+            audio=["-map", "0:1"],
+            subtitles=[],
+            output_video=Path("output.mp4"),
+            data_tracks=tracks,
+        )
+        result_str = " ".join(result)
+        # Track with title should have it set
+        assert "-metadata:s:2" in result
+        assert "title=Timecode" in result_str
+        assert "handler=Timecode" in result_str
+        # Track without title should have empty strings
+        assert "-metadata:s:3" in result
+        assert "title=" in result
+        assert "handler=" in result
 
     def test_with_disabled_data_tracks(self):
         tracks = [
@@ -183,7 +266,16 @@ def test_no_data(self):
 
     def test_attachment_only_codec(self):
         """When only attachment tracks, should set -c:t copy but not -c:d."""
-        tracks = [DataTrack(index=10, outdex=4, enabled=True, codec_type="attachment")]
+        tracks = [
+            DataTrack(
+                index=10,
+                outdex=4,
+                enabled=True,
+                codec_type="attachment",
+                mimetype="application/x-truetype-font",
+                filename="test_font.ttf",
+            )
+        ]
         result, _ = generate_ending(
             audio=[],
             subtitles=[],
@@ -192,3 +284,145 @@ def test_attachment_only_codec(self):
         )
         assert "-c:t" in result
         assert "-c:d" not in result
+        assert "mimetype=application/x-truetype-font" in result
+        assert "filename=test_font.ttf" in result
+
+    def test_attachment_mimetype_restored_after_metadata_strip(self):
+        """Mimetype and filename must be emitted per-stream so matroska muxer accepts attachments."""
+        tracks = [
+            DataTrack(
+                index=3,
+                outdex=2,
+                enabled=True,
+                codec_type="attachment",
+                mimetype="application/x-truetype-font",
+                filename="test_font.ttf",
+            ),
+            DataTrack(
+                index=5,
+                outdex=3,
+                enabled=True,
+                codec_type="attachment",
+                mimetype="application/json",
+                filename="metadata.json",
+            ),
+            DataTrack(
+                index=6,
+                outdex=4,
+                enabled=True,
+                codec_type="attachment",
+                mimetype="application/octet-stream",
+                filename="test_data.bin",
+            ),
+        ]
+        result, _ = generate_ending(
+            audio=["-map", "0:1"],
+            subtitles=[],
+            output_video=Path("output.mkv"),
+            data_tracks=tracks,
+            remove_metadata=True,
+        )
+        # -map_metadata -1 strips metadata, so per-stream mimetype must be restored
+        assert "-map_metadata" in result
+        # Font attachment
+        assert "-metadata:s:2" in result
+        assert "mimetype=application/x-truetype-font" in result
+        assert "filename=test_font.ttf" in result
+        # JSON attachment
+        assert "-metadata:s:3" in result
+        assert "mimetype=application/json" in result
+        assert "filename=metadata.json" in result
+        # Binary attachment
+        assert "-metadata:s:4" in result
+        assert "mimetype=application/octet-stream" in result
+        assert "filename=test_data.bin" in result
+
+    def test_attachment_without_mimetype_no_metadata(self):
+        """Attachments without mimetype/filename should not emit empty metadata."""
+        tracks = [
+            DataTrack(index=3, outdex=2, enabled=True, codec_type="attachment"),
+        ]
+        result, _ = generate_ending(
+            audio=[],
+            subtitles=[],
+            output_video=Path("output.mkv"),
+            data_tracks=tracks,
+        )
+        assert "-c:t" in result
+        assert "mimetype=" not in " ".join(result)
+        assert "filename=" not in " ".join(result)
+
+    def test_data_tracks_no_mimetype_for_data_type(self):
+        """Data streams (not attachments) should never get mimetype metadata."""
+        tracks = [
+            DataTrack(
+                index=5,
+                outdex=3,
+                enabled=True,
+                codec_type="data",
+                mimetype="application/octet-stream",
+                filename="some_data.bin",
+            ),
+        ]
+        result, _ = generate_ending(
+            audio=[],
+            subtitles=[],
+            output_video=Path("output.mkv"),
+            data_tracks=tracks,
+        )
+        assert "-c:d" in result
+        assert "mimetype=" not in " ".join(result)
+
+
+class TestDataTrackWidgetCompatibilityRestore:
+    """The user's Preserve selection must survive an incompatible -> compatible container switch."""
+
+    @staticmethod
+    def _make_widget(extension, user_enabled):
+        from unittest import mock
+
+        from PySide6 import QtWidgets
+
+        from fastflix.widgets.panels.data_panel import DataTrackWidget
+
+        QtWidgets.QApplication.instance() or QtWidgets.QApplication([])
+
+        track = DataTrack(index=3, outdex=1, codec_type="data", codec_name="bin_data", enabled=user_enabled)
+        app = mock.MagicMock()
+        app.fastflix.config.theme = "onyx"
+        app.fastflix.current_video.data_tracks = [track]
+        app.fastflix.current_video.video_settings.video_encoder_settings.name = "x265"
+
+        parent = QtWidgets.QWidget()
+        parent.app = app
+        parent.main = mock.MagicMock()
+        parent.main.resolve_output_extension.return_value = extension
+        parent.reorder = mock.MagicMock()
+        widget = DataTrackWidget(app, parent, 0, enabled=user_enabled)
+        return widget, track, parent
+
+    def test_enabled_selection_restored(self):
+        widget, track, parent = self._make_widget(".mp4", True)
+        assert track.enabled is True
+
+        parent.main.resolve_output_extension.return_value = ".mkv"  # data streams unsupported in MKV
+        widget._check_compatibility()
+        assert widget.incompatible is True
+        assert track.enabled is False
+        assert not widget.widgets.enable_check.isEnabled()
+
+        parent.main.resolve_output_extension.return_value = ".mp4"
+        widget._check_compatibility()
+        assert widget.incompatible is False
+        assert widget.widgets.enable_check.isEnabled()
+        assert track.enabled is True
+        assert widget.widgets.enable_check.isChecked()
+
+    def test_disabled_selection_stays_disabled(self):
+        widget, track, parent = self._make_widget(".mp4", False)
+        parent.main.resolve_output_extension.return_value = ".mkv"
+        widget._check_compatibility()
+        parent.main.resolve_output_extension.return_value = ".mp4"
+        widget._check_compatibility()
+        assert track.enabled is False
+        assert not widget.widgets.enable_check.isChecked()
diff --git a/tests/test_ff_queue_robustness.py b/tests/test_ff_queue_robustness.py
new file mode 100644
index 00000000..e94c9656
--- /dev/null
+++ b/tests/test_ff_queue_robustness.py
@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*-
+import logging
+import os
+import time
+from pathlib import Path
+
+import pytest
+from box import Box
+
+from fastflix import ff_queue
+from fastflix.ff_queue import get_queue, queue_file_lock, save_queue
+from fastflix.models.encode import x265Settings
+from fastflix.models.video import Video, VideoSettings
+
+
+def _video(name):
+    vs = VideoSettings(output_path=Path(f"/out/{name}.mkv"), video_encoder_settings=x265Settings())
+    return Video(
+        source=Path(f"/in/{name}.mkv"), work_path=Path(f"/work/{name}"), video_settings=vs, streams=Box(), format=Box()
+    )
+
+
+@pytest.fixture
+def qfile(tmp_path):
+    return tmp_path / "queue.yaml"
+
+
+def _two_video_queue(qfile):
+    save_queue([_video("a"), _video("b")], qfile)
+    return qfile
+
+
+def test_valid_queue_round_trip(qfile):
+    _two_video_queue(qfile)
+    out = get_queue(qfile)
+    assert [v.source.name for v in out] == ["a.mkv", "b.mkv"]
+    assert not list(qfile.parent.glob("queue_error_*"))
+
+
+def test_bad_encoder_name_skips_only_that_item(qfile, caplog):
+    _two_video_queue(qfile)
+    data = Box.from_yaml(filename=qfile)
+    data["queue"][0]["video_settings"]["video_encoder_settings"]["name"] = "Nonexistent Encoder"
+    data.to_yaml(filename=qfile)
+    with caplog.at_level(logging.WARNING, logger="fastflix"):
+        out = get_queue(qfile)
+    assert [v.source.name for v in out] == ["b.mkv"]
+    assert len(list(qfile.parent.glob("queue_error_*.yaml"))) == 1
+
+
+def test_missing_key_and_validation_error_skipped(qfile):
+    save_queue([_video("a"), _video("b"), _video("c")], qfile)
+    data = Box.from_yaml(filename=qfile)
+    del data["queue"][0]["status"]
+    data["queue"][1]["duration"] = "not a number"
+    data.to_yaml(filename=qfile)
+    out = get_queue(qfile)
+    assert [v.source.name for v in out] == ["c.mkv"]
+    assert len(list(qfile.parent.glob("queue_error_*.yaml"))) == 1
+
+
+def test_save_uses_os_replace_and_leaves_no_tmp(qfile, monkeypatch):
+    calls = []
+    real = os.replace
+    monkeypatch.setattr(ff_queue.os, "replace", lambda a, b: (calls.append((a, b)), real(a, b))[1])
+    _two_video_queue(qfile)
+    assert len(calls) == 1
+    assert not list(qfile.parent.glob("queue_*.yaml.tmp"))
+
+
+def test_get_queue_cleans_stale_tmp_files(qfile):
+    _two_video_queue(qfile)
+    stale = qfile.parent / "queue_abc123.yaml.tmp"
+    stale.write_text("partial")
+    old = time.time() - 3600
+    os.utime(stale, (old, old))
+    fresh = qfile.parent / "queue_fresh.yaml.tmp"
+    fresh.write_text("in progress")
+    get_queue(qfile)
+    assert not stale.exists()
+    assert fresh.exists()
+
+
+def test_lock_records_pid_and_token(qfile):
+    with queue_file_lock(qfile) as acquired:
+        assert acquired
+        content = qfile.with_suffix(".lock").read_text()
+        assert content.startswith(f"{os.getpid()}:")
+    assert not qfile.with_suffix(".lock").exists()
+
+
+def test_stale_lock_removed_when_unchanged(qfile):
+    lock = qfile.with_suffix(".lock")
+    lock.write_text("999999:deadbeef")
+    old = time.time() - 120
+    os.utime(lock, (old, old))
+    with queue_file_lock(qfile, timeout=3) as acquired:
+        assert acquired
+
+
+def test_lock_not_removed_if_replaced_while_stale(qfile, monkeypatch):
+    lock = qfile.with_suffix(".lock")
+    lock.write_text("1:old")
+    old = time.time() - 120
+    os.utime(lock, (old, old))
+    real_read = Path.read_text
+
+    def swap(self, *a, **k):
+        result = real_read(self, *a, **k)
+        if self == lock and result == "1:old":
+            lock.write_text("2:new")
+        return result
+
+    monkeypatch.setattr(Path, "read_text", swap)
+    with queue_file_lock(qfile, timeout=0.5) as acquired:
+        assert not acquired
+    assert lock.read_text() == "2:new"
+
+
+def test_timeout_does_not_delete_foreign_lock(qfile):
+    lock = qfile.with_suffix(".lock")
+    lock.write_text("1:other")
+    with queue_file_lock(qfile, timeout=0.3) as acquired:
+        assert not acquired
+    assert lock.read_text() == "1:other"
+
+
+def test_generation_mismatch_logs_warning(qfile, caplog):
+    _two_video_queue(qfile)
+    with caplog.at_level(logging.WARNING, logger="fastflix"):
+        save_queue([_video("z")], qfile, expected_generation="stale")
+    assert [v.source.name for v in get_queue(qfile)] == ["a.mkv", "b.mkv"]
+    assert any("dropped" in r.getMessage().lower() and "stale" in r.getMessage() for r in caplog.records)
diff --git a/tests/test_flix_core.py b/tests/test_flix_core.py
new file mode 100644
index 00000000..54dd3122
--- /dev/null
+++ b/tests/test_flix_core.py
@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+from box import Box
+
+from fastflix import flix
+from fastflix.exceptions import FlixError
+
+
+def test_concat_relative_entries_resolve_against_list_dir(tmp_path, monkeypatch):
+    sub = tmp_path / "lists"
+    sub.mkdir()
+    (sub / "a.mkv").write_text("x")
+    (sub / "b c.mkv").write_text("x")
+    lst = sub / "list.txt"
+    lst.write_text("# comment\nfile 'a.mkv'\nfile 'b c.mkv'\n")
+    elsewhere = tmp_path / "other"
+    elsewhere.mkdir()
+    monkeypatch.chdir(elsewhere)
+    assert flix.get_all_concat_items(lst) == [sub / "a.mkv", sub / "b c.mkv"]
+
+
+def test_concat_handles_escaped_quote(tmp_path):
+    (tmp_path / "it's.mkv").write_text("x")
+    lst = tmp_path / "list.txt"
+    lst.write_text("file 'it'\\''s.mkv'\n")
+    assert flix.get_all_concat_items(lst) == [tmp_path / "it's.mkv"]
+
+
+def test_concat_backslash_escape_unquoted(tmp_path):
+    (tmp_path / "it's.mkv").write_text("x")
+    lst = tmp_path / "list.txt"
+    lst.write_text("file it\\'s.mkv\n")
+    assert flix.get_all_concat_items(lst) == [tmp_path / "it's.mkv"]
+
+
+def test_concat_absolute_and_missing(tmp_path):
+    target = tmp_path / "abs.mkv"
+    target.write_text("x")
+    lst = tmp_path / "list.txt"
+    lst.write_text(f"file '{target.as_posix()}'\n")
+    assert flix.get_all_concat_items(lst) == [target]
+    lst.write_text("file 'missing.mkv'\n")
+    with pytest.raises(FlixError):
+        flix.get_all_concat_items(lst)
+
+
+def test_cropdetect_uses_frames_v(monkeypatch):
+    captured = {}
+
+    def fake_execute(cmd, **_):
+        captured["cmd"] = cmd
+        return SimpleNamespace(stderr="")
+
+    monkeypatch.setattr(flix, "execute", fake_execute)
+    flix.get_auto_crop(SimpleNamespace(ffmpeg="ffmpeg"), Path("a.mkv"), 1920, 1080, 0, 0, [])
+    assert "-vframes" not in captured["cmd"]
+    i = captured["cmd"].index("-frames:v")
+    assert captured["cmd"][i + 1] == "10"
+
+
+def test_extract_attachments_uses_basename_for_extension(monkeypatch):
+    calls = []
+    monkeypatch.setattr(flix, "extract_attachment", lambda *a: calls.append(a))
+    app = MagicMock()
+    app.fastflix.config.disable_cover_extraction = False
+    app.fastflix.current_video.streams.attachment = [
+        Box(index=3, tags={"filename": "some.dir/cover.jpg"}),
+        Box(index=4, tags={"filename": "../cover.jpg"}),
+        Box(index=5, tags={"filename": "other/notcover.jpg"}),
+    ]
+    flix.extract_attachments(app)
+    assert [c[2] for c in calls] == [3, 4]
+    assert all(c[4] == "cover.jpg" for c in calls)
+
+
+def test_hdr10plus_ffprobe_selects_absolute_stream_index(monkeypatch):
+    captured = {}
+
+    def fake_execute(cmd, **_):
+        captured["cmd"] = cmd
+        return SimpleNamespace(returncode=0, stdout='{"frames": []}')
+
+    monkeypatch.setattr(flix, "execute", fake_execute)
+    app = MagicMock()
+    app.fastflix.current_video.source = Path("a.mkv")
+    flix._detect_hdr10_plus_ffprobe(app, SimpleNamespace(ffprobe="ffprobe"), Box(index=2))
+    i = captured["cmd"].index("-select_streams")
+    assert captured["cmd"][i + 1] == "2"
+
+
+class FakePopen:
+    instances = []
+
+    def __init__(self, cmd, **kw):
+        self.cmd = cmd
+        self.kw = kw
+        self.stdout = MagicMock()
+        self.stderr = MagicMock()
+        self.stdin = MagicMock()
+        self.killed = False
+        self.waited = False
+        FakePopen.instances.append(self)
+
+    def communicate(self, *a, **k):
+        if self.cmd[0] == "parser":
+            return ("Dynamic HDR10+ metadata detected.", "")
+        return ("", "")
+
+    def kill(self):
+        self.killed = True
+
+    def wait(self, timeout=None):
+        self.waited = True
+        return 0
+
+    def poll(self):
+        return None
+
+
+def _tool_app():
+    app = MagicMock()
+    app.fastflix.current_video.source = Path("a.mkv")
+    return app
+
+
+def test_hdr10plus_tool_caps_frames_and_reaps_ffmpeg(monkeypatch):
+    FakePopen.instances = []
+    monkeypatch.setattr(flix, "Popen", FakePopen)
+    monkeypatch.setattr(flix, "get_hdr10_parser_version", lambda c: flix.version.parse("1.0.0"))
+    config = SimpleNamespace(ffmpeg="ffmpeg", hdr10plus_parser="parser")
+    assert flix._detect_hdr10_plus_tool(_tool_app(), config, Box(index=0)) is True
+    ffmpeg_proc, parser_proc = FakePopen.instances
+    assert "-frames:v" in ffmpeg_proc.cmd
+    assert ffmpeg_proc.killed and ffmpeg_proc.waited
+    ffmpeg_proc.stdout.close.assert_called()
+
+
+def test_hdr10plus_tool_reaps_ffmpeg_on_error(monkeypatch):
+    FakePopen.instances = []
+
+    class Boom(FakePopen):
+        def communicate(self, *a, **k):
+            if self.cmd[0] == "parser":
+                raise RuntimeError("boom")
+            return ("", "")
+
+    monkeypatch.setattr(flix, "Popen", Boom)
+    monkeypatch.setattr(flix, "get_hdr10_parser_version", lambda c: flix.version.parse("1.0.0"))
+    config = SimpleNamespace(ffmpeg="ffmpeg", hdr10plus_parser="parser")
+    assert flix._detect_hdr10_plus_tool(_tool_app(), config, Box(index=0)) is False
+    assert FakePopen.instances[0].killed
diff --git a/tests/test_gpu_detect.py b/tests/test_gpu_detect.py
new file mode 100644
index 00000000..9c34d5b9
--- /dev/null
+++ b/tests/test_gpu_detect.py
@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+from types import SimpleNamespace
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from fastflix import gpu_detect
+from fastflix.gpu_detect import DetectGPU, classify_vendor
+
+
+@pytest.mark.parametrize(
+    "name,expected",
+    [
+        ("NVIDIA", "NVIDIA"),
+        ("NVIDIA Corporation", "NVIDIA"),
+        ("Intel(R) Corporation", "INTEL"),
+        ("Intel Corporation", "INTEL"),
+        ("Advanced Micro Devices, Inc.", "AMD"),
+        ("ATI Technologies Inc.", "AMD"),
+        ("AMD", "AMD"),
+        ("Microsoft Basic Display Adapter", None),
+        ("", None),
+        (None, None),
+    ],
+)
+def test_classify_vendor(name, expected):
+    assert classify_vendor(name) == expected
+
+
+def test_windows_detect_handles_none_values(monkeypatch):
+    adapters = [
+        SimpleNamespace(AdapterCompatibility="Advanced Micro Devices, Inc.", VideoProcessor=None),
+        SimpleNamespace(AdapterCompatibility=None, VideoProcessor="x"),
+        SimpleNamespace(AdapterCompatibility="NVIDIA", VideoProcessor="GeForce"),
+    ]
+    fake_wmi = SimpleNamespace(WMI=lambda: SimpleNamespace(Win32_VideoController=lambda: adapters))
+    monkeypatch.setitem(__import__("sys").modules, "wmi", fake_wmi)
+    result = gpu_detect.windows_gpu_detect()
+    assert result.AMD and result.NVIDIA and not result.INTEL
+    assert result.fingerprint == "GeForce"
+
+
+def _setup(monkeypatch, nvenc_result, seven_zip_result):
+    config = SimpleNamespace(gpu_fingerprint=None, seven_zip=None, nvencc=None, vceencc=None, qsvencc=None)
+    monkeypatch.setattr(gpu_detect, "gpu_detect", lambda: DetectGPU(NVIDIA=True, fingerprint="fp"))
+    monkeypatch.setattr(gpu_detect, "find_seven_zip_windows", lambda: None)
+    monkeypatch.setattr(gpu_detect, "download_7zip", lambda stop: seven_zip_result)
+    monkeypatch.setattr(gpu_detect, "download_rigaya", lambda *a, **k: nvenc_result)
+    return config
+
+
+def test_failed_download_does_not_store_fingerprint(monkeypatch):
+    config = _setup(monkeypatch, None, Path("7zr.exe"))
+    gpu_detect.automatic_rigaya_download(config, None, MagicMock(), MagicMock())
+    assert config.gpu_fingerprint is None
+
+
+def test_cancelled_7zip_does_not_crash_or_store(monkeypatch):
+    config = _setup(monkeypatch, Path("nvenc.exe"), None)
+    gpu_detect.automatic_rigaya_download(config, None, MagicMock(), MagicMock())
+    assert config.gpu_fingerprint is None
+    assert config.nvencc is None
+
+
+def test_successful_download_stores_fingerprint(monkeypatch):
+    config = _setup(monkeypatch, Path("nvenc.exe"), Path("7zr.exe"))
+    gpu_detect.automatic_rigaya_download(config, None, MagicMock(), MagicMock())
+    assert config.gpu_fingerprint == "fp"
+    assert config.nvencc == Path("nvenc.exe")
diff --git a/tests/test_gui_review_fixes.py b/tests/test_gui_review_fixes.py
new file mode 100644
index 00000000..d1d05d6c
--- /dev/null
+++ b/tests/test_gui_review_fixes.py
@@ -0,0 +1,264 @@
+# -*- coding: utf-8 -*-
+"""Regression tests for GUI review fixes."""
+
+from unittest import mock
+
+import pytest
+from PySide6 import QtWidgets
+
+
+@pytest.fixture(scope="session")
+def qapp():
+    app = QtWidgets.QApplication.instance()
+    if app is None:
+        app = QtWidgets.QApplication([])
+    return app
+
+
+def test_overwrite_prompt_escape_and_default_are_cancel(qapp):
+    from fastflix.widgets.main_encoding import build_overwrite_prompt
+
+    box, cancel, overwrite = build_overwrite_prompt()
+    assert box.escapeButton() is cancel
+    assert box.defaultButton() is cancel
+    assert box.buttonRole(overwrite) == QtWidgets.QMessageBox.ButtonRole.AcceptRole
+    assert box.buttonRole(cancel) == QtWidgets.QMessageBox.ButtonRole.RejectRole
+
+
+def test_end_encoding_does_not_run_after_done():
+    from fastflix.widgets.main_encoding import EncodingMixin
+
+    fake = mock.MagicMock()
+    EncodingMixin.end_encoding(fake)
+    fake.video_options.queue.run_after_done.assert_not_called()
+
+
+def test_conversion_complete_runs_after_done_only_on_success():
+    from fastflix.widgets.main_encoding import EncodingMixin
+
+    fake = mock.MagicMock()
+    fake.app.fastflix.config.show_error_message = False
+    EncodingMixin.conversion_complete(fake, False)
+    fake.video_options.queue.run_after_done.assert_not_called()
+
+    fake = mock.MagicMock()
+    fake.app.fastflix.config.show_complete_message = False
+    EncodingMixin.conversion_complete(fake, True)
+    fake.video_options.queue.run_after_done.assert_called_once()
+
+
+def test_notifier_does_not_process_events_off_thread():
+    import inspect
+
+    from fastflix.widgets.main_encoding import Notifier
+
+    assert "processEvents" not in inspect.getsource(Notifier.run)
+
+
+def test_run_preview_command_no_shell_with_timeout():
+    from fastflix.widgets.windows import crop_window
+
+    fake = mock.MagicMock(return_value=mock.MagicMock(returncode=0))
+    cmd = ["ffmpeg", "-i", "a&b^c%d.mkv", "out.tiff"]
+    with mock.patch.object(crop_window, "run", fake):
+        result = crop_window.run_preview_command(cmd)
+    assert result is fake.return_value
+    assert fake.call_args.args[0] == cmd
+    assert not fake.call_args.kwargs.get("shell")
+    assert fake.call_args.kwargs["timeout"] > 0
+
+
+def test_run_preview_command_timeout_returns_none():
+    import subprocess
+
+    from fastflix.widgets.windows import crop_window
+
+    with mock.patch.object(crop_window, "run", side_effect=subprocess.TimeoutExpired("ffmpeg", 1)):
+        assert crop_window.run_preview_command(["ffmpeg"]) is None
+
+
+def test_large_preview_uses_shared_runner():
+    import inspect
+
+    from fastflix.widgets.windows import large_preview
+
+    src = inspect.getsource(large_preview.LargePreview.generate_image)
+    assert "shell=True" not in src
+    assert "run_preview_command" in src
+
+
+def test_dropped_local_path(qapp, tmp_path):
+    from PySide6 import QtCore
+
+    from fastflix.widgets.main import dropped_local_path
+
+    f = tmp_path / "a.mkv"
+    f.write_text("x")
+    mime = QtCore.QMimeData()
+    assert dropped_local_path(mime) is None
+
+    mime.setUrls([QtCore.QUrl("https://example.com/x.mkv"), QtCore.QUrl.fromLocalFile(str(f))])
+    assert dropped_local_path(mime) == f
+
+    mime = QtCore.QMimeData()
+    mime.setUrls([QtCore.QUrl("https://example.com/x.mkv")])
+    assert dropped_local_path(mime) is None
+
+
+def test_thumbnail_requests_do_not_run_concurrently():
+    from fastflix.widgets import main as main_mod
+
+    fake = mock.MagicMock()
+    fake._thumb_worker = None
+    fake._thumb_pending = False
+    with mock.patch.object(main_mod, "ThumbnailCreator") as creator:
+        main_mod.Main._start_thumbnail_worker(fake, ["ffmpeg", "1"])
+        main_mod.Main._start_thumbnail_worker(fake, ["ffmpeg", "2"])
+        main_mod.Main._start_thumbnail_worker(fake, ["ffmpeg", "3"])
+    assert creator.call_count == 1
+    assert fake._thumb_pending is True
+
+    worker = fake._thumb_worker
+    main_mod.Main._thumbnail_worker_finished(fake)
+    worker.deleteLater.assert_called_once()
+    assert fake._thumb_worker is None
+    assert fake._thumb_pending is False
+    fake.generate_thumbnail.assert_called_once()
+
+
+def test_field_change_debounced_only_when_user_is_typing():
+    from fastflix.widgets import main as main_mod
+
+    fake = mock.MagicMock()
+    fake.sender.return_value.hasFocus.return_value = True
+    main_mod.Main._field_changed(fake)
+    fake._page_update_timer.start.assert_called_once()
+    fake.page_update.assert_not_called()
+
+    fake = mock.MagicMock()
+    fake.sender.return_value.hasFocus.return_value = False
+    main_mod.Main._field_changed(fake)
+    fake.page_update.assert_called_once()
+    fake._page_update_timer.start.assert_not_called()
+
+
+def test_reindex_after_delete_shifts_later_tracks():
+    from types import SimpleNamespace
+
+    from fastflix.widgets.panels.audio_panel import reindex_after_delete
+
+    tracks = [
+        SimpleNamespace(index=0, disposition_widget=SimpleNamespace(track_index=0)),
+        SimpleNamespace(index=2, disposition_widget=SimpleNamespace(track_index=2)),
+        SimpleNamespace(index=3, disposition_widget=SimpleNamespace(track_index=3)),
+    ]
+    reindex_after_delete(tracks, 1)
+    assert [x.index for x in tracks] == [0, 1, 2]
+    assert [x.disposition_widget.track_index for x in tracks] == [0, 1, 2]
+
+
+def test_del_me_reindexes_before_reorder():
+    from types import SimpleNamespace
+
+    from fastflix.widgets.panels.audio_panel import Audio
+
+    remaining = SimpleNamespace(index=3, disposition_widget=SimpleNamespace(track_index=3))
+    me = SimpleNamespace(index=2)
+    audio_tracks = ["a", "b", "me", "c"]
+    seen = {}
+    parent = mock.MagicMock()
+    parent.tracks = [me, remaining]
+    parent.remove_track.side_effect = lambda w: seen.update(index=remaining.index, n=len(audio_tracks))
+    me.parent = parent
+    me.app = SimpleNamespace(fastflix=SimpleNamespace(current_video=SimpleNamespace(audio_tracks=audio_tracks)))
+    Audio.del_me(me)
+    assert audio_tracks == ["a", "b", "c"]
+    assert seen == {"index": 2, "n": 3}
+
+
+def test_call_with_timeout():
+    import threading
+    import time
+
+    from fastflix.widgets.main_post_encode import call_with_timeout
+
+    assert call_with_timeout(lambda x: x * 2, 1, 21) == 42
+    release = threading.Event()
+    start = time.time()
+    with pytest.raises(TimeoutError):
+        call_with_timeout(lambda: release.wait(5), 0.2)
+    assert time.time() - start < 2
+    release.set()
+    with pytest.raises(ValueError):
+        call_with_timeout(lambda: (_ for _ in ()).throw(ValueError("x")), 1)
+
+
+def test_follow_progress_sleeps_when_idle_and_emits_frames():
+    import io
+
+    from fastflix.widgets.background_tasks import follow_progress
+
+    f = io.StringIO("frame=1\nother\nframe=2\n")
+    running = iter([True] * 6 + [False])
+    emitted, sleeps = [], []
+    follow_progress(lambda: next(running), f, emitted.append, sleep=sleeps.append)
+    assert emitted == ["frame=1", "frame=2"]
+    assert len(sleeps) >= 1
+
+
+def test_show_log_dir_uses_desktop_services():
+    from fastflix.widgets import container
+
+    fake = mock.MagicMock()
+    fake.app.fastflix.log_path = "C:/logs dir"
+    with mock.patch.object(container.QtGui.QDesktopServices, "openUrl") as open_url:
+        container.Container.show_log_dir(fake)
+    url = open_url.call_args.args[0]
+    assert url.isLocalFile()
+    assert not hasattr(container, "OpenFolder")
+
+
+def test_audio_title_is_synced_to_the_model_on_every_edit():
+    """Typing a title then queueing without leaving the field must still use the typed title."""
+    from types import SimpleNamespace
+
+    from fastflix.widgets.panels.audio_panel import Audio
+
+    track = SimpleNamespace(title="old")
+    me = SimpleNamespace(
+        index=0,
+        title="typed title",
+        app=SimpleNamespace(fastflix=SimpleNamespace(current_video=SimpleNamespace(audio_tracks=[track]))),
+    )
+    Audio.sync_title(me)
+    assert track.title == "typed title"
+
+
+def test_audio_title_sync_ignores_stale_index():
+    from types import SimpleNamespace
+
+    from fastflix.widgets.panels.audio_panel import Audio
+
+    me = SimpleNamespace(
+        index=5,
+        title="x",
+        app=SimpleNamespace(fastflix=SimpleNamespace(current_video=SimpleNamespace(audio_tracks=[]))),
+    )
+    Audio.sync_title(me)
+
+
+def test_thumbnail_creator_gives_up_on_a_hung_ffmpeg():
+    """A stuck thumbnail ffmpeg must finish (reporting failure) so queued thumbnail requests are not blocked forever."""
+    import subprocess
+    from types import SimpleNamespace
+
+    from fastflix.widgets import background_tasks
+
+    main = mock.MagicMock()
+    fake = SimpleNamespace(main=main, command=["ffmpeg", "-i", "x"])
+    with mock.patch.object(
+        background_tasks, "run", side_effect=subprocess.TimeoutExpired(cmd="ffmpeg", timeout=1)
+    ) as run_mock:
+        background_tasks.ThumbnailCreator.run(fake)
+    assert run_mock.call_args.kwargs.get("timeout")
+    main.thumbnail_complete.emit.assert_called_once_with(0)
diff --git a/tests/test_history_robustness.py b/tests/test_history_robustness.py
new file mode 100644
index 00000000..d9cb7ea1
--- /dev/null
+++ b/tests/test_history_robustness.py
@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+import logging
+import os
+
+from fastflix.models import history
+from fastflix.models.history import (
+    HistoryEntry,
+    add_history_entry,
+    delete_history_entry,
+    get_history_file,
+    get_history_thumbnails_dir,
+    load_history,
+    save_history,
+    trim_history,
+)
+
+
+def _entry(uuid, thumb=""):
+    return HistoryEntry(uuid=uuid, source="s", output="o", encoder_name="x265", thumbnail_filename=thumb)
+
+
+def _corrupt_copies(tmp_path):
+    return sorted(tmp_path.glob("history.yaml.corrupt-*"))
+
+
+def test_corrupt_history_is_moved_aside_not_lost_by_add(tmp_path, caplog):
+    save_history(tmp_path, [_entry("1"), _entry("2")])
+    hf = get_history_file(tmp_path)
+    hf.write_text("entries: [unclosed")
+    with caplog.at_level(logging.ERROR, logger="fastflix"):
+        add_history_entry(tmp_path, _entry("3"))
+    copies = _corrupt_copies(tmp_path)
+    assert len(copies) == 1
+    assert copies[0].read_text() == "entries: [unclosed"
+    assert [e.uuid for e in load_history(tmp_path)] == ["3"]
+    assert caplog.records
+
+
+def test_corrupt_history_is_moved_aside_by_trim_and_delete(tmp_path):
+    hf = get_history_file(tmp_path)
+    hf.write_text("entries: [unclosed")
+    trim_history(tmp_path, 1)
+    assert len(_corrupt_copies(tmp_path)) == 1
+    assert _corrupt_copies(tmp_path)[0].read_text() == "entries: [unclosed"
+
+
+def test_unreadable_history_is_left_alone(tmp_path, monkeypatch):
+    """A transient read failure (file locked by another process) must never move or overwrite the file."""
+    save_history(tmp_path, [_entry("1")])
+    hf = get_history_file(tmp_path)
+    before = hf.read_text()
+
+    def locked(*a, **k):
+        raise PermissionError("locked")
+
+    monkeypatch.setattr(history.Box, "from_yaml", locked)
+    add_history_entry(tmp_path, _entry("2"))
+    monkeypatch.undo()
+    assert hf.read_text() == before
+    assert not _corrupt_copies(tmp_path)
+
+
+def test_missing_history_still_adds(tmp_path):
+    add_history_entry(tmp_path, _entry("1"))
+    assert [e.uuid for e in load_history(tmp_path)] == ["1"]
+
+
+def test_load_history_returns_empty_on_corrupt(tmp_path):
+    get_history_file(tmp_path).write_text("entries: [unclosed")
+    assert load_history(tmp_path) == []
+
+
+def test_save_history_is_atomic(tmp_path, monkeypatch):
+    save_history(tmp_path, [_entry("1")])
+    calls = []
+    real = os.replace
+    monkeypatch.setattr(history.os, "replace", lambda a, b: (calls.append(b), real(a, b))[1])
+    save_history(tmp_path, [_entry("2")])
+    assert calls
+    assert [e.uuid for e in load_history(tmp_path)] == ["2"]
+    assert not [p for p in tmp_path.iterdir() if p.name.endswith(".tmp")]
+
+
+def test_save_failure_keeps_old_file(tmp_path, monkeypatch):
+    save_history(tmp_path, [_entry("1")])
+
+    def boom(*a, **k):
+        raise OSError("nope")
+
+    monkeypatch.setattr(history.os, "replace", boom)
+    save_history(tmp_path, [_entry("2")])
+    monkeypatch.undo()
+    assert [e.uuid for e in load_history(tmp_path)] == ["1"]
+    assert not [p for p in tmp_path.iterdir() if p.name.endswith(".tmp")]
+
+
+def test_thumbnail_path_traversal_not_deleted(tmp_path):
+    victim = tmp_path / "victim.txt"
+    victim.write_text("keep")
+    thumbs = get_history_thumbnails_dir(tmp_path)
+    thumbs.mkdir()
+    save_history(tmp_path, [_entry("1", "../victim.txt")])
+    delete_history_entry(tmp_path, "1")
+    assert victim.exists()
+
+
+def test_thumbnail_normal_deleted(tmp_path):
+    thumbs = get_history_thumbnails_dir(tmp_path)
+    thumbs.mkdir()
+    (thumbs / "a.jpg").write_text("x")
+    save_history(tmp_path, [_entry("1", "a.jpg")])
+    delete_history_entry(tmp_path, "1")
+    assert not (thumbs / "a.jpg").exists()
+
+
+def test_trim_nested_name_uses_basename_only(tmp_path):
+    thumbs = get_history_thumbnails_dir(tmp_path)
+    thumbs.mkdir()
+    (thumbs / "a.jpg").write_text("x")
+    save_history(tmp_path, [_entry("1", "sub/../../a.jpg"), _entry("2")])
+    trim_history(tmp_path, 1)
+    assert not (thumbs / "a.jpg").exists()
+    assert [e.uuid for e in load_history(tmp_path)] == ["2"]
diff --git a/tests/test_keep_source_setting.py b/tests/test_keep_source_setting.py
new file mode 100644
index 00000000..646dbbee
--- /dev/null
+++ b/tests/test_keep_source_setting.py
@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+"""
+Tests for the keep_source_after_encode setting (#677).
+
+Verifies:
+- Config field defaults to False
+- Config round-trips through serialization
+- add_to_queue() clears video when setting is off (default)
+- add_to_queue() keeps video when setting is on
+"""
+
+from pathlib import Path
+from unittest import mock
+
+import tempfile
+
+import pytest
+
+from fastflix.models.config import Config
+
+
+@pytest.fixture
+def config():
+    return Config(
+        version="4.0.0",
+        ffmpeg=Path("ffmpeg"),
+        ffprobe=Path("ffprobe"),
+        work_path=Path("work_path"),
+    )
+
+
+class TestConfigField:
+    def test_default_is_false(self, config):
+        assert config.keep_source_after_encode is False
+
+    def test_can_set_true(self, config):
+        config.keep_source_after_encode = True
+        assert config.keep_source_after_encode is True
+
+    def test_round_trip_model_dump(self, config):
+        config.keep_source_after_encode = True
+        data = config.model_dump()
+        assert data["keep_source_after_encode"] is True
+
+    def test_round_trip_model_dump_default(self, config):
+        data = config.model_dump()
+        assert data["keep_source_after_encode"] is False
+
+
+class TestAddToQueueBehavior:
+    """Test that add_to_queue respects the keep_source_after_encode setting."""
+
+    @pytest.fixture
+    def mock_main(self, config):
+        """Create a mock Main widget with the encoding mixin behavior."""
+        main = mock.MagicMock()
+        main.app.fastflix.config = config
+        main.app.fastflix.current_video = mock.MagicMock()
+        main.video_options.queue.add_to_queue.return_value = None
+        return main
+
+    def test_clears_video_when_setting_off(self, mock_main):
+        """Default behavior: clear source after adding to queue."""
+        mock_main.app.fastflix.config.keep_source_after_encode = False
+
+        from fastflix.widgets.main_encoding import EncodingMixin
+
+        mixin = EncodingMixin()
+        mixin.__dict__.update(
+            {
+                "app": mock_main.app,
+                "video_options": mock_main.video_options,
+                "clear_current_video": mock_main.clear_current_video,
+            }
+        )
+        result = EncodingMixin.add_to_queue(mixin)
+
+        assert result is True
+        mock_main.clear_current_video.assert_called_once()
+
+    def test_keeps_video_when_setting_on(self, mock_main):
+        """With setting enabled: keep source after adding to queue."""
+        mock_main.app.fastflix.config.keep_source_after_encode = True
+
+        from fastflix.widgets.main_encoding import EncodingMixin
+
+        mixin = EncodingMixin()
+        mixin.__dict__.update(
+            {
+                "app": mock_main.app,
+                "video_options": mock_main.video_options,
+                "clear_current_video": mock_main.clear_current_video,
+                "get_temp_work_path": lambda: Path(tempfile.mkdtemp()),
+            }
+        )
+        old_uuid = mock_main.app.fastflix.current_video.uuid
+        result = EncodingMixin.add_to_queue(mixin)
+
+        assert result is True
+        mock_main.clear_current_video.assert_not_called()
+        # kept source gets a fresh identity so it can't collide with the queued copy
+        assert mock_main.app.fastflix.current_video.uuid != old_uuid
+
+    def test_no_clear_on_error(self, mock_main):
+        """If add_to_queue raises, clear_current_video should not be called."""
+        from fastflix.exceptions import FastFlixInternalException
+        from fastflix.widgets.main_encoding import EncodingMixin
+
+        mock_main.video_options.queue.add_to_queue.side_effect = FastFlixInternalException("test error")
+
+        mixin = EncodingMixin()
+        mixin.__dict__.update(
+            {
+                "app": mock_main.app,
+                "video_options": mock_main.video_options,
+                "clear_current_video": mock_main.clear_current_video,
+            }
+        )
+
+        with mock.patch("fastflix.widgets.main_encoding.error_message"):
+            result = EncodingMixin.add_to_queue(mixin)
+
+        assert result is None
+        mock_main.clear_current_video.assert_not_called()
+
+    def test_no_clear_when_queue_returns_code(self, mock_main):
+        """If queue.add_to_queue returns a non-None code, clear is not reached."""
+        from fastflix.widgets.main_encoding import EncodingMixin
+
+        mock_main.video_options.queue.add_to_queue.return_value = False
+
+        mixin = EncodingMixin()
+        mixin.__dict__.update(
+            {
+                "app": mock_main.app,
+                "video_options": mock_main.video_options,
+                "clear_current_video": mock_main.clear_current_video,
+            }
+        )
+        result = EncodingMixin.add_to_queue(mixin)
+
+        assert result is False
+        mock_main.clear_current_video.assert_not_called()
diff --git a/tests/test_local_encode.py b/tests/test_local_encode.py
index 118a71a6..c8608c6c 100644
--- a/tests/test_local_encode.py
+++ b/tests/test_local_encode.py
@@ -29,7 +29,10 @@
 from fastflix.models.config import Config
 from fastflix.models.encode import (
     AOMAV1Settings,
+    AttachmentTrack,
+    AudioTrack,
     CopySettings,
+    DataTrack,
     FFmpegNVENCSettings,
     GIFSettings,
     GifskiSettings,
@@ -68,6 +71,8 @@
 # Paths
 # ---------------------------------------------------------------------------
 TEST_SOURCE = Path(__file__).parent / "media" / "Beverly Hills Duck Pond - HDR10plus - Jessica Payne.mp4"
+TEST_SOURCE_ATTACHMENTS = Path(__file__).parent / "media" / "font_attachment_data.mkv"
+TEST_SOURCE_CHAPTERS = Path(__file__).parent / "media" / "chapters_timecode.mp4"
 FFMPEG = shutil.which("ffmpeg")
 FFPROBE = shutil.which("ffprobe")
 
@@ -227,6 +232,25 @@ def create_real_fastflix(encoder_settings, output_path: Path, work_path: Path, i
     return fastflix
 
 
+# ffprobe reports animated WebP output as "webp_anim"
+CODEC_ALIASES = {"webp": {"webp", "webp_anim"}}
+
+# Messages hardware encoders emit when the GPU / driver / device is missing or unusable
+HARDWARE_UNAVAILABLE_MARKERS = (
+    "no nvenc capable devices",
+    "cannot load nvcuda",
+    "openencodesessionex failed",
+    "no capable devices found",
+    "failed to initialize",
+    "device setup failed",
+    "no device available",
+    "unsupported device",
+    "not supported on current platform",
+    "unknown encoder",
+    "error initializing output stream",
+)
+
+
 # ---------------------------------------------------------------------------
 # Helper: verify output with ffprobe
 # ---------------------------------------------------------------------------
@@ -246,13 +270,14 @@ def verify_output(output_path: Path, expected_codec: str):
     video_streams = [s for s in data["streams"] if s["codec_type"] == "video"]
     assert len(video_streams) >= 1, "No video stream in output"
     actual_codec = video_streams[0]["codec_name"]
-    assert actual_codec == expected_codec, f"Expected codec {expected_codec}, got {actual_codec}"
+    accepted = CODEC_ALIASES.get(expected_codec, {expected_codec})
+    assert actual_codec in accepted, f"Expected codec {expected_codec}, got {actual_codec}"
 
 
 # ---------------------------------------------------------------------------
 # Helper: run a Command list
 # ---------------------------------------------------------------------------
-def run_commands(commands, work_path: Path):
+def run_commands(commands, work_path: Path, hardware: bool = False):
     for cmd in commands:
         if cmd.shell:
             cmd_to_run = cmd.to_string()
@@ -266,6 +291,10 @@ def run_commands(commands, work_path: Path):
             shell=cmd.shell,
             cwd=str(work_path),
         )
+        if result.returncode != 0 and hardware:
+            output = (result.stderr + "\n" + result.stdout).lower()
+            if any(marker in output for marker in HARDWARE_UNAVAILABLE_MARKERS):
+                pytest.skip(f"Hardware encoder unavailable in this environment: {result.stderr[-300:].strip()}")
         assert result.returncode == 0, (
             f"Command '{cmd.name}' failed (exit {result.returncode}):\n"
             f"CMD: {cmd.to_string()}\n"
@@ -488,5 +517,363 @@ def test_encode(encoder_id, settings, output_ext, expected_codec, is_rigaya, tmp
 
     assert commands, f"Encoder {encoder_id} returned no commands"
 
-    run_commands(commands, work_path)
+    hardware = is_rigaya or encoder_id.endswith(("nvenc", "qsv", "amf", "vaapi"))
+    run_commands(commands, work_path, hardware=hardware)
     verify_output(output_path, expected_codec)
+
+
+# ===========================================================================
+# Attachment / font preservation test
+# ===========================================================================
+def _probe_attachment_source() -> Optional[dict]:
+    if not FFPROBE or not TEST_SOURCE_ATTACHMENTS.exists():
+        return None
+    try:
+        result = subprocess.run(
+            [
+                FFPROBE,
+                "-v",
+                "quiet",
+                "-print_format",
+                "json",
+                "-show_streams",
+                "-show_format",
+                str(TEST_SOURCE_ATTACHMENTS),
+            ],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        return json.loads(result.stdout)
+    except Exception:
+        return None
+
+
+def test_encode_preserves_attachments_and_cover(tmp_path):
+    """Encode MKV with font, cover, and data attachments → verify all are in output."""
+    if ON_CI:
+        pytest.skip("Skipped on CI")
+    if not FFMPEG or not FFPROBE:
+        pytest.skip("ffmpeg/ffprobe not found")
+    if not _has_ffmpeg_encoder("libx265"):
+        pytest.skip("libx265 not available")
+    if not TEST_SOURCE_ATTACHMENTS.exists():
+        pytest.skip("font_attachment_data.mkv not found")
+
+    probe = _probe_attachment_source()
+    assert probe is not None, "Could not probe attachment test source"
+
+    video_streams = [
+        s
+        for s in probe["streams"]
+        if s["codec_type"] == "video" and s.get("disposition", {}).get("attached_pic", 0) == 0
+    ]
+    audio_streams = [s for s in probe["streams"] if s["codec_type"] == "audio"]
+    attachment_streams = [s for s in probe["streams"] if s.get("codec_type") == "attachment"]
+
+    for stream in video_streams:
+        if "bits_per_raw_sample" in stream:
+            stream["bit_depth"] = int(stream["bits_per_raw_sample"])
+        else:
+            stream["bit_depth"] = guess_bit_depth(stream.get("pix_fmt", ""), stream.get("color_primaries"))
+
+    streams = Box(
+        {
+            "video": [Box(v) for v in video_streams],
+            "audio": [Box(a) for a in audio_streams],
+            "subtitle": [],
+            "data": [],
+            "attachment": [Box(a) for a in attachment_streams],
+        }
+    )
+
+    output_path = tmp_path / "output_attachments.mkv"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    # Extract cover image to work_path (simulates what FastFlix does)
+    cover_path = work_path / "cover.png"
+    subprocess.run(
+        [FFMPEG, "-y", "-i", str(TEST_SOURCE_ATTACHMENTS), "-map", "0:4", "-c", "copy", str(cover_path)],
+        capture_output=True,
+        timeout=30,
+    )
+
+    video_settings = VideoSettings(
+        remove_hdr=False,
+        output_path=output_path,
+        end_time=2,
+    )
+    video_settings.video_encoder_settings = x265Settings(preset="ultrafast", crf=51)
+
+    video = Video(
+        source=TEST_SOURCE_ATTACHMENTS,
+        duration=10.0,
+        streams=streams,
+        format=Box(probe.get("format", {})),
+        video_settings=video_settings,
+        work_path=work_path,
+    )
+
+    # Audio track (stream 1: aac, copy)
+    # outdex: 1 (after video at 0)
+    video.audio_tracks = [
+        AudioTrack(
+            index=1,
+            outdex=1,
+            codec="aac",
+            enabled=True,
+            raw_info=Box({"channel_layout": "mono", "channels": 1, "codec_name": "aac"}),
+        ),
+    ]
+
+    # Set up data tracks (font + json + binary attachments from source)
+    # outdex starts at 2 (after video=0, audio=1)
+    # Stream 3: font (ttf), Stream 5: json attachment, Stream 6: binary attachment
+    video.data_tracks = [
+        DataTrack(
+            index=3,
+            outdex=2,
+            enabled=True,
+            codec_type="attachment",
+            codec_name="ttf",
+            mimetype="application/x-truetype-font",
+            filename="test_font.ttf",
+        ),
+        DataTrack(
+            index=5,
+            outdex=3,
+            enabled=True,
+            codec_type="attachment",
+            codec_name="",
+            mimetype="application/json",
+            filename="metadata.json",
+        ),
+        DataTrack(
+            index=6,
+            outdex=4,
+            enabled=True,
+            codec_type="attachment",
+            codec_name="",
+            mimetype="application/octet-stream",
+            filename="test_data.bin",
+        ),
+    ]
+
+    # Cover attachment via -attach (FFmpeg places after all -map streams)
+    # outdex: 5 (after video=0, audio=1, 3 data tracks=2,3,4)
+    video.attachment_tracks = [
+        AttachmentTrack(
+            index=4,
+            outdex=5,
+            file_path=str(cover_path),
+            filename="cover",
+            attachment_type="cover",
+        ),
+    ]
+
+    config = Config(
+        version="4.0.0",
+        ffmpeg=Path(FFMPEG),
+        ffprobe=Path(FFPROBE),
+        work_path=work_path,
+    )
+
+    fastflix = FastFlix(
+        config=config,
+        encoders={},
+        audio_encoders=[],
+        current_video=video,
+        ffmpeg_version="n5.0",
+    )
+
+    # Build and run
+    from fastflix.encoders.hevc_x265 import command_builder
+
+    commands = command_builder.build(fastflix)
+    assert commands, "Encoder returned no commands"
+    run_commands(commands, work_path)
+
+    # Verify output exists
+    assert output_path.exists(), "Output file does not exist"
+    assert output_path.stat().st_size > 0, "Output file is empty"
+
+    # Probe output and verify all streams
+    result = subprocess.run(
+        [FFPROBE, "-v", "quiet", "-print_format", "json", "-show_streams", str(output_path)],
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    assert result.returncode == 0, f"ffprobe failed: {result.stderr}"
+    output_data = json.loads(result.stdout)
+
+    out_video = [
+        s
+        for s in output_data["streams"]
+        if s["codec_type"] == "video" and s.get("disposition", {}).get("attached_pic", 0) == 0
+    ]
+    out_audio = [s for s in output_data["streams"] if s["codec_type"] == "audio"]
+    out_attachments = [s for s in output_data["streams"] if s["codec_type"] == "attachment"]
+    out_covers = [
+        s
+        for s in output_data["streams"]
+        if s["codec_type"] == "video" and s.get("disposition", {}).get("attached_pic", 0) == 1
+    ]
+
+    # Video and audio preserved
+    assert len(out_video) >= 1, "No video stream in output"
+    assert out_video[0]["codec_name"] == "hevc"
+    assert len(out_audio) >= 1, "No audio stream in output"
+
+    # Font attachment preserved with correct mimetype
+    font_attachments = [
+        s for s in out_attachments if s.get("tags", {}).get("mimetype") == "application/x-truetype-font"
+    ]
+    assert len(font_attachments) >= 1, f"Font attachment missing from output. Attachments found: {out_attachments}"
+
+    # JSON and binary attachments preserved
+    json_attachments = [s for s in out_attachments if s.get("tags", {}).get("filename") == "metadata.json"]
+    assert len(json_attachments) >= 1, f"JSON attachment missing from output. Attachments found: {out_attachments}"
+
+    bin_attachments = [s for s in out_attachments if s.get("tags", {}).get("filename") == "test_data.bin"]
+    assert len(bin_attachments) >= 1, f"Binary attachment missing from output. Attachments found: {out_attachments}"
+
+    # Cover image preserved
+    assert len(out_covers) >= 1, (
+        f"Cover image missing from output. All streams: {[s['codec_type'] for s in output_data['streams']]}"
+    )
+
+
+# ===========================================================================
+# Data stream exclusion test (MKV can't hold data streams)
+# ===========================================================================
+def test_encode_excludes_data_streams_for_mkv(tmp_path):
+    """Encode MP4 with data stream (timecode) to MKV — data must be excluded, not cause failure."""
+    if ON_CI:
+        pytest.skip("Skipped on CI")
+    if not FFMPEG or not FFPROBE:
+        pytest.skip("ffmpeg/ffprobe not found")
+    if not _has_ffmpeg_encoder("libx265"):
+        pytest.skip("libx265 not available")
+    if not TEST_SOURCE_CHAPTERS.exists():
+        pytest.skip("chapters_timecode.mp4 not found")
+
+    probe_result = subprocess.run(
+        [FFPROBE, "-v", "quiet", "-print_format", "json", "-show_streams", "-show_format", str(TEST_SOURCE_CHAPTERS)],
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    probe = json.loads(probe_result.stdout)
+
+    video_streams = [s for s in probe["streams"] if s["codec_type"] == "video"]
+    audio_streams = [s for s in probe["streams"] if s["codec_type"] == "audio"]
+    data_streams = [s for s in probe["streams"] if s["codec_type"] == "data"]
+
+    assert len(data_streams) >= 1, "Test file should have at least one data stream"
+
+    for stream in video_streams:
+        if "bits_per_raw_sample" in stream:
+            stream["bit_depth"] = int(stream["bits_per_raw_sample"])
+        else:
+            stream["bit_depth"] = guess_bit_depth(stream.get("pix_fmt", ""), stream.get("color_primaries"))
+
+    streams = Box(
+        {
+            "video": [Box(v) for v in video_streams],
+            "audio": [Box(a) for a in audio_streams],
+            "subtitle": [],
+            "data": [Box(d) for d in data_streams],
+            "attachment": [],
+        }
+    )
+
+    output_path = tmp_path / "output_no_data.mkv"
+    work_path = tmp_path / "work"
+    work_path.mkdir()
+
+    video_settings = VideoSettings(
+        remove_hdr=False,
+        output_path=output_path,
+        end_time=2,
+    )
+    video_settings.video_encoder_settings = x265Settings(preset="ultrafast", crf=51)
+
+    video = Video(
+        source=TEST_SOURCE_CHAPTERS,
+        duration=10.0,
+        streams=streams,
+        format=Box(probe.get("format", {})),
+        video_settings=video_settings,
+        work_path=work_path,
+    )
+
+    # Audio track (copy)
+    video.audio_tracks = [
+        AudioTrack(
+            index=1,
+            outdex=1,
+            codec="aac",
+            enabled=True,
+            raw_info=Box({"channel_layout": "mono", "channels": 1, "codec_name": "aac"}),
+        ),
+    ]
+
+    # Data track exists but is DISABLED (incompatible with MKV)
+    video.data_tracks = [
+        DataTrack(
+            index=2,
+            outdex=2,
+            enabled=False,
+            codec_type="data",
+            codec_name="bin_data",
+            title="",
+        ),
+    ]
+
+    config = Config(
+        version="4.0.0",
+        ffmpeg=Path(FFMPEG),
+        ffprobe=Path(FFPROBE),
+        work_path=work_path,
+    )
+
+    fastflix = FastFlix(
+        config=config,
+        encoders={},
+        audio_encoders=[],
+        current_video=video,
+        ffmpeg_version="n5.0",
+    )
+
+    # Build and run — this should NOT fail even though source has a data stream
+    from fastflix.encoders.hevc_x265 import command_builder
+
+    commands = command_builder.build(fastflix)
+    assert commands, "Encoder returned no commands"
+
+    # Verify -dn is in the command (explicitly disables data streams)
+    cmd_str = commands[0].to_string()
+    assert "-dn" in cmd_str, f"Expected -dn in command to exclude data streams: {cmd_str}"
+
+    run_commands(commands, work_path)
+
+    # Verify output
+    assert output_path.exists(), "Output file does not exist"
+    result = subprocess.run(
+        [FFPROBE, "-v", "quiet", "-print_format", "json", "-show_streams", str(output_path)],
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    output_data = json.loads(result.stdout)
+
+    out_video = [s for s in output_data["streams"] if s["codec_type"] == "video"]
+    out_audio = [s for s in output_data["streams"] if s["codec_type"] == "audio"]
+    out_data = [s for s in output_data["streams"] if s["codec_type"] == "data"]
+
+    assert len(out_video) >= 1, "No video stream in output"
+    assert out_video[0]["codec_name"] == "hevc"
+    assert len(out_audio) >= 1, "No audio stream in output"
+    assert len(out_data) == 0, f"Data streams should be excluded from MKV output, found: {out_data}"
diff --git a/tests/test_ocr_helpers.py b/tests/test_ocr_helpers.py
new file mode 100644
index 00000000..0acb855f
--- /dev/null
+++ b/tests/test_ocr_helpers.py
@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+import pytest
+
+from fastflix.widgets.background_tasks import pgsrip_srt_path, resolve_babel_language
+
+
+@pytest.mark.parametrize(
+    "code,alpha2",
+    [
+        ("fre", "fr"),
+        ("ger", "de"),
+        ("chi", "zh"),
+        ("eng", "en"),
+        ("fra", "fr"),
+        ("deu", "de"),
+        ("zho", "zh"),
+        ("und", "und"),
+        ("fr", "fr"),
+        ("EN", "en"),
+    ],
+)
+def test_resolve_babel_language(code, alpha2):
+    assert str(resolve_babel_language(code)) == alpha2
+
+
+def test_resolve_babel_language_name_and_garbage():
+    assert str(resolve_babel_language("French")) == "fr"
+    assert str(resolve_babel_language("zzzzz")) == "en"
+    assert str(resolve_babel_language("")) == "en"
+
+
+def test_pgsrip_srt_path(tmp_path):
+    assert pgsrip_srt_path(tmp_path / "movie.en.sup") == tmp_path / "movie.en.srt"
diff --git a/tests/test_output_dimensions.py b/tests/test_output_dimensions.py
new file mode 100644
index 00000000..1a84ffa4
--- /dev/null
+++ b/tests/test_output_dimensions.py
@@ -0,0 +1,258 @@
+# -*- coding: utf-8 -*-
+"""Tests for Video.compute_output_dimensions and related properties."""
+
+from pathlib import Path
+
+from box import Box
+
+from fastflix.models.video import Video, VideoSettings, Crop
+
+
+class TestComputeOutputDimensions:
+    """Test the static compute_output_dimensions method."""
+
+    def test_auto_returns_none(self):
+        assert Video.compute_output_dimensions(1920, 1080, method="auto") == (None, None)
+
+    def test_auto_with_custom_returns_none(self):
+        assert Video.compute_output_dimensions(1920, 1080, method="auto", custom="1280") == (None, None)
+
+    def test_no_custom_returns_none(self):
+        assert Video.compute_output_dimensions(1920, 1080, method="width", custom=None) == (None, None)
+
+    def test_empty_custom_returns_none(self):
+        assert Video.compute_output_dimensions(1920, 1080, method="width", custom="") == (None, None)
+
+    # Width scaling
+    def test_width_scaling_16_9(self):
+        w, h = Video.compute_output_dimensions(3840, 2160, method="width", custom="1920")
+        assert w == 1920
+        assert h == 1080
+
+    def test_width_scaling_4_3(self):
+        w, h = Video.compute_output_dimensions(1440, 1080, method="width", custom="720")
+        assert w == 720
+        assert h == 544  # 1080*720/1440=540, rounded to nearest multiple of 8 (half up) = 544
+        assert h % 8 == 0
+
+    def test_width_scaling_ultrawide(self):
+        w, h = Video.compute_output_dimensions(1920, 696, method="width", custom="1280")
+        assert w == 1280
+        assert h % 8 == 0
+
+    # Height scaling
+    def test_height_scaling_16_9(self):
+        w, h = Video.compute_output_dimensions(3840, 2160, method="height", custom="1080")
+        assert w == 1920
+        assert h == 1080
+
+    def test_height_scaling_4_3(self):
+        w, h = Video.compute_output_dimensions(1440, 1080, method="height", custom="540")
+        assert w == 720
+        assert h == 540
+        assert w % 8 == 0
+
+    # Long edge scaling
+    def test_long_edge_landscape(self):
+        w, h = Video.compute_output_dimensions(3840, 2160, method="long edge", custom="1920")
+        assert w == 1920
+        assert h == 1080
+
+    def test_long_edge_portrait(self):
+        w, h = Video.compute_output_dimensions(2160, 3840, method="long edge", custom="1920")
+        assert w == 1080
+        assert h == 1920
+
+    def test_long_edge_square(self):
+        w, h = Video.compute_output_dimensions(1000, 1000, method="long edge", custom="500")
+        assert w == 500
+        assert h == 504  # 500 rounded to nearest multiple of 8
+
+    # Custom scaling
+    def test_custom_explicit(self):
+        w, h = Video.compute_output_dimensions(3840, 2160, method="custom", custom="1280:720")
+        assert w == 1280
+        assert h == 720
+
+    def test_custom_invalid_format(self):
+        assert Video.compute_output_dimensions(1920, 1080, method="custom", custom="1280") == (None, None)
+
+    def test_custom_zero_dimension(self):
+        assert Video.compute_output_dimensions(1920, 1080, method="custom", custom="0:720") == (None, None)
+
+    # Auto dimension with -1/-2/-N (FFmpeg scale semantics)
+    def test_custom_auto_height_even(self):
+        assert Video.compute_output_dimensions(1920, 1080, method="custom", custom="1280:-2") == (1280, 720)
+
+    def test_custom_auto_width_even(self):
+        assert Video.compute_output_dimensions(1920, 1080, method="custom", custom="-2:720") == (1280, 720)
+
+    def test_custom_auto_nearest_integer(self):
+        # 1000x333 -> width 500 -> 166.5 -> 167 (half up)
+        assert Video.compute_output_dimensions(1000, 333, method="custom", custom="500:-1") == (500, 167)
+
+    def test_custom_auto_even_rounds_to_even(self):
+        # 1000x333 -> width 500 -> 166.5 -> nearest even = 166 or 168 (half up -> 168)
+        w, h = Video.compute_output_dimensions(1000, 333, method="custom", custom="500:-2")
+        assert w == 500 and h % 2 == 0
+
+    def test_custom_auto_multiple_of_n(self):
+        w, h = Video.compute_output_dimensions(1920, 800, method="custom", custom="-8:480")
+        assert h == 480
+        assert w % 8 == 0
+        assert w == 1152  # 1920*480/800
+
+    def test_custom_auto_uses_cropped_aspect(self):
+        # Crop to 1440x1080 then scale height 540 -> width 720
+        w, h = Video.compute_output_dimensions(
+            1920, 1080, crop_left=240, crop_right=240, method="custom", custom="-2:540"
+        )
+        assert (w, h) == (720, 540)
+
+    def test_custom_both_negative_invalid(self):
+        assert Video.compute_output_dimensions(1920, 1080, method="custom", custom="-1:-1") == (None, None)
+
+    def test_custom_auto_minus_one_via_video_scale(self):
+        v = TestVideoOutputProperties.make_video(method="custom", custom="-1:720")
+        assert v.scale == "1280:720"
+
+    # Rounding
+    def test_rounding_to_multiple_of_8(self):
+        # 1920x800 -> width=1280 -> height = 800*1280/1920 = 533.3 -> floor to 528
+        w, h = Video.compute_output_dimensions(1920, 800, method="width", custom="1280")
+        assert w == 1280
+        assert h % 8 == 0
+
+    def test_minimum_dimension_is_8(self):
+        # Very extreme downscale — ensure minimum of 8
+        w, h = Video.compute_output_dimensions(3840, 2160, method="width", custom="16")
+        assert w == 16
+        assert h >= 8
+        assert h % 8 == 0
+
+    # Crop
+    def test_crop_affects_aspect_ratio(self):
+        # 1920x1080, crop 100 from each side -> 1720x880
+        # Scale width to 860 -> h = 880*860/1720 = 440
+        w, h = Video.compute_output_dimensions(
+            1920,
+            1080,
+            crop_top=100,
+            crop_bottom=100,
+            crop_left=100,
+            crop_right=100,
+            method="width",
+            custom="860",
+        )
+        assert w == 860
+        assert h == 440
+        assert h % 8 == 0
+
+    def test_crop_pillarbox_4_3_in_16_9(self):
+        # 1920x1080 with 240px pillarbox on each side -> content is 1440x1080
+        w, h = Video.compute_output_dimensions(
+            1920,
+            1080,
+            crop_left=240,
+            crop_right=240,
+            method="width",
+            custom="720",
+        )
+        assert w == 720
+        # 1080*720/1440 = 540
+        assert h == 544  # 540 rounded to nearest multiple of 8
+        assert h % 8 == 0
+
+    def test_crop_letterbox_ultrawide(self):
+        # 1920x1080 with letterbox top/bottom -> content is 1920x696
+        w, h = Video.compute_output_dimensions(
+            1920,
+            1080,
+            crop_top=192,
+            crop_bottom=192,
+            method="width",
+            custom="1920",
+        )
+        assert w == 1920
+        assert h == 696
+        assert h % 8 == 0
+
+    def test_crop_exceeds_source_returns_none(self):
+        assert Video.compute_output_dimensions(
+            1920,
+            1080,
+            crop_left=1000,
+            crop_right=1000,
+            method="width",
+            custom="100",
+        ) == (None, None)
+
+    # Invalid inputs
+    def test_invalid_custom_string(self):
+        assert Video.compute_output_dimensions(1920, 1080, method="width", custom="abc") == (None, None)
+
+    def test_negative_pixels(self):
+        assert Video.compute_output_dimensions(1920, 1080, method="width", custom="-100") == (None, None)
+
+    def test_zero_pixels(self):
+        assert Video.compute_output_dimensions(1920, 1080, method="width", custom="0") == (None, None)
+
+
+class TestVideoOutputProperties:
+    """Test the Video convenience properties that use compute_output_dimensions."""
+
+    @staticmethod
+    def make_video(width=1920, height=1080, crop=None, method="auto", custom=None):
+        vs = VideoSettings(
+            crop=crop,
+            resolution_method=method,
+            resolution_custom=custom,
+        )
+        return Video(
+            source=Path("test.mkv"),
+            duration=60,
+            streams=Box({"video": [Box({"index": 0, "width": width, "height": height})]}),
+            format=Box({}),
+            video_settings=vs,
+            work_path=Path("work"),
+        )
+
+    def test_cropped_width_no_crop(self):
+        v = self.make_video()
+        assert v.cropped_width == 1920
+
+    def test_cropped_width_with_crop(self):
+        v = self.make_video(crop=Crop(left=100, right=100))
+        assert v.cropped_width == 1720
+
+    def test_cropped_height_with_crop(self):
+        v = self.make_video(crop=Crop(top=50, bottom=50))
+        assert v.cropped_height == 980
+
+    def test_output_width_auto(self):
+        v = self.make_video()
+        assert v.output_width is None
+        assert v.output_height is None
+
+    def test_output_width_with_scale(self):
+        v = self.make_video(method="width", custom="960")
+        assert v.output_width == 960
+        assert v.output_height == 544  # 1080*960/1920 = 540 -> nearest multiple of 8
+        assert v.output_height % 8 == 0
+
+    def test_scale_property_auto(self):
+        v = self.make_video()
+        assert v.scale is None
+
+    def test_scale_property_with_dimensions(self):
+        v = self.make_video(width=3840, height=2160, method="width", custom="1920")
+        assert v.scale == "1920:1080"
+
+    def test_scale_property_with_crop(self):
+        v = self.make_video(
+            crop=Crop(left=240, right=240),
+            method="width",
+            custom="720",
+        )
+        # Cropped: 1440x1080, scale width to 720 -> height = 1080*720/1440=540 -> nearest 544
+        assert v.scale == "720:544"
diff --git a/tests/test_pr740_gui_core_fixes.py b/tests/test_pr740_gui_core_fixes.py
new file mode 100644
index 00000000..f7eaef0f
--- /dev/null
+++ b/tests/test_pr740_gui_core_fixes.py
@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+"""Regression tests for PR 740 review fixes (deinterlace presets, GOP, warnings, queue identity, ElidedLabel)."""
+
+from pathlib import Path
+from unittest import mock
+
+import pytest
+from PySide6 import QtWidgets
+
+from fastflix.models.video import Video
+
+
+@pytest.fixture(scope="session")
+def qapp():
+    app = QtWidgets.QApplication.instance()
+    if app is None:
+        app = QtWidgets.QApplication([])
+    return app
+
+
+@pytest.fixture
+def advanced_panel(qapp):
+    from fastflix.widgets.panels.advanced_panel import AdvancedPanel
+
+    app = mock.MagicMock()
+    app.fastflix.config.theme = "onyx"
+    app.fastflix.config.suppress_video_speed_warning = False
+    app.fastflix.config.suppress_reverse_video_warning = False
+    app.fastflix.current_video = None
+    parent = QtWidgets.QWidget()
+    parent.main = mock.MagicMock()
+    parent.main.loading_video = False
+    panel = AdvancedPanel(parent, app)
+    panel._parent_keepalive = parent
+    return panel
+
+
+def test_deinterlace_presets_explicit_modes():
+    from fastflix.widgets.panels.advanced_panel import deinterlace_presets
+
+    assert deinterlace_presets["yadif"] == {
+        "send_frame": "yadif=mode=send_frame",
+        "send_field": "yadif=mode=send_field",
+    }
+    assert deinterlace_presets["bwdif"] == {
+        "send_frame": "bwdif=mode=send_frame",
+        "send_field": "bwdif=mode=send_field",
+    }
+    assert deinterlace_presets["w3fdif"] == {"send_frame": "w3fdif=mode=frame", "send_field": "w3fdif=mode=field"}
+    assert deinterlace_presets["estdif"] == {"send_frame": "estdif=mode=frame", "send_field": "estdif=mode=field"}
+
+
+def test_gop_length_minimum_and_parsing(advanced_panel):
+    w = advanced_panel.gop_length_widget
+    assert w.validator().bottom() == 1
+    for text, expected in [("", None), ("  ", None), ("0", None), ("-3", None), ("1", 1), ("250", 250)]:
+        w.setText(text)
+        assert advanced_panel.get_gop_length() == expected
+
+
+def test_warnings_not_shown_for_programmatic_changes(advanced_panel):
+    with mock.patch("fastflix.widgets.panels.advanced_panel.QtWidgets.QMessageBox") as box:
+        advanced_panel.updating = True
+        advanced_panel.reverse_video_widget.setChecked(True)
+        advanced_panel.video_speed_widget.setCurrentIndex(1)
+        advanced_panel.updating = False
+        advanced_panel.main.loading_video = True
+        advanced_panel.reverse_video_widget.setChecked(False)
+        advanced_panel.reverse_video_widget.setChecked(True)
+        advanced_panel.video_speed_widget.setCurrentIndex(2)
+        assert not box.called
+
+
+def test_warning_shown_for_user_change(advanced_panel):
+    with mock.patch("fastflix.widgets.panels.advanced_panel.QtWidgets.QMessageBox") as box:
+        advanced_panel.reverse_video_widget.setChecked(True)
+        assert box.called
+
+
+def test_refresh_video_identity(tmp_path):
+    from fastflix.widgets.main_encoding import refresh_video_identity
+
+    old = tmp_path / "old"
+    old.mkdir()
+    (old / "extra.txt").write_text("x")
+    video = Video(source=Path("a.mkv"), work_path=old)
+    old_uuid = video.uuid
+    new = tmp_path / "new"
+    refresh_video_identity(video, new)
+    assert video.uuid != old_uuid
+    assert video.work_path == new
+    assert (new / "extra.txt").read_text() == "x"
+    assert old.exists()
+
+
+def test_elided_label_does_not_force_width(qapp):
+    from fastflix.widgets.panels.queue_panel import ElidedLabel
+
+    long_text = "A very long video title " * 20
+    label = ElidedLabel(long_text)
+    assert label.minimumSizeHint().width() <= ElidedLabel.MIN_WIDTH
+    label.resize(120, 20)
+    label.show()
+    qapp.processEvents()
+    assert label.text() != long_text
+    assert label.text().endswith("\u2026")
+    assert label.fullText() == long_text
+
+
+def test_legacy_deinterlace_filters_map_to_presets():
+    from fastflix.widgets.panels.advanced_panel import deinterlace_presets, legacy_deinterlace_filters
+
+    assert legacy_deinterlace_filters["bwdif"] == ("bwdif", "send_frame")
+    assert legacy_deinterlace_filters["yadif=mode=1"] == ("yadif", "send_field")
+    assert legacy_deinterlace_filters["estdif=mode=1"] == ("estdif", "send_field")
+    for method, mode in legacy_deinterlace_filters.values():
+        assert mode in deinterlace_presets[method]
diff --git a/tests/test_program_downloads.py b/tests/test_program_downloads.py
new file mode 100644
index 00000000..0af25ef7
--- /dev/null
+++ b/tests/test_program_downloads.py
@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+import hashlib
+from unittest.mock import MagicMock
+
+import pytest
+
+from fastflix import program_downloads as pd
+from fastflix.exceptions import FastFlixError
+
+
+def asset(name, **extra):
+    return {"name": name, "browser_download_url": f"https://example.invalid/{name}", "size": 5000, **extra}
+
+
+def test_stable_picks_non_shared_numeric_latest():
+    assets = [
+        asset("ffmpeg-n8.9-latest-win64-gpl-8.9.zip"),
+        asset("ffmpeg-n8.10-latest-win64-gpl-8.10.zip"),
+        asset("ffmpeg-n8.10-latest-win64-gpl-shared-8.10.zip"),
+        asset("ffmpeg-n7.1-latest-win64-gpl-7.1.zip"),
+    ]
+    assert pd.select_stable_ffmpeg_asset(assets)["name"] == "ffmpeg-n8.10-latest-win64-gpl-8.10.zip"
+
+
+def test_stable_ignores_shared_only():
+    assert pd.select_stable_ffmpeg_asset([asset("ffmpeg-n8.0-latest-win64-gpl-shared-8.0.zip")]) is None
+
+
+def test_stable_empty():
+    assert pd.select_stable_ffmpeg_asset([]) is None
+
+
+def test_latest_picks_exact_static_build():
+    assets = [asset("ffmpeg-master-latest-win64-gpl-shared.zip"), asset("ffmpeg-master-latest-win64-gpl.zip")]
+    assert pd.select_latest_ffmpeg_asset(assets)["name"] == "ffmpeg-master-latest-win64-gpl.zip"
+
+
+def test_release_assets_rate_limit():
+    with pytest.raises(FastFlixError, match="rate limit"):
+        pd.release_assets({"message": "API rate limit exceeded for 1.2.3.4", "documentation_url": "x"})
+
+
+def test_release_assets_ok():
+    assert pd.release_assets({"assets": [1]}) == [1]
+
+
+def test_get_release_json_uses_timeout_and_raises(monkeypatch):
+    resp = MagicMock()
+    resp.json.return_value = {"assets": []}
+    get = MagicMock(return_value=resp)
+    monkeypatch.setattr(pd.requests, "get", get)
+    pd.get_release_json("https://api.github.com/x")
+    assert get.call_args.kwargs["timeout"]
+    resp.raise_for_status.assert_called_once()
+
+
+def test_expected_sha_from_digest_field():
+    a = asset("a.zip", digest="sha256:" + "ab" * 32)
+    assert pd.expected_sha256(a, [a]) == "ab" * 32
+
+
+def test_expected_sha_from_checksums_file(monkeypatch):
+    a = asset("a.zip")
+    sums = asset("checksums.sha256")
+    resp = MagicMock()
+    resp.text = f"{'cd' * 32} *a.zip\n{'ef' * 32}  b.zip\n"
+    monkeypatch.setattr(pd.requests, "get", MagicMock(return_value=resp))
+    assert pd.expected_sha256(a, [a, sums]) == "cd" * 32
+
+
+def test_expected_sha_missing(monkeypatch):
+    a = asset("a.zip")
+    assert pd.expected_sha256(a, [a]) is None
+
+
+def test_verify_sha256(tmp_path):
+    f = tmp_path / "x.bin"
+    f.write_bytes(b"hello")
+    good = hashlib.sha256(b"hello").hexdigest()
+    pd.verify_sha256(f, good.upper())
+    with pytest.raises(FastFlixError, match="checksum"):
+        pd.verify_sha256(f, "00" * 32)
+    pd.verify_sha256(f, None)  # warns, continues
+
+
+def test_download_file_cancel(tmp_path, monkeypatch):
+    resp = MagicMock()
+    resp.iter_content.return_value = [b"a" * 1024] * 3
+    monkeypatch.setattr(pd.requests, "get", MagicMock(return_value=resp))
+    dest = tmp_path / "f.bin"
+    assert pd.download_file("https://x", dest, lambda i: None, lambda: True) is False
+    assert not dest.exists()
+
+
+def test_download_file_ok(tmp_path, monkeypatch):
+    resp = MagicMock()
+    resp.iter_content.return_value = [b"a" * 1024] * 3
+    get = MagicMock(return_value=resp)
+    monkeypatch.setattr(pd.requests, "get", get)
+    dest = tmp_path / "f.bin"
+    assert pd.download_file("https://x", dest, lambda i: None, lambda: False) is True
+    assert dest.stat().st_size == 3072
+    assert get.call_args.kwargs["timeout"]
+    resp.raise_for_status.assert_called_once()
diff --git a/tests/test_rigaya_helpers.py b/tests/test_rigaya_helpers.py
new file mode 100644
index 00000000..45ce91f6
--- /dev/null
+++ b/tests/test_rigaya_helpers.py
@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+from subprocess import CompletedProcess, TimeoutExpired
+from unittest import mock
+
+from fastflix import rigaya_helpers
+from fastflix.rigaya_helpers import run_check_features
+
+
+def completed(returncode=0, stdout="#0: GPU (1 SM)\nCodec: H.264\n", stderr=""):
+    return CompletedProcess(args=[], returncode=returncode, stdout=stdout, stderr=stderr)
+
+
+def test_stderr_output_does_not_abort_device_detection():
+    """Warnings on stderr (very common with the encoder binaries) must not hide a working device."""
+    side_effect = [completed(stderr="some warning"), completed(stderr="another"), completed(returncode=1, stdout="")]
+    with mock.patch.object(rigaya_helpers, "run", side_effect=side_effect):
+        outputs = run_check_features("NVEncC64")
+    assert len(outputs) == 2
+
+
+def test_stops_at_first_failing_device():
+    side_effect = [completed(), completed(returncode=1, stdout=""), completed()]
+    with mock.patch.object(rigaya_helpers, "run", side_effect=side_effect) as run:
+        outputs = run_check_features("NVEncC64")
+    assert len(outputs) == 1
+    assert run.call_count == 2
+
+
+def test_timeout_is_passed_and_handled(caplog):
+    with mock.patch.object(rigaya_helpers, "run", side_effect=TimeoutExpired(cmd="x", timeout=1)) as run:
+        with caplog.at_level("WARNING", logger="fastflix"):
+            outputs = run_check_features("NVEncC64")
+    assert outputs == []
+    assert run.call_args.kwargs["timeout"] > 0
+    assert "NVEncC64" in caplog.text
+
+
+def test_missing_executable_is_logged(caplog):
+    with mock.patch.object(rigaya_helpers, "run", side_effect=FileNotFoundError("nope")):
+        with caplog.at_level("WARNING", logger="fastflix"):
+            assert run_check_features("NVEncC64", is_qsv=True) == []
+    assert "NVEncC64" in caplog.text
+
+
+def test_qsv_failure_returns_no_devices(caplog):
+    with mock.patch.object(rigaya_helpers, "run", return_value=completed(returncode=2, stdout="")):
+        with caplog.at_level("WARNING", logger="fastflix"):
+            assert run_check_features("QSVEncC64", is_qsv=True) == []
+    assert "QSVEncC64" in caplog.text
+
+
+def test_qsv_success_with_stderr():
+    with mock.patch.object(rigaya_helpers, "run", return_value=completed(stderr="warn")):
+        assert len(run_check_features("QSVEncC64", is_qsv=True)) == 1
diff --git a/tests/test_shared.py b/tests/test_shared.py
new file mode 100644
index 00000000..076d83ee
--- /dev/null
+++ b/tests/test_shared.py
@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+import shutil
+import subprocess
+
+import pytest
+
+from fastflix import shared
+from fastflix.shared import quoted_path, select_release, safe_release_url
+
+BS = "\\"
+
+
+@pytest.mark.parametrize(
+    "path,expected",
+    [
+        ("/My Videos/a.mkv", "/My Videos/a.mkv"),
+        ("a b.mkv", "a b.mkv"),
+        ("C:/Videos/a.mkv", "C" + BS + ":/Videos/a.mkv"),
+        ("C:" + BS + "Videos" + BS + "a.mkv", "C" + BS + ":" + BS * 2 + "Videos" + BS * 2 + "a.mkv"),
+        ("it's.mkv", "it'" + BS * 3 + "''s.mkv"),
+        ("  /x/a.mkv\n", "/x/a.mkv"),
+        ("a\r\nb.mkv", "ab.mkv"),
+        ("a\nb.mkv", "ab.mkv"),
+    ],
+)
+def test_quoted_path(path, expected):
+    assert quoted_path(path) == expected
+
+
+@pytest.mark.skipif(not shutil.which("ffmpeg"), reason="ffmpeg not installed")
+@pytest.mark.parametrize("name", ["/My Videos/a: b.cube", "C:" + BS + "My Videos" + BS + "it's a.cube", "x'y''z.cube"])
+def test_quoted_path_round_trips_through_ffmpeg(name):
+    filt = f"lut3d=file='{quoted_path(name)}'"
+    res = subprocess.run(
+        ["ffmpeg", "-hide_banner", "-f", "lavfi", "-i", "color=c=black:s=16x16:d=0.1", "-vf", filt, "-f", "null", "-"],
+        capture_output=True,
+        text=True,
+    )
+    assert f"{name}: No such file or directory" in res.stderr
+
+
+def rel(tag, prerelease=False, draft=False, assets=(), html="https://github.com/cdgriffith/FastFlix/releases/x"):
+    return {"tag_name": tag, "prerelease": prerelease, "draft": draft, "assets": list(assets), "html_url": html}
+
+
+def test_select_release_basic():
+    data = [rel("6.2.1"), rel("6.3.0"), rel("6.1.0")]
+    assert select_release(data)["tag_name"] == "6.3.0"
+
+
+def test_select_release_tolerates_odd_tags():
+    data = [rel("6.3.0-rc1"), rel("v6.3"), rel("nightly"), rel("6.2.1")]
+    assert select_release(data)["tag_name"] == "v6.3"
+
+
+def test_select_release_skips_prerelease_and_draft():
+    data = [rel("7.0.0", prerelease=True), rel("7.1.0", draft=True), rel("6.2.1")]
+    assert select_release(data)["tag_name"] == "6.2.1"
+
+
+def test_select_release_empty():
+    assert select_release([]) is None
+    assert select_release([rel("junk")]) is None
+
+
+def test_select_release_legacy_windows():
+    data = [rel("6.0.0"), rel("4.9.1"), rel("4.10.0")]
+    assert select_release(data, legacy_windows=True)["tag_name"] == "4.10.0"
+    assert select_release([rel("6.0.0")], legacy_windows=True) is None
+
+
+def test_safe_release_url():
+    assert safe_release_url("https://github.com/cdgriffith/FastFlix/releases/download/6.3.0/a.zip")
+    assert not safe_release_url("https://evil.example/cdgriffith/FastFlix/a.zip")
+    assert not safe_release_url("http://github.com/cdgriffith/FastFlix/a.zip")
+    assert not safe_release_url("https://github.com/cdgriffith/FastFlix.evil/a.zip")
+    assert not safe_release_url(None)
+
+
+def test_latest_fastflix_timeouts_and_bad_data(monkeypatch):
+    calls = {}
+
+    class Resp:
+        def raise_for_status(self):
+            pass
+
+        def json(self):
+            return []
+
+    def fake_get(url, timeout):
+        calls["timeout"] = timeout
+        return Resp()
+
+    monkeypatch.setattr(shared.requests, "get", fake_get)
+    monkeypatch.setattr(shared, "message", lambda *a, **k: calls.setdefault("msg", True))
+    shared.latest_fastflix(app=None, show_new_dialog=False)
+    auto_timeout = calls["timeout"]
+    shared.latest_fastflix(app=None, show_new_dialog=True)
+    assert auto_timeout < calls["timeout"]
diff --git a/uv.lock b/uv.lock
index 905e7d92..85e0afd0 100644
--- a/uv.lock
+++ b/uv.lock
@@ -187,6 +187,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" },
 ]
 
+[[package]]
+name = "execnet"
+version = "2.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bf/89/780e11f9588d9e7128a3f87788354c7946a9cbb1401ad38a48c4db9a4f07/execnet-2.1.2.tar.gz", hash = "sha256:63d83bfdd9a23e35b9c6a3261412324f964c2ec8dcd8d3c6916ee9373e0befcd", size = 166622, upload-time = "2025-11-12T09:56:37.75Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ab/84/02fc1827e8cdded4aa65baef11296a9bbe595c474f0d6d758af082d849fd/execnet-2.1.2-py3-none-any.whl", hash = "sha256:67fba928dd5a544b783f6056f449e5e3931a5c378b128bc18501f7ea79e296ec", size = 40708, upload-time = "2025-11-12T09:56:36.333Z" },
+]
+
 [[package]]
 name = "fastflix"
 source = { editable = "." }
@@ -222,6 +231,7 @@ dev = [
     { name = "pre-commit" },
     { name = "pyinstaller" },
     { name = "pytest" },
+    { name = "pytest-xdist" },
     { name = "ruff" },
     { name = "types-requests" },
     { name = "types-setuptools" },
@@ -262,6 +272,7 @@ dev = [
     { name = "pre-commit", specifier = ">=4.2.0" },
     { name = "pyinstaller", specifier = ">=6.13.0" },
     { name = "pytest", specifier = ">=9.0" },
+    { name = "pytest-xdist", specifier = ">=3.5" },
     { name = "ruff", specifier = ">=0.14" },
     { name = "types-requests", specifier = ">=2.32" },
     { name = "types-setuptools", specifier = ">=80.9" },
@@ -884,6 +895,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
 ]
 
+[[package]]
+name = "pytest-xdist"
+version = "3.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "execnet" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/78/b4/439b179d1ff526791eb921115fca8e44e596a13efeda518b9d845a619450/pytest_xdist-3.8.0.tar.gz", hash = "sha256:7e578125ec9bc6050861aa93f2d59f1d8d085595d6551c2c90b6f4fad8d3a9f1", size = 88069, upload-time = "2025-07-01T13:30:59.346Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ca/31/d4e37e9e550c2b92a9cbc2e4d0b7420a27224968580b5a447f420847c975/pytest_xdist-3.8.0-py3-none-any.whl", hash = "sha256:202ca578cfeb7370784a8c33d6d05bc6e13b4f25b5053c30a152269fd10f0b88", size = 46396, upload-time = "2025-07-01T13:30:56.632Z" },
+]
+
 [[package]]
 name = "python-box"
 version = "7.4.1"