Why Your Circles Aren't Round: The Truth About STLs and Tessellation

You designed a bearing holder in Fusion 360. The bore is exactly 22mm. You export the STL, slice it, print it, and the bearing doesn't fit. You measure the hole. It's 21.7mm. You blame the printer. You tweak flow rate. You adjust horizontal expansion. You reprint. It's still wrong. Not dramatically wrong. Just consistently, stubbornly, slightly wrong.

Here's what nobody told you when you started 3D printing: there are no circles in your STL file. There never were. The moment you clicked "Export as STL," every circle in your model was destroyed and replaced with a polygon. A shape with flat sides that approximates a circle but is not one. And that polygon is always smaller than the circle it replaced.

This is not a bug. It's not a slicer error. It's not your printer being imprecise. It's the fundamental geometry of how the STL file format works, and it affects every single curved surface on every single print you've ever made.

Understanding this will save you hours of chasing phantom calibration problems. Not because the fix is complicated. Because knowing where the error actually lives changes which knobs you reach for.

An STL file describes a 3D shape using nothing but triangles. That's it. No curves. No arcs. No mathematical descriptions of circles or spheres. Just triangles. Thousands or millions of them, stitched together edge to edge to approximate the surface of your model.

This process is called tessellation. Your CAD software takes every surface of your design, whether it's flat or curved, and tiles it with triangles. Flat surfaces are easy: a flat rectangle becomes two triangles and the representation is perfect. No information is lost.

Curved surfaces are where the trouble starts. A true circle is a continuous curve defined by a mathematical equation. Every point on it is exactly one radius away from the center. An STL file cannot store that equation. It can only store triangle vertices: specific points in 3D space connected by straight lines. So your CAD software does the only thing it can: it places points around the circumference of the circle and connects them with straight line segments. The result is a polygon inscribed inside the original circle.

A 10mm circle exported with 36 segments becomes a 36-sided polygon. It looks round in your slicer preview. It looks round on screen. But it is not round. Every straight segment between two vertices cuts a tiny chord across the inside of the original circle. The polygon fits inside the circle, not on it. The effective diameter of that polygon is smaller than the circle you designed.

This is where your missing 0.3mm went. Not into flow rate error. Not into thermal contraction. Into the geometry of the file format itself.

Here's the geometry that explains exactly how much diameter you lose.

When a circle is approximated by a polygon with n sides, the vertices sit on the true circle. But the midpoints of the straight edges between those vertices are inside the circle. The maximum distance between the true circle and the nearest polygon edge is called the chord deviation, and it follows a simple formula:

Chord deviation = r × (1 - cos(π/n))

Where r is the radius and n is the number of segments.

Let's make this concrete with a 10mm diameter hole (5mm radius):

With 12 segments (a common low-resolution export): the chord deviation is 0.17mm per side. The effective inscribed diameter shrinks to about 9.66mm. That's a third of a millimeter gone before the printer even turns on.

With 36 segments: the deviation drops to 0.019mm per side. The inscribed diameter is about 9.96mm. Much better. Probably within your printer's tolerance.

With 72 segments: the deviation is 0.0048mm. Effectively invisible. The inscribed diameter is 9.99mm. Your printer's mechanical accuracy is worse than this.

The critical insight is that the error scales with the radius. A 5mm hole with 24 segments loses a tolerable amount. A 50mm hole with the same 24 segments loses ten times as much. Large curves are far more sensitive to low segment counts than small ones, which is why tessellation problems sometimes only show up on bigger prints and you can't figure out what changed.

The other insight: the relationship is not linear with segment count. Doubling the segments from 18 to 36 eliminates most of the deviation. Going from 36 to 72 barely matters. There's a sweet spot, and overshooting it just bloats your file for no printable benefit.

Your CAD software decides how many segments each curve gets during STL export, and the default settings are almost always wrong for 3D printing. Not wrong in the sense that they produce bad files. Wrong in the sense that they either produce unnecessarily huge files or introduce visible faceting, depending on which default your software ships with.

Fusion 360 gives you three presets: Low, Medium, and High refinement. Low is visibly faceted on anything with curves. Medium is acceptable for most prints. High produces clean curves but large files. There's also a Custom option where you can set the surface deviation (chord tolerance) and normal deviation (angular tolerance) directly. For 3D printing, a surface deviation of 0.01mm with a normal deviation of 10-15 degrees produces excellent results without ballooning the file.

SolidWorks exposes chord tolerance and angular tolerance directly during STL export. The defaults are often too coarse. A chord tolerance of 0.01mm and angular tolerance of 5-10 degrees is a good starting point.

OpenSCAD is a special case because you set the resolution directly in your model code. The $fn variable controls how many segments make up each circle. The default is horrifyingly low: it produces 30-segment circles that look like stop signs at larger diameters. Setting $fn=72 or $fn=100 for final exports is standard practice, but beginners who don't know about $fn wonder why every hole they print is an obvious polygon.

Tinkercad gives you almost no control. Its export resolution is fixed and relatively low. This is one of the reasons experienced users eventually move away from it: not because it can't design complex shapes, but because it exports them at a resolution that throws away dimensional accuracy on curves.

The pattern across all of these: the software's default export settings prioritize small file size and fast processing over geometric accuracy. That's a reasonable default for previewing models on screen. It's a bad default for printing parts that need to fit together.

There's a specific and annoying consequence of polygon tessellation that trips up nearly everyone printing functional parts: holes are always undersized. Not sometimes. Always. By geometry, by definition, by the inescapable mathematics of inscribed polygons.

When your CAD software tessellates a circular hole, it places polygon vertices on the true circle and connects them with straight lines. Those straight lines cut across the inside of the circle. The polygon fits inside the hole, making the hole smaller. Every single segment shaves off a tiny crescent of material from the intended diameter.

Your slicer then generates toolpaths to fill the material around this already-undersized polygon. The nozzle traces the polygon boundary, not the original circle. Even with a perfectly calibrated printer and perfect flow, the physical hole will be smaller than what you designed in CAD.

This compounds with other sources of hole shrinkage: filament bulging slightly inward on internal curves, thermal contraction pulling the walls inward as they cool, and the fact that the nozzle deposits a bead of finite width that always intrudes slightly into concave features. But tessellation error is the first error in the chain. It happens before the slicer even sees the model.

This is why the common advice to "add 0.2mm to your hole diameters" works. It's a crude but effective compensation for the cumulative effect of tessellation shrinkage plus print physics. But it's a bandage. The cleaner fix is to export your STL at sufficient resolution that the tessellation error is below your printer's mechanical accuracy, and then only compensate for the printing-physics portion of the shrinkage.

If your 10mm hole prints at 9.7mm, that 0.3mm error is probably split: 0.1-0.15mm from tessellation (if your export was at medium resolution) and 0.15-0.2mm from print physics. Fix the export resolution and the problem gets cut roughly in half. Then your compensation offset is smaller and more predictable.

A common misconception: the slicer will smooth out the facets. It won't. It can't. The slicer reads the STL and generates toolpaths that trace the geometry it was given. If the geometry is a 24-sided polygon, the slicer generates a 24-sided toolpath. It has no way to know that the polygon was supposed to be a circle.

Some slicers have features that seem like they'd help. Arc fitting (sometimes called Arc Welder) is one. This feature looks at sequences of short straight G-code segments and replaces them with G2/G3 arc commands that the printer firmware can execute as smooth curves. This sounds perfect. It is not.

Arc fitting works on the G-code level, after the slicer has already interpreted the faceted STL mesh and generated toolpaths following those facets. It can smooth out the toolpath segments within the bounds of the polygon it was given, but it cannot recover the original circle. It's rounding the corners of a polygon, not reconstructing the curve. The result is smoother motion and slightly better surface finish, but the dimensional error from tessellation is still there. The hole is still undersized. The curve is still a polygon with slightly rounded corners.

Bambu Studio, OrcaSlicer, PrusaSlicer, and Cura all generate G1 (straight line) commands by default. Even with arc fitting enabled as a post-processing step, the geometric information lost during STL export is gone. You cannot add information that was discarded upstream.

The real fix lives upstream: in your CAD software's export settings. By the time the file reaches your slicer, the circles are already gone.

Tessellation affects every curved surface, not just circles. Spheres, fillets, chamfers, organic shapes, anything that isn't a flat plane gets approximated by flat triangles. The visual and dimensional consequences show up in specific, predictable places.

Spheres and domes. A sphere tessellated with too few triangles looks like a geodesic ball. The facets are visible both on screen and in the printed part. On large prints (anything above 50mm diameter), low-resolution tessellation produces visible flat spots that no amount of sanding will turn into a smooth curve because the geometry itself is stepped.

Fillets and rounds. That 2mm fillet you added to reduce stress concentration on a bracket? If it exported as four straight segments instead of a smooth curve, it's not a fillet anymore. It's a chamfer sequence. It looks different and it distributes stress differently. The functional benefit of the fillet is partially lost in translation.

Threads. Printing threads is already hard. Tessellation makes it harder. Thread profiles are complex curves with tight tolerances, and coarse tessellation can turn a smooth thread profile into a stepped approximation that doesn't engage properly with the mating part. If you're printing threads and they don't work, check your STL resolution before you blame your thread pitch.

Organic and sculpted shapes. If you're printing miniatures, artistic pieces, or anything with smooth flowing surfaces, low tessellation turns subtle curves into visible facets. The irony is that people often use high-detail resin printers for these parts and then feed them a low-resolution STL that limits the detail before the printer even gets involved.

The general rule: any feature that relies on being curved for either its appearance or its function is vulnerable to tessellation error. Flat surfaces are immune. Curves are not.

You might have heard that 3MF is the replacement for STL, and that it solves the tessellation problem. This is half true, and the half that's false matters.

3MF is a newer file format that stores more information than STL: color data, material assignments, print settings, texture maps, and build platform layout. It's a genuinely better format for communicating print jobs between software. Most modern slicers support it. Bambu Studio and PrusaSlicer both prefer it.

But here's what 3MF does not do: store mathematical curves. Like STL, 3MF represents geometry as a triangle mesh. The curves are still tessellated into flat triangles. The circles are still polygons. The fundamental limitation is the same.

What 3MF does do better is handle that mesh more efficiently. It uses indexed vertex lists instead of STL's redundant per-triangle vertex storage, which means the same quality mesh in 3MF is roughly one quarter the file size of the equivalent STL. That efficiency means you can afford to export at higher tessellation resolution without ending up with a 200MB file. A high-resolution 3MF might be 60KB where the equivalent STL is 240KB. Same geometry, same triangle count, fraction of the file size.

So 3MF doesn't fix tessellation. It makes the cost of high-resolution tessellation cheaper. That's useful. But if you export a 3MF with the same low-resolution settings you used for your STL, you get the same faceted polygon where your circle used to be, just in a smaller file.

The format that actually stores true curves is STEP. STEP files describe geometry mathematically: a circle is stored as a center point, a radius, and an equation. No approximation. No tessellation. The circle is perfect at any zoom level and any scale. Some slicers (notably PrusaSlicer experimentally) are beginning to support STEP import directly, which would skip the tessellation step entirely. But for now, the vast majority of the slicing workflow goes through a mesh format. Your circles become polygons. The question is just how many sides those polygons have.

The fix is not complicated. It's just not obvious if nobody tells you where the problem lives.

Step one: stop exporting at default resolution. Whatever CAD software you use, find the STL export settings and look for chord tolerance, surface deviation, or refinement level. Set the chord tolerance to 0.01mm or the refinement to High. This single change eliminates the vast majority of tessellation-induced dimensional error for typical desktop 3D printing. The file will be larger. On any computer made in the last decade, this does not matter.

Step two: check your exports visually. Open the STL in your slicer and zoom into a curved feature. If you can see individual straight segments with the naked eye, the resolution is too low. If the curve looks smooth at maximum zoom, you're fine. This takes ten seconds and catches the problem before you waste a print.

Step three: understand what you're compensating for. If you've been adding 0.3-0.5mm to every hole diameter as a blanket compensation, some of that was compensating for tessellation and some was compensating for print physics. After fixing your export resolution, retest. You'll likely find you need less compensation than before, and the compensation you do need is more consistent across different hole sizes.

Step four: use 3MF or STEP when your slicer supports it. 3MF gives you the same mesh at a fraction of the file size, letting you export at high resolution without penalty. STEP (where supported) eliminates the problem entirely by preserving true mathematical curves.

Step five: pay special attention to large features. Tessellation error scales with radius. A 5mm hole at medium export resolution might be off by 0.05mm, which is invisible. A 50mm bore at the same resolution might be off by 0.15mm, which is the difference between a press fit and a loose fit. The larger the curved feature, the more the export resolution matters.

That's it. Five steps, and most of the work is step one: changing one setting in your CAD software's export dialog. The circles in your file will never be truly round (not in a mesh format), but they can be round enough that the error is smaller than anything your printer can resolve. Once you're there, the file format is no longer the limiting factor. The printer is. And that's where it should be.