Nuke compositing turns a Houdini render into a finished shot by combining it with plates or backgrounds, matching its photographic response, and adding the effects that make separate elements feel coherent. A reliable workflow begins before rendering: the camera, frame range, resolution, motion blur, alpha, color management, and render passes must all support the composite.
This beginner guide explains the complete Houdini-to-Nuke workflow. You will learn how to prepare multichannel EXR files, inspect AOVs and Cryptomatte data, build a clear Nuke node graph, integrate CG over a plate, and diagnose common alpha, edge, color, depth, and timing problems. It also establishes a practical boundary between fixes that belong in Houdini and shot-level adjustments that are better handled in Nuke.
What compositing adds to a Houdini render
Rendering converts a Houdini scene into image data. The renderer evaluates geometry, materials, lights, animation, simulations, the camera, and render settings, then writes an image sequence—commonly OpenEXR files. That sequence may contain a finished beauty image as well as alpha, lighting components, mattes, and utility data.
Compositing happens after that render. In Nuke, the CG is combined with a background plate or other elements and adjusted in the context of the complete shot. Typical work includes exposure and color matching, atmospheric depth, contact treatment, defocus, grain, motion blur refinement, and lens effects.
A technically valid render is not necessarily an integrated image. It can have plausible materials and lighting but still appear to float because its contrast, edge quality, sharpness, motion response, or atmospheric perspective differs from the plate. Nuke provides shot-level control over these relationships without requiring a new render for every adjustment.
The basic workflow is:
- Prepare the Houdini scene, camera, timing, and render outputs.
- Render an image sequence with the required alpha, motion blur, AOVs, and utility passes.
- Read the sequence into Nuke and validate its channels, format, timing, and color interpretation.
- Merge the CG with the plate and match its broad image response.
- Use mattes and utility passes for controlled local adjustments.
- Add finishing effects, review the complete sequence, and write the approved output.
This order separates structural problems from finishing work. An incorrect camera cannot be repaired reliably with a two-dimensional transform, and missing motion blur cannot be recreated perfectly from a still image. By contrast, a small exposure adjustment or depth-based haze treatment is usually an appropriate compositing decision.
Prepare the Houdini scene for compositing
A dependable Nuke compositing workflow starts before the render is submitted. Treat the render as a technical handoff: confirm the shot context, provide purposeful outputs, and document assumptions that affect how Nuke will interpret the files.
Camera, timing, and image format
Confirm that the render uses the approved camera. Check its animation, focal length, aperture or sensor settings, film offsets, and any shake inherited from the camera track. Even a small camera mismatch can cause CG to slide against a live-action plate.
The render dimensions and pixel aspect ratio must also match the intended shot format. A mismatched pixel aspect can stretch the image or break alignment even when the numerical resolution appears reasonable. Avoid using a Nuke Transform or Reformat node to conceal an incorrect render setup unless the conversion is deliberate and documented.
- Frame range: Verify the first and last frames, including handles needed for editorial changes, transitions, or retiming.
- Frame rate: Make sure Houdini, Nuke, and the plate use compatible timing. Matching frame numbers do not help if the applications interpret playback speed differently.
- Render region: Disable accidental test regions, crops, and resolution overrides before the final render.
- Motion blur: Confirm the shutter interval and the required motion sources. Camera, rigid-body, deformation, particle, and volume motion may depend on different renderer settings or velocity data.
- Scene state: Check caches, textures, external assets, simulations, lights, and frame-dependent settings across the complete range.
Render an image sequence for animated or changing content. Repeating one still frame cannot represent camera movement, a developing pyro simulation, changing illumination, or animated motion blur.
OpenEXR, beauty passes, and AOVs
OpenEXR is normally the most useful delivery format for CG because it supports high-dynamic-range scene data, multiple channels, and suitable bit depths for compositing. A multichannel EXR can contain the beauty image, alpha, lighting components, utility passes, and Cryptomatte layers in one sequence. Separate files remain valid when a studio pipeline needs independent versioning or selective re-rendering.
The beauty is the main rendered appearance. AOVs may separate components such as diffuse, specular, reflection, refraction, emission, or shadows. Utility passes can include depth, normals, world position, motion vectors, object IDs, material IDs, and masks.
Render only the passes that support a known task. Extra AOVs increase storage, channel-management work, and the risk of inconsistent color or premultiplication. They are also not universally interchangeable: one renderer may encode a shadow pass for multiplication, while another expects a different reconstruction method. If Redshift is part of the pipeline, this guide to setting up Redshift AOVs provides a more focused pass-planning workflow.
Useful choices include:
- Lighting AOVs when a specific contribution may need controlled adjustment.
- Depth for atmospheric falloff, depth isolation, or depth-based defocus.
- Motion vectors when the renderer and Nuke setup support a compatible vector-blur workflow.
- Normals or position for technical masks and limited relighting operations.
- Cryptomatte when objects or materials will need flexible selections.
Cryptomatte is usually more practical than rendering a separate matte for every object. It stores identifiers that Nuke can use to generate editable selections, provided the expected layers and manifest data survive the handoff. For renderer-specific setup, see the guide to Redshift Cryptomatte masks.
Document alpha and background treatment
Record whether the beauty was rendered over transparency, an environment, or a solid background. Also state whether its RGB channels are premultiplied by alpha and whether transparent pixels contain meaningful RGB values.
This information matters at soft edges. If Nuke treats straight RGB as premultiplied—or premultiplies an image twice—the composite can develop dark or bright fringes. The handoff should also identify the file pattern, frame padding, render version, channel names, working color space, camera, resolution, and frame handles.
Set up the Nuke project correctly
Validate the source before grading or merging it. The first pass through a new script should answer one question: is Nuke reading the Houdini output as intended?
Read and inspect the sequence
Load the render with a Read node and check the file pattern, first and last frames, format, pixel aspect ratio, and input color interpretation. If a sequence starts at frame 1001 but is mapped to frame 1, every animated operation and editorial comparison will be offset.
Connect the source directly to a Viewer and inspect several frames, not just the first one. Review the RGB image, alpha, and important AOVs separately. Confirm that motion, deformation, lighting changes, and motion blur remain valid through the shot.
- Channels: Make sure the expected beauty, alpha, AOV, depth, motion, and Cryptomatte layers exist.
- Alpha: Check whether it represents the subject, a holdout, or an opaque full frame.
- Sequence integrity: Look for missing frames, corrupt frames, cache discontinuities, or frozen animation.
- Metadata: Use metadata as supporting information, but verify it against the plate and production settings.
Keep the original Read node unmodified. Branch downstream for denoising, channel extraction, grading, or diagnostics so the source remains available for comparison.
Understand scene-linear data and display viewing
Color management is one of the most important parts of EXR compositing in Nuke. CG EXRs are commonly stored as scene-linear data, where pixel values represent relative light and may exceed display white. A monitor cannot present that data directly in a useful way, so the Nuke Viewer applies the project’s display transform.
The display transform changes how the image is shown; it does not normally alter the image data moving between nodes. Confusing these two stages can lead to unnecessary grades or a display transform being applied twice.
Choose the production OCIO configuration or other approved color-management setup before making creative decisions. Then verify that each source is interpreted correctly. The Houdini render may already be scene-linear, while a live-action plate may need an input transform from a camera-specific space into the working space. A reference JPEG may be display-referred and require different treatment again.
If the EXR looks unexpectedly dark, flat, or saturated, check the Read colorspace and Viewer transform before modifying the image. If the file was written with the wrong render configuration, correct the render or its input interpretation rather than building a compensating grade that must be repeated in every shot.
Build a basic Houdini-to-Nuke composite
Work from broad structural relationships toward local corrections and finishing. This makes failures easier to diagnose and prevents grain, haze, or lens effects from hiding a bad camera match or broken alpha.
1. Establish the plate and CG branches
Create separate Read nodes for the plate and Houdini sequence. Set the Nuke project format and frame range deliberately rather than inheriting settings from an unrelated script. View both sources independently and compare their timing, framing, exposure, and sharpness.
Use Reformat only when an intentional format conversion is required. Use Transform for a justified two-dimensional adjustment, not as a replacement for an accurate Houdini camera.
2. Merge the CG over the plate
Connect the Houdini render to the A input of a Merge node, the plate to B, and use the over operation for a conventional foreground-over-background composite. The foreground alpha controls its coverage.
If the subject disappears, appears inside a rectangle, or develops a fringe, inspect the source alpha and premultiplication before grading. A black RGB background is not the same as transparency, and an opaque alpha cannot automatically recover the intended object boundary.
3. Match the broad image response
Use a Grade, exposure adjustment, or ColorCorrect on the CG branch to match the plate. Work in a practical order:
- Match overall exposure and contrast.
- Compare black levels and highlight behavior.
- Adjust color temperature and saturation.
- Evaluate the CG against nearby objects in the plate rather than in isolation.
A render can have the right hue but still feel separate because its shadows are too clean, its highlights roll off differently, or its saturation does not respond like the photographed environment. If the mismatch comes from a fundamentally incorrect light direction, missing contact shadow, or implausible reflection, return to Houdini instead of forcing the image with a heavy grade.
4. Use passes and mattes selectively
Use Shuffle or Shuffle2 to access channels from a multichannel EXR. A lighting AOV can isolate a specific contribution, but first confirm how the renderer expects it to be combined. Do not add every pass to the beauty: many beauty renders already contain those contributions.
A Cryptomatte node can generate a matte for an object or material. Use that matte to limit a Grade, color correction, or other local operation. This is appropriate when one material is too bright, for example, while the rest of the render is correct.
Depth passes need additional care. Establish what the values represent, which direction is near or far, and whether empty pixels contain meaningful data. Normalize or remap the depth only for the intended operation. An inverted or poorly ranged pass can place more haze on foreground objects than distant ones.
5. Handle premultiplication deliberately
In a premultiplied image, RGB has already been multiplied by alpha. Some color operations can produce contaminated edges when applied directly to those reduced RGB values. A common pattern is:
- Apply
Unpremultusing the correct alpha channel. - Perform the RGB correction.
- Apply
Premultto restore the relationship between RGB and alpha.
This is not required around every node. Use it when the operation needs full-color edge values, and inspect the result over both dark and light backgrounds. Blurs, filters, matte operations, and transforms can have their own alpha implications, so node order remains important.
6. Add integration and finishing effects
Once the basic layer relationship works, add the cues that place the element in the photographed environment:
- Contact shadows and holdouts
- Atmospheric haze or depth-based contrast reduction
- Defocus matched to the plate
- Motion blur consistent with the shutter and movement
- Lens distortion or other approved lens treatment
- Grain matched at the final working resolution
Distant objects often need lower contrast and saturation rather than simply lower opacity. Grain should normally be added after major transforms, defocus, and color operations; otherwise those operations can alter its size or character. For a broader finishing overview, see these CGI post-processing steps.
Diagnose common compositing failures
When a composite breaks, isolate the symptom before adding corrective nodes. View the plate, beauty, alpha, and relevant AOVs independently, then determine whether the defect exists in the source render or is introduced by the Nuke graph.
Dark or bright edge halos
Halos commonly indicate an incorrect premultiplication assumption, double premultiplication, or an RGB edge contaminated by the render background. Compare RGB and alpha separately. Test an appropriate Unpremult, correction, and Premult sequence rather than blurring the edge immediately.
If the edge color is already wrong in the source, investigate shader transparency, environment contribution, filtering, motion blur, and background settings in the renderer. A clean alpha does not guarantee useful RGB edge values.
Black rectangle or missing transparency
Check whether the EXR contains a meaningful alpha and whether the Merge is using it. A render written over black with a solid alpha is opaque. Nuke cannot derive a reliable transparency matte from every black-background render, especially when the subject contains dark, reflective, refractive, or motion-blurred areas.
Also inspect downstream Copy, Shuffle, Grade, and Merge operations. A node may have replaced, expanded, or removed the alpha unintentionally.
Washed-out or overly contrasty color
Before grading, verify the input colorspaces, working configuration, and Viewer transform. Common causes include treating display-referred footage as scene-linear, reading linear EXRs with the wrong transform, or applying a display conversion twice.
If the transforms are correct and the mismatch remains, assess the Houdini lighting, exposure, shader response, and environment contribution. Color management can explain a technical interpretation error; it cannot make unsuitable lighting physically consistent with the plate.
Sliding, framing, or timing mismatches
Check the source frame range, frame rate, pixel aspect ratio, resolution, and time offsets. Then confirm that Houdini rendered the approved camera with the correct focal length, film offsets, transform, and animation.
A static 2D correction may line up one frame while failing across a camera move. If perspective, parallax, or occlusion is wrong, the camera or scene usually needs an upstream correction.
Incorrect or unstable motion blur
Compare the render shutter interval with the plate’s motion response and confirm that the required geometry, deformation, particle, volume, and camera motion were available to the renderer. If using vectors in Nuke, verify their channel naming, scale, direction, coordinate convention, and timing.
Vector blur can be useful, but it is not a universal replacement for correctly rendered motion blur. Complex occlusion, transparency, deformation, and volumes may not reconstruct cleanly from a single vector pass.
Missing, invalid, or flickering passes
Inspect the EXR channel list before rebuilding the node graph. If an AOV is absent, empty, or invalid, the fix belongs in the Houdini output or renderer settings. Flickering reflections, crawling Cryptomatte selections, unstable simulations, and changing mattes should also be checked in the source sequence before temporal cleanup is attempted in Nuke.
A practical diagnosis order is:
- View the plate, beauty, alpha, and relevant utility passes separately.
- Check the
Readnode’s range, channels, format, and colorspace. - Inspect premultiplication and RGB edge values.
- Verify camera, resolution, pixel aspect, timing, and motion-blur assumptions.
- Test the correction across several frames.
- Only then add a targeted Nuke fix.
Decide whether to fix Houdini, the render, or Nuke
The most maintainable fix addresses the stage that caused the problem. Houdini should provide correct scene information, the renderer should produce the required image data, and Nuke should make shot-specific integration and finishing decisions.
| Problem | Preferred stage | Reason |
|---|---|---|
| Incorrect geometry, animation, simulation, scale, or camera | Houdini or the upstream layout stage | The pixels are based on incorrect scene information. |
| Wrong light direction, missing shadows, poor sampling, or inadequate motion blur | Houdini and the renderer | Nuke cannot fully reconstruct information that was never rendered. |
| Missing AOV, depth, alpha, motion, or Cryptomatte data | Render setup | The required channels must be generated at render time. |
| Plate matching, local exposure, color, haze, grain, or restrained lens treatment | Nuke | These decisions depend on the final shot context. |
| Object or material adjustment using an existing valid matte | Nuke | The render already contains sufficient data for a controlled change. |
Before building a complex workaround, ask:
- Is the object in the correct place, shape, scale, and frame?
- Does the camera match the plate in perspective and movement?
- Are the lighting direction, shadows, reflections, and occlusion plausible?
- Was the required alpha, motion blur, matte, depth, or AOV rendered?
- Does the proposed fix remain stable across the complete sequence?
- Will the same workaround need to be repeated in several shots?
If a correction compensates for the same source defect across many frames or shots, an upstream fix is usually more efficient and consistent. If the scene is technically sound and the change depends on the specific plate, edit, or desired look, Nuke is generally the better stage.
Organize a production-ready Nuke script
A clear Nuke node graph is easier to review, revise, and troubleshoot. Keep the main flow vertical and organize it into recognizable stages:
- Inputs: Plate, Houdini render, external mattes, and reference elements.
- Source preparation: Input transforms, denoising, reformats, and channel checks.
- CG preparation: Beauty adjustments, AOV extraction, Cryptomatte selections, and premultiplication handling.
- Integration: The main
Merge, contact work, atmospheric depth, and plate matching. - Finishing: Defocus, motion treatment, lens effects, and grain.
- Output: Delivery conversion, final format, and
Writenodes.
Label important nodes by purpose rather than by node type alone. Names such as CG_exposure_match, hero_object_matte, and final_grain communicate more than a sequence of generic Grade nodes. Keep temporary tests and alternate looks to the side of the approved flow, and preserve the original sources for comparison.
Use Merge nodes for explicit layer relationships and label operations such as over, plus, or multiply when their purpose may not be obvious. Do not hide critical alpha replacements or color conversions inside undocumented groups. Another artist should be able to identify the approved path without opening every node.
Final quality-control checklist
Review the written image sequence, not only the live Nuke Viewer. Check the first and last frames, representative motion frames, bright highlights, fades, fast movement, and any point where the camera or simulation changes significantly.
- Sequence: All required frames exist, including approved handles.
- Format: Resolution, pixel aspect ratio, frame rate, crop, and data window are correct.
- Color: Input, working, display, and output transforms follow the project configuration.
- Alpha: Coverage is correct and the image has not been premultiplied twice.
- Edges: No dark fringes, bright halos, matte chatter, unwanted contamination, or artificial softness.
- Integration: Exposure, black level, saturation, sharpness, perspective, and atmospheric depth agree with the plate.
- Motion: Animation, motion blur, defocus, and temporal effects remain stable through the shot.
- Shadows and reflections: Contact cues support the subject’s position and lighting.
- Grain and lens treatment: Finishing matches the plate at final delivery size.
- Channels: The output preserves only the channels required by delivery specifications.
- Write node: The approved branch, file type, bit depth, range, naming, and destination are correct.
Inspect the result at full resolution and at the intended viewing size, then play the complete sequence at speed. If a defect is embedded consistently in the rendered pixels—such as a wrong camera, unstable simulation, missing shadow, or absent AOV—send it back to Houdini or the render setup. If the render is valid and needs plate matching, local masking, atmospheric treatment, or final image finishing, keep the correction in Nuke.