On this page

In the Karma rendering pipeline, there are three separate types of filters.

Each filter works on AOV data at different stages of the rendering pipeline. Sample filters access raw sample data straight from ray evaluation. These filters run independent of any other samples.

Pixel filters combine multiple samples into a single pixel value. These filters.

Image filters process the entire image, after all the pixels have been resolved.

You can get a list of all filters using the command line tool by running:

karma --filters

At the current time, this doesn’t list any options to control filters.

Sample and Image filters are “global” and run on all AOVs simultaneously. For example, a sample filter might take multiple AOVs for different color components and sum them into a different AOV. An image filter might take several AOVs and use them to run a denoiser on other AOVs. There can be multiple Sample and Image filters for each render.

On the other hand, Pixel Filters are defined on each AOV individually. Thus, a color AOV might have a Pixel Filter that averages samples together, while an AOV for surface normals might take a single sample. Each AOV only has a single Pixel Filter defined.

Sample and Image filters are specified using a JSON string. Each filter is specified by a JSON list of 2 elements. The first element specifies the name of the filter, the second argument is a dictionary of arguments to control the filter’s behaviour.

Image Filters

ocio [arguments]

  • string planes <aov_pattern> The list of AOVs to be processed by OCIO (required)

  • string output <output_space> Output color space (required)

  • string input <input_space> Source color space (default “scene_linear”)

  • string looks <looks> A comma separated list of color gradings

Example: [ "ocio", {"planes":"C,diff*,spec*", "output":"sRGB"} ]

denoise [arguments]

  • string engine The denoiser to apply (for example “oidn” or “optix”)

  • string aovs List of AOVs to be denoised (defaults to “Cf”)

  • bool albedo Pass “albedo” plane to denoiser

  • bool use_N_input Pass “N”, “Ng” or “normal” plane to denoiser

  • bool use_gl_output Output directly to OpenGL

Example: [ "denoise", {"engine":"optix", "use_n_input":true, "use_albedo_input":true ]

Sample Filters

colorlimit [arguments]

  • string planes <aov_pattern> The list of AOVs to be color limited

  • float colorlimit <value> The maximum channel value allowed

Example: [ "colorlimit", {"planes":"C*,color*,diff*", "colorlimit":10.0} ]

copyalpha [arguments]

  • string planes <aov_pattern> The list of planes as input

This is added automatically by the renderer to copy the Af render global to the 4th component of any AOVs defined by LPE.

ocio [arguments]

  • string planes <aov_pattern> The list of AOVs to be processed by OCIO (required)

  • string output <output_space> Output color space (required)

  • string input <input_space> Source color space (default “data”)

  • string looks <looks> A comma separated list of color gradings

This sample filter is primarily an example since it’s much more efficient to do color correction in the image filter (after samples have been combined by pixel filters).

Example: [ "ocio", {"planes":"C,diff*,spec*", "output":"sRGB"} ]


You can chain multiple image filters (or sample filters):

    [ "denoise", {"engine":"oidn", "aovs":["Cf","diffuse","specular"]} ],
    [ "ocio", { "planes":"C,diff*", "output", "sRGB" }]

Pixel Filters

Radial Pixel Filter

Names: bartlett, blackman, box, catrom, gauss, hanning, mitchell, sinc

These pixel filters are radial filters which combine samples using the given filter shapes.


  • float width <filter_width> The filter width

Example: [ "gauss", {"width":2.5} ]

Unit Box Filter (ubox)

Uniform box filter. This simply averages all the samples which fall within a pixel. This is different than the box filter which blends in samples from adjacent pixels (based on the filter width).

Min Max filters (min, max)

Take only the sample with the minimum or maximum value.

omin, omax

Currently, these are synonyms for the min, max filters.

ocover, edge, idcover

Currently, these are not implemented

Pixel Oracles

Pixel Oracles are related to filters in karma. Oracles are used to tell the renderer where additional samples need to be sent. Unlike filters, Oracles take a simple string which is parsed into arguments.

Currently, there are two oracles:


  • Uniformly distribute rays to each pixel. Each pixel will always get the same number of ray-samples.


Distribute rays based on variance in the rendered image. Options:

  • minrays: The minimum number of samples

  • variance: Specify the pixel variance

  • plane: The image plane to measure

  • ociomode: Apply OCIO transform when measuring variance. Set to 0 to disable (gamma 2.0), 1 to choose color space based on OCIO Display and View, 2 to specify OCIO color space directly.

  • ociodisplay: Specify OCIO display (ignored unless ociomode is 1)

  • ocioview: Specify OCIO view (ignored unless ociomode is 1)

  • ociocolorspace: Specify OCIO color space (ignored unless ociomode is 2)

Example: [ "variance", {"minrays":2, "plane":"C", "variance":0.01} ]




  • Importing SOP geometry into USD

    Details of how Houdini converts SOP geometry to USD, and how you can control the process.

  • Component Builder

    The Component Builder tool puts down a network snippet for creating a USD model from SOPs, with support for materials, variants, payloads, and layering.


  • Edit node

    Interactively transforms prims in the viewer. Can use physics collisions to position props realistically.

  • Layout node

    Provides tools for populating a scene with instanced USD assets. You can place individual components, paint/scatter components in different ways using customizable brushes, and edit existing instances.

  • Custom Layout Brushes

    How to create layout brush digital assets you can use to customize the behavior of the Layout LOP.


  • Shader Framework

    Describes the Solaris shading framework, including shader node translation to USD primitives.

  • Using MaterialX with Karma

    Houdini has VOP node equivalents of the MaterialX shader nodes. You can build a shader network using these nodes, or import an existing MaterialX shader, and use them with Karma (Houdini’s USD renderer).

  • /solaris/materialx_nodes

Karma rendering