Beyond SH3
Test richer directional colour models against the same held-out views. The goal is to improve sharp reflections and transmission without losing interactive performance.
Synthetic neural rendering workbench
My earlier research showed where Gaussian splats reproduce materials well and where they fail. Neural Prism turns that finding into a controlled set of tools for testing the difference.
It renders an existing 3D asset, trains a neural scene and compares both results with the same cameras, lighting and colour pipeline.
Working prototype
Tested on Apple Silicon
Mojo + WebGPU
More hardware to validate
One controlled system
Neural Prism keeps the asset, camera, lighting and colour pipeline fixed while the rendering method changes. A visible difference can then be traced to the method under test, rather than to an unnoticed pipeline change.
Start with a glTF or GLB asset. Produce matched views, camera data and scene-linear EXR channels that become the reference for every later stage.
Mojo RenderTrain, evaluate and export Gaussian splats from the controlled capture. Error maps show where the learned scene differs from the reference.
Mojo SplatInspect PBR, progressive path-traced, splat and hybrid output through one live camera. The shared view makes the trade-offs visible.
WebGPU viewerBrowser renderer
The browser workbench uses Babylon.js Lite and custom WebGPU path-tracing shaders. One live camera moves between PBR, path-traced, splat and hybrid views.
The browser is therefore part of the experiment, not only a place to present the output. It lets the person inspecting the result see the same representation choices directly.
Progressive WebGPU path tracing
The sequence holds the Flight Helmet camera still and increases the samples per pixel from 8 to 256. This makes the reduction in Monte Carlo noise visible without changing the scene or framing.
The final pair compares the raw 256-sample image with its denoised result. The Dragon Attenuation image then shows the same process on a difficult transmissive material under a bright HDR environment.
At eight samples, Monte Carlo noise obscures much of the material detail. The camera, scene and framing stay fixed across the sequence.
Evidence from earlier research
Gaussian splats render quickly, but speed is not enough for product visualisation. Third-order spherical harmonics provide limited directional information, and that limit is clearest in reflections and transmission.



This held-out view keeps the full subject visible from the front and avoids the reverse of the checkerboard support, making the comparison easier to read.
Traditional splats use low-order spherical harmonics to vary colour with view direction. This compact model suits many diffuse surfaces, but it cannot reproduce many sharp reflection or transmission lobes.
Prism measures those errors while testing richer directional models. It also tests hybrid results that retain triangles for materials a splat cannot represent well enough.
Why Mojo
Graphics research often combines Python orchestration, C++ systems code and vendor-specific GPU kernels. Every boundary adds code to maintain and another place for an experiment to change before deployment.
Mojo provides high-level development and low-level control of CPU and GPU kernels in one language. In Prism, it covers path tracing, image processing, splat training and evaluation.
The aim is to reduce duplicated systems and make the research easier to move from a workstation to other accelerators and cloud hardware. That only matters if the same code remains correct on each target.
Neural Prism is in alpha and runs on Apple Silicon today. AMD, NVIDIA, Qualcomm and cloud support are planned, but they remain validation targets until the tests pass.
Project summary
Neural Prism is not a one-click photogrammetry service. It is an open test harness for researchers and artists who need synthetic ground truth and controlled comparisons.
Its purpose is to establish where neural rendering is already useful, measure where it fails, and use that evidence to build better representations for interactive delivery.