XRT is a raytracing based programmable rendering system for photo-realistic image synthesis built around a plug-in architecture design.

XRT main features

  • Extensibility

XRT is built around a tiny core. Everything else (primitives, intersection accelerators, scene file readers, shaders, I/O imaging, cameras, output filters, samplers, bucket ordering) is a plug-in.

  • Simple API

Based on Gelato API 2.0 with a few extensions to handle all plug-ins classes ( relighting and command calls are not supported )

  • Python binding

XRT ships with a scene format plug-in (pyg) that reads Python scripts that make calls to the Gelato API. This provides a flexible, fully scriptable method for scene input.

  • Multiple scene input formats

XRT does not prescribe a specific scene file format, forcing you to convert all data into that format. Instead, XRT has a simple API for the creation of scene format plug-ins. When a file is input, the plug-in (DSO/DLL) for that format is dynamically loaded and told to read the scene file. Thus, you may store your scene in any format for which there is a plug-in and you may freely mix different files in different formats within a single scene.

  • Programmable shading & lighting

Shaders are written using a modified version of the Open Shading Language which supports light shaders and gathering lights in surface and volume shaders.

  • Shader layers

Instead of allowing only a single surface, displacement, volume, or light shader per object, XRT allows you to assign multiple shaders of each type to an object. You may call several shaders in turn, specifying that one shader’s outputs be connected to the next shader’s inputs. This allows you to compose the operations of component shaders without modifying (or even having access to) the source code of any of the shaders involved, creating complex shaders without coding. For example, you can make any surface glossy by layering a "gloss" shader atop any other shader, without needing the source code to either.

For detailed information, you may want to check the Technical Reference Guide that comes with the XRT distribution and the RenderMan Interface Specification (see Links page)

Current features

Core capabilities

The Core implements the Gelato API and provides a number of base services

  • Raytracing engine
    • eye
    • reflection/refraction
    • shadow with support for partially transparent objects
    • multi-threaded rendering
    • ray differentials for partial derivatives
  • Shading language library
  • Plug-in management
  • Scene hierarchy management
    • scene attributes stack
    • object attributes stack
    • transformation stack
    • instancing
    • named coordinate systems
  • Geometry sets
  • Shading network management
  • Primitive variables (assignment of arbitrarily named and typed data to geometric vertices and interpolation of the values across the surface, passing the resulting values to shaders)
  • Global illumination
    • Irradiance caching
    • Ambient occlusion
  • Motion blur
    • transformation blur
    • camera blur
  • Area lights are supported for some primitives.
    • triangle
    • quadrilateral
    • bilinear patch
    • disk
    • sphere
    • cylinder
  • Constructive solid geometry
    • union
    • intersection
    • difference
  • Texturing (through OIIO)
    • plain textures
    • lat-long environment maps
  • Image I/O (through OIIO)


Primitives Primitives (continued) Intersection accelerators Scene file readers Shader types
  • points
  • curves
    • piecewise linear with/without normals
    • piecewise rational/non rational cubic (Bezier, B-Spline, Catmull-Rom, Hermite, Power basis) without normals
  • quadrics (partial/complete)
    • sphere
    • cone
    • cylinder
    • disk
    • hyperboloid
    • paraboloid
    • torus
  • polygon (single or mesh)
    • concave
    • convex (triangle and quad as special cases)
    • with holes
  • patch (single or mesh)
    • bilinear
    • bicubic (Bezier, B-Spline, Catmull-Rom, Hermite basis)
  • NURBS (with trim curves)
  • CSG operators (union, intersection, difference)
  • implicit surfaces
  • Catmull-Clark subdivision surfaces (texturing and primitive variable are not supported)
  • OpenVDB level sets
  • blobbies
    • sphere
    • segment with varying radius
    • capsule
    • plane
    • cube
    • constant
    • repelling plane
  • volumes
    • sphere
    • cone
    • cylinder
    • box
    • OpenVDB volume densities
  • bvh
  • uniform grid
  • list (a.k.a brute force)
  • qbvh
  • sah-kdtree
  • rib (ascii & binary)
  • nff
  • aff
  • yst (YASRT input format)
  • pyg (ascii only)
  • ply
  • obj
  • surface
  • displacement
  • light
  • volume

Cameras I/O image formats Image filters Samplers Bucket rendering order
  • orthographic
  • perspective (with depth of field support)
  • equirectangular (a.k.a lat/long projection)
  • bmp
  • cineon
  • dds
  • dpx
  • exr
  • fits
  • gif
  • hdr
  • ico
  • iff
  • jpeg
  • jpeg2000
  • png
  • pnm
  • psd
  • ptex
  • raw
  • rla
  • sgi
  • softimage
  • tga
  • tiff
  • webp
  • zfile
  • iv (framebuffer viewer)
  • box
  • catmull-rom
  • gaussian
  • mitchell
  • sinc
  • triangle
  • uniform
  • stratified
  • low-discrepancy
  • correlated multi-jittered
  • horizontal
  • vertical
  • diagonal
  • spiral
  • hilbert
  • z-order
  • random

Note on primitives

Point positions can be either an (x,y,z) triplet or an (x,y,z,w) 4-vector or a (z) coordinate. Color, opacity, normal, (s,t) texture coordinates attributes are supported for all primitives ( except for concave polygons and convex polygons with more than 4 vertices ). "constant", "perpiece", "linear", "vertex" interpolation types are available. Orientation and sidedness attributes are handled.
Except where indicated, XRT primitives capabilities should match RenderMan Interface Specification 3.2

Note on shaders

Displacement shaders do not displace geometry but perform bump mapping.


  • Programs
    • xrt : renderer
    • oslc : Open Shading Langage compiler
    • maketx : texture compiler
  • Client Libraries
    • libri : implement RenderMan API 3.2
  • Python bindings for Gelato and RenderMan APIs

Missing features

  • Grass type curves
  • NURBS curves
  • True displacement
  • Imagers
  • Global illumination
    • Photon mapping
    • Point clouds
    • Brick maps
    • Caustics
  • Stereo rendering
  • Matte objects
  • Motion blur
    • deformation blur
    • attributes blur
  • Package a Windows installer

A renderer is a never-ending story …