The current trend in the development of graphics hardware is
making it more flexible, so that users can come up with unique features and
create things that go far beyond anything the chip designer could dream
of.
The tool to allow this flexibility is a specialized programming language,
a so-called shading language. Given that a graphics chip is not a general
processor, these shading languages differ from regular programming
languages. So far, most of the existing shading languages tried to mimic
widely used standard languages (like assembler or C++) to lower the
barrier of entry for new users.
However, that might not always be the best approach, as high-level
languages like C++ can be hard to optimize and match to the constraint
environment of programmable graphics hardware. Therefore the approach
takes with Renaissance is using a functional language as a basis and
taking it from there.
Future directions are looking into completing the language, opening it up more to inclusion into scenegraph systems like OpenSG. This demands new ideas for looking at the orthogonality of shaders, which will benefit from the strict functional nature of Renaissance. We're also planning to look into using the fact that we have full control over the language and the fact that as a functional language each subexpression has a unique value to enable new and better debugging methods for shaders, which right now is very hard.