Optimal Path Planning and Hatch Filling For Pen Plotters

On Saturday mornings you can usually find me doing some sort of random craft project with my favorite tiny human. My daughter is a high energy curious 5 year old and I’m always trying to feed into her enthusiasm with open-ended toys, simple science experiments, origami, or drawing & coloring.

Much of the coloring she delegates to me (of course) and lately while filling in numerous random shapes I’m reminded of an interesting challenge I encountered while playing with an open-ended toy of my own.

Almost immediately after building and experimenting with my robotic cup plotter project I realized that smart path planning of drawing strokes is critical to getting jobs completed in a reasonable amount of time.

Plotters, 3d printers, & cnc machines in general can be mesmerizing to watch, but fascination can turn to frustration when poorly planned tool paths remind you just how dumb these machines really are.

“Gahhhh why is my machine drawing little bits all over the place rather than finishing off an entire area before moving on?”

Last month I shared how plotters use vector graphics in order to build a list of toolpaths needed to map out jobs, and I doted on Potrace for being the most common program used to generate vector graphics.

But as great as Potrace is, one thing is does not do for you is optimize the path order.

Optimizing paths is simple in theory, and yet impossible to get perfect in even a moderately complex job. A very interesting problem!


Lets say my kid asks me to color the inside of a circle, a process known as hatching. The optimal path algorithm is obvious, start at one side, swoop back and fourth repeatedly until the shape is filled.

Hatching is not supported by Potrace since it is not necessary for displaying images on a screen. It produces an outline & simply declares the interior to be a certain color.

To create the filled-in effect on a physically drawn image hatch paths must be calculated & then combined with the outline. It is also a tool-specific process because the appropriate spacing between strokes changes with the diameter of the pen you use.

Here I’ve illustrated the tool path of a hatched circle and I set the line color to linearly change from red to blue as the drawing progresses for visualization purposes. It looks exactly how you would expect.

Now imagine kiddo giving me a more complex shape to fill in. The decision on how to optimally proceed is much less obvious. Marker in hand, my instinct is to just scribble furiously everywhere to finish before she gives me my next task.

A more computer friendly approach we can try is to use is rasterization rendering. Start from the top corner, swoop across the entire width of the image only touching pen to paper where appropriate, move down one stroke width, & repeat swoop in reverse direction.

The path of motion is dead simple and this is how laser engravers usually generate paths. It produces a lot of wasted motion but they can get away with it because lasers can turn on and off instantaneously, so the benefit of operating at high motion speed far outweighs the time spent travelling over space that won’t be engraved.

Here’s what that looks like. (The white lines are travel-only-paths, wasted motion.)

Rasterization rendering is also how computers refresh pixel colors on your monitor, and its how the DePixelizer program I wrote about last time converts images into vectors.

But this is not a very good plan for a plotter. (Or for me with marker in hand for that matter.)

The pen has to be physically lifted & lowered every time you transition from a travel-path to a drawn-path. A roundtrip process of ~1 second on the CylinDraw, deliberately limited in speed to prevent the pen from bouncing.

The cumulative effect is significant. The example above has 2048 individual lifts, and a total of 6130 separate points of interest to visit to complete the job.

Ideally we want to minimize the number of pen lifts, minimize the total distance of travel-only-paths, and if possible keep the average drawn-line length as long as possible. Long straightaways are better because the bot can spend more time at high velocities & waste less time accelerating/decelerating.

We have a long list of points to visit only once and we want the shortest possible route, effectively we’ve run into the travelling salesman problem.

I wanted my program to be able to import any kind of vector files, not just those made with the DePixelizer program, so I had to figure out a way to generate hatching using only the perimeters of shapes.

This is what I came up with.

  1. Iterate over the SVG to separate out all the enclosed objects. Then for each closed object individually:
  2. Sequentially slice the object with an array of strokes spaced apart by the pen diameter. (blue lines) Everywhere the lines intersect the object will create at least 2 points of interest the bot will want to travel to. (Note there will always be an even number points of interest in a slice.)
  3. Collect both points of interest sequentially and add it to a running list, along with the color of the shape. Move directly from the last point found to the next point found, unless…
  4. …unless the number of points found in a slice is different than the number found on the previous slice. In that case create however many new lists (groups of sequential points) necessary so that each group is only getting two new points per blue slice line.
  5. When the end of the object is found, make a new blank master list & iterate over the lists of groups of the same pen color seeking the next nearest start or end point of the entire group. (greedy algorithm) If the next nearest point was the final point of a group then reverse the group order before adding it to the master list.

Using large groups as shown wasn’t strictly necessary; I found the system also works if you simply consider each 2 point line segment to be its own (tiny) group, since all groups are combined at the end & reordered with a greedy algorithm anyway.

However, this had a surprising & unintuitive effect on the result. I found that the additional constraint of large groups consistently had multiple benefits over line-segment-sized-groups.

Large groups prevented the greedy algorithm from making a short sighted decision to seek a locally optimal point at the cost of creating numerous inefficiently disjointed groups later. (There’s probably a parallel to be drawn here about the negative effect of frequent context changes on your brain/productivity)

Similarly, I found the starting position had an enormous effect on the greedy algorithm’s output. I found it was almost always best to start combining groups with the very first point & group being at one extreme side, then to finish off with the outline last since that may start or end anywhere.

Another benefit of large groups, the overall time to run the hatching code became near instantaneous because there are far fewer items to sort. The nature of sorting is such that doubling the number of items to sort on a single list will take more than double the time to sort. (I.e. Its quicker to sort 10 separate 10-book-shelves than a single 100-book-shelf.)

One big challenge was ensuring the transfer motion between groups did not mistakenly leave the pen down in cases when it should have lifted off the paper. To resolve this I simply assumed a lift was always necessary if the next group’s point of entry was more than a pen diameter away.

The final result is 31 total pen lifts & 2900 separate points of interest to visit. Neato.

Obviously there are a lot of ways this process could have been done, certainly many better than mine in different ways. At this point you’d have to start varying the slice direction & make the model iterate multiple times to try to get even slight improvements.

My main goal was not perfection but rather to ensure the output is error free every single time. For a system like this anything less than 100% reliable is 100% worthless. Reliability>>Perfectly optimal!

That’s why I used many different images to practice on while I figured all this out. Otherwise I’d risk ending up with a system ‘designed to pass the test’, that fails as soon as a unique situation comes along.

Other examples.

One final trick I came up with before I wrap up this topic.

Making progress & learning requires iteration, the faster you can iterate the faster you can learn.

The deliverable output of my slicing program is my variant of g-code, readily machine readable but not readily human viewable. It’s literally a text file thousands of lines long and at the beginning I had to copy & paste it into a g-code reader just to check how it worked out.

So to improve my ability to make progress faster I designed the system to output an SVG file that displayed the job preview and then embedded all the g-code at the end of that file between comment brackets so it didn’t affect the SVG format.

Then I installed a package that let me view SVG files in the thumbnail on my computer and I was able to organize experiments, review the results, and iterate much much quicker.

That’s all for now. Next time I’m looking forward to sharing a raspberry pi automation project.


Further Reading:

*Evil Mad Scientist ‘Creating Filled Regions’ in Inkscape.

*Evil Mad Scientist ‘TSP Art’, Vectors generated specifically to draw an image with a single continuous path.

*A higher lever but well explained article about optimizing plots with a Travelling Salesperson Problem Solver.

*Polygon Infill Algorithm Q&A on Stack Overflow

Discover the Joy of Pixel Manipulation and Vector Art

(This post first appeared on EngineerDog.com)

 In my previous post I shared an introduction to a cup-specific plotter project I developed over the last couple years. This time I want to dive a bit more deeply into appreciating some of the art you can produce with this type of machine.

This article has a good bit of detail and I don’t want to discourage someone looking for quick solutions or a casual hobby, so Ill mention upfront that there are many free tools available that allow you to easily use the techniques mentioned here to make cool art without sweating all the underlying details. But maybe this will inspire your curiosity to dig a little deeper and come up with some of your own.

Multiple well-meaning people have asked me how quickly the CylinDraw can pump out drawings, and if it can be made to automatically swap out cups & pens.1

The tool is quick for what it is, but thinking in terms of automation & cups per hour is not the best way to appraise its value & potential.

To them, a traditional pen plotter must seem like an odd choice of technology for me to choose to develop. In the world of printing tech, creating images on paper by tracing thousands of individual pen strokes cannot possibly compete with the efficiency and resolution of modern inkjet printers.

Even today’s architectural paper size “plotters” are in reality inkjet printers with a bigger frame. The traditional pen plotting process is antiquated for that purpose, so why develop a new hardware platform with it?

A pen plotter is fun to build & use, mesmerizing to watch, and there is something uniquely fun about pen-drawn art!

The pen drawn aesthetic has timeless appeal, in the same way that a handwritten letter is more enjoyable than an email or mass produced pamphlet. The information conveyed may be the same but the value is different. The efficiency of the process used to create the art has an inverse effect on how personal the result feels.

You wouldn’t judge a calligrapher primarily based on how many letters they can pump out per minute, because a more important aspect of appreciating their work is understanding the thought processes, skill, and effort that went into producing it.

Lets say I found an image online I like enough to decorate my cup with or print out and hang on my wall. This chiseled looking guy will do.

'Statue of David image'. Speaking of appreciating the effort that goes into art, how many people on earth today could even try to recreate something like this?

As you can see, this image is small but conveys a ton of detail. That’s because it is a matrix consisting of 180 by 215 individual pixels, each of which can be displayed on my computer monitor as a unique shade of gray. The digital image itself is a raster graphic which is great for displaying extreme color detail.

Now an interesting question,

How does an inkjet printer print in grayscale, using only black ink?

When I hit print on my office printer, my computer converts each pixel in that image into yet another smaller matrix of microscopic dots.

Each of those dots will be the target for aerosolized ink which is sprayed from row of tiny nozzles. (A good photo inkjet printer can print 1440 dots per inch).

On paper, the color of the image pixel is communicated by varying the density of those ultra tiny dots. Black is 100% dots, white is 0% dots, and gray is achieved via optical illusion (called dithering) by having some number in the middle.

img source https://en.wikipedia.org/wiki/Dither
The colors appear to blend as you use smaller dots.

The printing process is fundamentally different on a pen plotter. The tip of my pen is a single point 0.1-0.5mm wide, too large to reproduce a gray looking pixel with that method. The plotter armed with a single pen can only draw a large black dot or nothing at all, with no option in between.

A raster graphic is not directly usable.

To accommodate a plotter that uses a single pen what we need is a black & white vector graphic, a discrete mathematically defined image consisting of explicit curves readily parsable to derive the complex paths the plotter will need to follow.

img source: https://en.wikipedia.org/wiki/Image_tracing

But how do you convert a raster image into an equivalent vector graphic?

That’s part of the fun, there’s no precise ‘equivalent‘ way to do it, only endlessly different artistic interpretations.

To get started on any sort of vectorization we have to consolidate the number of colors in the image down to the number of ink pens that we will use. In this case just black & white for a single pen.

This is a core challenge of converting image types. Where a raster might have many shades of gray that merely imply an edge and let your imagination complete the unspecified feature, a rigorously black or white vector is less forgiving.

The simplest way to consolidate colors is a method called ‘thresholding’. You pick some threshold gray value, then convert every pixel in the image into completely black or white depending on which side of the threshold it falls on. Shown here as a screenshot in the CylinDraw DePixelizer program.

I adjusted the threshold value carefully, but you can see the image lost a lot of detail, especially around the eyes and hair.

We can attempt to get some of that detail back by applying a matrix filter, or what is essentially a strategically weighted average of pixels in a small area, applied over and over again.

The filter (or kernel) is the criteria for how the average is weighted and even small changes to it can have drastic effects on the result. (There are some great step by step images walking through this process at this link, but the core idea and math behind it is easier than first sounds.)

The effect of edge detection, sharpening, & embossing filters for example, is to emphasize the comparative difference between a given pixel and its nearest neighbors to make boundaries stand out. The examples below are still only black and white pixels but they show much more detail than before.

Another interesting color consolidation method is called stippling, or basically dithering on a larger scale. Just like the example shown earlier with red & blue squares appearing to blend together to make purple, except instead of dithering on a sub-pixel scale to produce a gray pixel, you dither together groups of pixels into consolidated larger dots to make the group appear gray in aggregate.

One way this technique is carried out is by performing a basic threshold on every pixel as before, except while doing so keep track of how much you’ve cumulatively rounded the pixels so far and apply that error as a bias going forward. So if you round a gray pixel toward black, it becomes more likely that the next gray pixel is rounded toward white. This keeps the overall rounding error low which preserves the intended effect of the shades of gray. Incredibly this image is nothing but black & white dots:

Those methods are widely used but there are examples of more esoteric methods and task specific tools that creative people have shared online for free. Here’s a couple I just made with ‘SquiggleCam’ & ‘Spiral Raster’ tools, both vary the amplitude of a wave based on the pixel darkness of a local matrix. I assume they did it that way to make the job faster by eliminating the need to lift the pen.

We can also do some neat stuff if we remove the black/white limitation & allow for drawing with a few more colors. Because we can easily program the plotter to sequentially draw each color on the same job.

The only real limitation to drawing in color is having enough uniquely colored pens and our ability to determine how to properly consolidate the pixels into a select few colors (a process called “color quantization”).

My software uses a Red/Green/Blue color model, which means that every possible color displayable on my screen can be quantified as some combination of those three colors. With a 3 category mix, the linear white to black scale we used for thresholding won’t work.

The question becomes, how do I compare the similarity of 2 colors on a 3 color scale? (i.e. Is that brown pixel more reddish green or bluish red or greenish blue?)

The trick is to use a tiny bit of trigonometry. We just pretend that Red, Green, & Blue constitute 3 perpendicular axes in space, then any color can be assigned a position in space based on its RGB components. From there any two colors can easily be compared using the distance formula, and voila we can figure out what parts of Obamas face are the most reddish green.

In this example I’ve used a sharpening filter & allowed 1 shade of gray on David. (This is what I ended up drawing on a cup). For an example that has more colors to begin with I tried to recreate the effect of the famous color reduced Obama campaign picture.

Up to this point I’ve shared some neat algorithms for conveying detail with a reduced color pallet, but to draw the image we still have to convert those pixels into mathematical paths the plotter can follow.

One of the most powerful & commonly used vectorization strategies is called contour tracing. A program checks every single pixel in the image and tries to logically connect the edge pixels into lines, then define & name the enclosed areas.

This link has some great contour tracing algorithm animations which make the process conceptually easy to understand..

The rendering above was made using the default settings Inkscape. Edge tracing is a common capability since there are many ‘unique’ tools online that trace images for you, or so it would seem…

To the best of my knowledge the vast majority of edge tracing vectorization programs delegate the actual tracing task to one specific open source program, Potrace. Manually creating a good edge tracing algorithm yourself is quite difficult because of the nuance & complexity of keeping track of which lines should be combined to form enclosed spaces.

Potrace is the Jenga block you don’t want to pull.
(img source: https://xkcd.com/2347/)

One problem with using the Potrace vectorizer for plotting is that the result does not take into account the size of your pen stroke.

A scalable vector graphic (SVG) by design can be scaled to any size and the paths will remain proportionally unchanged. So if I take a Potrace SVG and have my plotter draw it scaled onto paper at 2″ tall and then again at 20″ tall, the effect of the constant pen tip diameter will be significantly different.

All the perimeters on the smaller drawing will be thicker, possibly to the extent that they occlude the areas enclosed by them. I call this the narrow path problem. Its easily visualized by signing your name with a fine tip pencil, then tracing the signature with a thick sharpie.

Don’t put your personal signature on the internet folks.

For my DePixelizer software I came up with something original to solve this problem. Basically I rescale the raster image until one pen dot = one pixel so I can work at a 1:1 scale.

My program requires you to specify the desired physically drawn image size along with the pen stroke diameter. With that information I calculate the maximum number of pen diameters the image will be in width & height. This is the maximum resolution the pen is physically capable of achieving without overlapping strokes. (I squeeze a tiny bit more resolution out of the pen by allowing drawn strokes to overlap by 50%.)

What’s nice is that I don’t have to worry about defining edges & filled areas, I’m converting directly into readily usable dots that are located at the finest achievable positions.

Here you can see what a zoomed in screenshot of the corner of the CylinDraw logo. The first picture is a raw raster showing gray pixels everywhere around the edges. The second pic is cleaned with a threshold, and the third has a dithered edge trying to simulate those gray pixels. The dithering looks less desirable when vectorizing words, but the same effect looked much cooler when drawing David’s head earlier.

The tricky part is creating clean multicolor vectors.

Consolidating raster images into 3 or more non-white colors will produce errant dots that have to be filtered out. Thus the program was named after the primary challenge of improving it, “DePixelizer”.

Something more complex than a basic threshold filter is necessary. I use color quantization & sort by nearest match, but its really hard to correctly classify unsaturated gray pixels that have equal amounts of red, green, and blue content!

One method I use to reduce noise is to consolidate consecutive dots of the same color into lines, then remove any remaining lone dots because they were most likely noise and take longer to draw anyway. It works well for most scales but it starts breaking down as you continue to use larger markers & smaller output images.

In the ‘earth ice cream’ example below you can see only a little bit of noise with a 0.4mm stroke on an 100mm tall image, imperceptible when drawn. But with an absurdly thick 2mm stroke its a mess because the pen resolution is only 100 strokes tall and the raster had to be blurred to resize it. This is approximately the best you can do with that pen at that size output.

In any case, the DePixelizer tool is great for creating derivative artwork and enabling people with a simple vision to carry it out quickly & easily.

Ironically, my favorite kind of plotter art is a type that beyond my current ability to produce.

This article has been about challenges of converting image types to make creative interpretations of existing images. But many folks create algorithms to generate vector images from scratch, called ‘generative art.’ There is some amazing new stuff out there pretty much daily if you follow the hashtag #plottertwitter.

That’s all for now, next time I’ll be sharing some cool algorithms involving path optimization.

Thirsty for more? Drink from the fire hose! Here are some excellent resources on these topics:

https://drawingbots.net/knowledge/tools Actively manage collection of the best plotter resources

Whitepaper on Creative Plotting Workflows.

Drawing images with dots, computational stippling on Wolfram Alpha Blog

https://pixelparmesan.com/dithering-for-pixel-artists/ various dithering strategies

http://vector-conversions.com/vectorizing/raster_vs_vector.html Deeper dive raster vs vector

https://en.wikipedia.org/wiki/Color_quantization Color consolidation strategies


Statue of David image source: https://en.wikipedia.org/wiki/Dither

Melting earth image source https://www.reddit.com/r/Art/comments/ofpy94/ice_cream_me_digital_2021/

  1. Performance notes from beginning. CylinDraw cannot and will never automatically switch out cups for you. It does manage the timing & order of pen swaps but it merely pauses the job & beeps prompting you to switch the pen. For the task of engraving, cups-per-hour is a more relevant metric since the output is indistinguishable from the alternative tech; the full process throughput is probably half the speed of a good rotary laser engraver.
  2. The finished work:

CylinDraw Kits Available Now!

Good news everyone, we just posted the CylinDraw Kits on our Etsy web store! We are offering an introductory special including: Free Shipping, 10% off all orders, and we are including a bonus stainless steel tumbler along with kits while supplies last. Special ends July 6th.

Its been about a month since we posted the introductory video on YouTube, & introductory post on EngineerDog.com; The rest of this post we will share some challenges & victories we’ve encountered since then.

*First I want to point out that this work is not a ‘Kickstarter’ type project. We believe in the future of CylinDraw and have self funded the initial round of inventory. So you don’t have to worry about indefinitely long delivery schedules, and we can focus our efforts only on the most value-added aspects of the work.

*Developing & hardening the machine design & software was only the beginning. We’ve been working on expanding our workshop, honing our assembly processes, and figuring out packaging & shipping logistics. From experience we’ve learned that intentionally designing your internal processes pays back major dividends. (Lessons learned on that front to come!)

*2021 has been showing some of its ugly side with supply chain delays abound…the ‘great chip shortage‘ has affected our ability to secure multiple parts. We ordered everything quite some time ago and (almost comically) the estimated delivery dates kept getting push back! Well have to keep that in mind as we go forward. As it is, we finally have 100% parts in house!

*We are experiencing an extreme heatwave here in Portland Oregon. With air temperatures over 110F, it is personally too much to withstand being outdoors for too long. Many buildings around here do not have air conditioning, so we feel quite lucky that we do have it. Still, by late afternoon the AC can’t keep up since the mass of the whole building has been heated and indoor temps rise into the 80’s. We had to pause all 3d printing this week so as not to make matters worse.

*We’ve developed and honed a new tool to help with your vectorization workflow! Its an Inscape based fully automated PNG to SVG bot. Wicked cool, looking forward to sharing the details on that soon, but here’s the link for now: https://cylindraw.com/autovector/

*Questions about ordering can be directed to CylinDraw@Gmail.com

*Development ideas & technical questions are best asked in a public forum so that others can learn from the experience too! I setup a CylinDraw specific Discord server here.

That’s all for today, next time we’ll be sharing an article about the joy of vectorization. (The process really is quite interesting!)


Edit to note: If you do have your own 3d printer, getting together all the random non-printed parts for the CylinDraw without going through us is cost prohibitive & lead-time prohibitive to do on your own due to the global shipping delays. The very best way to finish the machine is to pick up our hardware kit too because we buy everything in bulk, check it, sort it, and we can offer all & only what you need at a good price! Plus, shopping with us supports independent creators!

Introducing CylinDraw!

(This article was originally posted on my blog at EngineerDog.com.)

When I was younger every Christmas at least one person in my family would inevitably receive the gift of a new flashlight. The trend never failed and became a running inside joke. 

“I don’t know what to get anyone, you’re all about to get flashlights.”

Part of the punchline was that doing so would have been normal & acceptable, since the receiver was always genuinely happy to get one. And why shouldn’t they be, a flashlight has broad appeal. It’s an all-ages, timeless, semi-durable good that’s highly utilitarian and has a wide variety of forms & sizes possible that allow it to retain the necessary degree of novelty a gift needs to be fun.

Its been a while since the family has gotten together but I’ve got next year covered since I discovered something else that meets all the criteria outlined above. Custom made tumblers are ‘the new flashlight’ gift.

 It turns out that many others out there have discovered this too. The trend is obvious when you look. People are making some highly creative cups online and they are using a wide variety of tools to do it. 

 I’ve seen tools as simple as a continuous motor driven cup rotator for applying glitter & epoxy coatings. More advanced tools like vinyl cutters allow people to create custom sticker decals. The most advanced makers utilize laser engravers with rotary jigs and even automated cup silkscreen machines.

All of these makers are serving a large, growing, and ultimately insatiable market because when will people ever not enjoy cool cups? (Or flashlights for that matter)

 Over the last year, I have been developing a semi-secret project. I am very excited to share this, its been the focal point of much of my free time for a while. 

I created a brand new type of tool that I believe can make a significant contribution toward serving the creators in the cup customization space. Especially those looking to find a competitive edge and bring something new to this market.

This is the CylinDraw, it lets you easily create incredible art on any kind of cup!

CylinDraw essentially does 2 things: It can engrave & it can paint. And it is highly adjustable so it can do those 2 things on any kind of cup. (tumblers, wine glasses, mason jars, shot glasses, mugs with handles, or any cylindrical object tapered or not under 3” diameter & 11” tall).

As a painting tool, we have experimented and perfected techniques for drawing on multiple types of materials and coating the end result to make it dishwasher safe. (Though there is a wide world of markers and coatings out there to choose from to continue experimenting with!)

 As an engraver, CylinDraw is an order of magnitude less expensive in terms of upfront/operating/& maintenance costs when compared to a rotary laser engraver, while offering better ease of use and equivalent drawing resolution. (CylinDraw operates at 0.2mm wide stroke, lasers are 0.1-0.5mm.) Engraving is also a safer cleaner process than laser etching since fumes and fire are not a factor. Lasers must be vented to the outside because of chemical byproducts (smoke), while mechanical engravers only create physical byproducts (microparticles) which can be contained with a shop vac.

But of equal importance to what it does, is how it does it.

Cool hardware is still a useless brick without software, and if the software sucks then its an irritating brick. But get both things right and using the tool becomes such an effective process that you can start taking it for granted. That’s when you know it has improved your life. That was the design intent. Every aspect of this tool is designed to make the user experience painless, because I think computers should just work so you can focus on the art! 

CylinDraw software is free* and all-inclusive. It can convert any bitmap image like a photo or screenshot into a vector graphic (SVG) and then into a drawing-in-progress in minutes. Most drawings are doable in under an hour.

The system automatically makes assumptions on your behalf to streamline the process. A few examples:

  • Multicolor jobs self sort the colors by brightness so you don’t smear light colors with dark ones.
  • Drawing paths are optimized using a honed greedy algorithm.
  • It automatically updates the feed & speed (steps-per-mm) to account for varying cup diameter.
  • Automatic connection to the tool when the USB cable is plugged in. A happy beep tells you all is well.
  • Separate user interfaces for separate functions so that all the information on screen is relevant, and the only controls you have are the ones you need.
  • No internet-of-things planned obsolescence security nightmare nonsense. CylinDraw operates entirely without internet access.
  • Custom ‘JOB’ files (machine readable g-code files) use an .svg extension so they can be viewed as thumbnails or in a browser, or they can be parsed with a viewer program that is part of the package.


Overall I think CylinDraw represents a high value proposition for what it does and I am excited to see what creative works people will come up with. I am preparing to offer kits in my store that will appeal to do-it-yourselfers as well as folks who prefer a turnkey experience.

Kit Option 1: You 3D Print + You Assemble it:  You get the 3d printable files & make them yourself. We send you all the tools, electronics & mechanical hardware. You build it using instructions online.

Kit Option 2: We 3D Print + You Assemble it: We send you all the 3d printed parts, tools, electronics & mechanical hardware. You build it using instructions online.

Kit Option 3: We 3D Print + We Assemble it:  CylinDraw comes to you tested & ready to use.

*The software is license locked but a license is free for anyone who buys a kit from us.

If you want to be the first to hear when kits become available then visit the project homepage and enter your email address. Doing so comes with benefits! To get this project going (& to celebrate your great taste in blog reading material) I am offering early followers an introductory special for my first batch of kits, valid in my store while supplies last.