Light that responds to the scene
Surface reflections, dynamic lighting, and dynamic shadows give glass, metal, and opaque materials their character. Path tracing brings these interactions together as objects and the camera move.
Nubix Engine
Light. Atmosphere. Impact.
Real-time path-traced materials, dynamic volumetrics, and interactive physics in one engine. Explore reflective glass and metal, light moving through fog, a deformable basketball, and destruction that changes the scene.
Nubix Engine in motion
Glass that catches the room. Fog that carries light. Objects that bend, bounce, and break.
A scene you can light, touch, and transform.
See through it. See the world in it.
Transparent glass spheres combine transmission and reflections. A dedicated glass-fog pass follows reflected and refracted rays through the volume, bringing the surrounding atmosphere into intact glass spheres and panes.
Atmosphere with depth and motion
NVIDIA Flow drives evolving smoke and fog. Sparse-volume rendering adds dynamic lighting and dynamic shadows within the volume, while volumetric ReSTIR reuses light-transport samples across space and time.
From sparse samples to a resolved image
DLSS 4.5 + Ray Reconstruction supports the surface rendering path. Volumetrics combine ReSTIR sampling with an optional recurrent neural denoiser deployed through TensorRT and CUDA. NRD denoisers are also integrated for surface rendering.
Three balls. Three distinct behaviors.
A FleX soft-body basketball deforms and bounces. Glass and metal balls use rigid-body dynamics, with different throw weights and material responses. PhysX handles collisions and the interaction of objects throughout the scene.
Impacts become part of the world
Blast turns collision-driven damage into fractured chunks and broken bonds. PhysX carries those pieces into the simulation, connecting a thrown object to a visible, physical change in the environment.
Over 40 rendered FPS. Smoother with 2×.
Nubix exceeded 40 FPS before generated frames were counted. In a separate default-scene benchmark, frame generation off delivered 51.4 FPS. With 2× Multi-Frame Generation enabled, the engine delivered 42.4 rendered FPS and 84.7 presented FPS.
The FPS figures above come from a separate 1920 × 1080 benchmark on an RTX 5070 Ti with DLSS Balanced and Ray Reconstruction. The featured recording was captured in 4K HDR. Rendered FPS counts engine-rendered frames; presented FPS includes generated frames.
Real-time · 4K (3840 × 2160) · HDR capture. The featured recording uses 2× Multi-Frame Generation alongside DLSS 4.5 and Ray Reconstruction, with path tracing at one ray per pixel. Streamline and NVIDIA Reflex connect reconstruction to presentation; supported generation modes are selected according to GPU capability.
Generated frames improve presentation smoothness. Physics and input continue at the rendered-frame rate.
Rendering and simulation, engineered together.
Nubix is my independent C++ engine, bringing DirectX 12 and HLSL rendering together with NVIDIA simulation and reconstruction technologies. The work spans GPU resource lifetimes, rendering passes, physics integration, model training, and live validation.
Runtime controls expose lighting, fog, denoising, and frame-generation settings. Capture and profiling tools connect what appears on screen to the buffers, timings, and numerical checks behind it.
Read the PhysX & Blast integration article ↗Validation captures
Five archived comparisons from the rendering and reconstruction work. Original panel labels are preserved; select any image to inspect the full-resolution capture.
01 · ReSTIR: temporal and spatial reuse
Three-scattering-event case from the static convergence audit. The original panels compare fresh sampling, individual reuse modes, and combined reuse against the native reference.
02 · ReSTIR: dense fog and longer paths
Seven-scattering-event dense-fog case from the same audit. This close view makes the noise structure across the labeled reuse modes easier to inspect.
03 · Reconstruction stages against a path-traced estimate
Earlier quality comparison showing the independent path-tracing estimate alongside raw, denoised, and resolved output. The top row uses ReSTIR; the bottom row uses native sampling.
04 · Neural reconstruction across a volume sequence
Earlier pilot-model validation preview for clip 0081. Frames 0, 2, 4, and 7 compare noisy input, neural reconstruction, and the 4,096-sample-per-pixel reference. This records the pilot model, rather than the later epoch-750 deployment.
05 · Runtime neural-model comparison
Earlier live deployment comparison with noisy HDR input, TensorRT output, and PyTorch output. This view checks agreement between execution paths; it is separate from a converged-reference image-quality comparison.
ReSTIR & neural-denoiser validation
Recorded checks from September 18–21, 2026 cover raw volumetric sampling, the deployed neural model, and recurrent history. Reproducible capture tools connect GPU tensor dumps, Python analysis, PyTorch evaluation, and TensorRT execution.
Volumetric ReSTIR: convergence against reference renders
Three static cases with path lengths of 1, 3, and 7 scattering events were tested at 640 × 360 on an RTX 5070 Ti. Each mode accumulated 1,024 frames after warm-up. Two independent native path-tracing reference splits provided 65,536 samples per pixel in total. Neural denoising and upscaling were disabled to isolate raw fog RGB.
- Mean RGB energy: Combined temporal and spatial reuse differed from the reference by −0.248%, −0.366%, and +0.013% in the three cases.
- Convergence: Log-MSE slopes were −0.945, −0.996, and −0.992, close to the expected −1 trend as more frames were accumulated.
- Numerical checks: No invalid or clipped accumulation blocks and no regional RGB discrepancies flagged at the configured tolerance. Stored-path, reservoir-bound, and long-path checks passed.
These are static consistency checks against Nubix’s own native path tracer, which shares its SHARC-assisted lighting model. They do not establish equivalence to an external renderer or quality under motion.
Neural denoiser: deployment fidelity
The epoch-750 recurrent model was validated in a 1,040-frame live run at 1280 × 720. Four dense-fog captures passed guide-channel, finite-output, temporal-history, and analytic-opacity checks.
- GPU tensor transfers: Guide, HDR-input, and output packing matched the expected FP16 tensors exactly.
- TensorRT versus PyTorch: On identical inputs, mean normalized absolute error was 0.0331%, with a −0.0001848% relative energy change.
- Temporal alignment: A separate six-frame capture checked motion reprojection and explicit history reset. Independent CPU gathering matched GPU history to a maximum HDR difference of 9.54 × 10−7; the reset frame correctly contained zero history.
- Earlier dense-fog validation run: Neural inference averaged 3.15 ms over 160 measured frames, while that workload averaged 37.58 ms per frame (26.61 FPS). This historical measurement uses a different workload from the newer default-scene performance results above.
These checks validate deployment fidelity and history alignment, rather than denoising accuracy against a converged image. The 1080p TensorRT engine also built successfully; live deployment validation used 720p. Neural filtering remains optional.
Libraries, research & acknowledgments
Nubix brings together NVIDIA libraries, published rendering methods, and engine-specific simulation and reconstruction work. Its current rendering code builds on NVIDIA’s NRD Sample and NRI framework. The sources below credit that foundation and explain where each technology fits.
NVIDIA rendering and reconstruction
- NRD Sample — The upstream path-tracing and denoising sample behind Nubix’s current renderer, including reference patterns for surface lighting, glass, and reconstruction.
- NVIDIA Rendering Interface (NRI) — GPU resource and command interfaces used by the renderer and its DirectX 12 integrations.
- NVIDIA Real-Time Denoisers (NRD) — Surface denoising, including REBLUR and RELAX. Nubix’s recurrent volumetric neural denoiser is a separate pipeline.
- Spatially Hashed Radiance Cache (SHARC) — Cached scene radiance used by the rendering path and volume-boundary lighting.
- NVIDIA DLSS — Super Resolution and Ray Reconstruction integration. Streamline supplies the frame-generation and Reflex integration used for presentation.
- TensorRT and CUDA — Deployment of the trained volumetric predictor, GPU filtering, and shared-resource inference.
Simulation and sparse volumes
- NVIDIA PhysX — Rigid-body dynamics, collision handling, and scene simulation.
- NVIDIA Blast — Destruction assets, bonds, damage, and fracture integration.
- NVIDIA FleX — Particle-based simulation used by the inflatable-cloth and deformable basketball implementation.
- NVIDIA Flow — Evolving smoke and fog simulation.
- OpenVDB / NanoVDB — Sparse-volume data and GPU-accessible volume representation.
Research implemented or cited in the code
- Fast Volume Rendering with Spatiotemporal Reservoir Resampling — Daqi Lin, Chris Wyman, and Cem Yuksel, 2021. The research basis for Nubix’s volumetric ReSTIR estimator and temporal/spatial reservoir reuse. Authors’ reference implementation ↗
- Interactive Path Tracing and Reconstruction of Sparse Volumes — Nikolai Hofmann, Jon Hasselgren, Petrik Clarberg, and Jacob Munkberg, 2021. The reference for sparse-volume path tracing, recurrent neural reconstruction, and the denoiser’s guide-input contract.
- Sampling the GGX Distribution of Visible Normals — Eric Heitz, 2018. Cited in Nubix’s ray-tracing shader for microfacet sampling and Monte Carlo throughput evaluation.
- A Low-Discrepancy Sampler that Distributes Monte Carlo Errors as a Blue Noise in Screen Space — Eric Heitz, Laurent Belcour, Victor Ostromoukhov, David Coeurjolly, and Jean-Claude Iehl, 2019. Cited by the shader’s screen-space sampling code.
- The Iray Light Transport Simulation and Rendering System — Alexander Keller and colleagues, 2017. Appendix 3 is cited in the shader’s ray-direction and shading-normal correction to avoid self-intersections.
Research behind the integrated simulation library
Unified Particle Physics for Real-Time Applications — Miles Macklin, Matthias Müller, Nuttapong Chentanez, and Tae-Yong Kim, 2014. FleX’s documentation identifies this paper as a foundation of its particle-based solver. Nubix uses that solver through FleX for its deformable objects.
Nubix’s contribution is the engine integration, extensions, interactive behavior, volumetric implementation, training workflow, and validation shown on this page. The upstream libraries and research methods remain credited to their respective authors. The links above describe the technologies; Nubix’s own captures and measurements document this integration.