Install. Open.
Start creating.

Install the app, then download a model from inside it if you want one. Still images need nothing else; movies need FFmpeg, which both packages include.

Windows 10 / 11 · x64

What your computer needs

macOS · Apple silicon

On a Mac the learned ACES 2.0 model runs as on Windows: download it in the app. For AI fill, run scripts/genfill_setup.sh from the RUDRA source once (Python, the packages and the Wan2.1 base model).

Prefer a portable app? Download the Windows ZIP, extract the whole folder, and open RUDRA.exe.

Add
a model.

RUDRA starts on its analytic reconstruction, which needs no model. The learned models download separately, so a new model never needs a new install: RUDRA lists them, downloads one, checks it, and keeps it ready.

Three steps.
Nothing else.

RUDRA opens in Simple: the three steps and the controls most shots need. Full shows every control. Switch with the Simple / Full buttons in the toolbar, or Advanced → on the Look tab.

The viewer bar

What Full adds

The analytic route and its Source curves and calibration, region exposure (the Grade tab), the probe, collections, the colour pipeline strip, and every delivery option: format, colour, bit depth, codec, start frame, timecode and reel.

Useful keys

Your first
HDR shot.

Start with one still or a short clip. Look, check, deliver — then do the rest of the sequence.

Read the Check tab in plain language.

A master.
In your folder.

On 3 Deliver, pick one of four choices, check the file path, and Render. Nothing is ever overwritten.

Train for
your material.

Training is separate from using the desktop app. It creates a candidate model from HDR reference footage. Better results are something to measure, not something to assume.

1. Gather the right dataset.

The pipeline generates SDR/HDR pairs from your HDR material. Include different scenes, lighting, bright regions, shadows, and textures. Thousands of adjacent frames from one shot do not replace independent scenes.

Keep whole scenes separate between training, validation, and testing. Review scene IDs before training. Reserve an additional independent set for final confirmation, especially after repeated experiments.

my_hdr_dataset/
  scene_001/
    frame_0001.exr
    frame_0002.exr
  scene_002/
    hdr_master.mov
  scene_003/
    frame_0001.exr

2. Prepare a training environment.

Use the source repository and Python 3.10–3.13; Python 3.12 is a practical choice. The current driver supports NVIDIA CUDA or CPU, not Apple’s MPS backend. CPU training can be very slow. You also need FFmpeg/FFprobe for video sources and disk space for generated pairs.

Clone the release source and enter its folder:

git clone --branch v1.2.0 https://github.com/FXTD-Studios/RUDRA.git
cd RUDRA

Create and activate a Python environment. Install a CUDA-enabled PyTorch build matching your GPU and driver using the official PyTorch selector. Then install the project and evaluation dependencies:

python -m pip install -e ".[metrics]" onnx onnxruntime OpenEXR
python -c "import torch; print('CUDA available:', torch.cuda.is_available())"

py -3.12 -m venv .venv
.\.venv\Scripts\Activate.ps1

python3 -m venv .venv
source .venv/bin/activate

3. Preview your training plan.

Choose a new work folder for each experiment. These controls only create commands; they do not start training or upload your data.

Dry run prints the commands; it does not validate footage, GPU, or dependencies. The normal run performs those checks. Step count is a budget, not a quality target.

4. Train, then follow the stages.

Watch the terminal for the active stage, training step, and validation output. Time depends on the GPU, image sizes, and dataset. If verification fails, fix the data rather than bypassing the checks.

5. Decide whether the model is better.

Look in your work folder for checkpoints/image/, checkpoints/shadow/, and results.json. Keep the learned ACES 2.0 model until the candidate proves useful.

• Compare against both the analytic baseline and the learned ACES 2.0 model.
• Evaluate clean and degraded inputs. The driver’s default benchmark covers the hard condition only.
• Read PU21-PSNR and perceptual scores together; low training loss alone is not approval.
• Inspect unseen scenes and complete sequences for colour shifts, lost detail, and flicker.
• Repeated validation tuning is not independent evaluation. Keep a genuinely unseen final set.

6. Try an approved candidate in the app.

The native app loads an exported model package, not a bare checkpoint. Export the candidate you have evaluated:

Use File → Model packages… to add the exported package folder containing manifest.json. Keep the learned ACES 2.0 model available for comparison and review the first-run checks on the target computer.

What’s new
in 1.2.0.

In 1.1.0

• The viewer bar: f/stop, γ, an SDR | RUDRA wipe, clamp and clip zebras and the Range layer (below), and AI fill: every frame that has a fill shown filled, stepping and playing; with Changes on, what it invented.
• Clean shadows (Deliver › Learned ACES 2.0, off by default): an edge-preserving denoise of the deep shadows, so a push of a few stops is not all grain; the SDR still shows the original within one code.
• AI fill fixes the master in place: when a fill finishes, the originals move to <master>_before_aifill. Setup… checks the LoRA is the published AI fill v3.
• An ACES Metadata File beside every EXR master, and alpha passed through (EXR, 16-bit TIFF, ProRes 4444).
• Playback is prepared in the background ("Preparing playback: N of M"), then Play is real time.
• The master stays at the source's native resolution. To deliver UHD from HD, resize once at the end in your finishing tool (Resolve's Deliver page, Nuke's Reformat) and label it up-converted.

In 1.0.3

• No model inside the package: every model is a download in File › Model packages that shows its licence first. Packages up to 1.0.1 carried the Beta 2 model sdr2hdr_image_v8, which is non-commercial; if you installed one of them, update or delete models/sdr2hdr_image_v8 from the install before commercial work.
• The learned ACES 2.0 model is a preview: in the last published test it graded better at −3 and +3 EV, but at the delivered exposure its highlights sat further from the reference than the analytic result. Compare the two before delivery.

Compare SDR and HDR like in Nuke

The bar under the viewer is the viewer's own: none of it changes the master, a render or a saved project. An amber VIEW badge shows whenever the view is gained, so a screenshot never passes for the grade.

• f/stop and γ: stop the view down or up as in Nuke (Alt+[ and Alt+] half a stop, Alt+E toggles 0 and the last value, Alt+0 resets). The buttons −6 −4 −2 0 +2 jump straight there (Alt+B steps through them).
• A | B: pick SDR (original), Baseline or RUDRA for each side of the wipe; A ⇄ B swaps them (Alt+X). Wipe SDR | RUDRA and stop down to −3 EV: where the original clipped it goes flat grey, RUDRA keeps a gradient.
• Clamped (Alt+K): stripes where the original is clamped: red all channels at code 254 or above, thin orange only some (a sky clipping in blue first), blue crushed at code 1 or below. They mark the same pixels on both sides at any exposure.
• Clipping (Alt+L): yellow stripes where the picture clips on the screen at this exposure and peak.
• Range (Alt+R): every pixel coloured by stops above the SDR white (203 nits): grey is the SDR's own range, then blue, green, yellow, orange and red for each stop up to +4 and over. White hatching marks what the original clamped.
• The line under the bar reads the frame in nits: how much of the original is clamped (per channel) and crushed, RUDRA's peak and how much goes over the SDR white and 1,000 nits, and, inside the clamped area, how far RUDRA took it and how much it left as the plain inverse. Hover a pixel for its original codes, which channels are clamped, and its stops over the SDR white.

Rebuild only highlights and shadows

In Deliver › Learned ACES 2.0, Rebuild only highlights and shadows keeps the model's result only where the brightest channel of the original is at or above τ high or at or below τ low (8-bit codes; 254 and 5 are the model's own bands). Everything between is the plain ACES inverse, which gives the original back pixel for pixel. 256 turns highlights off, −1 shadows. The viewer follows the setting; turn on Changes to see what was rebuilt. Off, the model's own result is used everywhere, as before.

In 1.0.2

• The learned ACES 2.0 model on every platform: its engine is now in the Windows and macOS packages, so the model you download runs straight away (DirectML or the CPU on Windows; the CPU or Core ML on a Mac).
• AI fill on a Mac, on the GPU through Metal. Experimental, as on Windows.

In 1.0.1

• The first published 1.0 build, for Windows and, again, macOS (Apple silicon).
• Wipe: the seam stays where you leave it when you change the peak or the exposure, and the bar says which side is which: SDR left, RUDRA right.
• Clipped highlights: a large blown area, like a sun in a hazy sky, now runs toward white at its centre instead of carrying the sky’s colour all the way in. Measured against HDR references, the colour is closer and the brightness unchanged.
• The model card, README and installers’ “Read me first” are rewritten for artists.

Since Beta 2

• Learned ACES 2.0 model, a free download inside the app: kept loaded on the GPU, in the viewer and every render. The analytic reconstruction needs no model.
• Simple workspace: Look, Check, Deliver, a first-run welcome and four tips. Full keeps every control.
• Model downloads from inside the app, checked before they are used.
• Delivery presets: Grading master, HDR10 movie, Broadcast HDR; Custom… for everything else.
• HDR10 metadata: MaxCLL / MaxFALL on the PQ output, mastering display, Dolby Vision XML.
• PQ 1000 / 2000 / 4000, HLG and SDR 709 outputs; ARRI LogC4 and ACEScct copies; DPX with full headers; ProRes 4444 XQ.
• Per-shot looks with Copy / Paste, and a batch queue.
• Check tab and scopes beside the picture, with RGB parade and gamut.
• Reference stills, EDL conform, timecode and reel in every render.
• Safer renders: files are written as .part then renamed; quitting asks while a render runs.
• Open… takes movies (MOV, MP4, MXF and more) as well as stills.
• Apache 2.0: the code is now free for commercial use; each model states its own licence.

Full notes on the release page.

A few useful
answers.

Need a hand?

Include your app version, operating system, GPU, input format, export format, and the exact error. Share a small reproducible example only if you have permission to share the footage.

References

Training guide   /   Research status   /   Models

This guide does not claim independent HDR-display or clean-machine certification.