QFX LABMADE UP. MADE REAL. Send a brief

HOME / TRICKS[N° T01] · UPDATED 2026-11-19

Finish Karma renders in ACES 2.0 without opening Nuke

Houdini already ships OpenImageIO and OpenColorIO. One hython script turns an EXR sequence into a graded 16:9 master and a 9:16 crop while you sleep.

HoudiniOCIOCompositing6 MIN READ

BY · PUBLISHED

Most product renders need only a little finishing: the display transform, a soft bloom on the hot spots, a gentle vignette and some grain. Opening a compositor for every overnight render is slow, and it means someone has to be awake when the render ends.

Houdini 22 already contains everything this needs. hython can import OpenImageIO and PyOpenColorIO, and Houdini ships the official ACES 2.0 OCIO config. So the finish can be a plain script that runs the moment the last frame lands.

1. Use the config Houdini already ships

On Linux it lives in the install folder. Windows and macOS have the same packages/ocio folder inside the Houdini install.

FIND THE CONFIG
ls /opt/hfs22.0/packages/ocio/
# cg-config-v3.0.0_aces-v2.0_ocio-v2.5.ocio

2. Do the looks in linear, the transform once, grain last

The order is the whole trick. Bloom and vignette are light, so they happen on scene-linear ACEScg values. Only energy above 1.0 feeds the bloom, which keeps it on speculars and emissive parts instead of fogging the whole frame. Then the ACES 2.0 display transform runs once. Grain goes on last, on display values, weighted towards mid-tones so blacks stay clean.

COMP_ACES.PY (CORE LOOP, SIMPLIFIED)
# the ACES 2.0 config that ships with Houdini
cfg = ocio.Config.CreateFromFile(CFG)
display = cfg.getDefaultDisplay()          # 'sRGB - Display'
view = cfg.getDefaultView(display)         # 'ACES 2.0 - SDR 100 nits (Rec.709)'
dvt = ocio.DisplayViewTransform(src="ACEScg", display=display, view=view)
cpu = cfg.getProcessor(dvt).getDefaultCPUProcessor()

# scene-linear ACEScg straight from the EXR
rgb = buf.get_pixels(oiio.FLOAT)[:, :, :3].copy()
rgb *= 2.0 ** exposure

# bloom: only energy above diffuse white feeds the glow
hot = np.clip(rgb - 1.0, 0.0, 30.0)
small = hot[::4, ::4]                      # a glow has no detail: quarter res
glow = blur(small, 6) * 0.6 + blur(small, 22) * 0.4
rgb += upscale(glow) * bloom_amount

rgb *= vignette(h, w)                      # still linear: light falls off

cpu.applyRGB(rgb)                          # ACEScg -> display, in place
out = np.clip(rgb, 0, 1)
out += grain(h, w) * midtone_weight(out)   # grain after the transform
Why blur at quarter resolutionA glow has no sharp detail, so blurring a quarter-size image and scaling it back up looks the same and is about 16 times cheaper. A three-pass box blur done with cumulative sums is close enough to a gaussian and needs nothing beyond numpy.

3. Get the vertical cut from the same frame

Frame the render so the product sits inside the centre 9:16 area of the 16:9 frame. The script then writes both: the full frame, and a centre crop scaled to 1080×1920. One render, two deliverables, no second camera.

4. Run it

TERMINAL
hython comp_aces.py render/beauty.%04d.exr \
    out/16x9/shot.%04d.png out/9x16/shot.%04d.png 1 192 \
    --exp 0.3 --bloom 0.14 --vig 0.35

ffmpeg -framerate 24 -i out/16x9/shot.%04d.png -c:v libx264 -crf 17 \
    -pix_fmt yuv420p -movflags +faststart shot_16x9.mp4

Both films on this site, Aurelia and QX-Core, were finished exactly this way, with no manual step between the last rendered frame and the MP4.

When you still want a real compositorThis script has no roto, no deep data and no per-shot masks. For packshots and turntables that is fine. For anything with plates, keying or heavy relighting from AOVs, use a compositor.
++++
QFX-BRIEF · ASYNC INTAKEWRITTEN · NO CALLS

Want something like this built for your product?

Send a short brief by email: the product, where the video or game will run, and when you need it. I reply in writing within a day with an approach and a quote for that project.

[email protected] · REPLY WITHIN 1 WORKING DAY