Parametric Modeling with Sverchok

Parametric Modeling with Sverchok

An introduction to parametric modeling with the Sverchok addon for Blender

Sverchok is the russian translation for the word grasshopper. You may have heard of Grasshopper, the parametric modeling software coupled with Rhino. Well, Sverchok, as its name implies, intends to be the free software pendant of Grasshopper for Blender.

Parametric modeling is a technique to build complex 3D geometries using formulas and equations. These techniques have been used in architecture, product design and graphical arts to produce complex shapes that would be too tedious or just impossible to produce by hands.

Here’s the Sverchok demo reel to have a glimpse of what is possible:

During this workshop, we intend to go over the basics of installing Sverchok with Blender and starting experimenting with the modelling workflow that it proposes. This will all be done using nodes. So it will also be a great opportunity to learn how to use node interface in Blender.

You might mention that this is not a Python coding workshop per se. And you’d be right. But the approach to this technique is very similar to visual programming as you will be manipulating concepts like variables and functions, while using a graphical interface. This is also an approach found in softwares like Pure-Data or Isadora, for example.

This workshop will be held at Arts2, Mons on Wednesday 29th April 2015, starting at 14:00 and finishing at 18:00, during the open doors of the art school. So please pay attention here, it’s not in Brussels, and not the usual Saturday. But a great opportunity to visit Mons, discover Arts2 and the work of its students. Everybody welcome. It’s a free public event.

Sounds interesting to you? Then announce your participation on our mailing-list. Just register and say “Hello, I’ll be there”.

The Blender-Brussels is a series of monthly free and open workshops dedicated to Python creative coding using Blender. Started by François Zajéga and Julien Deswaef in 2012, these have become a regular meeting point for anyone interested in experimenting with code. It works as a communal space to exchange ideas and share knowledge as a way to learn. All results of these practices − exercises and documentation produced during the workshop − are shared online under an open source license.

This event is hosted at Arts2 − 7000 Mons on Wednesday 29th April 2015, starting at 14:00 and finishing at 18:00.

Sverchok Add-on

If you’re familiar with Rhino you probably know Grasshopper, a plugin for parametric object creation. Sverchok (Russian for Cricket) is a new Blender add-on which aims to achieve the same functionality for Blender.

Sverchok is a node-based generative addon for creating parametric forms in Blender. Those familiar with Houdini or Rhinoceros 3D might know the visual scripting language Grasshopper, which Sverchok has been inspired by. Using a similar node based visual programming method, Ukrainian/Russian artists/programmers Nikita and Alexander have brought this functionality to Blender users.

This is the first implementation of the addon and there are limits due to the small NURBS Library found in Blender right now and the Python API places it’s own restrictions on speed of development, but Nikita says, “Future implementations of Sverchok (Cricket) will include nodes for math, expressions, finding specific edges, vertices, polygons, evaluate points on a spline, and ability to make node chains, etc.”

So if you are interested in architectural tools and/or generative arts and how a node based approach to creating parametric 3D objects works, the Cricket is a great new addition to Blender. Try it out and give the guys feedback over at BlenderArtists.

Alexander Nodovizin (who recently created the Grid Fill Manager addon) and Nikita Gorodetskiy (Nikitron tools addon) are in working team.


Great, I really like the idea of messing around with geometrie via nodes in Blender. But all in all I think we need an better UI for nodes in Blender. Something where you can keep track of what’s actually going on there. In this case it’s quite simple to understand. But as things get complecated as you would need them to controll nearly all via nodes you _will_ loose track. Blender needs an UI like Nuke where enormously complex scripts can be understood because there internal simplicity is not hidden by the UI.
I know, groups, frames and the reroute point are a step in the right direction but compared to Nuke the nodes themselves are far to limited.
However, thank you for this great add-on!

An option to use parametric modelling techniques in Blender would be a dream come true, although I understand that probably goes against the fundamental ethos and design of Blender as a mesh modeller.

Actually Lukas Toenne had started his work in BI just few days ago (I guess). And his main direction will be Nodes.
I guess the start will be with particles then (it will be highly appreciated by Blender society) it will be with geometry and etc.

Thanks, we will talk to him, if this person, as you say, responsible of Nodes.

He was already started a project with node particles..
It will be cool if you’ll be connected together!

Awesome! It reminds me of nodebox. This will make it a lot easier to play with generative art with Blender.

@Nikitron, I appreciate any efforts of that type made for Blender!
But what’s the difference between using Hair (with objects instead strands) + Weight modifiers or even Dynamic Paint + Hair and your add-on?
Maybe I’m missing something (yep, I see it’s nodable).

Yes, you missed, that it is first nodes of great idea – grasshopper. If you don’t know what is Grasshopper or Bantley on AutoCAD or Houdiny nodes, you better to see it to understand the idea.

Thanks for the explanation! So, it’s just a start for big changes, right?
I’ve tried parametric modelling with Houdini a bit but I couldn’t master it after some time passed.

adapt.ABILITY – Blender + Grasshopper workshop – Bratislava

Blender + Grasshopper workshop

Bratislava, Slovak
30 Oct – 3 Nov 2013

[.] Brief

“Intelligence is the ability to adapt to change.”― Stephen Hawking

The human ability to adapt to changing environments depends on human behavior as well as on the tools we create and use; we are, in fact, symbiotic with the tools we create and in turn they change our mindset and behavior, fostering the creation of new ones to solve upcoming challenges as well as to satisfy our need to explore the new. Embracing the technological evolution to the fullest as designers means embedding toolmaking as a necessary part of the design process, thus making us more adaptable in front of new design challenges, and in the present day the word “tools” in design and architecture implies directly software.
No single software fits all the situations and needs of our daily job or research; we must learn to play with many different tools with their own peculiar features, extending and combining them seamlessly in order to expand our toolset and enhance our tools sensibility.
The workshop will explore how to use and combine two powerful design tools and exploit their synergies. Blender is one of the most powerful and famous free, open source 3d modeler (and much more – just check the 2013 reel …don’t forget it’s a free software!) and Grasshopper is the well renowned graphic programming editor and generative modeling tool. The synergistic potential of these tools could lead to new opportunities for custom design strategies and provide new advanced features in our skills set.

[.]Software & skills:

Basic modeling skills in Rhino and Grasshopper [Primer level] are required.
No specific Blender skills are required (although an introductory knowledge of 3D modeling is welcome).

Participants should bring their own laptop with pre-installed software. The software package needed has no additional cost for the participant (Rhino can be downloaded as evaluation version, Grasshopper and Blender are free), but since they are subject to frequent updates a download link to the version used in the workshop will be sent to the participants a few days before the workshop.



Academy of Fine Arts and Design – Bratislava


30 Oct – 3 Nov 2013
The daily timetable is:
_ m: morning 10-13 (with coffee break)

_ a: afternoon 14-18 (with coffee break)

GH: Grasshopper
BL: Blender

[.] day 01
_ m
. workshop introduction
. conceptual overview (multitools synergies, Mesh & Nurbs modeling, mesh syntax)
. BL: Blender basic (Blender UI, Modeling tools, Modifiers and Deformation)
_ a
. BL: Blender basic (Precise Modeling and Freeform Modeling)

[.] day 02
_ m
. BL: Blender basic (Materials & Shaders, Textures and UV mapping , Light & Rendering [Blender Internal and Cycles], Particles)
_ a
. BL: export data from Blender + tutored work

[.] day 03
_ m
. GH: import data from Blender, mesh data syntax, GH mesh plug-in: Weaverbird, Mesh(+), Starling
_ a
. GH: mesh tasselation with Grasshopper, vertex color, patterns with vertexcolor, export mesh data to Blender

[.] day 04
_ m
. BL: Blender Advanced (Simple Animations, Shapekeys and vertexColor, Form Finding)
_ a
. BL: Blender Advanced (catenary using clothes, Minimal surfaces using softbodies, Isosurfaces with Fluids)

[.] day 05
_ m
tutored work (project development)
_ a
tutored work (project development)
final presentation

[.]Subscription fees:

– AFAD/VSVU student: 249 €
– student: 374 €
– professional : 499 €

* only students, teachers, researchers & PhD (proof of status required) or participants of previous 3D Dreaming or rese arch workshops are eligible for the educational discount. please, send a copy of your valid student/teacher ID or a confirmation from you institute on [email protected]


To register please fill this online FORM

[.] Organized by:

This workshop is organized by Co-de-iT in collaboration with:

Has anyone started a project similar to Grasshopper (Rhino) for blender?

For a while now I’ve been interested in prototyping parametric ways to generate geometry. The nodeview of Grasshopper reminds me a lot of the nodeviews we have in blender.

I was thinking, with the new pynodes feature maybe somebody has started to do work on node based parametric geometry creation, or does pynodes not make that possible?

edit: I’m already able to write scripts that generate parametric geometry using BMesh API.

edit2: example video of Grasshopper in action

4 Answers 4

There is such a tool, it is called Sverchok. It’s russian for “Cricket” as a sign of respect to Grasshopper. Sverchok is a Blender add-on that works on all platforms, and has over 180 node types.

The project github page: (including download links)

Ask questions on the issue tracker

To get a sense of what people are making with Sverchok checkout the google+ group

There have been experimental projects, but nothing too usable from what I’ve seen (there was some test using PyNodes with BMesh API: link

In my opinion writing a script makes more sense. You probably will have to import a few libraries(which I don’t think you can do with pynodes). Geometric PyNodes hasn’t been officially added yet. It’s just experimental add-on at the moment.

You will need to have a fair understanding of scripting and python – whatever the outcome. So if you don’t already know python, now is the time to learn.

You may want to try sverchock:

Here’s the description from author’s page:

Sverchok – is parametric tool for an architect, designer, lets you to programm object’s form without knowing program longuages.

Breafly, it is node programing of geometry, but in completely virtual way (with ability to bake geometry to blender). You would work with pure data, as floats, matrixes, lists, formulas, etc.

Those who familiar with Houdini or Rhinoceros 3D might know the visual scripting language Grasshopper, which Sverchok has been inspired by. Using a similar node based visual programming principle, Ukrainian/Russian artists Nikita and Alexander trying to bring this functionality to Blender users.

To understand what is parametric in ARCHITECTURE you’d better see my breaf explenation here.

Rhino -> Blender workflow

Howdy y’all! I have recently started using Blender for rendering purposes, but I still do most of my modeling in Rhino, but have recently run into a problem with imported objects, and that is that their faces do not seem to be attached to each other.

For example, if I create a cube in Blender, go into edit mode, select a single vertex and then press the L key, it selects all of the vertices of the cube. If I create a cube in Rhino, mesh it and export it as an OBJ or 3DS object and import that into blender and do the same thing, it does NOT select all of the vertices, at most it will select the vertices of the co-planar triangle face that makes up a quad, but nothing more. At first, I didn’t think much of it since things rendered properly, but now I’m getting into sculpting and doing other modifications and these non-joined objects are causing a problem, for example, sculpting over one of these objects will most often split the faces apart and make the object appear to be bursting at the seams.

I have tried exporting OBJ files with unmodified vertices and with welded vertices, but that doesn’t appear to change anything at all when importing to Blender.

Is there some way I can get Rhino to output properly joined objects that work correctly in Blender? I’m reasonably sure this IS an issue with Rhino, as objects exported from other tools (Such as Mudbox) do not have this problem, AND the same objects that have this problem in Blender also exhibit the same splitting behavior when imported into Mudbox as well.

Studio Rola

3D Graphics and Training Services

Rhino Grasshopper: Sl > Posted on July 15, 2018 July 15, 2018 Author admin Leave a comment

As of this writing, Grasshopper does not seems to have a way of setting the start and end value for the classic Number Slider.

The 2 videos below illustrate attempts at creating a number sliding system that only slide within a given range of value. Sliding within a given range of value is a good way to limit the sliding range to that corresponding to a list of numbers.

Rhino Grasshopper: Slider with a range (Method 1)

For this method, the general idea is to:

1. firstly deconstruction the list of numbers into its lower and upper value.
2. and then use the Maximum and Minimum Components to limit the range to correspond to these lower and upper values.

It is as illustrated in the video below.

Rhino Grasshopper: Slider with a range (Method 2)

Basically, for this method,

1. We get the range value of a list using the Bounds component
2. Using the Remap Number component, we remap this existing domain range to a new range. This new range is corresponding to the number slider has a range of 1 – 10.

This process is as illustrated in the video below.

Hope that this is helpful. If anybody has a better method, kindly response in the comments section.Thanks

Studiorola provide 3D related consultation and training pertaining to VR (Virtual Reality), Rhino 3D, Grasshopper and Blender in Singapore.

Parametric tiles with Blender and Sverchok

How to generate parametric tiles ready for 3D printing with the free Blender’s Sverchok add-on.

Some time ago I got very intrigued by this article: 3D Printed Patterned Landscapes from the University of Nicosia. As part of a 2nd year Digital Design Course at [ARC] Department of Architecture, University of Nicosia, the participants were asked to model and 3D print parametric tiles using Rhino and paneling tools. The results where fascinating:

I’ve then decided to try to replicate the experiment and to show the process here. Instead of Rhino though, we will use Blender and its great add-on Sverchok. Sverchok is a parametric tool for architects and designer with a node-based layout. It is inspired by Grasshopper and has similar features. If you are interested in parametric design or you are already a Blender user, I encourage you to explore it, it has a great power and it is constantly under development.

In this tutorial we will see how we can use Sverchok to create parametric tiles similar to the ones that the students of the university of Nicosia did.

Before starting, make sure you have set up Blender for 3D printing like we explained in our tutorial. Now download the Sverchok add-on from its GitHub repository and install it. It will be become available in the Node editor.

We will try to go step by step, however, if you don’t understand something, please refer to the documentation or to the material listed in Nikitron webpage. Also, a basic knowledge of modeling with Blender is assumed.

Creating the asset

The first thing we want to do is creating a basic asset that will undergo the transformations. I chose the following shape, you can go for a simpler or more complicated one, just remember to subdivide it on the vertical plane a sufficient number of times (at least ten) in order to twist it later on. Also, it should have a rectangular base since it will lay on a squared grid.

The node tree

Now create a new Sverchok node tree and add a Objects in node. You can do this by pressing SHIFT+ A and look for the node or type it’s name under the Search function. Once you have added the node, make sure the asset that we have previously created is selected and click Get selection on the node.

Nothing happened but don’t worry. Add a Viewer Draw node and plug the Vertices and Polygons sockets: in the center of the scene you will find the asset recreated by Sverchok.

Now we are going to use a powerful node called Adaptive Polygons but first let’s create a plane via Sverchok.

Now the magic, add the Adaptive Polygons node to the tree and plug the sockets as shown in the image (remember to center the plane):

This is already quite nice, but we can do much more. Let’s twist the assets, with the Simple deformation node.

This could already make a nice print. If you are happy with the result, click Bake in the Viewer Draw node and the new asset will be added to your Outliner.

How about introducing some randomness in our composition though? Try the Randomize input vertices node.

Although the node worked, unfortunately now our tile is not anymore a square; if you want to remedy to this problem, this could be an approach:

This is a worth printing tile! Before baking it, let’s add a last node, Mesh Join, which will join the 16 assets into one. Then we can press Bake.

Now rotate and scale the generated mesh according to your desired dimensions.

Export it to STL and you are ready for printing your parametric tiles. Now you can experiment with different base assets and parameters and see what you can came out with.

We will explore Sverchok also in future tutorials as there are many ways in which we can apply it to digital fabrication!

[HELP] Workflow Rhinoceros 5.4.1 to Blender 2.8

Hey, I wanted to export .OBJ file to keep layers from Rhino in Blender. But when importing to Blender nothing shows and layers don’t work also. Here are screenshots of export process:

I also tried it in Windows enviroment and nothing changes. Another weird thing is that the .OBJ file is 920MB in size.

Thanks anyone for any advice in advance

I’m a bot, bleep, bloop. Someone has linked to this thread from another place on reddit:

If you follow any of the above links, please respect the rules of reddit and don’t vote in the other threads. ( Info / ^ Contact )

Pretty sure that .obj format doesn’t support layers.

Make sure you are selecting everything you want to export (Ctrl+a), then type “export” and choose wavefront .obj from the drop-down.

Fix the file size issue by previewing the meshes before exporting using the Preview button in the Polygon Mesh Options dialog. Alternatively, tessellate the NURBS surfaces manually using the Mesh command, and export only the meshes into an OBJ file.

To export layer names, in the OBJ export settings dialog select Export Rhino object names: As OBJ objects and Export Rhino layer/group names: Layers as OBJ groups.

2 Significant digits is better than 16.

Having nothing visible in Blender might be a scaling issue. Select one mesh in Blender and check its dimensions. If it’s too big, for example 10km, scale everything down, and vice versa. To speed up troubleshooting, export just one simple object and try to get it visible in Blender.

To import layer names, in the Import OBJ settings enable Split by: Group and disable Split by: Object.

grasshopper code

. a collection of codes & grammars for Grasshopper, a generative modeling tool for Rhinoceros.

3D Hilbert Curve

This definition generates a 3D Hilbert Curve, a continuous fractal space-filling curve.

nGon mesh tessellation

Starting from a closed surface it builds a nGon mesh tessellation

Curves Sorter

Starting from a list of curves it takes the first one then it looks for the closest curve and it eventually flips the direction to optimize the toolpath lenght.


A sparse collection of tools for Grasshopper.

See the code, explanation and download here.


This definition groups indexes of connected points into separate clusters. It requires Sandbox & Anemone plugins.


This definition simulates a spirograph tool.

3D Differential mesh relaxation

This definition explores the 3D relaxation of a mesh effected by an image gradient.

2.5D Differential mesh relaxation

This definition explores the 2.5D relaxation of a 3D mesh by a system of attractor points forces.


This definition creates a mesh model of all the connections between the centers of the 3D voronoi cells and the adjacent cells.

2D Differential mesh relaxation

This definition explores the 2D relaxation of a mesh by a system of acctractor points forces.

3D Hexagonal Weaving

This definition explores the weaving of an hexagonal grid providing 3 different interwoven frames.

Vectors field over HexaMesh

This definition explores the deformations over an Hexagonal grid by a vectors field of point charges and the colors of the resulting mesh are driven by the field values.

Mesh faces by deviation angle

This definition selects adjacent mesh faces depending on the angle of deviation. It requires Hoopsnake & Starling plugins

Erwin Hauer’s Box Morph

This definition explores the Box Morph technique to get the Erwin Hauer’s continual surfaces using meshes.

Math surfaces

This definition provides several math surfaces (nurbs and mesh) based on k3surf formulas.


Custom user object (written in C#) to find the mathematical intersection(s) of 3 spheres.

you can dowload the files (user object + sample gh definition) here:


A serie of Clusters/Components in order to export and visualize directly a SVG file

ASCII art generator

This definition uses any image to create a AASCII art picture.

Recursive subdivision

Recursively subdivide a surface in order to minimize panel curvature (tested by keeping the distance between the centroid of the subsurface and its projection on the subsurface itself below a given threshold). Uses a C# custom component. It will all be a lot clearer if you give it a try.

Tangent threshold

This code samples one or more curves and, for each sample point, gives the points in both directions whose tangents form a given angle with the tangent of the given point. In narrow curvature zones the two given points will tend to be close to the original one, while in straighter zones they will spread farther. Uses a C# custom component.

Koch Snowflake [Hoopsnake]

This code creates a Koch Snowflake 2D fractal using the Hoopsnake component

Sierpinski Triangle [Hoopsnake]

This code creates a Sierpinski Triangle 2D fractal using the Hoopsnake component

Gradient Descent Algorithm

This code creates a Gradient Descent algorithm on a surface generated by an image sampler logic. There’re two type of the algorithm: normal and rotated. The package includes a GH definition, the Rhino 3d file and a map used for the image sampler component.
N.B.Original VBnet code by Woo Jae Sung.

GH to Maya

This tutorial package includes a GH definition with a method to preserve mesh vertices colors after welding and explains a pipeline to render vertex-color meshes in Mental Ray in Maya. Included are: GH definition (v 0.9.0014), Rhino 4.0 file, .fbx mesh sample, .mb file with finished result

GH to Blender

This tutorial package includes a GH definition with a method to preserve mesh vertices colors after welding and explains a pipeline to render vertex-color meshes in Blender with Cycles. Included are: GH definition (v 0.8.0060), Rhino 4.0 file, VRML mesh sample, Blender file with finished result


A definition that draws custom size cubic voxels onto a surface or polysurface.

Ribs Structure

This definition creates from a given Nurbs surface a Ribs structure and all pieces unrolled.

Strip fabrication

Fabrication of single-curvature striped surfaces. A study based on the Strip Morphologies technique by ©StudioMODE

Seamless Pattern

. A simple GH definition that mimics the Escher patterns process.

DiY Architectural Dialogue machine.

. insprired by this post –
i did a GH def to sort random strings from several lists of data in order
to do an architectural dialogue machine.


a simple GH definition to import a Blender3D geometry using the export .PLY file format


Random hexagonal based pattern generator

Uneven Subdivision.

Uneven subdivision of a NURBS surface, controlled by random intervals.

Complete Diagrid.

Diagrid definition that covers the whole surface, up to the edges.

Phyllotaxis growth.

Phyllotaxis variation working on variables with a few changes of the values “i” in the math formula of spiral: x= cos(i), y=sin(i), z=i


Phyllotaxis 2D pattern.

Curvature analysis pattern.

This definition subdivides a surface into a quadrangular panels, plots a circle or a closed spline(similar to an ellipse) with center in the centroid of each panels, scale the radius dimension trough a numeric values extrapolated from the curvature analisys of the input surface.

Attractors vector deformation.

The complex structure of radiolaria was treated as a two-dimensional representation with a hexagonal pattern. Two points control the deformation of individual cells that make structure through a transformation of vectors connecting the vertices of the single cell with the point. The deformation of the grid can be caused by an attraction or a repulsion generated by attractor points.

Image field04.

Investigation on the potentiality of numerical field generated by a source image. The height of one ellipse control point is linked with grayscale value of the image generating parametric variations in the starting flatten pattern.

Pie chart.

A definition that draws a percentage pie chart from a list of values (random values are used here but you can plug any list of values including external data).

Panels dispatch

This definition allows you to tessellate a surface with two different panel types dispatched through random sorting.

Quad 2 diagrid

This definition allows you to tessellate a surface and smoothly transform the tessellation from a quadrangular to a diagrid pattern.

Hexagonal field

A magnetic field applyed to an hexagonal grid ruled by 4 points that can be switched (attractors or repulsors).

Tatami-Cairo-Diagrid tessellation

This definition allows you to tessellate a surface going smoothly from tatami tessellation to diagrid through Cairo tessellation.

Curve driver

This definition allows you to control geometry properties (curvature radius) through a control curve.

No Comments

Leave a Reply

Your e-mail will not be published. All fields are required.