Houdini 20.0 Rendering

Rendering with RenderMan

On this page

RenderMan for Houdini

RenderMan provides its own bridge product called “RenderMan for Houdini”. Please follow this link for more information: setting up “RenderMan for Houdini”.

Legacy Setup

Earlier versions of Houdini shipped with dedicated RenderMan nodes and SOHO scripts. With the release of the “RenderMan for Houdini” bridge product, these nodes have been deprecated and hidden in $HFS/houdini/OPlegacyRMan (included in OPcustomize script). The following information is presented for legacy setups only.

Rendering with RenderMan is done in Houdini thru a RenderMan render output driver node. It generates a RIB stream and pipes it to the prman executable specified in the Command parameter. It is also possible to save a .rib file to disk, by turning on the toggle next to the Disk File parameter.

Under the hood, the output driver node runs SOHO scripts, taking into consideration the RenderMan version specifiedc in the Render Target parameter. The scripts inspect the scene and write out a corresponding RIB, compiling any VOP shaders such as RSL Material, if necessary.

Setting up RenderMan

In order for Houdini to be able to find all the necessary RenderMan tools, first you will need to set a few environment variables:

  • ensure the RMANTREE is set to the installed version of RenderMan, for example:

    export RMANTREE=/opt/pixar/RenderManProServer-21.0
  • ensure the search path includes the bin subdirectory of RenderMan, for example:

    export PATH=$PATH:$RMANTREE/bin
  • set the HOUDINI_DEFAULT_RIB_RENDERER to the desired version, for example:


After setting up these three environment variables, Houdini should be able to use RenderMan.

Choosing a renderer

Each RIB target renderer has its own executable, way of compiling shaders, attributes, options, and features. Much of this is handled by Houdini behind the scenes. However, as a big head start, you can give Houdini a hint as to which render you are using by setting the environment variable HOUDINI_DEFAULT_RIB_RENDERER to the render target you want to use. The list of renderers can be inferred by looking at the $HH/RIBtargets and also at $HH/soho directory and scanning the files. The current renderers include prman21.0.

Houdini uses this variable in several places. In the hrmanshader script (a wrapper around the shader compiler), the variable controls which compiler program to call. It also controls which properties appear on the RIB output driver.

To...Do this

Set the default RIB renderer

Set the HOUDINI_DEFAULT_RIB_RENDERER environment variable, for example:

# set up for prman21.0

Setting up the display driver

RenderMan version 20.2 and up ships with a Houdini display driver, so there is no need for any additional setup, beyond specifying houdini in the ROP node’s Display Device parameter. Once this is done, the RIB renderer will render directly to MPlay.

It is also possible to reconfigure RenderMan to remap framebuffer device to Houdini display driver, so that all framebuffer rendering goes to MPlay as well. This can be done in rendermn.ini with this line:

/displaytype/framebuffer houdini

Customizing the View: RenderMan menu

The render menu in viewports has an entry View:RenderMan. This will render the scene without having to create an output driver. However, Houdini needs to know which application to invoke to render the scene. This is determined by setting the environment variable HOUDINI_VIEW_RMAN.

To...Do this

Modify the “View: Renderman” menu command

To change the renderer used when you choose View: RenderMan from the render icon in the viewer, set the environment variable HOUDINI_VIEW_RMAN.

Overriding the shader path

Houdini will set the path to the default path each renderer expects. You can override the shader path in two ways:

  1. Set the path by adding the rendering parameter to the output driver (preferred method).

  2. Set the environment variable HOUDINI_RI_SHADERPATH.

If you customize the path, you should include $HFS/ri_shaders in the path for light shaders. If you don’t customize the path, Houdini will look for directories named ri_shaders in the HOUDINI_PATH.

For RIS shader plugins there is a HOUDINI_RI_RIXPLUGINPATH environment variable. But you don’t need to include $HFS/ri_shaders in your customization, since Houdini does not look for directories named ri_shaders because Houdini does not ship with any custom RIS shader plugins. Thus the implicit default of $RMANTREE/lib/RIS usually suffices.

Customizing object parameters

If you are using RenderMan as a primary renderer, you may not want to see all of the mantra parameters in your geometry objects. You can customize the geometry object to create objects with RenderManparameters instead.

To...Do this

Customize object parameters

  1. Create a Geometry object in Houdini.

  2. In the parameter editor, click the menu and choose Edit Rendering Parameters.

  3. Remove all of the mantra parameters.

  4. Add the appropriate RIB parameters.

    Different users may prefer different properties. The following list is not a complete list of all RenderMan parameters, but a list of useful ones.

    • Dicing

      • Binary Dicing

      • Raster Oriented Dicing

      • Motion Factor

    • Geometry

      • Automatically Compute N for Polygons

      • Render as points

      • Polys as subdivision

      • Backface Removal

    • Shading

      • Categories

      • Camera Hit Mode

      • Color (Cs)

      • Opacity (Os)

      • Matte

      • Cull Shading of Backface Surfaces

      • Shading Quality

  5. Choose Save As Permanent Defaults from the menu in the parameter editor. This will save the presets to the $HOME/houdiniX.Y/presets directory and can be moved to per-shot, per-job or per-site directories. For more information see the Houdini Path help.

Once you save the parameters as permanent default parameters, they will be applied to all new objects. (You can do the same with the light and camera objects, though lights should work fairly well out-of-the-box in Houdini).


You can improve shading quality by adding the Shading Interpolation parameter.

Importing shaders

You can use VOPs to create RSL shaders, or you can import other shaders that you have written. Importing is done by creating Houdini Digital Assets that correspond to the written shaders.

To import shaders, run a Python script which parse the output of sloinfo (prman), aqsltell (Aqsis), sdrinfo (Pixie), etc. Houdini ships with 2 scripts: slo2otl.py to convert prman shaders.

The scripts are reliant on being able to parse information about shader parameters, but should be fairly easy to customize for an unsupported renderer. The script tries to implicitly guess the HDA table type and is geared for RIS shaders which are VOPs, so light and displacement .slo files implicitly yeld a VOP HDA. You can force the HDA SHOP with the -t command-line switch.

For example:

slo2otl.py -t Shop -l myshaders.hda *.slo

This will create an HDA which can be loaded into Houdini. All of the recognized shaders will exist as SHOP nodes.


Windows requires you to run hython in order to run Python.

hython sdl2otl.py -l myrmanshaders.otl *.sdl

Hython will not find the sdl2otl.py script unless $HB is included in the Python path.

Building RSL shaders using VOPs

In addition to importing external .slo shaders described above, Houdini allows to build shaders using VOP networks such as RSL Material. You can assign RSL Material to objects by setting the Material parameter, or to individual primitives using the Material SOP, as described in the shading documentation.

RIS Rendering Mode

To use RenderMan’s RIS rendering mode, turn on the RIS Mode parameter in the RIS sub-tab of the Properties tab on the RenderMan node. You can then optionally specify an integrator shader in the Integrator parameter. Please see RIS shaders for more information.

See also


Mantra user guide



Next steps


Other renderers