Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

rega

rega is an image browser and viewer that runs in the terminal. It is made for renders: multi-layer OpenEXR files and sequences, plus TIFF, PNG, JPEG, MOV and MP4.

rega (reh-GAH, /rʲɛˈɡɐ/): Lithuanian for “sight”.

Use it on your own machine, or on one you reach through a terminal, such as a farm node or a remote workstation: log in there with ssh from Ghostty or kitty, run rega on that machine, and the images show in your terminal. Or run rega --gui for a window of its own, no terminal needed.

Where to start

  1. Install rega on your machine, and on any remote machine whose renders you want to look at.
  2. Terminal setup: check your terminal (and tmux, if you use it) with rega --doctor.
  3. The tutorial: rega --tutorial walks you through sample images.

After that, rega browses the current folder and rega render.exr opens one image. ? lists every key.

Then the guide follows the screen, in the same order as the ? list: the browser, the viewer and its panes. Each page starts with a clip of the feature, a TL;DR and its keys. The reference lists every command-line option and every key.

The clips use the tutorial’s images, so you can follow along: run rega --tutorial and press the keys shown in the corner of each clip.

What it does

  • Browse folders with a live preview. Numbered frames collapse into one sequence (shot.####.exr). Filter by typing, and mark images in any folder to open together.
  • View one image, a sequence with a playbar, every layer (AOV) side by side, or several images tiled.
  • Compare two versions: A, B and |A − B| side by side, plus the header rows that differ.
  • Inspect pixel values (Nuke coordinates), per-channel statistics, NaN and inf pixels, and the data window against the display window.
  • Colour through your OpenColorIO config ($OCIO) or OCIO’s built-in ACES configs: display, view, look and each image’s input colour space.
  • Annotate with burn-in text, filled in from each frame’s header ([#owner], [#@frame]).
  • Follow a render: new frames appear as they’re written, and a half-written EXR shows what’s there.

Reading the keys

  • h j k l move left, down, up and right, as in the vim editor. The arrow keys work too.
  • A capital letter means Shift: E is Shift+e, and e and E do different things.
  • gg means press g twice.
  • Ctrl+d and Ctrl+click mean hold Ctrl.
  • ? lists every key for the screen you’re on. Type to search it (a pane’s name finds that pane’s keys); ? or Esc closes the list.
  • q goes back one screen. Q quits rega from anywhere.

How images are drawn

In Ghostty and kitty, images are full resolution, also through tmux and ssh. Every other terminal shows half-blocks, a coarser picture (side by side). Terminal setup has the details. The window is always full resolution.

Install

Tip

TL;DR curl -fsSL https://raw.githubusercontent.com/Elyg/rega/main/scripts/install.sh | bash puts rega in ~/.local/bin, on your machine or on a remote one.

rega runs where the renders are. For renders on your own machine, install it there. For renders on a remote machine, ssh in and run the install line there too.

Linux and macOS

curl -fsSL https://raw.githubusercontent.com/Elyg/rega/main/scripts/install.sh | bash

The script downloads the latest release:

  • Linux (x86_64, aarch64): a fully static binary. It runs on any distribution and needs no libraries.
  • macOS: the Apple Silicon build.

To pin a release or pick another folder, set these for bash:

curl -fsSL https://raw.githubusercontent.com/Elyg/rega/main/scripts/install.sh \
  | REGA_VERSION=0.0.16 REGA_BIN_DIR=~/bin bash

Run the same line again to update.

Nix

nix run github:Elyg/rega -- shots/       # try it
nix profile install github:Elyg/rega    # install it

Home Manager (flake)

# flake.nix
inputs = {
  rega.url = "github:Elyg/rega";   # latest main, or "github:Elyg/rega/v0.0.16" to pin
  rega.inputs.nixpkgs.follows = "nixpkgs";
};

# home.nix (pass `inputs` through extraSpecialArgs)
home.packages = [ inputs.rega.packages.${pkgs.stdenv.hostPlatform.system}.default ];

# or with the overlay:
nixpkgs.overlays = [ inputs.rega.overlays.default ];
home.packages = [ pkgs.rega ];

Note

There is no binary cache yet, so the first Nix install builds rega from source. Its dependencies come from the nixpkgs cache.

Check it

rega --version
rega --doctor     # can this terminal show images? See Terminal setup

If rega --version says “command not found”, ~/.local/bin isn’t on your PATH. Add export PATH="$HOME/.local/bin:$PATH" to ~/.bashrc (or ~/.zshrc) and open a new terminal.

Build from source

See Build from source in the README: a Nix dev shell provides everything, then just build.

Terminal setup

Run rega --doctor first: it checks your terminal and tmux, and says what to add.

$ rega --doctor
rega doctor
  ✓ terminal     TERM=tmux-256color TERM_PROGRAM=tmux tmux client=xterm-ghostty
  ✓ tmux         version 3.8
  ✓ passthrough  allow-passthrough on
  ✓ cell size    13x28 px
  ✓ truecolor    tmux client has RGB
  ✓ clipboard    set-clipboard on
  · graphics     kitty
  · transfer     file: pixels go through temp files, not the pty

What rega needs depends on your terminal app and on what runs between it and rega. tmux keeps terminal sessions alive and splits them into panes; if you don’t use it, skip the tmux sections.

Ghostty or kitty: just works

flowchart LR
  T[Ghostty / kitty] --> R[rega]
  T2[Ghostty / kitty] --> S[ssh] --> R2[rega]

Other terminals: half-blocks

iTerm2, WezTerm, Warp, Konsole, Alacritty, foot, GNOME Terminal, xterm, Windows Terminal, Terminal.app, VS Code and zellij show half-blocks: each character cell shows two pixels, one above the other. Everything else works the same.

Full resolution on the left (Ghostty), half-blocks on the right.

tmux: one line in tmux.conf

flowchart LR
  T[terminal] --> X["tmux<br/>allow-passthrough on"] --> R[rega]
  T2[terminal] --> S[ssh] --> X2["remote tmux<br/>allow-passthrough on"] --> R2[rega]

In every tmux between the terminal and rega, add to ~/.tmux.conf, then tmux source-file ~/.tmux.conf:

tmux.confWhat for
set -g allow-passthrough onimages (needed)
set -as terminal-features ',xterm*:RGB'true colour
set -g set-clipboard ony copies reach the clipboard

Use tmux 3.8 or later: 3.7 drops images in split panes.

tmux, then ssh: add –graphics kitty

When tmux runs on your machine and you ssh from inside it, rega on the remote can’t ask your terminal what it supports. Tell it:

flowchart LR
  T[terminal] --> X["local tmux<br/>allow-passthrough on"] --> S[ssh] --> R["rega --graphics kitty"]
  T2[terminal] --> X2["local tmux<br/>allow-passthrough on"] --> S2[ssh] --> X3["remote tmux<br/>allow-passthrough on"] --> R2["rega --graphics kitty"]

--graphics kitty skips the check, so a missing setting leaves images blank instead of falling back to half-blocks. (--graphics halfblock forces half-blocks.)

Over ssh

Images go through the ssh connection. While a sequence plays, rega paces them to what the link carries, so a pause stops the picture at once instead of after a backlog drains. It measures the link as it plays: from the terminal’s answers to a query sent after each frame, or, inside tmux on the remote host, from the bytes tmux sent your client. Until measured it assumes --link-rate (4M a second); --link-rate 0 turns pacing off. Playback frames are sized to fit the link, so CG with flat areas plays sharper than grainy footage.

Frames played over ssh stay in the terminal (up to --terminal-cache, 256M by default), so rega shows them again without sending any pixels. It stores them ahead too: paused on a sequence, it sends the play range’s frames while the link is idle, so playback starts from the terminal; playing, it stays ahead of the playhead. On the playbar, frames the terminal keeps are cyan, frames only decoded (in rega) green; the status bar shows both caches, cache remote … local …. Playback frames are sized so the whole range fits in under half of it, when that is sharper than what the link carries in real time: the view before a pan or a zoom stays kept too (dim cyan on the playbar), and plays from the terminal again when you go back. Kitty and Ghostty keep 320 MB of images by default; to keep more frames, raise theirs (Ghostty: image-storage-limit, at most 4 GiB) and --terminal-cache with it (e.g. 3.9G). S shows the link, what a frame costs and what both caches hold. How the pixels travel (shared memory, temp files or inline) is chosen for you by the default, --transfer auto; set --transfer yourself only if images stay blank (see Command line).

The window

Tip

TL;DR rega --gui opens rega in a window of its own: the same keys and panes, no kitty or Ghostty needed. With nothing to open it starts on a screen to open files, a folder, pasted paths or a recent one. Drop files on it, Ctrl+V paths, drag to pan.

rega --gui              # the start screen
rega --gui shots/       # the browser, in that folder
rega --gui render.exr   # the viewer

Everything in this guide works the same in the window, keys and panes alike. Pictures are always full resolution, playback too (P still caps it when a sequence can’t keep up).

Note

The window comes with the Nix package and with source builds. The static Linux binary from the install script is terminal-only. On Windows, rega.exe is always the window.

Start screen

  Open files…
  Open a folder…
  Browse ~/renders
  Tutorial

  Paste paths…
    comp.exr            ~/renders/v002                 ×
    comp.exr            ~/renders/v003                 ×
                        [ Open (2) ]

  Recent
  shot.####.exr         ~/renders/sq010            2 h ago
  plates/               ~                         3 days ago
  • Open files… and Open a folder… show the system’s dialogs.
  • Browse opens the browser where it was last left. q in the browser comes back here.
  • Tutorial renders the tutorial’s images (the first time) and starts its tour.
  • Paste paths…: Ctrl+V adds each pasted line to the list; a types one (Enter adds it). Paths from a file manager (file://…), quoted ones and ~ are fine; patterns like shot.####.exr open as sequences. Missing ones show red. Open (n) opens them together, as marks do in the browser: n / p step, t tiles.
  • Recent: a click puts an item in that list (again: out), Shift+click a range, a double click opens it on its own. x forgets one.

Keys

Start screen

KeyDoes
oopen images or movies (the system’s dialog)
fopen a folder
bbrowse: the file browser, where it was left
tthe tutorial: a tour on sample images
Ctrl+Vpaste paths, one a line: listed to open together
atype a path (Enter adds it, Esc done)
x Xremove the selected path / clear the list
1 … 9open a recent one again
click spacea recent one into the list (again: out)
Shift+click J Ka range of them into the list
double-clicka recent one: open it at once
j/k ↑/↓move (the pointer too)
Enteropen what is selected
xa recent one: forget it
q / Qquit

Window

KeyDoes
Ctrl+Oopen images or movies (the system’s dialog)
Ctrl+Shift+Oopen a folder
dropfiles or folders on the window: open them
q (browser)back to the start screen (Q quits)
Ctrl+Ccopy: the path (browser, image), the rows (2, 4)
Ctrl+Fsearch the keys (in ? too)
Ctrl+Vpaste: into what is typed, else paths to open
Ctrl+= / -bigger / smaller text
Ctrl+0text size back to the default
F11full screen
on macOS, ⌘ works as Ctrl here

Mouse

  • Drop files or folders anywhere on the window to open them.
  • Drag to pan: the right or middle button anywhere, the left one on a still or on tiles. The picture follows the pointer; tiles still rendering show as boxes.
  • Wheel over the image or tiles zooms by as much as you turn: smoothly on a touchpad.
  • Shift+click / Ctrl+click in the browser mark a range / one more.
  • Drag a file in the files pane to sort the list.
  • Click a selected row in the metadata pane again, or below the rows, to unselect.

Ctrl+C copies: the path in the browser and the viewer, the selected rows in the metadata and inspector panes. Ctrl+V pastes into what you type, else opens the paths. On macOS ⌘ works as Ctrl.

What it keeps

PathWhat
~/.local/state/rega/windowsize, text size, the browser’s last folder
~/.local/state/rega/recentthe start screen’s recent items

On Windows they’re in %LOCALAPPDATA%\rega.

First launch

The app isn’t notarized (macOS) or signed (Windows) yet, so the system asks once:

  • macOS: open it, then System Settings → Privacy & Security → Open Anyway.
  • Windows: SmartScreen’s More info → Run anyway.

First run: the tutorial

Tip

TL;DR rega --tutorial renders sample images into ~/.cache/rega/tutorial and opens them with a guide card in the corner. F1 hides the card, F2 skips a step, F3 goes back one. Q quits.

rega --tutorial

The first run renders the images (a few seconds); later runs open them straight away. In the window, the start screen’s Tutorial does the same. rega opens in the browser, on the tutorial folder. A card in the bottom-right corner gives one step at a time. Each step names its keys; they turn green as you press them, and the step ticks off when all of them are done.

The steps go: move in the browser, open and play the sequence, step and scrub, set in and out points, step through the layers, tile them, switch channels, change exposure, read a pixel, go back to the browser, then the HDR sky, the broken render and several images at once.

KeyDoes
F1hide / show the card
F2skip a step
F3back one step
Qquit rega

On a Mac keyboard, the F keys may need Fn. The card starts from the first step each time.

The images

Every image explains itself in its comments attribute: open the metadata pane (2) to read it. The same list is in README.txt next to them.

FileWhat it showsTry
shot.####.exrframes 1001-1100 at 24 fps; layers rgba (R G B A, plus depth Z), N, albedo, diffuse, mask, specularspace to play, [ ], t
wip.####.exra render still being written: frames 1006-1008 and 1015 missing, the last one cut shortopen it, space to play, G
chart.exra colour chart over a linear grey wedgeCtrl+click a patch
chart-v2.exrthe chart with two patches changedin the browser, space on chart.exr and on this one, then d
hdr-sky.exrvalues far above 1E to stop down
luma-ramp.exra single channel (Y)y / Y gamma, s view transform off
beachball.exra data window (a box around a beach ball) inside the display windoww
nan-inf.exrNaN and inf pixels!

Every clip in this guide uses these images, so you can follow along.

Browser

Tip

TL;DR j / k move with a live preview, l or Enter opens, h goes up. / filters. space marks images in any folder; Enter then views them, t tiles them, d compares them. cc copies the path. Esc clears the filter, then the marks.

rega with no arguments, or with a folder, starts here:

rega            # the current folder
rega shots/     # another one

Three columns, like the column view in the macOS Finder: the parent folder on the left, the current folder in the middle, and a preview of the selected entry (the row under the cursor) on the right. Images preview at full resolution; text files show their first lines.

┌ parent ──┬ current ─────────────────────┬ preview ─────────┐
│ renders  │ ≋ shot.####.exr [1001-1100]  │                  │
│ ▸ shots  │ ▪ chart.exr                  │   (the image)    │
│          │ ▪ hdr-sky.exr                │                  │
└──────────┴──────────────────────────────┴──────────────────┘

Keys

Browser

KeyDoes
j/k ↑/↓move
h/l ←/→parent / enter dir or view image
gg / Gtop / bottom
/fuzzy filter (Enter keep, Esc clear)
eexpand sequence into frames / collapse
.toggle hidden files
spacemark (view marked together)
amark every image here (again: unmark)
tview tiled: the marked side by side
ddiff the marked in pairs (one marked: with this)
clickselect (double: open) / parent dir
Shift / Ctrl+clickmark a range / mark one more
cc cdcopy path / folder (marked: all of them)
cf cncopy file name / name without extension
ochoose → –chooser-file, quit
q / Qquit

q quits from the browser. Q quits rega from anywhere.

Moving around

j / k (or the arrows) move, gg / G jump to the top and bottom. l, → or Enter goes into a folder or opens an image in the viewer; h or ← goes back up. On a text file, l moves into the preview to scroll it.

With the mouse: a click selects, a double-click opens, a click in the parent column goes there. Drag the column dividers to resize them.

In the window, q goes back to the start screen instead of quitting.

. shows hidden files.

Filter

/ starts a fuzzy filter over the current folder: type, and only the matches stay. Enter keeps the filter and goes back to moving; Esc clears it.

Sequences

Numbered frames collapse into one entry: shot.1001.exr … shot.1100.exr becomes ≋ shot.####.exr [1001-1100], with the total size. Gaps show in the range ([1001-1005,1009-1014,1016-1024]). Two frames make a sequence; a lone numbered file stays a file.

e expands the selected sequence into its frames, and folds them back.

Note

The listing follows the disk: new files and frames appear as they’re written. A half-written EXR previews as an incomplete image.

Marks

Marking picks images to open together, like a selection that stays as you move between folders. space marks the selected image (again: unmarks it); a marks every image in the folder (again: unmarks them). Marked rows show in yellow, in the order you marked them. Esc clears every mark (after the filter, if one is set). With the mouse, Shift+click marks the images from the selected row to the clicked one, Ctrl+click marks or unmarks one (many terminals keep Shift+click for themselves; the window doesn’t).

With marks, Enter or l on any image opens the marked images, not the one under the cursor:

  • Enter views them one at a time: n / p step between them.
  • t opens them in a tiled view.
  • d compares them in pairs: the 1st with the 2nd, the 3rd with the 4th, … With one marked, d compares it with the selected image.

Copying paths

c, then a second key, copies to the clipboard: the marked entries, one per line, or the selected one when nothing is marked.

KeysCopies
ccthe full path
cdthe folder it’s in
cfthe file name
cnthe name without its extension

A sequence copies as its frame pattern, /renders/shot.####.exr, which Nuke and other viewers read as is. The bottom line shows what was copied. The copy works over ssh and in tmux the same way as y in the panes (see Copying).

Picking files for other tools

rega can act as a file picker. With --chooser-file FILE, o writes paths to FILE, one per line, and quits: the marked images, or the selected entry when nothing is marked (a sequence as its first frame). Enter still opens the viewer.

rega --chooser-file /tmp/picked shots/ && cat /tmp/picked

--cwd-file FILE writes the folder you were in when you quit, so a shell function can follow you there:

re() {
  local f; f=$(mktemp)
  rega --cwd-file "$f" "$@"
  cd "$(cat "$f")" && rm -f "$f"
}

Viewer

Tip

TL;DR Enter on an image in the browser, or rega render.exr, opens the viewer. Its keys come in groups: Image (zoom, layers, several images), Compare, Sequence (playback) and Display (channels, exposure). 2-6 open the panes. ? lists every key, q goes back to the browser, Q quits.

rega render.exr                 # one image
rega 'shot.####.exr'            # a sequence (quote the #s)
rega a.exr b.exr c.exr          # several: n / p step between them
rega --diff v1.exr v2.exr       # A, B and |A − B|

The screen

┌ [1] shot.1042.exr  rgba (1/6)  RGBA  960×540  🔍 fit ─────────────┐
│ layers ┐                                         ┌ inspector      │
│ colour │                the image                │ metadata       │
│ files  ┘                                         └                │
├ 1001 ───────────────▲──────────────────── 1100    24.00  24.0 fps ┤
└ space play  [ ] layer  2 meta  3 files  ? help  q back ───────────┘
  • Top line: which open image ([1], its number in the files pane) and its name, the layer shown, its channels, the resolution and the zoom (🔍 fit, 🔍 200%).
  • The image, fitted to the terminal at first.
  • Panes, when open: layers, colour and files on the left; inspector and metadata on the right. See Panes.
  • Playbar, for a sequence: frame numbers, the playhead, in and out points and the playback rate. See Sequence.
  • Bottom line: the keys that matter most right now.

Sequences on the command line

To open a sequence, give a pattern instead of one frame. Put it in single quotes so the shell passes it to rega unchanged:

PatternMatches
'shot.####.exr'shot.1001.exr … (each # one digit)
'shot.#.exr'any padding: a lone # finds it
shot.*.exr* works too, unquoted: the shell lists the frames for rega

A plain frame path (shot.1001.exr) opens just that frame.

Leaving

Viewer: Leaving the viewer

KeyDoes
q / Escback to browser
Qquit rega

Image

Tip

TL;DR + / - zoom, hjkl pans, f fits, z shows 1:1. [ / ] step through the layers; t tiles them. With several images open, n / p step between them and t tiles the images instead. Ctrl+click picks a pixel for the inspector.

Zoom and pan

+ / - or the mouse wheel zoom. f fits the image to the area the open panes leave; z shows it 1:1, one image pixel to one screen pixel. hjkl or the arrows pan, HJKL pan faster; right-drag (or middle-drag) pans with the mouse.

Keys

Viewer: Image

KeyDoes
[ / ]previous / next layer (AOV)
n / p (N)next / previous image (marked files)
diff: next / previous pair (A, B, |A - B|)
+ / - / wheelzoom
f / zfit / 1:1
hjkl ←↓↑→ HJKLpan (shift = faster)
right dragpan (middle button too; left on a still or tiles)
ttiles: all layers, or all marked images
+- wheel hjkltiles: zoom / pan the tiled view (f fit, z 1:1)
clickselect tile / focus pane
dragpane edges: width; files title: height
Enter (tile)open the selected tile
Tlayer name on the image (tiles: each tile’s;
tiled files numbered: [1] name, [2] name, …)
Ctrl+clickpick colour
[x, y] as in Nuke: from the bottom-left

Layers

An EXR’s channels group into layers (AOVs) by their prefix, up to the last dot: diffuse.R, diffuse.G, diffuse.B make the layer diffuse. Every channel without a prefix (R G B A, a Z, a lone Y) goes into the first layer, rgba; the other layers follow alphabetically. [ / ] step through them, and the top line shows which one is up (rgba (1/6)). T writes the layer’s name on the image.

t tiles every layer side by side: the quickest way to see what a render wrote. The top line names the selected tile; T writes each tile’s name on it. In the tiled view, + / - and the wheel zoom all the tiles together, hjkl or a drag pans, f fits and z goes 1:1. Click a tile to select it; Enter opens it on its own. t again, or q, goes back to one image.

The layers pane (5) lists them all.

Several images

Open several images (marked in the browser, or named on the command line) and n / p step between them. t tiles the images instead of the layers; there T numbers each name ([1] comp.exr, [2] comp.exr), for versions that differ only by folder. Small tiles keep the number and the end of the name, or just the number.

The files pane (3) lists what’s open: show, reorder or drop images there. To compare two versions, see Compare.

Picking a pixel

Ctrl+click a pixel to pick it: the inspector (4) lists every channel of the layer shown there. To read another layer, step to it ([ / ]) and pick again, or tile the layers (t) and Ctrl+click in a tile. Coordinates are [x, y] as in Nuke, counted from the bottom-left.

Labels

path:label=SLOT:TEXT on the command line puts a line of text on that image. See Labels from the command line.

Incomplete images

A render that’s still writing, or a file cut short, shows what’s there: the strips that were written, the rest black, and incomplete image in the top-right corner. Once the file is complete on disk, the viewer reloads it.

Compare

Tip

TL;DR rega --diff v1.exr v2.exr, or mark two images in the browser and press d. You get A, B and |A − B|: whatever changed lights up. Click the difference tile and 2 lists the header rows that differ.

Starting a comparison

rega --diff v1.exr v2.exr
rega --diff a1.exr b1.exr --diff a2.exr b2.exr   # several pairs: n / p

Or in the browser: mark two images and press d. More marked pair up in order (1st with 2nd, 3rd with 4th, …); with one marked, d compares it with the selected image.

The three tiles

A comparison opens as a tiled view: A and B on top, |A − B| below. The difference is per channel, so everything that changed lights up and the rest stays black. Under it, max Δ 0.0213 gives the largest difference, or identical.

The three tiles zoom and pan together, as in any tiled view. n / p go to the next and previous pair.

KeyDoes
d (browser)compare the marked images in pairs
n / pnext / previous pair
click a tileselect it; Enter opens it on its own
2the metadata pane: on the difference tile, the rows that differ

The header rows that differ

Click the difference tile to select it, then open the metadata pane (2): it compares A’s header with B’s and lists only the rows that differ. d there shows both headers whole, and back. With A or B selected, the pane shows that image’s header.

Labels on each side

Name each side so the tiles say which is which:

rega --diff v1.exr:label=bl:old v2.exr:label=bl:new

See Labels from the command line.

Sequence

Tip

TL;DR space plays and pauses. , / . step one frame, < / > jump to the first and last, : goes to a frame number. I / O set the in and out points (again: clear). G switches missing frames between skip and hold (show the nearest).

A sequence gets a playbar under the image. It shows:

  • the frame numbers, with the playhead over the current frame;
  • the bar, green where frames are decoded and ready;
  • the playback rate.

Keys

Viewer: Sequence

KeyDoes
spaceplay / pause
, . < >step frame / first, last
:go to frame (file number, nearest)
Gmissing frames: skip / hold the nearest (timing)
I / Oin / out point here (again: clear)
playback loops in to out; , . < > stay inside
left dragscrub (on the image or the playbar)
playbarclick: go to frame, wheel: step
Fcycle playback fps
Pplayback: capped resolution (keeps up) / full res
the window plays at full res until P caps it
Sstats: link, picture cost, caches (anywhere)

Playing

space plays and pauses. Playback runs at the file’s rate (framesPerSecond in the EXR header, or a movie’s own), else 24. F cycles the rate through 12, 23.976, 24, 25, 30, 48 and 60 fps. The playbar shows the target rate and, while playing, the rate actually reached.

Frames are never dropped: when the next one isn’t decoded yet, playback waits for it and the measured rate drops. While playing, rega reads ahead as many frames as fit in 60% of the cache (--cache, 4G by default), shared between the open sources, 2 to 96 frames each.

P switches how playback renders:

  • default: below full resolution, so playback keeps up. Pausing sharpens the frame.
  • full: every frame at full resolution, as fast as rega can.

Moving through frames

Key / mouseDoes
, / .one frame back / forward
< / >first / last frame
:type a frame number; Enter goes there (the nearest when it’s missing)
left-dragscrub, on the image or the playbar
click / wheel on the playbargo to a frame / step

Frame numbers are the files’ own (1001), not counted from zero. A movie’s start at 1.

In and out

I sets the in point at the current frame, O the out point; press it again on the same frame to clear it. Playback then loops from in to out, and , . < > stay inside. The bar is thinner outside the range.

Missing frames and renders in progress

A sequence with gaps (frames not rendered yet, or failed) plays one of two ways; G switches between them:

  • skip (default): missing frames are left out, so playback goes from one existing frame to the next.
  • hold: a frame for every number from first to last; a missing one shows the nearest that exists, so the timing stays right.

rega watches the folders it shows. New frames join an open sequence as they’re written, and a frame that changes on disk is decoded again. A frame still being written shows as an incomplete image until it’s done. Point rega at a render’s output folder and leave it open.

Note

Over ssh, playback is paced to the link, measured as it plays, so it doesn’t back up. See Over ssh.

Movies

.mov and .mp4 files open like a sequence: the same playbar, keys, in and out points, cache and --diff, with frames numbered from 1. In the browser a movie is one file, even when its name ends in a number, so take_v001.mov and take_v002.mov stay two takes.

Going anywhere is frame-accurate, including backwards. In a long-GOP codec (H.264, HEVC) a jump decodes forward from the keyframe before it, so it takes a moment on a heavy file; intra codecs such as ProRes jump straight there.

rega reads H.264, HEVC, ProRes, DNxHD and DNxHR, Motion JPEG, MPEG-2, MPEG-4 Part 2, VP9, PNG, QuickTime Animation and uncompressed video. An alpha channel shows as A, and a clip recorded on its side is turned upright. Metadata lists the codec, pixel format, colour tags and the file’s own tags.

What it doesn’t do:

  • No sound. Audio tracks are ignored.
  • No AV1. A file in a codec rega doesn’t read says so in place of the picture.
  • No HDR. Colour goes by the matrix and range tags, and the code values are then treated as sRGB like a PNG’s, whatever the transfer tag says: a PQ or HLG clip looks washed out rather than tone-mapped.
  • Non-square pixels are shown as stored. Metadata lists the pixelAspect.
  • A variable frame rate plays at its average. Every frame is shown, evenly spaced.
  • e doesn’t expand a movie in the files pane: its frames have no files.

Display

Tip

TL;DR c shows colour; r g b a show one channel as grey; u shows luma. e / E change exposure by half a stop, y / Y change gamma, 0 resets the display. s turns the view transform off and on. w outlines the display and data windows. ! paints NaN and inf pixels. B changes the backdrop.

The display settings change how the image looks, never the file. They stay as you step between images and frames.

Keys

Viewer: Display

KeyDoes
c r g b a ucolour / R / G / B / alpha / luma
e / Eexposure +/- 0.5 stop
y / Ygamma +/- 0.1
sview transform (sRGB / OCIO view) / raw
woutlines: display + data window / display window / off
w (tiles)selection / windows + selection / windows / off
!paint NaN (magenta) / inf (cyan) pixels
0reset the display (exposure, gamma, channel, …)
Bbackdrop: grey / black / checker (alpha over it)
Ashow / hide annotations

Channels

KeyShows
ccolour (all channels)
r g bone channel, as grey
aalpha, as grey
uluma

A layer with a single channel (luma-ramp.exr’s Y, a depth layer) shows as grey.

Exposure and gamma

E stops down half a stop, e brightens half a stop; y / Y change the gamma by 0.1. Values above 1 (an HDR sky, a hot specular) clip to white until you stop down.

0 resets the display: exposure, gamma and channel, and it turns the view transform back on, and outlines and NaN painting off.

View transform

The image goes through a view transform to the screen: plain sRGB, or your OCIO display and view when a config is in use (see the colour pane). s turns it off to show the raw values, and back on.

Outlines

An EXR has two rectangles:

  • the display window: the area the image is meant to show (Nuke’s format);
  • the data window: where the pixels actually are (Nuke’s bounding box).

They often match. When the data window reaches past the display window, that part is overscan; when it’s smaller, the rest of the display window simply has no pixels.

The clip shows beachball.exr from the tutorial, after the OpenEXR docs’ example: the data window is a box around a beach ball, inside the display window, and the rest of the display window has no pixels (black). w cycles the outlines:

  1. display window, plus the data window (dashed)
  2. display window only
  3. none (where it starts)

In a tiled view the selected tile is outlined from the start; there w cycles the selection, the windows plus the selection, the windows, none.

NaN and inf

! paints NaN pixels magenta and infinite ones cyan, so a broken render shows where it broke. The inspector counts them per layer; step through the layers ([ / ]) to find the one that broke.

Backdrop

B cycles what shows around the image:

  1. grey, the screen’s own (where it starts)
  2. black, the whole view
  3. checker, a checkerboard; transparent pixels show it through their alpha

It holds for the viewer, tiles and the browser’s preview, 0 leaves it, and rega remembers it next time.

Annotations

A shows or hides the annotations, the burn-in text over the image. Hiding keeps them.

Panes

Tip

TL;DR 2-6 open the metadata, files, inspector, layers and colour panes and focus them; the same key again closes a focused pane. 1 focuses the image, Tab hides every pane and brings them back.

Keys

Viewer: Panes

KeyDoes
2 3 4 5 6metadata / files / inspector / layers / colour
m o/x i /the same, as letters
open + focus; again while focused closes
1focus the image
Tabhide all panes / bring them back

The panes

The viewer’s panes, by number:

KeyAlsoPaneShowsWhere
2mMetadatathe header: attributes and layersright
3o / xFilesthe open sources and their annotationsbottom left
4iInspectorpixel values and layer statisticsright, above metadata
5/Layersevery layer; the cursor picks the one shownleft
6ColourOCIO config, display, view, look, input colour spaceleft

The keys in the Also column open their pane only when the focused pane doesn’t use that key itself: in the inspector x clears the pick, and in the metadata pane / filters.

Focus

A pane opens focused: its keys (j / k, y to copy, …) go to it. Keys it doesn’t use fall through to the viewer, so exposure, playback and the rest still work while a pane is focused.

  • The pane’s number again closes it.
  • 1 focuses the image, leaving the panes open, so j / k and the other keys act on the image again.
  • Tab hides every pane at once, and brings them back.
  • A click on a pane focuses it.

Panes cover the image

Panes are drawn over the image, so opening or closing one never moves or refits the image. f fits the image into the space the open panes leave; Tab hides them all for a clear view. (A tiled view is laid out beside the panes instead.)

Resizing panes

Drag a pane’s edge to change its width. The files pane sits at the bottom: drag its title up to show more rows.

Copying

The metadata and inspector panes share y (copy the line) and Y (copy just the value); in the metadata pane, v starts selecting lines. The copy goes to the system clipboard: in tmux through tmux’s buffer (set -g set-clipboard on passes it to the terminal), otherwise straight through the terminal, which Ghostty and kitty allow.

Metadata (2)

Tip

TL;DR 2 (or m) shows the current frame’s header: its parts, attributes and layers. / filters it, y / Y copy a line or just its value. On a comparison it lists only what differs.

Keys

Viewer: Metadata (2)

KeyDoes
j k gg Gmove (Ctrl+d / Ctrl+u half a page)
wheel { }scroll
/ clickfilter (Esc clear) / move there
v dragselect rows (Ctrl+click: to there)
clickthe selected row again, or below the rows: none
y Ycopy line / value
ddiff tile: differences / both whole

What it shows

The header of the frame on screen:

  • its path;
  • each part, with every attribute and its value (compression, dataWindow, framesPerSecond, comments, the renderer’s own);
  • each layer and its channels.

As you step or play, it shows each frame’s header. (rega --dump prints the same, with types: see below.)

Moving and filtering

j / k move, gg / G jump to the ends, Ctrl+d / Ctrl+u move half a page; the wheel or { / } scroll. The row under the cursor expands to show its whole value.

/ filters. A row stays when its name fuzzy-matches what you type, or its value contains it; matching rows stay under their part. Enter keeps the filter, Esc clears it.

Copying

y copies the line (name: value), Y only the value. v selects lines from the cursor; a mouse drag or Ctrl+click selects rows too. Then y / Y copy them all. A click on the selected row again, or below the rows, unselects.

On a comparison

Select the difference tile of a comparison: the pane compares A’s header with B’s and lists only the rows that differ. d toggles between those and both headers whole.

From the command line

$ rega --dump shot.1001.exr
shot.1001.exr  [exr]
fps: 24

part 0
  channels (chlist): A(half), B(half), G(half), N.X(half), …
  compression (compression): zip
  dataWindow (box2i): [0, 0]-[959, 539]  960x540
  …

layers:
  rgba: R(half) G(half) B(half) A(half) Z(half)
  N: X(half) Y(half) Z(half)
  …

Files (3)

Tip

TL;DR 3 (or o / x) lists what’s open. j / k move, Enter shows that source, J / K reorder, d drops one, e expands a sequence into frames. l goes into a row’s annotations.

Keys

Viewer: Files (3)

KeyDoes
j k Entermove / show that source
J / K dmove it down / up, drop it
draga file up or down the list: it moves there
esequence ⇄ its frames (up to 500)
l / hinto a row’s annotations / back
D Dclear all annotations (in a row: its own)

Sources

The files pane, at the bottom left, lists the viewer’s sources. A source is one entry in this list: a single image, or a whole sequence. j / k move the cursor; Enter (or a click) shows the source under it.

J / K move a source down or up the list, or drag it with the mouse. The list’s order is also the order of the tiled view and of n / p. d drops a source from the viewer.

e turns a sequence into one source per frame (up to 500), for example to tile frames side by side, and back.

Annotations

Above the files sits a global row: annotations there go over every image. Each row shows how many annotation lines it has; l goes into a row’s lines and h comes back out. D D clears every annotation (inside a row: just its own).

Drag the pane’s title up to show more rows.

Inspector (4)

Tip

TL;DR 4 (or i) opens the inspector. It reads the pixel under the mouse as it moves. Ctrl+click picks a pixel and lists every channel of the layer shown; x clears the pick. Below that: each channel’s min, max and average, with a warning for NaN and inf.

Keys

Viewer: Inspector (4)

KeyDoes
Ctrl+clickpick a pixel (in the image)
j k y Ymove, copy line / value
xclear the pick

Under the mouse

The top of the pane reads the pixel under the mouse as it moves: its position and its values, each number in its channel’s colour. Positions are [x, y] as in Nuke, counted from the bottom-left of the display window. A ≈ means the value was read from a reduced resolution (while playing, or zoomed out on a big image).

The picked pixel

Ctrl+click picks a pixel; a red ring marks it while the inspector is open. The pane lists the pixel’s channels in the layer it was picked in, plus its colour on screen and its luma. To read another layer, step to it ([ / ]) and pick again, or tile the layers (t) and pick in a tile. j / k move over the rows, y copies a line, Y a value, x clears the pick.

Layer statistics

For the layer on screen: each channel’s minimum, maximum and average. Under the title, a count for the whole layer (12 NaN · 3 inf px, also on the top line). The title shows a badge (NaN, inf) when the pixel under the mouse, or the picked one, holds such a value. ! paints them on the image: see NaN and inf.

Layers (5)

Tip

TL;DR 5 (or /) lists the image’s layers; moving the cursor, or clicking a row, shows that layer.

Keys

Viewer: Layers (5)

KeyDoes
j k gg G clickshow that layer

The list

Every layer of the current image, with its channels: rgba first, then the rest alphabetically. j / k move and show each layer as you go, the same as [ / ] in the viewer.

How channels group into layers, and t to tile them all: see Layers in the viewer.

Colour (6)

Tip

TL;DR 6 opens the colour pane: j / k pick a row, h / l change it, Enter picks from a list. With $OCIO set, rega shows images through that config. Without it, images are plain sRGB, or you pick a built-in ACES config in the first row. For ACEScg renders under a built-in config, set the input row to ACEScg (why).

Keys

Viewer: Colour (6)

KeyDoes
j kmove between the rows
h / l Enterchange the row / pick from a list

The rows

RowWhat
config$OCIO (when set), OCIO’s built-in configs (ACES studio and CG), the config in use, or none (plain sRGB)
displaythe config’s displays (sRGB, Rec.1886, P3, …)
viewthe display’s views (ACES 1.0 / 2.0 SDR, Un-tone-mapped, Raw, …)
lookthe config’s looks, or none
inputthe input colour space of the source shown

j / k move between rows, h / l step a row’s value, Enter opens a fuzzy list of its values (configs can have dozens of colour spaces): type to filter, Enter picks. In the config row’s list you can also type the path to a config file and press Enter.

“Plain sRGB” means linear values go through the sRGB curve, like Nuke’s default sRGB viewer.

Input colour space

By default the config’s file rules decide each image’s input colour space, from its path (a studio config often maps render folders or extensions to a space). rega doesn’t read a colour space from the EXR header. The input row overrides the rules for the source shown (a whole sequence), for this session.

Integer images (PNG, JPEG, 8- or 16-bit TIFF, and movies) are already display-encoded. rega decodes them from their sRGB codes once, so the input colour space applies to those codes and the curve isn’t applied twice.

File values and shown values

The inspector always reads the file’s own values (scene-linear, in the input colour space) plus the colour shown on screen. s in the viewer turns the view transform off to show the raw values on the image too, and back on; see Display.

ACES

With your studio’s config. Point $OCIO at it, as for Nuke:

export OCIO=/studio/config/config.ocio
rega shots/

rega then shows its displays, views and looks, and its file rules pick each image’s input colour space, the same as in the other apps reading that config.

Without one. OCIO comes with two ACES configs built in, nothing to download:

Config rowWhat it is
OCIO studio config (ACES, built in)ocio://studio-config-latest: the full set of ACES colour spaces, displays and views
OCIO CG config (ACES, built in)ocio://cg-config-latest: a smaller set for CG work

Pick one in the config row (6, then h / l on the first row); rega remembers it for next time. The display defaults to the config’s default display (sRGB for the built-in ones), and the view to its default for that display, the ACES SDR output transform.

Warning

The built-in configs’ file rules read every image as ACES2065-1 (AP0). Renders are usually ACEScg (AP1): Arnold, Karma, RenderMan and V-Ray in an ACES setup all write it. Shown as ACES2065-1, an ACEScg render looks slightly off in hue and saturation. Set the input row to ACEScg (Enter, type acescg, Enter). That holds for this session; for good, use a config whose file rules say ACEScg for your renders.

What’s remembered

rega remembers the config you picked last, and per config its display, view and look, in ~/.local/state/rega/colour. $OCIO, when set, wins at start-up.

Speed

The transform is baked into a 3D LUT, so an ACES 2.0 view costs the same per pixel as plain sRGB, and sequences play at full speed through it.

Annotations

Tip

TL;DR Burn-in text over the image. Press 3, move to global (every image) or a source, press l. On a slot, a adds a line: type it, Enter keeps it. [#@frame] and [#owner] fill in per frame. A in the viewer hides them all.

Keys

Inside a row of the files pane (3, then l):

Viewer: Annotations (3, then l)

KeyDoes
a A Enter dadd below / above, edit, delete
J / K g / sreorder, to global / source
Tab ↑↓ Ctrl+ntyping: next slot, history, [#key] / [#@key]

Slots and sets

Each image has six slots, the places a line can sit: tl tc tr along the top (left, centre, right), bl bc br along the bottom. A slot holds any number of lines; top slots stack downwards, bottom slots upwards.

Lines live in one of two sets:

  • global: over every image.
  • per source: one set for each row of the files pane. A sequence is one source, so its lines go over all its frames.

In each slot the global lines come first, then the source’s. In a tiled view, the global lines go once over the whole tiled view (filled in from the selected tile) and each tile shows its own source’s lines.

Text sits on the image, inside the display window, on a darkened patch of the image’s own colour, so it reads over any image. It moves with zoom and pan like a real burn-in.

Note

Panes are drawn over the image’s sides, so while the files pane is open it covers the left slots. A centre slot (tc, bc) stays in view while you edit.

Adding a line

  1. Open the files pane: 3.
  2. Move to global (the row above the files) or to a source, and press l to go into its set: all six slots, with their lines.
  3. Move to a slot with j / k and press a. Type the line in the bottom bar; the image shows it as you type. Enter keeps it, Esc drops it.

On a line, a adds a line below it and A above it; on a slot’s own row, a (or Enter) adds one at the end of that slot. Enter on a line edits it, d deletes it, J / K move it, and g / s move it to the global set or the source’s. h goes back to the file list.

While typing: Tab jumps to the next slot, ↑ / ↓ recall lines typed before, and Ctrl+n completes a [#… placeholder from the frame’s header.

D D in the file list clears every annotation; inside a set, just that set.

Placeholders

PlaceholderBecomes
[#key]header attribute key of the frame, e.g. [#owner], [#comments]
[#@file]the frame’s file name, shot.1042.exr
[#@frame]the frame number (empty for a single image)
[#@layer]the layer shown
[#@res]the resolution, 1920x1080
[#@fps]the playback rate
[#@date]today, YYYY-MM-DD

They fill in per frame and per tile. A key the header doesn’t have stays as typed, dimmed ([#ownr]), so a typo shows.

Kept between sessions

Annotations are saved when you quit and come back next time, with the recall history, in ~/.local/state/rega/annotations.

Labels from the command line

A :label= on an image path puts a line on that image for this run, with the same slots and placeholders:

rega 'shot.####.exr:label=tl:[#@frame]'  'v2.exr:label=bottom:client notes'
rega --diff v1.exr:label=bl:old v2.exr:label=bl:new

The slot is one of tl tc tr bl bc br, or top / bottom for the centre ones. Labels aren’t part of the sets above and aren’t saved, but A hides them too.

Command line

rega [OPTIONS] [paths...]

Paths

ArgumentOpens
(none)the browser, in the current folder
shots/the browser, in that folder
render.exrthe viewer, on that image
'shot.####.exr'the viewer, on the sequence (each # one digit)
'shot.#.exr'the sequence, whatever its padding
a.exr b.exr …the viewer, on all of them (n / p step)
a.exr:label=top:mainthe image, with a label

Quote patterns with # so the shell leaves them alone. A plain frame path (shot.1001.exr) opens just that frame.

Options

OptionDoes
--diff A Bcompare A with B: A, B and |A − B| tiled. Repeat for more pairs; paths can carry labels. See Compare
--dump FILEprint the layers, channels and metadata, then exit
--doctorcheck the terminal and tmux setup for images and copy, then exit (1 if a check fails). See Terminal setup
--guiopen in a window of its own instead of the terminal (not in the static Linux binary; on Windows always)
--tutorialrender the sample images into ~/.cache/rega/tutorial (first run) and open them with a guide. See tutorial
--graphics MODEauto (default), kitty or halfblock. See setup
--transfer MODEhow kitty images reach the terminal: auto (default) picks shm (shared memory) locally outside tmux, file (temp files) in tmux, direct (inline) over ssh. Change it only if images stay blank
--link-rate SIZEbytes a second the ssh link is assumed to carry until measured, e.g. 20M; playback sending images inline is paced to the link (default 4M, 0: unpaced, unmeasured)
--terminal-cache SIZEterminal image memory frames played over ssh may keep there, e.g. 512M: a loop’s second pass sends no pixels (default 256M, under kitty’s and Ghostty’s 320 MB; 0: off)
--cache SIZEmemory for decoded images, e.g. 8G or 512M (default 4G, at least 64M)
--chooser-file FILEo in the browser writes the chosen paths to FILE and exits. See picking files
--cwd-file FILEon exit, write the last folder to FILE
--versionprint the version and licence notice
-h, --helpprint the options

Files rega keeps

PathWhat
~/.cache/rega/tutorial/the tutorial’s images
~/.local/state/rega/annotationsannotations, between sessions
~/.local/state/rega/colourthe colour choices, per config
~/.local/state/rega/backdropthe backdrop
~/.local/state/rega/windowthe window’s size, text size and last folder
~/.local/state/rega/recentthe window’s recent items

$XDG_CACHE_HOME and $XDG_STATE_HOME move them. They, and the log (~/.cache/rega/rega.log, or $REGA_LOG), name the files viewed, so rega creates them readable by their owner only.

Environment

VariableEffect
OCIOthe OpenColorIO config to show images through
REGA_LOCAL_ONLY1: for sites where images must stay on the machine holding them. rega refuses to run over ssh, where frames and copied text go to the terminal’s machine, and never copies to the terminal’s clipboard (in tmux, copies stay in tmux’s buffer)
REGA_MAX_MEGAPIXELSthe largest frame rega will load, in megapixels (default 1024); a file’s header can claim any size
LC_TERMINALnames the terminal behind a tmux on the other side of ssh (ghostty, kitty): turns kitty graphics on there

Keys reference

Every key, as the ? overlay lists it. In the overlay, type to search.

Browser

KeyDoes
j/k ↑/↓move
h/l ←/→parent / enter dir or view image
gg / Gtop / bottom
/fuzzy filter (Enter keep, Esc clear)
eexpand sequence into frames / collapse
.toggle hidden files
spacemark (view marked together)
amark every image here (again: unmark)
tview tiled: the marked side by side
ddiff the marked in pairs (one marked: with this)
clickselect (double: open) / parent dir
Shift / Ctrl+clickmark a range / mark one more
cc cdcopy path / folder (marked: all of them)
cf cncopy file name / name without extension
ochoose → –chooser-file, quit
q / Qquit

Viewer: Image

KeyDoes
[ / ]previous / next layer (AOV)
n / p (N)next / previous image (marked files)
diff: next / previous pair (A, B, |A - B|)
+ / - / wheelzoom
f / zfit / 1:1
hjkl ←↓↑→ HJKLpan (shift = faster)
right dragpan (middle button too; left on a still or tiles)
ttiles: all layers, or all marked images
+- wheel hjkltiles: zoom / pan the tiled view (f fit, z 1:1)
clickselect tile / focus pane
dragpane edges: width; files title: height
Enter (tile)open the selected tile
Tlayer name on the image (tiles: each tile’s;
tiled files numbered: [1] name, [2] name, …)
Ctrl+clickpick colour
[x, y] as in Nuke: from the bottom-left

Viewer: Sequence

KeyDoes
spaceplay / pause
, . < >step frame / first, last
:go to frame (file number, nearest)
Gmissing frames: skip / hold the nearest (timing)
I / Oin / out point here (again: clear)
playback loops in to out; , . < > stay inside
left dragscrub (on the image or the playbar)
playbarclick: go to frame, wheel: step
Fcycle playback fps
Pplayback: capped resolution (keeps up) / full res
the window plays at full res until P caps it
Sstats: link, picture cost, caches (anywhere)

Viewer: Display

KeyDoes
c r g b a ucolour / R / G / B / alpha / luma
e / Eexposure +/- 0.5 stop
y / Ygamma +/- 0.1
sview transform (sRGB / OCIO view) / raw
woutlines: display + data window / display window / off
w (tiles)selection / windows + selection / windows / off
!paint NaN (magenta) / inf (cyan) pixels
0reset the display (exposure, gamma, channel, …)
Bbackdrop: grey / black / checker (alpha over it)
Ashow / hide annotations

Viewer: Panes

KeyDoes
2 3 4 5 6metadata / files / inspector / layers / colour
m o/x i /the same, as letters
open + focus; again while focused closes
1focus the image
Tabhide all panes / bring them back

Viewer: Metadata (2)

KeyDoes
j k gg Gmove (Ctrl+d / Ctrl+u half a page)
wheel { }scroll
/ clickfilter (Esc clear) / move there
v dragselect rows (Ctrl+click: to there)
clickthe selected row again, or below the rows: none
y Ycopy line / value
ddiff tile: differences / both whole

Viewer: Files (3)

KeyDoes
j k Entermove / show that source
J / K dmove it down / up, drop it
draga file up or down the list: it moves there
esequence ⇄ its frames (up to 500)
l / hinto a row’s annotations / back
D Dclear all annotations (in a row: its own)

Viewer: Inspector (4)

KeyDoes
Ctrl+clickpick a pixel (in the image)
j k y Ymove, copy line / value
xclear the pick

Viewer: Layers (5)

KeyDoes
j k gg G clickshow that layer

Viewer: Colour (6)

KeyDoes
j kmove between the rows
h / l Enterchange the row / pick from a list

Viewer: Annotations (3, then l)

KeyDoes
a A Enter dadd below / above, edit, delete
J / K g / sreorder, to global / source
Tab ↑↓ Ctrl+ntyping: next slot, history, [#key] / [#@key]

Viewer: Leaving the viewer

KeyDoes
q / Escback to browser
Qquit rega

Window

KeyDoes
Ctrl+Oopen images or movies (the system’s dialog)
Ctrl+Shift+Oopen a folder
dropfiles or folders on the window: open them
q (browser)back to the start screen (Q quits)
Ctrl+Ccopy: the path (browser, image), the rows (2, 4)
Ctrl+Fsearch the keys (in ? too)
Ctrl+Vpaste: into what is typed, else paths to open
Ctrl+= / -bigger / smaller text
Ctrl+0text size back to the default
F11full screen
on macOS, ⌘ works as Ctrl here

Start screen

KeyDoes
oopen images or movies (the system’s dialog)
fopen a folder
bbrowse: the file browser, where it was left
tthe tutorial: a tour on sample images
Ctrl+Vpaste paths, one a line: listed to open together
atype a path (Enter adds it, Esc done)
x Xremove the selected path / clear the list
1 … 9open a recent one again
click spacea recent one into the list (again: out)
Shift+click J Ka range of them into the list
double-clicka recent one: open it at once
j/k ↑/↓move (the pointer too)
Enteropen what is selected
xa recent one: forget it
q / Qquit