In today's video, we're going to dive deep into demystifying Blender's geometry nodes. We're going to go into certain technical details that most other videos skip so that by the end of it, you're not only confident with using Blender geometry nodes, but you feel like a pro who understands exactly why we're doing what we're doing and what you can and cannot do. We're going to go through right from basic concepts like data types and data flow to everything unique to Blender's geometry nodes such as the colors, the socket types, as well as the node types that there are and how they're colorcoded. We're going to pack this video with useful tips and tricks so that even if you are an intermediate geometry nodes user, I'm very confident that you'll have something to gain from this video if you watch it to the end. So if this particular screen seems daunting to you right now, don't worry, cuz by the end of this, all of this is going to feel like a breeze. And with that, let's actually dive into what geometry nodes actually are. Geometry nodes at its crux is just a modifier. That means it takes some input geometry, modifies it in some way, and provides an output. So that's why to add geometry nodes, you have to first go to the modifier properties and click add modifier. And from there, you can choose geometry nodes. Then you can press this plus button to create a new geometry node tree which is going to be labeled right over here. However, in order to actually access this, you're going to have to open a geometry node window which you can do by bringing your cursor to the junction of these two windows, clicking and dragging to create a new window and then changing this from the 3D viewport to the geometry node editor. After that, you can zoom in and you can take a look at this group input and group output. Now you can remove the side panel by tapping N. But all in all, this is all we're going to be working with in geometry nodes. Another method of creating this geometry node without going to the modifier is simply by switching this viewport to the geometry node editor and pressing this new button over here, which will automatically create and add a geometry node modifier in the modifier panel. Now all geometry nodes is actually doing is taking some input geometry modifying it somehow over here and providing that as an output. So what we're actually modifying is the data that's present between the input and the output. So the first thing that we actually need to understand is data types because for example this by itself the geometry is a complex data type that contains what type of geometry it is and in this case it's a mesh with data about the vertices the edges and the faces the number that they have as well as the position of the vertices and so many more things. So before we get into complex data types like this geometry data type, let's go ahead and deal with some more basic data types. In order to help visualize these data types, we're also going to be looking at the spreadsheet, which you can see from this drop-own button over here. However, we're going to take a look at the spreadsheet in a while and just focus on different data types. The most basic data type is the integer. So an integer is a whole value. That means it cannot be 75.5 or anything like that. But it has to be a whole value. As you can see, changing it changes it by one full digit. Now it does not have to be positive. It can also be negative as well. As you can see over here, the only thing is that it has to be a whole number. Similarly, even if you try making it 4 or something, it's going to get rounded down or rounded up based on what you try typing after the decimal point and it's going to become a whole number which is called the integer. You can identify the data type is an integer by this lime green socket which can be passed into other lime green sockets. Now you can manipulate this in many ways such as you know over here we're just checking if it's greater than or less than or you can put it into a math node and so on and so forth. But the base idea is that an integer data type no matter what you do to it will remain a whole number only. Examples of integers could be something like the index value, which is always going to be a whole number. Or if you're trying to count the number of points, for example, you add this in and you have a count, you can't have 2.5 points. You can only have a whole number. And that's why you would always want to use an integer. So that even if by chance somebody was to try and put in a decimal value, it's going to round it off to become a whole number only, which is why we use integers. But what if you didn't want to use integers and you wanted it to be a decimal point? And that actually brings us to the next data type which is the floating point data type. The reason it's called floating point is because this decimal point can actually be present anywhere within your number. So for example, you could have 73.6. You could also have 736.987 and so on and so forth. And it's actually going to take that in. As you press this, you see it changes the value right after the decimal point. But you have absolute fine control over which number you want to change and so on and so forth. This is depicted by a gray socket and you can add that into any other gray socket. And the coolest part about this is that you don't have to always connect gray to gray or green to green as you can see. But if you were to take this green value or this green socket and plug it into the gray, you can see the green converts itself to a gray, which means instead of -61 as an integer, it'll turn into -61.0000 when it comes in over here. Similarly, if you were to have some sort of a value present over here, like 737.385, if you were to plug this in over here, it still works, but it gets converted into an integer, which means it's going to change down to 737. We can actually visualize this by plugging this into the output. And now you can see that over here the value is 737.385, but over here the value is just 737 because it's been converted into an integer. as you can see. But now these are very basic data types. Let's go on to something a little bit more fun which is more used in geometry nodes. The next type is what if you actually want to know something like the position that contains not just one single floating point value but it contains three one for the x, one for the y and one for the z as you can see over here. For that you use what's called a vector. So vectors are denoted by this purple color socket and as you can see they contain three floating point values. So one for the X, one for the Y, and one for the Z. And you can plug all of these into other purple sockets as and when you please. And you can provide multiple vector math operations such as addition, multiplication, so on and so forth, as well as things that you usually associate with just vector math such as the dot product or the cross productduct and so on and so forth. So this is really cool. But another data type which is a little simpler than this and is mostly used in computer science is the boolean which can either be true or false. This is denoted by a light pink socket. Now it can either be false or true and it's usually something like a checkbox. So you can plug that in just like this and use various logical operations such as or and not and so on and so forth. So remember how we had something like a compare node up here which was just checking if this is greater than something else. The result is going to be true or false. Is it greater than or is it not greater than? So you could then check if something is greater than something or if something else is lesser than something. So you could do all of that using some type of math operations which is called boolean math. But essentially that is the light pink data type called boolean which is either true or false. Then we go ahead with a slightly different form of a vector which is called a rotation. So rotations are essentially vectors but they have their values in degrees and they're actually stored as quirons within Blender. So that means they have an axis of rotation and how much they're rotating about that axis. So it actually takes on four different values but three is sufficient to represent a rotation vector. So because rotations use different units and they can be depicted as four values or three values, they use a different data type itself which is called the rotation data type and that is denoted by a pink color socket as you can see. Now you can do crazy things like rotating any vector by some rotation as you depict like this to get a new vector that's been rotated. But we'll look at examples in another video very soon. The next one is when it comes to colors. Colors are depicted by yellow and they have four different values stored within them. A single color will have how much of red it is, green it is, blue it is and the alpha which is like the transparency. So the color data type contains four different values and it doesn't have to be RGB. You can always convert it from RGB to other types such as hue, saturation value or hue, saturation and lightness and things like that. But essentially this color can be used in various ways which you can see in multiple examples which we will do in future videos. Finally you have the newest data type which is the matrices. So matrices are dark pink and they contain essentially 4x4 matrices. That means you have four columns and four rows. So in column one you can have four different rows. Column 2 has four different rows. Column 3 has four different rows and so on and so forth. These are very useful because combining these you can get things called transformation matrices that show you the transform from one frame of reference to another frame of reference. We use these extensively when I was learning my robotics courses or when I did my masters in robotics. We use these everywhere not just for forward kinematics and inverse kinematics. We also use them for calculating things in artificial intelligence while creating our neural networks and things like that. So, this gives me really high expectations for how people are going to be using these in the future of Blender. But for now, it's an amazing addition and I will have a complete dedicated tutorial series on just matrices, what they are and how you use them later on. And then we have the last of the common data types which is the string. Strings are depicted by light blue and they are essentially a collection of characters. So you could type in whatever you want and that would be a string. And it doesn't have to be just alphabets. It could be alpha numeric. That means you could have numbers as well. You could have a few special characters present as well. But of course, not all special characters will be accepted. However, you can use this in different sockets like the string to curve nodes which will convert any string into a curve and you can choose the font that you want and how you want it to be so that you get instances that you can use later on. Now, these were basic data types, but there actually are even more data types which are a little more complex. Starting off with the most important, which is the geometry type. And the geometry type is depicted by this turquoise color. To me, it seems a little more green, but the official documentation says that this is turquoise. So, we're going to call it turquoise. The coolest thing about this is that these nodes actually contain not just something like three values as in vectors or four values like colors or rotations or in this case 16 values like matrices but they contain so much information such as what type of geometry it is. For example, is it a mesh? Is it a curve? Is it an instance? Then the number of vertices, edges, faces, etc., etc. based on what type of actual geometry it is. Now to visualize this better, we're going to use the spreadsheet. So let's go ahead and just open the spreadsheet. Right now you can see in the spreadsheet we have the type as geometry and the geometry is currently stating that it's a mesh. So for the mesh we know that meshes are consisting of vertices, edges, faces and corners. And we also know exactly how many vertices there are, how many edges there are, faces there are and face corners there are. Apart from that each of these have even more data about them which is stored as attributes. So for example the vertices contains this attribute called position that contains the x y and z location of every single vertex present on this particular sphere. So the data type of geometry actually contains all of this information in a single unit. So for example the faces can also know whether it's a sharp face or not. And even the face corners has its UV map associated with it and so on and so forth. So all of that data together forms a new data type called geometry. But this geometry itself has six different types. Mesh which is essentially a bunch of connected vertices or connected points. So this is the mesh type geometry. Then we have curves which is essentially made up of splines. We can actually take this geometry and plug it into the mesh to curve to show you the curve data type. So if the geometry is made of curves, you see these are not actually renderable. If you were to just switch off overlays, you will not see anything because curves don't actually contain any mesh data. So it doesn't know what is to be rendered. However, it's a mathematical representation of a line and that is done using these control points and again the control points have position for the point as well as a UV map associated with it. But as you can see this particular UV sphere is made up of 992 individual lines that for example in this case are running around like that as well as horizontally like that essentially like longitudes and latitudes. So each curve from one point to the other is a spline and there are 992 of them and each of these are control points which you can see right over here. So each vertex becomes a control point and you get a curve between them in the curve data type. Then you have the grease pencil which we're not going to go into too much but it's very similar to this curve except it uses a lot more of the grease pencil properties which is meant mostly for 2D animation in 3D space and it's a very unique feature of Blender. If you want to convert it to a point cloud, you can go for mesh to points. And now you see every single vertex instead of being joined with every other vertex forming a mesh, we actually get just the points. And they're stored in what's called a point cloud, which shows the position, radius, and UV map of every single point. So you can always go ahead and change the radius and values like that by pressing shift A and searching for a set radius. Plugging that in right over here. And now you can see as you change the value the value changes over here as well. So we're actually playing around with the attribute called radius for these particular points and that is what helps visualize them differently. So that is what's actually happening in geometry nodes. But yeah this was made up of 482 individual points. Now there's also volume grids as well as instances. So let's go ahead and look at volume grids that can be done using a mesh to volume node. And as you can see now we no longer see any mesh data curve grease metal or point cloud data but you have a volume grid. Now this volume grid just contains attributes such as the density and we know that the density is going to be a float type and it's present within a class called fog volume. So that's what's determining what method in which Blender is going to be actually visualizing this particular volume object. Now the last type of geometry data type there is is the instances and the instances just contain position, rotation and scale of an original geometry. So while you have an instance you can no longer control the individual points within this particular sphere but you can only change the entire position, rotation or scale of this sphere as a whole. But you can no longer access the individual positions of the vertices within this particular sphere. So an instance is only going to contain this particular geometry data, but it's not going to be able to access the data and actually manipulate it, but instead it can manipulate the overall position, rotation, and scale. So those are the five different types of geometries there are. And you can usually use only one type of geometry with another. And you'll always have to convert them to other types. For example, as you saw, we kept using mesh to curve or a mesh to points or a geometry to instance or a mesh to volume and so on and so forth. You can also do points to volume. You can do points to curve and you can do a curve to mesh and things like that. But essentially certain attributes or certain manipulations or certain modifications work only for specific types of geometry. So you'll need to know how and when to convert from one data type to the other within the geometry data type itself. Next we have a few other data points or data types such as the image which is depicted using this apricot color. Now you can load in whatever image you have and you can use that in nodes such as the image info node or the image texture node which is going to give you information about the image such as its width in pixels, height in pixels, whether it has an alpha channel or not, if it's a video, what's the frame count and the FPS and things like that. Apart from that, you can get the image texture which will give you the color for every single point present within this image. And you can use that to either texture your geometry or if you want, you can even use it to manipulate geometry. For example, if you were to take some particular image and convert it into the image texture, you can then separate out the color and compare. If the value of the color is greater than or less than some part, then you can delete the geometry. After that, you have the collection data type. So, the collection data type is essentially collections, which is a group of objects that are present within your scene. You can create a collection and access the data of all of the objects within that collection using this collection info node or the collection input socket. Then you can do various things such as instance these collections onto various points such as placing the objects from within this collection onto different points within your point cloud. So that collection data type is depicted using a white color socket. Next you have the material data type where you can store different materials. So you can see by default you have some material and you can select that using this particular material data type. Now obviously the material data type is also a very complex data type that contains everything such as what the surface actual material is. The base color, how metallic it is, roughness, everything about it is stored in this material data type. However, ideally the actual data is stored within the material itself and the material data type is only going to point to this particular material and then it's going to access the data from this particular material itself. So the material data type is actually just pointing to this material so that Blender knows where to take the information from and it's depicted using this salmon color socket as you can see. Next we have the object data type which contains all of the information of the object including the geometry, the transform, the location, position, scale, everything. So that's present in the object data type and it is depicted by the color orange. So that can go into a socket such as the object info and so on and so forth. Lastly, we have this menu which is depicted as a gray socket. And the only thing that I know is you can use it for one particular purpose which is to create a menu within your modifier panel. For example, if we were to just take this such that you have all of these going in as different options within the menu switch. You can add that as a new input and you just get this menu present. Now you can simply switch it into a volume cloud. You can switch it into an instance, curves or points just by using this single drop down over here. So that is menu and that is depicted by this gray little socket over there. So those are actually all of the data types that I know of within Blender's geometry nodes and those are all of the ones that you're going to be dealing with. So once you know that, you're already one step closer to completely understanding Blender's geometry nodes. Different data types can go into different colored sockets only. And if you try to collect the incorrect data type, it's just not going to connect as you can see. But there are some data types that can be connected to others if there is some form of implicit conversion that's possible such as an integer can be converted into a float and a float can be converted into an integer. Similarly, you could convert integers and floats into booleans as well. As you can see, that is a valid connection. And the way this works is if the value is rounded off to a zero then it's going to be considered as false. And if it's rounded off to a one it's going to be considered as true. Anything above one is also true. Anything below zero is also false. So that is how integers and floats can be converted to boolean values as well. Similarly you could convert them to vectors as well. Vectors would just take the same value for all three X Y and Z positions. So as you can see the green can be converted to purple. So can the gray become purple as well as a boolean can become purple and similarly a purple can become a boolean as well. The same way I didn't mention but purple can become gray and green. So all of these are convertible because we know the conversions. The same thing goes with rotations, colors but not necessarily matrices. Some things do work like rotations can be converted to matrices as you can see but colors cannot be converted to matrices. However, vectors can be connected or vectors can be converted to colors and vectors cannot be converted to rotations. So, apart from these conversions that are possible over here, there are very few other conversions that are possible. But in most of the cases, inks cannot be converted and you have to connect the correct color to its own color itself. Now, that's data types. But let's move on to the actual node types itself. So, as you can see, nodes are converted into various types and those are also colorcoded. First off, there are the input output nodes. The main ones being the group input and the group output. So, if you were to just plug these in, as you can see, the input gets converted to the output. And those are all depicted by black colors. The only one that's somewhat of an exception is the viewer node, which if is off is just gray, and if it's on, it's this reddish color. It's unique by itself, but it can somewhat act like an output node. As you can see, just by plugging it into the viewer, you're able to see it as an output. So, that's why I would consider this as an input output node itself. Apart from that, other black nodes include the gizmos, which allow you to create different gizmos to allow for better control. As you can see, if you were to switch on gizmos over here, these are Blender's inbuilt gizmos that allow you to rotate and things like that. If you want to create your own custom gizmo, you can create that within Blender's geometry nodes as well to help change the positioning of the item and you can change the position of the gizmo and things like that as well and then transform according to what happens to the gizmo over here. You can also show different error messages and the other type of input outputs are when certain nodes create their own subgroup or their subsections of the geometry node tree such as the simulation zone. As you can see, it forms its own zone. And once you put something inside the zone, such as, let's say, a set position. It's going to stay within the zone itself, and you can't actually move it out of the zone. So, information from outside can go into a zone, but you can't have information from within a zone go out of a zone. So, that happens for both simulation zones as well as repeat zones. So, repeat zones allow for multiple iterations within a single frame, whereas simulation zones allow for simulations over different frames. So those are input and output nodes which are denoted by a black color on top. Then you have the geometry nodes which is the turquoise on top which to me is more greenish. But as you can see what they do is they take some input geometry and modify that geometry and give an output. So these are the main nodes for the geometry nodes modifier. They take in an input geometry. They modify it in some way and they output geometry or else information about that geometry. Often these nodes by themselves are actually their own node groups which means if you press this you can see that it's actually made up of multiple nodes within itself which have been well packaged into one single node just like this which you can then manipulate from the outside. Now apart from that you have attributes. Remember how we stated that every geometry has some attributes like the vertices we have the positions which is an attribute. This will give us the information. So if you plug in a mesh, it's going to tell us the point count, edge count, face count, and face corner count, which are the numbers over here. You can convert it to different things such as curve. And remember when we had it as a curve, we were able to get the point count as well as the spline count. So you get different things such as that. So attributes allow us to get information present within more complex data types such as a geometry data type. But attributes don't necessarily have to be only read. You can also write attributes so by using things like the store named attribute which will create a new attribute and store it in based on what value you want to give and whether you want to give it to every point, every edge or every face and so on and so forth. So it's actually really cool how you can not only read different attributes but you can also store them. Now these attributes are always colored as a blue color node as you can see over here. Then you have information that's going to be input from wherever other sources. So information that's coming from outside the geometry node tree is going to be read. For example, you can see which camera is currently active by using this active camera node. You can get information about a collection using collection node. You can import certain things like objs or you can find out what the index of the material is by using this and so on and so forth. If you're ever taking information from something that's not currently a part of the node tree, it's going to be in red. Then you have any node that's going to be dealing with vectors, they're always going to be purple. And all of this matches up with the color of the socket as well. So if you have any vector math nodes or a vector rotate node, vector curves, so on and so forth, they're always going to be purple and they're going to have purple sockets within them where you can connect some purple socket to another purple socket. Then you have the last two types which I think are the most used again which is the utilities as well as the textures. So utilities essentially allow you to just manipulate data. They are not going to be dealing with complex data types or things like that but they're just going to help you manipulate the primitive data types that we were talking about such as in this case it gives you random floats. It gives you integers. You can do some math operations or you can combine some matrices, things like that. So, anything that's allowing you to manipulate data is called a utility and it is visualized using this blue color on top. And then you have the textures which use some form of algorithm such as the noise texture, the photoonoid texture, gradient textures, brick textures, so on and so forth that you can use in various ways. But these textures are usually denoted by this orange color. And they usually have a color output right over there. So that actually explains what all of the different socket types are in the Blender's geometry nodes. Blender continuously updates its geometry nodes. So there are new types of nodes being added in. Different things are changing. Different data types keep getting added in. But essentially this should now give you a basic understanding of how you can understand what each of these nodes are doing and their color and the data types as well. And this leads us to the last thing which is the sockets. So as you can see can either be round or they can be diamond. So if they are round what does it mean? And if they are a diamond what does it mean? And within the diamond you see there are some that are solid shaded and some of them that have a dot. So essentially anything that has a round socket implies that it's going to work or it's going to manipulate data for the entire geometry as a whole. So that means for example if you were to take this and then just use a transform geometry node in between the group input and the group output. You can only transform it by changing every single value as a whole. This value is going to be added to every single one of the indices over here and not the individual index values. You don't have control over that when you're using a round socket. So if I was to move it by 0.1, it would move by 0.1 for every single one of these. If I was to move it by a value of one, it would change by a value of one for all of these values on the X. If I change it for the Z, it changes for all of the Z together. You don't have control over the individual ones. Even if you try to get control over individual ones, it's not going to let you. However, the diamond socket implies that you have control over individual ones. So instead of using a transform geometry that allows only for circular inputs or circular sockets, if I was to use the set position that allows me to use a diamond socket. You can see right now if I offset it's doing the exact same thing as the transform geometry. However, this is a diamond socket. That means I do have access to individual points within it. If I want to give an individual value for every single point, I can do that by plugging in something else that has a diamond socket. So I can take this color, plug it in over there, and now you see every single point gets its own independent value. And so I'm able to manipulate each of these separately. If I was to try and use this diamond socket into this translation, you'll see that it just gives me an error because it's not going to be supported. And that means anything that is diamond is called a field value. That means it's going to be manipulating each and every single index separately. However, there's a difference between a diamond and a diamond with a dot. A diamond with a dot means that although you can control each one independently, right now it's all being controlled by one single value, which means it's currently behaving like a circle over here. So that's why if I was to move this, you see one single value is affecting all of them. So it is currently working with one independent value and not a different value for every individual index. So if I was to plug this circle in, it'll still work. And the fact is that it still uses a dot because that means it's still using one single value for every single one of the points. I hope that makes sense. However, if I was to use a diamond socket like this, you'll see it no longer has a dot, which means each independent vortex is having its own independent value. The same thing could happen with this noise texture. As you see, once I plug it in, there's no longer going to be a dot. Now, the reason why this position is not having a dot is because it's currently by default using a position attribute, which gives an individual position for every single index. And that's what's going in right over there. However, this doesn't mean that it has to only be individual values for every single point. If I was to plug this in right over there, you see it becomes a single dot because now it's going to use the same position for every single vertex. So, as you can see, I have the same position going in for every single vertex. And that's also being offset by this. If I change this to zero, you'll see this exact value becomes the position for every single point present. And that's why because it's the same value for every single point, it's going to be a single dot over there. However, if I use the default position, it's individual for every single point. And that's why you get no dot in the diamond. So hopefully now you understood the difference between circular sockets and diamond sockets as well as diamond sockets with one single dot. The dot implies that it's currently using one single value and is very similar to a circle. However, because it's in diamond, you can use diamond values. Now that brings us to the last thing which is solid lines versus dashed lines. Whenever you make a connection, the connection can be a solid line as you can see these green lines are solid or it can be a dashed line. If the line is solid, as you can see over here, it means that there's only one value that's going in to this particular socket. However, a dash line implies that it's a field value. That means it's an individual value for every single independent index. Every index has its own value and that is depicted by these dashed lines. So if I was to use this, you'll see it's still going to be a dashed line itself. So that's how you know whether it's behaving as different values for every single index or it's one single value. So that's actually all there is to know about this. You can use circular sockets in diamond sockets. However, you cannot use diamond sockets in circular sockets. Similarly, if you were to use something that cannot be a diamond value, all of these will end up becoming circles. For example, the translation cannot use a diamond value. But this simply because it uses points over here or it has single values for all of these. This right now is also giving out a single value. That means it's acting as a circular socket. So I could potentially plug this into the translation. But the moment I plug it into the translation, remember the translation cannot take anything but a circular socket. So that automatically means that this can has to be a circular socket and for this to be a circular socket all of these have to be circular sockets. So these automatically convert to circular sockets. Now I can no longer plug this color in over here and this becomes an error. So if I remove that there's no longer an error. I can use this in something like that. So that is something that you have to actually understand. But essentially now you know that all of these are fairly usable and I hope you understood exactly how to use these in your own projects. Now there's one final thing that we have to talk about before we end this particular tutorial and that is how data flows through geometry nodes. In geometry nodes, data always flows from left to right. That means if you were to do something like subdivide and then set position, it's going to do that by subdividing first and then setting position. So let's actually take a look at this. Let's just press shift D and subdivide. So you can see this is the subdivided surface. If you were to shift D, plug this in here and just give it some sort of a noise texture for the offset, you can see how every single subdivided point is offset. However, if you were to actually do the subdivision after the set position, as you'll see, you don't get the same effect. So that's because we're offsetting only four points or the eight corners of the cube and then we're subdividing it. So we get to offset only those eight points. So there's very little variation. However, if we were subdividing it first and then offsetting it, we're offsetting all of those new subdivided vertices as well. So, that's something that's really cool that you need to know that data is always going from left to right. However, often data is being retrieved from something to the left. So, if you were to plug this in right over here, let's ignore these. All right. So, let's take a look at this particular scenario. This set position is taking its position from something to the left, which is this particular position node. But this position node is giving it its position based off of what geometry is going in over here. It is not that this position is storing some values and giving the same values here, here and here. In fact, it is giving it different values here, different values here and different values here based off of what geometry node is or what geometry is present over here, what geometry is present over here and what geometry is present over here. So how we know that is if we capture the attribute before we set position based off of this noise. So we're storing this position right over here before we're setting the position by some various values. If we were to plug this into the new position, you can see that we then set position back to how it was before the noise texture moved everything around. So even though the position value was connected over here, the position value that it gave over here is different from the position that it's giving over here because it's giving position based off of the geometry that's present right up over here. So data is always flowing from right to left. But when it's retrieving data from something that's to its left, it's still going to retrieve data based off of what input it has and not what input is there to the left. So irrespective of where this position value had been plugged in before, it's going to use position values that it has from its original geometry data. So I hope that gives everything that you need to know to actually understand geometry nodes and make your own projects. Essentially, you have an input geometry that gets manipulated and gets converted to output geometry. You can manipulate them using different data types such as complex data types like geometry, color, matrices, so on and so forth or very simple data types like float, integers, booleans and so on. Some data types work with other data types and some do not. So all in all, a single node has various properties that we have to take a look at. Each node has a node color itself which determines what the node is actually doing. Whether it's a utility node, whether it's a node that manipulates geometry, whether it's a node that deals with vectors, or it's an input or output node, or it's an information node, so on and so forth. So that's present by just looking at the top. Then you have all of the different socket colors. The socket colors determine the data type that the socket is dealing with. For example, turquoise is dealing with geometries. Geometry is a complex data type that has six different possibilities. It could be mesh, curve, grease, pencil, point cloud, volume grids or instances. Each of these by themselves have more information such as the number of vertices and the position of each of those vertices, the number of edges, the face corners, UV maps, so on and so forth. Then we have other data types such as integers, floats, booleans, and stuff like colors, matrices, vectors, rotations, objects, images, object or collections, and so on and so forth. Each have their own color and can be connected up to their own color only unless they are compatible with each other such as integers and floats, which will be implicitly converted from one data type to the other. Lastly, you have the socket shape. The socket shape can be circular, which means it's going to change the entire geometry as a whole and not the individual indices or the data at individual indices, but for everything together. Then you have the diamond ones which allow you to manipulate individual data independently. That means you can manipulate each index's value separately by using other diamond data, but you don't necessarily have to. Diamond with a dot implies that currently it is all being done using one single value for every single point or every single index. Then you have the actual connections. The connections can be a dashed line or a solid line. And if it's a solid line, it means it is having one value for the entire geometry or at least the value for the whole geometry together. And if it's a dash line, it means it is carrying an individual separate value for every single index and it's manipulating each index independently. Then lastly, we know that data goes from left to right and is manipulated based off of all of these nodes and data that we manipulate ourselves. So hopefully with that, you got a base understanding of geometry nodes and you can use this to your advantage. I'm going to consider this as part one of demystifying geometry nodes. And in part two, we will be just looking at examples and various things you can do using this knowledge in geometry nodes. So, I really hope this helped you and I really hope that this tutorial covered enough depth and gave everyone useful information. And I hope that you're no longer really daunted by geometry nodes. If you have any questions or suggestions, feel free to let me know and I'll do my best to answer them for as long as I can. Until my next video comes out, thank you so much for watching. Keep creating and don't forget to stay creative.