and speaking of, Yes, thats probably heaviest computationally “regular” node (so not ShaderToRGB, or AmbientOcclusion or BSDFs like Principled)
It does not use textures, so it does not takes VRAM and memory bandwith, and GPU does not have to wait for textures. But on the other hand to compute 3D noise fBM with a lot of octaves (Detail parameter in node) is alot of various instructions (dot, floor, frac, sin).
The way Blender’s shader code is composed is somewhat confusing:
gpu_shader_material_noise.glsl
gpu_shader_material_tex_noise.glsl
so heres what LLM says it results:
GLSL Code for Noise Texture
// Pseudo-random hash function for 3D space
vec3 noise_hash(vec3 p) {
p = vec3(dot(p, vec3(127.1, 311.7, 74.7)),
dot(p, vec3(269.5, 183.3, 246.1)),
dot(p, vec3(113.5, 271.9, 124.6)));
return fract(sin(p) * 43758.5453123);
}
// Basic 3D Value Noise
float noise_value(vec3 p) {
vec3 i = floor(p);
vec3 f = fract(p);
// Smooth interpolation curves
vec3 u = f * f * (3.0 - 2.0 * f);
// Mix 8 corners of a cube
float n000 = dot(noise_hash(i + vec3(0.0, 0.0, 0.0)), f - vec3(0.0, 0.0, 0.0));
float n100 = dot(noise_hash(i + vec3(1.0, 0.0, 0.0)), f - vec3(1.0, 0.0, 0.0));
float n010 = dot(noise_hash(i + vec3(0.0, 1.0, 0.0)), f - vec3(0.0, 1.0, 0.0));
float n110 = dot(noise_hash(i + vec3(1.0, 1.0, 0.0)), f - vec3(1.0, 1.0, 0.0));
float n001 = dot(noise_hash(i + vec3(0.0, 0.0, 1.0)), f - vec3(0.0, 0.0, 1.0));
float n101 = dot(noise_hash(i + vec3(1.0, 0.0, 1.0)), f - vec3(1.0, 0.0, 1.0));
float n011 = dot(noise_hash(i + vec3(0.0, 1.0, 1.0)), f - vec3(0.0, 1.0, 1.0));
float n111 = dot(noise_hash(i + vec3(1.0, 1.0, 1.0)), f - vec3(1.0, 1.0, 1.0));
float nx0 = mix(mix(n000, n100, u.x), mix(n010, n110, u.x), u.y);
float nx1 = mix(mix(n001, n101, u.x), mix(n011, n111, u.x), u.y);
return 0.5 + 0.5 * mix(nx0, nx1, u.z);
}
// Fractal Noise (FBM) mimicking Blenders Detail and Roughness parameters
float noise_texture(vec3 co, float scale, float detail, float roughness) {
vec3 p = co * scale;
float sum = 0.0;
float freq = 1.0;
float amp = 1.0;
float total_amp = 0.0;
int octaves = int(clamp(detail, 0.0, 15.0));
// Base octaves
for (int i = 0; i <= octaves; i++) {
sum += noise_value(p * freq) * amp;
total_amp += amp;
freq *= 2.0; // Lacunarity fixed at 2.0 like Blender default
amp *= roughness; // Roughness controls falloff per octave
}
// Handle fractional detail (smooth transition for non-integer detail levels)
float fractional_detail = fract(detail);
if (fractional_detail > 0.0 && octaves < 15) {
float next_octave = noise_value(p * freq) * amp;
sum += next_octave * fractional_detail;
total_amp += amp * fractional_detail;
}
return sum / total_amp;
}
If LLM does not lies to me its something like that:
| Detail Setting (Octaves) |
Estimated ALU Instructions per Pixel |
Performance Impact |
| Detail = 0 (1 octave) |
~50 instructions |
Very lightweight |
| Detail = 2 (3 octaves) |
~150 instructions |
Low / Standard |
| Detail = 4 (Default) |
~250 instructions |
Moderate |
| Detail = 8+ (High detail) |
~500+ instructions |
Heavy (can cause lag on high-res viewports if scaled across many objects) |
Those are computation instructions, but that obviously also slow down compilation.
And we can actually somewhat check it using GPU debugger to look up what GPU driver gets from Blender:
But because i dont look at what Blender generates, but what GLSL code generated from dissasembled SPIRV code that was already optimised by GPU drivers from actual shader code
- it does not represent actual lines or instruction count, but it might rough idea of how much it adds to compilation and how much it might cost performance.
so:
Emission Shader connected directly Output results in 2073 lines (2207 SPRV ops)
(6 “add” nodes connected to color adds only line GLSL line, but results in 2244 Ops total)
Principled Shader connected to Output gives: 3461 lines
Single Noise Texture gives: 4472 lines
and 4x Mixed Noise Textures 11670 lines
So as You guys see, adding single noise texture might out weight those single math optimizations You guys might make.
So what can You do?
Emm.. Nothing? And just eat the cost 
RTX 5070 can do theoretical 30 trillion instructions per second,
So theoretically that texture noise if it would fill whole screen, it would take about 0.003 ms on Full HD or ~0.01 ms for 4K image.
Real number is worse, but probably only by about 50%.
Because EEVEE uses multiple sampling,that get multiplied by sample count.
So for 4K render with 64 samples would be 1.28ms if my napkin math is correct (it probably is not)
In Gamedev we actually use volumetric noise in some cases, but in Unreal or Unity there are some lighter versions that use 3d textures (not avaliable currently in Blender).
What else can You do?
If what You do is only using scalar value, then dont use Color output, because thats just making 3 times calculation to later avarage it out.
Lower dimensions if You dont need more.
Lower Octaves. I guess that does not lowers compilation time, but it might (i dunno) reduce performance cost in eevee, in Cycles it does. But if You connect something to other than constant -cost might go up, dunno.
Reuse already calculated stuff if You are doing essentially the same stuff in other place in same material.
