3dMake Foundation & Design — Complete Course Compendium

Course: Accessible 3D Printing with OpenSCAD and 3DMake Track: 3dMake Certification — High School Distance Learning Contents: Instructional Framework · Curriculum Guide · All 11 Lessons · Final Exam · Quick Reference Guide

Part I — Instructional Framework

A pedagogical overview of the 3DMake and OpenSCAD ecosystem for secondary STEM education.

The Architecture of Programmatic Design

Programmatic CAD differs from standard industry tools like Fusion 360 or SolidWorks by utilizing a “code-as-model” philosophy. OpenSCAD, the primary engine supported by 3DMake, uses a functional programming language to define three-dimensional volumes.¹ This approach is particularly robust for parametric design, where the dimensions of an object are defined as variables, allowing for instantaneous reconfiguration without manual rebuilding.² 3DMake enhances this by providing a unified command-line interface (CLI) to manage the entire process, from editing source files to triggering remote print jobs through interfaces like OctoPrint or Bambu Connect.³

The educational value of this toolchain lies in its transparency. Students are not hidden behind a proprietary user interface; they interact directly with the file system, configuration files, and API integrations. This exposure fosters a deeper understanding of how modern software interacts with hardware — a skill set increasingly vital in robotics and aerospace engineering.⁴ However, the shift to a terminal-based environment requires a structured instructional approach to overcome initial barriers to entry.

AI Integration and Model Descriptive Feedback

The integration of artificial intelligence into the 3DMake workflow represents a significant advancement in democratizing CAD for students with varying levels of spatial reasoning skills. The 3dm info command acts as a multimodal bridge between the deterministic world of OpenSCAD and the probabilistic world of LLMs.³

When a student executes 3dm info, the system initiates a rendering pipeline, generating multiple viewpoints of the current model, which are packaged as image data and sent to the configured AI (e.g., Gemini) along with a descriptive prompt. The AI’s response provides a summary that can include the model’s intended function, aesthetic qualities, and potential engineering failures.³

The Limits of AI Spatial Reasoning

While powerful, current LLMs do not possess a true “3D world model” — they are trained primarily on 2D images and text.⁵ Common failures include:

• Detached Geometry: The AI might describe a “table” even if the legs are hovering below the tabletop.⁵
• Scale Misinterpretation: Without a reference object in the render, the AI may misjudge scale, leading to inappropriate feedback on wall thickness.³

Caution

Hallucination of Detail: The AI may describe features it expects to see (like “engraved text”) even if the student’s code failed to render them.⁵

Important

AI is a verification assistant, not a source of truth. The deterministic rendering of OpenSCAD remains the final authority on geometry. AI is most useful as a “sanity check” to catch obvious mistakes before wasting filament.³

Occupational Health and Safety

Safety in the 3DMake workflow extends to the physical act of printing, which involves thermal, chemical, and mechanical risks. The National Institute for Occupational Safety and Health (NIOSH) provides a clear framework for these risks.⁶

Chemical and Particulate Emissions

The melting of plastic filament is a thermal degradation process. ABS releases styrene, a known respiratory irritant and potential carcinogen.⁶ Even PLA emits millions of ultrafine particles (UFPs) per minute during extrusion — particles smaller than 100 nanometers that can penetrate deep into the lungs.⁶

Warning

ABS and ASA filaments release styrene — a respiratory irritant and potential carcinogen. Always use an enclosed printer with carbon filtration for these materials.

| Styrene | ABS, ASA | Enclosed printer with carbon filtration.⁶ | | Formaldehyde | POM, Nylon | High-efficiency external ventilation.⁶ | | Ultrafine Particles | All filaments | HEPA filtration and “20-minute” settling period.⁷ | | Volatile Organic Compounds | All filaments | Minimum 6 air changes per hour in the room.⁸ |

Physical and Mechanical Hazards

The extruder nozzle can reach 260°C and the heated build plate can reach 110°C.⁹ Standard operating procedures for a student lab must include:

• Pre-use Inspection: Check for frayed wires, loose belts, and a clear build surface.⁸
• Environmental Controls: Prohibit eating or drinking in the print area to avoid ingestion of contaminants.⁹
• Emergency Response: Locate the nearest ABC fire extinguisher (Class D for metal prints).¹⁰
• Post-Print Cooling: Ensure the printer has cooled below 30°C before removing the model.⁸

Challenges Inherent in the OpenSCAD Language

OpenSCAD’s declarative nature and unique rendering kernel present specific hurdles for students. Unlike imperative languages, OpenSCAD describes what a shape is, not how to build it step by step.¹¹

Immutable State

Note

Variables in OpenSCAD are more like constants within a scope. If a student writes x = 5; x = 10;, OpenSCAD will use the last assigned value (x = 10) for the entire script.¹² This requires adopting a functional programming mindset where geometry is defined by its state rather than a sequence of movements.

Performance Bottlenecks

Note

OpenSCAD’s CGAL geometry kernel is highly accurate but slow for certain operations. Minkowski sums (used for rounding corners) can take minutes at high $fn values. Keep $fn low while developing and only raise it for final renders.¹³ OpenSCAD also has no native “fillet” command — students must construct these manually using boolean subtractions or libraries like BOSL2.²

The Absolute Coordinate Barrier

OpenSCAD has no concept of relative constraints — every object is positioned in absolute (X, Y, Z) space.¹⁴ If a student moves one part, they must manually calculate and update the translation of every related part. This necessitates heavy use of variables and mathematical offsets.¹⁴

Technical Limitations of 3DMake

Caution

AI features (3dm info descriptions, 3dm orient) require an active internet connection and a configured API key. These features will fail silently on offline school networks — plan accordingly.

| API Dependency | AI features require external internet and API keys | Advanced features fail in offline school networks.³ | | Slicer Lock-in | Reliant on external templates for G-code generation | Students may not learn the nuance of slicing settings.³ | | Feedback Latency | No real-time “live” preview in the editor | The edit-compile-view cycle is slower than GUI-based CAD.³ |

Caution

Non-manifold geometry (zero-thickness walls or improperly closed polyhedrons) will generate an STL without warning from 3dm build, but the slice command may then fail or produce corrupt G-code. Always verify mesh integrity before printing.¹⁵ Students must learn mesh verification skills using tools like MeshLab or PrusaSlicer’s repair functions.¹⁶

Local Resources — Utah Makerspaces

Utah provides a broad network of makerspaces across public libraries, universities, and community nonprofits.

Public Library Makerspaces

Salt Lake City Public Library – Creative Lab (Main + Marmalade, Glendale, Sprague branches): 3D printers, Cricut cutters, Adobe Creative Cloud, sound booth, and more.¹⁷

Salt Lake County Library – Create Spaces (Daybreak, Granite, Holladay, Kearns, Magna, Sandy): Flashforge and LulzBot 3D printers, VR/robotics kits, audio/visual studios.¹⁸

Weber County Library Makerspaces: Laser cutters, vinyl cutters, embroidery machines, and design software stations.¹⁹

Washington County Library – Sid Atkin Makerspace (St. George): Large-format 3D printers, CNC cutters, sewing machines, electronics kits, and woodworking tools.²⁰

Logan Library – Cytiva STEM Makerspace (Cache County): Bambu 3D printers, laser engravers, heat presses, and digitization tools.²¹

University & Higher-Education Makerspaces

University of Utah – Marriott Library ProtoSpace: Prusa MK4 and Prusa XL printers, 3D scanners, open to students and staff.²²

Utah Tech University – Jr. Makerspace (St. George): Supports K–12 and community visitors with training and STEM events.²³

Southern Utah University – Thunderworks Makerspace (Cedar City): CNC tools, 3D printers, electronics benches, and generous public hours.²³

Regional STEM Hubs

Make Salt Lake: Nonprofit makerspace with woodshop, metal shop, laser cutters, 3D printer labs, and electronics benches.²³

The Utah STEM Action Center’s Innovation Hub Network maintains a statewide directory across all counties: stem.utah.gov/innovationhubnetwork.

National Makerspace Directories

• Nation of Makers — U.S. crowdsourced map of makerspaces and hackerspaces
• Makerspace.com Global Directory — Worldwide listing with search and filters
• Makerspace Directory (makerspacedir.com) — U.S.-focused, covers Fab Labs, youth programs, and coworking hybrids
• WorkMakeCreate — Find free and public makerspaces by ZIP code

Supplemental Learning Resources

• Programming with OpenSCAD: A Beginner’s Guide to Coding 3D-Printable Objects — Complete reference covering syntax, geometry concepts, design patterns, and best practices
• Simplifying 3D Printing with OpenSCAD — Focused guide to practical workflows, optimization, and real-world printing
• CodeSolutions Repository — Working OpenSCAD examples organized by topic and difficulty
• Practice Worksheets and Guides — Printable materials for visualization practice and assessment

References

Deck, T. (2025). 3DMake: A command-line tool for 3D printing workflows. GitHub. https://github.com/tdeck/3dmake Gohde, J., & Kintel, M. (2021). Programming with OpenSCAD: A beginner’s guide to coding 3D-printable objects. No Starch Press. Gonzalez Avila, J. F., Pietrzak, T., & Casiez, G. (2024). Understanding the challenges of OpenSCAD users for 3D printing. ACM UIST. NIOSH. (2024). Approaches to safe 3D printing. https://www.cdc.gov/niosh/blogs/2024/safe-3d-printing.html Ohio State University EHS. (2026). 3D printer safety concerns and ventilation. https://ehs.osu.edu/kb/3d-printer-safety Washington State Department of Health. (2026). 3D printer and filament selection for safe school environments. https://doh.wa.gov/community-and-environment/schools/3d-printers

• https://www.nationofmakers.us/find-a-maker-organization
• https://makerspace.com/directory/
• https://makerspacedir.com/
• https://workmakecreate.com/

Part II — Curriculum Guide

Structure, learning paths, and reference material for the complete 11-lesson course.

Overview

This 11-lesson curriculum (plus 4 reference appendices) teaches non-visual 3D modeling, parametric design principles, and the complete 3D printing workflow through integrated projects. Each lesson builds on prior knowledge, introducing real-world examples and hands-on activities.

Target Audience: High school and early undergraduate students, makers, and anyone interested in programmatic CAD and 3D printing Estimated Total Time: 30–40 hours (11 lessons + 4 appendices + projects)

Lesson Structure at a Glance

Learning Paths

Path 1 — Complete Mastery (30–40 hours): Lessons 1–11 + all appendices. Best for first-time learners wanting comprehensive understanding.

Path 2 — Design Focus (Fast Track): Lessons 1 → 2 → 3 → 6 → 7 → 8 → 9. Best for experienced designers new to programmatic CAD.

Path 3 — Project-Based: Lessons 1–3 → 6 (Keycap) → 7 (Phone Stand) → 8 (Bins) → 9 (Automation) → 10 (Troubleshooting) → 11 (Leadership). Best for learning by doing.

Path 4 — Safety & Printing Focus: Lessons 1, 2, 5, 6, 10 + Appendices A, B, C. Best for practical printing and quality focus.

Detailed Lesson Descriptions

Lesson 1: Environmental Configuration and the Developer Workflow

Install and configure 3dMake, create a project scaffold, and run your first build. Covers installation and tool verification, project structure (src/, build/, 3dmake.toml), parametric design philosophy, and the 3dm build command. Checkpoint: You can initialize a project, edit a parametric model, and generate an STL file.

Lesson 2: Geometric Primitives and Constructive Solid Geometry

Combine basic shapes using boolean operations. Covers cube(), sphere(), cylinder(); CSG operations (union(), difference(), intersection()); the 0.001 offset rule for non-manifold geometry; and low-resolution renders for faster debugging. Checkpoint: You understand CSG operations and can diagnose common geometry issues.

Lesson 3: Parametric Architecture and Modular Libraries

Create reusable modules and organize code into libraries using the DRY principle. Covers module definitions, derived calculations, library organization (lib/ folder), BOSL2, and low-resolution testing with $fn. Checkpoint: You can create parametric modules and organize code into libraries.

Lesson 4: AI-Enhanced Verification and Multimodal Feedback

Use 3dm info to generate AI diagnostics and validate designs. Covers the 3dm info command, AI-generated descriptions, AI limitations, privacy and governance, and prompt engineering basics. Checkpoint: You can use AI tools to supplement your design validation.

Lesson 5: Safety Protocols and the Physical Fabrication Interface

Transition from digital design to physical printing. Covers the Hierarchy of Controls, chemical and particulate emissions, pre-print environmental and equipment checks, post-print inspection, and spool metadata. Checkpoint: You understand safety procedures and can safely conduct supervised prints.

Lesson 6: Practical 3dm Commands and Text Embossing

Master key 3dm commands by building a customizable keycap. Covers 3dm info, 3dm preview, 3dm orient, 3dm slice, and text embossing with linear_extrude() and text(). Project: Generate 3+ keycap variants (small, medium, large). Checkpoint: You can generate keycaps with embossed text and understand all major 3dm commands.

Lesson 7: Parametric Transforms and the Phone Stand Project

Apply transforms to build a multi-part assembly. Covers translate(), rotate(), scale(), Minkowski sum for edge rounding, multi-part assemblies, and parametric angle variations. Project: Phone stand with configurations for phones, tablets, and documents. Checkpoint: You can design multi-part assemblies with positioned components.

Lesson 8: Advanced Parametric Design and Interlocking Features

Design tolerance-critical assemblies where parts snap together. Covers tolerance and clearance management, stack-up error, interlocking rims, snap-fit connectors, and chamfers. Project: Stackable storage bins — test different stack_clear values, create size variants, add optional dividers. Checkpoint: You understand tolerance management and can design stackable assemblies.

Lesson 9: Automation and 3dm Workflows

Automate design workflows using shell scripts. Covers chaining 3dm commands with &&, shell script batch processing, library management (3dm lib), variant testing matrices, and production build workflows. Checkpoint: You can automate design workflows and manage parametric variants at scale.

Lesson 10: Hands-On Practice Exercises and Troubleshooting

Capstone lesson synthesizing all prior learning across three exercise sets: Set A (guided projects: Phone Stand, Keycap Set, Storage System), Set B (problem diagnosis: non-manifold geometry, print failure prevention, dimensional accuracy), and Set C (validation and documentation templates). Checkpoint: You can complete real projects from concept to verified print.

Lesson 11: Stakeholder-Centric Design and the Beaded Jewelry Project

Design for real users, not just yourself. Covers stakeholder identification and interview techniques, extracting functional requirements, defining measurable acceptance criteria, design iteration based on feedback, and documentation for reproducibility. Project: Beaded jewelry bracelet holder — interview a stakeholder, extract requirements, design parametrically, test with actual bracelets, iterate. Checkpoint: You can conduct a real interview, translate needs into measurable requirements, and iterate a design based on user feedback.

Project Completion Tracking

Assessment and Completion

Each lesson includes learning objectives, step-by-step tasks, checkpoints, a 10-question self-assessment quiz, and 10 extension problems.

Lesson completion criteria: Watched/read entire lesson · Completed all step-by-step tasks · Reached all checkpoints · Answered quiz questions · Attempted at least 3 extension problems · Documented findings.

Project completion criteria: Code builds without errors · All parameters functional · STL generated and inspected · Measurements documented · Assembly tested (if multi-part) · README or documentation included.

Appendices Overview

Accessibility Features

This curriculum is designed for non-visual learners: text descriptions of all models via 3dm info, tactile 2D previews via 3dm preview, structured written documentation, command-line based (no graphical interface required), and measurement-based validation without visual inspection.

Next Steps After Completion

Upon completing this curriculum, students are ready for: advanced BOSL2 library features and parametric assemblies; multi-material printing (TPU, Nylon, etc.); mechanical assemblies with bearings, gears, and mechanisms; community contribution via shared designs and libraries; and professional applications in product design, prototyping, and manufacturing.

Curriculum Revision History

Part III — All 11 Lessons

Lesson 1 — Environmental Configuration and the Developer Workflow

Estimated Time: 60–90 minutes
Course: 3dMake Certification — High School Distance Learning Track

A Message to You Before We Begin

Welcome to your first lesson. If you’ve never used a command line, never written code, or never sent a file to a 3D printer before, you are in exactly the right place. This lesson is designed so that someone who has done none of those things can follow every step.

If you have done some of those things, you’ll still find this lesson useful — because the way 3D printing tools fit together is different from most software you’ve used before, and understanding the full picture from the start will save you real trouble later.

By the time you finish this lesson, you will have your tools installed and working, you’ll understand the basic logic of the coordinate system your designs live in, and you’ll have run your first parametric 3D model through the complete build-and-verify workflow.

Take your time here. The concepts in this first lesson are the foundation everything else is built on.

Learning Objectives

By the end of this lesson you will be able to:

• Install and verify the 3dMake toolchain on Windows, macOS, and Linux
• Understand the OpenSCAD coordinate system and unit conventions
• Write and build your first parametric .scad file
• Read and interpret 3dm info output without a visual display
• Use the core developer workflow: edit → build → verify

Concept 1: What Is Parametric 3D Design?

The Two Ways to Design for 3D Printing

There are two ways to design a 3D object for printing. The first way is to use a visual editor — a program where you click, drag, and push shapes around the screen until they look right. Programs like Tinkercad work this way. They’re intuitive and fast for simple objects, but they have a limitation: if you want to change the size of something, you often have to go back and manually adjust every related dimension by hand.

The second way is to use code. You write instructions that describe your object mathematically. “Make a box that is 30 millimeters wide, 20 millimeters deep, and 10 millimeters tall.” If you later decide that 30 mm is too narrow and 40 mm would be better, you change one number, and the model automatically updates everywhere that number is used. This is called parametric design — the word “parametric” means the design is controlled by parameters, which are the named values you can adjust.

Parametric design is how professional engineers create parts. An engineer designing a phone stand might create one file that works for phone models ranging from 60 to 90 mm wide just by changing a single variable. That single source file is the design concept, and specific values turn it into specific objects.

OpenSCAD is the tool you’ll use for parametric design in this course. Instead of clicking and dragging, you write code that describes shapes and their relationships. The learning curve is steeper than a visual editor at the very beginning, but within a few lessons you’ll be creating things that would be extremely difficult or impossible in a drag-and-drop tool.

What 3dMake Does

OpenSCAD by itself is powerful, but its workflow has a lot of friction. To go from code to a printable file, you’d normally need to open OpenSCAD, manually trigger a render, export an STL file, open a separate slicer program, check for geometry errors, and save the output. That’s a lot of steps just to see if your idea works.

3dMake is a tool that wraps around OpenSCAD and smooths out that friction. When you type 3dm build, it runs the entire compile-and-export process for you automatically. When you type 3dm info, it analyzes your model and tells you its dimensions, volume, and a description in plain language. The more time you spend designing rather than managing files, the faster you learn and the more you make.

Think of it this way: OpenSCAD is the engine, and 3dMake is the dashboard. You could use the engine directly, but the dashboard makes it dramatically easier to operate.

Concept 2: The Command Line

What It Is and Why We Use It

You’re going to be working with the command line throughout this course. If you’ve mostly used computers by clicking icons and menus, the command line can feel strange at first — but it’s really just a different way to talk to your computer.

Here is the basic idea: the command line is a text box where you type an instruction, press Enter, and the computer does something and prints a response. That’s the whole interaction model. Type a command. Press Enter. Read the result. Repeat.

For example, if you type 3dm build and press Enter, the computer finds the 3dMake program, tells it to build your project, and then prints either a success message with your model’s dimensions, or an error message with a line number pointing to the problem. This feedback loop is tight, fast, and precise — which is exactly what you want when you’re designing and testing.

The command line has another advantage: it’s repeatable. If you type a command that works, you can type it again. You can save it in a script and run it automatically. You can share it with someone else, and they can run the same command and get the same result. Clicking around menus is difficult to document and impossible to automate; text commands are both.

Which Terminal to Use

Windows users: You have two options. PowerShell is the modern choice and the one we recommend — it’s more powerful and consistent with what you’ll find in professional environments. To open it, press the Windows key, type PowerShell, and press Enter. Alternatively, Command Prompt (CMD) is an older option that still works for basic tasks. This course provides code examples for both.

macOS users: Open Terminal by going to Applications → Utilities → Terminal. It runs a shell called bash (or zsh on newer Macs — both work for this course).

Linux users: You almost certainly already know how to open a terminal. If not, look for “Terminal” in your applications menu.

A Few Things to Know Before We Start

• On macOS and Linux, file paths use forward slashes: src/main.scad
• On Windows, file paths use backslashes: src\main.scad
• Commands are case-sensitive on macOS and Linux — 3DM and 3dm are different things, and only the lowercase version will work
• When a command says it “isn’t found,” it almost never means the software isn’t installed — it usually means the terminal opened before the installation updated its search path (we’ll cover how to fix this in Step 1)

Step 1 — Install the 3dMake Toolchain

Understanding What You’re Installing

You’re installing two pieces of software that work together:

OpenSCAD is the underlying 3D geometry engine. It reads your .scad code files and turns them into 3D model files (specifically .stl files). You can think of it like a compiler for 3D geometry — the same way a Python interpreter turns Python code into running behavior, OpenSCAD turns design code into physical geometry. You don’t need to interact with OpenSCAD directly very often; 3dMake does it for you.

3dMake is the project management layer that sits on top of OpenSCAD. It organizes your project files, runs OpenSCAD with the right settings, analyzes your model output, and provides the plain-English 3dm info descriptions you’ll use to verify your work.

The installer sets up both. Run the appropriate command for your operating system below, let it finish completely, and then run the verification commands before doing anything else.

Installation Commands

Linux and macOS (bash terminal):

# Download and run the official installer
curl -fsSL https://get.3dmake.dev | bash

# After it finishes, verify both tools are installed correctly.
# Both of these commands should print version numbers, not errors.
3dm --version
openscad --version

Windows (PowerShell):

# Install using Windows Package Manager
winget install 3dMake.3dMake

# If winget isn't available, download the installer directly:
# https://3dmake.dev/install
# Run the downloaded installer, then open a NEW PowerShell window.

# Verify the installation:
3dm --version
openscad --version

Windows (Command Prompt / CMD):

REM After installation, open a NEW CMD window and verify:
3dm --version
openscad --version

REM If you see "not recognized as an internal or external command",
REM see the troubleshooting section below.

What the Version Numbers Mean

When you run 3dm --version, you should see output like 3dMake v1.4.2 (the exact number doesn’t matter as long as something prints). When you run openscad --version, you should see OpenSCAD version 2021.01 or later. If either command produces an error instead of a version number, something went wrong with the installation. Read the troubleshooting section before moving on.

Troubleshooting Installation

“command not found” or “is not recognized as an internal or external command”

This is the most common issue and it almost always has the same cause: your terminal session started before the installer ran. When the installer finishes, it adds the 3dMake folder to a system setting called the PATH — a list of folders your computer searches when you type a command name. But a terminal that was already open when the installer ran doesn’t know about the change. The fix is simple: close your terminal completely and open a new one, then try the verification commands again.

What is PATH? When you type 3dm at the command line, your computer doesn’t search your entire hard drive — that would take forever. Instead, it searches only the folders listed in PATH. If 3dMake’s folder isn’t in that list, the computer genuinely can’t find the program even though it’s installed. Closing and reopening the terminal forces it to reload the PATH list.

If opening a new terminal doesn’t fix it, you may need to add the folder manually. On Windows, search the Start menu for “Edit the system environment variables,” click “Environment Variables,” and add the 3dMake installation folder to the Path variable. On macOS/Linux, add the folder path to your ~/.bashrc or ~/.zshrc file and restart the terminal.

OpenSCAD version too old

3dMake requires OpenSCAD 2021 or later. If you have an older version from a previous installation, download the latest release from openscad.org, uninstall the old version, and install the new one.

Concept 3: The Coordinate System — Where Objects Live in 3D Space

Why You Need to Understand This Before Writing Code

Imagine you’re on the phone with a friend trying to tell them where to place a chair in an empty room. You’d need to agree on two things: where to measure from (a corner? the center of the room?), and which directions count as “forward,” “sideways,” and “up.” Without that shared reference, your instructions are meaningless.

OpenSCAD works exactly the same way. Every object you create lives at a specific location in 3D space. That space has a fixed starting point called the origin and three directions called axes. If you don’t know these, you’ll place objects and wonder why they appear where they do.

The Three Axes

OpenSCAD uses a right-handed XYZ coordinate system — a standard that’s shared by engineering software worldwide, so learning it here transfers directly to other professional tools.

Picture a 3D printer’s build plate in front of you:

• X axis — points to the right across the build plate. Positive X is rightward; negative X is leftward.
• Y axis — points away from you, toward the back of the build plate. Positive Y is away from you; negative Y is toward you.
• Z axis — points straight up, perpendicular to the build plate. Positive Z is upward; negative Z would be underground.

The origin — the point (0, 0, 0) — sits at the front-left corner of the build space, right at bed level. When you type cube([20, 20, 10]) without any translation, it appears with its front-left-bottom corner at the origin, extending 20 mm to the right, 20 mm back, and 10 mm up.

Why This Matters for Printing

Because the Z axis points up and the origin is at bed level, any geometry with a negative Z coordinate would be “underground” — below the build plate. The printer can’t print there. Part of your job when designing is to make sure your entire model lives in positive Z space (Z ≥ 0) so it sits on the bed correctly.

Units: Always Millimeters

OpenSCAD has no built-in concept of units — it just works with numbers. The convention in this course (and in the 3D printing community generally) is that all dimensions are in millimeters. This is not optional or adjustable — it’s a universal agreement.

When you write cube([30, 20, 10]), that means 30 mm × 20 mm × 10 mm. If you accidentally think in centimeters and write cube([3, 2, 1]) meaning “3 cm by 2 cm by 1 cm,” OpenSCAD will treat those as millimeters and your print will come out ten times too small. Always, always, always think in millimeters.

The center Parameter: Where Does the Object Anchor?

Every 3D primitive in OpenSCAD has a center parameter. This is one of the most important things to understand early, because it affects where objects appear and how easy your placement math is.

center=false (this is the default — it applies if you don’t write anything): the object’s bottom-left-front corner sits at the position you specify. A cube([20, 20, 10]) with no translation occupies the space from X=0 to X=20, Y=0 to Y=20, Z=0 to Z=10. The object lives entirely in positive space and sits neatly on the build plate.

center=true: the object’s geometric center sits at the position you specify. The same cube at the origin would extend from X=−10 to X=10, Y=−10 to Y=10, Z=−5 to Z=5. Half of it would be underground — which means if you print it without moving it up first, you’ll only get the top half.

Neither option is wrong. You choose based on which makes your math simpler. For parts that should sit on the build plate, center=false is more natural. For parts you want to rotate around their center, center=true is much cleaner.

// Demonstrating center=false vs center=true
// Build this and use 3dm info to see the bounding box of each shape.

// This cube sits on the bed naturally — its bottom is at Z=0.
cube([20, 20, 10]);                    // corner at origin; occupies X:0–20, Y:0–20, Z:0–10

// This cube straddles the origin — half of it is underground!
// Move it sideways with translate() so it doesn't overlap the first one.
translate([35, 0, 0])
  cube([20, 20, 10], center=true);     // center at origin; occupies X:25–45, Y:-10–10, Z:-5–5

// A small red sphere marks where the origin is.
color("red") sphere(r=1.5, $fn=16);

// Colored cylinders mark the positive direction of each axis.
color("red")   translate([25, 0, 0]) cylinder(r=0.5, h=1, $fn=8);  // +X
color("green") translate([0, 25, 0]) cylinder(r=0.5, h=1, $fn=8);  // +Y
color("blue")  cylinder(r=0.5, h=25, $fn=8);                        // +Z

Note

When using center=true, notice how the bounding box may show negative coordinates — that’s geometry underground. In a real project, always use translate() to lift centered objects so their bottom is at Z=0.

Build this code and run 3dm info to read the bounding boxes.

Step 2 — Create Your First Project

What a “Project” Is

3dMake organizes work into projects — folders with a specific, standard structure. This structure keeps your source code separate from generated output, which makes it easy to clean, rebuild, back up, and share your work.

Here is what a project folder looks like:

my_project/
  src/          ← your .scad source files live here (YOU write and edit these)
  build/        ← generated STL files go here (3dMake creates these automatically)
  3dmake.toml   ← project configuration file (created when you initialize the project)

Important

Never manually edit files in the build/ folder. Everything in there is generated automatically — changes will be overwritten the next time you run 3dm build. All your actual work goes in src/.

Creating the Project

Linux / macOS (bash):

# Create the project folder and its standard subdirectories
mkdir my_first_project
cd my_first_project
mkdir src build

# Create the main design file
cat > src/main.scad << 'EOF'
// My First Parametric Model
// ========================
// All dimensions in millimeters.
// To customize this design, change the values below and run: 3dm build

width  = 30;   // mm — how wide the box is (X dimension)
depth  = 20;   // mm — how deep the box is (Y dimension, front to back)
height = 10;   // mm — how tall the box is (Z dimension)

cube([width, depth, height]);
EOF

Windows (PowerShell):

# Create project folder and subdirectories
New-Item -ItemType Directory -Path "my_first_project\src","my_first_project\build"
Set-Location "my_first_project"

# Create the main design file
@'
// My First Parametric Model
// All dimensions in millimeters.
// Change values below and run: 3dm build

width  = 30;   // mm
depth  = 20;   // mm
height = 10;   // mm

cube([width, depth, height]);
'@ | Out-File -FilePath "src\main.scad" -Encoding UTF8

Windows (CMD):

mkdir my_first_project\src
mkdir my_first_project\build
cd my_first_project

echo // My First Parametric Model > src\main.scad
echo width  = 30; >> src\main.scad
echo depth  = 20; >> src\main.scad
echo height = 10; >> src\main.scad
echo cube([width, depth, height]); >> src\main.scad

Reading the Code Line by Line

This small file introduces the core pattern you’ll use for the entire course. Let’s read every line carefully.

// My First Parametric Model — this is a comment. In OpenSCAD, anything following // on a line is ignored by the computer — it’s a note for human readers. Comments are essential. They explain what the code does, what the units are, and what you were thinking when you wrote it.

width = 30; — this declares a variable named width and sets it equal to 30. The semicolon at the end is required — it tells OpenSCAD “this statement is finished.” The comment // mm reminds anyone reading the file that this value is in millimeters.

depth = 20; and height = 10; — same pattern. Each variable represents one dimension of the box.

cube([width, depth, height]); — this creates a box. The brackets [] enclose a list of three values: the X size, the Y size, and the Z size. Instead of writing cube([30, 20, 10]) with raw numbers, you use the variable names. This is the magic of parametric design: if you change width = 30 to width = 50 at the top, the cube automatically becomes 50 mm wide everywhere width is used — which might be one place in a simple file, but could be dozens of places in a complex one.

This pattern — declare named parameters at the top of the file, use them in geometry below — is the single most important habit this course will teach you.

Step 3 — Build and Verify

Running Your First Build

With your terminal open inside the my_first_project/ folder, run:

3dm build

This single command does several things: it finds your src/main.scad file, runs OpenSCAD on it to turn the code into geometry, checks the result for basic validity, and saves the output as build/main.stl.

If the build succeeds, you’ll see output indicating the file was written. If there’s an error in your code, you’ll see an error message with a line number pointing to the problem. Error messages with line numbers are extremely helpful — they tell you exactly where to look to fix the issue.

Understanding the Model Information

Now run:

3dm info

This analyzes your built model and prints a report. You’ll see something like this:

File:         build/main.stl
Bounding Box: 30.0 x 20.0 x 10.0 mm
Volume:       6000.0 mm³
Triangles:    12
Description:  A small rectangular box measuring 30mm wide by 20mm deep by 10mm tall.

Let’s understand each piece.

Bounding Box: The bounding box is the smallest rectangular box that perfectly contains your entire model. 30.0 x 20.0 x 10.0 mm means your model is 30 mm in X, 20 mm in Y, and 10 mm in Z. This number is your primary verification tool — if the bounding box doesn’t match what you designed, something went wrong. Check it every single time you build.

Volume: This is how much solid material fills the model. A solid box that is 30 × 20 × 10 mm contains exactly 30 × 20 × 10 = 6,000 cubic millimeters of material. If your model were hollow, the volume would be less. Volume directly predicts how much filament you’ll need.

Triangles: STL files represent surfaces as a mesh of triangles. More triangles means more geometric detail (and a larger file). A simple box needs only 12 triangles. A sphere with smooth curves needs thousands.

Description: The plain-English description comes from an AI analysis of the geometry. It’s useful for a quick sanity check, but it’s not a replacement for checking the bounding box numbers yourself.

Caution

If the bounding box shows 0 × 0 × 0, the build failed and no geometry was produced. Check the output from 3dm build — error messages will point to the specific line in your code.

Estimating Material Cost from Volume

Before printing anything — especially something that might take hours — it’s professional practice to estimate the cost. Here is the formula:

mass (grams) = (volume_mm³ ÷ 1000) × filament_density_g_per_cm³
cost ($)     = mass_g × (spool_price_$ ÷ spool_weight_g)

For our 6,000 mm³ box using PLA filament:

mass = (6000 ÷ 1000) × 1.24 = 7.44 grams
cost = 7.44 × (20 ÷ 1000)   = $0.15

Common filament densities: PLA = 1.24 g/cm³, PETG = 1.27 g/cm³, ABS = 1.05 g/cm³, TPU = 1.20 g/cm³.

This calculation won’t be exact (slicer settings affect actual usage), but it gives you a reasonable estimate within about 20% of the actual cost.

Concept 4: The FDM Printing Pipeline

How Your Code Becomes a Physical Object

Understanding how 3D printing actually works changes how you design. The printing process has physical constraints — things it can and can’t do — and every design decision you make either works with those constraints or fights against them. Here’s the complete journey from your code to a finished print.

Stage 1 — STL File When you run 3dm build, OpenSCAD converts your .scad code into an STL file. STL stands for Standard Triangle Language (sometimes called Standard Tessellation Language). An STL file describes the surface of your 3D model as a mesh of tiny triangles — like wrapping a shape in a piece of paper made of triangles. It contains no color, no material information, no internal structure — just the outer surface geometry.

Stage 2 — Slicing A program called a slicer (PrusaSlicer and Cura are popular options) reads the STL and slices the model into horizontal layers, like cutting through a loaf of bread to see the shape of each slice. The thickness of each slice is the layer height — typically 0.15 to 0.30 mm.

Stage 3 — G-code The slicer converts those layer slices into a file of G-code — a language of machine instructions telling the printer exactly what to do. G-code commands look like: “move the print head to X=50, Y=30; heat the nozzle to 215°C; extrude 2.3 mm of filament.” The printer reads these instructions literally and executes them in sequence.

Stage 4 — Printing The printer reads the G-code and executes it. The nozzle heats to between 200°C and 240°C (depending on the material), melts a thin strand of plastic filament, and deposits it in the shape of each layer — one layer on top of the last, slowly building up the 3D form.

Stage 5 — Cooling and Bonding As each layer is deposited, it needs to cool and bond to the layer below it. This inter-layer fusion is what holds the part together. However, it also means 3D-printed parts are slightly weaker in the vertical direction than in the horizontal direction — because the bond between layers is never quite as strong as the plastic itself. Good design takes this into account: parts that will experience stress should be oriented so the layers are perpendicular to the direction of that stress.

The Three Key Slicer Settings to Know

Layer Height — how thick each printed layer is, typically 0.15 to 0.30 mm. Thinner layers produce smoother surfaces with more detail, but require more layers to reach the same total height, so prints take longer. For most classroom projects, 0.20 mm is a good starting point.

Infill Percentage — the internal structure of a print. A 100% infill print is completely solid. A 0% print is just the outer walls (hollow). In practice, most parts work well at 15–20% infill — the slicer creates a grid-like internal structure that supports the walls without using much material. Structural parts that will bear loads or stress should use 40–50% infill.

Supports — if your design has overhanging geometry (parts that extend horizontally without anything underneath them), the slicer can add temporary scaffolding called supports. These get removed after printing. The problem is that supports can leave rough surfaces and add both print time and material cost. Good design minimizes overhangs, which reduces or eliminates the need for supports.

First Prints Are Tests, Not Final Products

Tip

You will almost never get a perfect-fitting part on the first print. Treat the first print of any new feature as a test print: a quick, small print specifically designed to tell you what needs to be adjusted. This saves time and material by testing deliberately rather than accidentally printing a large part only to find the hole is 0.3 mm too small.

Step 4 — The Edit–Build–Verify Workflow

The Fundamental Loop

Professional software development runs on a tight feedback cycle: write some code, run it, check the result, fix any problems, and repeat. The shorter each cycle is, the faster you learn and the fewer problems pile up. Parametric 3D design works exactly the same way:

EDIT → BUILD → VERIFY → repeat

Edit:   Change src/main.scad in any text editor. Save the file.
Build:  3dm build   → compiles your .scad code into build/main.stl
Verify: 3dm info    → confirms bounding box and volume match your design intent
        (optional)  → open build/main.stl in your slicer for a visual check

Tip

Verify after every meaningful change, not just when you think you’re done. Frequent verification means any problem is always close to the last thing you changed. Verifying only at the end of a long session means sifting through dozens of changes to find one small mistake.

Watch Mode: Automatic Rebuilds

If you’re iterating quickly on a design, you can tell 3dMake to automatically rebuild every time you save your source file:

3dm watch

Run this in one terminal window, keep your text editor open in another. Every time you save src/main.scad, the terminal automatically runs 3dm build and reports the result. This creates a nearly real-time feedback loop: you save the file and, a few seconds later, see whether it built successfully and what the new dimensions are.

Step 5 — Building Parametric Variants

Overriding Parameters at Build Time

Once your design uses variables for all its dimensions, you can generate different versions without editing the source file at all. The -D flag tells OpenSCAD to override a variable at build time:

openscad -D "width=50" -o build/main_wide.stl src/main.scad

This builds a version with width=50 instead of the width=30 in the file — without changing the file. You can combine multiple overrides:

openscad -D "width=50" -D "height=15" -o build/main_large.stl src/main.scad

Building Multiple Variants Automatically

You can use a shell loop to generate a whole family of variants automatically:

Linux / macOS (bash):

>[!TIP]
>Use shell loops to generate multiple parametric variants automatically. Each run creates a separate STL file — a fast way to produce a tolerance test matrix without manually editing the source file.

```bash
# Build four width variants — generates four separate STL files
for w in 20 30 40 50; do
  openscad -D "width=$w" -o "build/main_w${w}.stl" src/main.scad
  echo "Built: width=${w}mm → build/main_w${w}.stl"
done

**Windows (PowerShell):**

```powershell
$widths = @(20, 30, 40, 50)
foreach ($w in $widths) {
  openscad -D "width=$w" -o "build\main_w$w.stl" "src\main.scad"
  Write-Host "Built: width=${w}mm → build\main_w$w.stl"
}

Windows (CMD):

FOR %%W IN (20 30 40 50) DO (
  openscad -D "width=%%W" -o build\main_w%%W.stl src\main.scad
  echo Built width=%%W
)

This is one of the most powerful things about parametric design: one source file, many specific outputs. The file represents the concept; the parameters turn it into instances.

Concept 5: Code Documentation Standards

Why Documented Code Is Part of Certification

When you return to a file weeks later, you will not remember what every variable was for. When a classmate, instructor, or future collaborator reads your code, they need to understand your design intent without asking you. When you submit work for this certification, well-documented code demonstrates professional-level practice — not just that you got the geometry right, but that you thought about it clearly.

OpenSCAD documentation has three levels:

File Header Comments — a block comment at the very top of the file explaining: what this part is, what it’s used for, print recommendations (layer height, infill, supports needed?), and which parameters are meant to be customized. This is the first thing anyone reads.

Parameter Line Comments — every variable declaration should have a comment stating the unit and a reasonable range. This:

wall = 2;   // mm — wall thickness (1.5–3.0 for a 0.4mm nozzle)

is dramatically more useful than just wall = 2;.

Module Comments — every module (a named, reusable chunk of geometry — covered in depth in Lesson 3) should have a one-line description of what shape it creates.

A Well-Documented File Template

// ==============================================================
// Parametric Box Lid
// ==============================================================
// Purpose:     Snap-fit lid for the storage box (box.scad)
// Print time:  ~8 minutes at 0.20 mm layers
// Material:    ~6 g PLA
//
// PARAMETERS TO CUSTOMIZE:
// - box_width:   width of the matching box (default: 60 mm)
// - box_depth:   depth of the matching box (default: 40 mm)
// - lip_height:  how deep the lid lip fits into the box (default: 3 mm)
//
// PRINT RECOMMENDATIONS:
// - Layer height: 0.20 mm
// - Infill:       15%
// - Supports:     not needed
// - Orientation:  print flat, face-down
// ==============================================================

box_width  = 60;   // mm — must match box.scad box_width
box_depth  = 40;   // mm — must match box.scad box_depth
lip_height = 3;    // mm — depth the lid lip extends downward (2–5 mm)
wall       = 2;    // mm — lid wall thickness (1.5–3.0 mm)

// (Geometry below this line — uses the parameters above)

This header comment takes about two minutes to write and saves many minutes of confusion later. Make it a habit starting with your very first project.

Summary Table

Extension Resources

Lesson 1 Asset Folder

• Your First Print guide
• Basic project scaffold template

Learning Series Sample Projects (3dmake_learning_series/)

• 01_cube_keycap (Beginner) — Text embossing basics
• 02_parametric_phone_stand (Intermediate) — Transforms and Minkowski fillets
• 03_stackable_bins (Advanced) — Tolerance and assemblies

Reference Materials (Reference_Materials/)

• 3dmake-setup-guide.md — Complete setup walkthrough
• openscad-cheat-sheet.md — Keyboard shortcuts and common functions
• filament-comparison-table.md — Material properties reference
• master-rubric.md — Assessment criteria

Quiz — Lesson 1 (15 questions)

1. What command initializes a 3dMake project?
2. What folder holds generated STL files?
3. How do you run 3dMake’s automatic rebuild mode?
4. Why is it useful to run 3dm build frequently during development rather than only at the end?
5. Give one reason to prefer an external text editor over the built-in OpenSCAD editor for this workflow.
6. True or False: 3dMake requires a graphical user interface to use effectively.
7. Explain what the 3dmake.toml file does in your project.
8. Describe what the src/ and build/ project folders are used for and which one you edit directly.
9. In your own words, explain the difference between a visual 3D editor (like Tinkercad) and a code-based parametric design tool (like OpenSCAD). What is the main advantage of the parametric approach?
10. What validation step should you always perform after running 3dm build before sending a file to print?
11. If the bounding box reported by 3dm info shows 0 × 0 × 0 mm, what does that tell you, and what should you do next?
12. Explain what center=false and center=true mean for a cube(). For each, where does the object appear relative to the position you specify?
13. What does FDM stand for, and what are the five stages of the FDM pipeline from STL file to cooled physical part?
14. A box has dimensions 50 × 40 × 25 mm and you’re printing it in PLA (density 1.24 g/cm³) at 100% infill. Using a $22 / 1 kg spool, what is the estimated material cost? Show your calculation.
15. You run 3dm build and receive the error “No such file or directory: src/main.scad”. List two likely causes and the fix for each.

Extension Problems (15)

1. Add a README entry explaining your top-level parameters and expected units.
2. Create a parameter variant by changing width by 20% and build both variants; compare dimensions using 3dm info to confirm the change.
3. Script a command sequence that automates the entire new-project setup: create folder, create src/main.scad, and run 3dm build — in a single script file.
4. Intentionally introduce a syntax error in your .scad file (remove a semicolon), run 3dm build, and document what the error message says and which line it points to. Then fix it.
5. Prepare a short instructor sign-off checklist describing the safety checks you should complete before sending a file to print.
6. Build a variant testing suite: create 5 different combinations of width, depth, and height, build all five, and record the bounding box and volume for each.
7. Create a 3dMake project template with best-practice structure, documentation header, and parameter comments. Write a README explaining how to use it.
8. Write a short accessibility guide explaining how a student using a screen reader could use 3dm info output to understand a model’s geometry without a visual preview.
9. Design a simple parametric part library (three or more related parts) in a single project. Document all parameters with units and example values.
10. Write a comprehensive troubleshooting guide for common 3dm build errors, with the cause and fix for each.
11. Add a .gitignore file to your project, commit it using Git, make a parameter change and create a second commit. In 2–3 sentences, explain why version control is valuable for parametric design.
12. Edit the global configuration file using 3dm edit-global-config to change the default editor. Document the setting name and how you verified the change took effect.
13. Create a project with three .scad source files and build each using 3dm build -m <n>. Record the output STL filenames.
14. Research the FDM layer height trade-off: slice the same model at 0.15 mm, 0.20 mm, and 0.30 mm. Record the estimated print time and filament use for each. What is the trade-off?
15. Write a one-page “new student onboarding guide” for 3dMake covering installation, project creation, first build, and first print. Write it as if your audience is a classmate who has never used the command line.

References and Helpful Resources

• 3DMake GitHub Repository — https://github.com/tdeck/3dmake

• OpenSCAD Manual — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual

• OpenSCAD Parametric Design — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/The_OpenSCAD_Language#Variables

• OpenSCAD Review — CadHub — https://learn.cadhub.xyz/blog/openscad-review/

• PrusaSlicer Validation Tools — https://docs.prusa3d.com/en/guide/39012-validation-tools/

• 3dmake e2e_test.py — https://github.com/tdeck/3dmake/blob/main/e2e_test.py

• PrusaSlicer Documentation — https://docs.prusa3d.com/en/

• OpenSCAD Non-Manifold FAQ — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/FAQ#Why_is_my_model_not_manifold.3F

Supplemental Resources

• Programming with OpenSCAD EPUB Textbook — assets/Programming_with_OpenSCAD.epub
• CodeSolutions Repository — https://github.com/ProgrammingWithOpenSCAD/CodeSolutions
• OpenSCAD Quick Reference — https://programmingwithopenscad.github.io/quick-reference.html
• All other reference documents are embedded as appendices below — no separate files needed.

Part 2: Extension Project and Reference Appendices

All supporting documents for Lesson 1 are included below. You do not need to open any additional files.

Appendix A: Your First Print — Extension Project

Estimated time: 2–4 hours (including setup and print monitoring)

Overview

This extension project applies the workflow and concepts from Lesson 1 to a real physical print. Rather than designing from scratch, you’ll select a simple ready-made model, evaluate whether it’s appropriate for a beginner print, configure slicer settings, run the print safely, and document what happened. The goal is to complete one full cycle of the pipeline you just learned — from file to printed object — and to practice the observation and documentation habits you’ll use for every print in this course.

Learning Objectives

By completing this project, you will:

• Select a simple ready-made model and evaluate its printability for a classroom printer
• Configure slicer settings for a short-duration print and prepare the printer safely
• Monitor a print in progress and recognize early warning signs of failure
• Document print parameters and reflect on the physical outcome

Materials

• Computer with slicer and access to an online model repository
• Classroom-approved printer, filament spool

Tasks

1. Choose a simple model (under 2 hours estimated print time) from Thingiverse or Printables. Download the STL.

2. Inspect the model before loading it in the slicer. Look at it from all angles. Note any overhangs, thin features, or very small details. Write two short reasons why this model is appropriate for a first print — specifically, why it is not risky.

3. Load the model in your slicer, select the classroom profile, and adjust settings only if necessary. Record the final print time estimate, layer height, infill %, and filament weight estimate.

4. Perform safety checks using the checklist in Lesson 5 Appendix A (or the condensed checklist below). Start the print and remain present and watching for the first 15 minutes. Note what you observe about first-layer adhesion and extrusion quality.

5. After the print cools, measure three critical dimensions using calipers (or by comparing against the model’s stated dimensions). Record the measured values and any deviations.

Condensed Pre-Print Safety Checklist

• Bed clean and level
• Filament loaded and extruding cleanly (run a short purge)
• Build area clear of obstructions
• Print area free of flammable materials
• You will remain present for the first 15 minutes

Probing Questions

1. Why did you select this model? What specific risks did you anticipate, and how does this model avoid or minimize them?
2. Which slicer setting most affects print time for this model, and why?
3. If a thin feature failed during printing, what is the minimum change you would make to give it a better chance on the next attempt?

Starter Code

If you want to build a simple printable object from scratch rather than downloading one, use this scaffold as your starting point:

// Basic Project Scaffold
// ============================================
// PROJECT CONFIGURATION
// ============================================
// Set your project dimensions here. All other geometry derives from these.

object_w  = 50;   // mm — overall width
object_d  = 50;   // mm — overall depth
object_h  = 20;   // mm — overall height
wall      = 2.0;  // mm — wall thickness (2–3mm recommended for FDM)
$fn       = 30;   // curve resolution (higher = smoother, slower to render)

// ============================================
// MAIN DESIGN
// ============================================

module base_shape() {
  // Replace this cube with your own geometry
  cube([object_w, object_d, object_h]);
}

module hollow_version() {
  // Creates a hollow version by removing an inner volume
  difference() {
    base_shape();
    translate([wall, wall, wall])
      cube([object_w - 2*wall,
            object_d - 2*wall,
            object_h]);  // open top — no overhang needed
  }
}

// Render your design:
hollow_version();

Deliverables

• Short report: model selected, key slicer settings, measured dimensions and deviations, answers to probing questions
• Photos of the final print (at least two angles)
• Completed student documentation template (Appendix B)

Appendix B: Your First Print — Student Documentation Template

Author: ________________ Date: __________ Description: Select a simple 3D model, configure slicer settings, and complete your first independent print job.

Model Selection

• Model name and source (Thingiverse, Printables, etc.):
• Link or file name:
• Why did you choose this model?
• Why is this model appropriate for a first print (two specific reasons)?

Printability Assessment

• Estimated print time (from slicer): ____ hours ____ min
• Estimated filament: ____ g
• Layer height selected: ____ mm
• Infill %: ____
• Supports required? Yes / No — if yes, describe where:
• Any overhangs or thin features that concerned you?

Printer Setup Log

Safety Checks

• Bed clean and level
• Filament loaded and purged cleanly
• Nozzle at correct first-layer height
• Print area clear of obstructions
• I remained present and watching for the first 15 minutes

Print Monitoring Notes

• What did you observe in the first layer?
• Was first-layer adhesion good, marginal, or poor?
• Any extrusion issues observed (clicking, skipping, thin lines)?
• Print completed successfully? Yes / No / Partially
• If partially or no — what happened and at what layer?

Dimensional Verification (After Cooling)

Measure three features on the printed part and compare to the model’s stated dimensions:

Reflections

What went well:

What didn’t go well:

What would you do differently next time:

If you printed this again, what settings would you change and why?

Attachments Checklist

• STL file or link to source model
• Slicer settings (screenshot or exported settings file)
• Photo of final print — at least two angles
• Completed measurement table above
• Answers to probing questions

Teacher Feedback

Resubmission: If resubmitting, attach a paragraph explaining what was changed and why. The resubmission score replaces the original.

Appendix C: Your First Print — Instructor Reference

Project Context

This is the first physical print extension project in the course. Its primary purpose is to establish safe printer operation habits and complete documentation practices — not to produce a complex or impressive object. A student who selects an appropriate model, monitors the print safely, and documents the outcome accurately has succeeded, regardless of whether the print is visually impressive.

Key Learning Points to Reinforce

Model selection discipline. The most common mistake at this stage is selecting a model that is too complex, too large, or has features that will fail (overhangs without supports, very thin walls, very fine detail). Push students to justify their selection in terms of printability, not just aesthetics.

Important

The first 15 minutes rule: students must stay and watch the printer for the first 15 minutes of every print. A print that lifts off the bed in the first few layers becomes a tangled failure — you must be present to catch it early.

Documentation enables iteration. A student who records their slicer settings has something to start from on the next print. A student who doesn’t has to guess. Reinforce this constantly.

Constraints (Enforce These)

• Model must be under 2 hours estimated print time
• Minimal or no support requirements recommended
• Student must record slicer settings, not just print the file
• Dimensional measurements must be taken after the part has fully cooled

Assessment Notes

Strong submissions show: clear model selection reasoning (not just “it looked cool”), a complete printer setup log, specific first-layer observations, measurements that reflect actual caliper readings (not round numbers), and a reflection that identifies something specific to do differently.

Common weak areas: Vague reflections (“it went well”), missing measurements, and skipped safety checks. Address all three in feedback.

Appendix D: 3dMake Setup and Workflow Guide

Installing 3dMake

Prerequisites

Before installing 3dMake, you need:

• Node.js version 18 or higher — download from https://nodejs.org
• OpenSCAD — download from https://openscad.org/downloads.html

To verify both are installed, open a terminal (PowerShell on Windows, Terminal on macOS/Linux) and run:

node --version    # should print v18.0.0 or higher
openscad --version  # should print a version number

If either command returns “not found,” install that software first before continuing.

Installing 3dMake

npm install -g 3dmake

Verify the installation:

3dm --version

You should see a version number. If you get “command not found,” check that npm’s global bin directory is in your PATH (see Troubleshooting below).

Creating Your First Project

# Create a new folder for your project and enter it
mkdir my_project
cd my_project

# Initialize a 3dMake project
3dm init

3dm init creates this project structure:

my_project/
├── src/
│   └── main.scad      ← Your design code goes here
├── build/             ← Generated STL files appear here (auto-created)
└── 3dmake.toml        ← Project configuration

The src/ folder is where you write your OpenSCAD code. You should never need to edit files in build/ directly — that folder is managed by 3dMake.

3dmake.toml stores your project settings: the slicer path, filament density, cost-per-gram, and other project-level configuration. Open it with any text editor to see the available settings.

The Core Workflow

Every design session follows this cycle:

edit src/main.scad  →  3dm build  →  3dm info  →  review / repeat

3dm build — compiles your .scad source into an STL file in the build/ folder.

3dm build              # standard build
3dm build --clean      # delete build/ first, then rebuild
3dm build --watch      # auto-rebuild whenever you save src/main.scad

3dm info — reports on the most recently built STL: bounding box, volume, triangle count, and an AI-generated description.

3dm info
3dm info --view front
3dm info --view top,front,isometric

3dm preview — renders an image of your model to build/preview.png.

3dm orient — recommends a print orientation based on your model’s geometry.

3dm slice — calls your configured slicer on the current STL.

Command Reference

Configuring Your Slicer

Edit 3dmake.toml in your project folder and add your slicer path:

Windows (PrusaSlicer):

[slicer]
path = "C:/Program Files/Prusa3D/PrusaSlicer/prusa-slicer.exe"

macOS (PrusaSlicer):

[slicer]
path = "/Applications/PrusaSlicer.app/Contents/MacOS/PrusaSlicer"

Linux:

[slicer]
path = "/usr/bin/prusa-slicer"

Configuring Cost Estimation

To use the cost estimation feature, set your filament density and spool price:

[filament]
density = 1.24        # g/cm³ — PLA default (see Lesson 5 Appendix C for other materials)
spool_weight = 1000   # grams per spool
spool_price = 22.00   # dollars per spool

3dMake will then include cost estimates in 3dm info output.

Troubleshooting

3dm: command not found after installation

npm’s global bin directory isn’t in your PATH. Find the directory:

npm config get prefix

Add the bin subdirectory of that path to your PATH. On Windows, this is usually C:\Users\YourName\AppData\Roaming\npm. On macOS/Linux, it’s usually ~/.npm-global/bin or /usr/local/bin.

No such file or directory: src/main.scad

You either haven’t run 3dm init, or you’re in the wrong folder. Run pwd to confirm your current location, and ls (or dir on Windows) to see if src/ exists.

OpenSCAD: command not found during build

OpenSCAD isn’t in your PATH. On Windows, find where OpenSCAD is installed (usually C:\Program Files\OpenSCAD\) and add it to your PATH in System Settings → Environment Variables.

Build succeeds but 3dm info shows 0 × 0 × 0 mm

Your OpenSCAD code compiled without errors but produced no geometry. Check that your shapes are actually being rendered (not commented out), and that no difference() has subtracted more than it started with.

WARNING: Normalized tree is empty

Same as above from OpenSCAD’s perspective. The most common causes: a shape with zero volume, all geometry inside a difference() was subtracted away, or a module was defined but never called.

Appendix E: Navigating This Curriculum (mdBook Guide)

This curriculum is published as a web book using mdBook. This guide explains how to find what you need, navigate between chapters, and use the book with a screen reader.

Basic Navigation

Sidebar table of contents — the left side of the page lists all chapters by unit and lesson. Click or tap any title to jump to it. On a small screen, the sidebar may be hidden — look for a hamburger menu icon (three horizontal lines) to show it.

Arrow navigation — at the bottom of every page are Previous and Next links. You can also use keyboard arrow keys:

• Left Arrow — go to the previous chapter
• Right Arrow — go to the next chapter

Search — press S to open the search box. Type your search term; results appear as a dropdown. Click any result to jump to that chapter. Press Escape to close search.

Screen Reader Navigation

With NVDA (Chrome, Firefox, or Edge recommended)

• H — jump between headings; the fastest way to skim a long lesson
• D — move between landmark regions (use to reach the sidebar)
• NVDA + F7 — open the Elements List; select “Landmarks” to navigate to the sidebar directly
• Set punctuation level to Most or All before reading code blocks: NVDA + P to cycle
• Ctrl + F — browser Find, works alongside mdBook search

With JAWS (Chrome or Edge recommended)

• H — jump between headings
• R — move between landmark regions to reach the sidebar
• JAWS Key + F6 — list all headings on the current page
• Set punctuation to All before reading code: JAWS Key + Shift + 2
• JAWS Key + F5 — links list
• Ctrl + F — browser find

With VoiceOver (Mac / iOS)

• VO + U — open the rotor; select Headings to navigate by heading
• H (Quick Nav on) — move between headings
• iOS: use the rotor (two-finger rotate) to set navigation mode to Headings

Finding What You Need

If you know the unit or project: open the table of contents and look for the unit name. Structure: Unit 0 (Foundation lessons) → Unit 1 (Guided projects) → Unit 2 (Intermediate skills) → Unit 3 (Open-ended projects) → Reference Materials.

If you’re looking for a specific term or command: use Search (S). Search for an OpenSCAD command (difference, translate), a vocabulary word (infill, tolerance), or a project name.

While working: keep a second browser tab open to the Reference Materials section. Useful pages to bookmark: OpenSCAD Cheat Sheet, Slicing Settings Quick Reference, Filament Comparison Table, Screen Reader Coding Tips.

Appendix F: Screen Reader Coding Tips (NVDA and JAWS)

General Principles

Turn punctuation up. All OpenSCAD syntax — semicolons, brackets, parentheses, commas — is meaningful. If your screen reader skips punctuation, you will miss syntax errors. Set to Most or All before coding.

Navigate by line. Arrow up and down through code one line at a time. Use Ctrl + Left/Right to move word by word within a line.

Use go-to-line. OpenSCAD errors always give a line number. In VSCode: Ctrl + G, type the number, press Enter.

Comment as you go. A short comment after a block of code lets you navigate back to it by searching with Ctrl + F.

NVDA Quick Reference

Setting punctuation level: NVDA + P cycles through None → Some → Most → All. For code: Most or All.

Navigation in VSCode with NVDA:

If NVDA stops reading the editor: press NVDA + Space to toggle between Browse and Application mode. For code editors, you want Application mode.

JAWS Quick Reference

Setting punctuation level: JAWS Key + Shift + 2 cycles through levels. For code: All.

Navigation in VSCode with JAWS:

If JAWS stops reading the editor: press JAWS Key + Z to toggle Virtual mode off. You want Virtual mode OFF in VSCode.

OpenSCAD-Specific Tips

Reading errors. OpenSCAD errors always include a line number. Use Ctrl + G in VSCode to jump to it. Common errors:

Bracket matching. Every ( needs a ), every [ needs a ], every { needs a }. In VSCode, cursor on a bracket highlights its match. Navigate to the matching bracket with Ctrl + Shift + \.

Commenting out code. To test without deleting: // before a line, or Ctrl + / in VSCode to toggle comment on selected lines.

Caliper and OpenSCAD Workflow Tip

When measuring and entering into OpenSCAD: say the measurement aloud before typing, then read it back after typing to confirm.

1. Measure → say “seventy point three millimeters”
2. Type 70.3 in OpenSCAD
3. Read back: “seven zero point three” — confirm match

Appendix G: VSCode Setup Guide for NVDA and JAWS

Why VSCode Instead of the OpenSCAD Editor

The built-in OpenSCAD editor has inconsistent behavior with screen readers — focus can jump unexpectedly and the editor sometimes stops being read after certain actions. VSCode is a mainstream code editor with strong, well-tested accessibility support for both NVDA and JAWS.

You write code in VSCode. OpenSCAD runs in the background to render the preview. You never need to interact with the OpenSCAD editor itself.

Install Required Software

Install VSCode — download from https://code.visualstudio.com/ During installation: check “Add to PATH” and “Register Code as an editor for supported file types.”

Install OpenSCAD — download from https://openscad.org/downloads.html Use the installer version (not portable). After installing, verify it’s in your PATH:

openscad --version

Optional: OpenSCAD VSCode Extension — press Ctrl + Shift + X, search for “OpenSCAD Language Support,” install it. Adds syntax highlighting and keyword completion for .scad files.

Configure the Task Runner

The task runner lets you open your .scad file in OpenSCAD or export an STL with a single keypress.

Create or open your workspace folder in VSCode:

cd ~/Documents/OpenSCAD_Projects
code .

Create tasks.json:

1. Press Ctrl + Shift + P to open the Command Palette
2. Type Tasks: Configure Task and press Enter
3. Select “Create tasks.json file from template” → “Others”

Replace the file’s entire contents with:

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "Preview in OpenSCAD",
      "type": "shell",
      "command": "openscad",
      "args": ["${file}"],
      "group": { "kind": "build", "isDefault": true },
      "presentation": { "reveal": "silent", "panel": "shared" },
      "problemMatcher": []
    },
    {
      "label": "Export STL",
      "type": "shell",
      "command": "openscad",
      "args": [
        "-o",
        "${fileDirname}/${fileBasenameNoExtension}.stl",
        "${file}"
      ],
      "group": "build",
      "presentation": { "reveal": "always", "panel": "shared" },
      "problemMatcher": []
    }
  ]
}

Save with Ctrl + S.

Run the preview: with a .scad file open, press Ctrl + Shift + B. OpenSCAD opens and displays your model. Alt + Tab to return to VSCode.

Export STL: Ctrl + Shift + P → “Tasks: Run Task” → “Export STL.”

NVDA Settings for VSCode

• Symbol level: Most (NVDA + N → Preferences → Settings → Speech → Symbol level: Most)
• For code reading: NVDA + P to cycle to Most or All on the fly

JAWS Settings for VSCode

• Toggle Virtual mode OFF: JAWS Key + Z (you want Virtual mode off in VSCode)
• Punctuation level: All (JAWS Key + Shift + 2)

Workflow Summary

1. Open VSCode workspace          code ~/Documents/OpenSCAD_Projects
2. Open or create a .scad file    Ctrl + P → type filename
3. Write OpenSCAD code
4. Preview in OpenSCAD            Ctrl + Shift + B
5. Export STL                     Ctrl + Shift + P → Tasks: Run Task → Export STL
6. Open slicer, import STL, slice, export G-code
7. Print

Troubleshooting

Lesson 2 — Geometric Primitives and Constructive Solid Geometry

Estimated Time: 90–120 minutes
Course: 3dMake Certification — High School Distance Learning Track

Before You Start

In Lesson 1, you made a box by calling cube(). You understood the coordinate system, installed the tools, and ran the complete build-verify workflow. That’s a real foundation — but a single rectangular box isn’t going to take you very far as a designer.

This lesson introduces the complete vocabulary of 3D shapes OpenSCAD knows how to build, and — more importantly — the three operations that let you combine those shapes into virtually anything you can imagine. Those three operations are union (merge), difference (subtract), and intersection (keep only what overlaps). Together with the primitive shapes, they form a system called Constructive Solid Geometry, and nearly every 3D model ever built in OpenSCAD is made from these tools.

Learning Objectives

By the end of this lesson you will be able to:

• Use all core OpenSCAD 3D primitives: cube, sphere, cylinder, polygon
• Combine shapes with union(), difference(), and intersection()
• Apply the 0.001 mm offset rule and understand exactly why it exists
• Create 2D profiles with polygon() and extrude them into 3D geometry
• Use rotate_extrude() and linear_extrude() to create complex rotational shapes
• Use the four debugging modifier characters (#, %, !, *)
• Use hull() to create convex envelope shapes

Concept 1: What Are Primitives?

The Raw Materials of 3D Design

A primitive is the simplest, most basic shape a system can produce from scratch, with no prior shape as input. Everything more complex gets built by combining and modifying these primitives. Think of them the way a sculptor thinks about blocks of material: the primitive is the raw material, and the operations you’ll learn in this lesson are the tools you use to shape it.

OpenSCAD has four main 3D primitives. Every complex shape you’ll ever design in this course is built from some combination of these four, using the CSG operations to combine them.

Step 1 — The Four Core 3D Primitives

cube([width, depth, height]) — The Rectangular Box

Despite the name cube, this primitive creates any rectangular box — it doesn’t have to be a perfect cube. The three numbers you provide are the dimensions along the X, Y, and Z axes respectively. cube([30, 20, 10]) creates a box that is 30 mm wide (X), 20 mm deep (Y), and 10 mm tall (Z).

The center=true option (which you learned about in Lesson 1) centers the box on the origin rather than placing one corner there. Remember: center=false is the default, and it’s usually what you want for parts that should sit on the build plate.

sphere(r=radius) — The Round Ball

sphere(r=10) creates a sphere with a 10 mm radius (so 20 mm diameter). The sphere is centered on the origin by default — it can’t be un-centered the way a cube can.

The key parameter to know here is $fn — short for “facet number.” OpenSCAD doesn’t have a mathematically perfect curved surface; it approximates curves by using lots of flat faces. A sphere with $fn=8 looks like a faceted gem. A sphere with $fn=64 looks smooth and round. The catch is that higher $fn values take longer to compute. During development, use $fn=16 for speed. Use $fn=64 or higher only when you’re generating your final print file. Many designers set $fn globally at the top of their file.

cylinder(h=height, r=radius) — The Tube, Cone, or Pipe

cylinder(h=20, r=8) creates a 20 mm tall cylinder with an 8 mm radius. Like spheres, $fn controls how round it looks.

There’s an especially powerful variant: instead of a single r (which makes both the top and bottom the same radius), you can specify r1 for the bottom radius and r2 for the top radius. This creates tapered shapes:

• r1=10, r2=5 creates a cone that’s wider at the bottom and narrower at the top
• r1=8, r2=0 creates a spike — the top radius is zero, so the top comes to a point
• r1=0, r2=8 creates an upside-down spike — a shape that tapers to a point at the bottom

This flexibility makes cylinder far more versatile than its name suggests.

polygon(points) — The Custom 2D Shape

None of the above shapes can make an L-shape, a T-shape, a hexagon, or a star. That’s what polygon() is for.

polygon() accepts a list of (x, y) coordinate pairs and creates a flat 2D shape in the XY plane by connecting them in order. The shape automatically closes — the last point connects back to the first. Points should be listed in counterclockwise order as seen from above — this convention tells OpenSCAD which side is the “inside” of the polygon.

By itself, a polygon() is a flat 2D cutout. Combined with linear_extrude(height=N), it gets pushed straight up along the Z axis to become a 3D prism with that polygon as its cross-section. This is your escape hatch for any shape that can’t be described with boxes, spheres, and cylinders.

// All four primitives demonstrated:

// 1. A simple box (already familiar from Lesson 1)
cube([30, 20, 10]);

// 2. A sphere — note it's centered on origin by default
// Translate it sideways so it doesn't overlap the cube
translate([40, 0, 10])
  sphere(r=10, $fn=32);    // $fn=32 gives a smooth appearance

// 3. A standard cylinder
translate([70, 0, 0])
  cylinder(h=20, r=8, $fn=32);

// 4. A tapered cylinder (cone) — wider at the bottom
translate([100, 0, 0])
  cylinder(h=20, r1=10, r2=3, $fn=32);

// 5. A spike — r2=0 makes a pointed top
translate([130, 0, 0])
  cylinder(h=20, r1=8, r2=0, $fn=32);

// 6. A polygon extruded into a prism
// This L-shape profile gets pushed up 5 mm to become a 3D L-bracket
translate([0, 40, 0])
  linear_extrude(height=5)
    polygon([[0,0],[40,0],[40,8],[8,8],[8,30],[0,30]]);

After building this code, run 3dm info to check the bounding box of each shape and make sure you understand the relationship between the numbers you typed and the dimensions reported.

Concept 2: Constructive Solid Geometry

The Logic Behind Combining Shapes

Constructive Solid Geometry (CSG) is a technique for building complex 3D shapes by performing logical operations on simpler ones. The word “Boolean” comes from Boolean algebra — the mathematics of true/false logic. In 3D space, a Boolean operation asks a question about every point in space: is this point inside shape A? Inside shape B? Inside both? Inside neither?

The three answers to those questions correspond to the three CSG operations.

Why This Approach Is So Powerful

Think about how you’d make a box with a cylindrical hole drilled through it. You can’t do that with a single primitive. But you can:

1. Create a box
2. Create a cylinder the size of the hole
3. Subtract the cylinder from the box

That’s difference(). Most real-world parts are designed exactly this way: start with a basic solid shape, then cut, drill, and hollow it using additional shapes as “tools.”

Now think about a phone stand that has a rounded edge. You can’t describe that with a box. But you can:

1. Create the main body as a box
2. Create a sphere slightly larger than the corner radius
3. Use hull() to create a smooth, rounded version

That’s the power of CSG: you’re building a vocabulary of operations that let you describe arbitrarily complex geometry by combining simple pieces.

Step 2 — The Three CSG Operations

union() — Merge Shapes Together

union() combines two or more shapes into a single solid. Any point that is inside any of the shapes is inside the result.

An important subtlety: union() isn’t the same as just rendering two objects next to each other. If shapes overlap, union() properly merges them into a single watertight solid. Two overlapping objects without a CSG wrapper can cause problems for the slicer — it may not know whether the overlapping region should be treated as solid once or twice. Always use union() when shapes share space.

// union() — combines a cube and a sphere into one solid piece
// The sphere sits on top of the cube, and the two are fused where they meet.
union() {
  cube([20, 20, 5]);
  translate([10, 10, 5])
    sphere(r=10, $fn=32);
}

Build this and notice: the cube and sphere are one object. You can’t select them separately.

difference() — Subtract Shapes

difference() subtracts child shapes from the first child. The first shape listed inside difference() is the base — the “workpiece.” Every shape listed after it acts as a cutting tool, removing its volume from the base.

Think of a drill press: the block of material is the first child, and the drill bits are the shapes that follow. You position the drills where you want the holes, and difference() removes exactly the volume each drill bit occupies.

// difference() — a cube with a cylindrical hole drilled through it
// The cube is the base. The cylinder is the cutting tool.
difference() {
  cube([20, 20, 20]);
  translate([10, 10, -0.001])       // see Step 4 for why this -0.001 matters
    cylinder(h=20.002, r=5, $fn=32);
}

Caution

The most common mistake with difference() is accidentally listing the cutting tool first and the base second — the result will be empty or backwards. Always check: is the first child in your difference() the piece you want to keep?

intersection() — Keep Only What Overlaps

intersection() keeps only the volume that exists inside all shapes simultaneously. If shape A and shape B overlap, intersection() gives you just the overlapping region — everything that is inside both at the same time.

A practical mental model: intersection() is like a cookie cutter. The cookie cutter shape is one child, the dough is another. The result is the piece of dough within the cutter’s outline.

// intersection() — keeps only the region inside both shapes
// A cube intersected with a sphere = a cube with rounded corners
intersection() {
  cube([20, 20, 20], center=true);
  sphere(r=12, $fn=64);
}

Build this and observe: the straight edges of the cube are rounded off wherever the sphere’s surface cuts through them. The result is a shape that’s simultaneously box-like and rounded.

Visualizing Each Operation

The best way to internalize these operations is to build each example above separately and study the result before moving on. When you can predict what each operation will produce before you build it, you’re ready to combine them in more complex designs.

Here’s a quick mental checklist:

• union(): Think “merge everything together, fill in any gaps.”
• difference(): Think “start with the first thing, carve away everything else.”
• intersection(): Think “keep only the parts that are inside every single child.”

Step 3 — polygon() for Custom 2D Profiles

When Primitives Aren’t the Right Shape

Boxes, spheres, and cylinders get you surprisingly far. But eventually you’ll need a shape that doesn’t fit any of them — an L-bracket, a triangular wedge, a hexagonal base, an irregular outline traced from a measurement. That’s where polygon() earns its place.

polygon() takes a list of (x, y) coordinate pairs and creates the 2D shape enclosed by connecting them in order. The shape is drawn in the XY plane. Because it’s 2D, you can’t print it directly — but combined with linear_extrude(height=N), it becomes a 3D solid with that exact cross-section.

Here’s how to use it: sketch your cross-section shape on graph paper. Mark the coordinates of every corner. Transfer those coordinates into the polygon() list. Connect the last point back to the first (OpenSCAD does this automatically). List them counterclockwise when viewed from above.

// An L-shaped bracket: cross-section traced from corner coordinates
bracket_profile = [
  [0,  0],    // bottom-left
  [40, 0],    // bottom-right
  [40, 8],    // step up — beginning of horizontal arm's top edge
  [8,  8],    // inside corner of the L
  [8,  30],   // top of the vertical arm
  [0,  30]    // top-left
];

// Extrude 5 mm along Z — this produces a 3D L-bracket
linear_extrude(height=5)
  polygon(bracket_profile);

Walk through those coordinates: starting at the bottom-left, moving right along the bottom, up and left to form the horizontal arm, then up the vertical arm, and back to the start. The result is a shape you genuinely cannot make with cube() alone.

The graph-paper method works for almost any traced shape. Measure your object, draw it on grid paper, read off the corner coordinates, and type them in. This is a real engineering workflow.

Step 4 — The 0.001 mm Offset Rule

The Co-Planar Face Problem

When you use difference() to cut one shape with another, there’s a subtle problem that occurs when the cutting shape shares an exact face with the base shape — for example, when the bottom face of a cutting cylinder sits at exactly Z=0, the same as the bottom face of the box it’s cutting.

At that shared boundary, OpenSCAD faces an ambiguity: does this face belong to the outer solid or the inner (cutting) solid? The geometry engine can’t make that decision cleanly, and the result is undefined behavior — sometimes a rendering artifact, sometimes a non-manifold edge that crashes the slicer, sometimes output that looks fine in preview but is broken in the exported STL.

This problem is called a co-planar face problem, and it’s one of the most common sources of mysterious errors in OpenSCAD files.

The Fix

Important

The 0.001 mm offset rule: whenever subtracting a shape, extend the cutting shape 0.001 mm past each face it needs to pass through (0.002 mm total extra length). This eliminates co-planar face ambiguity that causes rendering artifacts and slicer errors.

Specifically, move it 0.001 mm past the face on the entry side and make it 0.002 mm longer total.

Why 0.001 mm? It’s large enough to eliminate the ambiguity entirely — the cutting shape now unambiguously passes through the surface. It’s also small enough that no printer in the world can detect it. The 0.001 mm offset is invisible in the physical print.

// WRONG — co-planar faces: the cutting shape is exactly as tall as the base
// This may produce rendering artifacts or slicer errors.
difference() {
  cube([20, 20, 10]);
  translate([1, 1, 0])      // cutting shape's bottom at Z=0, same as base
    cube([18, 18, 10]);     // cutting shape's top at Z=10, same as base's top
}

// CORRECT — the 0.001 offset rule applied
// The cutting shape starts 0.001 mm BELOW the base bottom
// and extends 0.001 mm ABOVE the base top.
difference() {
  cube([20, 20, 10]);
  translate([1, 1, -0.001])         // start 0.001 mm below the floor
    cube([18, 18, 10 + 0.002]);     // 0.001 below + 0.001 above = 0.002 extra height
}

The pattern to memorize: when cutting along the Z axis, use translate([x, y, -0.001]) to start the cut 0.001 mm below the floor, and add 0.002 to the cutting shape’s height (0.001 below + 0.001 above = 0.002 total extra). For cuts along the X or Y axis, apply the same logic to those dimensions instead.

Step 5 — Debugging Modifier Characters

The Four Special Modifiers

OpenSCAD provides four modifier characters that you can prefix onto any shape to temporarily change how it appears in the preview. These are debugging tools — they don’t change the final exported geometry. Always remove them before exporting a file for printing.

# (hash / highlight) — renders the shape in translucent pink/red, and keeps it in the model. Use this when you want to see exactly where a cutting shape is sitting relative to the base. Add # to a cylinder inside a difference() and you’ll see the cutting tool highlighted.

% (percent / ghost) — renders the shape as a transparent ghost, and excludes it from the model output. Use this for reference geometry — a ghost outline of a component you’re designing something to attach to — that helps you position things but shouldn’t be in the final print.

! (bang / isolate) — renders only this shape, ignoring everything else in the entire file. Use this when you want to check a single module or shape by itself, without every other object in the scene blocking the view.

* (star / disable) — completely disables this shape; it’s not rendered at all and produces no output. Use this to temporarily turn off part of your design during debugging, without deleting the code.

// USING MODIFIERS FOR DEBUGGING:

difference() {
  cube([30, 30, 20]);

  // # highlights the cutting shape so you can see where it's cutting
  # translate([15, 15, -0.001])
    cylinder(h=20.002, r=8, $fn=32);
}

// % ghost reference — helps position but doesn't print
% translate([0, 0, 20])
  cube([30, 30, 5]);   // ghost of a lid that will sit on top

Important

F5 vs F6: F5 runs a fast approximate preview that is NOT manifold-safe — good for quick visual checks only. F6 runs the full CGAL geometric kernel: slower, but accurate and manifold-safe. Always use F6 (or 3dm build) before sending anything to print.

Step 6 — linear_extrude() and rotate_extrude()

Two Ways to Create 3D Shapes from 2D Profiles

You’ve already used linear_extrude() with polygon(). Now let’s understand it more fully, and introduce its sibling rotate_extrude().

linear_extrude(height=N) takes a 2D profile (any 2D shape: circle, square, polygon, or a combination) and pushes it straight up along the Z axis, creating a prism. The cross-section of the prism matches the 2D profile exactly.

Two important optional parameters:

• twist=angle — rotates the profile as it extrudes, creating a spiral or helix. A twist=90 on a square profile creates a twisted square column.
• scale=factor — changes the size of the profile from bottom to top. scale=0.5 means the top is half the size of the bottom, creating a tapered shape.

rotate_extrude(angle=360) takes a 2D profile and rotates it around the Z axis, sweeping it in a circle to create a rotationally symmetric solid. Imagine a lathe: the profile is the outline of a piece, and the lathe spins it to create a solid of revolution.

The profile for rotate_extrude() must be positioned in positive X space — to the right of the Z axis. The X distance from the Z axis becomes the radius of the resulting shape. If you place a small circle at X=15 and rotate-extrude it, you get a torus (donut) with a 15 mm ring radius.

// linear_extrude: circle pushed straight up = a cylinder
linear_extrude(height=20) {
  circle(r=10, $fn=32);
}

// linear_extrude with twist: a twisted square column
translate([30, 0, 0])
linear_extrude(height=30, twist=90) {
  square([10, 10], center=true);
}

// linear_extrude with scale: a tapered shape (like a pyramid with a square base)
translate([60, 0, 0])
linear_extrude(height=30, scale=0.1) {
  square([15, 15], center=true);
}

// rotate_extrude: a circle swept around the Z axis = a torus (donut)
translate([0, 50, 0])
rotate_extrude(angle=360, $fn=64) {
  translate([15, 0, 0]) circle(r=5, $fn=32);
}

Any shape that is rotationally symmetric — a bowl, a cup, a ring, a knob, a vase — can and should be made with rotate_extrude(). It’s dramatically more elegant than building the same shape from many overlapping cylinders.

Step 7 — hull() — The Convex Envelope

What hull() Does

hull() computes the convex hull of all its children — the smallest convex shape that completely contains all of them. The easiest mental model: imagine stretching a rubber band around a collection of objects laid on a table. The shape the rubber band makes when it snaps tight around all of them is the convex hull.

Notice the key word: convex. A convex shape has no indentations or concave regions — every surface curves outward. hull() fills in any gaps or concavities between the shapes you give it.

How hull() Differs from union()

union() takes all the shapes and merges them, preserving their individual forms including any gaps or indentations between them.

hull() takes all the shapes and creates the smoothest possible outer envelope that touches or contains all of them, filling in any gaps.

This makes hull() excellent for:

• Creating smooth transitions between two shapes of different sizes
• Making rounded boxes (place a small sphere at each corner, take the hull)
• Creating organic, blob-like shapes
• Generating ramps and smooth blends

// hull() of three spheres — creates a smooth rounded triangle
hull() {
  translate([0,  0,  0]) sphere(r=5, $fn=32);
  translate([30, 0,  0]) sphere(r=5, $fn=32);
  translate([15, 20, 0]) sphere(r=5, $fn=32);
}

// Practical use: a rounded box
// Place small spheres at the eight corners of a box
// The hull creates a box with perfectly rounded edges
translate([0, 40, 0])
hull() {
  for (x = [3, 27], y = [3, 17], z = [3, 7]) {
    translate([x, y, z]) sphere(r=3, $fn=16);
  }
}

The rounded box pattern is one of the most commonly used techniques in OpenSCAD. The sphere radius controls how round the edges are. The positions of the spheres control the overall box dimensions. Change the sphere radius to change how much rounding you get.

Advanced CSG: Putting It All Together

A Parametric Mounting Bracket

Here is a complete practical example that uses nested CSG operations to create a real functional part. Read through it carefully — notice how the design intent is encoded as named variables at the top, and the geometry simply uses those variables.

// Parametric Mounting Bracket
// Change these values to resize the bracket
width  = 40;    // mm — total bracket width
height = 30;    // mm — total bracket height
depth  = 8;     // mm — bracket thickness (front to back)
hole_r = 4;     // mm — radius of mounting holes
slot_w = 6;     // mm — width of top slot
slot_h = 15;    // mm — height of top slot
wall   = 3;     // mm — material remaining above slot

module bracket() {
  difference() {
    // Base: a solid rectangular block — this is what everything gets cut from
    cube([width, depth, height]);

    // Two circular mounting holes drilled through the Y axis
    // The rotate([-90,0,0]) turns the cylinder to point in the Y direction
    translate([10, -0.001, 10])
      rotate([-90, 0, 0]) cylinder(r=hole_r, h=depth + 0.002, $fn=32);
    translate([30, -0.001, 10])
      rotate([-90, 0, 0]) cylinder(r=hole_r, h=depth + 0.002, $fn=32);

    // A slot cut through the top portion of the bracket
    translate([width/2 - slot_w/2, -0.001, height - slot_h - wall])
      cube([slot_w, depth + 0.002, slot_h]);
  }
}

bracket();

Walk through this mentally: start with a solid block. Drill two circular holes through it from front to back. Cut a slot down from the top. The result is a bracket with two mounting holes and an adjustment slot — all from one parametric design.

Try changing hole_r, slot_w, or width and rebuilding. Watch how every feature adapts automatically.

Quiz — Lesson 2 (15 questions)

1. What are the four main 3D primitives in OpenSCAD?
2. What does difference() do? Which child is the base, and which children are the cutting tools?
3. Why do you add 0.001 mm to the cutting geometry in a difference() operation? What problem does it prevent?
4. What does the # modifier character do, and when would you use it during debugging?
5. What is the difference between F5 and F6 in the OpenSCAD GUI? Which should you use before printing?
6. What does hull() produce? How is it different from union()?
7. What does the % modifier do to a shape in OpenSCAD?
8. Describe what rotate_extrude() does and give one example of a shape it could produce.
9. What does intersection() return when applied to a cube and a sphere that partially overlap?
10. True or False: the * modifier renders a shape as a transparent ghost for debugging purposes.
11. Describe what linear_extrude() does and explain what the twist parameter changes.
12. What is a co-planar face, and what problem does it cause in a difference() operation?
13. If you want to subtract a cylinder from a cube and the cylinder is exactly as tall as the cube, what two adjustments do you need to make to ensure a clean cut?
14. When using polygon(), what order should points be listed in, and why?
15. What is the difference between combining two overlapping shapes with union() versus rendering two separate overlapping objects without any CSG operation?

Extension Problems (15)

1. Build a hollow sphere with 1.5 mm walls using difference() and the 0.001 mm rule. Document the outer and inner radii you chose and verify the wall thickness using 3dm info.
2. Create a vase shape using rotate_extrude() and a custom 2D profile. The vase should be wider in the middle than at the top and bottom.
3. Design a bracket or clip using nested difference() and union(). Add a comment to every CSG step explaining what it does.
4. Use hull() to create a smooth, rounded box with 3 mm radius corners. Document the sphere placement strategy you used.
5. Use the % modifier to create a ghost reference shape that helps you position a snap-fit clip around a cylinder. Screenshot the debugging view and explain it.
6. Create a parametric name badge: a flat rectangular base with your name text embossed (raised) on the top face, using linear_extrude() combined with text(). Make the text height a parameter.
7. Build a compound hinge using two cylinders (the barrel), a hull() for the hinge leaf, and alignment holes through the barrel. Document the design intent.
8. Design a 10-sided (decagonal) prism using cylinder() with $fn=10 and a difference() to cut a hexagonal through-hole aligned with the prism’s center.
9. Create a single test print that exercises all three CSG operations (union, difference, intersection) in one part. Add header comments explaining what each operation does in the design.
10. Using only cube(), sphere(), difference(), and hull(), build a simple chess pawn. It should be recognizable as a pawn when printed.
11. Create a lattice cube: a solid cube with a grid of cylindrical holes drilled through it in all three axes. Calculate and document the relationship between hole spacing and remaining wall thickness.
12. Build a parametric ring using rotate_extrude() where the cross-section shape (round, square, or custom polygon) is easily changeable by modifying a variable.
13. Research and document the surface() primitive: what input does it accept, what shape does it produce, and when would you use it instead of polyhedron()? Include a working example.
14. Design a tolerance test set: five pairs of pegs and holes with clearances from 0.0 mm to 0.4 mm in 0.1 mm increments. Print one set and document which clearance allows free movement on your specific printer.
15. Write a short guide explaining all four modifier characters (#, !, %, *) with one concrete use case for each, and a note on why you must always remove them before exporting the final file.

References and Helpful Resources

• OpenSCAD User Manual — Primitive Solids and Boolean Operations — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Primitive_Solids

• OpenSCAD User Manual — CSG Modelling — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/CSG_Modelling

• OpenSCAD User Manual — Transformations and Extrusions — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Using_the_2D_Subsystem

• OpenSCAD User Manual — Modifier Characters — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Modifier_Characters

Supplemental Resources

• Programming with OpenSCAD EPUB Textbook — assets/Programming_with_OpenSCAD.epub — Chapters on CSG and primitives
• CodeSolutions Repository — https://github.com/ProgrammingWithOpenSCAD/CodeSolutions — Worked examples for CSG, hull, and extrusions
• OpenSCAD Quick Reference — https://programmingwithopenscad.github.io/quick-reference.html — All primitive and CSG syntax at a glance
• 3DMake GitHub Repository — https://github.com/tdeck/3dmake — Build workflow reference
• All other reference documents are embedded as appendices below — no separate files needed.

Part 2: Extension Projects and Reference Appendices

All supporting documents for Lesson 2 are included below. You do not need to open any additional files.

Appendix A: OpenSCAD Quick Reference — Cheat Sheet

Keep this handy during all OpenSCAD work. For full documentation: https://openscad.org/documentation.html

Basic Shapes (Primitives)

cube([length, width, height]);           // rectangular box at origin
cube([l, w, h], center=true);           // box centered at origin

sphere(r=radius);                        // sphere by radius
sphere(d=diameter);                      // sphere by diameter

cylinder(h=height, r=radius);            // cylinder
cylinder(h=height, d=diameter);          // by diameter
cylinder(h=height, r1=5, r2=2);         // cone (different top/bottom radii)

$fn = 50;  // curve resolution — higher = smoother, slower to render

Transformations

translate([x, y, z]) shape;             // move
rotate([x_deg, y_deg, z_deg]) shape;    // rotate around each axis
scale([x, y, z]) shape;                 // scale (1.5 = 150%)
mirror([1, 0, 0]) shape;               // mirror across YZ plane
                                        // use [0,1,0] for XZ, [0,0,1] for XY

Boolean Operations

union() { shape1; shape2; }             // combine shapes
difference() { base; subtract; }        // remove one shape from another
intersection() { shape1; shape2; }      // keep only the overlapping region

Critical rule for difference(): always make the subtracting shape extend 0.001 mm past each shared face to avoid co-planar artifacts.

// Example — box with a through-hole:
difference() {
  cube([30, 30, 10]);
  translate([15, 15, -0.001])           // extends past bottom face
    cylinder(h=10.002, r=5, $fn=32);   // extends past top face
}

Variables and Parameters

length = 70;      // define a variable
width  = 16;
height = 5;

cube([length, width, height]);          // use variables
cube([length * 2, width, height]);      // math in expressions

Modules (Reusable Functions)

// Define:
module my_box(l=20, w=15, h=10) {
  cube([l, w, h]);
}

// Call:
my_box();               // uses all defaults
my_box(30, 20, 8);     // positional arguments
my_box(l=50);           // named argument; others use defaults

Loops

// Repeat a shape N times:
for (i = [0:4]) {                       // i goes 0, 1, 2, 3, 4
  translate([i * 20, 0, 0]) cube([15, 15, 5]);
}

// With step size:
for (i = [0:5:20]) {                    // i goes 0, 5, 10, 15, 20
  translate([i, 0, 0]) sphere(r=3);
}

2D Shapes (for Extrusion)

circle(r=10);                           // 2D circle
square([w, h]);                         // 2D rectangle
polygon([[0,0],[10,0],[5,10]]);         // arbitrary 2D shape

// Extrude into 3D:
linear_extrude(height=5) circle(r=10); // cylinder from 2D circle
linear_extrude(height=10, twist=90)    // twisted extrusion
  square([10, 5]);
rotate_extrude()                        // solid of revolution
  translate([15, 0]) circle(r=3);      // torus

Modifier Characters (Debugging — Remove Before Final Export)

Warning

Always remove all modifier characters (#, %, !, *) before exporting your final STL. Leaving them in can alter or omit geometry in the exported file.

Useful Functions

len([a, b, c])     // returns 3 — length of a vector
sqrt(25)           // returns 5
pow(2, 8)          // returns 256 (2^8)
abs(-5)            // returns 5
min(3, 5, 1)       // returns 1
max(3, 5, 1)       // returns 5

Keyboard Shortcuts

Export Workflow

1. Press F6 (full render — wait for it to complete)
2. File → Export → Export as STL
3. Save with a descriptive filename: projectname_v2.stl
4. Run 3dm info on the exported file to verify dimensions before slicing

Appendix B: Bonus Print — Extension Project

Estimated time: 3–5 hours

Overview

This extension project builds on your first successful print by introducing purposeful modification. You’ll take an existing model from an online repository, decide on a specific change that improves or adapts it for a new purpose, apply that change in OpenSCAD or the slicer, and document the entire process. The goal is to experience the design iteration cycle — make a change, understand why you made it, evaluate the result.

Learning Objectives

By completing this project, you will:

• Apply scaling and simple modifications to an existing model
• Understand how scaling affects tolerances and assembly fit
• Document design changes with enough detail that someone else could reproduce your work
• Practice logging print time, filament use, and outcome for reproducibility

Materials

• Online repository access (Thingiverse, Printables), slicer, printer, filament

Tasks

1. Choose a model from Thingiverse or Printables. Note its original stated dimensions.

2. Decide on a purposeful modification — scale it up or down, add a mounting hole, strengthen a thin feature, or combine it with another model. Write one paragraph explaining what the modification is and why you’re making it. Who benefits from this change?

3. Apply the change in OpenSCAD (preferred) or by scaling in the slicer. Record the new dimensions and what changed relative to the original.

4. Slice and print all parts in one session where possible. Log: print time, filament used (in grams), layer height, infill %, and any slicer settings you adjusted.

5. Create a short construction note: describe how the modified print is used or assembled. Photograph the result.

Probing Questions

1. What motivated the modification, and who benefits from it?
2. How did scaling affect tolerances or assembly fit? If the model connects to anything else, did the fit change?

Starter Code

If adapting a model using OpenSCAD, use this scaling scaffold as a starting point:

// Bonus Print Modification Scaffold
// Import an STL and apply modifications parametrically.

// ---- Parameters ----
scale_factor  = 1.5;    // 1.0 = original, 1.5 = 50% larger, 0.75 = 25% smaller
add_mount     = true;   // set false to skip the mount hole
mount_r       = 2.5;    // mm — mount hole radius (for M5 screw: 2.75mm)
mount_pos     = [25, 0, 0]; // mm — position of mount hole center

// ---- Base Model ----
// Replace "original.stl" with your actual file path
module base_model() {
  scale([scale_factor, scale_factor, scale_factor])
    import("original.stl", convexity=10);
}

// ---- Mount Hole (optional) ----
module mount_hole() {
  if (add_mount) {
    translate(mount_pos)
      cylinder(h=100, r=mount_r, center=true, $fn=32);
  }
}

// ---- Assembly ----
difference() {
  base_model();
  mount_hole();
}

Appendix C: Bonus Print — Student Documentation Template

Author: ________________ Date: __________ Description: Modify an existing 3D model and document the design changes and print outcomes.

Original Model

• Model name and source:
• Link or file name:
• Original stated dimensions:
• Why did you choose this model for modification?

Modification Plan

• What change will you make, and why?
• Who benefits from this modification?
• Will this be done in OpenSCAD, or by scaling in the slicer? Why?

Variant Specifications

Print Results

How Does Scaling Affect Fit?

If your model connects to anything (a wall mount, another printed part, a standard fastener), describe how the scaled dimensions affect the fit:

Original mating dimension: ____ mm → Scaled dimension: ____ mm → Fit result:

Reflections

• Which variant is most effective for its intended purpose, and why?
• How did scaling or modification affect print time and material use?
• What trade-offs did you observe (strength vs. speed, size vs. material cost)?
• If you made a third variant, what would it be?

Attachments Checklist

• .scad file with modification code (or slicer project file if scaled in slicer)
• Photos of original and modified prints side by side (if both available)
• Print log for each variant
• Completed variant specification table above

Teacher Feedback

Appendix D: Real-Life Problem Solver — Extension Project

Estimated time: 4–8 hours (design, adapt, print, and document)

Overview

This extension project asks you to do something harder than downloading and printing: identify a real problem in your life or environment, find or design a 3D-printed solution, adapt it to meet the actual constraints of that situation, and document the full process. This is the closest this course gets to professional design work at this stage — it requires a problem statement, candidate research, a design decision, iteration, and evaluation.

Learning Objectives

By completing this project, you will:

• Identify a user problem and write a problem statement that defines what success looks like
• Evaluate candidate printed solutions and choose one to adapt
• Make at least one documented design modification
• Test and measure a prototype with documented results
• Write a final report summarizing performance and next steps

Materials

• Computer with slicer and access to repositories
• Printer, filament, basic hand tools for post-processing

Tasks

1. Write a problem statement. Interview a potential user (yourself counts) and write one paragraph that describes: what the person is trying to do, what gets in their way, and what a successful solution would let them do. Be specific — “it’s inconvenient” is not a problem statement; “my headphones fall off the desk and the cable gets tangled” is.

2. Research candidate models. Search Thingiverse or Printables for at least three options that could address your problem. List all three in your documentation, explain why each could or couldn’t work, and justify your final selection.

3. Adapt the model. Make at least one modification — scale it, add or remove features, combine it with another model, or change the material or infill for durability. Document your changes in a short changelog with one entry per change.

4. Print and test. Run a supervised test of the prototype. Log any failures and what corrective actions you took. If the first print fails or doesn’t work as intended, print again with documented changes.

5. Write a final report summarizing: how well the prototype performed, measured deviations from specifications, any remaining limitations, and what you would change in the next iteration.

Probing Questions

1. What assumptions did you make about the user’s context? How could you validate those assumptions with someone other than yourself?
2. Which modification had the biggest impact on whether the part worked, and why?

Appendix E: Real-Life Problem Solver — Student Documentation Template

Author: ________________ Date: __________ Description: Adapt an existing 3D model to solve a real problem, with documented design changes and test results.

Problem Statement

Write one paragraph. Who is the user? What are they trying to do? What gets in their way? What would a successful solution let them do?

Candidate Models

Selected model: _____ Reason for selection:

Modification Changelog

Original vs. Adapted Specifications

Design Iteration Cycle

Print 1

• Date:
• Settings (layer height, infill, supports):
• Result:
• Issues observed:
• Next action:

Print 2 (if made)

• Date:
• What changed from Print 1:
• Result:
• Issues resolved / remaining:

Test Results

How did you test whether the prototype solves the problem? What did you observe?

• Test method:
• Did the prototype succeed? Yes / Partially / No
• Any deformation, failure, or fit issues?
• User feedback (if you had a second person try it):

Reflections

What worked:

What didn’t work:

What you would change in iteration 3:

What this taught you about the gap between a design on screen and a physical object that works in real life:

Accessibility Considerations

• How would you describe this modified design to someone who cannot see it?
• What measurements or tactile features would help a non-visual user understand or use the part?

Attachments Checklist

• Problem statement (one paragraph, specific)
• Three candidate models with analysis
• Modification changelog
• .scad or .stl files for each iteration
• Photos of each printed iteration
• Test results documentation
• Final report (performance summary and next steps)

Teacher Feedback

Resubmission: attach a paragraph explaining what was changed and why. Resubmission score replaces original.

Appendix F: Real-Life Problem Solver — Instructor Reference

Project Context

This is the most demanding extension project in Lessons 1–2. It requires students to work through a full design loop: problem definition → research → selection → modification → testing → evaluation. The quality of the outcome depends heavily on the quality of the problem statement — students who write a vague problem statement produce vague designs. Front-load the problem statement review.

Key Learning Points to Reinforce

A problem statement is not a solution. Students tend to jump to “I want to print a phone stand” without explaining why. The problem statement should describe a situation and a gap, not a predetermined output. “My phone falls off my desk and I can’t see notifications while working” is a problem statement. “I want a phone stand” is a solution.

A changelog creates accountability. Every design change should have a reason. Students who change things without documenting why have no basis for evaluating whether the change helped. Reinforce this by asking “why did you make this change?” at every iteration review.

Testing must be observable. A test that consists of “I tried it and it worked” is not documentation. Students should describe the test method (how many times, under what conditions, measured how), not just the result.

Constraints (Enforce These)

• Problem statement must be written before model selection
• At least one print iteration is required — first-attempt submissions are not acceptable
• Changelog must have at least one entry per design change
• Test results must include an observable measurement or observation, not just a pass/fail judgment

Assessment Notes

Strong submissions show: a specific problem statement that identifies a real user, a justified model selection (not just “I found this one”), a changelog that explains the reasoning behind each change, and a test result that describes what was actually measured or observed.

Common weak areas: problem statements that are really solution statements, modification changelogs with a single vague entry, and test sections that say “it worked fine” without any specifics. Push back on all three in feedback.

Extension for advanced students: have them repeat the design loop with a second user who is different from themselves. Designing for yourself and discovering that a different person has different constraints is a powerful experience. -e

Lesson 3 — Parametric Architecture and Modular Libraries

Estimated Time: 90–120 minutes
Course: 3dMake Certification — High School Distance Learning Track

Before You Start

You can now create shapes and combine them using CSG. That’s the vocabulary. Now it’s time to learn the grammar — how to organize and generalize your code so it’s maintainable, reusable, and professional.

The difference between a beginner OpenSCAD file and a professional one isn’t usually the shapes — it’s the structure. A beginner file has magic numbers scattered throughout, the same geometry copy-pasted in three places, and no indication of what any variable is for. A professional file has clearly named parameters at the top, organized modules, validation that catches errors before they become bad prints, and code you could hand to someone else and they’d immediately understand.

This lesson introduces the complete system for professional OpenSCAD structure: modules, functions, libraries, and the DRY principle. It also covers one of the most confusing aspects of OpenSCAD for programmers coming from other languages: how variables work here is completely different from Python, JavaScript, or Java — and understanding that difference upfront will save you hours of debugging.

Learning Objectives

By the end of this lesson you will be able to:

• Understand and work with OpenSCAD’s unique “last-wins” variable scoping rules
• Write parametric modules with validated inputs using assert()
• Organize reusable geometry into library files using use and include
• Write recursive functions for mathematical and spatial computations
• Apply list comprehensions and vector operations for advanced parametric design
• Apply the DRY (Don’t Repeat Yourself) principle through modules and functions
• Use for loops, conditionals, and list comprehensions to generate repetitive geometry
• Write type-safe modules using is_number(), is_list(), and is_string()

Concept 1: How Variables Work in OpenSCAD (It’s Different)

The Most Important Thing to Understand in This Lesson

If you’ve ever programmed in Python, JavaScript, Java, or almost any other language, you have a mental model of variables that works a certain way: you assign a value, the program runs, and that variable holds that value until you change it. Variables are like buckets — you put a value in, you can read what’s in there, and you can put a new value in later.

OpenSCAD does not work this way. The difference is fundamental and will cause bugs if you misunderstand it. Let’s dig in.

How OpenSCAD Actually Works

OpenSCAD processes your file in two distinct passes:

Pass 1 — Parse: OpenSCAD reads the entire file from top to bottom, collects every variable assignment and module/function definition, and resolves what every variable equals. No geometry is created during this pass.

Pass 2 — Render: OpenSCAD creates geometry using the values that were determined in Pass 1.

This two-pass system leads to three rules that govern all OpenSCAD code:

Rule 1: There is no assignment during execution. You cannot update a variable while the geometry is being computed. Variables are set during parse time and then read during render time. “Updating” a variable mid-computation isn’t a concept in OpenSCAD.

Rule 2: The last assignment in a scope wins — everywhere in that scope. This is the most confusing rule. If you write x = 5; on line 3 and then x = 10; on line 20, the value of x is 10 everywhere in that scope — including on line 3, even though you hadn’t written the second assignment yet. It’s as if OpenSCAD reads the entire file first, decides what everything equals, and then uses those final values. Writing x = 5; echo(x); x = 10; will print 10, not 5.

Rule 3: Variables inside modules are local. A variable declared inside a module exists only within that module. The global variable with the same name is unchanged.

// COMMON MISTAKE — expecting x to change during execution
x = 5;
echo("x =", x);   // This prints 10, NOT 5 — because the last assignment wins
x = 10;

// CORRECT PATTERN — each value gets its own name
base_size    = 20;          // 20
padded_size  = base_size + 10;   // 30 — computed from base_size
doubled_size = base_size * 2;    // 40 — computed from base_size
echo(base_size, padded_size, doubled_size);  // 20, 30, 40

// MODULE SCOPE — variables inside a module are completely separate
wall_t = 3;   // global wall thickness

module demo_box(size) {
  wall_t = 1;           // This is a DIFFERENT variable — local to this module
  cube([size, size, wall_t]);   // uses the local wall_t = 1
}

demo_box(20);
echo("Global wall_t is still:", wall_t);  // Still 3 — unchanged by the module

// CHOOSING BETWEEN VALUES conditionally — use a ternary expression
mode = "large";
box_size = (mode == "large") ? 40 : 20;   // If mode is "large", 40; otherwise 20
cube([box_size, box_size, 5]);

What This Means in Practice

Because you can’t update a variable during execution, you can’t accumulate a total like total = total + item. Instead, you describe relationships between values mathematically. If the width of your inner wall depends on the outer wall and the wall thickness, you write that as a formula: inner_width = outer_width - 2 * wall_t;. The system computes the value once, and that value is used everywhere.

This is actually quite elegant once you adjust to it. You’re writing equations, not instructions. Each variable is defined once and means exactly one thing.

For cases where you genuinely need to choose between values or compute something iteratively, OpenSCAD provides ternary expressions (condition ? value_if_true : value_if_false), recursive functions, and list comprehensions — all covered in this lesson.

Step 1 — Modules: Named, Reusable Geometry

What a Module Is

A module is a named, reusable piece of geometry. When you find yourself writing the same shape code in multiple places, that’s the signal to create a module. Modules accept parameters — just like functions in other languages — so you can write one module that creates many different variations of the same shape.

The syntax is:

module name(param1, param2=default_value) {
  // geometry code here
  // uses param1 and param2
}

Parameters with default values (param2=default_value) are optional — callers can omit them and the default will be used. Parameters without defaults are required.

You call a module just like a statement:

name(value1, value2);

The DRY Principle

Tip

DRY — Don’t Repeat Yourself. If geometry is defined in one module, changing it once updates everywhere it’s used. Copy-pasting the same geometry multiple times means one missed update creates inconsistency across your design.

If you need four mounting holes in a plate, you could write the cylinder code four times — once for each hole. But now if you need to change the hole size, you have to change it in four places. If you miss one, your design is inconsistent. If you need to add a fifth hole later, you have to remember the pattern and paste it again.

The DRY approach: write a module mounting_hole(r, depth) once, then call it four times. Now the hole geometry is defined in exactly one place. Change it once, every hole updates. Add more holes as easily as one line each.

// WRONG — copy-pasted, hard to maintain
difference() {
  cube([60, 40, 5]);
  translate([5,  5,  -0.001]) cylinder(r=2, h=5.002, $fn=16);
  translate([55, 5,  -0.001]) cylinder(r=2, h=5.002, $fn=16);
  translate([5,  35, -0.001]) cylinder(r=2, h=5.002, $fn=16);
  translate([55, 35, -0.001]) cylinder(r=2, h=5.002, $fn=16);
}

// CORRECT — DRY: one module, used multiple times
module mounting_hole(r=2, depth=5) {
  // The 0.001 offsets prevent co-planar face problems (Lesson 2)
  translate([0, 0, -0.001])
    cylinder(r=r, h=depth + 0.002, $fn=16);
}

difference() {
  cube([60, 40, 5]);
  translate([5,  5,  0]) mounting_hole();
  translate([55, 5,  0]) mounting_hole();
  translate([5,  35, 0]) mounting_hole();
  translate([55, 35, 0]) mounting_hole();
}

The second version is easier to read, easier to change, and scales effortlessly. If you need a larger hole, change r=2 to r=3 in one place, and all four holes update.

Step 2 — assert() for Parameter Validation

Why Your Modules Should Validate Their Inputs

In a parametric design, other people (and future-you) will change parameter values. What happens if someone sets wall_thickness = 0? Or cylinder_radius = -5? Depending on the code, it might silently produce garbage geometry, or it might produce a cryptic error that doesn’t explain what went wrong.

assert() is OpenSCAD’s built-in validation statement. It takes a condition and an optional message. If the condition is false, OpenSCAD stops rendering immediately and displays your message in the console. This is vastly better than allowing invalid values to silently produce a broken model.

Think of assert() as making your design constraints machine-enforceable. Instead of just knowing that wall_t must be at least 1.2 mm for a 0.4 mm nozzle, you write it as an assertion and the tool enforces it automatically.

How assert() Works

assert(condition, "message if condition is false");

If condition evaluates to true, nothing happens — the code continues normally. If condition is false, the render stops and the message is printed. The message should be descriptive enough that anyone reading it immediately understands what went wrong.

module safe_cylinder(r, h, fn=32) {
  // Validate all inputs before creating any geometry
  assert(is_num(r) && r > 0,
    str("safe_cylinder: radius must be a positive number, got: ", r));
  assert(is_num(h) && h > 0,
    str("safe_cylinder: height must be a positive number, got: ", h));
  assert(fn >= 3,
    str("safe_cylinder: fn must be at least 3, got: ", fn));
  assert(r < 500,
    str("safe_cylinder: radius ", r, "mm seems wrong — did you enter cm instead of mm?"));

  cylinder(r=r, h=h, $fn=fn);
}

safe_cylinder(5, 20);          // fine
// safe_cylinder(-3, 20);      // STOPS: "radius must be a positive number, got: -3"
// safe_cylinder(5, 20, fn=1); // STOPS: "fn must be at least 3, got: 1"

The str() function assembles a string from multiple values — very useful for error messages that include the bad value so the user knows exactly what to fix.

Tip

Add assert() statements to every module at the very top of the module body, before any geometry. This turns bad-input problems into clear, descriptive messages instead of mysterious rendering failures.

Step 3 — Library Files: use vs. include

Organizing Code Across Multiple Files

Once you have a collection of useful modules — mounting holes, standoffs, snap clips, text labels — you’ll want to reuse them across multiple projects without copy-pasting them every time. The solution is a library file: a separate .scad file containing only module and function definitions, which you can import into any project.

There are two ways to load a library:

use <filename.scad> — imports only the module and function definitions from the file. Any top-level geometry statements in the file (bare cube(), cylinder(), etc.) are not executed. This is almost always what you want: you want the tools, not any leftover test geometry the library file might contain.

include <filename.scad> — executes the entire file, including any top-level geometry statements. If the library file has a cube([10,10,10]); at the top level, that cube will appear in your model. Use this sparingly and intentionally.

Note

use <file.scad> imports only module/function definitions — top-level geometry in the file is ignored. include <file.scad> executes the entire file including any top-level geometry. Prefer use for libraries to avoid unexpected geometry.

// === lib/hardware.scad ===
// A reusable hardware library. Load with: use <../lib/hardware.scad>

module m3_bolt_hole(depth=10, countersink=false) {
  // M3 clearance hole: 3.4mm diameter (ISO standard M3 clearance)
  assert(depth > 0, "m3_bolt_hole: depth must be positive");
  translate([0, 0, -0.001]) {
    cylinder(d=3.4, h=depth + 0.002, $fn=16);
    if (countersink) {
      // Add a countersunk cone for flat-head screws
      translate([0, 0, depth - 2.5])
        cylinder(d1=3.4, d2=7.0, h=3, $fn=32);
    }
  }
}

module m3_standoff(height=5, outer_d=6) {
  // Hollow cylindrical standoff with M3 hole through center
  assert(height > 2, "m3_standoff: height must be > 2mm");
  difference() {
    cylinder(d=outer_d, h=height, $fn=16);
    m3_bolt_hole(depth=height);  // Modules can call other modules from the library
  }
}

// === src/main.scad ===
use <../lib/hardware.scad>   // loads definitions; no top-level geometry executes

// Place M3 standoffs at all four corners of a mounting plate
cube([60, 40, 5]);
for (pos = [[5,5], [55,5], [5,35], [55,35]]) {
  translate([pos[0], pos[1], 0])
    m3_standoff(height=8);
}

Structuring a Good Library

A well-organized library groups related modules, documents each one, and validates inputs. Here’s a template:

// ============================================================
// fasteners.scad — Parametric fastener library
// Usage: use <fasteners.scad>
// All dimensions follow ISO metric standards.
// ============================================================

module m3_hole(depth=10) {
  // M3 clearance hole: 3.2mm diameter
  cylinder(r=1.6, h=depth + 0.001, $fn=16);
}

module m4_hole(depth=10) {
  // M4 clearance hole: 4.3mm diameter
  cylinder(r=2.15, h=depth + 0.001, $fn=16);
}

module m3_nut_trap(extra_depth=0) {
  // M3 hex nut trap: 6.4mm across-flats, 2.4mm thick
  cylinder(r=3.2, h=2.4 + extra_depth, $fn=6);  // $fn=6 makes a hexagon
}

Step 4 — for Loops and Conditionals

Repeating Geometry with for

OpenSCAD’s for loop iterates over a list or range and creates geometry for each iteration. Each iteration is independent — you can’t pass values between iterations. But you can create geometry in each one.

Three forms:

for (variable = list) — iterates over every element in a list.

for (variable = [start : end]) — iterates over a range with a step of 1. [0:5] gives 0, 1, 2, 3, 4, 5.

for (variable = [start : step : end]) — iterates over a range with a specified step. [0:45:315] gives 0, 45, 90, 135, 180, 225, 270, 315.

// Place pegs at four specific positions
peg_positions = [[0,0], [20,0], [40,0], [20,20]];

for (pos = peg_positions) {
  translate([pos[0], pos[1], 0]) cylinder(r=3, h=10, $fn=32);
}

// Place cylinders every 45° around a circle (8 cylinders total)
for (angle = [0 : 45 : 315]) {
  rotate([0, 0, angle])
    translate([20, 0, 0])
      cylinder(r=2, h=5, $fn=16);
}

// Conditional: if show_lid is true, draw a lid
show_lid = true;
if (show_lid) {
  translate([0, 0, 30]) cube([50, 30, 3]);
}

Evenly spacing around a circle: If you want N objects evenly spaced, the angular step is 360 / N. For 12 objects, that’s 30° each. Use [0 : 360/N : 360 - 360/N] to avoid duplicating the first position at 360°.

Using for with Multiple Variables

You can use multiple for clauses in a single statement to create grids:

// 4×4 grid of cylinders — nested for in a single statement
for (x = [0:3], y = [0:3]) {
  translate([x * 20, y * 20, 0]) cylinder(r=3, h=5, $fn=16);
}

This is equivalent to two nested for loops but more compact.

Step 5 — Recursive Functions

Why OpenSCAD Needs Recursion

Most programming languages let you write a loop that accumulates a value: total = 0; for item in list: total += item. OpenSCAD doesn’t allow this — variables are fixed after parse time. So when you need to compute something iteratively, you use recursive functions.

A recursive function is one that calls itself with a smaller version of the problem. Every recursive function has two parts:

The base case — the input is simple enough to handle directly, so return an answer without recursing.

The recursive case — reduce the problem slightly and call yourself with the smaller version, then combine the result.

Functions vs. Modules — A Critical Distinction

Before we look at examples, there is an important rule in OpenSCAD that trips up almost every programmer coming from other languages:

Functions return values (numbers, strings, lists). They cannot create geometry.

Modules create geometry. They cannot return values.

Important

This is a hard boundary in OpenSCAD: Functions return values — they cannot create geometry. Modules create geometry — they cannot return values. A function with a cylinder() call inside it won’t work, and a module cannot return a value.

// FUNCTION — computes and returns a value
// This is a function because it's defined with "function" and uses "="
function factorial(n) = (n <= 1) ? 1 : n * factorial(n - 1);

echo(factorial(5));   // prints 120
echo(factorial(0));   // prints 1

// Another function: Fibonacci sequence
function fib(n) = (n <= 1) ? n : fib(n-1) + fib(n-2);

// Use the function to space pegs with Fibonacci spacing
// fib(2)=1, fib(3)=2, fib(4)=3, fib(5)=5, fib(6)=8, fib(7)=13, fib(8)=21, fib(9)=34
for (i = [2:9]) {
  translate([fib(i) * 4, 0, 0])
    cylinder(r=1.5, h=5, $fn=16);
}

// A useful function: generate N evenly-spaced values between start and stop
function linspace(start, stop, n) =
  (n <= 1)
    ? [start]
    : concat([start], linspace(start + (stop - start) / (n - 1), stop, n - 1));

positions = linspace(0, 50, 6);   // evaluates to [0, 10, 20, 30, 40, 50]
echo("Positions:", positions);

for (p = positions) {
  translate([p, 0, 0]) sphere(r=2, $fn=16);
}

Reading a Recursive Function

The factorial function works like this:

• factorial(5) → is n <= 1? No. → return 5 * factorial(4)
• factorial(4) → is n <= 1? No. → return 4 * factorial(3)
• …and so on until…
• factorial(1) → is n <= 1? Yes. → return 1

Then the chain unwinds: 1 * 2 * 3 * 4 * 5 = 120.

The ternary expression (condition) ? value_if_true : value_if_false is the standard way to write the base-case branch in OpenSCAD functions.

Step 6 — List Comprehensions

What a List Comprehension Is

A list comprehension is a compact way to generate a list by applying an expression to every element of a range or existing list, optionally filtering elements. Instead of writing a loop that builds a list step by step, you describe the entire list in one expression.

The syntax:

[for (variable = range_or_list) expression]
[for (variable = range_or_list) if (condition) expression]

List comprehensions are OpenSCAD’s answer to the fact that you can’t use for loops to accumulate values. If you need a list of computed values, a comprehension gives you the entire list at once.

// Generate heights: [5, 10, 15, 20, 25]
heights = [for (i = [1:5]) i * 5];
echo(heights);   // [5, 10, 15, 20, 25]

// Generate 8 evenly-spaced positions along the X axis
positions = [for (i = [0:7]) [i * 12, 0, 0]];
for (pos = positions) {
  translate(pos)
    cylinder(h = 5 + pos[0] * 0.3, r=3, $fn=16);  // height increases with X position
}

// Filter: generate only even numbers from 0 to 18
evens = [for (i = [0:9]) if (i % 2 == 0) i * 2];
echo(evens);   // [0, 4, 8, 12, 16]

// 2D grid of points — nested comprehension generates a flat list of [x,y,0] vectors
grid = [for (x = [0:3]) for (y = [0:3]) [x * 20, y * 20, 0]];
for (pt = grid) {
  translate(pt) cylinder(r=2, h=8, $fn=16);
}

List comprehensions are the preferred way in OpenSCAD to generate lists of positions, sizes, or other computed values that drive the placement of geometry. Master them and you’ll be able to generate complex repetitive patterns with very compact code.

Step 7 — Vector Math and Math Functions

Working with Vectors

Positions and dimensions in 3D space are naturally expressed as vectors — lists of three numbers representing X, Y, and Z. OpenSCAD supports arithmetic directly on vectors, which makes geometric calculations much more readable.

v1 = [10, 20, 5];
v2 = [3, 4, 0];

sum    = v1 + v2;    // [13, 24, 5]  — add matching components
diff   = v1 - v2;    // [7,  16, 5]  — subtract matching components
scaled = v1 * 2;     // [20, 40, 10] — multiply each component by a scalar
dot    = v1 * v2;    // 110          — dot product: v1·v2 = 10*3 + 20*4 + 5*0
length = norm(v1);   // ≈ 22.9       — Euclidean length (√(10² + 20² + 5²))

Important Math Functions

abs(-5)         // 5    — absolute value
ceil(3.2)       // 4    — round up to nearest integer
floor(3.8)      // 3    — round down to nearest integer
round(3.5)      // 4    — round to nearest integer
max(3, 7, 2)    // 7    — largest of all arguments
min(3, 7, 2)    // 2    — smallest of all arguments
pow(2, 8)       // 256  — 2 raised to the power 8
sqrt(144)       // 12   — square root

>[!IMPORTANT]
>OpenSCAD trigonometry uses **degrees, not radians**. `sin(90)` = 1 (correct). If you pass radians by mistake, your geometry will be wildly wrong.

// Trigonometry — CRITICAL: OpenSCAD uses DEGREES, not radians
sin(90)         // 1    — sine of 90 degrees
cos(0)          // 1    — cosine of 0 degrees
tan(45)         // 1    — tangent of 45 degrees
atan2(1, 1)     // 45   — arctangent of y/x, safe for all quadrants

The atan2(y, x) function deserves special attention. When you need to convert a (x, y) position to an angle, the naive approach atan(y/x) fails when x is zero or negative (wrong quadrant). atan2(y, x) handles all cases correctly by taking both components separately.

Step 8 — Controlling Curve Quality with $fn, $fa, $fs

Why You Need to Think About This

Spheres, cylinders, and circles in OpenSCAD are approximations — they’re actually polygons with many flat faces. The more faces, the smoother the curve looks, but the longer the render takes and the larger the file.

$fn (facets number) — sets the exact number of faces. $fn=8 gives a rough octagon. $fn=64 gives a very smooth circle. Setting it on a single shape overrides the global value for that shape only.

$fa (minimum angle per face) — the smaller this is, the more faces large curves get. Default: 12°.

$fs (minimum face size in mm) — very small features automatically use more faces. Default: 2 mm.

When all three are specified, OpenSCAD uses whichever produces the most faces.

// During development: low $fn for fast rendering
sphere(r=10, $fn=8);     // rough but fast

// For final export: high $fn for smooth curves
translate([30, 0, 0])
  sphere(r=10, $fn=64);  // smooth for printing

// Set globally at the top of a file:
$fa = 5;    // max 5 degrees per face
$fs = 0.5;  // minimum 0.5mm face size (more faces on small features)

Recommended practice: set $fn=16 or $fn=24 during development for fast iteration. Use $fn=64 or higher for spheres and visible curves in the final exported file. Use $fn=32 for functional cylindrical features like bolt holes — it’s smooth enough for function without being slow to render.

Exercises

Exercise 3.1: Write a module safe_box(w, d, h, wall=2) that validates all parameters with assert() and creates a hollow box. Add a constraint that wall must be less than half of the smallest dimension.

Exercise 3.2: Create a library file lib/fasteners.scad with modules for M2, M3, and M4 bolt holes. Use use to load it in a main file and place holes at the four corners of a 60 × 40 mm plate.

Exercise 3.3: Write a recursive function sum_list(lst, i=0) that returns the sum of all elements in a list. Use it to compute the total volume of a set of cylinders.

Exercise 3.4 (Advanced): Use a list comprehension to generate a 5×5 grid of cylinders where each cylinder’s height equals row_index + col_index + 1. Use echo() to verify the maximum and minimum height values.

Quiz — Lesson 3 (15 questions)

1. What is the DRY principle and why is it important in parametric OpenSCAD design?
2. What is the difference between a module and a function in OpenSCAD?
3. What does include <library.scad> do differently from use <library.scad>? When would you use each?
4. If you write x = 5; on line 3 and x = 10; on line 20 in the same file, what is the value of x everywhere in that file? Why?
5. What does is_number() return, and give one example of when to use it in a module.
6. What does the list comprehension [for (i=[0:5:20]) i*2] evaluate to?
7. What does the echo() function do in OpenSCAD, and where does its output appear?
8. True or False: a function in OpenSCAD can contain a cylinder() call and create geometry.
9. How do you specify a default parameter value in an OpenSCAD module? Write an example.
10. What is the ternary operator in OpenSCAD? Write an example that picks a box size based on a "small" or "large" variable.
11. Write an OpenSCAD for loop that places 8 cylinders evenly spaced around a circle of radius 25.
12. What is the difference between [0:10] and [0:2:10] as OpenSCAD range expressions?
13. Explain why you might use assert() in a module rather than relying on the caller to pass correct values.
14. Describe how a recursive function works. What are the two required parts of any recursive function?
15. A library file called shapes.scad contains a module rounded_box(...) and also a top-level cube([5,5,5]);. What happens when you load it with use? What happens when you load it with include?

Extension Problems (15)

1. Create a bolts.scad library with M3, M4, and M5 clearance holes and nut traps. Use it in a test plate with one of each type.
2. Build a parametric pegboard using a for loop. Parameters: cols, rows, spacing, peg_r, peg_h. Every parameter should have an assert() validation.
3. Implement a recursive function that generates a Fibonacci sequence up to n terms and use it to space objects with Fibonacci distances.
4. Build a module that validates all its inputs using assert() and logs informational output with echo(). Document when assert() halts rendering vs. what echo() does.
5. Create two library files — one for mechanical fasteners and one for decorative shapes — and use both in one combined project.
6. Design a parametric gear profile module with teeth, module_size, and thickness parameters. Use assert() to validate that the number of teeth is at least 8.
7. Build a “shelf peg” system: a board with N parametrically positioned holes and matching pegs sized to press-fit into them.
8. Use a list comprehension to generate a spiral path of evenly-spaced points and place a small sphere at each point on the spiral.
9. Extend a fastener library with threaded insert pockets for M3, M4, and M5 heat-set inserts, with the insert dimensions as parameters.
10. Write a module that draws a text label with a surrounding rectangular border frame. Parameters: text_str, font_size, padding, border_thickness.
11. Build a parametric snap-fit lid for a rectangular box using for loops to generate evenly-spaced snap clips around the perimeter.
12. Write a module that takes a list of 3D coordinate vectors as input and draws a connecting chain of cylinders between consecutive points.
13. Create a parametric honeycomb panel module. Parameters: rows, cols, cell_r, wall_t, depth. Each cell should be a hexagonal through-hole.
14. Research the BOSL2 library (https://github.com/BelfrySCAD/BOSL2). Find two modules that solve problems you’ve encountered in this course, and write a documented example using each.
15. Design a comprehensive test suite: build 10 small parametric shapes each specifically testing a different OpenSCAD feature from this lesson. Export them all from one main file that uses a for loop.

References and Helpful Resources

• OpenSCAD User Manual — Modules — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/User-Defined_Functions_and_Modules

• OpenSCAD User Manual — For Loops and Conditionals — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/The_OpenSCAD_Language#for_loop

• BOSL2 Library Documentation — https://github.com/BelfrySCAD/BOSL2/wiki

• OpenSCAD User Manual — Include and Use — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Include_Statement

Supplemental Resources

• Programming with OpenSCAD EPUB Textbook — Chapters on modules, functions, and libraries
• CodeSolutions Repository — Worked examples for parametric architecture
• BOSL2 GitHub Repository — Comprehensive parametric library
• 3DMake GitHub Repository — Build workflow reference -e

Lesson 4 — AI-Enhanced Verification and Multimodal Feedback

Estimated Time: 90–120 minutes
Course: 3dMake Certification — High School Distance Learning Track

Before You Start

Every lesson so far has ended with “build and verify.” But what does verification actually mean? And when can you trust the result? This lesson is about that question.

The workflow you’ve been using — 3dm build followed by 3dm info — involves two types of tools: deterministic tools (which always give the same answer for the same input) and AI tools (which interpret and describe, but can be vague or wrong). Knowing the difference, and knowing which to use when, is one of the most important skills in modern digital fabrication.

Many beginners treat AI output as authoritative. When 3dm info says “a small peg-like protrusion,” they assume everything is correct. But AI descriptions can be vague, can miss features, and can be flat-out wrong about specifics. This lesson gives you a structured, layered verification approach that combines AI descriptions, deterministic tools, and your own judgment — and makes clear which tool to reach for in which situation.

Learning Objectives

By the end of this lesson you will be able to:

• Use 3dm info effectively and know its real capabilities and limitations
• Verify AI-generated OpenSCAD code systematically before printing
• Build a personal verification chain for any critical design feature
• Use 3dm preview and slicer layer view as verification methods
• Apply AI description to accessibility workflows for visually impaired makers
• Distinguish deterministic from AI-assisted validation
• Apply prompt engineering techniques for better AI design feedback
• Recognize when to trust, question, or reject AI suggestions
• Understand data privacy considerations when using cloud AI tools

Concept 1: Deterministic vs. AI-Based Validation

Two Fundamentally Different Types of Tools

When you run 3dm info after a build, you get two very different types of information in the same output. It’s critical to understand the difference.

Deterministic output comes from directly reading the geometry of the STL file — no interpretation involved. The bounding box (30.0 × 20.0 × 10.0 mm) is computed from the actual vertex coordinates in the mesh. The volume is computed from the triangle faces. These numbers are produced by a formula applied to the file, and they will be identical every time you run the command on the same file. There is no randomness, no ambiguity, no “interpretation.” If the bounding box says 30.0 mm, your model is 30.0 mm wide — full stop.

AI-based output is the natural-language description portion of 3dm info. An AI vision model “looks at” a rendered image of your model and generates a text description. This is fundamentally different: it involves interpretation, and interpretations can vary. The same model might be described as “a small peg” one time and “a narrow cylindrical protrusion” another time. The AI might miss a feature that is too small to be clearly visible. It might describe a 3.2 mm hole as “approximately 3 mm” or “roughly 3–4 mm.” The description is genuinely useful for a quick sanity check, but it is not a measurement.

The Rule That Follows from This

Always verify critical dimensions using deterministic methods first. Bounding box, volume, triangle count — these are computed from the mesh and cannot lie if the build succeeded. Only after confirming the numbers should you look at the AI description, and then only for orientation and general-shape confirmation.

Step 1 — Using 3dm info Effectively

What 3dm info Does

3dm info runs after 3dm build and produces a report about your built STL file. It always includes deterministic data (bounding box, volume, triangle count) and optionally generates an AI description by rendering the model from a specific angle.

# Standard usage — run after every build
3dm build
3dm info

# Request a description from a specific viewing angle
3dm info --view front
3dm info --view top
3dm info --view isometric

# Save the description to a log file
3dm info --output description.txt

# Windows PowerShell
3dm info | Out-File -FilePath description.txt -Encoding UTF8

# Windows CMD
3dm info > description.txt

What 3dm info Does Well

3dm info is genuinely useful for:

Overall shape identification — confirming a part is roughly the right shape. If you designed a bracket and the description says “an L-shaped bracket,” that’s a useful confirmation that the basic geometry is correct.

Relative positions — confirming which part is on top of which, or that a protrusion sticks out from the side rather than the front.

Component counting — “a base plate with four cylindrical protrusions” tells you the four pegs you expected are there and visible.

Accessibility — a student who cannot easily see a rendered 3D model can use 3dm info to get a verbal description of what they’ve built.

What 3dm info Does Poorly

3dm info is not reliable for:

Precise measurements — it cannot replace checking the bounding box or using calipers. “Approximately 10 mm” is not the same as “exactly 9.8 mm.”

Small features — features smaller than about 1–2 mm may not be clearly visible in the rendered view and might be ignored or described vaguely.

Internal geometry — walls, cavities, and internal structures that aren’t visible on the exterior surface won’t be described.

Tolerance-critical features — a 0.2 mm clearance gap that determines whether two parts fit together is invisible to visual AI.

Step 2 — The Verification Escalation Chain

A Layered Approach to Verification

When you need to confirm that your design is correct, don’t jump straight to printing. Instead, follow a layered chain of verification methods from most reliable (and fastest) to most authoritative (and slowest). Start at the top and only go further down if you need more certainty.

Level 1 — Bounding Box and Volume (always accurate)

The very first thing to check after every build. If these numbers don’t match your design intent, something is wrong and you stop here to fix it before going further.

3dm info
# Look for: Bounding Box: [expected width] × [expected depth] × [expected height] mm
# Look for: Volume: [reasonable volume] mm³

Level 2 — Slicer Layer Preview

Open build/main.stl in your slicer (PrusaSlicer, Cura, etc.) and step through layers one at a time. Each layer is a cross-section through your model at a specific height — like slicing a loaf of bread and looking at each slice. This reveals:

• Wall thicknesses that the bounding box can’t show
• Internal geometry and cavities
• Whether holes cut all the way through or stop short
• Overhanging geometry that may need supports

The slicer layer view is the best non-physical verification tool available. Use it for anything more complex than a simple box.

Level 3 — Isolate and Test a Single Module

If your full model is complex and 3dm info gives a vague or confusing description, temporarily modify your file to render only the specific module you’re trying to verify:

// Temporarily comment out everything else, render only one module
// full_assembly();     // commented out
// base_plate();        // commented out
snap_clip();            // only this renders — easier for 3dm info to describe

Build and run 3dm info on just that isolated piece. A simpler model gives more reliable AI descriptions and easier-to-check bounding boxes.

Level 4 — Physical Measurement

For anything tolerance-critical — a hole size that determines fit, a slot width for a specific component, a snap-fit clearance — print a test coupon and measure with digital calipers. Physical measurement is the ground truth. Nothing replaces it for precise fit verification.

Lesson 8 covers test coupons in detail, but the principle is simple: design a small, fast-printing test piece that includes only the critical feature you’re validating. Print it, measure it, and adjust before printing the full part.

Step 3 — A Verification Log

Creating an Audit Trail

When you verify a design feature, record which method you used and what it confirmed. This creates a professional audit trail — evidence that you thought carefully about whether your design was correct.

Here’s a simple verification log format:

DESIGN VERIFICATION LOG
Project: phone_stand_v2.scad
Date: 2026-03-10

Feature: USB-C charging slot
  Designed: 9.5mm wide × 3.5mm tall
  Level 1 — Bounding box of isolated slot_module(): 9.5 × 3.5mm ✓
  Level 2 — Slicer layer view: rectangular hole visible at Z=5–8.5mm ✓
  Level 3 (AI): "rectangular cutout, approximately 10mm wide" (too vague for precision)
  Level 4 — Calipers after first test print: 9.4mm wide (0.1mm under — acceptable) ✓

Feature: Rubber foot posts (4×)
  Designed: 3.0mm diameter × 2.0mm tall
  Level 1 — Bounding box of isolated foot_post(): 3.0 × 3.0 × 2.0mm ✓
  Level 2 — Slicer: four small protrusions visible on bottom face ✓
  Level 3 (AI): "four small round protrusions" ✓
  Level 4 — Not yet printed

This log takes a few minutes to fill in, and it demonstrates exactly the kind of professional thinking that certification assessments reward.

Step 4 — AI-Generated OpenSCAD Code: How to Verify It

AI Can Write Code, but You Must Check It

AI tools like Claude or ChatGPT can write OpenSCAD code from a plain-English description. This is a genuinely useful way to get a first draft of a design quickly. But AI-generated OpenSCAD code is frequently wrong in subtle ways. The code will look plausible, it may even build without errors, and it can still produce geometry that doesn’t match your intent or that will fail in the slicer.

The most common errors AI makes in OpenSCAD:

Forgetting the 0.001 co-planar rule. The AI writes a difference() with touching surfaces and omits the critical offset. The code looks correct, but the cut may produce rendering artifacts or non-manifold geometry.

Python-style variable reassignment. The AI writes x = 5; x = x + 1; as if variables work like Python, which doesn’t work in OpenSCAD (remember from Lesson 3: last assignment wins at parse time).

Wrong transform order. The AI reverses the order of translate() and rotate(), producing geometry in the wrong location. In OpenSCAD, transforms are applied in reverse order — rotate() then translate() is not the same as translate() then rotate().

Non-manifold geometry. The code looks correct but produces a solid that isn’t a properly sealed, watertight mesh. Slicers will reject it or produce incorrect layers.

Wrong clearance values. The AI invents plausible-sounding tolerances (like “0.1 mm clearance”) that don’t match your specific printer. Tolerances must be calibrated — they can’t be looked up in a general reference.

The AI Code Verification Checklist

Apply these checks to every piece of AI-generated OpenSCAD code before treating it as correct:

AI CODE VERIFICATION CHECKLIST
Run each check in order. Do not proceed if a check fails.

[ ] 1. SYNTAX
      3dm build → does it compile without errors?

[ ] 2. DIMENSIONS
      3dm info → does the bounding box match what you asked for?

[ ] 3. BOOLEAN OPERATIONS
      Does every difference() use the 0.001 offset rule?
      Look for: translate([*, *, 0]) inside difference()
      Should be: translate([*, *, -0.001])

[ ] 4. PARAMETER BEHAVIOR
      Change each parameter to an extreme value (minimum, maximum, zero).
      Does the model change correctly? Are there any edge cases that break it?

[ ] 5. MANIFOLD CHECK
      Open build/main.stl in your slicer.
      Are there any geometry warnings or errors?

[ ] 6. PRINT FEASIBILITY
      Are all walls at least 1.2mm thick for your nozzle size?
      Are there any overhangs steeper than 45°?
      Are all features large enough to be printable?

Step 5 — Prompt Engineering for Better AI Results

Weak Prompts Produce Weak Results

The quality of AI output depends heavily on the quality of your input prompt. A vague request produces a vague or incorrect response. A specific, structured request produces specific, actionable feedback.

Weak prompt:

Review my OpenSCAD code.

This gives the AI almost no information about what to look for. The response will be generic and may miss exactly the issues you care about.

Strong prompt:

I have an OpenSCAD model of a parametric mounting bracket with two M3 bolt holes.
Parameters: width=40, height=30, depth=8, hole_r=3.2.

Please review this code for:
1. Correct use of the 0.001 offset rule in all difference() operations
2. Manifold-safe geometry (no co-planar faces)
3. Whether hole_r=3.2mm is the correct M3 clearance hole diameter per ISO standards
4. Any parameter combinations that could produce invalid geometry

For each issue found, provide:
- Severity: critical / warning / note
- Line number (if applicable)
- Explanation of the problem
- Suggested fix

This prompt tells the AI exactly what to look for, what standard to check against, and how to format its response. The output is dramatically more useful.

Four Characteristics of a Strong Code Review Prompt

Specificity — name the design, state the parameters, describe the intent. Don’t make the AI guess what you’re trying to build.

Explicit criteria — list the specific things you want checked. If you’re worried about the 0.001 rule, say so. If you want to verify dimensional correctness, specify the intended dimensions.

Standard references — mention the standards or rules you want applied (“ISO M3 clearance hole”, “0.001 co-planar offset rule”, “minimum 1.2mm wall for 0.4mm nozzle”).

Output format request — ask for a structured response (severity, line, explanation, fix) rather than a prose paragraph.

Step 6 — Design Intent Guards with assert()

Making Constraints Automatic

In Lesson 3, you learned how to use assert() inside modules to validate parameters. You can also use assert() at the top level of your file to enforce the same constraints you’d put in your verification log. This turns manual checks into automatic ones.

// Top-level design constraints
// These run before any geometry is computed.
width  = 30;
height = 10;
wall_t = 2;

assert(width  >= 10, str("width must be >= 10mm for structural integrity, got: ", width));
assert(height >= 5,  str("height must be >= 5mm to fit standard hardware, got: ", height));
assert(wall_t >= 1.5, str("wall_t must be >= 1.5mm to print reliably with 0.4mm nozzle, got: ", wall_t));
assert(wall_t < width / 2,
  str("wall_t (", wall_t, ") must be less than half of width (", width/2, ")"));

// Geometry — guaranteed to be within valid bounds by the asserts above
difference() {
  cube([width, width, height]);
  translate([wall_t, wall_t, -0.001])
    cube([width - 2*wall_t, width - 2*wall_t, height + 0.002]);
}

Every constraint you can express as an assert() is a constraint that no longer requires manual verification. If someone changes wall_t = 0.5 (too thin to print), the build immediately stops with a clear message instead of silently producing a model that fails on the printer.

Concept 2: Privacy and AI Tools

What Happens to Files You Upload

When you use cloud-based AI tools — including the 3dm info AI description feature when it connects to a cloud model, or an external AI chat like Claude or ChatGPT — your files and prompts are processed on remote servers. Depending on the service and its privacy policy, that data may be:

• Used to improve the AI model (potentially meaning others could see examples from your session)
• Stored for a period of time
• Subject to the provider’s legal obligations in their jurisdiction

For classroom learning projects, this is generally a non-issue — there’s nothing sensitive about learning how to make a parametric box. But if you’re ever working on a design that represents real intellectual property (a product idea, a client’s design, proprietary measurements), you need to understand what you’re sending and to whom.

Best practices for privacy-sensitive work:

• Check the AI service’s data retention policy before uploading
• Simplify or abstract the design before sending for review (remove specific dimensions, replace proprietary shapes with generic approximations)
• Use local/offline tools for final verification of sensitive designs — the bounding box and slicer checks don’t require network access

For the purposes of this certification course, all your projects are learning work and standard cloud AI tools are appropriate. But developing the habit of thinking about this now is professional practice.

Validation Type Summary

Quiz — Lesson 4 (15 questions)

1. What does 3dm info do? What two fundamentally different types of information does it provide?
2. What is the key difference between deterministic validation and AI-based validation?
3. Give two specific examples of information that 3dm info’s AI description cannot reliably provide.
4. In the verification escalation chain, which level provides “ground truth” for dimensional accuracy, and why?
5. List three common errors that AI tools make when generating OpenSCAD code.
6. True or False: the bounding box reported by 3dm info might be slightly different each time you run it on the same file.
7. What data privacy concern should you consider before uploading a proprietary design to a cloud AI service?
8. What does the slicer layer view let you verify that the bounding box cannot show?
9. What two characteristics distinguish a strong AI code review prompt from a weak one?
10. If an AI describes your model as “a small cylindrical protrusion” and you designed it as 3.2 mm in diameter, why is this description insufficient for print verification?
11. What is “prompt engineering” and why does it matter when asking an AI to review OpenSCAD code?
12. Write an assert() statement that ensures a variable called layer_height is between 0.05 mm and 0.4 mm.
13. What is the advantage of using assert() at the top of a file compared to manually checking parameter values before every build?
14. Describe one scenario where AI validation would be genuinely useful and one where you must rely on deterministic tools instead.
15. A classmate says “the AI said my model looked fine, so I sent it to print.” What is wrong with this approach, and what should they have done instead?

Extension Problems (15)

1. Design a five-item verification checklist for a new 3D printed part. Include items that are deterministic and items that benefit from AI assistance. Label each.
2. Build a “prompt library” for three common design review scenarios (mounting bracket, enclosure with lid, text embossing). Test each prompt against an AI tool and document the output quality.
3. Run 3dm info on the same STL file five times. Document any variation in the AI description output. What does this variation tell you about using AI for precision work?
4. Create a structured accept/reject log for one full design cycle: design → verification checklist → AI review → physical test → decision to print or revise.
5. Research what “hallucination” means in the context of AI language models. Describe two specific ways an AI could hallucinate during a design review of OpenSCAD code.
6. Create a set of deliberately flawed OpenSCAD files — one with a missing 0.001 offset, one with a Python-style variable reassignment, one with a thin wall below 1.2 mm. Test whether an AI code review catches each flaw.
7. Write a one-page data privacy policy for a classroom 3D printing lab that uses cloud AI tools. What should students be required to understand before uploading files?
8. Build a “verification script” that automatically runs 3dm build, checks the exit code, runs 3dm info, and extracts the bounding box for comparison against expected values.
9. Research the difference between “AI-assisted” and “AI-automated” workflows. At what point does removing a human from the verification loop become risky in a manufacturing context?
10. Design an experiment: ask three different AI tools to review the same OpenSCAD file. Document the similarities and differences in their feedback. What does this tell you about AI reliability?
11. Build a comparison table: for five design features (bolt holes, thin walls, snap-fit gaps, embossed text, threaded inserts), identify whether AI review, slicer validation, or physical calipers is most reliable.
12. Research and document what “manifold” means in geometry. What makes a mesh non-manifold? What are the three most common causes in OpenSCAD?
13. Write a one-page explanation of the verification escalation chain written for a student in the 8th grade who has never heard of 3D printing. Use no technical jargon without defining it.
14. Create an assert() suite for a parametric box design: validate width, depth, height, wall thickness, and the relationship between wall thickness and overall size. Test it with at least three invalid parameter sets.
15. Write a short guide titled “When to Trust AI and When Not To” specifically for 3D design workflows. Include at least five specific decision rules.

References and Helpful Resources

• OpenSCAD User Manual — Manifold and Geometry Validation — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/The_OpenSCAD_Language

• Anthropic Prompt Engineering Guide — https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview

• Data Privacy — Review your AI provider’s terms of service and data retention policy before submitting proprietary design files.

• NIST AI Risk Management Framework (AI RMF 1.0) — https://www.nist.gov/system/files/documents/2023/01/26/AI%20RMF%201.0.pdf

Supplemental Resources

• 3DMake GitHub Repository — https://github.com/tdeck/3dmake
• Anthropic Prompt Engineering Overview — https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview
• NIST AI RMF — https://airc.nist.gov/Home
• PrusaSlicer Documentation — https://docs.prusa3d.com/en/
• All other reference documents are embedded as appendices below — no separate files needed.

Part 2: Extension Project and Reference Appendices

All supporting documents for Lesson 4 are included below. You do not need to open any additional files.

Appendix A: Dice, Dice, Dice — Extension Project

Estimated time: 3–6 hours

Overview

This extension project connects the verification and AI-assisted feedback skills from Lesson 4 to a physical object where design precision is directly measurable: a six-sided die. A fair die is one of the most demanding manufactured objects you can design — it requires uniform geometry, controlled mass distribution, and a randomness that can be tested statistically. The design is straightforward. The verification is where the real learning happens.

This project also inverts the lesson’s AI-skepticism lesson in a productive way: it uses AI as part of the design ideation process, then requires you to verify every claim with physical testing and statistical analysis. A die that the AI describes as “balanced and symmetric” should be tested with 100+ real rolls. If the data disagrees with the description, the data wins.

Learning Objectives

By completing this project, you will:

• Design parametric dice in OpenSCAD with controlled geometry and mass distribution
• Apply the verification chain from Lesson 4 to a physical fabrication outcome
• Test durability and randomness for small, thrown objects
• Conduct and document statistical fairness testing
• Understand how infill, wall thickness, and pip geometry affect roll behavior

Materials

• Computer with OpenSCAD and slicer
• Printer and filament (PLA recommended — easy to print and dimensionally consistent)
• A small throwing surface (book, box lid, or low-sided tray)
• Calipers if available (for dimensional verification)

Tasks

1. Design three distinct die variants in OpenSCAD using parameters (size, wall, infill_proxy, pip_depth, pip_r). Each variant must differ in at least one meaningful way — for example: different pip geometry (sunken vs. flat), different wall thickness, or different overall size. All three must be generated from the same parametric module by changing variables at the top of the file.

2. Document your design decisions. For each variant, write one short paragraph explaining which parameters you changed and why you expected that change to affect fairness or durability.

3. Print one sample of each variant. Use the same material and layer height for all three to isolate the design variable.

4. Durability test: five throws onto a soft surface for each die. Record whether any delamination, corner chipping, or pip damage is visible after testing.

5. Fairness test: roll each die at least 100 times on a consistent surface. Record every result in the roll data table (Appendix B). Compute the frequency of each face and compare to the expected 16.67%.

6. Statistical analysis: calculate the deviation from expected for each face. A die within ±3% per face on 100 rolls is performing within normal random variation. A face appearing more than 20% of the time suggests a design or print bias that warrants investigation.

Probing Questions

• How does internal infill or a hollow cavity affect mass distribution and roll randomness?
• Which parameter change had the largest effect on fairness or durability, and why do you think that is?
• If one face came up significantly more often than expected, what is the most likely physical cause?

Starter Code

// Parametric Six-Sided Die
// All critical dimensions are top-level parameters.
// Change these to create your three variants.

// ---- Parameters ----
die_size   = 16;     // mm — overall cube side length
wall       = 2.0;    // mm — wall thickness (increase for more durability)
pip_r      = 1.0;    // mm — radius of pip hemispheres
pip_depth  = 0.6;    // mm — how deep pips are pressed into the face
corner_r   = 1.2;    // mm — chamfer/rounding radius on die edges
$fn        = 32;     // curve resolution

// Verify printability
assert(wall >= 1.2,
  str("wall (", wall, "mm) is below minimum printable thickness (1.2mm)"));
assert(pip_r > 0 && pip_r < die_size / 6,
  str("pip_r (", pip_r, "mm) is unreasonable for this die size"));
assert(pip_depth < wall,
  str("pip_depth (", pip_depth, "mm) must be less than wall (", wall, "mm)"));

// ---- Pip Positions (for each face, relative to face center) ----
// Each face is a list of [x, y] offsets from center, in pip-spacing units.
// spacing = die_size / 5 gives a comfortable pip layout.
pip_spacing = die_size / 5;

face_1_pips = [[0, 0]];
face_2_pips = [[-1, -1], [1, 1]];
face_3_pips = [[-1, -1], [0, 0], [1, 1]];
face_4_pips = [[-1, -1], [1, -1], [-1, 1], [1, 1]];
face_5_pips = [[-1, -1], [1, -1], [0, 0], [-1, 1], [1, 1]];
face_6_pips = [[-1, -1], [1, -1], [-1, 0], [1, 0], [-1, 1], [1, 1]];

// ---- Single Pip (hemisphere subtracted from a face) ----
module pip(depth=pip_depth, r=pip_r) {
  sphere(r=r, $fn=16);
}

// ---- Pips on a face (2D positions, extruded onto face surface) ----
// This module places pips at the given positions on the +Z face of the die.
module place_pips(positions, face_z, r=pip_r, depth=pip_depth, spacing=pip_spacing) {
  for (pos = positions) {
    translate([die_size/2 + pos[0]*spacing,
               die_size/2 + pos[1]*spacing,
               face_z + r - depth])
      pip(depth, r);
  }
}

// ---- Die Body ----
module die_body() {
  // Simple cube — replace with minkowski sphere for rounded edges
  cube([die_size, die_size, die_size]);
}

// ---- Full Die with Pips Subtracted ----
module die() {
  difference() {
    die_body();

    // Face +Z (top): 1 pip
    place_pips(face_1_pips, die_size);
    // Face -Z (bottom): 6 pips (opposite of 1)
    mirror([0, 0, 1])
      place_pips(face_6_pips, 0);
    // Face +X (right): 2 pips (opposite of 5)
    rotate([0, -90, 0]) translate([0, 0, -die_size])
      place_pips(face_2_pips, die_size);
    // Face -X (left): 5 pips
    rotate([0, 90, 0])
      place_pips(face_5_pips, die_size);
    // Face +Y (front): 3 pips (opposite of 4)
    rotate([90, 0, 0]) translate([0, 0, -die_size])
      place_pips(face_3_pips, die_size);
    // Face -Y (back): 4 pips
    rotate([-90, 0, 0])
      place_pips(face_4_pips, die_size);
  }
}

die();

Notes on using this scaffold:

• To create Variant 2, change wall and pip_depth. To create Variant 3, change die_size. Keep all other parameters the same between variants so you isolate the effect.
• The assert() statements will catch unreasonable parameter combinations before rendering.
• For rounded-corner dice (more realistic feel, less edge chipping), replace die_body() with a minkowski() of a smaller cube and a sphere(r=corner_r) — see the AI code gallery in Appendix D for a worked example of this technique.

Quiz Questions (from workshop)

1. What parameter controls wall thickness in your .scad file?
2. Name one method to increase a die’s impact resistance without changing its overall size.
3. How would you test a die for randomness? What is the minimum number of rolls for a meaningful result?
4. Why might a hollow die behave differently from a solid one of the same external dimensions?
5. What is a simple visual sign of print-layer delamination on a die?
6. True or False: A perfectly fair die must have uniform weight distribution throughout, including the internal structure.
7. Describe two design approaches for rendering the face numbers: one using difference() to create sunken pips, one using linear_extrude() for raised numbers.
8. Your die lands on face 1 significantly more often than any other face in 100 rolls. Name two possible physical causes and describe how you would diagnose each.
9. If you increase infill from 15% to 50%, what is the primary effect? (A) Dramatically longer print time, same weight (B) Significantly longer print time and higher weight (C) Same weight, different surface finish. Answer: B
10. Explain why a fair die is an excellent test of manufacturing precision. How does this project connect design decisions to real-world measurable outcomes?

Appendix B: Dice, Dice, Dice — Student Documentation Template

Author: ________________ Date: __________ Description: Design parametric 3D-printed dice and test for fairness through physical testing and statistical analysis.

Design Concept

• Overall die size and material:
• How will you address uniform weight distribution in your design?
• What design details will differentiate your three variants?

Design Specifications

Variant 1 design rationale (one paragraph — what did you change and what outcome did you expect?):

Variant 2 design rationale:

Variant 3 design rationale:

Dimensional Verification

Run 3dm build then 3dm info on each variant. Record the deterministic output:

If any dimension deviates by more than 0.5 mm from die_size, investigate before printing.

Durability Test

Five throws per variant onto a soft surface (book cover, box lid, fabric).

Post-durability inspection:

• Any layer delamination visible? (Variant 1 / 2 / 3):
• Any corner chipping? (Variant 1 / 2 / 3):
• Any pip damage? (Variant 1 / 2 / 3):

Fairness Testing — Roll Results

Complete this table for your best-performing variant (or all three if time permits). Minimum 100 rolls per die tested.

Variant tested: ____ Total rolls: ____ Date: ____ Surface used: ____

Statistical Analysis

Maximum deviation from expected (the highest “Deviation” value in your table): ____ %

Interpretation:

• Deviation ≤ 3% on all faces: Normal random variation — die performs within acceptable range
• Deviation 3–5% on one face: Mild bias — investigate print quality and pip geometry
• Deviation > 5% on any face: Significant bias — design or print issue warrants redesign

Your conclusion (is this die fair within statistical tolerance?):

Most frequent face: ____ Least frequent face: ____

If the die shows bias, what physical cause do you suspect? (Pip depth on the heavy face? Bed adhesion producing a flatter bottom? Asymmetric corner rounding?):

Reflections

1. Were you surprised by the fairness test results? Did the die perform better or worse than you expected?

2. Which design parameter had the largest effect on the test outcome, and what does that tell you about the physics of the die?

3. What would you change in a fourth iteration to improve fairness?

4. What did this project teach you about the gap between a design that looks correct on screen and one that performs correctly in the physical world?

Attachments Checklist

• .scad file with parametric die module (all three variants producible from one file)
• Photo of all three printed die variants
• Raw roll data tally sheet (the actual marks for each roll)
• Completed frequency and statistical analysis table
• Dimensional verification output from 3dm info for each variant

Teacher Feedback

Appendix C: Dice, Dice, Dice — Instructor Reference

Project Context

This extension project reinforces the lesson’s central theme — trusting data over descriptions — by making the verification stakes concrete and measurable. The fairness of a printed die is something a student can test with their own hands. A die that the AI describes as “perfectly symmetric” but lands on face 1 thirty percent of the time is an immediate, visceral demonstration of why physical testing matters.

The chi-squared test is mentioned in the teacher rubric but is not required for baseline completion. Students who complete it should receive recognition for the additional rigor; students who compute simple percentage deviation are satisfying the core requirement.

Key Learning Points to Reinforce

Verification is empirical, not descriptive. The workflow mirrors Lesson 4’s verification chain directly: deterministic check (3dm info bounding box), then visual check (slicer layer view), then physical test (the roll data). A student who prints without running 3dm info first has skipped the deterministic layer.

Parametric design means one module, multiple variants. Students who create three separate .scad files (one per variant) miss the core parametric design goal. The correct approach is a single file where changing variables at the top produces each variant. This is directly assessable in the code review.

Statistical fairness has a physical explanation. When a face appears too frequently, the most common causes are: (1) pip depth asymmetry — faces with fewer/shallower pips have more mass on that face, causing it to face down more often; (2) bed adhesion flattening the bottom face slightly during printing; (3) infill asymmetry if the model origin isn’t centered. Students should be guided toward diagnosing the cause, not just noting the result.

Constraints (Enforce These)

• All three variants must be produced from a single parametric .scad file
• assert() statements must validate key parameters (wall thickness minimum, pip depth less than wall)
• Minimum 100 rolls for fairness testing — 50 rolls is not statistically meaningful
• Raw roll data (the actual tally) must be submitted, not just the summary table

Assessment Notes

Strong submissions show: roll data with a tally sheet (not just a filled-in table), a physical explanation for any bias observed, and a genuine iteration — the student changed something between variants because of a hypothesis, not randomly.

Common weak areas: Single-variant testing because “it looked fine,” statistical tables with numbers that don’t add up to 100%, and designs where pip depth equals wall thickness (causing holes through the die). The assert() in the starter code catches the last one at render time.

Extension for advanced students: A formal chi-squared goodness-of-fit test. With 100 rolls and 6 faces, the critical value at p=0.05 significance is χ² = 11.07 (5 degrees of freedom). If the computed chi-squared exceeds this value, the die has a statistically significant bias. This is a meaningful cross-curricular mathematics application.

Appendix D: AI Guidance — Advantages, Disadvantages, and Flawed Code Gallery

This appendix expands on the lesson’s AI discussion and provides concrete debuggable examples of typical AI mistakes. Use the flawed examples as debugging exercises — fix each one, then run 3dm build → 3dm info → slicer layer view to confirm the fix.

D1 — Advantages of AI in OpenSCAD Development

Rapid ideation and scaffolding. AI can convert a natural-language description into a first-draft parametric scaffold quickly. This is useful for getting a starting structure, but the generated code must always be verified — never sent directly to print.

Accessibility support. Natural-language descriptions via 3dm info make model verification more accessible to visually impaired makers who cannot rely on visual inspection of the 3D preview. AI-assisted verbal description of model geometry can substitute for visual inspection when implemented carefully.

Promptable code review. A well-structured prompt asking an AI to review OpenSCAD code for boolean pitfalls, coplanar faces, and thin walls can catch issues that a visual scan might miss — as long as you verify any issues it raises rather than trusting its “all clear.”

Iteration speed. AI can propose parameterizations and printability tips rapidly, letting you evaluate more design directions before committing to print. The key is that you verify deterministically; AI accelerates the ideation, not the verification.

D2 — Disadvantages and Risks

Non-determinism. The same prompt given twice may produce different answers. AI is not a source of truth for design specifications or dimensional requirements.

No geometric guarantees. AI generates descriptions based on inference from rendered images or code text — it does not compute solid geometry. It can describe a model as correct that has non-manifold geometry or zero-thickness walls that will fail in the slicer.

Standards and tolerances gaps. AI may suggest clearances, wall thicknesses, or print settings that contradict established practice for your specific printer and material. Always check AI suggestions against the lesson’s reference values.

Hallucinations. AI tools sometimes generate code using functions that do not exist in OpenSCAD, such as rounded_cube(), fillet3d(), or bevel_edge(). These functions will cause a compile error if you attempt to use them. The AI is not aware it has invented them.

Privacy and IP exposure. Cloud AI tools may retain uploaded files or use them for training data, depending on their terms of service. Before uploading a design file to any cloud AI service, check the provider’s data retention and privacy policy. In a classroom context, no personally identifiable or commercially sensitive designs should be uploaded without explicit instructor approval.

D3 — Flawed AI-Generated OpenSCAD — Debugging Gallery

Use each example below as a debugging exercise. Identify the flaw, fix it, and verify the fix with 3dm build followed by 3dm info.

Example 1: Hallucinated Convenience Function

The AI claims OpenSCAD has a rounded_cube() built-in. It does not.

// ❌ FLAWED — rounded_cube() does not exist in OpenSCAD
module enclosure() {
  rounded_cube(size=[60, 40, 20], r=3);
  translate([10, 10, 0]) cylinder(h=20, r=2, center=false);
}
enclosure();

Fixed version — use minkowski() with a sphere() instead:

// ✅ CORRECT — native minkowski approach for rounded corners
module rounded_box(x=60, y=40, z=20, r=3) {
  minkowski() {
    cube([x - 2*r, y - 2*r, z - 2*r]);
    sphere(r=r, $fn=32);
  }
}
rounded_box();

What to learn from this: If an AI gives you OpenSCAD code that uses a function name you haven’t seen before, look it up in the OpenSCAD documentation before using it. A compile error at render time is the warning sign.

Example 2: Coplanar Boolean (Missing 0.001 Offset)

When the subtracted shape shares an exact face with the outer shape, some renderers produce Z-fighting artifacts and unreliable geometry.

// ❌ FLAWED — bottom faces are coplanar (Z=0 on both shapes)
difference() {
  cube([30, 30, 10]);
  translate([5, 5, 0]) cube([20, 20, 10]);
}

Fixed version — extend the subtracted shape by 0.001 mm past each coplanar face:

// ✅ CORRECT — 0.001 overshoot on both Z faces
difference() {
  cube([30, 30, 10]);
  translate([5, 5, -0.001]) cube([20, 20, 10 + 0.002]);
}

What to learn from this: Any time a difference() subtraction should go all the way through a face, add a 0.001 mm overshoot. This is a mechanical rule, not an approximation — apply it consistently.

Example 3: Wrong Transform Order (Misplaced Holes)

Rotate-then-translate and translate-then-rotate produce different results. AI often gets this wrong.

// ❌ FLAWED — rotate applied before translate; hole ends up in wrong position
module bracket(width=40, height=20, th=3, hole_r=3) {
  difference() {
    cube([width, th, height]);
    translate([width/2, th/2, height/2])
      rotate([90, 0, 0])
        cylinder(h=th, r=hole_r, center=true);
  }
}
bracket();

Fixed version — the translate sets the center, then the rotate orients correctly:

// ✅ CORRECT — translate to center, then rotate into the correct plane
module bracket(width=40, height=20, th=3, hole_r=3) {
  difference() {
    cube([width, th, height]);
    translate([width/2, th/2, height/2])
      rotate([90, 0, 0])
        cylinder(h=th + 0.002, r=hole_r, center=true);
  }
}
bracket();

What to learn from this: Always check hole placement in the slicer layer view. The AI’s code may look syntactically correct but produce geometry that is correct only for a specific, unverified set of assumptions about how transforms compose.

Example 4: Procedural Variable Reassignment

OpenSCAD is a declarative language — variables are not mutable. AI trained on Python, JavaScript, or other imperative languages sometimes generates code that assumes variables can be updated.

// ❌ FLAWED — OpenSCAD does not allow reassignment of variables
width = 60;
width = width + 10; // This silently uses the LAST assignment; the first is ignored
cube([width, 20, 10]);

Fixed version — use distinct names for derived values:

// ✅ CORRECT — derive a new variable from the base value
base_w  = 60;
final_w = base_w + 10;
cube([final_w, 20, 10]);

What to learn from this: In OpenSCAD, a variable that appears assigned twice will use the last assignment for the entire file — including places that appear before the second assignment in the code. This is a source of subtle bugs. Always use a new name for derived values.

Example 5: Unsafe Parameter Limits (Geometry Inversion)

AI-generated modules often lack parameter validation. When given edge-case values, the geometry inverts silently.

// ❌ FLAWED — no validation; wall=12 on a w=20 box inverts the geometry
module box(w=30, d=30, h=20, wall=3) {
  difference() {
    cube([w, d, h]);
    translate([wall, wall, -0.001])
      cube([w - 2*wall, d - 2*wall, h + 0.002]);
  }
}
box(w=20, d=20, h=15, wall=12); // wall larger than half the width — silent failure

Fixed version — add assert() to catch invalid combinations:

// ✅ CORRECT — assert() catches invalid parameters before geometry is computed
module box(w=30, d=30, h=20, wall=3) {
  assert(w > 0 && d > 0 && h > 0, "All dimensions must be positive");
  assert(wall > 0 && wall < min(w, d) / 2,
    str("wall (", wall, "mm) must be less than min(w,d)/2 = ", min(w,d)/2, "mm"));
  difference() {
    cube([w, d, h]);
    translate([wall, wall, -0.001])
      cube([w - 2*wall, d - 2*wall, h + 0.002]);
  }
}
box(w=20, d=20, h=15, wall=12); // will halt with a clear error message

What to learn from this: assert() is your safety net for parametric designs. Any relationship between parameters that could produce invalid geometry should have an assert() checking it. This is especially important for designs you share with others.

Example 6: Hallucinated Text Function + Misplaced Emboss

Two compound errors: a function that doesn’t exist (fillet_text()), and a text position that extends outside the model face.

// ❌ FLAWED — fillet_text() does not exist; second translate puts text outside the body
difference() {
  cube([80, 40, 6]);
  translate([0, 0, 0])
    fillet_text("RYAN", size=10, radius=1); // bogus function
  translate([70, 20, 3])
    linear_extrude(2) text("RYAN", size=10); // misplaced — extends off the edge
}

Fixed version — use standard text() with linear_extrude(), centered on the face:

// ✅ CORRECT — centered debossed text using standard OpenSCAD functions
module top_deboss(txt="RYAN", size=10, depth=1) {
  translate([40, 20, 6 + 0.001])  // position at center of top face
    linear_extrude(height=depth)
      text(txt, size=size, halign="center", valign="center");
}

difference() {
  cube([80, 40, 6]);
  top_deboss();
}

What to learn from this: Text positioning requires knowing the face center, not just a rough location. Use halign="center" and valign="center" with a translate to the face center. The 0.001 mm overshoot on the Z translate ensures the subtracted text breaks through the face cleanly.

Example 7: Zero Clearance on a Fitted Lid

AI-generated box and lid designs often omit clearance, making the lid impossible to remove after printing.

// ❌ FLAWED — zero clearance means the lid walls will fuse to the box walls
module box_outer(sz=[60, 40, 20], wall=2) { cube(sz); }
module box_inner(sz=[60, 40, 20], wall=2) { cube([sz[0]-2*wall, sz[1]-2*wall, sz[2]]); }

difference() {
  box_outer();
  translate([2, 2, -0.001]) box_inner(); // clearance = 0; lid won't come off
}

Fixed version — add a clearance parameter to the socket dimensions:

// ✅ CORRECT — clearance creates the physical gap needed for the lid to fit and move
module box_with_clearance(w=60, d=40, h=20, wall=2, clr=0.25) {
  assert(clr > 0 && clr < 1.0, "Clearance should be between 0 and 1mm for most FDM fits");
  difference() {
    cube([w, d, h]);
    translate([wall + clr, wall + clr, -0.001])
      cube([w - 2*(wall + clr), d - 2*(wall + clr), h + 0.002]);
  }
}
box_with_clearance();

What to learn from this: FDM-printed parts that are designed to fit together always need clearance. A nominal 0mm gap at design time produces a stuck or impossible fit after printing. Typical clearance for a slip fit is 0.2–0.3 mm; for a press fit, 0.0–0.1 mm. This topic is covered in depth in Lesson 8. -e

Safety Protocols and the Physical Fabrication Interface

Estimated Time: 90–120 minutes
Course: 3dMake Certification — High School Distance Learning Track

Before You Start

Every lesson so far has been entirely digital: code on a screen, commands in a terminal, virtual geometry. Now we’re moving into the physical world. 3D printers are machines that get very hot, draw substantial electrical current, and produce airborne particles and vapors. This lesson exists because these machines are genuinely safe when you know what you’re doing, and genuinely dangerous when you don’t.

The good news is that 3D printing safety is not complicated. The hazards are well-understood, the mitigations are straightforward, and the incidents that do happen are almost always caused by ignoring simple rules. The goal of this lesson is to make sure you know the rules and understand why they exist — not just as things to memorize for a quiz, but as habits you can apply in any shop or makerspace you ever work in.

Learning Objectives

By the end of this lesson you will be able to:

• Identify and apply the Hierarchy of Controls for 3D printing hazards
• Apply fire, electrical, and fume safety protocols for FDM printing
• Understand filament-specific hazards and safe material handling
• Follow a safe printer startup, monitoring, and shutdown sequence
• Select appropriate filament materials for given projects
• Use pre-flight build scripts to estimate cost before committing to a print
• Design parts that minimize safety risks during printing

Concept 1: The Hierarchy of Controls

Why We Don’t Just “Be Careful”

When it comes to workplace and lab safety, the common advice “just be careful” is the least effective approach available. It relies entirely on individual attention, and attention is inconsistent — everyone gets tired, distracted, or hurried sometimes. Professional safety systems are designed to work even when individual attention lapses.

The Hierarchy of Controls is a framework developed by OSHA (the U.S. Occupational Safety and Health Administration) and adopted worldwide. It ranks safety strategies from most effective to least effective, and it says: apply the most effective strategy you can afford, and layer additional strategies below it.

The five levels, from most to least effective:

1. Elimination — Remove the hazard entirely. If a filament requires a sealed enclosure with active filtration and you’re in an open classroom, the safest choice is simply not to use that filament. If a print requires supports made from difficult material, redesign the print to not need supports. Elimination always wins.

2. Substitution — Replace the hazard with a less dangerous one. Use PLA instead of ABS. Use a PEI spring steel bed instead of a glass bed that can shatter. Substitution keeps the functionality while reducing the risk.

3. Engineering Controls — Build protection into the environment. A fume enclosure with a HEPA + activated carbon filter. Thermal runaway protection in the printer firmware. A smoke detector mounted above the printer. These controls work automatically without relying on human behavior.

4. Administrative Controls — Rules, procedures, and training. The startup checklist, the monitoring schedule, the training program you’re in right now. Administrative controls are less reliable than engineering ones because they depend on people following rules consistently.

5. Personal Protective Equipment (PPE) — Gloves, goggles, respirators. PPE is the last resort — it protects one person, it can fail or be used incorrectly, and it doesn’t actually remove the hazard. Always apply higher-level controls first and use PPE as a supplement.

The key insight: many beginners think that putting on gloves and goggles makes them safe. In the hierarchy, PPE is the weakest protection. Real safety comes from eliminating or substituting hazards, and then engineering the remaining risks away. PPE is what you use when those options aren’t available.

Step 1 — Fire and Electrical Safety

The Golden Rule

Never leave an FDM printer completely unattended during the first layer. Print failures most often happen at the start — the first layer either bonds to the bed or it doesn’t. If it doesn’t bond and nobody is watching, the printer may continue for hours, dragging filament across the bed in a mess called “spaghetti” that can tangle around the print head, cause jams, or — in rare worst cases — create a fire hazard.

Be present and watching for at least the first 15 minutes of every print. For long prints, check in every 30 minutes or set up remote monitoring via OctoPrint or a camera.

Fire Hazards

Fire risk in FDM printing comes from two main sources. First, electrical failure: wiring that cracks from repeated movement, loose connections at terminal blocks, or a faulty temperature sensor that allows the heater to run without limit. Second, filament accumulation: plastic that melts and collects on the hot nozzle can sometimes ignite if the build-up becomes large enough.

Fire safety protocols:

• Keep a Class ABC fire extinguisher within arm’s reach of every printer
• Never run the printer while away from the building
• Keep the print area clear of flammable materials: paper, fabric, solvent containers
• Mount a smoke detector directly above the printer so rising smoke reaches it quickly
• Know where the power switch is before you start — cutting power is the first response to any emergency
• If smoke appears: cut power immediately, do not try to continue the print, and report the incident

Electrical Safety

• Use a surge protector to protect the printer’s control board from voltage spikes
• Inspect all wiring periodically, especially the flexible cable bundle that runs to the heated bed — this bundle flexes with every print and can crack the insulation over time

Warning

Thermal runaway protection must be enabled. This firmware feature monitors the temperature sensor and shuts the heater off if the temperature climbs unexpectedly or the sensor fails. A printer without thermal runaway protection can overheat catastrophically. Never disable this protection. If your printer doesn’t have it, do not use it.

• Never open the power supply enclosure or work on any electrical component while the printer is plugged in. The power supply contains mains voltage (120V or 240V) that can kill.

Step 2 — Fume Safety

Why Fumes Matter

All FDM printing produces some airborne emissions. These fall into two categories: particulates (tiny plastic particles, especially ultrafine particles below 0.1 microns) and VOCs (volatile organic compounds — chemical vapors that off-gas from the hot plastic). Both can affect respiratory health with repeated exposure, and the risk varies significantly by material.

Warning

ABS and ASA are NOT safe for open classrooms without a dedicated fume enclosure with HEPA + activated carbon filtration. Do not print ABS or ASA in any space without proper exhaust infrastructure.

| ABS | High | Dedicated fume enclosure with HEPA + activated carbon filter required; NOT safe for open classrooms | | ASA | High | Same as ABS | | TPU | Medium | Active ventilation; keep nozzle temperature at the minimum needed | | Resin (SLA/MSLA) | Very High | Full enclosure; nitrile gloves; UV-blocking goggles; no open-workspace use |

The Safe Choice: PLA

Tip

PLA is the safest classroom filament available. Made from bio-derived sources, it prints at low temperatures (190–220°C) and produces the lowest emissions of any common FDM material. Default to PLA for any project where mechanical requirements don’t specifically demand something else.

What “Good Ventilation” Actually Means

“Good ventilation” means that the air in the room is actively exchanging with outside air. This is not the same as “a window that’s crackable.” Active ventilation means:

• A window open with a fan pulling air through the room, or
• An HVAC system that is running and moving air, not just recirculating internal air

If you’re printing ABS or ASA, room ventilation is not sufficient. You need an enclosure with a filtered exhaust system — a box around the printer with an internal fan that pulls fumes through a HEPA filter (for particles) and an activated carbon filter (for VOCs) before exhausting outside or into a large ventilated space.

Step 3 — Material Selection

Choosing the Right Filament

The right material for a project depends on what the part needs to do and where it will be used. This table gives you a practical guide:

What “Hard” to Print Actually Means

When a material is listed as “hard,” that means it requires one or more of the following: a higher nozzle temperature, a heated enclosure to prevent warping, special bed adhesion (glue stick, hairspray, specialized plates), slower print speeds, or more careful tuning of retraction settings. Starting with a difficult material before you have PLA dialed in is a recipe for frustration and wasted filament.

Tip

The practical material rule: use PLA until you have a specific functional reason not to. Need better heat resistance? Try PETG next. Reserve ABS and specialty materials for when you have the appropriate safety infrastructure.

PLA and Sustainability — A Realistic Picture

PLA is often marketed as “biodegradable” and “eco-friendly.” These claims deserve some scrutiny. PLA is bio-derived — made from fermented plant starch rather than petroleum — which reduces its carbon footprint somewhat compared to petroleum plastics. But PLA only biodegrades under very specific industrial composting conditions (temperatures above 58°C sustained for weeks). It does not break down in a home compost bin or a landfill.

The most sustainable approach to FDM printing is not any particular material — it’s designing durable parts that don’t need to be reprinted, using the minimum infill that meets your mechanical requirements, and avoiding test prints you don’t need (which is exactly why this course emphasizes verification before printing).

Step 4 — Estimating Print Cost Before You Print

Always Estimate First

Tip

Always estimate filament cost and print time before sending a model to print. For small parts the cost is trivial, but large high-infill parts can cost several dollars and several hours — time you can’t recover if the part needs revision.

The estimate formula from Lesson 1 applies here:

mass (grams)  = (volume_mm³ ÷ 1000) × filament_density_g_per_cm³
cost ($)      = mass × (spool_price_$ ÷ spool_weight_g)

The preflight scripts below automate this calculation and require you to confirm before proceeding.

Pre-Flight Cost Check Scripts

Linux / macOS (bash):

#!/bin/bash
set -e

3dm build
INFO=$(3dm info)
echo "$INFO"

# Extract volume from 3dm info output
VOLUME=$(echo "$INFO" | grep -oP '(?<=Volume:\s)\d+\.?\d*')
if [ -z "$VOLUME" ]; then
  echo "ERROR: Could not parse volume from 3dm info output"
  exit 1
fi

DENSITY=1.24    # g/cm³ — PLA density (change for other materials)
COST_PER_G=0.02 # $/g  — adjust for your spool price

MASS=$(echo "$VOLUME $DENSITY" | awk '{printf "%.1f", ($1/1000)*$2}')
COST=$(echo "$MASS $COST_PER_G" | awk '{printf "%.2f", $1*$2}')

echo ""
echo "=== PRE-FLIGHT SUMMARY ==="
echo "Volume:   ${VOLUME} mm³"
echo "Mass:     ${MASS} g  (PLA @ ${DENSITY} g/cm³)"
echo "Filament: \$${COST}  (@ \$${COST_PER_G}/g)"
echo ""
echo "Proceed? [y/N]"
read CONFIRM
if [ "$CONFIRM" != "y" ]; then
  echo "Cancelled."
  exit 0
fi
echo "Approved. Send to slicer."

Windows (PowerShell):

3dm build
$info = 3dm info
Write-Host $info

$volumeMatch = $info | Select-String -Pattern "Volume:\s+([\d.]+)"
if (-not $volumeMatch) { Write-Error "Could not parse volume"; exit 1 }
$volume = [double]$volumeMatch.Matches.Groups[1].Value

$density  = 1.24    # PLA
$costPerG = 0.02
$mass     = ($volume / 1000) * $density
$cost     = $mass * $costPerG

Write-Host ""
Write-Host "=== PRE-FLIGHT SUMMARY ==="
Write-Host ("Volume:   {0:F0} mm3" -f $volume)
Write-Host ("Mass:     {0:F1} g  (PLA)" -f $mass)
Write-Host ("`$Filament: {0:F2}" -f $cost)
Write-Host ""
$confirm = Read-Host "Proceed? [y/N]"
if ($confirm -ne "y") { Write-Host "Cancelled."; exit 0 }
Write-Host "Approved. Send to slicer."

Step 5 — The Printer Startup Checklist

Before Every Print Session

Use this checklist before starting any print. It takes about 5 minutes and prevents the most common causes of print failure.

PRINTER STARTUP CHECKLIST
□ Bed level verified (run auto-level, or manually check at all four corners)
□ Build plate clean (wipe with IPA — remove finger oils and dust)
□ Nozzle cleared (cold pull if returning from more than a day idle)
□ Filament loaded and extruding cleanly (run 50mm manual extrude purge)
□ First layer height set correctly (0.2mm gap typical for 0.4mm nozzle)
□ Print fan operational (watch it spin up at the start)
□ Workspace clear of flammable materials
□ You will remain present for the first 15 minutes of the print
□ Power switch is accessible and you know where it is

Why Each Item Matters

Important

Bed leveling is the single most critical setting for successful prints. A bed that is just 0.1 mm too high or too low can cause every print to fail. Always verify leveling before each print session. Most modern printers have automatic bed leveling (ABL), but you should still understand how it works and check that it’s running correctly.

Clean build plate prevents adhesion failures. Skin oils from touching the plate are invisible but dramatically reduce how well plastic sticks. An isopropyl alcohol (IPA) wipe before every print takes 30 seconds and prevents a common failure mode.

Cold pull (nozzle clearing) removes degraded filament from inside the nozzle. Heat the nozzle to print temperature, push some filament through, then let it cool to about 90°C and pull the filament out firmly. The end of the pulled filament should bring out any debris or degraded material from inside the hot end.

Filament loaded correctly means the extruder is feeding without clicking or skipping, the filament is straight in the Bowden tube (if present), and the purge line at the start of the print flows smoothly with no bubbles or gaps.

Step 6 — Monitoring During Prints

What to Watch For

Checking in periodically during a print takes only a few seconds each time and lets you catch problems early. A problem caught at layer 10 is a minor inconvenience. The same problem discovered at layer 100 means you’ve wasted 90 layers of material and print time.

Warning

Spaghetti is the most common print failure: the part lifts off the bed and the nozzle drags filament through the air. If you see this, pause or cancel the print immediately — catching it at layer 10 is a minor inconvenience; catching it at layer 100 wastes 90 layers of material and time.

Caution

Layer shifts (horizontal displacements in the print) usually indicate a mechanical problem — belt tension, loose pulley, or a motor skipping steps. Cancel the print and diagnose the cause before trying again.

Nozzle clog — the extruder starts making a clicking or ticking sound as the gear slips because material isn’t flowing. Filament may start grinding. Pause the print and clear the clog before restarting.

Stringing — thin wisps of filament connecting different parts of the print. Usually a retraction or temperature setting issue rather than an emergency, but it may require post-processing cleanup.

Warning

Smoke is an immediate emergency. Cut power immediately. Do not attempt to continue or diagnose while the printer is running. Notify your instructor. Do not restart the printer until the cause has been fully identified and corrected.

Step 7 — Safe Shutdown and Part Removal

The Right Way to End a Print

A print ending doesn’t mean the work is done. Follow these steps after every print:

Caution

Wait for the nozzle to cool below 50°C before reaching anywhere near the hot end. The nozzle can reach 200°C+ during printing and retains heat for several minutes after shutdown.

1. Wait for the nozzle to cool below 50°C before reaching anywhere near the hot end.

2. Wait for the bed to cool below 30°C before removing the part. Parts printed on a hot bed can warp slightly if removed while the bed is still warm. Many PEI-coated beds release parts naturally as they cool — you may not even need tools.

3. Use a spatula or palette knife to gently separate the part from the build plate. Never force parts off with your fingers — the edge of a part against a spring steel bed can cut skin. Apply the spatula at a low angle and use a gentle rocking motion.

Note

Store filament in a sealed bag with desiccant. Filament absorbs moisture (hygroscopy), causing bubbling, popping sounds, and reduced mechanical properties during extrusion. This is especially critical for Nylon and PETG. A silica gel desiccant packet in a ziplock bag is sufficient for short-term storage.

Concept 2: Design for Printability and Safety

Your Design Choices Affect Safety

The decisions you make in OpenSCAD directly affect how safe and reliable the printing process will be. Good design doesn’t just mean a part that looks right — it means a part that prints reliably without requiring dangerous materials, excessive supports, or heroic printer tuning.

Minimize overhangs. Any geometry that extends more than about 45° from vertical needs supports — temporary scaffolding that the printer adds automatically. Supports increase print time, use more material, often leave rough marks where they’re removed, and increase the risk of print failure due to tangled support material. Good design reorients parts or modifies geometry to eliminate or reduce overhangs.

Caution

Minimum wall thickness for a 0.4 mm nozzle: walls below 0.8 mm (2× nozzle width) may not print reliably, and walls below ~0.8 mm may be omitted entirely by the slicer. Use at least 1.2 mm (3× nozzle width) for any structural wall.

Use the safest material that meets requirements. If PLA is strong enough, use PLA. Don’t introduce PETG, ABS, or specialty materials unless you have a specific reason and the appropriate safety infrastructure.

Encode printability constraints in your code:

// Printability constants — these drive safe design decisions
wall_min     = 1.2;    // mm — minimum wall for 0.4mm nozzle (3× nozzle width)
hole_min_r   = 1.5;    // mm — minimum hole radius for reliable circular holes
clearance    = 0.2;    // mm — fitting clearance between mating faces
overhang_max = 45;     // degrees — maximum overhang without supports

module printable_box(w, d, h, wall=2) {
  // Validate against printability limits
  assert(wall >= wall_min, str("wall (", wall, "mm) must be >= ", wall_min, "mm"));
  assert(w > 2 * wall, "width must be greater than two wall thicknesses");
  assert(d > 2 * wall, "depth must be greater than two wall thicknesses");

  // Open-top box: no overhangs on the inside
  difference() {
    cube([w, d, h]);
    translate([wall, wall, wall])
      cube([w - 2*wall, d - 2*wall, h]);  // open at top — no overhang required
  }
}

printable_box(50, 40, 30);

Exercises

Exercise 5.1: Run 3dm info on your model from Lesson 3. Calculate the material cost in PLA and in PETG (density 1.27 g/cm³). If PLA spools cost $20/kg and PETG spools cost $25/kg, what is the cost difference for your part?

Exercise 5.2: Write a pre-flight script (bash or PowerShell) that builds your model, reports the estimated cost, and requires a y confirmation before proceeding.

Exercise 5.3 (Advanced): Modify the pre-flight script to accept a --material argument (options: pla, petg, abs, tpu) and calculate cost using the correct density for the selected material.

Quiz — Lesson 5 (15 questions)

1. What are the five levels of the Hierarchy of Controls, from most to least effective?
2. Why is Elimination considered the most effective safety control?
3. Which filament requires a dedicated fume enclosure with HEPA + activated carbon filtration and is NOT recommended for open classrooms?
4. At what temperature should you wait before removing a print from the bed?
5. What should you do immediately if you see smoke coming from your 3D printer?
6. Give three reasons why PLA is considered the safest classroom filament.
7. What is the minimum reliable wall thickness for a 0.4 mm nozzle, and why does this minimum exist?
8. What is the purpose of storing filament with desiccant?
9. True or False: It is safe to leave a 3D printer completely unattended for hours once the first layer has printed successfully.
10. What is “spaghetti” in the context of a 3D printing failure, and what causes it?
11. What is thermal runaway protection, and why is it critical that it remain enabled?
12. What are the two types of airborne emissions from FDM printing, and which filaments produce the most hazardous levels of each?
13. Describe one engineering control and one administrative control you could implement in a classroom 3D printing lab.
14. Explain why minimizing overhangs in your design is both a safety consideration and a quality consideration.
15. A student wants to print a car dashboard mount in ABS because it will be in a hot car. The classroom has no fume enclosure. Using the Hierarchy of Controls, what recommendations would you make?

Extension Problems (15)

1. Create a material selection flowchart that guides a user from mechanical requirements to the safest filament that meets them.
2. Conduct a ventilation assessment of your classroom or makerspace. Document air exchange methods, window locations, and any existing filtration.
3. Write a Standard Operating Procedure (SOP) for ABS printing that includes all required safety equipment and ventilation infrastructure.
4. Design and describe a “first layer test tile” — a 100 × 100 × 0.4 mm flat tile — and explain how you’d use it to verify bed leveling.
5. Build a parametric filament storage clip in OpenSCAD: a clip that holds the free end of a filament spool. Parameters: filament diameter, clip width.
6. Research OSHA’s published guidance on VOC exposure in 3D printing environments. Summarize the key recommendations.
7. Compare the Safety Data Sheets (SDS) for PLA and ABS filament from two manufacturers. Document differences in recommended exposure limits and PPE.
8. Design a simple printer enclosure in OpenSCAD: four walls, a front door opening, and a top panel with a circular vent hole. Document the parametric variables.
9. Create a safety poster covering the five most important 3D printing safety rules, organized using the Hierarchy of Controls framework.
10. Write a one-page risk assessment for a new FDM printer being added to a classroom.
11. Design and describe a parametric filament moisture indicator holder: a small box that holds a humidity indicator card inside a resealable filament storage bag.
12. Build a “print monitoring log” template: a paper form with columns for time, nozzle temperature, bed temperature, layer number, visual observations, and action taken.
13. Research the difference between particle emissions and VOC emissions from FDM printing. Which is considered more hazardous at typical classroom distances from the printer?
14. Design a parametric build plate corner protector: a small clip that attaches to the edge of a glass or spring steel build plate to protect it from spatula damage.
15. Write a hypothetical “near-miss incident report” for a fictional 3D printing incident using a standard workplace incident report format (date, location, description, contributing factors, corrective actions).

References and Helpful Resources

• OSHA Hierarchy of Controls — https://www.osha.gov/hierarchy-of-controls / NIOSH — https://www.cdc.gov/niosh/topics/hierarchy/default.html

• UL Research Institutes — 3D Printing Emissions Study — https://www.ul.com/news/ul-research-institutes-releases-3d-printing-emissions-study

• NIOSH Science Blog — Health and Safety Considerations for 3D Printing — https://blogs.cdc.gov/niosh-science-blog/2020/05/14/3d-printing/

• PrusaSlicer Documentation — https://docs.prusa3d.com/en/

• All3DP Filament Types — https://all3dp.com/1/3d-printer-filament-types-3d-printing-3d-filament/

• MatterHackers Filament Compare — https://www.matterhackers.com/3d-printer-filament-compare

• Prusa Research Materials Guide — https://help.prusa3d.com/materials

Supplemental Resources

• 3DMake GitHub Repository — https://github.com/tdeck/3dmake
• OpenSCAD User Manual — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual
• All other reference documents are embedded as appendices below — no separate files needed.

Part 2: Reference Appendices

All supporting documents for Lesson 5 are included below. You do not need to open any additional files.

Appendix A: Safety Checklist for 3D Printing

Complete this checklist before and after each printing session. Print it out and keep a copy at your printer station.

Pre-Print Setup

Work Area

• Desk or table cleared of unnecessary items
• Tripping hazards removed from around the printer
• Adequate ventilation confirmed (window open, fan running, or fume enclosure active)
• Class ABC fire extinguisher within arm’s reach
• Smoke detector mounted above printer is functional

Printer Inspection

• Nozzle is clean — no old filament residue baked on
• Build plate is level (re-level if the printer has been moved or bumped)
• Heated bed temperature sensor is attached and secure
• All cables are secure and none are frayed or cracked — especially the flexible bed cable bundle
• Thermal runaway protection is enabled (check firmware settings if unsure)

Filament Preparation

• Filament spool rotates freely on the holder — no binding or tangling
• Filament path is clear of obstructions from spool to extruder
• Extruder drive gear is clean — not clogged with ground plastic
• Filament is correctly loaded and primed (a few mm of filament extruded before starting)

Environmental Conditions

• Room temperature is adequate (18–25°C ideal — extreme cold slows bed heating; extreme heat can soften PLA)
• No direct drafts from windows or air conditioning blowing on the printer (drafts cause warping and layer splitting)
• Adequate lighting to clearly see the first layer as it prints

During Print

First Layer Monitoring (Do Not Leave)

• Watch the first 2–3 layers without interruption
• Bed adhesion is correct — filament sticks flat, not lifting at corners or curling
• Nozzle temperature is stable at target value
• No unusual sounds (grinding, clicking, popping)

Regular Checks (Every 15–30 Minutes)

• Print is building correctly — no layer shifting, no spaghetti
• Filament is feeding smoothly from the spool
• No grinding or skipping sounds from the extruder
• No warping visible at part edges

Temperature Stability

• Heated bed maintains consistent temperature throughout
• Nozzle temperature does not fluctuate more than ±5°C
• No thermal runaway warnings on the printer display

Stop the Print Immediately If

• The nozzle jams or extrudes unevenly
• Filament stops feeding entirely
• Any burning smell is detected
• Visible layer shifting occurs
• Grinding or skipping sounds from the extruder
• Any unusual chemical or burning odor
• Smoke appears — cut power immediately

Post-Print

Cool Down

• Allow the heated bed to cool naturally for 10–15 minutes before attempting print removal
• Keep hands clear of the nozzle until it reads below 50°C
• Confirm the printer is idle and all temperatures are dropping before touching

Print Removal

• Use a proper spatula or scraper — not fingers or improvised tools
• Remove the print only when the bed has fully cooled (PLA releases easily from PEI beds when cool)
• Inspect the print for sharp edges, support stubs, or layer delamination
• Sand or file sharp edges if the part will be handled

Equipment Cleaning

• Wipe the nozzle with a brass wire brush when cooled to 50°C (never cold — residue must be slightly soft)
• Remove any plastic debris and failed print material from the build plate
• Check the extruder for embedded filament residue
• Clear any visible dust from the electronics area

Workspace Cleanup

• Return all tools to their proper storage location
• Dispose of support material and failed prints in a bin (not on the floor)
• Store filament in a sealed bag with desiccant
• Confirm the workspace is clear and safe for the next user

Hazard Reference Summary

Emergency Actions

• Fire: Unplug immediately. Use a dry chemical (Class ABC) extinguisher — NOT water on electrical fires. Evacuate and call emergency services.
• Burns: Rinse with cool (not cold) running water for 15+ minutes. Seek medical attention for any burn larger than a coin.
• Fume inhalation: Move to fresh air immediately. Seek medical attention if symptoms (headache, dizziness, nausea) persist.

Last Reviewed: __________ Reviewed By: __________

Appendix B: Filament Comparison Table

Quick reference for choosing the right filament. All temperature values are typical ranges — always check the label on your specific spool. The spool always wins over this table.

Side-by-Side Comparison

When to Use Each Material

PLA — Use for:

• Prototypes and test prints
• Classroom projects
• Decorative objects and tactile models
• Anything that won’t be exposed to heat, moisture, or heavy mechanical stress

PLA — Avoid for:

• Objects left in a hot car or direct sun (softens above ~60°C)
• Parts that need to flex or bend without cracking
• High-impact applications

PETG — Use for:

• Functional parts that need to be tougher than PLA
• Parts exposed to mild heat or moisture
• Mechanical components: brackets, clips, mounts
• Food-contact applications (check your specific brand for food-safe certification)

PETG — Avoid for:

• Very fine surface detail (it strings more than PLA)
• Projects where you need the easiest possible first-time print

TPU / Flexible — Use for:

• Wearable objects (wristbands, phone cases, watch straps)
• Bumpers and shock absorbers
• Grips and handles
• Objects that must deform under pressure and return to shape

TPU — Avoid for:

• Fine surface detail
• Printers with Bowden extruders (the flexible filament buckles in the tube — direct drive only)
• Your first few prints while still learning

ABS — Use for:

• High-heat environments (car interiors, near motors)
• Parts requiring post-processing (ABS sands, bonds with acetone vapor, and paints easily)
• Professional or industrial contexts with proper dedicated ventilation

ABS — Avoid for:

• Any classroom without a dedicated sealed fume enclosure and active filtration
• Beginners
• Any print where warping at the edges would be a problem and you have no enclosure

Slicer Profile Quick Reference

Filament Storage

All filament absorbs moisture from the air over time. Wet filament causes: popping or crackling sounds during printing, bubbles in extruded plastic, excessive stringing, and weak or brittle finished parts.

Sources: All3DP Filament Types Guide; MatterHackers Filament Compare; Prusa Research Materials Guide

Appendix C: Material Properties Quick Reference

Essential material data for FDM/FFF printing. Use alongside the Filament Comparison Table for material selection decisions.

Properties at a Glance

Heat Resistance After Printing

This is one of the most common reasons to choose a material other than PLA.

Chemical Resistance

Acetone note: Can be used to smooth ABS surfaces (vapor or liquid application). Also dissolves PLA — keep acetone away from PLA prints and filament spools.

Strength After Printing — Curing Time

Freshly printed parts are not at full strength.

Do not stress-test functional parts immediately after printing. Allow at least 24 hours before load testing.

Storage Conditions

Quick Material Selection Guide

Appendix D: Printer Maintenance Log

Copy this log and keep a printed or digital copy with your printer. Fill in the Printer Information section first, then log every maintenance event and issue as it occurs. A complete log is your best diagnostic tool when problems arise.

Printer Information

Maintenance Schedule

Before each use (Daily)

• Visual inspection — no visible damage, cables intact
• Clean nozzle tip if residue is present
• Verify build plate is level (re-level if printer was moved)
• Confirm filament spool rotates freely with no tangles

Weekly

• Clean extruder drive gear (compressed air or brush out ground plastic)
• Inspect and wipe Z-axis rails and lead screw
• Check all cable connections at the control board
• Test emergency stop / power cut

Monthly

• Full build plate leveling procedure (manual or automatic)
• Clean interior of print chamber
• Inspect heating elements and thermistor connections
• Run a temperature calibration test print

Quarterly (every 3 months)

• Replace nozzle if inner bore shows wear or repeat clogging
• Full mechanical inspection — belt tension, eccentric nuts, frame screws
• Check firmware for updates
• Run a full calibration test print and document results

Maintenance Log

Types: Routine / Repair / Calibration / Cleaning / Part replacement

Issue Tracking Log

Statuses: Open / In progress / Resolved / Monitoring

Parts Replacement Record

Filament Compatibility Notes

Record your tested settings for each material on this specific printer. Published temperature ranges are starting points — your printer may run hotter or cooler than its display indicates.

Troubleshooting Quick Reference

Nozzle Clog

• First response: Cold pull (heat to printing temp, push filament through manually, cool to 90°C, pull sharply)
• Second response: Acupuncture needle or nozzle cleaning filament
• Last resort: Replace nozzle

Bed Adhesion Problems

• Check: Bed level, nozzle height from bed, bed surface condition (clean? worn?)
• Fix by material: PLA → clean PEI with IPA; PETG → apply glue stick; ABS → glue stick + enclosure

Layer Shifting

• Common causes: Belt too loose, motor current too low, print speed too high, X/Y axis obstruction
• Check belt tension first — it’s the most common cause

Extrusion Issues (Under-extrusion)

• Common causes: Partial clog, worn drive gear, incorrect extruder steps/mm, wet filament
• Run a flow rate test: extrude 100 mm and measure actual output

Monthly Performance Summary

Last log entry: __________ Logged by: __________ -e

Lesson 6 — Practical 3dm Commands and Text Embossing

Estimated Time: 90–120 minutes
Course: 3dMake Certification — High School Distance Learning Track

Before You Start

You’ve built solid 3D geometry, organized it into modules, learned to verify it rigorously, and understood the physical realities of printing it safely. Now we’re going to add two powerful new capabilities to your toolkit.

The first is text. Adding text to 3D parts is more useful than it might sound at first. Engineers put part numbers on manufactured components so they can be identified after assembly. Makers label storage bins so they can find what they need. Designers emboss names and logos on products. Accessibility designers create braille labels. OpenSCAD’s text() function makes all of this parametric — you can generate a hundred labeled bins automatically, make the text content a parameter, and produce variants for different languages or quantities without touching the geometry code at all.

The second is the full 3dm command suite. You’ve been using 3dm build and 3dm info. There are three more commands — preview, orient, and slice — that round out the workflow from design to print.

Learning Objectives

By the end of this lesson you will be able to:

• Use text() to add embossed and debossed labels to 3D models
• Find available fonts on your system and write portable font code
• Size text to fit a specific container using the cap-height model
• Use the full 3dm command suite: build, info, preview, orient, slice
• Use OpenSCAD string functions: str(), len(), search(), substr()
• Apply let() for scoped variable declarations
• Automate multi-variant text label generation in bash, PowerShell, and CMD

Concept 1: The Full 3dm Command Suite

Five Commands, One Workflow

You’ve been using two commands. Here’s the complete set:

# BUILD VARIANTS
3dm build                          # standard build
3dm build --clean                  # delete build/ folder first, then rebuild
3dm build --watch                  # auto-rebuild when src/ files change

# INFORMATION AND DESCRIPTION
3dm info                           # bounding box, volume, triangle count, AI description
3dm info --file path/to/file.stl   # query a specific STL (not just the current build)
3dm info --view front              # generate description from the front view
3dm info --view top,front,isometric  # generate from multiple views

# ORIENTATION, PREVIEW, SLICING
3dm preview                        # render model to build/preview.png
3dm orient                         # AI recommendation for best print orientation
3dm slice                          # call slicer on build/main.stl

3dm orient — What It Does and How to Use It

3dm orient uses AI to analyze your model’s geometry and recommend which face should be placed down on the build plate for printing. This recommendation considers two things: minimizing the need for supports (overhangs), and maximizing the quality of visible surfaces (which sit better when they’re on the top or sides, not facing down toward the bed).

Use 3dm orient as a starting suggestion, but verify it with your own judgment. For complex parts, you may have competing priorities — perhaps the AI recommends an orientation that minimizes supports but puts a cosmetically important surface face-down against the bed, where it will look rough. Your own analysis matters.

Concept 2: Text on 3D Parts

Why 3D Text Is Useful

Before diving into syntax, it’s worth thinking about why you’d want text on a 3D print:

Identification — part numbers, serial numbers, batch codes. Manufacturing parts need to be traceable. A part with its number embossed on it can never be confused with another part.

Directional labels — “FRONT,” “TOP,” “THIS SIDE UP.” Assembly instructions encoded directly in the part.

Storage and organization — labels for bins, drawers, shelves. Parametric text means you can batch-generate 30 labeled bins automatically.

Personalization — names, logos, messages on gifts, art, and personal projects.

Accessibility — braille labels for visually impaired users. OpenSCAD can generate braille if you encode the dot patterns.

Step 1 — The text() Function

How Text Works in OpenSCAD

text() creates a 2D shape from a text string. By itself, it’s flat — it has no height. You add height by wrapping it in linear_extrude(), which pushes the 2D letterforms straight up along the Z axis.

Embossed text is raised above the surface — the letters stand up above the base. This is more visible and readable, especially at small sizes, because there’s contrast between the raised letters and the surrounding surface.

Debossed text (also called engraved or incised) is carved into the surface — the letters are sunken below the surrounding surface. This reads well when the sunken areas catch shadow, or when filled with paint. It also doesn’t add any height to the overall part dimensions.

// Full text() parameter reference
linear_extrude(height=1.5)
  text(
    text      = "3dMake",           // the string to display
    size      = 10,                  // cap height in mm (capital letter height)
    font      = "Liberation Sans",   // font family name (more on this in Step 2)
    halign    = "center",            // horizontal alignment: "left", "center", "right"
    valign    = "baseline",          // vertical alignment: "top", "center", "baseline", "bottom"
    spacing   = 1.0,                 // letter spacing multiplier (1.0 = normal)
    direction = "ltr",               // text direction: "ltr" (left-to-right) or "rtl"
    language  = "en",
    script    = "latin"
  );

// EMBOSSED: raised letters sitting on top of the base
cube([80, 15, 5]);
translate([40, 7.5, 5])             // sit text on top face (Z=5)
  linear_extrude(height=1.5)        // letters are 1.5mm tall
    text("FRONT", size=6, font="Liberation Sans:style=Bold",
         halign="center", valign="center");

// DEBOSSED (ENGRAVED): letters carved into the surface
difference() {
  translate([0, 20, 0]) cube([80, 15, 5]);
  translate([40, 27.5, 5 - 0.8])   // start 0.8mm below the top face
    linear_extrude(height=1)        // 1mm cut: 0.8 into + 0.2 through (clean cut)
      text("BACK", size=6, font="Liberation Sans:style=Bold",
           halign="center", valign="center");
}

Understanding the debossed depth calculation: If the plate is 5 mm tall and you want 0.8 mm deep engraving, start the extrusion at z = 5 - 0.8 = 4.2. Extrude 1.0 mm (so it reaches z=5.2 — 0.2 mm past the top). This uses the 0.001 rule logic from Lesson 2: the cutter goes slightly beyond the face for a clean cut. The visible result is letters engraved 0.8 mm deep.

Step 2 — Finding and Using Fonts

Why Font Availability Is a Portability Problem

OpenSCAD uses fonts installed on your operating system. Different computers have different fonts. If you write code that uses “Arial” and another student or instructor tries to render it on a Linux machine that doesn’t have Arial, OpenSCAD will fall back to a substitute font — and the text proportions may change, potentially causing the text to overflow its container or look wrong.

The solution has two parts: check which fonts are available on your machine before writing your code, and define your font choice as a single parameter at the top of the file so it’s easy to change.

Finding Available Fonts

Linux (bash):

# List all available fonts
fc-list | sort | less

# Find fonts with "liberation" in the name
fc-list | grep -i "liberation"

# Get the exact format needed for OpenSCAD's font= parameter
fc-list --format="%{family}:style=%{style}\n" | grep -i liberation | sort | head -20
# Output examples:
# Liberation Sans:style=Bold
# Liberation Sans:style=Regular
# Liberation Mono:style=Bold

Windows (PowerShell):

# List all installed fonts
[System.Reflection.Assembly]::LoadWithPartialName("System.Drawing") | Out-Null
$fonts = (New-Object System.Drawing.Text.InstalledFontCollection).Families
$fonts | Select-Object Name | Sort-Object Name

# Search for a specific font
$fonts | Where-Object { $_.Name -like "*Arial*" } | Select-Object Name

On Windows, the most convenient method is the Help → Font List menu inside the OpenSCAD application — it shows every available font with its exact name string.

macOS (bash):

fc-list | sort
# or
system_profiler SPFontsDataType | grep "Full Name" | sort

Classroom-Safe Fonts (Available on Most Linux Systems)

These fonts are widely pre-installed and safe to use in code you’ll share with classmates:

• Liberation Sans — clean, modern sans-serif, compatible proportionally with Arial
• Liberation Mono — monospaced, excellent for part numbers and code
• DejaVu Serif — serif font with good contrast for labels

Note

If OpenSCAD can’t find your specified font, it prints WARNING: No match for requested font family in the console. Font availability varies by OS — if text looks wrong, check the console for this warning and substitute an available font.

Step 3 — Font-Agnostic Code Pattern

Define Your Font Once

Instead of hardcoding a font name at every text call, define it once as a constant at the top of your file. This way, switching fonts is a one-line change, and the font choice is clearly documented.

// Define font choice once at the top — comment/uncomment for your OS
LABEL_FONT = "Liberation Sans:style=Bold";   // Linux
// LABEL_FONT = "DejaVu Sans:style=Bold";    // Linux alternative
// LABEL_FONT = "Arial:style=Bold";          // Windows / macOS
// LABEL_FONT = "Helvetica:style=Bold";      // macOS

module label(txt, size=8) {
  text(txt, font=LABEL_FONT, size=size, halign="center", valign="center");
}

module embossed_plate(message, plate_w=80, plate_d=15, plate_h=5,
                      text_size=8, relief=1.5) {
  cube([plate_w, plate_d, plate_h]);
  translate([plate_w/2, plate_d/2, plate_h])
    linear_extrude(height=relief)
      label(message, size=text_size);
}

embossed_plate("FRONT");
translate([0, 20, 0]) embossed_plate("BACK");
translate([0, 40, 0]) embossed_plate("LEFT");

Step 4 — Text Sizing: The Cap-Height Model

How the size Parameter Works

The size parameter in text() sets the cap height — the height of a capital letter in millimeters. This is not the total height of the text block; lowercase letters with descenders (g, p, q, y) extend further below the baseline.

Useful rules of thumb:

• Total text block height ≈ size × 1.25 (to include descenders)
• Width of a capital letter ≈ size × 0.65 to size × 0.75
• Total width of an all-caps string ≈ size × 0.65 × character_count

These are approximations — the exact values depend on the specific font.

Auto-Fitting Text to a Container

When you need text to fill a specific width and height automatically, this module computes the right size:

module fitted_text(txt, container_w, container_h,
                   font="Liberation Sans:style=Bold") {
  char_count  = len(txt);
  size_by_w   = container_w / (char_count * 0.68);  // size that fills width
  size_by_h   = container_h * 0.75;                  // size that fills height
  fitted_size = min(size_by_w, size_by_h);            // use whichever is smaller

  echo(str("Fitted text size for '", txt, "': ", fitted_size, "mm"));

  text(txt, size=fitted_size, font=font,
       halign="center", valign="center");
}

// These labels auto-size to fit their containers
difference() {
  cube([60, 12, 5]);
  translate([30, 6, 5 - 0.8])
    linear_extrude(height=1)
      fitted_text("HELLO", 60, 12);
}

translate([0, 20, 0]) {
  cube([60, 12, 5]);
  translate([30, 6, 5])
    linear_extrude(height=1.5)
      fitted_text("WORLD", 60, 12);
}

Step 5 — String Functions

Building Labels Dynamically

The str() function converts any value to its string representation and concatenates multiple values into a single string. This is how you create part numbers, serial numbers, and version stamps programmatically.

// str() — convert values to strings and concatenate
part_id = str("PART-", 2026, "-", 42);
echo(part_id);   // PART-2026-42

// len() — length of a string or list
name = "OpenSCAD";
echo(len(name));   // 8

// search() — find the position of a character in a string
// Returns a list; [[4]] means found at index 4
echo(search("S", "OpenSCAD"));   // [[4]]

// substr() — extract a substring
// substr(string, start_index, length)
full = "BATCH-001";
batch  = substr(full, 0, 5);   // "BATCH"
number = substr(full, 6, 3);   // "001"
echo(batch, number);

Auto-Generating Serial Numbers

// Generate 5 parts with serial numbers SN-01 through SN-05
for (i = [1:5]) {
  serial = str("SN-", i < 10 ? "0" : "", i);   // zero-pad single digits
  translate([i * 35, 0, 0]) {
    cube([30, 12, 4]);
    translate([15, 6, 4])
      linear_extrude(1.5)
        text(serial, size=5, font="Liberation Sans:style=Bold",
             halign="center", valign="center");
  }
}

Step 6 — let() for Scoped Variables

What let() Does

In Lesson 3 you learned that OpenSCAD global variables are resolved at parse time, and that last-assignment wins. let() provides a way to declare variables that are scoped to a specific block — they only exist inside the let() block and don’t affect global scope.

let() is useful when you need intermediate calculated values in one place and don’t want them polluting the global namespace, or when you want to make a series of dependent calculations explicit within one block.

// let() scopes variables to the block they're declared in
let (
  base_w          = 80,
  base_d          = 50,
  plate_height    = 5,
  text_center_x   = base_w / 2,
  text_center_y   = base_d / 2
) {
  cube([base_w, base_d, plate_height]);
  translate([text_center_x, text_center_y, plate_height])
    linear_extrude(2)
      text("v1.0", size=6, halign="center", valign="center");
}
// text_center_x and text_center_y are not accessible outside the let() block

Step 7 — A Complete Parametric Label Plate

Here is a production-quality label module that uses every concept from this lesson:

// Parametric Label Plate
// Adjust these parameters and run: 3dm build
label_text   = "STORAGE BOX";
label_w      = 80;        // mm — plate width
label_h      = 18;        // mm — plate height
plate_depth  = 3;         // mm — plate thickness
text_depth   = 1.2;       // mm — engraving depth
font_size    = 7;         // mm — cap height of text
corner_r     = 2;         // mm — corner rounding radius

module label_plate(txt, w, h, t, td, fs, cr) {
  difference() {
    // Rounded rectangle base (minkowski creates rounded corners)
    minkowski() {
      cube([w - 2*cr, h - 2*cr, t], center=true);
      cylinder(r=cr, h=0.01, $fn=16);
    }
    // Engraved text, centered
    translate([0, 0, t/2 - td + 0.001])
      linear_extrude(td + 0.001)
        text(txt, size=fs, font="Liberation Sans:style=Bold",
             halign="center", valign="center", $fn=4);
    // Mounting hole for wall attachment
    translate([w/2 - 6, 0, -0.001])
      cylinder(r=1.5, h=t + 0.002, $fn=16);
  }
}

label_plate(label_text, label_w, label_h, plate_depth, text_depth, font_size, corner_r);

Step 8 — Automating Multi-Label Generation

Once your label design is parametric, you can generate a whole set of labels automatically — one build command per label variant.

Linux / macOS (bash):

#!/bin/bash
LABELS=("FRONT" "BACK" "LEFT" "RIGHT" "TOP" "BOTTOM")
mkdir -p build/labels

for label in "${LABELS[@]}"; do
  filename=$(echo "$label" | tr '[:upper:]' '[:lower:]')
  output="build/labels/${filename}.stl"
  echo "Generating: $label → $output"
  openscad -D "label_text=\"${label}\"" -o "$output" src/main.scad
  [ $? -eq 0 ] && echo "  OK" || echo "  FAILED"
done
echo "Done. Output: build/labels/"

Windows (PowerShell):

$labels = @("FRONT", "BACK", "LEFT", "RIGHT", "TOP", "BOTTOM")
New-Item -ItemType Directory -Force -Path "build\labels" | Out-Null

foreach ($label in $labels) {
  $filename = $label.ToLower()
  $output   = "build\labels\$filename.stl"
  Write-Host "Generating: $label → $output"
  openscad -D "label_text=`"$label`"" -o $output "src\main.scad"
  if ($LASTEXITCODE -eq 0) { Write-Host "  OK" } else { Write-Host "  FAILED" }
}
Write-Host "Done."

Windows (CMD):

@echo off
mkdir build\labels 2>nul
FOR %%L IN (FRONT BACK LEFT RIGHT TOP BOTTOM) DO (
  echo Generating: %%L
  openscad -D "label_text=\"%%L\"" -o "build\labels\%%L.stl" src\main.scad
  IF %ERRORLEVEL% EQU 0 (echo   OK) ELSE (echo   FAILED)
)
echo Done.

Exercises

Exercise 6.1: Find the fonts available on your computer using the appropriate command for your OS. List three font names in the exact format required by OpenSCAD’s font= parameter (e.g., Liberation Sans:style=Bold).

Exercise 6.2: Create a parametric name plate module where the text is auto-sized to fill 75% of the plate width. Test it with strings of 3, 6, 9, and 12 characters — verify that the text scales correctly and doesn’t overflow.

Exercise 6.3 (Advanced): Write a shell script that generates 10 identical parts with serial numbers SN-001 through SN-010 embossed on each. Display success or failure for each part and the total file count at the end.

Quiz — Lesson 6 (15 questions)

1. What does 3dm orient output and when would you use it?
2. What is the difference between embossed text and debossed (engraved) text in 3D printing? How does the OpenSCAD code differ?
3. What does the size parameter in text() represent specifically? Is it the total height of the text block?
4. What parameter in text() controls horizontal alignment, and what are the three main options?
5. What does str("PART-", 2024, "-", 1) return?
6. What does len("OpenSCAD") return?
7. What is the purpose of let() in OpenSCAD, and how does it differ from declaring a global variable?
8. What does setting $fn=4 do to letters rendered with text()?
9. What does 3dm preview produce and where does the output file go?
10. What is the format for specifying a font style (e.g., bold) in OpenSCAD’s font= parameter?
11. Explain the depth calculation for debossed text: if a plate is 6 mm tall and you want 1 mm engraving depth, where do you position the linear_extrude() call and what height do you give it?
12. What does substr("BATCH-001", 6, 3) return?
13. What happens if you use text() without wrapping it in linear_extrude()?
14. Why is defining the font as a constant at the top of your file (e.g., LABEL_FONT = "Liberation Sans:style=Bold") better than hardcoding it in every text() call?
15. Write the OpenSCAD code to create a 50×20×4mm plate with the text “LOT-42” engraved 1.5mm deep, centered on the top face.

Extension Problems (15)

1. Build a parametric serial number generator: accept a prefix string and a starting number, and generate a set of embossed labels with incrementing serial numbers.
2. Create a dynamic version stamp: use str() to combine a product name, major version, and minor version, all as separate parameters.
3. Design a 4-up label sheet: four identical labels in a 2×2 grid, using translate() and a for loop with two variables.
4. Build a two-line label: stack two text() calls at different heights. Line 1 is the label text; line 2 is a smaller subtitle.
5. Create a label with a decorative border: use difference() to cut a framing slot into the top face of the label plate.
6. Use 3dm orient on three different models (a flat slab, a tall cylinder, an L-bracket) and document whether you agree with the AI suggestion in each case.
7. Build a “batch tag” system: a module that generates 12 small tags in a row, each with a different serial number from a list.
8. Design a keychain tag: a rounded rectangle with a ring hole, parametric text, and a border around the text.
9. Use search() to find the position of a separator character (dash or underscore) in a part-number string. Explain a practical use case for this.
10. Build a “negative space” text plate: a plate with all letters cut completely through, creating a stencil or silhouette effect.
11. Design a parametric drawer label holder: a clip that attaches to the front edge of a drawer and holds a flat label insert.
12. Create a font comparison plate: render the same text string using Liberation Sans, Liberation Mono, and DejaVu Serif side by side on one base plate.
13. Write a screen-reader accessibility guide for the five 3dm commands. For each command: what it does, expected output, and how to interpret that output without visual reference.
14. Write a module that auto-reduces font size to fit text within a fixed-width container. The module should reduce size in 0.5 mm steps until the estimated width fits.
15. Design a production part-marking system: a jig that holds 10 small labels in a row, each with an incremented part number, ready to print all at once as one STL file.

References and Helpful Resources

• 3DMake GitHub Repository — Command Reference — https://github.com/tdeck/3dmake

• OpenSCAD User Manual — Text and Fonts — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Text

Supplemental Resources

• Programming with OpenSCAD EPUB Textbook — assets/Programming_with_OpenSCAD.epub — String functions and text embossing examples
• OpenSCAD Quick Reference — https://programmingwithopenscad.github.io/quick-reference.html — All string function syntax
• CodeSolutions Repository — https://github.com/ProgrammingWithOpenSCAD/CodeSolutions — Worked text embossing examples
• All other reference documents are embedded as appendices below — no separate files needed.

Part 2: Extension Project and Reference Appendices

All supporting documents for Lesson 6 are included below. You do not need to open any additional files.

Appendix A: Parametric Keychain — Extension Project

Estimated time: 2–4 hours

Overview

This extension project applies the text embossing and parametric design skills from Lesson 6 to build something immediately usable: a personalized keychain. The goal is not just to make one keychain — it’s to build a system that can produce any variant (different names, sizes, materials) by changing a small set of top-level variables. That’s what makes it a professional parametric design rather than a one-off model.

Learning Objectives

By completing this project, you will:

• Create parametric OpenSCAD modules that accept user inputs as top-level variables
• Implement embossed and debossed text using linear_extrude() of 2D text shapes
• Generate and test multiple design variants systematically
• Document design parameters for reproducibility and user customization

Objective

Create a keychain.scad file that adapts to custom text, dimensions, and attachment ring size — all through top-level parameter variables. Anyone with your .scad file should be able to produce a custom keychain by changing only the variables at the top of the file.

Tasks

1. Create keychain.scad with these top-level parameters at minimum: name, tag_w, tag_h, tag_thickness, text_size, ring_d. Add others as your design requires. Every dimension in the file should trace back to one of these variables.

2. Implement text using linear_extrude() of a 2D text() shape. Add either embossed text (the letters rise above the surface) or debossed text (the letters are engraved into the surface). Embossed text is more durable; debossed text is easier to read when painted or filled with ink.

3. Produce three size variants — small (25 mm wide), medium (35 mm wide), large (45 mm wide) — by changing only tag_w and tag_h proportionally. Export an STL for each and record print time and filament weight.

4. Test the key ring attachment by inserting a standard key ring (typically 25–30 mm diameter wire) through the attachment loop. Document what ring diameter fits, and whether the attachment point survives a reasonable tug test.

Deliverables

• keychain.scad — fully parametric source file with all key dimensions as named variables and comments explaining each
• Three STL variant files (small, medium, large)
• Completed student documentation template (Appendix B of this document)
• Print settings log and fit-test report for key ring attachment

Starter Code

Use the minimal keycap example as your starting structure for the shell + emboss pattern. The more advanced examples below show how to add circular text arrangements, multi-line compositions, and font variation.

Minimal Starting Point:

// Cube Keycap — Structural Reference
// This shows the shell + emboss pattern. Replace with keychain geometry.

keysize    = 18;    // mm — tag size
keyheight  = 12;    // mm — tag thickness
wall       = 1.2;   // mm — shell wall
letter     = "R";   // change to your text
lettersize = 10;    // mm — text size
letteraise = 0.8;   // mm — emboss height above surface

module shell() {
  difference() {
    cube([keysize, keysize, keyheight], center=false);
    translate([wall, wall, wall])
      cube([keysize - 2*wall, keysize - 2*wall, keyheight], center=false);
  }
}

module emboss() {
  translate([keysize/2, keysize/2, keyheight - 0.01])
    linear_extrude(height=letteraise)
      text(letter, size=lettersize, halign="center", valign="center");
}

union() {
  shell();
  emboss();
}

Parametric Keychain Nameplate — use this as your primary starting scaffold:

// Customizable Keychain Nameplate
// Change the parameters below to create your own variant.

// ---- Top-Level Parameters (change these) ----
name          = "ALEX";    // text to emboss on the tag
tag_w         = 35;        // mm — tag width
tag_h         = 20;        // mm — tag height (vertical dimension)
tag_thickness = 5;         // mm — tag thickness (Z height)
wall          = 1.2;       // mm — shell wall thickness
text_size     = 12;        // mm — font cap-height
text_raise    = 0.8;       // mm — emboss height above top face
ring_d        = 6;         // mm — key ring hole inner diameter
ring_wall     = 2;         // mm — wall thickness around ring hole

// ---- Derived Values ----
ring_outer_d  = ring_d + 2 * ring_wall;

// Verify ring attachment won't be too thin to print reliably
assert(ring_wall >= 1.2,
  str("ring_wall too thin to print reliably: ", ring_wall, "mm. Minimum: 1.2mm"));

// ---- Shell Module ----
module tag_shell() {
  difference() {
    cube([tag_w, tag_h, tag_thickness]);
    translate([wall, wall, wall])
      cube([tag_w - 2*wall, tag_h - 2*wall, tag_thickness]);  // open top — hollow shell
  }
}

// ---- Text Module ----
module tag_text() {
  translate([tag_w/2, tag_h/2, tag_thickness - 0.01])
    linear_extrude(height=text_raise)
      text(name,
           size=text_size,
           font="Liberation Sans:style=Bold",
           halign="center",
           valign="center",
           $fn=4);   // $fn=4 speeds up preview; use $fn=32 for final render
}

// ---- Key Ring Attachment Loop ----
// A short cylinder projecting from the top edge center with a hole through it.
module ring_attachment() {
  translate([tag_w/2, tag_h + ring_outer_d/2 - 0.001, tag_thickness/2])
    rotate([90, 0, 0])
      difference() {
        cylinder(d=ring_outer_d, h=tag_thickness, center=true, $fn=32);
        cylinder(d=ring_d,       h=tag_thickness + 0.002, center=true, $fn=32);
      }
}

// ---- Assembly ----
union() {
  tag_shell();
  tag_text();
  ring_attachment();
}

Advanced Technique: Circular Text Arrangement

// Arrange text in a circle around a center point.
// Useful for medallion-style keychains, badge designs, or decorative borders.

module rotate_text(display_text,
    text_size    = 10,
    distance     = 20,
    rotation_span = 360,
    tilt         = 0)
{
  rotate([0, 0, tilt])
  for (i = [0 : len(display_text) - 1]) {
    rotate([0, 0, -i * rotation_span / len(display_text)])
    translate([0, distance, 0])
      text(display_text[i],
           font="Liberation Sans:style=Bold",
           size=text_size,
           halign="center");
  }
}

// Usage: extrude the circular text arrangement
linear_extrude(height=2)
  rotate_text("MAKER", text_size=12, distance=30, rotation_span=75, tilt=30);

Advanced Technique: Multi-Line Text Composition

// Combine multiple text elements at different sizes for a professional nameplate.

module nameplate(name, role, plate_w=120, plate_d=60, plate_h=3) {
  union() {
    // Base plate
    cube([plate_w, plate_d, plate_h], center=true);

    // Main name — large, centered near top
    translate([0, 15, plate_h/2 + 1.5])
      linear_extrude(height=2)
        text(name, size=24, font="Liberation Sans:style=Bold",
             halign="center", valign="center");

    // Role — medium
    translate([0, 0, plate_h/2 + 1.5])
      linear_extrude(height=2)
        text(role, size=14, font="Liberation Sans:style=Regular",
             halign="center", valign="center");
  }
}

nameplate("Alex Chen", "3D Design Engineer");

Font Reference: Cross-Platform Options

The fonts below are widely available. Always fall back gracefully — define your font as a constant at the top of your file so you change it in one place.

// Define font as a constant — change here, applies everywhere
BODY_FONT  = "Liberation Sans:style=Bold";    // clean, reliable on all platforms
MONO_FONT  = "Liberation Mono:style=Regular"; // technical/code style
SERIF_FONT = "DejaVu Serif:style=Regular";    // classic, decorative

// Usage
linear_extrude(height=2)
  text("BOLD", size=20, font=BODY_FONT, halign="center");

Assessment Questions

1. How did you use OpenSCAD parameters to enable customization without requiring users to edit code logic?
2. What were the key differences in print time and material usage between your three size variants?
3. How did you test the key ring attachment, and what adjustments did your testing reveal?

Appendix B: Parametric Keychain — Student Documentation Template

Author: ________________ Date: __________ Description: Design a fully parametric keychain that supports personalization and customization through top-level variables.

Design Concept

• Keychain theme or purpose (personal use, gift, label system, other):
• Design elements (shape, attachment method, text or symbol, any decorative features):
• Parametric strategy — what will be variables, and what will be fixed geometry?

Parametric Variables

List every named variable in your file and what it controls.

Variant Configurations

Document the three variants you produced. Change only size-related variables between variants — text, attachment, and structural relationships should scale automatically.

Print Settings Used

Key Ring Attachment Test

Adjustments needed based on testing:

Print and Assembly Results

For each variant, describe the print result:

Small variant:

• Text legibility (clear / readable / hard to read):
• Surface quality:
• Any print issues:

Medium variant:

• Text legibility:
• Surface quality:
• Any print issues:

Large variant:

• Text legibility:
• Surface quality:
• Any print issues:

Customization Guide

Write this section for a future user who will download your .scad file and want to make their own version:

1. To change the name: set name = "YOUR TEXT" at line ___.
2. To change the size: adjust tag_w and tag_h proportionally. Recommended ratio: tag_h = tag_w * 0.57.
3. To change the font: update the LABEL_FONT constant at line ___.
4. Common customizations:
   • Smaller text that doesn’t overflow: reduce text_size until the preview looks right.
   • Different ring size: change ring_d to match your key ring’s wire diameter + 1 mm clearance.

Reflections

1. Which parameterization decision had the most impact on the usefulness of the final design?

2. How could someone who doesn’t know OpenSCAD still customize this design? What instructions would you write for them?

3. What would you add in a future iteration — a second line of text, a logo, a different attachment style?

Attachments Checklist

• .scad file with full parametric structure and comments on all variables
• Photos of all three printed variants side by side
• Photos of key ring fit test (ring inserted through attachment loop)
• Completed variant configuration table
• Customization guide written for a future user

Teacher Feedback

Appendix C: Parametric Keychain — Instructor Reference

Project Context

This extension project reinforces the core text embossing and parametric design content of Lesson 6. The key educational goal is parameter-driven design: every visible dimension should trace back to a named variable, so changing one number updates the entire design proportionally. Students who hardcode numbers (e.g., translate([35/2, 20/2, 5]) instead of translate([tag_w/2, tag_h/2, tag_thickness])) miss the point even if the print looks fine.

Key Learning Points to Reinforce

All dimensions must be variables. A fully parametric design produces a different variant for every combination of input values, without any code changes. If changing tag_w from 25 to 45 produces a broken design (text overflow, attachment loop detaches, walls become invalid), the design is not truly parametric.

The font constant pattern. Students should define LABEL_FONT = "Liberation Sans:style=Bold" at the top of the file and reference it in every text() call. This is a direct application of the DRY principle from Lesson 3. Hardcoding font strings in every text call is a common mistake.

Text overflow is a design failure, not a rendering quirk. OpenSCAD does not automatically fit text to a container — if text_size is too large, the text will extend beyond the tag boundary and produce an illegal geometry when combined with the shell. Students should either add an assert() that checks estimated text width, or test each variant in preview before exporting.

The key ring attachment geometry is the most technically demanding part. The cylinder that forms the attachment loop must: (1) be large enough for a real key ring wire to fit through, (2) have walls thick enough to print reliably (minimum ~1.2 mm), and (3) connect cleanly to the main tag body. The 0.001 mm overlap in the starter code’s translate() prevents non-manifold geometry at the junction.

Constraints (Enforce These)

• All key dimensions (width, height, thickness, text size, ring diameter) must be named variables — no hardcoded numbers in geometry
• At least three variants must be printed, not just rendered
• Key ring attachment must be physically tested, not just visually inspected

Assessment Notes

Strong submissions show: text that scales proportionally with text_size as a variable, a ring attachment that has been tested with a real key ring, and a customization guide that actually tells a non-programmer how to make their own version.

Common weak areas: Text overflow not detected until printing (add assert() or preview check to starter code reminder), attachment loop too thin to be durable (check ring_wall >= 1.2 mm), and documentation that describes the final design but doesn’t guide future customization.

Extension opportunity: Students who finish early can investigate font rendering differences on their platform (Linux vs. macOS vs. Windows font availability), or add a second line of text (a subtitle or date) as a separate variable.

Appendix D: Slicing Settings Quick Reference

Use this reference when preparing your keychain (or any Lesson 6 design) for printing. Find your slicer and printer below. Recommended settings for most keychain prints: 0.20 mm layer height, 20% infill, no supports.

D1 — PrusaSlicer (Prusa Printers)

Recommended Settings by Use Case

Filament Temperature Settings

Always check the temperature range printed on your filament spool — it varies by brand.

Support Settings Guide

Common Problems and Quick Fixes

G-code Export Checklist

Before exporting, confirm:

• Correct printer profile selected
• Correct filament profile selected
• Layer height appropriate for use case
• Infill percentage set
• Supports enabled if needed
• Layer preview reviewed (no floating parts; supports where needed)
• Print time and filament weight noted for your records

Sources: Prusa Research PrusaSlicer knowledge base (help.prusa3d.com); Hubs FDM guide (hubs.com)

D2 — Cura / Anycubic i3 Mega

Recommended Settings by Use Case

Filament Temperature Settings

Support Settings Guide

Common Problems and Quick Fixes

G-code Export Checklist (Cura)

• Anycubic i3 Mega printer profile selected
• Correct filament type and diameter (1.75 mm)
• Layer height set appropriately
• Infill percentage set
• Supports enabled if needed (tree supports preferred)
• Nozzle and bed temperatures verified
• Print preview checked (no floating parts)
• Estimated time and filament weight noted

Sources: Anycubic official documentation (anycubic.com); Ultimaker Cura guide (ultimaker.com)

D3 — Bambu Studio / X1 Series

Recommended Settings by Use Case

Filament Temperature Settings

Check Bambu’s material database for current profile updates — these are dynamically optimized.

Support Settings Guide

Common Problems and Quick Fixes

G-code Export Checklist (Bambu Studio)

• Correct printer (X1 / X1E) and hotend selected
• Filament material and color match actual AMS configuration
• Layer height optimal for desired quality
• Infill and supports set appropriately
• Print preview shows correct color layering (if multi-material)
• Estimated time and filament weight acceptable
• Camera enabled for remote monitoring
• Web upload or USB export ready

Sources: Bambu Lab documentation (bambulab.com); Bambu Lab Community forums (community.bambulab.com) -e

Lesson 7 — Parametric Transforms and the Phone Stand Project

Estimated Time: 90–120 minutes
Course: 3dMake Certification — High School Distance Learning Track

Before You Start

You can now create shapes, combine them with CSG, organize them into modules, and add text. This lesson is about the next layer of precision: moving, rotating, mirroring, and scaling objects with mathematical exactness.

You’ve used translate() before to move shapes around. But there’s a subtlety about how OpenSCAD applies transforms — specifically, the order in which they execute — that is one of the most common sources of confusing bugs in OpenSCAD designs. Understanding the order rule deeply is one of the most valuable things you’ll get from this lesson.

This lesson also builds your first complete, multi-module project: a parametric phone stand. It’s not just an exercise — it’s a real, functional object. You’ll measure your actual phone, enter those measurements as parameters, and the math will generate the exact geometry needed to hold your phone at the angle you specify. Change the angle parameter and the entire stand recalculates.

Learning Objectives

By the end of this lesson you will be able to:

• Apply translate(), rotate(), and scale() in the correct order for compound transforms
• Use trigonometric functions (sin(), cos(), atan2()) to compute precise geometry positions
• Use minkowski() to create rounded edges and mirror() to create perfectly symmetric parts
• Build a complete parametric phone stand from three measured dimensions
• Use $preview to conditionally speed up rendering during development
• Apply vector math functions: norm(), cross(), and the dot product

Concept 1: Transform Order — The Most Important Rule in This Lesson

How OpenSCAD Applies Multiple Transforms

When you write multiple transforms on the same line, OpenSCAD applies them in right-to-left order — the transform closest to the geometry object applies first.

Read this line:

translate([10, 0, 0]) rotate([0, 0, 45]) cube(5);

Your eye reads left to right: “translate, then rotate.” But OpenSCAD executes right to left: first rotate (it’s closer to cube), then translate. So the cube is first rotated 45° around the origin, and then moved 10 mm in X.

Now read this:

rotate([0, 0, 45]) translate([10, 0, 0]) cube(5);

This time: first translate (cube moves 10 mm right), then rotate (the cube, now positioned at X=10, rotates around the origin). The result is that the cube ends up in a completely different location — it orbits around the origin rather than rotating in place.

Why This Matters

This rule has a real consequence: changing the order of transforms changes the position of your geometry, even if the transforms themselves are identical. This is the source of a lot of frustrating bugs in OpenSCAD designs, especially when the code looks correct to you.

The way to internalize it: think of it as nested functions. In translate(rotate(cube())), cube() runs first, then rotate() acts on its output, then translate() acts on that result. The same way f(g(x)) in math means “apply g first, then f.”

// Example A: cube rotates 45° in place, then moves 10mm right
// (rotate happens to the stationary cube, then translate moves it)
translate([10, 0, 0]) rotate([0, 0, 45]) cube(5);

// Example B: cube moves 10mm right first, then the rotated version orbits the origin
// (translate moves it first, then rotate spins it around origin — completely different result)
rotate([0, 0, 45]) translate([10, 0, 0]) cube(5);

Build both of these side by side. Look at where each cube ends up. The visual difference makes this rule concrete in a way that reading about it can’t.

The Rule in Plain Language

“The last transform written (closest to the shape) runs first.” Repeat this until it’s automatic.

Step 1 — Translate, Rotate, Scale

translate([x, y, z]) — Move

translate() moves its child object by the specified amount in each axis. translate([10, 0, 0]) moves 10 mm to the right. translate([0, 0, 5]) moves 5 mm up. Negative values move in the opposite direction.

You already know this one from previous lessons. The key reminder is the order rule above.

rotate([x_deg, y_deg, z_deg]) — Rotate

rotate() rotates its child around the X, Y, and/or Z axes by the specified angles in degrees. The rotation happens around the origin — if the object isn’t at the origin, it will orbit around it (which is sometimes what you want, sometimes not).

rotate([0, 0, 45]) rotates around the Z axis (spins in the XY plane). rotate([90, 0, 0]) rotates around the X axis (tips the object forward/backward). rotate([0, 90, 0]) rotates around the Y axis (tips the object left/right).

When you want to rotate an object around its own center (not the origin), translate it to the origin first, rotate it, then translate it to its final position:

// Rotate a cylinder around its own center, then position it
translate([20, 30, 0])        // 3. move to final position
  rotate([0, 90, 0])          // 2. rotate (runs before translate due to order rule)
    cylinder(h=20, r=5);      // 1. cylinder starts at origin

scale([x, y, z]) — Stretch or Compress

scale([1, 1, 2]) doubles the height of an object without changing its width or depth. scale([0.5, 0.5, 0.5]) shrinks everything by half. scale([1, 2, 1]) doubles depth only.

scale() is less common than the others because it changes proportions — a sphere becomes an ellipsoid, a cube becomes a rectangular box. But it’s useful for quick dimension experiments or for stretching a symmetrical part in one direction.

// Stretch a sphere 2x in Z to create an egg shape
scale([1, 1, 2]) sphere(r=10, $fn=32);

Step 2 — Trigonometry for Geometric Positioning

Why You Need Trig in Design

Trigonometry shows up in 3D design whenever you need to:

• Place objects evenly around a circle
• Compute an angle from a measured slope
• Position something at a known distance and direction from a reference point
• Calculate how deep a feature needs to be at a given angle

Fortunately, you don’t need to understand all of trigonometry deeply — you need three functions and one rule.

The rule: all angles in OpenSCAD are in degrees. Not radians. This is different from most programming languages. sin(90) in OpenSCAD returns 1 (correct for 90°). If you accidentally use radians, your numbers will be wildly off.

sin(), cos(), and Placing Things Around a Circle

sin(angle) and cos(angle) return the Y and X components of a unit vector pointing at that angle. Multiplying by a radius gives you the actual coordinates.

For a circle of radius r, the (x, y) position at angle a is:

• x = cos(a) * r
• y = sin(a) * r

// Place 6 cylinders evenly around a circle of radius 25mm
// 360° / 6 = 60° apart
for (i = [0:5]) {
  angle = i * 60;
  translate([cos(angle) * 25, sin(angle) * 25, 0])
    cylinder(r=3, h=5, $fn=16);
}

atan2(y, x) — The Safe Angle Calculator

When you need to go the other direction — from (x, y) coordinates back to an angle — use atan2(y, x).

atan(y/x) seems like it would work, but it fails in two quadrants. When x is negative (the left half of the circle), the division produces a value that places the angle in the wrong half of the circle. atan2(y, x) takes both components separately and always returns the correct angle for all four quadrants.

dx = -5;  dy = 5;
angle_correct = atan2(dy, dx);   // 135° — correct (upper-left quadrant)
angle_wrong   = atan(dy / dx);   // -45° — wrong (treats it as lower-right)
echo("atan2:", angle_correct, "  atan:", angle_wrong);

Always use atan2() when computing angles from coordinate pairs. Make this a habit.

Step 3 — minkowski() for Rounded Edges

What the Minkowski Sum Does

minkowski() computes something called the Minkowski sum of its children. The geometric meaning: it “rolls” the second shape over every point on the surface of the first shape, and the result is all the space swept out by this rolling.

In practice, the most useful application is rounding the edges and corners of a box. If you take the Minkowski sum of a cube and a small sphere, you get a box with perfectly rounded corners and edges — the rounding radius equals the sphere’s radius.

The variation used most often for printable parts is to use a cylinder instead of a sphere. A very flat cylinder (nearly zero height) rounds the vertical edges of a box but keeps the bottom face flat. This is ideal for parts that will sit on a surface, because a sphere-Minkowski box has a rounded bottom that makes it rock.

// Rounded box — sphere rounds all corners and edges including bottom
module rounded_cube(w, d, h, r=3) {
  minkowski() {
    cube([w - 2*r, d - 2*r, h - r], center=false);
    sphere(r=r, $fn=16);
  }
}

// Flat-base rounded box — cylinder rounds edges but keeps bottom flat
// The w/d dimensions shrink by 2r, and the height stays the same
module flat_rounded_cube(w, d, h, r=3) {
  minkowski() {
    cube([w - 2*r, d - 2*r, h], center=false);
    cylinder(r=r, h=0.01, $fn=24);   // nearly zero height: rounds edges, not top/bottom
  }
}

rounded_cube(40, 30, 20, r=4);
translate([50, 0, 0]) flat_rounded_cube(40, 30, 20, r=4);

Performance Warning

minkowski() is computationally expensive. With high $fn values on the secondary shape, it can take several minutes to compute. During development, keep the secondary shape at $fn=12–16. Only use $fn=32+ for final export. Even better: use the $preview technique in Step 5 to skip Minkowski entirely during quick iterations.

Step 4 — mirror() for Symmetry

Design One Half, Mirror the Other

Many designs have a line of symmetry — two legs, two wings, two ears, two cable clips. Instead of designing both halves separately (which introduces the risk of slight misalignment), design one half and mirror it. The mirrored copy is guaranteed to be exactly symmetric.

mirror([1, 0, 0]) reflects across the YZ plane — negates X coordinates. mirror([0, 1, 0]) reflects across the XZ plane — negates Y coordinates. mirror([0, 0, 1]) reflects across the XY plane — negates Z coordinates.

// Design one ear, mirror it to get a symmetric pair
module ear_peg() {
  translate([20, 0, 0]) cylinder(r=4, h=8, $fn=32);
}

ear_peg();                     // right ear
mirror([1, 0, 0]) ear_peg();  // left ear — exact mirror image

// Mirror works for complex modules too
module mounting_clip() {
  difference() {
    cube([15, 8, 10]);
    translate([7.5, -0.001, 2])
      cylinder(r=3, h=8.002, $fn=32);  // cable channel
  }
}

translate([0, 20, 0]) {
  mounting_clip();
  translate([15, 0, 0]) mirror([1, 0, 0]) mounting_clip();  // symmetric partner
}

Step 5 — Build the Complete Phone Stand

Why Build This

The phone stand is your first complete multi-module project. It’s functional, parametric, and applies trigonometry to solve a real design problem. More importantly, it’s something you’ll actually use — which is a good test of your own design work.

Measuring Your Phone

Before writing code, use a ruler or calipers to measure:

• Phone width: the dimension across the face (X dimension in the cradle)
• Phone thickness: how thick the phone is (determines cradle depth)
• Preferred angle: how far you want the phone to lean back from vertical (65° from horizontal is a comfortable default for most people)

The Full Parametric Design

// ============================================================
// Parametric Phone Stand
// ============================================================
// Measure your phone and enter the three values below.
// All other dimensions are computed automatically.
//
// PARAMETERS TO CUSTOMIZE:
// - phone_w: width of your phone in mm
// - phone_d: thickness of your phone in mm
// - angle:   viewing angle from horizontal (60–80 degrees typically)
// ============================================================

phone_w = 75;   // mm — phone width (fits in cradle)
phone_d = 9;    // mm — phone thickness (sets cradle clearance)
angle   = 65;   // degrees — viewing angle from horizontal

// Internal dimensions — computed from the parameters above
lip_h       = 15;   // mm — depth of cradle lip
base_h      = 5;    // mm — base plate thickness
cradle_wall = 3;    // mm — wall thickness around phone
r_fillet    = 3;    // mm — rounded edge radius

// Trigonometry: compute base depth from the viewing angle
// The phone support must be at the correct lean angle
base_d = (phone_d + 10) / cos(90 - angle);

module flat_rounded_cube(w, d, h, r=3) {
  // Guard against degenerate dimensions after subtracting rounding radius
  assert(w > 2*r && d > 2*r, "Dimensions too small for the rounding radius");
  minkowski() {
    cube([w - 2*r, d - 2*r, h]);
    cylinder(r=r, h=0.01, $fn=24);
  }
}

module base_plate() {
  // Wide, flat base that anchors the stand
  flat_rounded_cube(phone_w + 20, base_d + 10, base_h, r_fillet);
}

module back_support() {
  // Angled wall that supports the back of the phone
  // rotate([angle-90, 0, 0]) tilts the wall to the viewing angle
  rotate([angle - 90, 0, 0])
    flat_rounded_cube(phone_w + 6, cradle_wall, 60, r_fillet);
}

module lip() {
  // Bottom ledge that the phone rests on
  rotate([angle - 90, 0, 0])
    translate([0, -lip_h, 0])
      flat_rounded_cube(phone_w + 6, lip_h + cradle_wall, cradle_wall, r_fillet);
}

// Final assembly: base + back support + lip
base_plate();
translate([0, 0, base_h]) {
  back_support();
  lip();
}

Understanding the Trigonometry

The rotation rotate([angle - 90, 0, 0]) deserves an explanation.

In OpenSCAD, a rotation of 0° around the X axis means the object is vertical (standing straight up). A rotation of -90° tips it flat forward (horizontal). When we want the back support to lean at angle degrees from horizontal, we need a rotation of angle - 90 degrees:

• If angle = 90 (vertical phone): rotate([0, 0, 0]) — no rotation, support is vertical
• If angle = 65 (typical lean): rotate([-25, 0, 0]) — leans 25° back
• If angle = 45 (steeper lean): rotate([-45, 0, 0]) — leans 45° back

After building the stand, try changing angle from 45 to 80 in 5-degree steps and rebuild each time. Watch the support geometry recalculate automatically for every value.

Step 6 — Adaptive Quality with $preview

Fast During Development, High-Quality for Export

$preview is a special OpenSCAD variable that is automatically true during F5 preview (the fast OpenSCAD preview) and false during F6 full render and 3dm build. You can use it to conditionally use lower-quality (faster) settings during development and automatically switch to high quality for final export.

// Low $fn during preview for fast renders; high $fn for final build
$fn = $preview ? 16 : 64;

sphere(r=20);  // uses $fn=16 in preview, $fn=64 during 3dm build

This is especially valuable with minkowski(), which can be very slow at high $fn. During development, replace the Minkowski operation with a plain box placeholder:

module rounded_box_adaptive(w, d, h, r=4) {
  if ($preview) {
    // Fast placeholder during development
    color("orange", 0.6) cube([w, d, h]);
  } else {
    // Full, accurate Minkowski sum for final export
    minkowski() {
      cube([w - 2*r, d - 2*r, h - r]);
      sphere(r=r, $fn=12);
    }
  }
}

Concept 2: Vector Math Functions

Three Functions Worth Knowing

norm(v) — returns the length (magnitude) of a vector. norm([3, 4, 0]) = 5. This is the Euclidean distance from the origin to the point (3, 4, 0), and it follows from the Pythagorean theorem: √(3² + 4² + 0²) = 5.

Dot product (a * b) — returns a single number that measures how “aligned” two vectors are. If both vectors point in exactly the same direction, the dot product equals the product of their lengths. If they’re perpendicular, it equals 0. If they point in opposite directions, it’s negative. Useful for checking angles between directions.

cross(a, b) — returns a vector perpendicular to both input vectors. cross([1,0,0], [0,1,0]) returns [0,0,1] — the Z axis is perpendicular to both X and Y. Useful for computing surface normals or finding the axis of rotation between two vectors.

// norm: length of a vector
v = [3, 4, 0];
echo("Length:", norm(v));   // 5

// dot product: alignment measure
a = [1, 0, 0];   // X axis
b = [0.7, 0.7, 0];
echo("Dot product:", a * b);   // 0.7

// cross product: vector perpendicular to both
c = cross([1, 0, 0], [0, 1, 0]);
echo("Cross:", c);   // [0, 0, 1] — the Z axis

Quiz — Lesson 7 (15 questions)

1. In OpenSCAD, do transforms apply left-to-right or right-to-left (which transform runs first)?
2. What is the result of cos(0) and sin(90) in OpenSCAD (working in degrees)?
3. What is the key advantage of atan2(y, x) over atan(y/x) for computing angles?
4. What does minkowski() do geometrically? Describe it in plain language.
5. What does mirror([1, 0, 0]) do? Which plane does it reflect across?
6. What does scale([1, 1, 2]) do to a sphere?
7. Write OpenSCAD code to place 8 cylinders evenly spaced around a circle of radius 30 mm.
8. What does norm([3, 4, 0]) return, and how is this computed?
9. True or False: translate([10,0,0]) rotate([0,0,45]) cube(5) rotates the cube first, then translates it.
10. What does setting $preview to true mean in OpenSCAD, and when is it set automatically?
11. Why does using minkowski() with cylinder(h=0.01) instead of sphere() produce a flat bottom surface?
12. In the phone stand design, the back support uses rotate([angle - 90, 0, 0]). If angle = 70, what is the actual rotation applied? What does this mean physically?
13. What does cross([1,0,0], [0,1,0]) return and what is the geometric meaning?
14. Explain why designing one half of a symmetric part and using mirror() is better than designing both halves separately.
15. A design requires placing 5 components at the vertices of a regular pentagon centered at the origin. Using cos() and sin(), what is the formula for the coordinates of each vertex, given a circumradius of 25 mm?

Extension Problems (15)

1. Redesign your phone stand with a USB cable slot cut through the lip. Make the slot width and depth parameters.
2. Add rubber foot pockets to the base plate: four small rectangular cutouts on the bottom face, positioned at the corners.
3. Create a phone stand variant that holds the phone in landscape (horizontal) orientation. Document which parameters changed and why.
4. Build a radially symmetric decoration: 12 identical fins evenly spaced around a central cylinder using for loop and rotate().
5. Use atan2() to compute the angle of a ramp and use that angle with rotate() to align a small object precisely on the ramp surface.
6. Design a phone stand for a large tablet (e.g., 180mm × 240mm). Update the parameters, rebuild, and verify the stand still holds at the correct angle.
7. Build a “compound arm” — three rigid link segments connected end-to-end, each at a different angle. Display all three as an assembly with no gaps or overlaps.
8. Create an ergonomic keyboard wrist rest using minkowski() with a cylinder for smooth, flat-base contouring.
9. Build a visual transform order demo: two colored objects that differ only in the order of translate() and rotate(), placed side by side with labels.
10. Redesign the phone stand as a wall-mount: replace the base plate with a flat back plate that has two M3 mounting holes.
11. Build a mirror-symmetric earring holder: design one branch with pegs, then use mirror() to create the symmetric partner. Both branches should connect to a central hanging loop.
12. Use norm() to calculate the space diagonal of a rectangular prism (distance from one corner to the opposite corner) and use that value as a dimension in the design.
13. Research OpenSCAD’s multmatrix() function. Build a shear transformation example (slanting a box into a parallelogram-shaped prism) that can’t be achieved with standard transforms.
14. Add snap-fit clips to the phone stand cradle: two small flexible fingers that slightly grip the phone. Dimension the fingers using snap-fit principles from Lesson 8.
15. Design a dual phone stand: two cradles side by side at different angles, sharing a common base. Use a for loop and parametric spacing.

References and Helpful Resources

• OpenSCAD User Manual — Transformations — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Transformations

• OpenSCAD User Manual — Mathematical Functions — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Mathematical_Functions

• OpenSCAD User Manual — Minkowski and Hull — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Minkowski_and_Hull

Supplemental Resources

• Programming with OpenSCAD EPUB Textbook — Transforms chapter
• CodeSolutions Repository — Phone stand worked example
• OpenSCAD Quick Reference — Math and transform functions -e

Lesson 8 — Advanced Parametric Design and Interlocking Features

Estimated Time: 90–120 minutes
Course: 3dMake Certification — High School Distance Learning Track

Before You Start

Every design you’ve built so far has been a single-piece print. This lesson moves to multi-part assemblies: designs where two or more printed pieces must physically fit together. This is where the gap between “looks right on screen” and “works in real life” becomes most critical.

The central concept of this lesson is tolerance: the intentional gap between mating parts that makes them fit together correctly. Too tight and the pieces won’t go together at all. Too loose and they wobble, rattle, or fall apart. The exact right amount of clearance depends on your specific printer, your specific filament, and your slicer settings — and the only reliable way to know it is to measure it.

This lesson gives you a systematic, professional approach: print a tolerance test coupon, measure the actual results, encode those measurements as named constants in your code, and build designs that work the first time instead of after three reprints.

Learning Objectives

By the end of this lesson you will be able to:

• Explain why FDM-printed holes are always undersized and how to compensate
• Design press-fit and slip-fit joints using printer-specific tolerance values
• Print and use a tolerance test coupon to measure your printer’s actual clearances
• Design snap-fit cantilever arms sized correctly for different materials
• Design dovetail slide joints and stackable assemblies
• Use threaded insert pockets for secure metal-to-plastic fastening
• Apply true chamfer geometry
• Apply tolerance values as named constants throughout a design

Concept 1: The Physics of FDM Tolerances

Why Printed Holes Are Always Too Small

This is one of the most important physical facts about FDM printing, and it surprises almost every beginner the first time they encounter it.

When an FDM printer extrudes a bead of filament, that bead spreads slightly as it deposits — it squishes outward from the center of the extrusion path. This happens at every wall, but the direction of the squishing is important:

• On outer walls (the outside of a part), the extrusion squishes outward from the wall’s nominal surface. The part comes out slightly larger than designed.
• On inner walls (the inside of a hole), the extrusion squishes inward — toward the center of the hole. The hole comes out smaller than designed.

The result: a hole designed to be 10 mm in diameter prints as approximately 9.6–9.8 mm. A peg designed to be 10 mm prints as approximately 9.8–10.0 mm. Two parts with a 10 mm nominal dimension will not fit together — the peg is too large for the hole.

This isn’t a flaw in your printer. It’s a fundamental consequence of how FDM extrusion works, and every designer working with FDM printing accounts for it.

What “Clearance” Means

Clearance is the intentional difference in size between a peg (or shaft, or tab) and its mating socket (or hole, or slot). You make the peg slightly smaller than the socket — the amount of this size difference is the clearance.

Different clearances produce different fits:

These are starting-point estimates. Your actual values will differ based on your printer and materials. That’s what the test coupon is for.

Step 1 — The Tolerance Test Coupon

Print This Before Every New Printer or Material

The tolerance test coupon is a small, quick print that gives you empirical data about your specific printer’s actual clearances. Print it once with your standard material and settings. Test each peg-socket pair. Record the results. These numbers become the constants in your design files.

You’ll need to do this test if you:

• Use a new printer you haven’t printed on before
• Switch to a significantly different filament (e.g., from PLA to PETG)
• Change your nozzle size
• Change your slicer settings significantly (especially layer height)

// Tolerance Test Coupon
// Prints a row of pegs and a row of matching sockets at five clearance values.
// After printing: test each peg in each socket. Record which clearances give
// press-fit, slip-fit, and loose fit.

nominal        = 10;     // mm — nominal peg diameter
test_h         = 8;      // mm — peg height
plate_t        = 3;      // mm — socket plate thickness
socket_d_outer = nominal + 8;   // mm — outer diameter of socket annulus

clearances = [0.0, 0.1, 0.2, 0.3, 0.4];   // mm — the five clearances to test

module test_peg(clearance) {
  // Peg diameter = nominal - clearance
  color("SteelBlue")
    cylinder(d=nominal - clearance, h=test_h, $fn=32);
}

module test_socket() {
  // All sockets have the same nominal hole; pegs vary
  color("Coral")
  difference() {
    cylinder(d=socket_d_outer, h=plate_t, $fn=32);
    translate([0, 0, -0.001])
      cylinder(d=nominal, h=plate_t + 0.002, $fn=32);
  }
}

module clearance_label(clearance) {
  // Small label showing the clearance value
  translate([0, -(nominal/2 + 5), 0])
    linear_extrude(1)
      text(str(clearance, "mm"), size=2.5, font="Liberation Sans",
           halign="center", $fn=4);
}

// Row 1: Pegs — each has a different clearance reduction applied
for (i = [0 : len(clearances) - 1]) {
  translate([i * (socket_d_outer + 4), 0, 0]) {
    test_peg(clearances[i]);
    clearance_label(clearances[i]);
  }
}

// Row 2: Sockets — all have the same nominal hole
translate([0, -(socket_d_outer + 8), 0])
  for (i = [0 : len(clearances) - 1]) {
    translate([i * (socket_d_outer + 4), 0, 0])
      test_socket();
  }

How to Read the Results

After printing, test each peg in each socket. Record:

These measured values replace the rough estimates in the table above. Record them in a note or file, and use them for every design from now on.

Step 2 — Encoding Tolerance as Named Constants

Never Hardcode Tolerance Values

Tolerance clearance values should appear in your design file exactly once — at the top, as named constants. When you measure different clearances (because you’re on a different printer, or using PETG instead of PLA), you change the constant in one place and the entire design updates.

// ============================================================
// TOLERANCE CONSTANTS — measured from your test coupon print
// Run the test coupon, measure, and update these values.
// ============================================================
PRESS_FIT_C = 0.2;    // mm — tightest peg that enters with thumb pressure
SLIP_FIT_C  = 0.3;    // mm — loosest peg that doesn't rattle
SNAP_C      = PRESS_FIT_C;   // snap-fits use press-fit clearance

// Use these constants throughout the file:
// hole_r = peg_r - SLIP_FIT_C    (for a slip-fit hole)
// hole_r = peg_r - PRESS_FIT_C   (for a press-fit hole)

This is exactly the same DRY principle from Lesson 3 applied to physical measurements. The constants are derived from reality (your test print); the geometry uses those constants; change one measurement and everything that depends on it updates automatically.

Step 3 — Snap-Fit Cantilever Arms

What a Snap-Fit Is

A snap-fit is a self-locking fastener made entirely from the printed plastic itself. A thin, flexible beam (the cantilever arm) deflects as the mating part pushes past it, then springs back to its original position, locking the parts together. Think of the plastic tab that holds a battery cover in place, or the clip that holds a phone case together.

Snap-fits are one of the most elegant features you can design. When they work well, they’re intuitive, require no separate hardware, and can be assembled and disassembled dozens of times without wearing out. When they’re designed wrong, they either crack (too stiff) or don’t hold (too flexible).

The Flexibility Rule

The key design parameter is the beam flexibility ratio: beam_thickness / beam_length. For PLA, this ratio must be 0.15 or less — meaning the beam’s thickness must be at most 15% of its length. A beam that’s too thick relative to its length won’t flex and will crack instead of deflecting.

Different materials allow different ratios because they have different stiffness (elastic modulus):

module snap_arm(beam_l=20, beam_t=1.8, beam_w=8, hook_h=1.2, hook_angle=30,
                material="PLA") {

  // Maximum flexibility ratio by material
  max_ratio = (material == "TPU")  ? 0.25 :
              (material == "PETG") ? 0.18 :
              (material == "Nylon")? 0.20 :
              (material == "ABS")  ? 0.12 :
              0.15;  // default: PLA

  ratio = beam_t / beam_l;

  // Validate before any geometry is created
  assert(ratio <= max_ratio,
    str("snap_arm: beam_t/beam_l ratio (", ratio,
        ") exceeds maximum for ", material, " (", max_ratio,
        "). Reduce beam_t to ≤ ", floor(beam_l * max_ratio * 10) / 10, "mm."));

  union() {
    // The flexible beam itself
    cube([beam_w, beam_l, beam_t]);
    // The hook at the end of the beam that catches the mating part
    translate([0, beam_l, 0]) union() {
      rotate([0, -hook_angle, 0])
        cube([beam_w, 2, hook_h]);
      translate([0, 0, beam_t])
        cube([beam_w, 2, hook_h]);
    }
  }
}

// PLA snap arm — standard sizing
snap_arm(beam_l=20, beam_t=1.8, beam_w=8, hook_h=1.5, material="PLA");
// For a 20mm PLA beam: max thickness = 20 × 0.15 = 3.0mm. This design uses 1.8mm — safe.

// PETG snap arm — can be slightly thicker, more resilient
translate([15, 0, 0])
  snap_arm(beam_l=20, beam_t=2.2, beam_w=8, hook_h=1.5, material="PETG");

Orienting the Snap-Fit for Printing

Snap-fit beams need to flex in one specific direction. For maximum strength and flexibility, the beam should be printed so that the flex direction is perpendicular to the layer lines. This means orienting the print so the beam runs horizontally and flexes up-down (in the Z direction), not sideways (where layer interfaces would create a weakness).

Step 4 — Dovetail Slide Joint

What a Dovetail Is and Why It’s Useful

A dovetail joint has a trapezoidal cross-section — wider at one end than the other, like the tail of a dove. This shape means the joint can only slide in one direction. You can slide two dovetail pieces apart, but you cannot pull them perpendicular to the slide direction — the trapezoidal shape prevents it.

This makes dovetails excellent for: drawer rails, camera slider tracks, adjustable phone mounts, and any assembly where you want parts that can be separated easily but don’t fall apart during normal use.

dt_l     = 50;    // mm — length of the slide
dt_w_top = 8;     // mm — narrower dimension (top of trapezoid)
dt_w_bot = 12;    // mm — wider dimension (base of trapezoid)
dt_h     = 5;     // mm — depth of the dovetail profile
clearance = 0.2;  // mm — your measured slip-fit clearance

module dovetail_male(l=dt_l, w_top=dt_w_top, w_bot=dt_w_bot, h=dt_h) {
  // The trapezoidal profile, extruded along the Y axis
  profile = [
    [-w_bot/2, 0], [ w_bot/2, 0],   // wide base
    [ w_top/2, h], [-w_top/2, h]    // narrow top
  ];
  rotate([90, 0, 0])
    linear_extrude(l)
      polygon(profile);
}

module dovetail_female(l=dt_l, w_top=dt_w_top, w_bot=dt_w_bot, h=dt_h, c=clearance) {
  // Female slot: same shape but all dimensions enlarged by clearance
  profile = [
    [-(w_bot/2 + c), -0.001], [ w_bot/2 + c, -0.001],
    [ w_top/2 + c,   h + c ], [-(w_top/2 + c), h + c]
  ];
  rotate([90, 0, 0])
    linear_extrude(l + 0.002)
      polygon(profile);
}

// Part A: a plate with a female dovetail slot
difference() {
  cube([30, dt_l, 15]);
  translate([15, -0.001, 5])
    dovetail_female();
}

// Part B: the sliding piece with a male dovetail
translate([40, 0, 0]) {
  cube([30, dt_l, 10]);
  translate([55 - 40, 0, 5])
    dovetail_male();
}

Step 5 — Stackable Bin System

Designing Bins That Stack

For parts that stack vertically, one piece needs a raised lip on top that fits inside the walls of the next piece. The outer dimensions of this lip must be slightly smaller than the inner dimensions of the wall — by your slip-fit clearance — so the stacked bin sits snugly but can still be separated by hand.

bin_w     = 80;    // mm — bin width
bin_d     = 60;    // mm — bin depth
bin_h     = 40;    // mm — bin height
wall      = 2.5;   // mm — wall thickness
lip_h     = 5;     // mm — height of the stacking lip
lip_clear = 0.25;  // mm — your measured slip-fit clearance

module bin_body() {
  difference() {
    cube([bin_w, bin_d, bin_h]);
    translate([wall, wall, wall])
      cube([bin_w - 2*wall, bin_d - 2*wall, bin_h]);  // hollow interior, open top
  }
}

module stacking_lip() {
  // Lip outer dimensions = bin inner dimensions - clearance
  // This makes the lip fit inside the next bin's walls
  translate([lip_clear, lip_clear, bin_h])
    difference() {
      cube([bin_w - 2*lip_clear, bin_d - 2*lip_clear, lip_h]);
      translate([wall - lip_clear, wall - lip_clear, wall])
        cube([bin_w - 2*wall, bin_d - 2*wall, lip_h]);
    }
}

bin_body();
stacking_lip();

After building this, change lip_clear and note how it affects the stacking fit. If you print two bins and they don’t stack or are too loose, adjust lip_clear by 0.05–0.10 mm and reprint the test piece.

Step 6 — Heat-Set Threaded Inserts

The Problem with Plastic Threads

If you tap a thread directly into printed plastic and screw a bolt into it repeatedly, the plastic threads will wear down and eventually strip. This makes plastic-threaded holes unsuitable for any assembly that will be disassembled and reassembled multiple times.

Heat-set threaded inserts solve this problem. They are small brass cylinders with internal threads and external ridges. You heat them with a soldering iron and press them into a printed hole — the heat melts the plastic around the insert, the ridges embed into the material, and when it cools, you have a permanent metal thread that won’t strip even after many assembly cycles.

Heat-set inserts are commonly available in M2, M3, and M4 sizes and are standard hardware in professional product design.

// M3 brass heat-set insert dimensions:
// Outer diameter: ~4.5mm; Length: ~5.7mm
module m3_insert_pocket(depth=6) {
  // Slightly undersized hole — insert is heated and pressed in with force
  cylinder(r=2.35, h=depth + 0.001, $fn=16);  // (4.5 + 0.2) / 2
}

// M4 brass heat-set insert:
// Outer diameter: ~5.6mm
module m4_insert_pocket(depth=8) {
  cylinder(r=2.9, h=depth + 0.001, $fn=16);   // (5.6 + 0.2) / 2
}

// Example: a plate with two M3 insert pockets
difference() {
  cube([40, 30, 10]);
  translate([10, 15, -0.001]) m3_insert_pocket(depth=10.002);
  translate([30, 15, -0.001]) m3_insert_pocket(depth=10.002);
}

Note: Heat-set insert hole dimensions vary between manufacturers. Check the datasheet for your specific inserts. The values above are typical for common brass inserts.

Step 7 — True Chamfers

What a Chamfer Is

A chamfer is a 45° beveled edge where two surfaces meet at a sharp corner. Chamfers serve two purposes in printed parts: they look more professional than a sharp edge, and they can act as lead-ins that help parts align during assembly.

A common mistake is creating a chamfer by simply cropping the top of a part at an angle — this produces a slanted surface, but it’s not a true chamfer created from the model’s geometry. A true chamfer is created using a difference() boolean cut.

module chamfered_box(w, d, h, c=2) {
  // c = chamfer size in mm (both horizontal and vertical dimension of the bevel)
  difference() {
    cube([w, d, h]);
    // Remove the top c millimeters of the edges
    // by cutting a hollow frame shape from the top
    translate([0, 0, h - c])
      difference() {
        cube([w, d, c + 0.001]);                      // top layer of the box
        translate([c, c, 0]) cube([w - 2*c, d - 2*c, c + 0.001]);  // inset rectangle
      }
  }
}

chamfered_box(50, 40, 20, c=3);

The chamfer logic: take the top c mm of the box as a separate region. Subtract an inset rectangle from it, leaving only the border frame. Remove that border frame from the original box. The result is a clean 45° bevel around the top perimeter.

Step 8 — Dowel Pins for Alignment

Why Alignment Pins Matter

When two parts are assembled by hand, they may not align perfectly — especially if the mating surfaces are flat. Dowel pins are small cylindrical protrusions on one part that fit into matching pockets on the other. They guarantee precise alignment regardless of how the parts were held during assembly.

One part has the pins (protruding pegs). The other has the pockets (matching blind holes). The pins enter the pockets with a press-fit or slip-fit clearance, locking the parts into perfect alignment.

pin_r     = 3;      // mm — pin radius
pin_h     = 6;      // mm — pin height
pin_clear = 0.15;   // mm — slightly tighter than slip-fit for precise alignment

module alignment_pin() {
  cylinder(r=pin_r, h=pin_h, $fn=32);
}

module alignment_pocket() {
  // Slightly larger radius and slightly deeper — ensures pin seats fully
  cylinder(r=pin_r + pin_clear, h=pin_h + 0.5, $fn=32);
}

// Part A — has two alignment pins protruding from top face
cube([50, 40, 5]);
translate([10, 10, 5]) alignment_pin();
translate([40, 30, 5]) alignment_pin();

// Part B — has matching pockets in bottom face
translate([60, 0, 0])
  difference() {
    cube([50, 40, 5]);
    translate([10, 10, -0.001]) alignment_pocket();
    translate([40, 30, -0.001]) alignment_pocket();
  }

Exercises

Exercise 8.1: Print the tolerance test coupon. Test each peg-socket pair. Record your press-fit and slip-fit clearance values. Update PRESS_FIT_C and SLIP_FIT_C with your measured values.

Exercise 8.2: Design a snap-fit battery cover for a 60 × 40 × 20 mm space using your measured press-fit clearance and the snap_arm() module. Verify the beam flexibility ratio before printing.

Exercise 8.3 (Advanced): Create a parametric box set where a size_scale parameter (values 0.5, 1.0, 2.0) generates small, medium, and large boxes that all use the same lid design and tolerance values. Generate all three sizes with a bash/PowerShell loop and verify each with 3dm info.

Quiz — Lesson 8 (15 questions)

1. Why do FDM-printed holes consistently come out smaller than designed? Explain the physical mechanism.
2. What clearance range (in mm) produces a slip-fit for a typical FDM printer with a 0.4mm nozzle and PLA?
3. What is a press-fit, and what application would you use one for?
4. What is the beam_t / beam_l flexibility rule for PLA snap-fit cantilever beams?
5. Why must you print a tolerance test coupon rather than using published clearance values from a chart?
6. What is a heat-set threaded insert and why is it preferred over a plastic-tapped hole for assemblies that are disassembled repeatedly?
7. What is a dovetail joint and in which direction does it lock?
8. What does a stacking lip do in a stackable bin design, and how does clearance factor into its dimensions?
9. True or False: a thicker snap-fit beam is easier to deflect than a thinner one of the same length.
10. What happens if you design a stacking lip with clearance = 0mm?
11. Explain the concept of “tolerance stack-up.” If three parts each have ±0.2mm dimensional variation, what is the worst-case total gap variation in an assembled chain of three?
12. Why should tolerance clearance values be defined as named constants at the top of a file rather than hardcoded at each use?
13. Describe how a chamfer is created using difference(). What shape is subtracted from the original?
14. For a snap-fit clip made of PLA with beam_l = 18mm, what is the maximum beam_t allowed by the flexibility rule? Show your calculation.
15. Describe how you would design and conduct a complete tolerance test for a new printer. What prints would you make, what would you measure, and how would you decide on your final clearance values?

Extension Problems (15)

1. Design a complete stackable bin set (small, medium, large) where each size nests inside the next. Use your measured tolerance values throughout.
2. Build a snap-fit box lid that attaches with four clips. Make the number of clips a parameter and validate the beam dimensions with assert().
3. Design a press-fit peg and socket set with five clearances from 0.0 to 0.4 mm. Print one set, test all pairs, and create a table showing which clearance produced which fit type on your printer.
4. Create a wall-mount organizer using snap-fit clips that attach to a standard pegboard (hole pitch = 25.4mm, hole diameter = 6.35mm).
5. Build a two-part enclosure with heat-set insert pockets for M3 screws and matching through-holes for the bolts. Test with real hardware.
6. Design a snap-together dice tray: the tray snaps into a carrying case lid using four snap clips.
7. Create an alignment jig using two dowel pins and matching pockets. Use it to verify your printer’s positional accuracy by measuring pin spacing with calipers.
8. Build a cable management clip with a snap-fit that can be opened and closed repeatedly for easy cable insertion and removal.
9. Design a telescoping tube: an inner cylinder that slides freely inside an outer cylinder using your measured slip-fit clearance.
10. Create a bayonet mount: a part that locks with a 90° twist.
11. Design a “living hinge” — a thin flexible connection between two rigid sections that can be folded. Research the appropriate wall thickness and document which materials are suitable.
12. Build a parametric drawer divider system: interlocking slotted panels that can be arranged in any grid configuration.
13. Design a self-locking dovetail joint that slides together in one direction and resists being pulled apart in any perpendicular direction.
14. Create a complete assembly drawing in OpenSCAD: an exploded view with each component translated away from the assembly center, with clear labels and a tolerance reference table as a comment block.
15. Conduct a failure mode analysis for a snap-fit clip: list five ways it could fail in use, rate each by likelihood and severity, and propose a design modification to reduce the top two risks.

References and Helpful Resources

• Snap-Fit Design Principles — Bayer MaterialScience Snap-Fit Design Manual

• OpenSCAD User Manual — Difference and Boolean Operations — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/CSG_Modelling

• Tolerance and Fit in FDM Printing — All3DP Guide — https://all3dp.com/2/fdm-3d-printing-tolerances/

Supplemental Resources

• Programming with OpenSCAD EPUB Textbook — assets/Programming_with_OpenSCAD.epub — Assemblies and interlocking features
• 3DMake GitHub Repository — https://github.com/tdeck/3dmake
• All other reference documents are embedded as appendices below — no separate files needed.

Part 2: Extension Project and Reference Appendices

All supporting documents for Lesson 8 are included below. You do not need to open any additional files.

Appendix A: Snap-Fit Clip — Extension Project

Estimated time: 3–6 hours

Overview

This extension project takes the snap-fit concepts from Lesson 8 and turns them into a systematic engineering investigation. Rather than building a snap-fit and hoping it works, you will design a parametric test structure, print it at three different tolerance values, measure what happens, and let the data drive your final design.

This is how snap-fit components are actually designed in professional practice: tolerance ranges are established empirically for a specific material-printer combination, then codified as constants for future designs.

Learning Objectives

By completing this project, you will:

• Design flexible components that must bend without failing
• Conduct tolerance and material testing systematically
• Understand the relationship between geometry, material properties, and functional performance
• Document design iterations and trade-offs in a format that would transfer to a colleague

Objective

Design a parametric snap-fit clip with adjustable clip thickness and spacing. Use it to determine optimal tolerances for your specific printer and material combination.

Tasks

1. Design a parametric snap-fit test piece with adjustable clip thickness and spacing. All key dimensions must be variables. The design must include at least one cantilever beam using the beam_t / beam_l flexibility rule from Lesson 8.

2. Print test pieces for three tolerance values. For each variant, change only the tolerance variable — keep all other parameters fixed. Label each print (embossed text, or a note taped to the print).

3. Test each clip for snap-fit behavior. For each variant: assemble and disassemble at least 5 times. Record the effort required, any deformation observed, and whether the clip still functions after 5 cycles.

4. Refine dimensions based on results. Choose the tolerance value that produced the most reliable behavior and create a final clip design. Write a one-paragraph justification of your choice.

Deliverables

• Source .scad file with parametric clip modules (all key dimensions as named variables)
• Test print results table (see student documentation template in Appendix B)
• Final clip design with recommended print settings documented
• Completed student documentation template

Starter Code

The stackable bins example from Lesson 8 demonstrates the stacking rim and clearance pattern that snap-fit features build on. Use it as a reference for parametric structure, then design your own snap-fit geometry.

// Stackable Storage Bins — Structural Reference
// This example shows the clearance and rim pattern.
// Your snap-fit clip will use similar parametric constants.

bin_w        = 80;    // mm — bin width
bin_d        = 120;   // mm — bin depth
bin_h        = 60;    // mm — bin height
wall         = 2;     // mm — wall thickness
rim          = 3;     // mm — interlock rim height
chamfer      = 2;     // mm — top edge chamfer
stack_clear  = 0.6;   // mm — clearance between stacked bins (measure yours)

module outer() {
  cube([bin_w, bin_d, bin_h]);
}

module inner() {
  translate([wall, wall, wall])
    cube([bin_w - 2*wall, bin_d - 2*wall, bin_h - 2*wall]);
}

module body() {
  difference() { outer(); inner(); }
}

module rim_outer() {
  translate([0, 0, bin_h])
    cube([bin_w, bin_d, rim]);
}

module rim_inner() {
  translate([wall + stack_clear, wall + stack_clear, bin_h])
    cube([bin_w - 2*(wall + stack_clear),
          bin_d - 2*(wall + stack_clear), rim]);
}

module chamfer_top() {
  difference() {
    children();
    translate([-1, -1, bin_h - chamfer])
      cube([bin_w + 2, bin_d + 2, chamfer + 2]);
  }
}

union() {
  chamfer_top() { body(); }
  rim_outer();
  difference() { rim_outer(); rim_inner(); }
}

Snap-fit beam starting scaffold — adapt this for your test piece:

// Snap-Fit Cantilever Beam — Parametric Test Scaffold
// Replace the base_body and target geometry with your own design.

// ---- Key Parameters ----
beam_l      = 15;    // mm — beam length (longer = more flex)
beam_t      = 1.5;   // mm — beam thickness (thinner = more flex)
beam_w      = 6;     // mm — beam width
hook_h      = 1.2;   // mm — hook catch height (the lip that locks)
tolerance   = 0.2;   // mm — clearance for the socket opening
base_w      = 30;    // mm — base block width
base_d      = 20;    // mm — base block depth
base_h      = 4;     // mm — base block height

// Flexibility check: beam_t / beam_l should be < 0.1 for PLA
echo("Flexibility ratio:", beam_t / beam_l,
     "(target < 0.1 for reliable snap-fit)");
assert(beam_t / beam_l < 0.12,
  str("Beam too stiff: beam_t/beam_l = ", beam_t/beam_l,
      ". Reduce beam_t or increase beam_l."));

// ---- Snap-Fit Arm ----
module snap_arm() {
  union() {
    // Main cantilever beam
    cube([beam_w, beam_l, beam_t]);
    // Hook at tip
    translate([0, beam_l - hook_h, 0])
      cube([beam_w, hook_h, beam_t + hook_h]);
  }
}

// ---- Socket (receiver) ----
// The socket opening is wider than the arm by 2×tolerance
module snap_socket() {
  socket_opening = beam_w + 2 * tolerance;
  difference() {
    cube([base_w, base_d, base_h]);
    // Socket slot
    translate([(base_w - socket_opening) / 2, 0, -0.001])
      cube([socket_opening, beam_l + hook_h + tolerance, base_h + 0.002]);
  }
}

// ---- Test Assembly (render both for sizing check) ----
snap_socket();
translate([(base_w - beam_w) / 2, 0, base_h])
  snap_arm();

Assessment Questions

1. What clip thickness and spacing values produced a reliable snap-fit for your specific printer and material?
2. How did you balance flexibility (easy to snap and unsnap) with durability (no premature failure)?
3. What would you change in the design if this clip needed to survive 1,000+ assembly cycles?

Appendix B: Snap-Fit Clip — Student Documentation Template

Author: ________________ Date: __________ Description: Design a snap-fit connector that joins two 3D-printed parts without external fasteners.

Design Concept

• What two parts will your snap-fit connect?
• Design approach (cantilever arm, torsion box, other):
• Material selected and expected flex limits:
• How did you verify the beam flexibility ratio (beam_t / beam_l)?

Tolerance Specifications

Flexibility ratio check:

beam_t / beam_l = ___ / ___ = ___
Target: < 0.1 for PLA, < 0.08 for PETG
Result: [ ] Pass   [ ] Fail — adjusted to: ___

Test Print Results

Print three variants with different tolerance values. Change only the tolerance variable between variants.

Selected tolerance value: _____ mm Justification (one paragraph — reference your test data, not intuition):

Assembly Testing Log

Cycle 1 — Initial Assembly

• Date:
• Effort required to snap together (easy / moderate / hard / wouldn’t snap):
• Snap strength — resistance to pulling apart (weak / moderate / strong / won’t release):
• Visual inspection — any deformation, whitening at bend, or cracking:

Cycle 2

• Date:
• Observations:

Cycle 3

• Date:
• Observations:

Cycle 4

• Date:
• Observations:

Cycle 5

• Date:
• Observations:

Durability Assessment

• After 5 cycles, is the snap-fit still functional? Yes / No / Partially
• Any permanent deformation observed? Describe:
• Estimated service life based on observed degradation rate:

Mechanical Analysis

Answer in complete sentences:

1. Describe the snap mechanism — explain why it works mechanically, not just that it does.

2. What material properties enable this design? What would happen if you printed the same geometry in a rigid material with no flex (like resin)?

3. Where are the stress concentration points in your design? How did you address them?