Score encodes against a reference with VMAF on the GPU, then see exactly where they differ.
Per-frame curves for many encodes at once, a frame-exact synced viewer, and a difference heatmap.

Download · Features · Build · CLI · Docs

Features

Scoring

• GPU-first VMAF. Every score runs through libvmaf_cuda when the GPU and ffmpeg allow it, with automatic CPU fallback. Two GPU scores run at once (900 frames of 1080p in about 1.6 s on an RTX 5060 Ti).
• VMAF NEG by default, so sharpening and contrast tricks do not buy points. Standard and 4K models are one click away, and mixing models in one comparison is flagged.
• Pooled stats that matter: mean, harmonic mean, p1, min, max and σ, plus the true video bitrate from the packet index (no audio or container overhead).

Comparing

• Many encodes, one reference. Overlaid per-frame curves in a colourblind-safe palette, a table with mean, p1 and bitrate, Δ-to-baseline and smoothing.
• Frame-exact viewer: side by side, wipe with a draggable divider, A/B flicker, or an amplified difference heatmap with luma/chroma channels and auto gain. Zoom and pan stay locked across panes.
• Fast stepping: ←/→ steps, scrubs and plays smoothly thanks to a keyframe walk that skips frames nobody sees and a byte-budgeted frame cache (benchmarks).

Workflow

• Drag and drop with explicit roles. Drop on Reference or Compare (or anywhere for the automatic rule). Folders, paste, startup arguments and "Open With" follow the same rules.
• Live job queue. Rows appear immediately and move through probe → index → score, with per-row progress, re-score, reveal-in-folder and remove.
• Honest about what it did: backend and precision (CUDA·8b when a 10-bit source was converted on the GPU), colour metadata warnings, resolution/fps/frame-count mismatch warnings, and a session log.
• Portable. On Windows the release is one VideoQuality.exe with ffmpeg bundled, and settings live in settings.json beside it.

Screenshots

Wipe: drag the divider between reference and encode.	Difference: amplified error heatmap with auto gain.
Scoring: per-row progress, two GPU jobs at a time.	Side by side: five encodes, NEG model, CUDA backend.

Download

Windows 10/11 (x64): grab VideoQuality-<version>-win-x64.zip from Releases, unzip anywhere, and run VideoQuality.exe. Nothing else to install. For GPU scoring you need an NVIDIA GPU (Turing or newer) and its driver; without one, scoring runs on the CPU.

VideoQuality.exe      the app (single file)
settings.json         your settings, created on first change
ffmpeg\               FFmpeg 9 + libvmaf 3.2.1 (CUDA), LGPL build
tools\vq.exe          command-line tool
licenses\             third-party notices

Linux (x86-64): grab VideoQuality-<version>-linux-x64.tar.gz, then:

tar -xzf VideoQuality-0.1.0-linux-x64.tar.gz
cd VideoQuality-0.1.0-linux-x64
./VideoQuality                    # run it
./install-desktop-entry.sh        # optional: add to the application menu and "Open With"

Same layout as Windows, with ffmpeg and libvmaf (CUDA) bundled. It runs on any distro with glibc 2.35 or newer (Ubuntu 22.04+, Debian 12+, Fedora 36+, …) and needs no extra packages; verified on a stock Ubuntu 22.04. GPU scoring uses the NVIDIA driver you already have.

Quick start

1. Drop a reference (lossless or high-bitrate is best) onto the left zone.
2. Drop one or more encodes, or a folder of them, onto the right zone.
3. Watch them score, then click a row to inspect it: step with ←/→, switch modes with the segmented control, hold F to flicker, scroll to zoom, drag to pan.

Keys	Action
← / → (+ Shift)	step 1 (10) frames
Space	play / pause
F (hold)	flicker to the encode
Ctrl+O / Ctrl+Shift+O	open reference / add encodes
Ctrl+V	paste files or paths
Ctrl+R	re-score the selected encode

Build from source

Requirements: .NET 10 SDK and FFmpeg 9.x (libavcodec.so.63 / avcodec-63.dll) built with --enable-libvmaf (plus libvmaf with CUDA and --enable-ffnvcodec for GPU scoring, and --enable-libdav1d for AV1 on the CPU path). The bindings are FFmpeg.AutoGen 9.0.1.1, and the app refuses to start against a different libavcodec major.

git clone https://github.com/SeaAndStars/VideoQuality.git
cd VideoQuality
dotnet build VideoQuality.slnx

# reference first, then any number of encodes (or start empty and drop files)
dotnet run --project VideoQuality.App -- ref.mkv encode-a.mp4 encode-b.mp4

The app finds a VMAF-enabled ffmpeg automatically: a bundled ffmpeg/ folder, $VQ_FFMPEG, ffmpeg on PATH if it has libvmaf, $FFMPEG_ROOT/bin, /opt/ffmpeg/bin, or C:\ffmpeg\bin. The resolved path is shown in Settings.

Release packages. The bundled FFmpeg is LGPL with cuda-llvm, so both releases are redistributable. Windows is cross-compiled with mingw-w64. Linux is built in an Ubuntu 22.04 container for glibc 2.35 compatibility and self-tested:

./scripts/build-ffmpeg-windows.sh          # FFmpeg n9.0.2 + libvmaf v3.2.1 CUDA + dav1d → ~/build-win/stage
./scripts/build-ffmpeg-linux-docker.sh     # the same for Linux, in Docker            → ~/build-linux/stage
VQ_VERSION=0.1.0 ./scripts/package.sh win-x64      # → artifacts/VideoQuality-0.1.0-win-x64.zip
VQ_VERSION=0.1.0 ./scripts/package.sh linux-x64    # → artifacts/VideoQuality-0.1.0-linux-x64.tar.gz

Command line

vq probe                                          # ffmpeg, libvmaf, CUDA and libav detection
vq score ref.mkv dist.mp4 --json out.json --csv out.csv [--gpu|--cpu] [--model vmaf_v0.6.1]
vq frame dist.mp4 42 --ppm frame.ppm              # decode one frame exactly as the viewer does
vq diag                                           # environment report for bug reports

From source, replace vq with dotnet run --project VideoQuality.Cli --.

Performance

Measured with the BenchmarkDotNet suite in VideoQuality.Benchmarks (Ryzen 7 9700X, 1080p H.264):

	Before	After
10 backward frame steps	931 ms	80 ms
10 random slider jumps	352 ms	270 ms
Difference image	45 ms	5 ms
Auto-gain percentile	31 ms	4.6 ms
60 frames, reference + encode	202 ms	90 ms
Two 1080p CUDA scores	5.4 s	3.5 s

Documentation

Guide	Contents
Usage	UI tour, drop rules, compare modes, keyboard and mouse, settings, CLI
FFmpeg + CUDA	Building ffmpeg with libvmaf_cuda on Linux and for Windows, GPU policy, 10-bit, troubleshooting
Architecture	Projects, data flow, threading, decoding, jobs, ingest
Metrics	What VMAF measures, frame pairing, bitrate, interpreting stats
Development	Build, tests, benchmarks, verification, repository layout, roadmap

Built with

Avalonia 12 with Semi.Avalonia and Ursa · Fluent System Icons · ScottPlot · FFmpeg.AutoGen · FFmpeg · libvmaf · dav1d

Status

Verified on Ubuntu 26.04 (CUDA 13.1) and Windows 10, RTX 5060 Ti: 8-bit and 10-bit scoring, H.264/HEVC/AV1, all compare modes, multi-encode comparison, with identical CPU scores on both platforms. 64 tests (60 unit/ABI, 4 integration that run when VQ_TEST_VIDEO points at a clip).

Not yet: rate-distortion plots and BD-rate, worst-frame navigation, graph hover tooltips, score caching, resolution-mismatch scaling, frame-offset control, colour-matrix-aware RGB conversion (mismatches are warned), an in-app log panel, and single-instance "Open With" forwarding. See the roadmap.

License

MIT; see LICENSE. Release packages bundle FFmpeg under the LGPL 2.1+ and other third-party components under their own licenses, listed in licenses/THIRD-PARTY-NOTICES.txt inside each release.