let's code some noodles

This article began as a talk at cm26 on machine control as a design material. The course it describes is the talk's main exhibit: four days of notebooks in which design students write their 3D printer's toolpaths in Python, with no slicer in between.¹ I want to do two things. First, explain what it means to write a print as a list of points and how that differs from what a slicer does, concretely enough that you could follow along. Second, make the pedagogical argument the course rests on: design students avoid technical knowledge for structural reasons, not from timidity, and the way around that is to turn the machine into a material they can play with before anyone asks them to respect it. The printing comes first. The argument is why the printing happens in a design school and not in an engineering lab. A link to the repository is at the end for anyone who'd sooner skip the argument.

A word on the title, which sits inside two fashions at once. "Machine control as design material" is one more "X as Y" title, the construction I complained about at length elsewhere on this site: it borrows legitimacy from whatever stands after the "as".² It also joins the habit of calling everything a material: theory as material, data as material, code as material. I use "as material" here as a method, not a claim. I'm not saying machine control is a craft supply, or that writing G-code is like throwing a pot. I'm saying that approaching a machine the way one approaches a material, asking what its properties are, what bends, what can be formed, and postponing the question of whether this is the prescribed use, is a productive way to meet it. Whether it is should be judged by what comes out, and the rest of this is what came out.

The slicer as a black box

If you've printed anything, you've probably done it like this: you model a shape, hand it to a slicer, and the slicer hands the printer a file. The slicer cuts your shape into layers and plans a route through each one: the outlines first, then a pattern to fill the inside, quick moves without plastic in between, and a spot where each layer starts and ends. It picks the speeds, the temperatures, and how much plastic goes where. It's very good at this, it's free, and for most of what people print you should use it.

It's also the reason most people never find out what their printer actually does. Every one of those decisions comes with a default, and the defaults all agree on what a good print is: a clean part, as if it came out of a mould, because the software was written by and for people who want parts. If you want something else, you argue with the settings one at a time, and the settings are named for what they do to a part, not for what they might do to a line. The slicer is a black box. Not a secret one; the source of most slicers is open. It's closed in the way that matters: nothing in it invites you to look inside, and the interface is built so you never have to. A box like that takes away the possibility of critique by making the question not arise. A design student who meets a 3D printer through a slicer meets a machine that has already decided what it's for.

What the printer actually receives

Here is what the printer gets: a list. Go here, push out this much plastic on the way, go there. The format is called G-code, it was written for milling machines in the late 1950s, and you can read it.³

steps = [
    fc.Extruder(on=True),
    fc.Point(x=105.0, y=85.0, z=0.288),
    fc.Point(x=145.0, y=85.0, z=0.288),
    fc.Point(x=145.0, y=125.0, z=0.288),
    fc.Point(x=105.0, y=125.0, z=0.288),
    fc.Point(x=105.0, y=85.0, z=0.288),
]

G1 F1000 X105 Y85 Z0.288 E0
G1 X145 E11.574527
G1 Y125 E11.574527
G1 X105 E11.574527
G1 Y85 E11.574527

One point is one line of G-code, and everything in the course after this is a way of producing that list without typing it. The tool is FullControl, a Python library from manufacturing engineering: you write the list as points, and it writes the G-code for your printer.⁴ Using it to teach designers is an off-label use. In the course it runs in notebooks with sliders, so you can move a number and watch the path change before you've read a line of code. No Python is assumed; the first notebook opens with its code hidden. The important change is the object, not the library. A model is a shape, and something that knows about printing has to turn a shape into motion. A list of points is already motion. The student isn't describing a part and asking the machine to approximate it. They're telling the machine where to go, and what comes out is exactly what they said, mistakes included. That's a better position to learn from.

Thickness as a variable

A path has no thickness, but what comes out of the nozzle does: a bead, about one and a half millimetres wide and half a millimetre tall on the course's printer, pressed flat onto whatever is under it.⁵ A slicer sets the bead's size once, for the whole print, because a part wants uniform walls. In your own list you can set it for every segment, and then flow becomes something you draw with. The second day is about that, and about the fact that the nozzle doesn't have to stop at the end of a layer. The height can climb a little all the way round, and a whole vessel is one bead from the bed to the rim.⁶

Let the bead swell and thin four times per lap, and the bulges stack up into straight ribs. Make it four and a half times per lap, and every lap bulges where the one below thinned, so the ribs spiral. Nothing changed but half a unit. This is the first moment in the course where people see that a property of the object, ribbed or spiralled, lives in a number they typed and not in a shape they drew. It's also what I mean by meeting the machine as a material. "What are its properties" and "what bends" get concrete answers, and the answers are in the student's hands.

Noodles, or dropping "correct"

Pasta is extruded: dough is pushed through a metal die, comes out as a continuous shape, and gets cut. The die is the cross-section, and the noodle is that cross-section dragged along a line. A vessel is the same thing, a circle dragged upward. So on the third day, the one the course is built around, we make pasta. All eight shapes below come out of the same loop. Only the numbers differ; pick one, and the loop shows you which.

length, radius         = 45,   10
ridges, ridge_depth    = 14,   0.16
rings, ring_depth      = 0,    0.0
twist, slant           = 0.0,  0.0
bend, coil, coil_turns = 0.0,  0.0,  0.0

for i in range(laps * 72 + 1):
    up, a = i / (laps * 72), tau * i / 72
    r = radius * (1 + ridge_depth * sin(ridges * a)
        + ring_depth * sin(rings * tau * up))
    a += twist * tau * up
    c = coil_turns * tau * up
    x = bend * up**2 + coil * (cos(c) - 1)
    y = coil * sin(c)
    on = up * length <= length - slant * (1 - cos(a)) / 2
    point(x + r * cos(a), y + r * sin(a), up * length, on)

A die has two limits: one cross-section for the whole length, and no say over the dough once it's out. The second half of the day takes both away. Flow, position and extrusion change along the path, and the settings go out of spec on purpose. Too much plastic, and the outside beads up like a weld. Too little, and the wall becomes a lattice with strings across the gaps. This is where the canon gets dropped. There is a canon of what a 3D printer is for, a clean, injection-mould-like part, and a list of faults, stringing, ooze, sag, blobs, that a good operator removes. We're not that industry. Once "is this correct" is postponed, stringing and ooze become techniques to build on, and the question becomes whether the result is something you'd keep.⁷ The standard changes hands, from the part to the maker, and that is what makes the technical knowledge worth having: it now buys something the student wants.

Code that asks questions

The last day doesn't hand you a product to make. It adds one idea: code that asks a question about a point before placing it. How far is this point from a spot I picked? Is it in the part where the spout goes? Has it ended up past this plane? Did the lap below stick out further than a bead can bridge? Each question is a few lines, and the answers stack on everything from the days before. That's the end of the course: an empty template, and whatever people want to print. It ends there, and not at a finished object, on purpose.

Design students arrive in one of two states with respect to anything that smells of engineering. Some are into it and don't much care about money. Many more chose design partly because they didn't get on with the technical subjects at school and still need a way to make a living, and they avoid anything that looks like a subject they expect to fail. That isn't a character flaw, and it isn't entirely their own. The technical disciplines present themselves as a matter of genius and of a certain kind of person, and that tells everyone else it isn't for them.⁸ On top of that sits a problem specific to the university. Under a prescribed study time, with credits to collect and a career to point at, every hour gets measured against whether it pays into graduation, and a detour into non-design knowledge looks like a risk nobody can afford.⁹ This is where the respect we're taught to have for powerful technology does its damage. Respect sits very close to fear, and both keep the box closed. The fear can't be adjusted directly, so the course adjusts the object of the fear: it makes the machine small, legible, and cheap to break.

So the course claims three things. The technical knowledge is not a prerequisite; it arrives when the work asks for it, and in a four-day course it arrives on day two, when somebody wants ribs and has to find out what a layer height is. Failure has to be affordable before anyone risks it, so the lessons preview at real size without a printer, a wrong path still prints something, and the objects are small. And the aim is an understood machine, not a good object, so the course ends with a template and not with a vase. None of this is new. Papanek asked for "an atmosphere permissive of failure" in 1971 and noted how rare it was, and the idea that tools generate the knowledge, and not the other way round, is at least as old as the steam engine's relation to thermodynamics.¹⁰ What the course adds is a cheap, concrete place to do it. A design student who has made a noodle on purpose is harder to intimidate with a machine afterwards.

The course, and what it hasn't shown

If you want to try this, or teach it, here's the whole course: github.com/PeterEhses/fullcontrol-workshop. Four days of notebooks, each with the taught parts, exercises, and a brief with the schedule, a table of parameters and where they break, and printer notes. One setup script for Windows and one for macOS and Linux install everything. You don't need a printer to start: every lesson previews the path at real size and writes G-code you can open in any viewer.

git clone https://github.com/PeterEhses/fullcontrol-workshop
cd fullcontrol-workshop
./setup_mac.sh        # Windows: setup_windows.bat
./run.sh 1 a          # day 1, part a. Windows: run.bat 1 a

An argument from a syllabus is not evidence that the syllabus works. I haven't measured whether students who take the course are later more willing to open technical boxes, and I'm not sure how to. The structural problem, a timetable in which a detour is unaffordable, is not solved by a course that fits inside the timetable; the course makes one detour cheap. And the stance has a failure mode: technophilia. "Treat it as material" can turn into chasing the newest tool for spectacle, where the work becomes an ornament for the technology. The guard is the verb: understand and shape, not adopt and display.¹¹ Permission to break a machine isn't evenly distributed either. With less time and money it feels out of reach, and that's where access is decided, long after "can you code" stopped being the gate.¹² So this is another thing that's reproducing cultural, social and economic capital, in Bourdieu's sense: a student who grew up taking things apart, who knows someone with a printer, or who can pay for a failed print hears the permission as obvious, and the others may not hear it as meant for them.¹³ It's a stance, not a method, and the course is one experiment toward it. Contributions are welcome: noodles I haven't thought of, profiles for other printers, translations, and fixes for whatever breaks on your machine.

The talk was given at cm26 in 2026.