tev HDR Viewer: Installation, Formats, and Inspection

Why tev Targets HDR Inspection Instead of Casual Photo Browsing

tev addresses users who need to examine image data rather than simply look at a finished picture. Its purpose is high dynamic range image viewing for people who care about color, but its documented controls go beyond opening and closing photographs. Images can arrive through a file dialog or by drag and drop. Once loaded, they can be selected, filtered, reloaded, closed, or compared against reference images.

The key distinction is tev's treatment of image structure. A conventional image viewer usually presents the final frame produced by a decoder. tev can load all layers and channels by default, or accept a request for a specific layer or channel. That makes it relevant to developers inspecting rendered files, image-format maintainers, photographers checking unusual output, and users comparing one image against another. The README also lists pixel inspection, histograms, tonemaps, error metrics, gain maps, auxiliary channels, animation, and metadata beyond EXIF and XMP.

A general-purpose desktop image browser is the better fit for someone who only wants an uncomplicated gallery. Its interface will usually center the composed image rather than its internal channels. tev is more specialized, and that specificity comes with a larger control surface. The documentation acknowledges this directly by saying that controls provide explanatory tooltips and that a keyboard-shortcut reference is available through the interface.

tev's Layer Selection and Channel Loading Path

tev exposes image selection through positional command-line arguments. The simplest invocation opens two named images:

$ tev foo.exr bar.exr

Both files are loaded through the same graphical application, after which one image can be selected with a left click. Right-clicking can designate a reference image for comparison. This arrangement supports a direct inspection loop: open the candidate and reference files, select them, and use the available comparison or error-analysis controls.

The more important mechanism is selective loading. The README says that all layers and channels are loaded by default. It also provides colon-prefixed selectors, allowing a named layer such as `depth` or a channel group such as `r,g,b` to be requested:

$ tev :depth foo.exr :r,g,b foo.exr bar.exr

That command requests the `depth` layer from the first `foo.exr` and the `r`, `g`, and `b` channels from the second `foo.exr` and from `bar.exr`. The syntax is valuable for layered formats because it avoids treating every embedded channel as part of the initial inspection set.

The repository layout includes source and header directories, dependency declarations, CMake configuration, and scripts. The README identifies external libraries for formats including OpenEXR and JPEG XL, plus jxrlib for JPEG XR. This supports the conclusion that codec-specific dependencies feed a common viewer rather than defining a separate application for each format. The documentation does not expose the complete internal rendering graph, so it does not support further claims about decoder scheduling or pixel buffer management.

Installing tev Through Packages and Prebuilt Files

Prebuilt downloads are available for all three named desktop platforms. Windows has an `.msi` installer and a portable `.exe`, Linux has an AppImage, and macOS has a `.dmg` installer. The README directs users to the latest release assets rather than requiring source compilation for normal installation.

Several package managers are also documented. The Arch User Repository uses `yay`, Homebrew and Flathub use their own commands, and Windows users can install through Scoop or WinGet. For example, Homebrew installs the cask with:

brew install tev

Linux users can install the Flathub package with:

flatpak install flathub io.github.tom94.tev

Windows users covered by the documented WinGet listing can use:

winget install Tom94.tev

Arch users can invoke the documented AUR helper as follows:

yay -S tev

The README does not state minimum system versions, package signing details, or whether every distribution package is built from the same source revision. Users choosing packages should therefore check the linked package page and the release artifacts they actually receive. Prebuilt installation is the clearest route for evaluating tev as an image viewer because it avoids managing CMake, platform libraries, and submodules.

Building tev and Running a First Selective Inspection

A source build requires CMake and a C++23-compatible compiler. GCC, Clang, and MSVC are supported. On x86, tev also requires NASM to generate optimized assembly. Many Linux distributions need development packages for Xorg, Wayland, OpenGL, and D-Bus. The documented Ubuntu or Debian dependency installation is:

$ apt-get install cmake libdbus-1-dev libffi-dev libglu1-mesa-dev libwayland-dev libxkbcommon-dev nasm wayland-protocols xorg-dev

The recursive clone is important because the build instructions explicitly request repository submodules:

$ git clone --recursive https://github.com/Tom94/tev

After entering the cloned directory, configure and compile the release build:

$ cmake. -B build -DCMAKE_BUILD_TYPE=Release
$ cmake --build build --config Release -j

Install the result with:

$ cmake --install build

The reader should see a desktop viewer rather than a terminal-only conversion result. The README also documents argument discovery through the following command:

$ tev -h

It does not document a non-interactive export command. tev is therefore a visual inspection tool in this workflow, not a documented batch transcoder. The source build is practical for contributors or users whose target platform lacks a suitable binary, but it creates a larger setup burden than package installation.

TCP Control for Renderers and Custom Front Ends

Beyond its local interface, tev provides a simple TCP protocol for remote control. The `--host` argument selects the IP and port on which tev listens. The default is `127.0.0.1:14158`, so a client on the same machine can connect without tev being exposed directly to other network interfaces. The README presents renderer integration, including pbrt version 4, as one possible use.

The protocol supports concrete image operations. `OpenImage` opens a path on the machine running tev. `CreateImage` creates a named image from a size and channel set, overwriting an existing image with the same name. `UpdateImage` modifies a rectangular pixel region, `CloseImage` removes an image, `ReloadImage` reads a path again, and `VectorGraphics` draws over an existing image.

Each packet has a fixed framing structure:

[uint32_t total_length_in_bytes][byte operation_type][byte[] operation_specific_payload]

Integers use little-endian encoding. The README points to `src/Ipc.cpp`, specifically `IpcPacket::set*`, as the source for packet assembly examples. It also documents existing C++, Python, and Rust clients. The Python client can be installed with:

pip install tevclient

This feature is a concrete reason to choose tev over a basic viewer when a renderer needs to send images into an interactive inspection session. The drawback is operational responsibility. The documentation gives no authentication or authorization layer, so deployment decisions must be based on the actual listener address and network environment rather than assumptions about remote access.

Format Scope, Licensing, and Maintenance Boundaries

The documented format list includes OpenEXR, JPEG XL with gain maps, and JPEG XR for examples such as HDR screenshots from Windows and Xbox. Repository topics also name AVIF, DDS, DNG, HEIC, HEIF, JXL, JXR, PNG, RAW, TIFF, and WebP. Those topic labels are not equivalent to a documented compatibility guarantee, so the listed format section and current release behavior should be checked before depending on a particular codec.

tev is licensed under GPL-3.0. That identifier matters for organizations considering redistribution or integration, although this article does not provide legal advice. The README does not document a separate commercial license or describe a relicensing process. A team that cannot distribute a GPL-covered desktop binary should resolve its licensing requirements before redistribution.

The repository is not archived. Its last push was on 2026-10-03, and the release history includes v2.14.0 on 2026-08-23, v2.13.1 on 2026-07-07, and v2.13.0 on 2026-07-02. These facts indicate recent repository activity, but they do not establish compatibility across every platform or codec in the topic list. Native application upgrades may also require users or packagers to replace the binary and its bundled dependencies rather than apply a small library update inside an existing product.

Where tev Is the Wrong Tool

tev is the wrong choice when the requirement is a minimal viewer for ordinary photographs. Its strength comes from layers, channel selection, color profiles, comparison, metrics, and metadata inspection. A user who does not need those capabilities may find the interface more complicated than necessary.

It is also a poor match for automated image conversion because the documented workflow opens a graphical viewer. Although `UpdateImage` and `CreateImage` allow external clients to send image data, the README does not present tev as a command-line conversion or rendering pipeline. Projects needing a headless batch encoder should not infer one from its image libraries or network operations.

The source build is another boundary. A C++23-compatible compiler, CMake, NASM on x86, and several Linux development packages can complicate deployment. Existing users of another viewer may also have no requirement for tev's remote protocol and should not expose the TCP listener without understanding its network scope. Finally, the repository does not provide a complete per-format compatibility table or a documented rollback procedure for package releases. Those gaps matter more to adoption decisions than the README's broad format topic labels.

Editorial conclusion

Adopt tev when image inspection requires HDR metadata, named layers, individual channels, comparison against reference images, or control from a rendering workflow. Do not choose it solely as a lightweight replacement for an ordinary photo viewer, because the dense inspection interface and optional build dependencies add complexity. Before adoption, verify codec support on the target operating systems, review the local TCP listener if network control is unnecessary, and confirm that distribution of a GPL-3.0 application fits the intended deployment.

Frequently asked questions

Official sources

1. Issues
2. License: GPL-3.0
3. README
4. Releases
5. Tom94/tev on GitHub