Made by AI, Directed by David Stein

Search
Creative Coding

Pen Plotter Tutorial: Getting Started With AxiDraw and vpype

Your code already makes lines. A plotter draws them with a real pen on real paper — here's the whole chain from sketch to finished drawing.

5 min read

Generative work on screen has an oversupply problem: everything is infinitely reproducible and nothing is an object. A pen plotter is a small machine that holds an actual pen and drags it across actual paper following coordinates you supply. The output is a unique drawing with ink variation, paper texture and the faint evidence of a machine having spent two hours on it.

It is also a genuinely good discipline for a coder, because a plotter cannot fake anything. No fills, no alpha, no anti-aliasing, no gradients. You have lines, and you have how many of them you’re willing to wait for.

What you need

The machine. The AxiDraw from Evil Mad Scientist is the default recommendation — a pen-holding gantry that takes any pen you can clamp, with well-maintained software and a long track record in the art community. The V3/A3 is the common choice for artists who want to work larger than letter size. It’s not cheap.

Cheaper routes exist and are legitimate starting points: converted 3D printers with a pen mount, the iDraw and similar AxiDraw-compatible machines, or a homebuilt CoreXY frame. The software chain below is the same for all of them, because it all ends in SVG.

The pen. This matters more than beginners expect. Start with fineliners — Sakura Pigma Micron, Staedtler pigment liners — in the 0.3–0.5mm range. Fountain pens and brush pens are where the interesting textures are, and they are also where the blots, skips and paper-tears are. Earn those.

The paper. Heavier than you think. 200gsm+ for anything with dense linework, because a pen passing over the same spot forty times will pill and then tear lighter stock.

Step 1: make lines, not pictures

The mental shift is the first real step. Whatever you write your sketches in — Processing, p5.js, Python, openFrameworks, Nannou — you need it to output paths, not pixels.

In Processing, that means the SVG export renderer rather than screenshotting the canvas:

import processing.svg.*;

void setup() {
  size(800, 1000, SVG, "output.svg");
  // your drawing code — line(), beginShape()/vertex()/endShape()
  // NO fill(), NO image operations
  exit();
}

In p5.js, p5.js-svg adds an SVG renderer. In Python, vsketch is built specifically for plotter work and is worth starting with over raw svgwrite.

The rule that governs everything downstream: if it isn’t a stroked path, it will not plot. A filled shape either vanishes or, depending on your toolchain, becomes a solid block of ink that destroys the paper. Convert fills to hatching deliberately, or don’t use them.

Step 2: run it through vpype

This is the step people skip, and skipping it is why their first plot takes four hours and looks scruffy.

vpype is a command-line SVG processor built for plotters. Your generative output is naive: paths in whatever order your loop emitted them, duplicate overlapping lines, tiny stray segments, and a pen that lifts and travels across the whole page between every stroke.

pip install vpype

vpype \
  read input.svg \
  linemerge --tolerance 0.5mm \
  linesort \
  reloop \
  linesimplify --tolerance 0.1mm \
  layout -m 2cm a3 \
  write output.svg

What each one is doing:

  • linemerge joins paths whose endpoints are nearly touching into single continuous strokes. Fewer pen lifts, cleaner joins.
  • linesort reorders paths to minimise travel distance between them. This is the one that halves your plot time. It changes nothing about the image.
  • reloop randomises where closed loops start, so the tiny ink blot at a path’s start point isn’t in the same place on every circle.
  • linesimplify drops redundant points. Smaller file, smoother motion.
  • layout centres and scales to your paper with a margin.

Run vpype ... show at the end to preview before committing a pen to paper.

Step 3: plot

For AxiDraw, the AxiDraw CLI or the Inkscape extension both work; the CLI is better once you’re iterating.

axicli output.svg --model 2 --speed_pendown 25

Before the real thing, always:

  1. Plot a bounding box first with the pen raised, to confirm your drawing lands on the paper. Every plotter user has drawn beautifully onto the desk.
  2. Set pen height carefully. Too high skips, too low digs and bleeds. Test on the same paper stock you’ll use.
  3. Start slow. --speed_pendown 25 is conservative. You can push it once you know how your pen behaves.

The failures you’ll actually hit

  • Four-hour plots. Almost always unsorted paths. Run linesort.
  • Blobs at path starts. Ink pooling on pen-down. Use reloop, and consider a faster pen-down speed.
  • Torn paper. Too many passes over one area, pen too low, or stock too light.
  • Drifting registration on multi-pen plots. Don’t move the paper between colour passes. Tape it down, change pens, continue.
  • A drawing that’s technically perfect and visually dead. The most common one. Screen work survives on colour and fill; plotted work survives on line density variation. Give it areas of rest.

Where to go next

Once the chain works, the interesting problems are aesthetic rather than technical: hatching algorithms for tonal variation, flow fields for organic line behaviour, multi-pen layer separation for colour, and deliberately introducing error — plotting on wrinkled paper, using a pen that’s running dry, letting the machine slip.

Vera Molnár is the reference point worth studying. She was making plotter work in the late 1960s, and the conceptual questions she was asking about systematic variation and controlled randomness have not been improved on since.

Related Reading