ART is a command-line system for physically based image synthesis. It offers a number of innovative features which are not standard in most other rendering systems:

  • Spectral rendering
    • Spectral reflectance and transmission measurements can be directly used
    • Hero wavelength spectral sampling is used within the path tracer
  • The ability to handle bi-spectral materials
    • Fluorescent surfaces and volumes are supported. To our knowledge, ART is still the only publicly available rendering software to support this fairly important appearance attribute.
  • Creation and manipulation of spectral images
    • ART features its own spectral image file format
    • It also supports spectral OpenEXR
    • Tools for the manipulation of these images are provided
  • Polarisation rendering
    • Polarisation support is a switchable feature, so comparisons can be made
    • Spectral result images can contain the polarisation state of light for each pixel
    • Visualisation tools for the polarisation state of result images are provided

These features are offered in a system which has the following general infrastructure:

  • A multithreaded uni-directional MIS path tracer
  • A physically-based sky dome lighting model
  • A proprietary but documented scene description language
    • Procedural modelling via loops and functions
    • CSG modelling with solid shapes
    • PLY meshes can be loaded as object geometry
    • A shading language for appearance modelling
    • Action sequences which describe the rendering process are part of the scene file
  • A tone mapping utility for the spectral image file format
  • A difference image generator

The gallery section showcases some of these features via a few representative result images.


Work on ART was funded by the Czech Science Foundation under grant number 16-08111S, with the title “Efficient Rendering of Light Polarisation Effects in Nontrivial Scenes”. One of the stated goals of the project was the eventual release of the rendering software which is being developed for the project: this is being achieved by the public release of ART.

Funding was also supplied by the DISTRO ITN, financed by the European Union via the Marie Skłodowska-Curie grant agreement No. 642841, and the PRIME ITN, grant agreement No. 956585.

System Requirements

Operating System

ART is command-line software, and UNIX command-line software at that. Which means that you need one of the following environments to build and run it:

  • MacOS, or
  • a reasonably modern Linux.

Currently, MacOS is the preferred environment for ART, due to the affinity of Xcode to Objective-C. But Linux also works without any problems, if you don’t mind that most editors there are not quite as comfortable with handling ObjC sources as they could be.

But what about ART on Windows?

What should work is installing ART in the recently introduced Linux-in-a-jar subsystem on Windows 10: but we have not tried this yet. Chances are that you have to tweak the CMakeLists.txt files of the project a bit to make things work, if you give it a shot. If you get this to run, we would definitively love to hear from you!

What we have tried, and what did not work all that well, is to build ART under some of the earlier “UNIX on Windows” environments, such as cygwin or mingw. With a bit of a struggle, ART 2.x can actually be built under some of these: specifically, the ones which emulate UNIX file systems, i.e. those where you do not have to re-write the file handling code in ART to deal with Windows drive letters and such. There are actually remnants of these efforts still to be found in the CMakeLists.txt files of the project.

However, due to the limited threading support that is being offered there, ART turned out to perform very poorly in these environments (essentially, it reverts to a slowed down single thread mode), so this work was not pursued further after rendering a few proof of concept images.

Required Software and Libraries

Prerequisites specific to the two main platforms are:

  • On MacOS: Xcode has to be present, along with the command line tools
  • On Linux: gcc or llvm, with GNUStep installed

Common to all platforms is that the following have to be present:

  • CMake
  • Sam Leffler’s ubiquitous libtiff
  • The littleCMS colour management library
  • LaTeX, if you want to build the handbook yourself
  • python3, if you want to run the functionality tests, and build the ARM reference manual
  • The OpenEXR library, if you want support for this format (ART can be built without it)

On MacOS, we have had good experiences with using homebrew as a way to install the extra components which are needed.


Over the years, a considerable number of people have contributed to ART. The two maintainers and main architects of the system were and are:

  • Robert F. Tobler - initial author, designer of the overall system structure, and its maintainer until ~2001. He did not work on ART after that timeframe, and instead became designer and project lead for the Aardvark rendering software at the VRVis research centre.

  • Alexander Wilkie - designed the polarisation capabilities of ART, the (bi-)spectral subsystem including the ARTRAW image format and the polarisation visualisation tools, was responsible for the 2.x refactoring, and a considerable number of smaller things, plus the MIS path tracer of ART 1.x. Current overall maintainer of the toolkit.

At the graphics research group of Charles University in Prague, a number of master and Ph.D. students contributed to ART 2.x in the years since 2008. In no particular order (but with a certain bias towards recent contributions), some of the main contributors are:

  • Alban Fichet: without him, the public release of ART simply would not have happened. Also, responsible for fluorescent volume tracing, the functionality tests, the ARM documentation, general cleanup of ART to ready it for release, and many other smaller things.

  • Michal Mojzík: wrote the current MIS path tracer, implemented the Hero sampling scheme, developed the current layered surface material code and the Torrance-Sparrow material, and made ART 2.x fluorescence capable (the fluorescence support which ART 1.x had was fundamentally incompatible with Hero sampling). In other words, with the exception of the polarisation features, he was directly responsible for a major part of the cool things that might make people want to download ART 2.x in the first place.

  • Chi Wang: considerable improvements to the polarisation subsystem.

  • Lukáš Hošek: added the sky dome model which is named after him.

  • Ivo Pavlík: ported the shading language from ART 1.x to ART 2.x, and wrote an implementation of the He-Sillion-Torrance-Greenberg BRDF. Due to technical issues caused by changed interfaces, the HTSG model is not part of the first release, but it might get re-added later.

  • Petr Zajíček: wrote the kD-tree raycasting acceleration which is capable of natively working with CSG operators.

  • Lukáš Novosad: work on PLY mesh import.

  • Kristina Bartová: improvements to the polarisation rendering sub-system.

At the Institute of Computer Graphics in Vienna, the following persons made significant contributions to ART 0.x or 1.x. in the 1996-2008 timeframe. Not all of their work has been ported to ART 2.x: in some cases, the code they wrote has either been lost, or is so incompatible with current ART that there is no reasonable way to port it. Other things are still in storage, and might yet see the light of day.

  • Andrea Weidlich: developed the original version of layered surfaces, made improvements to the shading language, added a volume material for bi-refringent crystals, wrote a bi-directional path tracer, and improved the polarisation ray tracing capabilities. Some of her improvements are still present in initial ART 2.x, others might yet be ported.

  • Thomas Gamper: modified ART to use GNUStep under Linux, instead of the old bare bones ObjC runtime provided with gcc, which was initially used on that platform. He also performed some of the spectral reflectance measurements which are part of the ART resource library.

  • Stefan Maierhofer: he implemented subdivision surfaces in ART 1.x, and wrote an excellent Ph.D. thesis about complex subdivision meshes which are generated by L-systems: ART was the visualisation tool for this work. Unfortunately, the corresponding ART code has been lost.

  • Caroline Larboulette: worked on improved hybrid photon tracing / path tracing renderers.

  • Heinrich Hey: path tracing research. The sub-version of ART he did his work on is one of those which has been lost.

  • Georg Zotti: work on sky dome models, and random number generators. His TMS QMC code is still in ART 2.x, and his LaTeX formatting is still used in the ART Handbook.

  • Robert Stepanek: created a scene graph node which contained a tileable ocean surface block generated via frequency spectrum synthesis. This code would need serious overhaul to work with ART 2.x, but could theoretically be revived.

  • Carl Eugen Hoyos: wrote a powerful distributed network rendering layer for ART 1.x which used Distributed Objects to transparently spread rendering jobs to remote machines, and gather the results back. He also wrote the first incarnation of impresario, which was then a network rendering control tool. It would be interesting to revive this codebase, but also a considerable challenge, as both Objective-C and ART have changed a lot since then.

  • Walter Haschka: support for NURBS. The relevant modules still exist, and could probably be ported to ART 2.x with reasonable effort.

  • Jan Přikryl: wrote the first path tracer for ART 0.x.