Path Tracing

Every photorealistic image you see in a modern animated film was built the same way: fire a ray from your eye through each pixel, let it bounce around the scene, and average up the light it collects. Do that enough times per pixel and the noise dissolves into a perfect image. This technique is path tracing, and it works because of a simple mathematical fact — the average of many random samples converges to the true answer.

The "true answer" is the rendering equation, written down by James Kajiya in 1986. It says the light leaving a surface in any direction equals the light the surface emits plus all the reflected light arriving from every direction in the hemisphere above it. Solve it exactly and you have a perfect simulation of physics. The catch: the equation is an integral over infinitely many incoming directions, and each of those directions leads to another surface with the same integral, creating an infinite recursion.

Path tracing breaks the recursion by sampling. Instead of integrating over all directions, you pick one random direction per bounce, trace it, and repeat. A single path is a terrible estimate. But by the law of large numbers, the average over thousands of paths converges to the exact integral — and with it, to a physically correct image.

The algorithm was formalized by Kajiya in the same 1986 paper that introduced the rendering equation. Today it powers every major film renderer: Pixar's RenderMan, Weta's Manuka, Disney's Hyperion, and the GPU renderers inside Blender, Unreal Engine, and NVIDIA's Falcor. It is one of those rare algorithms where a simple statistical idea and a physical law click together perfectly.

The canvas below is a live path tracer running in your browser. Each frame it fires random rays through a lit Cornell box and averages all samples so far. Hit Start and watch the noisy grainy image settle into a smooth render.

<!-- {{c_html_comment}} -->
<div class="controls">
  <button id="btn-start" type="button">{{btn_start}}</button>
  <button id="btn-reset" type="button" class="ghost">{{btn_reset}}</button>
  <span class="spp-label">{{label_spp}} <strong id="spp-count">0</strong></span>
</div>
<canvas id="canvas" width="300" height="300" title="{{canvas_title}}"></canvas>
<p class="status" id="status">{{status_idle}}</p>

/* {{c_css_comment}} */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; background: #f4f6f8; display: flex; flex-direction: column; align-items: center; gap: .6rem; padding: .8rem; }
.controls { display: flex; align-items: center; gap: .6rem; flex-wrap: wrap; }
button { font: 600 14px system-ui; padding: .4rem .85rem; border: 1px solid #1d3557; background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
.spp-label { font-size: .85rem; color: #444; }
canvas { display: block; border-radius: 10px; box-shadow: 0 2px 12px #0002; width: 300px; height: 300px; image-rendering: pixelated; }
.status { font-size: .85rem; color: #555; margin: 0; min-height: 1.3em; text-align: center; }

// Code not found

Notice how the first few samples produce a chaotic image and each new batch of samples halves the visual noise. This $1/\sqrt{n}$ convergence rate is the signature of Monte Carlo integration — mathematically guaranteed no matter how complex the scene, but never quite zero noise in finite time.

The rendering equation looks deceptively compact:

$$L_o(\mathbf{x}, \omega_o) = L_e(\mathbf{x}, \omega_o) + \int_{\Omega} f_r(\mathbf{x}, \omega_i, \omega_o)\, L_i(\mathbf{x}, \omega_i)\, (\omega_i \cdot \mathbf{n})\, d\omega_i$$

Here $L_o$ is the outgoing radiance, $L_e$ is emitted light, $f_r$ is the BRDF describing how the surface scatters light, and the integral runs over all incoming directions $\omega_i$ in the hemisphere $\Omega$. The problem: $L_i$ itself satisfies the same equation at the point it came from, making it recursive.

Why Monte Carlo? For most scenes there is no closed-form solution. Numerical quadrature (like a grid of sample directions) scales exponentially with the number of bounces — the curse of dimensionality. Monte Carlo integration sidesteps this: draw $n$ random directions $\omega_1, \dots, \omega_n$ from a distribution $p(\omega)$ and estimate the integral as

$$\hat{L} = \frac{1}{n} \sum_{k=1}^{n} \frac{f_r\, L_i(\omega_k)\, (\omega_k \cdot \mathbf{n})}{p(\omega_k)}$$

The estimator is unbiased (its expectation equals the true integral) and its error shrinks as $1/\sqrt{n}$, regardless of the number of dimensions. That rate is slow — halving the noise requires four times as many samples — but it is dimension-independent, which is why it beats every deterministic alternative for complex scenes.

Russian roulette handles the infinite recursion: at each bounce, terminate the path with probability $q$ and divide surviving paths by $1-q$. This keeps the estimator unbiased while ensuring paths eventually end.

The $1/\sqrt{n}$ rate is both the power and the pain of path tracing. It means a completely correct algorithm, but one that costs compute linearly with image quality. Modern techniques — importance sampling (choose $p(\omega)$ to match the integrand), multiple importance sampling (MIS, Veach 1997), and denoising (NVIDIA DLSS, Intel OIDN) — reduce the effective noise but cannot break the fundamental rate.

Path tracing is the gold standard wherever light must be computed correctly:

• Animated films: Pixar, DreamWorks, Sony Pictures Imageworks, and every major studio switched to path tracing during the 2010s. It handles caustics, subsurface scattering, and volumetric effects (fog, fire, smoke) that earlier methods faked.
• Architecture and product visualization: architects and car designers render proposals before they are built. Path tracing produces images indistinguishable from photographs, which is the point.
• Real-time games: NVIDIA RTX hardware (2018) brought ray-traced shadows and reflections to GPUs fast enough for 60 fps. Full path tracing in games (Cyberpunk 2077 Overdrive Mode, Alan Wake 2) is now commercially available.
• Scientific simulation: Monte Carlo light transport models radiation in medical imaging (PET scanners, optical coherence tomography) and atmosphere simulation.
• VR and film post-production: relighting of live footage — replacing a real set's lighting with a virtual one — uses path tracing to match the physics of the original capture.

The same ideas appear in Monte Carlo methods used across statistics and physics. The rendering equation is also a cousin of the randomized algorithms that sample their way to correct answers across computer science.

Path tracing is one of the most elegant ideas in computer science: an impossibly complex integral — light bouncing through all of space — solved by the oldest trick in probability, the law of large numbers. Fire enough random rays and the physics takes care of itself.

The noise you see in the early samples is not an artifact to be hidden. It is the honest signature of a correct algorithm, converging at $1/\sqrt{n}$ toward a perfect physical answer. Every doubling of samples buys you a halving of error — slow, inexorable, and guaranteed.

The same principle — Monte Carlo integration — underlies Bayesian inference, particle physics simulation, and financial option pricing. A random walk through a problem, averaged long enough, becomes the truth. Path tracing just happens to make that truth beautiful.