Compositor: Vector Blur differs between CPU and GPU #69
Assignees
Triager-bot
Clear assignees
Triager-bot
No Assignees
Notifications
Due Date
No due date set.
Dependencies
No dependencies set.
Reference: Triager-bot/blender-bug-reports#69
Reference in New Issue
Block a user
Delete Branch "%!s()"
Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?
Original bug report: https://projects.blender.org/blender/blender/issues/157265
System Information
Operating system: Debian 13 Linux x86_64
Graphics card: NVIDIA GeForce RTX 3060, backend OPENGL
Blender Version
Broken: version: 5.2.0, branch: main, commit date: 2026-04-13 04:33, hash: 4b3a40956e
Worked: - (tested 5.2.0, 5.1.0, 4.5.8, 4.4.3)
Short description of error
The Vector Blur node produces different results when the compositor runs on the CPU and the GPU. This looks like a bug not a numerical difference. Not much to add, I reproduced this back to 4.4.3, but didn't identify the first version where it worked correctly.
Exact steps for others to reproduce the error
Open .blend file and switch the compositor from CPU to GPU (Options/Performance/Device) and render. Switch between the two and notice the difference.
Report is clear
LLM Reasoning
Got it, let's see. The bug report has a title, system info (but we ignore that), Blender version, short description, and steps to reproduce. The description says Vector Blur differs between CPU and GPU, which is clear. Steps are there: open .blend, switch device, render, notice difference. So the clarity is good. So answer is Yes.
JSON Data
{
"llm_judgement": true,
"processing_time": 6.00241
}
Report is specific
LLM Reasoning
Got it, let's analyze this bug report. The title is "Compositor: Vector Blur differs between CPU and GPU". The body talks about a specific issue where the Vector Blur node produces different results when using CPU vs GPU in the compositor. The steps to reproduce are specific: open a .blend file, switch device, render, and notice the difference. So this is a specific issue because it's about a particular feature (Vector Blur) behaving differently between two rendering devices (CPU/GPU). It's not a vague "crashing while rendering" but a specific discrepancy in a node's output based on device. So the answer should be 'Specific'.
JSON Data
{
"llm_judgement": true,
"processing_time": 8.921776
}
Report flagged as NOT a duplicate by LLM
compositor vector blur node only works in GPU mode.
https://projects.blender.org/blender/blender/issues/130863
System Information
Operating system: Windows-10-10.0.26100-SP0 64 Bits
Graphics card: NVIDIA GeForce RTX 4080 SUPER/PCIe/SSE2 NVIDIA Corporation 4.6.0 NVIDIA 565.90 Opengl Backend
Blender Version
Broken: version: 4.4.0 Alpha, branch: main, commit date: 2024-11-24 00:23, hash:
23ac825a15abWorked: (unsure)
Short description of error
vector blur node outputs blank image if compositor is in cpu mode. gpu mode is fine.
Exact steps for others to reproduce the error
5.5. add a viewer node and enable the backdrop.
The vector node will only output an image when GPU compositor is selected.
LLM Reasoning
Got it, let's analyze these two bug reports. First, look at the descriptions and steps to reproduce.
Bug report 1: The issue is that Vector Blur gives different results between CPU and GPU (not blank, just different). Steps involve switching compositor device and noticing difference.
Bug report 2: Vector Blur outputs a blank image in CPU mode, works fine in GPU. Steps include enabling passes, adding node, toggling device—result is blank vs working.
So the core issues are different: one is differing results (not blank), the other is blank output in CPU. Therefore, they aren't the same issue. So answer is No.
JSON Data
{
"llm_judgement": false,
"processing_time": 11.203146,
"duplicate_report_number": "130863"
}
Report flagged as NOT a duplicate by LLM
Compositor: Blur in new CPU Compositor is significantly slower on Windows
https://projects.blender.org/blender/blender/issues/134436
System Information
Operating system: Windows-10
Graphics card: NVIDIA GeForce RTX 2080 Ti
Blender Version
Broken: version: 4.4.0 Beta, branch: blender-v4.4-release, commit date: 2025-02-10 02:02, hash:
567669d3ff4dWorked: 4.3.1
Short description of error
Gaussian Blur in CPU Compositor is considerably slower than in 4.3 version (other effects seem to be slower too, except of improved Glare node).
Exact steps for others to reproduce the error
Based on the attached .blend file:
LLM Reasoning
Got it, let's analyze the two bug reports. First, look at the key sections: Description and Steps to Reproduce.
Bug Report 1 is about Vector Blur producing different results between CPU and GPU. The steps involve switching compositor device (CPU vs GPU) and noticing differences in blur output.
Bug Report 2 is about Gaussian Blur being significantly slower on Windows when using the new CPU Compositor, comparing versions 4.3 and 4.4. The steps are rendering images in both versions and checking processing time.
The issues are different: one is about visual difference (output) between CPU/GPU for Vector Blur, the other is about performance (speed) of Gaussian Blur on CPU across versions. So they're not the same issue. Therefore, the answer is No.
JSON Data
{
"llm_judgement": false,
"processing_time": 12.189779999999999,
"duplicate_report_number": "134436"
}
Report flagged as duplicate by LLM
Compositor: CPU vs GPU Differences
https://projects.blender.org/blender/blender/issues/118548
Each of the following sections describe one difference between the CPU and GPU compositors, its
problem, its potential solution, the nodes it affects, and the failed regression tests where it
manifests.
Anisotropic Filtering
Problem
GPU uses the hardware anisotropic filtering capabilities of the GPU. Since each vendor, GPU, and
driver might have a different implementation, we can't really unify the implementations.
Solution
Reimplement our own anisotropic filter.
Affected Nodes
This affects the following nodes:
Failed Tests
Jitter Anti-Aliasing (blender/blender!118853)
Problem
CPU uses an 8-sample jitter multi-sample anti-aliasing algorithm to anti-alias some masks. GPU
compositor uses bilinear interpolation with zero boundary to achieve anti-aliasing.
Solution
Use SMAA in all compositor operations that require anti-aliasing.
Affected Nodes
Failed Tests
SMAA (blender/blender!119414)
Problem
SMAA operation produce different results between CPU and GPU. GPU uses the original SMAA library,
CPU uses a C++ port of the library.
Solution
No solution known yet. Needs investigation to figure out where the difference originates.
Affected Nodes
Failed Tests
Fast Gaussian (382131fef2)
Problem
GPU does not implement the Fast Gaussian blur mode and falls back to the slow convolution algorithm.
But, CPU implementation seems broken and could better match standard Gaussian for low dynamic range
images. Further, CPU sometimes uses Fast Gaussian as a utility in other operations, like the Glare
node, while a normal blur should be used instead since the blur radius is very small.
Solution
Implement Fast Gaussian for GPU, port the same implementation to CPU.
Affected Nodes
Failed Tests
Curve Maps (Indirectly fixed by blender/blender!118624)
Problem
CPU and GPU evaluates curve maps slightly differently, which can produce a tiny difference in the
0.001 magnitude. Further, curve maps are stored as half floats in the GPU, so we lose some
precision, making the difference worse.
Solution
Don't use the hardware sampler and interpolate the curve maps manually. Use full float for curve
maps.
Affected Nodes
Failed Tests
Clipped Transformations (blender/blender!119278)
Problem
The result of some transformations is clipped in CPU, but only in background rendering, so this is a
bug in the CPU implementation rather than a difference.
Solution
Unknown, still needs investigation.
Affected Nodes
Failed Tests
Linear Space Color Conversion (blender/blender!118624)
Problem
CPU produces slightly different values after sRGB to Linear color transformations, for instance,
pixels of value 1.0 becomes 1.00002408. According to Sergey:
Solution
Do the color space conversion on the CPU using the same OIIO method. Or move to a more accurate method on the CPU.
Affected Nodes
Failed Tests
Legacy Cryptomatte (blender/blender!118570)
Problem
GPU doesn't have an implementation.
Solution
Unclear what this node represents or if it will be removed. Just do an implementation regardless.
Affected Nodes
Failed Tests
Fog Glare (f0c379e1d3)
Problem
CPU convolves the image with an arbitrary point spread function. GPU uses a Bloom algorithm.
Solution
Move Bloom as to separate option, port implementation to CPU. Add an FFT implementation for GPU and
use that to do the convolution, getting rid of the arbitrary PSF for both CPU and GPU.
Affected Nodes
Failed Tests
Denoise (blender/blender!118553)
Problem
CPU always adds the normal and albedo passes even if they are not connected, and inflates their
values to full buffers.
Solution
Only add the normal and albedo passes if they are actually connected and are full buffers.
Affected Nodes
Failed tests
Interpolation
Problem
CPU and GPU interpolate images differently, but it is likely that the GPU is more correct.
Solution
Unknown, needs more investigation.
Affected Nodes
Failed Tests
Vector Blur (blender/blender#120135)
Problem
GPU uses an implementation similar to EEVEE, while CPU uses a more compute intensive operation.
Solution
Formalize GPU implementation and port it to CPU.
Affected Nodes
Failed Tests
Variable Transformations (blender/blender#120314)
Problem
CPU allow the inputs of transform nodes to be variable, GPU does not.
Solution
Allow variable transformations for GPU.
Affected Nodes
Failed Tests
LLM Reasoning
Got it, let's analyze these two bug reports.
First, Bug Report 1 is about the Vector Blur node producing different results between CPU and GPU. The steps to reproduce are switching the compositor device (CPU vs GPU) and noticing the difference.
Bug Report 2 has a section on "Vector Blur" under its list of differences. It says the problem is that GPU uses an implementation similar to EEVEE, while CPU uses a more compute-intensive operation. The affected node is Vector Blur, and there's a failed test for it.
So both reports are about the Vector Blur node having different results between CPU and GPU. The first report is a specific instance (user's experience), and the second is part of a broader list of CPU vs GPU differences, but the core issue—Vector Blur differing between CPU and GPU—is the same.
Therefore, they are duplicates.
JSON Data
{
"llm_judgement": true,
"processing_time": 20.768289,
"duplicate_report_number": "118548"
}
Report flagged as NOT a duplicate by LLM
Compositing: Increasing Blur Size value above 1 GPU and CPU devices give different results
https://projects.blender.org/blender/blender/issues/133837
System Information
Operating system: Windows-10-10.0.26100-SP0 64 Bits
Graphics card: NVIDIA GeForce RTX 3060 Laptop GPU/PCIe/SSE2 NVIDIA Corporation 4.6.0 NVIDIA 566.36 Opengl Backend
Blender Version
Broken: version: 4.3.2, branch: blender-v4.3-release, commit date: 2024-12-16 21:10, hash:
32f5fdce0a0aShort description of error
When increasing the Blur Size value on the Blur node above 1 in the compositor, GPU and CPU devices give different results.
Exact steps for others to reproduce the error
LLM Reasoning
Got it, let's analyze these two bug reports. First, look at the descriptions and steps.
Bug report 1 is about the Vector Blur node having different results between CPU and GPU. The steps are switching compositor device (CPU/GPU) and rendering.
Bug report 2 is about the Blur node (not Vector Blur) with Blur Size above 1, differing between GPU and CPU. Steps are similar: switch devices and render.
So the nodes are different (Vector Blur vs Blur), so the issues are not the same. Therefore, the answer is No.
JSON Data
{
"llm_judgement": false,
"processing_time": 9.927086,
"duplicate_report_number": "133837"
}
Report flagged as NOT a duplicate by LLM
Compositor: GPU processes both inputs of switch node
https://projects.blender.org/blender/blender/issues/133618
System Information
Operating system: win10
Graphics card: 1050ti
Blender Version
Broken: 4.3.2
Broken: 4.2
Worked:
Short description of error
Bypass via Switch node doesn't give performance advance in GPU mode likewise in CPU.
Exact steps for others to reproduce the error
Create some blur setup in Compositor utilizing Switch node, enable timing overlay and test GPU vs CPU modes
LLM Reasoning
Got it, let's analyze these two bug reports. First, look at the descriptions and steps.
Bug report 1 is about Vector Blur producing different results between CPU and GPU. The steps involve switching compositor device (CPU/GPU) and noticing differences.
Bug report 2 is about a Switch node in Compositor where GPU processes both inputs, leading to no performance gain compared to CPU. Steps are creating a blur setup with Switch node, testing GPU vs CPU modes.
The core issues are different: one is about Vector Blur's result difference between devices, the other is about Switch node behavior (processing both inputs) affecting performance. So they're not the same issue. Therefore, the answer is No.
JSON Data
{
"llm_judgement": false,
"processing_time": 9.584205,
"duplicate_report_number": "133618"
}