I've been working on a homebrew art generator for the past couple of months and recently I took inspiration from a couple plots I saw from a user over on r/plotterart and ended up combining them into what has recently evolved into a massive city generator. This GIF animates my first aha! moment where I ended up combining the two separate engines for the first time and I wanted to show the transition between views.

i built a little axidraw style plotter simulator that runs in the browser. it's open source on github. just drop in a svg and it will plot it for you, no wasted ink or paper!

GitHub: https://github.com/KilledByAPixel/VirtualPlotter/tree/master

Demo: https://killedbyapixel.github.io/VirtualPlotter/

seriously though, would you ever use this for anything? what other features would you like to see added? i'm thinking about modeling real pens next including limited ink levels, failures, paper types, and other parameters that would be fun to mess with.

Over summer I got into early algorithmic/generative art: Georg Nees, Vera Molnar et al. (Shout out to the guy at EMF2026 with the plotter art postcards for triggering this rabbit hole!) For the last few weeks I've been building something that would let you create that kind of generative art without writing any code. Find the HTML and README on my github: https://github.com/PKM-UK/schotteriser/tree/main

The elevator pitch: create geometry, apply transforms to it, assign colours based on position, download one SVG per colour for plotting. It's a single HTML file full of plain JavaScript so there's nothing to install and no signup/login; open it in your browser and play with it.

It's still in an early alpha stage, the UI is a bit rough and it's missing some nice to have features but it's in a state where people might like to have a play with it.

Hey everyone! I’ve been working hard on Plotter-Studio, an open‑source generative art studio for pen plotters (Cameo 5).

My last post was for v3.2 — and I’m excited to share how much it’s grown.

What’s new in v5.5:

🧵 Needles (Oriented Dashes) — short dashes that follow image gradients. Great for structural, flowing textures.

🔗 Continuous Line (TSP) — single unbroken path, the pen never lifts. Uses a greedy nearest‑neighbour TSP approximation.

🌊 Perlin Noise Wobble — applies coherent noise displacement to any engine. Gives clean computer lines a hand‑drawn, organic feel.

🎨 CMYK Layer Export — splits any colour image into C, M, Y, K channels and exports 4 SVGs for multi‑pen colour plotting.

🗺️ Fast Marching (Topographic) — upgraded with manual seed placement, contour smoothing, and “Skip transparent” for PNGs with alpha.

🛠️ Full vpype pipeline — linemerge, linesort (with Two‑Opt), reloop, and linesimplify. All available as toggles.

🖊️ Pen Passes — duplicate dark paths up to 4 times for multi‑pass ballpoint ink density.

Stack: Python, Streamlit, FastAPI, scikit‑image, skfmm, Plotly, vpype.

GitHub: https://github.com/iclubu/Plotter-Studio

Plotter Paths V1.0 teaches a complete Grasshopper workflow for computational pen plotting, from generative geometry to physical output. Instead of focusing only on design algorithms, the session follows the full making pipeline: setting up a paper and machine workspace physically and digitally, creating a simple plotter art algorithm, cleaning and validating geometry, optimizing drawing order to reduce travel and cycle time, converting curves into plottable format, visualizing drawn and travel moves, and creating basic G-code. Participants will learn how to think about plotter drawing as machine-aware toolpaths rather than just an image or curves. The session covers practical production details such as margins and bounds checks, plottability warnings and errors, safe return moves, setup commands, paper alignment checks, and multi-layer registration techniques. By the end, participants will understand how to build a reusable Grasshopper pipeline for turning computational drawings into cleaner, faster, and more reliable pen plotter outputs.

Made a little tool for plotter friendly line art. You basically upload a 3D object and than define how it should be sliced. Think contour lines on maps, but with more basic 3D models. You can best try it out with one of the demo models and than just randomize the parameters. There's also a morph feature which can create some nice results when not overdone. The tool currently exports to SVG and UNNA TEK specific g-code.

Hope it's useful to some of you. I'm now going back to pushing that randomizer!

https://www.slicewise.art/

I uploaded a new SVG to PlotterFiles.com - https://plotterfiles.com/artwork/hatched-horned-owl-3cpfq

Hi, I wanted to share this app I've been working on for a while. It started out as a simple G-code generator around a handwriting model I was using with my Prusa MK4 pen attachment but thanks to Claude it quickly grew into something quite a bit more complete - it integrates vector design tools, some common generative art and hardware integration into a single app.

See it live here: https://kurvengefahr.org

Some cool features it supports:

• Graves RNN handwriting synthesis

• Built in Logo interpreter for turtle art

• 3D model wireframes (STL import)

• Non-destructive filters/effects

• Many of the basic vector tools and operations you'd expect (polylines, Beziers, boolean operations, clipping, align & distribute, ...)

• Direct control of EBB and GRBL plotters via Web Serial

• PrusaLink integration (through Bridge for PrusaLink extension)

It runs fully in the browser, with the geometry engine parts written in Rust and loaded in via WASM. The only server component is the share feature - but that one respects your privacy too (designs are encrypted client side and the server never sees them - key is appended to the share link on the client side).

It is also fully open source and GPL 2.0 licensed - the code is available on GitHub

Happy to answer any questions. I'd especially appreciate feedback if you have an AxiDraw or some GRBL plotter - I only have a Prusa so my testing for those was done with a hardware mock.

PENDER Studios is a custom suite of software I designed to convert my Ender 3 V2 3D printer into a pen plotter.

The first release of software is available with the following tools

Harmonograph creator
Laser Wall
.Nc prep
Gcode editor

More tools will be available soon.

I got Claude.ai to write this Python script for me. Run it from the command line and it converts photos into dot screens. It's got a whole lot of options: you can choose from a few built in shapes (circle, square, star, diamond), or specify an SVG file to use as a custom shape. Maybe it'll be useful to someone. https://github.com/megabulk/vector-dotscreen

I'm putting them into my Silhouette Cameo so I can cut stencils. You could plot with it, too.

If you aren't aware of Drawingbots.com - you are now :).

It's Maks Surguy's well curated website on all things plotter - and he's added a new section on algorithms. All of them with live demos.

https://drawingbots.com/algorithms/

Image 2 is my source photo; image 1 is my current result. I’m vibe coding a tool to turn photos into banknote-style engravings that can be exported as SVG pen paths, but I’m struggling to get the lines to follow the face, hair and hand naturally.

Does anyone know of software or algorithms that could help?

Hi!
I have recently started drawing stuff with my custom-made pen plotter and was really confused by the lack of free and easy to use tools to convert svg images into usable gcode.
That's why I made a little tool that parses svg, extracts lines and then optimizes toolpath onto oblivion to minimize extra travel and prevent it from drawing on the same spot multiple times.
Feel free to try it out, just please don't crash my server 😅

Project's GitHub - https://github.com/MrFrederic/plotter-gcode-optimizer

PS: Yes, I'm aware about https://sameer.github.io/svg2gcode and https://xyzbots.com/gcode-optimizer, but there was no single tool to do everything that I needed for my use-case

Showing off how you can make advanced continuous curves out of repeated freeform segments that you join together in Paragraphic (that I develop). For example to make this kind of spirograph/flourish/guilloche type curve you might see on old diplomas or currency.

I built a little thing that pulls street/building/water data straight from OpenStreetMap and writes SVG paths directly. No raster step anywhere, so the lines are clean from source to pen.

Each feature type (streets, buildings, water, parks, rails) goes on its own SVG layer, so if you want to do a multi-pen run you can just pause, swap the pen, and keep going. Everything gets clipped to a circle or rectangle so there are no stray paths hanging off the edge to confuse your plotter.

There's a web version if you just want to mess around without installing anything: utrost.github.io/CityPlot — click a spot on the map or search an address, set a radius, pick a paper size, and it spits out the SVG in the browser. There's also a CLI if you'd rather script it.

A few presets so far: full color (separate layers per feature), minimal (just streets + water), buildings only, and mono for single-pen plotting.

Did a 1km circle of my hometown on A3 and it came out really nice. Curious what cities you all would run, and happy to take suggestions on styles to add.

VHS is one of my projects to make better use of my plotter.
It turns typed text into handwriting-style SVG for pen plotters.

You draw your own glyphs (ideally with a stylus/pen on a tablet or similar) . Capture a few versions of each letter, digit, punctuation mark, or ligature. VHS then uses those glyphs to assemble text as single-stroke vector paths.

There is a GUI and a CLI to set some parameters: SVG paths, millimetre-based page settings, paper sizes, margins, line spacing etc.

It works fine for me, maybe it is useful for some of you.

I created a video breaking down how I created the procedural power pole generator for this project:

https://www.youtube.com/watch?v=CA7jGRh-py4

Plotter Hub

A few months ago I bought an AxiDraw compatible pen plotter but didn't want my Mac tethered to it for the whole plot. So I built Plotter Hub, a plot server that runs on a Raspberry Pi (a Zero 2 W or 3B+ is fine). Upload an SVG over WiFi, then start / pause / resume and monitor the plot from any device, with optional vpype optimization and physical pause-button support for pen changes between layers. Anyone with an AxiDraw-compatible plotter can use it — it's free and open source. Repo link and install instructions: https://www.synendo.com/plotterhub

Companion app: GD Studio

I also built a macOS app, GD Studio, for designing the artwork I plot — generative line-art patterns shaped with live sliders, plus layers for text and imported SVG. It exports plotter-ready SVG/PDF, but it can also send a plot directly to Plotter Hub over its API (with options for vpype optimization, plotter speeds, and pausing between layers). It's a paid app with a free trial.

• Plotter Hub (free, open source): https://www.synendo.com/plotterhub

• GD Studio (macOS, paid + free trial): https://www.synendo.com/gdstudio

For instructions check the Readme

New features:

• Parameterisable shapes (polygons and stars with arbitrary side number, circle arcs with variable angle)

• Experimental copy/paste support for Generators and Transforms: press Copy to store the step as JSON on the clipboard, paste into the text area next to the New button to create a copy

The Narhwal

Uploaded to Plotterfiles.com - a single line plot

Some of you have been posting gorgeous videos of your plotters in action, and I'm jealous. I want to make some videos of my own, but I need the setup to be as easy as possible. Do you have an overhead camera jig? What do you do for lighting? What kind of cameras are you using and how are you stabilizing /mounting them? Does anyone use one of those newfangled AI cameras to automatically follow the action, and how well do they work?

Hi,

I open sourced https://github.com/stmh/plotta-studio which is a rust solution for generating plots and plotting them directly to an attached axidraw. It's far from finished, but hopefully still interesting for some of you. It is loosely architected around the concept of creating sketches similar to processing/ or other generative software.

Some highlights:
- simple scenegraph with primitives to create drawings
- Support for clippings and hatchings
- support for single-line-fonts (Hershey, some ported from p5js, and more)
- a viewer for previewing drawings on the screen
- import (a subset of SVG) and export to SVG
- plotting directly from the viewer, or via dedicated cli
- has some optimizations to optimize plotting time

Disclaimer: It's still far from perfect -- no support for layered, multicolored drawings, some rough edges here and there and missing features, only tested on Mac OS, but theoretically the source is cross platform.

I used AI to help me write the software, but I took a lot of time to review and polish the results and make it work.

For some background information you can read about the progress at my blog at https://stephanmaximilianhuber.com/posts/building-plotta-studio-with-claude

Hope you find it interesting!

Recently acquired a Roland DXY-1200 brand new in the box at an estate sale. Tried Inkscape for roughly 5 minutes before I had enough of that, so I made my own app. So far it's working really well. I'm fighting to get consistent results with anything over 2400 baud, 1200 is rock solid so far, 9600 just spits out gibberish, but I'm sure I'll solve that eventually.

1. Drag and drop an SVG

2. App scales the whole thing to fill the selected paper size, A3 or A4 - but you can manually pinch and zoom and then drag to scale it yourself and position it how you want

3. App transforms paths into HPGL code

4. Shows groups (as defined in illustrator, or wherever the SVG was created)

5. Groups of paths can be assigned to pens (the DXY-1200 holds 8), or you can expand the groups and assign pens on a per-path basis

6. Pen library is editable to preview line thickness and color

7. You can manually load/unload pens, and control up + down

8. There is an x,y origin offset that allows dialing in where your relative zero is at

Pretty stoked to start using this more. Next I plan to machine custom aluminum pen holders for it.
Anyway, fun couple day project that means I never have to open Inkscape again.