Generative Art for Pen Plotters: A Technical Primer

When you generate art for a screen, mistakes are invisible. A triangle with a slight gap renders fine; the display fills it in. Lines can overlap arbitrarily. Color can be sampled per-pixel.

When you generate art for a pen plotter, every mistake is permanent. The pen either touches the paper or it doesn't. Overlapping paths mean double-inking, which looks wrong on cotton paper. A gap in a stroke is a gap in the physical ink line.

The constraints aren't limitations; they're design parameters. Understanding them changes how you write generators.

SVG Is the Lingua Franca

Every plotter workflow I've found converges on SVG as the interchange format. The reasons are practical:

SVG paths are the natural representation of "move pen to X,Y, draw to X2,Y2." The M (moveto), L (lineto), and C (curveto) commands map directly to plotter motion primitives.

SVG is text. You can generate it from any language, inspect it in any editor, and debug it by reading the coordinates.

The AxiDraw driver (the most common plotter for fine art) accepts SVG directly. Your generator outputs an SVG file, you open it in Inkscape with the AxiDraw plugin, and it plots.

The critical SVG parameter: stroke width in the SVG should correspond to the actual pen tip width. For a 0.3mm Micron, set stroke-width to 0.3mm in the SVG. This matters when you're evaluating density; you want the visual preview to approximate the physical result.

Why Single-Stroke Paths Matter

A screen renderer draws each path in isolation. Overlapping paths layer visually, and the result is color mixing. Fine.

A plotter pen tracks across paper physically. If path A overlaps path B, the pen crosses that area twice. On thick paper with light ink, this doubles the ink deposit and creates visible striping. On thin paper, it can saturate and bleed.

The solution: design generators that produce non-overlapping paths, or at minimum, minimize overlap. For fill patterns (hatching, stippling), think about coverage rather than overlap.

There's a subtler version of this problem with continuous paths. A generator might output 500 separate line segments when it could output 10 continuous strokes. More pen lifts means more travel time and more opportunities for the pen to blot when it returns to paper. Continuous strokes produce cleaner, faster plots.

The optimization problem: given a set of line segments, find the traversal order that minimizes total pen-up travel distance. This is a variant of the Traveling Salesman Problem, NP-hard in general, but good approximations exist. The vpype tool does this automatically on any SVG input, which is worth knowing about.

Algorithm Families That Work Well

Not all generative art algorithms translate equally to plotters. A few that reliably produce good physical results:

Flow fields simulate vector fields and draw particle traces through them. The traces are naturally continuous paths. Perlin noise fields produce organic, almost geological results. The key parameter is step size; smaller steps mean smoother curves but longer files.

Lorenz attractors and other chaotic systems produce infinitely non-repeating paths through 3D space. Projecting them onto 2D gives dense, tangled line work that looks good at high iteration counts. Because the path never closes, you can control density by controlling iteration count.

Voronoi tessellations produce networks of bounded cells. The cell edges are natural single-stroke paths. Relaxed Voronoi (Lloyd's algorithm) produces more uniform cell sizes. Combined with variable cell sizing based on an input image, you get dithered portraits made of geometry.

Recursive subdivision (quadtrees, triangle subdivision) produces patterns with self-similar structure at multiple scales. The subdivision boundary lines are natural paths. Start with a rectangle, subdivide based on local image intensity, and you get an abstract representation of any input image.

Truchet tiles fill a grid with simple tile shapes that connect across edges. The key insight: design tiles so connected lines span multiple tiles, creating long continuous paths rather than isolated shapes. This minimizes pen lifts and produces more interesting visual flow.

The AI Scoring Pipeline

Running 105+ experiments manually would mean 105+ physical plots. I don't have that kind of paper budget or time.

Instead, every generator gets scored by an LLM judge before it ever touches the plotter. The scoring criteria:

Composition: does the piece use the available space well? Heavy clustering in one corner scores low. Balanced visual weight across the frame scores high.

Line density: too sparse looks unfinished; too dense loses the detail that makes plotter art interesting at close range. The target density depends on paper size. For A4, I aim for 40-60% coverage.

Visual interest: the hardest to formalize. Does the piece have focal points? Does it reward looking at it for more than 10 seconds? The judge looks for variety in mark density, interesting transitions, and emergent structure that wasn't explicitly programmed.

Plottability: are there construction artifacts? Tiny isolated marks that would require a full pen lift cycle for one dot? Very long straight lines that require precise paper grip?

The judge generates a score from 0-10 and a brief explanation. I only plot generators that score 7+. This has saved a significant amount of time and paper.

The current scoring prompt and rubric are in the pen plotter experiment log.

Materials Matter

The generator doesn't exist in isolation. The same SVG looks different depending on paper and ink.

Paper: I use Strathmore 400 Series Bristol (vellum surface, 270gsm) for production plots. It takes ink cleanly without bleed, is stiff enough for long sessions without cockling, and has enough texture to give ink strokes slight character. For prototyping I use Canson marker paper; it's cheaper and the smooth surface is more forgiving of overlapping paths.

Ink: Pigma Micron 0.1mm and 0.3mm for most work. The Micron ink is archival and doesn't fade. For single-color pieces, I sometimes use a Sailor Profit fountain pen with Pilot Iroshizuku ink; the sheen on coated paper is something screen art can't replicate.

Speed: The AxiDraw's motor speed directly affects line quality. Too fast and the pen skips on texture. Too slow and ink bleeds at corners where the pen pauses. I run at 60% of max speed for most work, 40% for very fine detail.

Getting Started

If you're writing your own generators, start with a flow field. It's the most forgiving algorithm family: organic, continuous paths, naturally limited overlap. Set your canvas to A4 at 96 DPI (the SVG default), use stroke-width 0.5mm for testing, and score the output before committing to a plot.

The Edgeless lab experiments page logs all the generator experiments including source code for the ones that scored well. The Lorenz attractor generator, the Voronoi dither, and the recursive quad subdivision are all open.

If you want to go deeper into the scoring and iteration pipeline, the pen plotter autoresearch pattern documents how the AI-in-the-loop workflow runs.