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
- Install rega on your machine, and on any remote machine whose renders you want to look at.
- Terminal setup: check your terminal (and tmux, if you use it) with
rega --doctor. - The tutorial:
rega --tutorialwalks 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
hjklmove left, down, up and right, as in the vim editor. The arrow keys work too.- A capital letter means Shift:
Eis Shift+e, andeandEdo different things. ggmeans pressgtwice.Ctrl+dandCtrl+clickmean hold Ctrl.?lists every key for the screen you’re on. Type to search it (a pane’s name finds that pane’s keys);?orEsccloses the list.qgoes back one screen.Qquits 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 | bashputsregain~/.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.conf | What for |
|---|---|
set -g allow-passthrough on | images (needed) |
set -as terminal-features ',xterm*:RGB' | true colour |
set -g set-clipboard on | y 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 --guiopens 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.exeis 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.
qin 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;
atypes one (Enteradds it). Paths from a file manager (file://…), quoted ones and~are fine; patterns likeshot.####.exropen as sequences. Missing ones show red. Open (n) opens them together, as marks do in the browser:n/pstep,ttiles. - Recent: a click puts an item in that list (again: out), Shift+click a range,
a double click opens it on its own.
xforgets one.
Keys
Start screen
| Key | Does |
|---|---|
o | open images or movies (the system’s dialog) |
f | open a folder |
b | browse: the file browser, where it was left |
t | the tutorial: a tour on sample images |
Ctrl+V | paste paths, one a line: listed to open together |
a | type a path (Enter adds it, Esc done) |
x X | remove the selected path / clear the list |
1 … 9 | open a recent one again |
click space | a recent one into the list (again: out) |
Shift+click J K | a range of them into the list |
double-click | a recent one: open it at once |
j/k ↑/↓ | move (the pointer too) |
Enter | open what is selected |
x | a recent one: forget it |
q / Q | quit |
Window
| Key | Does |
|---|---|
Ctrl+O | open images or movies (the system’s dialog) |
Ctrl+Shift+O | open a folder |
drop | files or folders on the window: open them |
q (browser) | back to the start screen (Q quits) |
Ctrl+C | copy: the path (browser, image), the rows (2, 4) |
Ctrl+F | search the keys (in ? too) |
Ctrl+V | paste: into what is typed, else paths to open |
Ctrl+= / - | bigger / smaller text |
Ctrl+0 | text size back to the default |
F11 | full 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
| Path | What |
|---|---|
~/.local/state/rega/window | size, text size, the browser’s last folder |
~/.local/state/rega/recent | the 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 --tutorialrenders sample images into~/.cache/rega/tutorialand opens them with a guide card in the corner.F1hides the card,F2skips a step,F3goes back one.Qquits.
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.
| Key | Does |
|---|---|
F1 | hide / show the card |
F2 | skip a step |
F3 | back one step |
Q | quit 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.
| File | What it shows | Try |
|---|---|---|
shot.####.exr | frames 1001-1100 at 24 fps; layers rgba (R G B A, plus depth Z), N, albedo, diffuse, mask, specular | space to play, [ ], t |
wip.####.exr | a render still being written: frames 1006-1008 and 1015 missing, the last one cut short | open it, space to play, G |
chart.exr | a colour chart over a linear grey wedge | Ctrl+click a patch |
chart-v2.exr | the chart with two patches changed | in the browser, space on chart.exr and on this one, then d |
hdr-sky.exr | values far above 1 | E to stop down |
luma-ramp.exr | a single channel (Y) | y / Y gamma, s view transform off |
beachball.exr | a data window (a box around a beach ball) inside the display window | w |
nan-inf.exr | NaN and inf pixels | ! |
Every clip in this guide uses these images, so you can follow along.
Browser
Tip
TL;DR
j/kmove with a live preview,lorEnteropens,hgoes up./filters.spacemarks images in any folder;Enterthen views them,ttiles them,dcompares them.cccopies the path.Escclears 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
| Key | Does |
|---|---|
j/k ↑/↓ | move |
h/l ←/→ | parent / enter dir or view image |
gg / G | top / bottom |
/ | fuzzy filter (Enter keep, Esc clear) |
e | expand sequence into frames / collapse |
. | toggle hidden files |
space | mark (view marked together) |
a | mark every image here (again: unmark) |
t | view tiled: the marked side by side |
d | diff the marked in pairs (one marked: with this) |
click | select (double: open) / parent dir |
Shift / Ctrl+click | mark a range / mark one more |
cc cd | copy path / folder (marked: all of them) |
cf cn | copy file name / name without extension |
o | choose → –chooser-file, quit |
q / Q | quit |
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:
Enterviews them one at a time:n/pstep between them.topens them in a tiled view.dcompares them in pairs: the 1st with the 2nd, the 3rd with the 4th, … With one marked,dcompares 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.
| Keys | Copies |
|---|---|
cc | the full path |
cd | the folder it’s in |
cf | the file name |
cn | the 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
Enteron an image in the browser, orrega render.exr, opens the viewer. Its keys come in groups: Image (zoom, layers, several images), Compare, Sequence (playback) and Display (channels, exposure).2-6open the panes.?lists every key,qgoes back to the browser,Qquits.
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:
| Pattern | Matches |
|---|---|
'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
| Key | Does |
|---|---|
q / Esc | back to browser |
Q | quit rega |
Image
Tip
TL;DR
+/-zoom,hjklpans,ffits,zshows 1:1.[/]step through the layers;ttiles them. With several images open,n/pstep between them andttiles the images instead.Ctrl+clickpicks 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
| Key | Does |
|---|---|
[ / ] | previous / next layer (AOV) |
n / p (N) | next / previous image (marked files) diff: next / previous pair (A, B, |A - B|) |
+ / - / wheel | zoom |
f / z | fit / 1:1 |
hjkl ←↓↑→ HJKL | pan (shift = faster) |
right drag | pan (middle button too; left on a still or tiles) |
t | tiles: all layers, or all marked images |
+- wheel hjkl | tiles: zoom / pan the tiled view (f fit, z 1:1) |
click | select tile / focus pane |
drag | pane edges: width; files title: height |
Enter (tile) | open the selected tile |
T | layer name on the image (tiles: each tile’s; tiled files numbered: [1] name, [2] name, …) |
Ctrl+click | pick 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 pressd. You get A, B and |A − B|: whatever changed lights up. Click the difference tile and2lists 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.
| Key | Does |
|---|---|
d (browser) | compare the marked images in pairs |
n / p | next / previous pair |
| click a tile | select it; Enter opens it on its own |
2 | the 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
spaceplays and pauses.,/.step one frame,</>jump to the first and last,:goes to a frame number.I/Oset the in and out points (again: clear).Gswitches 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
| Key | Does |
|---|---|
space | play / pause |
, . < > | step frame / first, last |
: | go to frame (file number, nearest) |
G | missing frames: skip / hold the nearest (timing) |
I / O | in / out point here (again: clear) playback loops in to out; , . < > stay inside |
left drag | scrub (on the image or the playbar) |
playbar | click: go to frame, wheel: step |
F | cycle playback fps |
P | playback: capped resolution (keeps up) / full res the window plays at full res until P caps it |
S | stats: 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 / mouse | Does |
|---|---|
, / . | one frame back / forward |
< / > | first / last frame |
: | type a frame number; Enter goes there (the nearest when it’s missing) |
| left-drag | scrub, on the image or the playbar |
| click / wheel on the playbar | go 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.
edoesn’t expand a movie in the files pane: its frames have no files.
Display
Tip
TL;DR
cshows colour;rgbashow one channel as grey;ushows luma.e/Echange exposure by half a stop,y/Ychange gamma,0resets the display.sturns the view transform off and on.woutlines the display and data windows.!paints NaN and inf pixels.Bchanges 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
| Key | Does |
|---|---|
c r g b a u | colour / R / G / B / alpha / luma |
e / E | exposure +/- 0.5 stop |
y / Y | gamma +/- 0.1 |
s | view transform (sRGB / OCIO view) / raw |
w | outlines: display + data window / display window / off |
w (tiles) | selection / windows + selection / windows / off |
! | paint NaN (magenta) / inf (cyan) pixels |
0 | reset the display (exposure, gamma, channel, …) |
B | backdrop: grey / black / checker (alpha over it) |
A | show / hide annotations |
Channels
| Key | Shows |
|---|---|
c | colour (all channels) |
r g b | one channel, as grey |
a | alpha, as grey |
u | luma |
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:
- display window, plus the data window (dashed)
- display window only
- 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:
- grey, the screen’s own (where it starts)
- black, the whole view
- 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-6open the metadata, files, inspector, layers and colour panes and focus them; the same key again closes a focused pane.1focuses the image,Tabhides every pane and brings them back.
Keys
Viewer: Panes
| Key | Does |
|---|---|
2 3 4 5 6 | metadata / files / inspector / layers / colour |
m o/x i / | the same, as letters open + focus; again while focused closes |
1 | focus the image |
Tab | hide all panes / bring them back |
The panes
The viewer’s panes, by number:
| Key | Also | Pane | Shows | Where |
|---|---|---|---|---|
2 | m | Metadata | the header: attributes and layers | right |
3 | o / x | Files | the open sources and their annotations | bottom left |
4 | i | Inspector | pixel values and layer statistics | right, above metadata |
5 | / | Layers | every layer; the cursor picks the one shown | left |
6 | Colour | OCIO config, display, view, look, input colour space | left |
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.
1focuses the image, leaving the panes open, soj/kand the other keys act on the image again.Tabhides 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(orm) shows the current frame’s header: its parts, attributes and layers./filters it,y/Ycopy a line or just its value. On a comparison it lists only what differs.
Keys
Viewer: Metadata (2)
| Key | Does |
|---|---|
j k gg G | move (Ctrl+d / Ctrl+u half a page) |
wheel { } | scroll |
/ click | filter (Esc clear) / move there |
v drag | select rows (Ctrl+click: to there) |
click | the selected row again, or below the rows: none |
y Y | copy line / value |
d | diff 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(oro/x) lists what’s open.j/kmove,Entershows that source,J/Kreorder,ddrops one,eexpands a sequence into frames.lgoes into a row’s annotations.
Keys
Viewer: Files (3)
| Key | Does |
|---|---|
j k Enter | move / show that source |
J / K d | move it down / up, drop it |
drag | a file up or down the list: it moves there |
e | sequence ⇄ its frames (up to 500) |
l / h | into a row’s annotations / back |
D D | clear 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(ori) opens the inspector. It reads the pixel under the mouse as it moves.Ctrl+clickpicks a pixel and lists every channel of the layer shown;xclears the pick. Below that: each channel’s min, max and average, with a warning for NaN and inf.
Keys
Viewer: Inspector (4)
| Key | Does |
|---|---|
Ctrl+click | pick a pixel (in the image) |
j k y Y | move, copy line / value |
x | clear 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)
| Key | Does |
|---|---|
j k gg G click | show 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
6opens the colour pane:j/kpick a row,h/lchange it,Enterpicks from a list. With$OCIOset, 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 toACEScg(why).
Keys
Viewer: Colour (6)
| Key | Does |
|---|---|
j k | move between the rows |
h / l Enter | change the row / pick from a list |
The rows
| Row | What |
|---|---|
| config | $OCIO (when set), OCIO’s built-in configs (ACES studio and CG), the config in use, or none (plain sRGB) |
| display | the config’s displays (sRGB, Rec.1886, P3, …) |
| view | the display’s views (ACES 1.0 / 2.0 SDR, Un-tone-mapped, Raw, …) |
| look | the config’s looks, or none |
| input | the 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 row | What 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, typeacescg,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, pressl. On a slot,aadds a line: type it,Enterkeeps it.[#@frame]and[#owner]fill in per frame.Ain the viewer hides them all.
Keys
Inside a row of the files pane (3, then l):
Viewer: Annotations (3, then l)
| Key | Does |
|---|---|
a A Enter d | add below / above, edit, delete |
J / K g / s | reorder, to global / source |
Tab ↑↓ Ctrl+n | typing: 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
- Open the files pane:
3. - Move to global (the row above the files) or to a source, and press
lto go into its set: all six slots, with their lines. - Move to a slot with
j/kand pressa. Type the line in the bottom bar; the image shows it as you type.Enterkeeps it,Escdrops 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
| Placeholder | Becomes |
|---|---|
[#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
| Argument | Opens |
|---|---|
| (none) | the browser, in the current folder |
shots/ | the browser, in that folder |
render.exr | the 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:main | the 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
| Option | Does |
|---|---|
--diff A B | compare A with B: A, B and |A − B| tiled. Repeat for more pairs; paths can carry labels. See Compare |
--dump FILE | print the layers, channels and metadata, then exit |
--doctor | check the terminal and tmux setup for images and copy, then exit (1 if a check fails). See Terminal setup |
--gui | open in a window of its own instead of the terminal (not in the static Linux binary; on Windows always) |
--tutorial | render the sample images into ~/.cache/rega/tutorial (first run) and open them with a guide. See tutorial |
--graphics MODE | auto (default), kitty or halfblock. See setup |
--transfer MODE | how 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 SIZE | bytes 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 SIZE | terminal 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 SIZE | memory for decoded images, e.g. 8G or 512M (default 4G, at least 64M) |
--chooser-file FILE | o in the browser writes the chosen paths to FILE and exits. See picking files |
--cwd-file FILE | on exit, write the last folder to FILE |
--version | print the version and licence notice |
-h, --help | print the options |
Files rega keeps
| Path | What |
|---|---|
~/.cache/rega/tutorial/ | the tutorial’s images |
~/.local/state/rega/annotations | annotations, between sessions |
~/.local/state/rega/colour | the colour choices, per config |
~/.local/state/rega/backdrop | the backdrop |
~/.local/state/rega/window | the window’s size, text size and last folder |
~/.local/state/rega/recent | the 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
| Variable | Effect |
|---|---|
OCIO | the OpenColorIO config to show images through |
REGA_LOCAL_ONLY | 1: 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_MEGAPIXELS | the largest frame rega will load, in megapixels (default 1024); a file’s header can claim any size |
LC_TERMINAL | names 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
| Key | Does |
|---|---|
j/k ↑/↓ | move |
h/l ←/→ | parent / enter dir or view image |
gg / G | top / bottom |
/ | fuzzy filter (Enter keep, Esc clear) |
e | expand sequence into frames / collapse |
. | toggle hidden files |
space | mark (view marked together) |
a | mark every image here (again: unmark) |
t | view tiled: the marked side by side |
d | diff the marked in pairs (one marked: with this) |
click | select (double: open) / parent dir |
Shift / Ctrl+click | mark a range / mark one more |
cc cd | copy path / folder (marked: all of them) |
cf cn | copy file name / name without extension |
o | choose → –chooser-file, quit |
q / Q | quit |
Viewer: Image
| Key | Does |
|---|---|
[ / ] | previous / next layer (AOV) |
n / p (N) | next / previous image (marked files) diff: next / previous pair (A, B, |A - B|) |
+ / - / wheel | zoom |
f / z | fit / 1:1 |
hjkl ←↓↑→ HJKL | pan (shift = faster) |
right drag | pan (middle button too; left on a still or tiles) |
t | tiles: all layers, or all marked images |
+- wheel hjkl | tiles: zoom / pan the tiled view (f fit, z 1:1) |
click | select tile / focus pane |
drag | pane edges: width; files title: height |
Enter (tile) | open the selected tile |
T | layer name on the image (tiles: each tile’s; tiled files numbered: [1] name, [2] name, …) |
Ctrl+click | pick colour [x, y] as in Nuke: from the bottom-left |
Viewer: Sequence
| Key | Does |
|---|---|
space | play / pause |
, . < > | step frame / first, last |
: | go to frame (file number, nearest) |
G | missing frames: skip / hold the nearest (timing) |
I / O | in / out point here (again: clear) playback loops in to out; , . < > stay inside |
left drag | scrub (on the image or the playbar) |
playbar | click: go to frame, wheel: step |
F | cycle playback fps |
P | playback: capped resolution (keeps up) / full res the window plays at full res until P caps it |
S | stats: link, picture cost, caches (anywhere) |
Viewer: Display
| Key | Does |
|---|---|
c r g b a u | colour / R / G / B / alpha / luma |
e / E | exposure +/- 0.5 stop |
y / Y | gamma +/- 0.1 |
s | view transform (sRGB / OCIO view) / raw |
w | outlines: display + data window / display window / off |
w (tiles) | selection / windows + selection / windows / off |
! | paint NaN (magenta) / inf (cyan) pixels |
0 | reset the display (exposure, gamma, channel, …) |
B | backdrop: grey / black / checker (alpha over it) |
A | show / hide annotations |
Viewer: Panes
| Key | Does |
|---|---|
2 3 4 5 6 | metadata / files / inspector / layers / colour |
m o/x i / | the same, as letters open + focus; again while focused closes |
1 | focus the image |
Tab | hide all panes / bring them back |
Viewer: Metadata (2)
| Key | Does |
|---|---|
j k gg G | move (Ctrl+d / Ctrl+u half a page) |
wheel { } | scroll |
/ click | filter (Esc clear) / move there |
v drag | select rows (Ctrl+click: to there) |
click | the selected row again, or below the rows: none |
y Y | copy line / value |
d | diff tile: differences / both whole |
Viewer: Files (3)
| Key | Does |
|---|---|
j k Enter | move / show that source |
J / K d | move it down / up, drop it |
drag | a file up or down the list: it moves there |
e | sequence ⇄ its frames (up to 500) |
l / h | into a row’s annotations / back |
D D | clear all annotations (in a row: its own) |
Viewer: Inspector (4)
| Key | Does |
|---|---|
Ctrl+click | pick a pixel (in the image) |
j k y Y | move, copy line / value |
x | clear the pick |
Viewer: Layers (5)
| Key | Does |
|---|---|
j k gg G click | show that layer |
Viewer: Colour (6)
| Key | Does |
|---|---|
j k | move between the rows |
h / l Enter | change the row / pick from a list |
Viewer: Annotations (3, then l)
| Key | Does |
|---|---|
a A Enter d | add below / above, edit, delete |
J / K g / s | reorder, to global / source |
Tab ↑↓ Ctrl+n | typing: next slot, history, [#key] / [#@key] |
Viewer: Leaving the viewer
| Key | Does |
|---|---|
q / Esc | back to browser |
Q | quit rega |
Window
| Key | Does |
|---|---|
Ctrl+O | open images or movies (the system’s dialog) |
Ctrl+Shift+O | open a folder |
drop | files or folders on the window: open them |
q (browser) | back to the start screen (Q quits) |
Ctrl+C | copy: the path (browser, image), the rows (2, 4) |
Ctrl+F | search the keys (in ? too) |
Ctrl+V | paste: into what is typed, else paths to open |
Ctrl+= / - | bigger / smaller text |
Ctrl+0 | text size back to the default |
F11 | full screen on macOS, ⌘ works as Ctrl here |
Start screen
| Key | Does |
|---|---|
o | open images or movies (the system’s dialog) |
f | open a folder |
b | browse: the file browser, where it was left |
t | the tutorial: a tour on sample images |
Ctrl+V | paste paths, one a line: listed to open together |
a | type a path (Enter adds it, Esc done) |
x X | remove the selected path / clear the list |
1 … 9 | open a recent one again |
click space | a recent one into the list (again: out) |
Shift+click J K | a range of them into the list |
double-click | a recent one: open it at once |
j/k ↑/↓ | move (the pointer too) |
Enter | open what is selected |
x | a recent one: forget it |
q / Q | quit |