Golden Mean, Fractal Growth Series Creation

Hello everyone,

Its been a lifetime passsion for me to study and explore the fractal patterns and after meeting with Grasshopper, of course that’s the first thing I wanted to explore :slight_smile:

As a beginner, I tried some few ways of crating the series, however I felt there must be a SIMPLE, EFFECTIVE & BEAUTIFUL way of building the grasshopper - just like nature does in everywhere!!

So my main intention to learn to create simple fractal growth patterns with Golden Ratio as indicated below in the example.

I tried to create this in grasshopper but couldn’t really figured it out how to.
I can share my version below, but I’m sure there are way better ways to mimic this beautiful series! :innocent:

Even tried to map out manually but couldn’t figured it out how to write the series formula in expression

phi play.3dm (49.0 KB)
phi (12.3 KB)

Also, my passion drives to the ancient temple architecture where they used these formulas wonderfully…
So fully open to hear your ideas/suggestions/solutions to create marvels like these below. :smiling_face_with_three_hearts:

I am sure there are many people that will reply on the thread as there are many ways to approach this. Here is a Gallery of examples using Fractal style algorithms to do many forms: fractals | Parametric House

Perhaps there is some inspiration there?

1 Like

Thank you, @scottd !
That looks like definitely useful resource, however it requires membership with a good price tag :slight_smile:
And I’m sure its very, very, very worth it to subscribe.

I was wondering if any of the community members would like to give a hand in this exciting subject.

It would be fantastic to learn different ways of building such definitions.
Feeling that would be valuable to share with the community.

Fractals are recursive algorithms. The problem with native grasshopper is that it does not allow you to implement recursion out of the box. You either use one of the script components (C#,Python,VB) or you install plugins. There are plugins like Anemone which allow you to loop, or even specialised plugins for fractals. But I personally find it harder to work with them, as by writing a simple script. In any case, as Grasshopper was not designed to support recursion natively, for a beginner it might not be the best thing to start… Do you have any coding experience?

1 Like

Thank you for your reply dear @TomTom

That makes sense…

It’s a bit sad that we cannot simply work with recursive curves natively in Grasshopper.
I was trying to wrap my mind around it but that brought quite clarity on that.

I have no coding experience, but if this is the best way of creating loops/fractals, as I shared above, I can definitely dedicate myself to learning the basics. Would you suggest anything for me to start focusing on creating loops or fractals?
I believe that GPT can help a lot with true guidance, especially these days.

Another question would be:
Yes, I checked the plugin Anemone, but it seems quite old and not compatible with Rhino8 - is that right?

Any recommendation on that?

Also, I have seen very talented users like @laurent_delrieu who created many marvelous creations with fractals, and I was wondering if there are any native/alternative solutions they’d like to suggest? :pray:

I don’t need that because I do code :wink: It is indeed a problem if Anemone does not work for Rhino8. There are also other plugins doing this. I don’t remember their name. Essential it gives you the ability to wire a loop, which is something you need for recursion. From a coding perspective a common pattern is this (untested):

def recursive_function(level, action, depth):  
    # Guard against infinite looping 
    if level > 100: 
        raise Error("Detected infinite looping. Abort...")

    # Check if we reached the end
    if level == depth:

    # perform a given action, note that "action" is a function pointer 
    # lets assume on each iteration you call twice in the next run
    recursive_function(level+1, action, depth)
    recursive_function(level+1, action, depth)

# our action to be performed
def print_action(level):
    print(f"Called on level: {level}")

# start the recursion, where on each level something is printed 
recursive_function(0, print_action, 5)

It seems to work here on Rhino 8 and PC.

Like said by @TomTom this kind of work is sometime more easy with code for example if you add a lot of conditions but Anemone seems to be OK for what you are after, it is just movement polar array and scale.

Anemone is working here on Rhino8; behavior is slightly improved, if any of the inputs change, loop auto recalculates, does not specifically have to be a trigger input. This can be an issue for complicated definitions; in that case use a data dam before inputs. Suggest you try a simple anemone loop as a learning exercise, say, a circle that moves position depending on loop. then, next, for recursion, try inputting a circle, then divide that circle in half and draw 2 circles. rinse and repeat

Here something like in your image

recursion (11.5 KB)

It is a scale, a move then a polar Array

Wow… Thank you for all your comments and feedback!

Deeply appreciated all - and yes Anemone seems working very fine, my apologies.

Will dive deep with your suggestions and try to work out the best way of learning loops and fractals…

Thank you once again @TomTom @laurent_delrieu @markz - this community is a gem!!!

Please feel free to advise me on anything if you feel valuable, I’m hungry to learn :slight_smile: