How do I combine render passes in Blender?

You enabled a bunch of passes, hit render, and now the Render Layers node is dangling thirty-something outputs in the compositor. The Diffuse Color pass looks flat and weirdly cartoony. The Indirect passes look like grainy black-and-white photos. So you grab a single Add node, wire all of them in, and the result is brighter and uglier than the render you started with.

This is not a math problem. It is a categorization problem. Blender stuffs different kinds of passes into the same panel, and they do not all want the same treatment. Add all of them together and you double-count finished lighting, treat pigment as illumination, and use a multiplier as if it were a glow. The rebuild gets worse from the first connection. (I have shipped first attempts that came out brighter than the original render, more than once.)

The fix is to pause before reaching for any node and ask what kind of information each pass is carrying. The next two sections give you the physics that answers that question. After that the recipes are derivable.

If render passes themselves are still new ground, read What are render passes in Blender? first. This lesson picks up where that one stops: now that you know what the passes are, what do you actually do with them in comp?

You combine for control, not because Blender forgot how to render

Blender already gives you a Combined pass. That is the full beauty render the engine produced before any compositor change. The reason to recombine passes is not to do Blender’s job for it. The reason is to change one part of the image without flattening the rest:

• pull reflections down on a chrome surface without crushing diffuse shading
• balance specific groups of lights using Light Groups (a Cycles feature where you tag lights at render time and Cycles writes one finished pass per group, so you can dim the key or warm the fill in comp instead of re-rendering)
• multiply Ambient Occlusion into a contact shadow without over-darkening
• composite CG shadows from Shadow Catcher (objects you mark to receive shadow only, used for VFX integration) onto a real plate

If your goal is just “show me the render,” you do not need to recombine anything. The whole exercise is about precision.

Light adds. Color multiplies. The physics tells you which.

Once you know why each operation exists physically, the recipes stop feeling arbitrary.

Light is energy. Energy adds. Two lamps shining on the same wall deliver the photons of lamp A plus the photons of lamp B. That is why Cycles splits lighting into Direct (first-bounce hits) and Indirect (light that bounced before reaching the camera) and why Light Groups can be summed: they are independent contributions of light energy onto the same surface.

Color is a fraction. Fractions multiply. A red ball does not emit red light. It absorbs the green and blue parts of incoming light and reflects roughly red. The Diffuse Color pass is that fraction per pixel: usually a number between 0 and 1 saying “of the light hitting this surface, this much comes back.” (For ordinary opaque surfaces this stays under 1.0; emissive-tinted shaders can push it past 1.0 occasionally, but the multiply-not-add intuition holds either way.) Multiplying light by color asks “how much of this light actually leaves the surface?” That is the physics you obey when you write Light × Color.

Once you see Add and Multiply that way, every pass falls into one of two buckets. Light energy or already-finished lighting? Add. Surface color or grayscale mask between 0 and 1? Multiply. That single question carries you through the rest of the lesson.

Cycles: gather the light, then color it

Cycles splits each beauty family into three sockets: light arriving directly, light arriving indirectly, and the surface color it should be tinted by. Reassembly looks like this for any one family:

family = (family Direct + family Indirect) × family Color

Direct and Indirect are both light energy, so they Add. The result is the total light hitting the surface for that family. Then Color, which is a fraction, multiplies in.

Three families follow this exact pattern in Cycles:

• Diffuse
• Glossy (the reflection family)
• Transmission (glass-like behavior)

The full beauty assembles by adding those finished families to the simpler outputs:

Combined = Diffuse family + Glossy family + Transmission family + Emission + Environment + Volume

Emission, Environment, and Volume arrive as finished lighting contributions with no separate Color pass to multiply by. They just Add into the beauty.

One caveat worth keeping in mind: a pass-by-pass rebuild does not always bit-match Combined. Light path nodes, holdout objects, subsurface scattering, and a few other engine internals can introduce small drifts that are not caused by your math being wrong. The rebuild is the model. Combined is what the renderer actually shipped. The model is good enough to reason about and good enough to make precise comp moves, even when bits do not match.

The most common beginner failure is wiring Diffuse Color straight into an Add node like it were extra light. It is not. Treating pigment as illumination is the single fastest way to make a recombined image brighter than the render it came from.

Eevee: same idea, fewer pieces

Eevee does not split light into Direct and Indirect. The combine math is simpler:

• Diffuse family = Diffuse Light × Diffuse Color
• Specular family = Specular Light × Specular Color

Then add the already-finished extras: Emission, Environment, Volume Light.

Three notes that catch people:

• The reflection family is named Glossy in Cycles and Specular in Eevee. Same job, different label.
• Eevee’s specular path uses screen-space approximations and pre-filtered probes, so the Specular Light × Specular Color rebuild is the model. The actual Combined pass can drift from a hand-rebuild more visibly than in Cycles. Use the rebuild for relative changes, not as a bit-exact replica.
• Eevee does not render depth of field or motion blur into anything except Combined. If you rebuild the beauty from split passes in Eevee, post effects that were on the Combined pass do not come along for free. The math can be perfectly correct and the rebuild can still look “wrong” because of missing post effects, not because of bad nodes.

Four categories, four recipes

Each kind of pass listed above gets its own combine treatment. The first three are arithmetic moves on the beauty branch. The fourth is wiring, not arithmetic.

1. Beauty ingredients (the family rebuild)

Direct, Indirect, and Color for each family. These are the passes Cycles split on your behalf so you can change them. Recombine with (Direct + Indirect) × Color, then drop the finished family back into the rebuilt beauty.

When to reach for this: you want to dim hot reflections, recolor diffuse shading, or rebuild the beauty entirely so you can swap one family for an adjusted one.

2. Light Groups (already finished lighting)

A Light Group is a tag you put on certain lights at render time. You set it on a light’s Object Data Properties panel under Light Group, give the group a name, and enable it as a pass in the View Layer’s Light Groups list. Once that is set up, Cycles writes one extra Combined-style pass per group. That pass contains the full beauty contribution from those tagged lights only: diffuse, glossy, transmission, emission, all the families summed together, all the surface colors already multiplied in. It is not a partial family rebuild. It is a small finished render.

That is what “already finished” means here. The family math, including the multiply by every relevant Color pass, already happened inside the render for those lights. By the time the pass lands in the compositor, there is nothing left to multiply.

The combine recipe is therefore just Add: Key + Fill + Rim + World, in whatever ratios you want. Multiplying a finished Light Group by Diffuse Color colors something that was already correctly colored, which is how you ruin the lighting you just enabled groups to control.

3. Multipliers (AO, Shadow Catcher, and other 0-to-1 passes)

Ambient Occlusion is a grayscale pass between 0 and 1. Each pixel is roughly the fraction of ambient or sky light that makes it past nearby geometry to reach that surface point. That is the same physics as Diffuse Color (a fraction of incoming light), just from a different mechanism (occlusion instead of pigment). Fractions multiply, so AO multiplies. The recipe is image × AO in a Mix node set to Multiply.

(Worth knowing: Blender’s AO pass is a sampled approximation of occlusion, not a perfect physical measure. It is usually good enough as a stylized contact-shadow boost, but treat it as a useful mask, not as ground truth.)

One thing to know about workflow: in Cycles, the AO pass is separate from Combined. It is not automatically multiplied into the render. You enable it because you want to apply it yourself in comp. Multiplying Combined directly by AO darkens direct lighting too, which is overkill for most shots. The correct play is usually to multiply AO only into the indirect or environment portion of the beauty (or use it as a subtle soft mask), not the whole image.

Shadow Catcher works the same way for compositing CG shadows onto a real plate: plate × Shadow Catcher. Adding either of these to anything is using them backward.

4. Data passes (Mist, Depth, Cryptomatte, Vector, Position)

These are not lighting at all. They are coordinate or label data the compositor reads as input to other nodes. Vector feeds Vector Blur. Cryptomatte feeds the Cryptomatte mask node. Mist and Depth feed depth-based fades or fake depth of field. Position feeds relighting or world-space effects.

You do not Add or Multiply data passes into the beauty. You wire them into the specific compositor node built to read them, then that node’s output goes into the beauty branch.

The full placement rule across all four categories:

• Beauty ingredients (Direct, Indirect, Color): Add the light terms inside the family first, Multiply by the family’s Color, then Add the finished family into the rebuilt beauty. Two operations, in that order.
• Already-finished lighting (Light Groups, finished families like Emission and Environment): Add. They are already done, no Multiply step.
• Multipliers (AO, Shadow Catcher, other 0-to-1 fractions): Multiply. Never Add.
• Data passes (Vector, Cryptomatte, Position, Mist, Depth): not arithmetic. Wire into the specific compositor node built to read them, then send that node’s output downstream.

If you can answer “what is this pass carrying?” you can place any pass Blender adds in a future version, including ones you have never seen.

In real work, you fix one family, not the whole render

A full beauty rebuild from passes is great for learning. On a real shot I almost never do it. Too many places for the math to drift, too many connections to spot-check. Here is what I actually reach for:

1. keep Combined as your reference
2. rebuild only the family you want to change (say, Glossy)
3. adjust the finished family
4. re-merge it against Combined without double-counting

For step 4 the move is what people call the surgical patch. The math is short:

final = Combined − original Glossy family + adjusted Glossy family

The Glossy contribution is fused inside Combined along with every other family, and there is no socket to pull it out cleanly. So you rebuild the original Glossy from its passes ((Glossy Direct + Glossy Indirect) × Glossy Color), build the adjusted version the same way, then wire Combined - original + adjusted in the compositor. Diffuse and the rest of the image stay exactly as the renderer produced them. Only Glossy moves. The TryThis below walks the actual node-by-node build, including a step where you swap the recipe to feel the wrong path.

Why this only works on EXR data

This kind of arithmetic against Combined is the reason MultiLayer EXR exists. A MultiLayer EXR carries every pass in one file and keeps them as linear scene-referred values: numbers where doubling the value really does mean twice the light, with no cap at 1.0 and no display-color baked in. That linearity is what makes Add and Multiply behave like real light math. Save your rebuild work as PNG and you are working on already-baked pixels (clipped, gamma-shifted, display-ready), where the math no longer corresponds to physics. The recipes above stop working in any way you can predict. For the format-side story, see What the hell is an EXR file in Blender?.

The failure modes worth recognizing on sight

Before the failure list: Add is not the wrong node. Add is exactly right for Direct + Indirect inside a family, for summing finished families, and for summing Light Groups. The mistake is reaching for Add when the pass is meant to multiply (Color, AO) or for a data pass that should not touch arithmetic at all. With that out of the way, here are the four ways rebuilds go wrong:

Treating Color as another light pass

The rebuilt image lifts above the original because pigment is being added like illumination instead of shaping it.

Adding a rebuilt family on top of Combined

Combined already contains every family. Wiring a rebuilt Glossy on top without subtracting the original first means glossy shows up twice.

Treating data passes as arithmetic operands

Vector, Cryptomatte, Mist, and Depth are inputs to specific compositor nodes (Vector Blur, Cryptomatte, depth-driven mixes). Trying to Add or Multiply them into the beauty directly is a category error.

Expecting the rebuild to look as clean as a denoised Combined

The denoiser ran on the combined render. Pass-by-pass rebuilds have not been denoised yet. If your rebuild looks noisy, the math is probably fine. Denoising is a separate step you also need to handle.

What to take from this

Two things, in order of importance:

1. Add is for light. Multiply is for color or 0-to-1 masks. If you remember the physics, you can place a pass you have never seen in the right recipe.
2. Rebuild only what you need to change. A surgical edit against Combined is faster, smaller, and easier to spot mistakes in than a full beauty reconstruction.

Pick a pass next time you open the compositor and ask what it is carrying. If you can answer that out loud, the right node falls out of the question. If you cannot, look the pass up before you wire anything. Beats spending an afternoon wondering why the rebuild came out pinker than the render you started with.