Getting started¶

Main features¶

• Foundation ready to use: easy interface to convert your algorithms to the transient domain.

• Python-only library for doing transient rendering in both CPU and GPU.

• Several integrators already implemented: transient pathtracing (also adapted for NLOS scenes) and transient volumetric pathtracing.

• Cross-platform: Mitsuba 3 has been tested on Linux (x86_64), macOS (aarch64, x86_64), and Windows (x86_64).

• Polarization tracking

• Differentiable transient rendering

The following video showcases mitransient simulating light at a trillion frames per second, imitating a femto-photography experiment.

Installation¶

We provide the package via PyPI. Latest release: .

To install mitransient you need to run:

pip install mitransient

which will also install the mitsuba Python package as a dependency.

Using your own compiled Mitsuba: mitransient and mitsuba have different variants that specify the number of channels (RGB image, monochromatic, etc.), hardware acceleration (execution in CPU, GPU, etc.). If you install mitransient/mitsuba via pip, you will have access to the following variants specified in this website. There are more variants available, but you will have to compile Mitsuba 3 yourself. For more information on using a custom Mitsuba 3 compilation, see Installation.

Usage¶

Rendering your first transient scene with mitransient is easy. The code below will render the famous Cornell Box scene in transient domain and show a video of the results:

import mitsuba as mi
mi.set_variant('llvm_ad_rgb')
import mitransient as mitr

scene = mi.load_dict(mitr.cornell_box())
img_steady, img_transient = mi.render(scene, spp=1024)

img_transient = mitr.vis.tonemap_transient(img_transient)
mitr.vis.show_video(img_transient)

Important: mitransient needs to be imported after mitsuba. The moment you add mitransient to the code, all of our transient-related plugins are registered in Mitsuba 3. At that point you can call mitsuba’s functions as normal (e.g. mi.render in the example above), and our additional utility functions (mitr.cornell_box, mitr.vis.tonemap_transient, etc.).

Tutorials¶

If this is your first time, we strongly recommend that you start with the Transient rendering tutorials. Going through these in order will give you an idea of the main features of mitransient. The rest of the tutorials assume that you’ve gone through the first tutorial in that series. You can find a full list of all tutorials on the sidebar.

Transient rendering

src/tutorials/transient_rendering_tutorials.html

Non-line-of-sight rendering

src/tutorials/nlos_tutorials.html

Transient polarization tracking

src/tutorials/polarization_tutorials.html

Differentiable transient rendering

src/tutorials/diff_tutorials.html

License and citation¶

This project was started by Diego Royo, Miguel Crespo and Jorge Garcia-Pueyo. See the GitHub page for the full list of mitransient contributors. Also see the original Mitsuba 3 license and contributors. If you use our code in your project, please consider citing us using the following:

@misc{royo2025mitransient,
      title={mitransient: Transient light transport in Mitsuba 3},
      author={Diego Royo and Jorge Garcia-Pueyo and Miguel Crespo and Óscar Pueyo-Ciutad and Guillermo Enguita and Diego Bielsa},
      year={2025},
      eprint={2510.25660},
      archivePrefix={arXiv},
      primaryClass={cs.GR},
      url={https://arxiv.org/abs/2510.25660},
}

Additionally, the NLOS features were re-implemented from our publication Non-line-of-sight transient rendering. Please also consider citing us if you use them:

@article{royo2022non,
      title        = {Non-line-of-sight transient rendering},
      author       = {Diego Royo and Jorge García and Adolfo Muñoz and Adrian Jarabo},
      year         = 2022,
      journal      = {Computers & Graphics},
      doi          = {https://doi.org/10.1016/j.cag.2022.07.003},
      issn         = {0097-8493},
      url          = {https://www.sciencedirect.com/science/article/pii/S0097849322001200}
}

What is transient rendering?¶

Conventional rendering is referred to as steady state, where the light propagation speed is assumed to be infinite. In contrast, transient rendering breaks this assumption allowing us to simulate light in motion (see the teaser image for a visual example).

For example, path tracing algorithms integrate over multiple paths that connect a light source with the camera. For a known path, transient path tracing uses the very complex formula of time = distance / speed (see [Two New Sciences by Galileo]) to compute the time when each photon arrives at the camera from the path’s distance and light’s speed. This adds a new time dimension to the captured images (i.e. it’s a video now). The simulations now take new parameters as input: when to start recording the video, how long is each time step (framerate), and how many frames to record.

Note: note that the time values we need to compute are very small (e.g. light takes only ~3.33 * 10^-9 seconds to travel 1 meter), time is usually measured in optical path distance. See Wikipedia for more information. TL;DR opl = distance * refractive_index