Embree is a collection of high-performance ray tracing kernels, developed at Intel. The target user of Embree are graphics application engineers that want to improve the performance of their application by leveraging the optimized ray tracing kernels of Embree. The kernels are optimized for photo-realistic rendering on the latest Intel® processors with support for SSE, AVX, AVX2, and the 16-wide Xeon Phi™ vector instructions. Embree supports runtime code selection to choose the traversal and build algorithms that best matches the instruction set of your CPU. We recommend using Embree through its API to get the highest benefit from future improvements. Embree is released as Open Source under the Apache 2.0 license.
Embree supports applications written with the Intel SPMD Programm Compiler (ISPC, http://ispc.github.com) by also providing an ISPC interface to the core ray tracing algorithms. This makes it possible to write a renderer in ISPC that leverages SSE, AVX, AVX2, and Xeon Phi™ instructions without any code change. ISPC also supports runtime code selection, thus ISPC will select the best code path for your application, while Embree selects the optimal code path for the ray tracing algorithms.
Embree contains algorithms optimized for incoherent workloads (e.g. Monte Carlo ray tracing algorithms) and coherent workloads (e.g. primary visibility and hard shadow rays). For standard CPUs, the single-ray traversal kernels in Embree provide the best performance for incoherent workloads and are very easy to integrate into existing rendering applications. For Xeon Phi™, a renderer written in ISPC using the default hybrid ray/packet traversal algorithms have shown to perform best, but requires writing the renderer in ISPC. In general for coherent workloads, ISPC outperforms the single ray mode on each platform. Embree also supports dynamic scenes by implementing high performance two-level spatial index structure construction algorithms.
In addition to the ray tracing kernels, Embree provides some tutorials to demonstrate how to use the Embree API. The example photorealistic renderer that was originally included in the Embree kernel package is now available in a separate GIT repository (see Embree Example Renderer).
New features in Embree 2.3.3
- BVH builders more robustly handle invalid input data (Xeon™)
- Motion blur support for hair geometry (Xeon™)
- Improved motion blur performance for triangle geometry (Xeon™)
- Improved robust ray tracing mode (Xeon™)
- Added rtcCommitThread API call for easier integration into existing tasking systems (Xeon™ and Xeon Phi™)
- Added support for recording and replaying all rtcIntersect/rtcOccluded calls (Xeon™ and Xeon Phi™)
New features in Embree 2.3.2
- Improved mixed AABB/OBB-BVH for hair geometry (Xeon Phi™)
- Reduced amount of pre-allocated memory for BVH builders (Xeon Phi™)
- New 64bit morton code BVH builder (Xeon Phi™)
- (Enhanced) morton code BVH builders use now tree rotations to improve BVH quality (Xeon Phi™)
- Bug fixes (Xeon™ and Xeon Phi™)
New features in Embree 2.3.1
- High quality BVH mode improves spatial splits which result in up to 30% performance improvement for some scenes (Xeon™).
- Compile time enabled intersection filter functions do not reduce performance if no intersection filter is used in the scene (Xeon™ and Xeon Phi™)
- Improved ray tracing performance for hair geometry by >20% on Xeon Phi™. BVH for hair geometry requires 20% less memory
- BVH8 for AVX/AVX2 targets improves performance for single ray tracing on Haswell™ by up to 12% and by up to 5% for hybrid (Xeon)
- Memory conservative BVH for Xeon Phi™ now uses BVH node quantization to lower memory footprint (requires half the memory footprint of the default BVH)
New features in Embree 2.3
- Support for ray tracing hair geometry (Xeon™ and Xeon Phi™)
- Catching errors through error callback function
- Faster hybrid traversal (Xeon™ and Xeon Phi™)
- New memory conservative BVH for Xeon Phi™
- Faster Morton code-based builder on Xeon™
- Faster binned-SAH builder on Xeon Phi™
- Lots of code cleanups/simplifications/improvements (Xeon™ and Xeon Phi™)
New features in Embree 2.2
- Support for Motion Blur on Xeon Phi™
- Support for intersection filter callback functions
- Support for buffer sharing with the application
- Lots of AVX2 optimizations, e.g. ~20% faster 8-wide hybrid traversal
- Experimental support for 8-wide (AVX/AVX2) and 16-wide BVHs (Xeon Phi™)
New features in Embree 2.1
- new future proof API with a strong focus on supporting dynamic scenes
- lots of optimizations for 8-wide AVX2 (Intel Haswell™ architecture)
- automatic runtime code selection for SSE, AVX, and AVX2
- support for user-defined geometry
- new and improved BVH builders:
- fast adaptive Morton code-based builder (w/o SAH-based top-level rebuild)
- both the SAH and Morton code-based builders got faster (Xeon Phi™)
- new variant of the SAH-based builder using triangle pre-splits (Xeon Phi™)
- Intel® Core™ i7 (Haswell-based CPU, 4 cores @ 3.0 GHz)
- 7-8 million triangles/s for the SAH-based BVH builder
- 30-36 million triangles/s for the Morton code-based BVH builder
- Intel Xeon Phi™ 7120
- 37-40 million triangles/s for the SAH-based BVH builder
- 140-160 million triangles/s for the Morton code-based BVH builder
- Intel® Core™ i7 (Haswell-based CPU, 4 cores CPU @ 3.0 GHz)
- 1024x1024 resolution: 7.8 million rays per sec
- 1920x1080 resolution: 9.9 million rays per sec
- Intel Xeon Phi™ 7120
- 1024x1024 resolution: 47.1 million rays per sec
- 1920x1080 resolution: 61.1 million rays per sec
- support for the Intel Xeon Phi™ coprocessor platform
- support for high-performance "packet" kernels on SSE, AVX, and Xeon Phi™
- integration with the Intel SPMD Program Compiler (ISPC)
- instantiation and fast BVH reconstruction
- example photo-realistic rendering engine for both C++ and ISPC
Example performance numbers for Embree 2.1BVH rebuild performance (including triangle accel generation, excluding memory allocation) for scenes with 2-12 million triangles:
New features in Embree 2.0
Papers:Exploiting Local Orientation Similarity for Efficient Ray Traversal of Hair and Fur
Sven Woop, Carsten Benthin, Ingo Wald, Gregory S. Johnson, and Eric Tabellion
High Performance Graphics 2014
Embree - A Kernel Framework for Efficient CPU Ray Tracing
Ingo Wald, Sven Woop, Carsten Benthin, Gregory S. Johnson, and Manfred Ernst
ACM Transactions on Graphics (proceedings of ACM SIGGRAPH) 2014
Watertight Ray/Triangle Intersection
Sven Woop, Carsten Benthin, Ingo Wald
Journal of Computer Graphics Techniques (JCGT), Volume 2, Issue 1, pages 65-82, 2013.
Combining Single and Packet-Ray Tracing for Arbitrary Ray Distributions on the Intel MIC Architecture
Carsten Benthin, Ingo Wald, Sven Woop, Manfred Ernst, William R. Mark
IEEE Transactions on Visualization and Computer Graphics, Volume 18, Issue 9, 2012
Fast Construction of SAH BVHs on the Intel Many Integrated Core (MIC) Architecture
IEEE Transactions on Visualization and Computer Graphics, 18(1), 2012, pages 47-57
Embree Paper Talk at SIGGRAPH 2014
Embree Tutorial at SIGGRAPH 2014
Embree 2.0 Presentation at SIGGRAPH 2013
Embree 1.1 Presentation at SIGGRAPH 2012
Read the Embree Blog for more details about Embree.
Participate in Embree Forum Discussion.
Embree Support and Contact
For questions and bug reports please write us at email@example.com.
To receive notifications of updates and new features of Embree please subscribe to the Embree mailing list.
For information about compiler optimizations, see our Optimization Notice.