Ray tracing engine

OpenMoonray is a production-grade physically based rendering system and path-tracing engine. It simulates the physical behavior of light to generate high-fidelity photorealistic images and is compatible with Universal Scene Description files for visualizing complex 3D scenes and production pipelines. The system is designed as a distributed rendering framework, capable of splitting heavy computational workloads across multiple machines or cloud clusters to accelerate image generation. It integrates OpenColorIO for consistent color management across different display devices and color spaces.

Kajiya is a physically based rendering engine and real-time global illumination renderer. It utilizes a GPU-accelerated path tracer to simulate real-world material properties, such as roughness and metalness, to achieve photorealistic visual results. The engine incorporates a temporal super-resolution upscaler to increase final render resolution by reconstructing images from lower-resolution internal frames. It also generates high-fidelity reference images through path-tracing to verify the visual accuracy of real-time lighting outputs. The system covers 3D scene visualization and asset mana

This project is a browser-based, physically based path-tracing renderer built on WebGL and integrated with Three.js. It functions as a real-time global illumination engine, calculating light bouncing, soft shadows, reflections, refractions, and color bleeding interactively within web environments. The rendering system incorporates progressive multi-pass accumulation to refine noisy images iteratively over multiple frames, alongside GPU-accelerated spatial acceleration structures and bounding volume hierarchies to handle complex geometry. It supports diverse material types such as refractive

Mitsuba is a physically based rendering engine that calculates realistic light interactions to produce accurate synthetic images using both biased and unbiased numerical integration techniques. It is designed for computer graphics research and supports interactive three-dimensional scene inspection through a graphical interface that provides progressive real-time previewing, refining images iteratively when movement stops. The system features a plugin-based architecture that dynamically loads modular components at runtime to incorporate custom materials, light sources, and complete rendering

Mitsuba 3 is a high-performance physically based rendering framework that operates as a CPU and GPU render engine. It functions as a spectral rendering system and a differentiable path tracer, simulating the transport of light as spectral or polarized data through materials and geometry. The system is distinguished by its differentiable rendering pipeline, which calculates derivatives of images relative to input parameters to enable inverse rendering and optimization. It utilizes a just-in-time compilation layer to transform rendering logic into optimized kernels for hardware-agnostic executi

Mitsuba 2 is a physically based ray tracing engine and differentiable rendering framework designed to simulate realistic light transport and compute exact gradients of the rendering process with respect to scene parameters. The software functions as an optical simulation tool that models complex phenomena using monochromatic, RGB, or spectral color representations alongside optional polarization effects. The system incorporates an automatic differentiation engine that records mathematical operations during the rendering pass to solve inverse problems and optimize designs. A plugin-based scen

This project is a physically based rendering system and ray tracing engine designed to generate photorealistic images. It operates as a spectral rendering system that records radiance across discretized wavelength buckets and functions as a volumetric path tracer to compute light scattering and absorption within participating media. The engine utilizes GPU acceleration to execute its rendering pipeline on parallel graphics hardware. It integrates real-world optical data, such as measured spectral power distributions and lens description files, to simulate the behavior of physical camera syste

This project is a ray tracing engine and C++ rendering project designed to simulate the physical behavior of light to generate 2D images from 3D scenes. It serves as a computer graphics tutorial and educational implementation intended to teach the fundamental mathematical and algorithmic principles of 3D graphics programming. The implementation focuses on the foundations of light transport and scene geometry. It utilizes Whitted-style recursive raytracing to simulate reflections and employs Lambertian diffuse shading to calculate surface brightness. The engine handles 3D scene rendering thro

Renderer is a low-level software graphics engine implemented in standard C for educational and experimental real-time computer graphics. It functions as a CPU rasterizer that computes vertex transformations, clipping, texturing, and lighting entirely through software computation without requiring hardware acceleration. The software includes a geometry pipeline supporting depth and alpha testing, geometry clipping and culling, and perspective-correct attribute interpolation. Its lighting and shading subsystem provides advanced physical simulation including metallic-roughness and specular-gloss

EveryRay Rendering Engine is a high-performance graphics framework designed for real-time three-dimensional rendering. It utilizes a physically based deferred rendering pipeline to simulate realistic light behavior, incorporating global illumination, cascaded shadow mapping, and advanced volumetric effects to produce high-fidelity visual output. The engine distinguishes itself through a unified graphics abstraction layer that enables consistent performance across diverse hardware backends by translating high-level commands into specific instructions. It further optimizes complex environments

This project is a ray tracing reference implementation and educational resource for building a Monte Carlo path tracer from scratch. It serves as a guide for physically based rendering, demonstrating how to simulate the behavior of light and materials to create realistic images. The implementation includes a spatial hierarchy accelerator to optimize intersection tests and a system for generating images in the portable pixmap format. It provides a community reference library of implementations across various programming languages and distributes complete source code archives for study. The pr

TRELLIS.2 is a generative image-to-3D system that creates high-resolution 3D assets with physically based rendering materials from 2D images. It utilizes a sparse voxel representation to handle complex topologies and internal structures without relying on iso-surface fields. The project features a structured latent space representation that maps geometry and texture attributes to maintain visual fidelity. It employs an optimization-free geometry reconstruction process to decode latent representations directly into voxel grids and includes a PBR texture generator for synthesizing base color, r