Filament-based 3D prints are sometimes limited by physics. The steeper the overhang, the more you run into the risk of the nozzle just printing in mid-air and the material drooping down. Yet quite recently, you might have seen the FullControl.XYZ challenge where due to clever movement of the printhead, you can print complete horizontal overhangs into mid-air, because every previous loop supports the one next to it. Unfortunately, this demo is hand-crafted and just shows what could be possible with 3D printing. And here is where the story of the ArcOverhang starts that once again shows how much advancements in software still is able to bring 3D printing forward! When Steven McCulloch was messing around and printing in mid-air, it worked way better than you would imagine. These spiral discs also were self-supporting and created almost perfect overhangs. He then pushed it to the next level and stacked discs on top of each other, realizing that he was able to print huge overhangs without the need for any supports. And so the idea for ArcOverhangs was born. Instead of stacking discs manually on top of each other, Steven developed an algorithm that takes an overhanging surface and fills it with arcs that start at the location where there is still support to the main print and then grows them outside, getting smaller and smaller until the whole surface is filled. And this doesn’t only look mesmerizing in the animation but works just as well if you print out the samples on a real printer.

On some geometries, you can simulate something very similar by setting the number of perimeters to 100 in the overhanging layer and reducing print speeds quite drastically, but this, unfortunately, has its limitations when the overhangs become more complex. This is where ArcOverhangs shine because they grow out from one line and then can grow even around corners. All of the arcs are on the same level, and they just hold together because the tracks are slightly overlapping and therefore fuse to each other. Slow printing and a ton of cooling help to solidify the layers directly after extrusion and prevent them from drooping down. Whereas the proof of concept used overlapping circles, the method that Steven developed only pints arcs and therefore prevents multiple extrusions at overlapping sections. This leads to the almost crystal-structure-looking surface, and if you look closely, you also know why some call it NipOverhangs.

This method makes it possible to print even huge overhangs without the material drooping down. The arcs start at one point, grow out until they find a limit, and can even branch out in different directions until the whole layer is filled. If you’re interested in even more details on the algorithm, you can check out Steven's video on the method!

Once this layer is finished, you can continue printing as usual to get parts with decently looking overhangs that were impossible before without support structures.

Unfortunately, the ArcOverhang algorithm is currently only a proof of concept and not available in a slicer. For the big demo part right here, I had to extract the coordinates of the overhangs by hand, type them into the script, generate the arc overhangs, and paste that G-Code into the previously conventionally sliced model. Even though this sounds complicated right now, I really think that this has the potential to be quickly implemented into other open-source software because it’s fairly simple and, even more importantly, doesn’t require any special hardware in contrast to what we’ve recently seen on the RotBot project or conical slicing. It also doesn’t require any special clearance around the nozzle as with conical slicing because all movements are purely planar. Since ArcOverhangs are printed all on the same height, even machines like the Voron and Prusas MK3 can use the method without any issue. The more cooling a machine has, the better this method seems to work and the faster you can print the arcs. Yes, ArcOverhangs are not fast at the moment. I printed all of my samples in PLA, but I had to go down to 2 to 5 mm/s printing speed to not run into any printing problems. This sounds quite dramatic, and on some models, this can potentially increase the print time quite a bit. Yet if you consider how long printing supports would have taken and how much material you would have wasted, this quickly becomes a viable option again. And if you also value your own time that you’d need to invest in removing supports, it might even be cheaper to print a bit longer if this means that you don’t need to remove support manually, especially if you consider geometries that feature internal supports that are very hard to reach!

If we don’t even consider the longer print time and just look at the results themselves, we can also see that ArcOverhangs are not perfect. The bottom surfaces are not super smooth and we still get some warping.

Warping is interesting because during printing, the ArcOverhangs, almost stay perfectly level. Only when the subsequent layers are printed on top does this layer start warping because when the new layers cool down, they contact and deform because the ArcOverhangs are very flexible. The algorithm and my parameters, like overlap, temperatures and speeds are by far not optimized, but it’s already way better than having no supports at all, and honestly, this implementation and proof of concept is just the start! I love to talk about ideas like this because this is what brings 3D printing forward and prevents these algorithms from being patented. And if this gets traction, I’m sure that slicers like PrusaSlicer, SuperSlicer or CURA will start jumping on the bandwagon to implement it. So be sure to feed the YouTube algorithm by liking, sharing, and letting me know in the comments what you think about this novel concept! ArcOverhangs don’t need to become the new default, but if we get this as an option, I’m sure there will be a ton of use for it!

So as I said, ArcOverhangs are currently only a proof of concept and just a Python script that comes up with a random polygon and then creates GCode from it for a small test print. Stevens code is available as Open Source on his GitHub, and during the making of this video, I created a fork with a bunch of improvements and optimizations. If you don’t want to use the script yourself but still try it out on your own printer, you can download some sample GCodes linked below.

Sample GCodes on Printables.com