Path tracing works by firing a ray from the camera through each pixel, letting it bounce off surfaces in random directions, and adding up the light it finds along the way. One such path is one sample.
- A single sample is grainy because the random bounce may or may not find a light. Averaging hundreds of samples per pixel turns the grain into a clean image, which is why a path traced picture resolves over time.
- Soft shadows, reflections, and colour bleeding from one surface to another are not added as separate effects. They fall out of the same calculation, because every bounce is followed.
- The rules are few: light is never created by a surface that does not emit it, each material decides where a bounce is likely to go, and paths end at random so the average stays honest without tracing forever.
- The cost is the number of samples, and samples per second is a clean measure of a graphics card under sustained load. That is what the path tracing stage of a SystemCheck run reports.
Start at the camera, not at the light
In the real world light leaves a lamp, bounces around a room, and a tiny fraction of it reaches your eye. Simulating that directly would waste almost all the work, because most light never reaches the camera at all. Path tracing runs the journey backwards. For every pixel on the screen it fires a ray out of the camera into the scene and asks where that pixel's light could have come from.
When the ray hits a surface, the renderer looks at the material and chooses a new direction for the ray, at random but weighted by how that material scatters light. A mirror sends the ray one way; a matt wall could send it almost anywhere. The ray keeps going, bounce after bounce, until it hits something that emits light, such as a lamp or the sky, or until the renderer decides to stop.
The light it collected on the way, dimmed at every bounce by how much each surface absorbed, is that pixel's colour for one sample. That is the whole algorithm. Everything else is about doing it many times and doing it fast.
Why one sample is grainy and many are not
Because each bounce direction is random, a single path through a pixel might find the lamp on its first bounce, or wander into a dark corner and find nothing. Two neighbouring pixels can get very different answers from one sample each, which is what the grain in an early path traced image is: not an error, just too few guesses.
Take a second sample through the same pixel and average it with the first. Then a third. The average converges towards the true amount of light arriving at that pixel, and the grain fades. Halving the noise takes four times as many samples, which is why the image improves quickly at first and then slowly, and why an image that looks finished may still be resolving.
This is also why path tracing is a natural benchmark. The work is the same for every sample, the scene never gets easier, and the card is either producing samples quickly or it is not.
What comes for free
Older rendering methods add each lighting effect separately: a shadow map for shadows, a reflection probe for reflections, an ambient term to stand in for light bouncing around the room. Each is an approximation with its own settings and its own failure cases.
Path tracing does not add any of them. A soft shadow appears because some paths from a point near the edge of the shadow reach the light and some do not. A reflection appears because paths that hit a shiny surface continue in the mirrored direction and pick up whatever they hit next. A red wall tints the white floor beside it because paths from the floor bounce off the wall before reaching the light. These are called global illumination, and they are what makes a path traced image look photographed rather than drawn.
The rules path tracing follows
The physics underneath is usually written as the rendering equation: the light leaving any point equals the light that point emits, plus all the light arriving at it from every direction, weighted by how the surface scatters it. Path tracing is a way of estimating that sum by random sampling rather than solving it exactly, which is impossible for any real scene.
From that come the rules a path tracer has to keep. Energy is conserved: a surface never reflects more light than reaches it, or the image glows. Each material has a scattering function that says where a bounce is likely to go, and the renderer picks directions in proportion to it, which is called importance sampling and is what keeps the noise manageable. Paths are ended at random rather than at a fixed depth, with the survivors weighted up to compensate, a trick called Russian roulette that keeps the average correct without tracing forever.
A renderer that bends any of these rules produces images that look plausible and are quietly wrong. Ones that keep them produce the same answer whichever way they are written, which is the property that makes path tracing the reference other methods are checked against.
Why it costs so much
A 1080p image has about two million pixels. At a few hundred samples per pixel for a clean result, and several bounces per sample, that is billions of ray intersections for one frame. Film renderers spend minutes to hours per frame. Games that offer path tracing lean on dedicated ray tracing hardware, take only a few samples per pixel, and clean up the remaining noise with a denoiser and upscaling.
In a browser there is no access to that hardware, so a browser path tracer runs as a shader that marches rays through a small scene. That is exactly what makes it a fair test between cards: every card does the same work per sample, with no denoiser or upscaler to hide a slow one.
What the SystemCheck path tracing stage measures
The path tracing stage renders a small scene at a fixed 960 by 540, one path per pixel per sample, and takes samples back to back for the whole stage so the graphics card stays loaded. Each sample is timed to completion on the card. The first sample pays for shader compilation and is excluded.
The result is samples per second, which is the cost of each sample on your card, and a consistency figure that says how evenly those samples arrived. A card that delivers samples unevenly is usually being interrupted by something else, or is running into a power or heat limit as the stage goes on, and that is visible in the consistency number even when the average looks fine.
The stage cannot read temperature, power draw or video memory, because no browser can. What it can show is whether the card sustained its rate for the whole stage or fell away, which is the question most people are actually asking when they wonder if their machine can handle path tracing.
Terms used here
Questions
- How does path tracing work in simple terms?
- It follows light backwards. For each pixel a ray leaves the camera, bounces off surfaces in random directions, and stops when it finds a light. The light it gathered is one sample for that pixel. Many samples are averaged to make a clean image.
- Why is a path traced image noisy at first?
- Each sample takes a random path, so a single sample may or may not find the light. Averaging more samples per pixel smooths the randomness out. Halving the noise takes four times as many samples, so the image improves quickly at first and slowly afterwards.
- What rules does path tracing follow?
- Light is conserved, so a surface never reflects more than it receives. Each material has a scattering function that decides where a bounce is likely to go, and directions are sampled in proportion to it. Paths are ended at random with the survivors weighted up, so the average stays correct.
- Is path tracing the same as global illumination?
- Global illumination is the effect: light bouncing between surfaces so that shadows soften and colours bleed. Path tracing is one way of computing it, and the most complete, because it follows every bounce rather than approximating some of them.
- Can I test my own graphics card with path tracing?
- Yes. The SystemCheck run includes a path tracing stage that runs in the browser with nothing to install, and reports samples per second and how consistently they were delivered. Start the free test and the stage runs at the end.