TABLE OF CONTENTS

CHAPTER 0 - About This Book ----------------------------------------[1]

CHAPTER 1 - What Are Geometry Nodes? ------------------------[2]
CHAPTER 2 - Getting Started -----------------------------------------[7]
CHAPTER 3 - Ice Cream -----------------------------------------------[11]
CHAPTER 4 - Vectors, math, and time ----------------------------[16]
CHAPTER 5 - What Is A Field? --------------------------------------[23]
CHAPTER 6 - Duality Of The Donut -------------------------------[32]
CHAPTER 7 - So… Curves -------------------------------------------[42]
CHAPTER 8 - Now We’re Rolling! ----------------------------------[46]
CHAPTER 9 - Unchained ----------------------------------------------[53]
CHAPTER 10 - Grass ---------------------------------------------------[61]
CHAPTER 11 - 3D Text ------------------------------------------------[68]
CHAPTER 12 - Head In The Clouds---------------------------------[79]
CHAPTER 13 - The End - With Ice Cream-------------------------[86]
CHAPTER 14 - The Time We’ve Spent-----------------------------[99]
CHAPTER 15 - Page 100--------------------------------------------[100]
First and foremost, thank you for buying this book. It’s thanks to readers like you -
yes I'm looking at you - that I can do this whole Blender education schtick. I’m very
grateful. I just wanted to say that - moving on!

Welcome to the world of Geometry Nodes! A world of scary math you forgot from
highschool (or maybe some of you are still in highschool), vector operations, and
yes… there are nodes. But worry not! This book really and truly is an introduction.

I won’t assume anything from the get go. We’ll start from the beginning. Back to
square one. The real fucking basics. Not: what are geometry nodes? No no! We start
from: what is a node? And speaking of basics, we’ll do math review as well. I know, I
know, thrilling…

But after trudging through the math and slaying some nodes, you will have a new
tool in your arsenal. An invaluable skill set. The power to ‘proceduralize’ pretty
much anything (we’ll get into what procedural means in a bit).

By the way, expect a lot of images and diagrams. Geometry nodes are very
conceptual. Very abstract. Very… well… ‘nodey’. To explain everything we’ll be using
lots of words, images, and…

That’s right! QR-Codes! Make sure to scan these!

After all, this is the very first (as far as I know)
interactive Blender book ;)
Let’s get started!

1
 “What the fuck are Geometry Nodes?”
- Lao Tzu

Before defining Geometry Nodes we should probably talk about what nodes are.
Sounds like Geometry Nodes will have plenty of them. Put simply:

This operation could be moving something, calculating the center-point of an object,

or anything really. Here is an example of a node called UV Sphere:

So… clearly this is a visual representation. But for what operation? After all, a node is
“a visual representation of an operation”. Well in this case the operation is
generating a sphere. Pretty simple. Here comes another one:

2
In this case we have a “Group Output” node. What operation does it do? It outputs
(displays) the geometry! Notice the Geometry input “ ” dot. And on the UV Sphere
node! Another “ ”! But this time it’s on the right side of the node. Therefore it
must be a geometry output. In general, when you see green, think geometry.

Let’s send geometry output data to geometry input via a connection which is:

Connecting these 2 nodes would look like:

What is this node network (network of nodes) doing? Think of it like this:
1) The UV Sphere node is generating a sphere (as geometry data)
2) This sphere data is being sent to the Group Output node via a connection
3) The Group Output node is outputting this data
And the result looks like this!

3
So very literally, this node network creates and displays a sphere. Pretty much as
simple as it gets. The astute reader, or really anybody with eyeballs probably noticed
something else… The UV Sphere node has a lot of - ummm - settings? Things like
segments, rings, and radius. Look here (highlighted in red)!

In the trade we call these parameters:

So in this case, the node network on page (3) displays a sphere with a 32x16
resolution (in terms of rings and segments) with a radius of 1 meter. We could have
just as easily modified these parameters to generate different spheres:

Changing these parameters actually touches on something subtle. Maybe the most
important thing in Geometry Nodes. And that thing is proceduralism:

4
I know, I know. I’m assaulting you with definitions. But this is the second-to-last one.
I promise. In layman’s terms: procedural refers to a recipe. In our first node network
that recipe was:
1) The UV Sphere node is generating a sphere (as geometry data)
2) This sphere data is being sent to the Group Output node via a connection
3) The Group Output node is outputting this data

Note that by changing the UV Sphere’s parameters we generated different spheres.

But the recipe remained the same! We didn’t have to create a new sphere each time
from scratch. No, we just changed some numbers and followed steps (1), (2), and
(3). We call this kind of workflow non-destructive (because we can just go back to
any step in the recipe and change some values).

Kinda hard to wrap your head around right? Think about it like this. You’re mixing
two colors of paint. Red and blue. Blue and green. Whatever. We’re just mixing two
colors of paint, and of course this generates a new color (red and blue makes
purple). But can we un-mix these colors? Nope. Once you perform the ‘mixing
operation’ we can no-longer separate the colors. Hence, a destructive workflow.

Instead now imagine we have the recipe:

1) Pick color A
2) Pick color B
3) Mix colors A and B

Well this is a non-destructive workflow. Why? Because we can always swap out our
inputs for A and B. Via nodes! It’s like we can go back in time and then run the
procedure again (see why it’s called proceduralism now?). The node network for this
recipe would look like this by the way:

5
In the case of this node network the two Color nodes have a color parameter. We can
change these at any point. This data is then sent to the Mix node which… well it
mixes. Now just to be crystal clear, this is a node network. It is composed of 3 nodes.
Each node is an operation (Color nodes generate a color, Mix node mixes them). The
data is sent from one node to another via connections. And finally this is all a
procedural non-destructive workflow (because we can change the input parameters
and ‘go back in time’ at any point).

Now for the big finale! What the fuck are Geometry nodes?

And there it is folks! That is what this book is about. Generating node networks that
have to do with geometry!1 And it turns out we can push this concept quite far. From
generating meshes, to particle explosions, to… almost anything really.

To review this chapter use the QR-Code below:

1
As opposed to shader nodes which are node networks related to materials. Or compositing nodes which are
node networks related to compositing. You get the point.
6
 “When do we start wrangling nodes?”
- Albert Einstein

Now regarding Geometry Nodes, here’s the plan. We’re going to get as many nodes
under your belt as possible. Enough to get you going. You already know a few of
these like the UV Sphere, Color, and the Group Output nodes. But there are more.
Much more. As of writing this, there are 189 nodes. They are:
Attribute Statistic, Capture Attribute, Domain Size, Remove Named Attribute, Store Named Attribute, ColorRamp,
Combine Color, Mix Color, RGB Curves, Separate Color, Curve Length, Curve to Mesh, Curve to Points, Deform Curves on
Surface, Fill Curve, Fillet Curve, Resample Curve, Reverse Curve, Sample Curve, Subdivide Curve, Trim Curve, Curve
Handle Positions, Curve Tangent, Curve Tilt, Endpoint Selection, Handle Type Selection, Is Spline Cyclic, Spline Length,
Spline Parameter, Spline Resolution, Set Curve Normal, Set Curve Radius, Set Curve Tilt, Set Handles Position, Set
Handle Type, Set Spline Cyclic, Set Spline Resolution, Set Spline Type, Arc, Bezier Segment, Curve Circle, Curve Line,
Curve Spiral, Quadratic Bezier, Quadrilateral, Star, Offset Point in Curve, Curve of Point Points of Curve, Bounding Box,
Convex Hull, Delete Geometry, Duplicate Elements, Geometry Proximity, Geometry to Instance, Join Geometry, Merge
by Distance, Raycast, Sample Index, Sample Nearest, Separate Components, Separate Geometry, Transform, Set ID, Set
Position, Boolean, Collection Info, Color, Integer, Is Viewport, Material, Object Info, Self Object, String, Value, Vector,
ID, Index, Named Attribute, Normal, Position, Radius, Scene Time, Instance on Points, Instances to Points, Realize
Instances, Rotate Instances, Scale Instances, Translate Instances, Instance Rotation, Instance Scale, Replace Material,
Material Index, Material Selection, Set Material, Set Material Index, Set Shade Smooth, Vertex Neighbors, Shortest Edge
Paths, Mesh Island, Is Shade Smooth, Is Face Planar, Face Set Boundaries, Face Neighbors, Face Area, Edge Vertices,
Edge Neighbors, Edge Angle, Triangulate, Subdivision Surface, Subdivide Mesh, Split Edges, Scale Elements, Sample UV
Surface, Sample Nearest Surface, Mesh to Volume, Mesh to Points, Mesh to Curve, Mesh Boolean, Flip Faces, Extrude
Mesh, Edge Paths to Selection, Edge Paths to Curve, Dual Mesh, Canoe, Cube, Cylinder, Grid, Ico Sphere, Mesh Circle,
Mesh Line, UV Sphere, Corners of Face, Corners of Vertex, Edges of Corner, Edges of Vertex, Face of Corner, Offset
Corner in Face, Vertex of Corner,Viewer, Distribute Points in Volume, Distribute Points on Faces, Points, Points to
Vertices, Points to Volume, Set Point Radius, Join Strings, Replace String, Splice String, String Length, String to Curves,
Value to String, Special Characters, Brick Texture, Checker Texture, Gradient Texture, Image Texture, Magic Texture,
Musgrave Texture, Noise Texture, Voronoi Texture, Wave Texture, White Noise Texture, Accumulate Field, Align Euler to
Vector, Boolean Math, Clamp, Compare, Field at Index, Foat Curve, Float to Integer, Interpolate Domain, Map Range,
Math, Mix, Random Value, Rotate Euler, Switch, Pack UV Islands, UV Unwrap, Combine XYZ, Separate XYZ, Vector
Curves, Vector Math, Vector Rotate, Volume Cube, Volume to Mesh, Group Input, Group Output, ‘Frame’, and
‘Reroute’2

So you know, no biggie. Really though, we’ll only be talking about a handful of these.
This is an introduction. Not torture3.
2
Frame and Reroute aren’t really nodes, they’re more like organizational tools.
3
Not yet at least.
7
But before we go collect some nodes, we need to know how to access them in the
first place! Cue… workspaces!

When you open up Blender you’ll see a bunch of workspaces at the top bar. Things
like ‘Layout’, ‘Modeling’, and more. Click the Geometry Nodes workspace and you’ll
be greeted to:

8
Note that there are - count em’ - 1,2,3 windows. Each is vitally important to working
with Geometry Nodes (especially the Geometry Node Editor).

The 3D Viewport we’re all familiar with. It’s where we see our geometry in 3D space.
The other two should be new to you4. First we have the Geometry Node Editor. This
is where we’ll be wrangling all our nodes. Think of it as our node canvas. And paint
we shall! Secondly we have the Spreadsheet window. This is where all our data is
displayed. Kind of like an Excel sheet. In fact right now you can see 8 entries
(indexed 0 through 7) that actually show the XYZ coordinates of each vertex of our
default cube. There will be much more data we can access later.

Next we’ll create a Geometry Nodes network by clicking the +New:

This will create our very first Geometry Nodes network! It should look like this:

Now we already know that a node network represents a procedural recipe. What is
the recipe doing in this case?
1) Geometry data is being imported into the Group Input
2) That data is being sent to the Group Output node via a connection
3) The geometry data is being displayed by the Group Output node
Long story short, this network just generates our cube. But look! We have another
new node - the Group Input node.

4
Unless perhaps you’re familiar with one of the other node editors in which case the Geometry Node Editor will
look familiar.
9
What this node does is store the geometry data of our initial object. In this case that
initial object is a cube. But it can be anything really. Here is a QR-Code to explain:

Now, we have our Geometry Nodes editor populated. We have our simple network.
But how do we add more nodes? You have two options. The first is to use the add
function:

The second is to use the hotkey shift+A. I heavily recommend the latter.

Either way you’ll then have access to all the nodes. You’ll
then want to use the search feature (highlighted in red) to
find any node we’ll be talking about.

And that’s about it… we’re now ready to start :)

10
 “I have no mouth and I must eat ice cream”
- Harlan Ellison

In this chapter we’re going to make delicious ice cream. Our first real geometry
nodes project. And it will look like this:

Yum. I feel like I’ll break a tooth eating that. Anyways, here is the node network:

A lot more nodes than before right? As intimidating as this may look it really is quite
simple. Notice that on the left we have 2 mesh primitives (the cone and the UV
sphere),

11
3 transform nodes,

And 1 join node:

So we read this node network as:

1) We start with a cone and a sphere
2) We transform the cone (rotating it upside-down)
3) We transform a copy of the sphere (the first scoop)
4) We transform another copy of the sphere (the second scoop)
5) We merge everything together
6) We output that geometry
Not too complicated right? But really we have lots to unpack here. From what the
mesh primitives are, to how the transform node works, to the idea of joining. Let’s
take things one step at a time…

Starting with mesh primitives - we said that we used 2 of these, the cone and the
sphere. Just so you know our options were:

12
We happened to pick the cone and the sphere. Why? Because those were the shapes
that served our project. Something like a cube, or a cylinder would not be useful
here.

Think of mesh primitives as our building blocks. The 8 shapes we get for free. The
founding fathers. The cone served as our ice cream cone. The sphere served as our
scoops. But we need to transform these into the right positions!

When expanded, the transform node looks like this:

It lets us translate, rotate, and scale an input geometry (which it then outputs). By
rotating by 180o on either the X or Y axis we flip our cone upside down:

13
Then by translating the sphere twice we get the positioning for the 2 scoops:

Finally we join the trifecta together with a join node! All in all, our node network
end up looking like this:

14
While this project was super simple it hits on some important points. Firstly, if you
can describe the recipe for how to make something - or the procedure for it - then it
can be made procedurally with a node network! Remember our recipe in this case
was this:
1) We start with a cone and a sphere
2) We transform the cone (rotating it upside-down)
3) We transform a copy of the sphere (the first scoop)
4) We transform another copy of the sphere (the second scoop)
5) We merge everything together
6) We output the geometry

So the first step with any Geometry Nodes project is to conceptualize this recipe.
We’ll be tackling larger and more complex procedures as we move on.

Secondly, we learned that with only mesh primitives, transforms, and joining
geometry we can make all sorts of meshes. I challenge you to use the same
techniques to make something else5. Here is an example project of making a
snowman6 using only the nodes we talked about:

5
Just some ideas: robot, dumbbell, simple tree, seesaw.
6
This is a much more complex result that can be generated from the same set of nodes.
15
 “I love math”
- Everyone

Ah yes. The math chapter… We had to do this at some point so I figure let’s do it
early while you’re still fresh. Vectors, math, and time will be showing up everywhere
throughout this book. So pay attention!

When I say vector I’m referring to a (almost always 3-termed) list of numbers like
these:

More generally it’s a list of numbers in the form:

Where do these show up? Well… everywhere! If we’re moving a cube up on the z-axis
by 2 units then we’re translating by the vector:

Or let’s look at the default cube’s transforms:

16
Notice that this is just a list of 4 3-termed vectors. One for location, rotation, scale,
and dimension. Even some of the nodes we looked at before have vectors. Remember
the transform node?

This has 3 vector inputs (signified by the purple ‘ ’ whereas the geometry input has
the green ‘ ’) for translation, rotation, and scale.

Even 3D space is described by these ‘3-dimensional’ x, y, and z vectors. So get used

to em’! Of course vectors have their own node:

17
Now the math. Yay… Basically the two math operations you need to know when it
comes to vectors are addition and multiplication7. Adding looks like this:

Or in other words, we add vectors by adding their components. For example:

And for vector multiplication we have:

Or in other words, we multiply a vector by a number by multiplying each component.

For example:

And that’s really it for vectors! Now when it comes to math operations, we have 2
nodes to do this, the math node and the vector math node. As you might guess, the
math node is for doing math operations on numbers and the vector math node is for
doing vector math operations on vectors. They look like:

7
For the math-y people reading: I’m talking about scalar multiplication, not matrix vector multiplication.
18
So the vector addition example from before looks like:

And the vector multiplication example looks like this:

By the way, something subtle is happening here with the multiplication example. Do
you see it? No!? Look closer… we’re multiplying by a single value (‘5’), but we’re
plugging it into a vector socket! This is a sort of shortcut where by ‘5’ we’re
referring to the vector ‘[5,5,5]8’. We just don’t want to write it all out with another
vector node. So yes! You can plug numbers into vector sockets. Just be aware of
what’s happening under the hood.

Finally we have the concept of time. Cue Stephen Hawking narration. In Geometry
Nodes we actually have a specific node for this. As you might expect, it’s used to
drive animations (since animations need time for them to even occur).

8
I’ll be using column vectors and row vectors interchangeably. Don’t @ me.
19
Here it is:

Notice that whether we use seconds or frames this will output a number whose value
depends on our timeline. This means we can now animate things!

Let’s start off with something simple but familiar. Using nodes from before.
Something like… having a sphere perpetually rotating in a circle:

This will force us to use everything that we’ve learned. As always let’s start from the
recipe:
1) Create a sphere
2) Calculate the position vector over time to translate the sphere by
3) Translate the sphere by that vector
4) Output the geometry.

20
And just like that we’ve broken down this behemoth into a bunch of little tasks. Most
of which we know how to do. I’m going to emphasize this again and again until you
cry: write down your procedure first!

In this case we already know how to do steps (1), (3), and (4). It’s step (2) that’s the
trouble. How do we know where the sphere will be in a given time? Believe it or not,
if you’ve taken a trigonometry class you already know the answer *hint!*. Let me
rewrite the same problem:

A particle is traveling along the unit circle. What are it’s

x,y coordinates at a given time t?

Look familiar now? Common! It's right there! We are looking for 2 functions x(t), y(t)
that tell us the coordinates about the unit circle… Oh!!! That’s right:

cos(t), sin(t)

So for step (2) we just need the node network representation of the vector:

21
Looks like a job for the scene time node and the math node! We will write out each
component of the vector and then combine those elements using the last node for
this chapter, the Combine XYZ node:

This is the piece of the puzzle that takes our 1-dimensional inputs and slaps them
together into a 3D one.

Finally we can execute our procedure. The Final node network looks like this:

22
 “There is no ‘I’ in team, but there is one in field.”
- Charles Whitmore

You’re not going to hear about Geometry Nodes without fields mentioned in the
same breath. So what are fields? How do we harness their power? What can fields do
for us? Quite a lot actually.

You may have noticed that some nodes we’ve discussed have inputs that look like
circles (‘ ’ for geometry input for example) and some have diamonds (‘ ’ as a
vector input for example). To keep it as simple as possible:

Circle Constant
Diamond Field

So, if a constant is something that is the same - or constant - everywhere… then a

field must have the ability to vary. What is varying? What is a field? What is
anything!?

Pretty vague right? It turns out this isn’t really a complete definition. But for our
purposes it will get us started. Don’t worry. I’ll explain.

Consider a new node, the position node:

23
You’ll see that this node has that diamond shape from before. So this must output a
field right? Yes. And because that diamond is purple we know that this is not just a
field but a vector field.

From our definition, this node then assigns a position (this is the property) to every
point. And this position can vary… Which… makes sense right? Every point can have
its own [x,y,z] position vector. And this vector can vary from point to point.

Now consider the vector node from last chapter:

This also has a purple output, but it’s a circle. Implying constant. A constant vector.
Does this make sense? Well consider we input something into the x,y,z parameters.
We’d then have a set vector. And only that vector! No variation whatsoever! Unlike
position which is a vector unique9 to each point. Starting to get it?

Again:
Circle Constant
Diamond Field

So a single vector is constant everywhere, for all points. But something like position
varies. Can have different values for different points. As a rule - when we’re talking
about fields, think about variety. On the other hand constants… have no variety at
all. They’re the same everywhere. Like time as another example. Time must be the
same for all points in space10. Hence a circular output:

9
Assuming that no 2 points perfectly overlap.
10
Forget all the Einstein relativity nonsense.
24
By the way, when it comes to fields we get a sort of bonus. Remember the
spreadsheet editor from before? It’s the top-left window that carries all that data:

Well would you look at that… There is the position field with all its vectors for each
point on the default cube. And look at that! Another field hidden in plain sight!
Check out the numbers or indexing that goes 0,1,2,3,...,7. This is the index of each
point of the default cube. And of course here is the corresponding field node:

Lastly, let me introduce one more field that we’ll be using. The normal field. As you
expect, this node carries the normal vector data for each face:

And just in case you didn’t know, when we talk about normals we’re referring to the
perpendicular vector to each face. Kind of like the ‘outwards’ direction.

25
Let’s do something with these fields already! Okay, okay - calm down. We need one
more critical node…

It looks like this:

Think of this as the transform node on steroids. Instead of transforming an entire

mesh, we can transform any part of that mesh individually, and in different
directions! It’s almost like we have a transform node for each point of the geometry.

To illustrate the power of this, let's try to make some more complicated shapes.
Specifically a spiral, a star, and whatever the fuck the third thing is:

Starting off with the star, we need our recipe… A procedure that can generate the
shape. I’m thinking that this star kind of looks like a circle with every other point
stretched outwards. Something like this:

26
So if we can express that procedure in terms of nodes then we’ve done it. The
procedure is then:
1) Generate a circle
2) Select every other point
3) Translate that selection outwards
4) Output the geometry

For step (1) we can use one of the mesh primitives. The mesh circle primitive11:

For step (2) we can use the indexing of the circle along with a bit of clever math.
Remember modulus? That thing that has to do with remainders? If not, let me remind
you. If we have:

Then the result is the remainder of b÷a. For example:

This is because 3 goes into 14 three times (resulting in 12) and there is a remainder of
2.
Now for the clever part. Suppose we take the indexing (mod 2). That is 1,2,3,...,16
(mod 2). Then we get 1,0,1,0,1,... In other words we alternate between 1 and 0!

11
I’m going to generate a circle with 16 points so that the star will be 8-pointed.
27
This is exactly what we need for selecting every other point in step (2). The nodes
would look like this:

Remember, the indexing is our enumeration of the points along the circle - and by
taking modulus 2 we’re essentially saying “Hey! Pick every other point!”.

Now for step (3), we need to move the selection outwards. Really there are two parts to
this: assigning the selection and specifying ‘outwards’. But remember! We just created
our selection and we have a field for ‘outwards’, it’s called the normal field. And by
adding in a group output (that is, step (4)) we arrive at:

Which indeed outputs a star! Notice that we’re offsetting using the set position node
because we need custom offset directions for each point (given by the normal field).
We hooked our modulus setup into the selection input which has this pinkish color. The
diamond part of ‘ ’ tells us that it must be a field input. But what is that pinkish color?
Turns out it’s something called a boolean.

28
Think of this as on and off. True and false. Yes and no. Or in the case of our modulus
selection… 0 and 1. A field that tells us which points we should be offsetting. Let’s
move on.

For our spiral:

What’s our recipe/procedure? Well in general we could:

1) Generate a line
2) Transform that line into a spiral
3) Output the spiral

The pudding of course is in step (2). But we’re not there yet. Let’s start by generating a
line. This is another one of our mesh primitives:

In this case we don’t really care about the start and end of the line because we’ll be
transforming this entire mesh in step (2) via indexing. Speaking of which, what is the
transformation that takes us from a line to a spiral? Well let’s think about it…

If we look at the spiral from the top view you’ll see that it profiles a circle:
29
This gives us a hint as to what the transformation will be. Really a spiral is the result of
tracing a circle while going up on the z-axis. Meaning that step (2) boils down to:

Where ‘x’ is our progress along the line. Now how do we output how far along the
mesh line we are? Indexing! Our vertices are literally labeled 0,1,2,3,... all the way
across the line. So… let’s express our transformation in terms of nodes:

Notice that I added a little something extra. The divide operations. These are just to
control the dimensions of our spiral (the height and the number of rotations). Think of
these as parameters for our spiral. The ‘settings’ of it.

Now to make our transformation real, we need to, well, transform it. Again, we’ll be
using set position for this because we want each point mapped to its own destination.
This time instead of offsetting the position, we’re hardwiring it in. Setting the position
explicitly. Along with step (3) which involves the group output node, we arrive at:

30
Finally we’re at the last shape. This thing:

I’ll leave this as an exercise for you to practice but here’s a hint. The transformation
equation for this one is12:

Now for your review 🥳 :

12
Notice that the z-component is 0 because this shape rests on the xy-plane.
31