Path tracing vs ray tracing: the difference, with Cycles and EEVEE in Blender
Short answer
Path tracing is a form of ray tracing. It follows random light paths over several bounces and averages many samples per pixel, which reproduces all the lighting of a scene but leaves noise until enough samples add up. In most games, ray tracing means a few rays for specific effects, such as reflections and shadows, on top of a rasterized image. In Blender, Cycles is a path tracer; EEVEE is a rasterizer that can also trace rays in screen space since 4.2 (Raytracing panel, off in a new file).
In Blender: Cycles path traces, set in Render Properties > Sampling and Light Paths (12 bounces in total by default). EEVEE rasterizes, and since 4.2 can trace rays against the depth buffer: tick Render Properties > Raytracing, which is off in a new file.
The two terms are often set against each other, yet one contains the other. Settings and default values below are those of Blender 5.2, checked against its manual and source code.
Path tracing vs ray tracing: the short answer
Ray tracing is the general technique: the renderer follows rays through the scene and computes what each one hits. Path tracing is one ray tracing algorithm. For each pixel, it follows a path that starts at the camera and bounces from surface to surface, with the direction of each bounce chosen at random, and repeats this many times. The average of those paths gives the color of the pixel, with direct light, bounced light, reflection and refraction all accounted for at once.
In games, "ray tracing" usually means something narrower. The frame is rasterized as usual, and a limited number of rays improve chosen effects such as reflections, shadows or global illumination. Introducing the Overdrive mode of Cyberpunk 2077 in 2023, NVIDIA called path tracing "full ray tracing" and contrasted it with earlier techniques that handled ray traced shadows, reflections and global illumination separately, for a small number of light sources.
Rasterization, ray tracing and path tracing compared
| Rasterization | Ray traced effects (games) | Path tracing | |
|---|---|---|---|
| How it works | Projects triangles onto the screen and shades the visible surface of each pixel | Rasterizes the frame, then traces rays for chosen effects | Follows random light paths from the camera over several bounces and averages them |
| Indirect light | Approximated, for instance with light probes | Traced if ray traced global illumination is on, approximated otherwise | Every bounce, up to the bounce limit |
| Noise | No sampling noise from light paths | Yes, few rays per pixel: a noisy raw output smoothed by a denoiser | Yes, fading as samples add up, plus a denoiser |
| Speed | Real time | Real time on recent GPUs | The slowest, grows with samples and bounces |
| In Blender | EEVEE | EEVEE Raytracing panel, traced against the depth buffer | Cycles |
Ray tracing: following rays from the camera
A ray tracer sends a ray from the camera through each pixel and finds the first surface it hits. From there it can send more rays: toward each light to check for shadow, in the mirror direction for a reflection, through the surface for refraction. That covers sharp reflections, clear glass and crisp shadows. Light bounced off a matte wall, soft shadows and blurry reflections need many rays in many directions: the job of path tracing.
The rays run backwards compared with real light. The Cycles manual explains the choice: starting from the camera wastes no ray on light that never reaches it, but some important light paths become hard to find.
Path tracing: many random paths per pixel
The theory goes back to The Rendering Equation, presented by James Kajiya at SIGGRAPH 1986: an integral equation for the light traveling between surfaces, and a Monte Carlo solution to it. Instead of evaluating every direction, sample random ones and average them, which is what a path tracer does.
The manual calls Cycles "Blender's physically-based path tracer for production rendering". It uses path tracing with next event estimation: at each bounce, a ray goes straight toward a known light source for the direct light, then the path continues in a direction drawn from the BSDF of the surface (the function that describes how a material scatters light). A path bounces until it reaches a light source, an emissive mesh or the world background, or until the bounce limit stops it.
One path per pixel gives a speckled image. Max Samples, in Render Properties > Sampling > Render, is the number of paths traced per pixel; as they accumulate, the average settles.
Rasterization and EEVEE
Rasterization works the other way round: it projects the triangles onto the screen and works out which surface is visible in each pixel. The EEVEE manual is explicit: EEVEE "is based on rasterization and is not a path tracer": once it knows the visible surface, it estimates the lighting with a set of algorithms. It renders on a single GPU and uses the same shader nodes as Cycles, so a scene can switch engines.
What changed in Blender 4.2
EEVEE was rewritten for Blender 4.2. According to the release notes, it now uses screen space ray tracing for every BSDF, and its soft shadows come from shadow map ray tracing. Tutorials made before 4.2 show a Screen Space Reflections checkbox, now the Raytracing panel of the Render Properties (the code still stores it in the same setting), and a Screen Space Refraction option, now Raytraced Transmission in the Settings panel of the material.
How EEVEE traces rays
In the Raytracing panel, Method offers Light Probe, the cheapest, which finds intersections with the light probe spheres and planes placed in the scene, and Screen-Trace, which traces rays against the depth buffer and falls back to the light probes when a ray leaves the view. The panel is unchecked in a new file, and EEVEE then uses a faster pipeline based on pre-filtered light probes.
The limitations page of the manual is direct: ray-triangle intersection is not supported, and the depth buffer stands in for the scene. Screen space effects only see what is on screen: an object hidden behind another is ignored, and the effects disappear at the edge of the frame (the Overscan option of the Film panel partly helps). Blended materials are not compatible with ray tracing, and only one refraction event is modeled correctly. EEVEE also has a Light Paths panel, but it holds clamping and intensity settings, with no bounce count.
Noise and denoising
Noise is the price of random sampling. The Cycles manual takes a point lit partly by a lamp's highlight on a nearby glossy sphere: path tracing spreads rays at random over the hemisphere above the point, hoping to hit every bright spot. A pixel whose rays miss the highlight comes out darker than its neighbor whose rays found it, and that difference is noise. More samples make it likelier that every important source is found.
In Monte Carlo integration with independent samples, the standard deviation of the estimate, which shows up as noise, falls as 1/√N for N samples: halving it takes about four times as many. Cycles has two ways around that cost.
- Adaptive sampling: with Noise Threshold ticked, as it is by default (0.01 for final renders, 0.1 in the viewport), Cycles stops sampling pixels that are already clean. The guide to the Blender noise threshold gives values for stills and animations.
- Denoising: on by default for final renders, with OpenImageDenoise, which the manual describes as typically giving the highest quality. The OptiX denoiser, NVIDIA only, runs on the GPU on some older cards where OpenImageDenoise cannot. Keep at least the Albedo pass: the manual warns that None can blur out details at low sample counts.
Fireflies, isolated bright pixels, come from light paths that are rare but carry a lot of light; caustics are the classic source. In Light Paths, Clamping > Indirect Light (10 by default) caps their intensity, Filter Glossy (1.0 by default) blurs sharp highlights seen through rough reflections, and the Reflective and Refractive caustics boxes turn caustics off. Each one trades accuracy for a cleaner image.
EEVEE's ray tracing makes noise too. Its own Denoising subpanel (Spatial Reuse, Temporal Accumulation, Bilateral Filter) cleans it at the cost, says the manual, of some light leaks, color bias and blur.
Light bounces: the Light Paths panel in Cycles
How far a path goes is set in Render Properties > Light Paths > Max Bounces. Ideally, says the manual, the number would be infinite; in practice fewer bounces may be enough, and leaving some out converges faster. The defaults in Blender 5.2:
| Setting | Default | What it limits |
|---|---|---|
| Total | 12 | All bounces of a path; 0 gives direct lighting only |
| Diffuse | 4 | Bounces off matte surfaces |
| Glossy | 4 | Glossy reflections |
| Transmission | 12 | Passes through glass and liquids |
| Volume | 0 | Scattering bounces inside volumes |
| Transparent | 8 | Layers of Transparent BSDF, counted apart from Total |
The preset menu in the panel header offers Default, Direct Light, Limited Global Illumination, Fast Global Illumination and Full Global Illumination, which sets every type to 32. According to the manual, diffuse surfaces get away with fewer bounces, glossy ones need a few more, and transmission shaders such as glass usually need the most. If glass turns dark, raise Transmission and Total together, since Total ends the path whatever the bounce type. Fast GI Approximation, in the same panel, swaps global illumination for ambient occlusion after a set number of bounces. How bounced light shapes a scene is covered in the guide to Blender lighting.
Why path tracing costs GPU time
The work grows with the number of pixels, the samples per pixel and the bounces per path. Every sample is a complete path, and every bounce means one more ray to intersect with the scene and one more surface to shade. Cycles sets Max Samples to 4,096 for final renders and 1,024 in the viewport, as ceilings that adaptive sampling lowers wherever pixels are already clean; Time Limit, in the same panel, stops the render after a set time.
Light Tree, on by default, picks lights by distance and estimated intensity: the manual notes that it can significantly reduce noise, for a somewhat longer render time per sample. Path Guiding learns the important light directions in hard cases, such as a room lit through a small door opening, but only on the CPU. The guide on how to render faster in Cycles goes through these levers.
Hardware: RT cores, OptiX and the other backends
Finding which surface a ray hits is the operation a path tracer repeats constantly, and recent GPUs have dedicated hardware for it, which NVIDIA calls RT cores. In Cycles, the backend is chosen in Edit > Preferences > System > Cycles Render Devices, then Device is set to GPU Compute in the Render Properties.
- NVIDIA: CUDA and OptiX both need compute capability 5.0 or higher, but only OptiX takes advantage of the hardware ray tracing acceleration of RTX cards. Since Blender 5.2, it requires driver 575 or newer. The guide to OptiX vs CUDA covers the setup.
- AMD, Intel, Apple: HIP runs on RDNA1 cards and newer; its hardware ray tracing (the HIP RT checkbox in the Preferences) works from the Radeon RX 6000 series and is on by default since Blender 5.1. oneAPI also accelerates ray tracing in hardware on Intel Arc, and Metal uses it by default (MetalRT) on Apple M3 chips and newer.
Cycles can also render on several GPUs and, depending on the backend, on the CPU and GPU together. EEVEE ignores all of these settings: it goes through the graphics driver, on a single GPU.
Cycles or EEVEE: which one to choose
New files start on EEVEE; change it with Render Engine, at the top of the Render Properties. The EEVEE manual itself says that Cycles will always provide more physically accurate renders, since EEVEE's BSDFs are approximations.
- Choose Cycles when bounced light carries the image (interiors lit through a window, color bleeding between surfaces), for glass, liquids and caustics, for stacked refractive objects, for accurate reflections of what lies off screen, and for volumes that must scatter light more than once or show in reflections, two things EEVEE does not do.
- Choose EEVEE for real-time feedback, stylized looks, motion graphics, previews, and animations where speed matters more than physical accuracy.
One trap: the Material Preview shading mode always runs on EEVEE, so judge glass and reflections in Rendered mode with your final engine. The full workflow is in the guide on how to render in Blender, and the guide to photorealistic rendering in Blender gets the most out of Cycles.
Frequently asked questions
Is path tracing better than ray tracing?
Path tracing is a kind of ray tracing that simulates light bouncing around the scene up to a set limit, so indirect light, soft shadows and blurry reflections come out right. It is also slower and noisier, and caustics remain hard for it. Most games trace fewer rays for chosen effects to keep a playable frame rate; offline renderers such as Cycles use full path tracing.
Is Cycles path tracing or ray tracing?
Both, since path tracing is a form of ray tracing. The Blender manual calls Cycles Blender's physically-based path tracer: it traces paths from the camera, bouncing them until they reach a light source, the world background or the bounce limit, and averages many paths per pixel.
Does EEVEE use ray tracing?
Yes, since Blender 4.2, once the checkbox of the Raytracing panel in the Render Properties is ticked (it is off in a new file). Its rays are traced against the depth buffer, falling back to light probes when they leave the view, and the manual states that ray-triangle intersection is not supported. EEVEE remains a rasterization engine, not a path tracer.
Why is path tracing so noisy?
Each sample picks random directions, so some pixels find a bright light source or highlight and their neighbors miss it. The difference shows as noise until enough samples have been averaged. In Cycles, adaptive sampling (Noise Threshold) and the denoiser clean it up; clamping and Filter Glossy reduce fireflies.
Do you need an RTX card for path tracing?
No. Cycles path traces on the CPU and on GPUs through CUDA, OptiX, HIP, oneAPI or Metal. Dedicated ray tracing hardware makes it faster: on NVIDIA RTX cards through OptiX, on AMD Radeon RX 6000 and newer through HIP RT (on by default since Blender 5.1), on Intel Arc, and on Apple M3 chips and newer.
Rendering the animation on TURNA
When a scene is already well optimised and the frame count is what takes the time, the remaining lever is rendering several frames at once. TURNA does this for Blender: an add-on (Blender 4.0 to 5.2, Cycles and Eevee) sends the scene in one click, and the frames are split across 1, 2, 4 or 8 GPUs in parallel, RTX 5090 first and RTX 4090 when none is free. The add-on shows the estimated cost before anything starts. Prices start at €4.90 per hour, billed on the time actually used, with a 30-second minimum, and new accounts get €25 of free credit. A single still image is still rendered by one machine, so the gain is on animations. Tiers and worked examples are on the Blender render farm page.
A path traced animation repeats the full cost for every frame. Measure one final frame first; the render time calculator then estimates the whole sequence from that time and the number of frames.
