Take a look at OpenSCAD CheatSheet. You'll find that OpenSCAD provides only 2D or 3D fundamental modules, such as `circle`

, `square`

, `sphere`

, `cube`

, etc. You may, however, perform boolean operations on these modules to create a more complex model. These operations are `union`

, `difference`

and `intersection`

. Besides, the `hull`

transformation is also very useful in some situation.

# union

A boolean operation which you've implicitly used before is `union`

. As the name said, if you perform the `union`

operation on a group of modules, they would be being united or joined. For example.

```
radius = 10;
circle(radius, $fn = 48);
translate([0, -radius, 0])
square(radius * 2);
```

This example creates a circle and a square. A circle consists of many (infinite, actually) sides in geometry. The `$fn`

parameter in the parameter list of the `circle`

module is used to determine how many sides a circle has.

Then, I create a square, and its side length is the radius of the circle. The square is moved `radius`

centimeters along the negative y-axis. So the result is:

In OpenSCAD, if you don't specify any boolean operation on modules, they are united automatically. Sometimes, you need to do some advanced actions on a particular group of modules; one way is defining a module to contains these modules, such as:

```
radius = 10;
module circle_and_square(radius) {
circle(radius, $fn = 48);
translate([0, -radius, 0])
square(radius * 2);
}
rotate(-45) circle_and_square(radius);
```

The other way is using `union`

to group these modules explicitly.

```
radius = 10;
rotate(-45) union() {
circle(radius, $fn = 48);
translate([0, -radius, 0])
square(radius * 2);
}
```

Both ways generate the following model.

Defining a module for a small group of modules might be troublesome for you if those modules still don't reach a sub-goal. Using `union`

will be more suitable in this situation. For example, you might want to use the previous code to create a love heart.

```
radius = 10;
module heart(radius) {
rotated_angle = 45;
diameter = radius * 2;
$fn = 48;
rotate(-rotated_angle) union() {
circle(radius);
translate([0, -radius, 0])
square(diameter);
}
translate([cos(rotated_angle) * diameter, 0, 0])
circle(radius);
}
heart(radius);
```

It leaves a question for you. Why is the last circle translated `cos(rotated_angle) * diameter`

centimeters to make a heart?

# difference

The `difference`

operation subtracts the follow-up modules from the first one. For example, you probably want to carve a word in the heart.

```
radius = 20;
module heart(radius) {
rotated_angle = 45;
diameter = radius * 2;
$fn = 48;
rotate(-rotated_angle) union() {
circle(radius);
translate([0, -radius, 0])
square(diameter);
}
translate([cos(rotated_angle) * diameter, 0, 0])
circle(radius);
}
difference() {
heart(radius);
text("LOVE");
}
```

In this example, you use `difference`

to subtract the word from the heart. It will generate the model below.

# intersection

The `intersection`

operation creates the intersection of all modules. It keeps the overlapped portion. To illustrate, how to put a character on a sphere surface? You may use `difference`

to subtract a smaller sphere from a bigger sphere. It generates a hollow sphere. Then, create a text and `linear_extrude`

it to create an intersection with the hollow sphere.

```
character = "A";
font_size = 10;
thickness = 1;
module hollow_sphere(radius, thickness) {
$fn = 48;
inner_radius = radius - thickness;
difference() {
sphere(radius);
sphere(inner_radius);
}
}
module sphere_character(ch, font_size, thickness) {
font_offset = font_size / 2;
intersection() {
hollow_sphere(font_size, thickness);
linear_extrude(font_size * 2)
translate([-font_offset, -font_offset, 0])
text(ch, size = font_size);
}
}
sphere_character(character[0], font_size, thickness);
sphere(font_size - thickness, $fn = 48);
```

This example is a comprehensive exercise containing `union`

, `difference`

and `intersection`

. Appropriately combining boolean operations could generate many complex models. As shown in this example, you should define modules to encapsulate these basic models. It makes the code more readable, and you can use these basic models some other day.

This example generates a model below.

# hull

The `hull`

is classified into **Transformatons** in OpenSCAD CheatSheet.

When seen for the first time, you probably don't understand what it can do. The word “hull” means the outer covering of anything. If you `hull`

several modules, you create the outer cover for them. If those modules are 2D objects, you may imagine that a rope bound these modules. To illustrate, you create two circles first.

```
radius = 10;
circle(radius);
translate([2 * radius, 0, 0])
circle(radius);
```

It generates a model below.

Then, `hull`

these two circles.

```
radius = 10;
hull() {
circle(radius);
translate([2 * radius, 0, 0])
circle(radius);
}
```

The result is below.

If you `hull`

3D objects, you may imagine that a plastic wrap seal these objects. For example. The code below `hull`

two cylinders.

```
radius = 10;
hull() {
linear_extrude(10)
circle(radius);
linear_extrude(20)
translate([2 * radius, 0, 0])
circle(radius);
}
```

The model generated is shown below.

Here's a question for you. In the earlier example, I created a heart which had a right angle at the bottom. Can you make it round, such as the model below? Hint: It would be easier if you leverage the `hull`

transformation.