Your Help is Needed for Adding Fractal Voronoi Noise Into Blender!

Hi everyone,

There have been requests for more noise variations in Blender for quite some time now.
In fact on Right-Click Select it is the highest voted feature suggestion.
Unfortunately not a lot has happened since it was posted 3 years ago.
So to address the lack of procedural noises I decided to actually do something about it and implemented Fractal Voronoi noise in Blender.

But let me first introduce myself. I’m Hoshinova and I’m a volunteer Blender developer.
To get Fractal Voronoi noise into Blender I started D16262.
“What’s Fractal Voronoi noise?” is probably what you’re asking yourself now so let me give you a quick explanation.

—Fractal Voronoi Noise in a Nutshell—

To better explain Fractal Voronoi noise it’s good to first give a quick explanation on how Blender’s Noise Texture works:
Basically the Noise Texture creates a single layer of what’s called “Perlin noise”:

The Noise Texture then adds multiple layers of them together to create what’s known as “Fractal Perlin noise”:

The above image has 5 layers of Perlin noise added together which in Blender’s Noise Texture is controlled by the Detail input. Therefore the Detail input for 1st image was set to 0.0 and for the 2nd image it was set to 4.0.
I think most of you would agree that a single layer of Perlin noise as seen in the first image is rather plain and boring, while in the second image we have a much more interesting noise pattern which can be used to create various procedural textures.

So what does all of that have to do with Fractal Voronoi noise?
Well let’s take a look into what Blender’s Voronoi Texture can create:

It creates a single layer of Voronoi noise…
Yes that’s pretty much all it can really do. Rather plain and boring like the single layer of Perlin noise isn’t it?
So what if we took multiple layers of it and added them together like we did with Perlin noise?
This is what you get:

Just like with Perlin noise adding multiple layers of Voronoi noise creates a much more interesting pattern than just having a single layer.

Apart from just the Detail input both Fractal Perlin and Fractal Voronoi noise have 2 other inputs:
Roughness: Essentially how much influence each successive layer should have relative to the previous.
Lacunarity: Essentially how much you want to scale each successive layer relative to the previous. (The Noise Texture lacks this input for some reason but it is set to 0.5 internally.)

—End of Explanation—

Now that you have not only read how the Noise Texture works but also how the upcoming Fractal Voronoi noise will work I have both good and bad news.
The good news is that there is a fully working implementation of Fractal Voronoi noise on Blender’s development website.
The bad news is that the (paid) Blender developers are rather indecisive as to whether or not it should be added into Blender.
That is not to say that some are for and some against adding it into Blender but rather that currently no one wants to make the decision.
Therefore I posted some examples of where Fractal Voronoi noise can be used to create shaders.
But the Blender developers wanted to see more “real world applications” of Fractal Voronoi noise.

This is Where Your Part Comes Into Play

As artists you can surely find many more beautiful and practical use cases of Fractal Voronoi noise, which is why I’m asking you to try out the new patch build that contains Fractal Voronoi noise:
Link to Patch Build
and post your results using it here.

Of course if you have any feedback you can also post it here or on the Developer forum.
If you’re interested in implementation details you can always check out D16262

Thanks a lot for your help, your post could very well be the one that gets Fractal Voronoi noise into Blender!


@AlphaChannel wanna throw your use case here as a reply?


Yup, Ocean shaders!!


The functionality seems useful!
With that being said, it doesn’t seem to add something that wasn’t possible before, it just makes it more convenient. This is a good thing of course – but I never had any problems layering noises on top of each other – which is usually really straightforward and flexible in node-based systems.

What’s really tough to do is generate a procedural Voronoi with varying cell sizes:

I’d love to see a solution to that.


I had a setup for layere voronoi with gain, lucanarity and some other mofifiers. It was really useful for creating rock formations, mountains, caves and stuff like that. It was too slow, though. I will see if i can dig it up tonight.

1 Like


This is just a thread to promote the inclusion of fractal voronoi from the OP.

No need to dig up yr shader, (unless you want to!)

I have no use case and am aware of layering techniques.

I am all, for as many procedural textures in Blender as possible.

Oh, I know. I just thought it was a convient way to show an example of what fractal voronoi can be used for.

1 Like

Oh, yes I see,

yeah, go for it!

That would be awesome! Basically any examples of shader or geometry node groups using Fractal Voronoi noise will help here, since it’s more about the concept of it rather than about the technical implementation. So the results don’t have to use my specific implementation, as long it’s got something to do with Fractal Voronoi noise it’s fine.

By the way you mentioned that your node setup was rather slow. This implementation also addresses this problem with custom made Fractal Voronoi noise.
From the tests that I made for D16262 it performed about 4 times faster than a node group version.


I haven’t checked the exact details of this implementation yet, but I think one of the key features I might want from fractal Voronoi noise would be that smaller-scale cells would be subdivisions of larger-scale cells, i.e., cell boundaries would never cross each other, like they would if one just overlaid two existing Voronoi textures with different scales on each other. That would result in randomly-shaped, not-necessarily-‘oct’ ‘octree’-like that cannot presently be made at all, I don’t think, looking something like this:

If that’s not what this is, that’s fine, but if it is, fantastic.


Hi and first of all thank you for your effort. I am all for more node options for shaders.

I have seen node setups for fractional Fractal Voronoi but they where complicated to set up!

I have downloaded and will check it out to see what I can do with it.

When that proposal was made, official stable release was 2.82. Math node had just been completed with 14 new operations.
In 2.83, Roughness was added to Noise and Wave textures. Wave texture was completed with a Phase Offset.
Nothing obvious happened for procedural textures during 2.9x series. Because of brainstorming around geometry nodes.
But, for blender 3.0, textures nodes were added to geometry nodes, before the ability to bake anything to a color attribute.

Between Blender 3.0 and Blender 3.1, developers posted an article about a new design for layered textures.

It seems that none of developers talked to you about plans, to make Texture Layers nodes with blend modes, masks and reordering.
Is it be possible that some part of your work could become a kind of blend mode between textures or a filter ?

I suppose that their reluctance to merge your work, now, is due to an anticipation, that bugs occurring between a new layer system and your complicated texture with thousands of lines of code could be hard to track.

So, they are probably hesitating to make feature operational for everybody now, and encounter problems later to debug by themselves, or letting users wait for the feature during one year or two (until layered textures project becomes a reality), and let you fix possible problems with new system before a merge.

1 Like

Is this much different to what @Secrop implemented a few years back with his loop node. This could be used to iteratively overlay successive textures of different scales or different levels of detail - but was more generalised in it’s implementation so could be used with all textures and nodes (and could mix between them).

This was implemented as a python node - but given how geometry nodes have evolved to include iterative solving - would Secrop’s approach better fit the direction Blender is going in?

When that proposal was made, official stable release was 2.82. Math node had just been completed with 14 new operations.
In 2.83, Roughness was added to Noise and Wave textures. Wave texture was complete with a Phase Offset.
Nothing obvious happened for procedural textures during 2.9x series. Because of brainstorming around geometry nodes.
But, for blender 3.0, textures nodes were added to geometry nodes, before the ability to bake anything to a color attribute.

This may be a subjective opinion but to me this simply isn’t much progress in 3 years. I absolutely don’t want play down the contributions by our fellow Devs regarding procedural noise, but most improvements were either minor like adding a Phase Offset to Wave Texture or reused already existing code like adding a Roughness input to the Noise Texture, which the Musgrave Texture already had.
But that’s off topic anyways so regarding the Layered Textures Design you mentioned:
First of all development of it has been very slow, from what I can tell it might take months if not years for it to be released into Blender. The fact that none of the Dves I talked to mentioned it when reviewing the Diff makes it even more unlikely that bugs with that system is a major concern for now.

What is true however is that the Fractal Voronoi noise code is more sophisticated than the current plain Voronoi Texture code.
This, like almost every new feature, makes it a tradeoff between having new features and keeping the code simple, which is why the Devs want to see more applications of Fractal Voronoi noise.

1 Like

I’m not familiar with the Addon you mentioned but from what I can tell the biggest differences are probably ease of use and mainly both compiling and rendering speed.

Indeed - it does take a little bit to learn how to use it - however would a more generalised approach like this be a better direction to take? If this could be polished and implemented in native blender, instead of being a Python code - it would give a huge amount of flexibility and would massively expand the use cases for existing textures and noise - as my limited amount of testing on that thread demonstrate.

Will the proposed “layered textures” function effectively give us this?

No. I don’t deny that. I was just making a recap of what happened to conclude it with plans for the future.
Improvements with new texture patterns and new math nodes were made in 2.80, 2.81, 2.82 and 2.83.
The proposal about more textures was published, when people working on shading nodes had to take a break.
Then, what happened, after that break, was a kind of freeze due to development of Blender 3 features (Cycles X and refactoring of Geometry Nodes).
And in Blender 3, we obtained with Geometry Nodes, ability to use same textures than the ones used in shading to displace geometry. Something missing since 2.6 and introduction of Cycles.
Those textures should be available for brushes and other modifiers, too, since 2.80.
We still don’t have that.

Well. The development of layered textures can not be qualified as slow. It just hasn’t started, yet.
For the moment, that is just an hypothetical design.
So, bugs related to it are as hypothetical. That is maybe why, they did not talk about it at all.
They want to stay concrete when posting on d.b.o.

You replied to their review in 2 months. And now, they are asking for use cases.
I think that they did not expect you to progress at that pace.

It’s really funny that I just came up with a very similar idea to that of the “Loop” node while chatting with another Blender developer.
I’ll look into ways to make general looping possible for nodes but even if I manage to get something like this working in Blender it would still be better both user friendliness wise and performance wise to have computationally expensive Fractal noises like Voronoi noise implemented directly into Blender.

Hmm… it appears that I lost it.
However, it was basically a Setup that use Gain and Lacunarity on all inputs of a Smooth F1 Voronoi Texture. That is W, Scale, Smoothness and Randomness.

Furthermore it had a multiplier on lacunarity and gain for fine tuning. This multiplier would make it possible to have non linear lacunarity and gain.
Example: Usually with lacunarity the first iteration of the texture might be size 8. The next 4 and the next 2 and so on. With the multiplier it was possible to make the steps non linear, meaning that the first step might be size 8 the next 4 and the next 3 then 2.5 then 2 and so on.

If I find some time I will try to recreate it and upload it.