The render node

The Render node is where your 3D scene becomes a picture — it gathers everything in front of the camera, lights it, and hands back an image.

The Render node is the single crossing point from a 3D scene to flat pixels. Cameras are just viewpoints and lights are just lights — nothing turns into an actual image until a Render node does it. Feed it your scene, choose a camera, and it gives you a finished frame you can composite, grade, or export.

What it does

When the Render node cooks, it walks the whole scene once: it draws every solid object, casts shadows, adds ambient occlusion and any reflections, then lights everything in one pass. After that it layers in the see-through things — volumes, Gaussian splats, glass and refraction, glowing and unlit surfaces — over the lit result. Finally it runs your post effects and tone-maps the bright, wide-range image down to something your display can show.

You don't have to think about that order. You wire a scene in and get an image out. But it's worth knowing the shape of it, because it explains why some things composite over others (a transparent object always lands on top of the solid scene behind it) and why effects like Bloom or Depth of Field apply to the finished frame.

You rarely need more than one Render node. It already sees the entire scene through your camera. Reach for a second one only when you genuinely want a separate baked image — for example a reflection feed or a picture-in-picture from another camera.

Choosing a camera

The Render node renders through a camera. Leave its camera input empty and it uses the active viewport camera, so the render follows however you orbit and zoom. Wire a Camera into it and the render locks to that viewpoint instead — useful for a fixed shot, a second angle, or a result you'll export.

See Cameras for setting up and animating cameras, and Choosing a renderer for picking which renderer draws the scene.

Output passes

Beyond the final lit colour, the Render node can also hand out the extra information it computed along the way: depth (how far each pixel is from the camera), surface normals (which way each surface faces), and world position. These are the building blocks for compositing tricks — fog by depth, relighting, masking by position — without re-rendering.

Turn on only the passes you need. Each one is extra work, so leaving them off keeps the render lean.

The renderer that ships is DNA's built-in GPU renderer. Plugging in external renderers — path tracers, or Cycles/Eevee-style engines — is a planned extension point, not something available today. See Choosing a renderer.

Parameters

ParameterTypeDefault
includeAnyCollection(AttributedCollection { col...
cameraOneOf([Camera3D])
bake_widthNumber1024
bake_heightNumber1024
reprojectString"Live"
bake_frameNumber0
pass_typeString"Color"
normal_spaceString"World"
position_rangeNumber10
position_offset_xNumber0
position_offset_yNumber0
position_offset_zNumber0
ssao_enabledBooleantrue
ao_radiusNumber1
bloom_enabledBooleanfalse
bloom_thresholdNumber1
bloom_intensityNumber0.500
dof_enabledBooleanfalse
dof_focus_distanceNumber5
dof_focus_rangeNumber3
dof_max_blurNumber10
outline_enabledBooleanfalse
outline_strengthNumber1
outline_thresholdNumber0.100
outline_color_rNumber0
outline_color_gNumber0
outline_color_bNumber0
motion_blur_enabledBooleanfalse
motion_blur_intensityNumber1
motion_blur_maxNumber20
post_process_orderString"Bloom,DoF,Outline,MotionBlu..."
stereo_enabledBooleanfalse
stereo_ipdNumber0.063
stereo_convergenceNumber5
curve_width_scaleNumber1
taa_enabledBooleanfalse
ssr_enabledBooleanfalse
ss_shadows_enabledBooleanfalse
ssgi_enabledBooleanfalse
gtao_enabledBooleanfalse
auto_exposure_enabledBooleanfalse
rt_enabledBooleanfalse
rt_shadowsBooleantrue
rt_aoBooleantrue
rt_reflectionsBooleanfalse
rt_giBooleanfalse
denoise_passesNumber3
drive_viewportBooleantrue
positionVec3(0, 0, 0)
rotationVec3(0, 0, 0)
scaleVec3(1, 1, 1)
anchorVec3(0, 0, 0)
opacityNumber1

See also