Skip to main content

Preface — Open-Source Additive Manufacturing

📍 Where we are: Preface (unnumbered) — the start of Book 3. Books 1 and 2 explained what additive manufacturing is and how the processes work; this book looks at the part of the field whose source code, schematics and design files anyone can read, build and change.

The simple version

Think of a restaurant that publishes every recipe, lets you walk through the kitchen, and tells you which supplier sells each ingredient. You can cook the same dishes at home, fix the oven yourself, or open a competing restaurant. Open-source 3D printing works like that kitchen: the printer's frame design, the code in its brain, the program that turns a 3D model into movements, and the tools that monitor a print are all published, so you can inspect, copy and improve any layer.

What this chapter covers​

This preface says who the book is written for, sets the one rule every page follows (every tool, command and claim is either runnable or cited), and draws a map of the open stack, from design files at the top down to motors and heaters at the bottom. The thirteen chapters that follow each zoom into one layer of that map.

Who this book is for​

The book is rated Intermediate to Advanced. It assumes you are comfortable in a terminal: you can edit a text file, run a command, read an error message and use a package manager. It does not assume you have built a printer. If you need the basics of what a layer, a nozzle or a slicer is, read Book 1 first; if you want the physics and materials of each process, read Book 2. Here we work at the level of repositories, configuration files and wiring.

The rule: runnable or cited​

Open-source projects change fast, and many pages about them are written from memory and are out of date a year later. This book therefore follows one rule.

  • Cited. Every tool, project, licence or event named in the text is backed by an entry in the chapter's reference list: an official repository or documentation page, a licence text, or a paper. Where a version or a date matters, we give it. Software facts in this book were checked in November 2026; for example, at that time the GitHub release listings showed Marlin 2.1.2.10 and RepRapFirmware 3.7.0, and Klipper's newest tag was v0.13.0 (April 2025) [1] [2] [3]. By the time you read this, they will have moved on.
  • Runnable. Any code in the text is something you can paste and run. Where we ran a snippet, we say so ("run with Python 3 and the standard library only"). Where a snippet is a configuration fragment that needs real hardware (for example a Klipper printer.cfg section), we say it was not run on a machine and point to the documentation page it comes from.
  • Honest about gaps. If we could not verify something, such as a licence on a particular hardware design, the text says so rather than guessing. Nothing here is legal advice; where licences are discussed we describe what the published licence texts and the Open Source Hardware Association (OSHWA) pages say, and no more.

The open stack, layer by layer​

A desktop printer looks like one object, but it is a stack of cooperating layers. Each layer has open options, and each is covered by a chapter.

LayerWhat it doesOpen examples (cited in later chapters)Chapter
Designs and dataShapes and file formatsFreeCAD, OpenSCAD, STL/3MF filesCh. 7, Ch. 9
SlicerTurns a model into layers and toolpathsPrusaSlicer (AGPL-3.0) [4], OrcaSlicer, CuraCh. 6
Host softwareQueues jobs, streams G-code, monitorsOctoPrint (AGPL-3.0) [5], Moonraker (GPL-3.0) [6]Ch. 8
FirmwarePlans motion, runs heatersMarlin, Klipper, RepRapFirmwareCh. 4
ElectronicsDrives motors, reads sensorsStepper drivers, mainboards, CAN toolheadsCh. 5
MachineFrame, motion, hotendRepRap lineage, Voron, PrusaCh. 1, Ch. 3

A six-layer stack from designs and data at the top, through slicer, host software, firmware and electronics, down to the machine, with the tools named in this book at each level. The open-source additive-manufacturing stack: files flow down through the slicer as G-code to firmware, which turns them into electrical signals for motors and heaters. Original diagram by the authors, created with AI assistance.

Why the layers matter​

Because the layers talk through plain, documented interfaces (most famously G-code, a text format of movement commands), you can swap one without rewriting the others. You can run Klipper or Marlin on the same frame, or slice with PrusaSlicer or OrcaSlicer for the same firmware. That modularity is the real engineering advantage of open source in this field, and the legal framework that allows it is the subject of Chapter 2.

How the book is organised​

Part I (Roots) tells where open 3D printing came from and how its licences work. Part II (The Machine Stack) goes through the machine, its firmware and its electronics. Part III (The Software Stack) covers slicers, CAD, host software and file formats. Part IV (Beyond the Desktop) looks at materials and recycling, metal and large-format printing, research tools, and finally an honest verdict on what open source does well and badly. Part IV also explains how to contribute.

Why it matters​

Open tools are how most people first touch additive manufacturing, and many commercial machines run open firmware. Understanding the stack lets you repair a machine, audit what it does, avoid vendor lock-in and read research that builds on these tools. It also lets you judge claims of "open" critically, using the definition the community actually maintains [7].

In the real world​

Marlin describes itself as a firmware used in many commercial printers, and its README tells vendors who ship it that they must keep the source available under GPL-3.0 [2]. That one sentence shows the pattern of the whole book: open code, commercial products built on it, and a licence that sets the rules between them.

Key terms​

  • Open source (software) — software whose source code is published under a licence that lets others use, study, change and share it.
  • Open-source hardware (OSHW) — physical products whose design files are published so anyone can make, modify, distribute and use them, as set out in the OSHWA definition.
  • Firmware — the program that runs on the printer's own microcontroller, controlling motors and heaters.
  • Slicer — software that cuts a 3D model into layers and produces the toolpath instructions for the printer.
  • G-code — the line-by-line text language of machine commands, such as move to a position or set a temperature.
  • Host software — a program on a computer or small board that sends jobs to the printer and shows its status.
  • Repository — a project's online home for code or design files, usually a Git repository on a site such as GitHub.
  • Runnable or cited — this book's rule that every command can be run and every named tool or claim has a source.

Where this leads​

The story starts with a small group in England who decided a machine should be able to copy itself: RepRap and the open-hardware movement.