STEP→STL Your file stays in this tab · nothing is uploaded

What is the difference between STEP and STL?

This is the most-asked question on this site's subject and there is a short honest answer: STEP describes surfaces, STL describes triangles. Every number below was measured on the machine that wrote this page and is re-checked by npm test. Nothing here is a rule of thumb.

A thread on SolidWorks from April 2026, asking whether STL files can become editable again, put the difference into the analogy people keep reaching for on their own: “It is roughly the difference between a JPEG and an SVG.” The same thread also put this exact comparison near the top — not because someone was asking about it, but because that is what people actually search for when they hit this wall. This page is that comparison written out in the form that survives contact with real numbers.

The short version

A STEP file stores geometry as exact mathematical surfaces. A cylinder in a STEP file is a radius, a height and a position — no approximation involved, and the file is often human-readable text you could open in a text editor. An STL file stores a flat list of triangles, each one three points and a normal. The cylinder is gone. What remains is whatever number of flat facets the tessellator chose to approximate it with.

So the difference is not quality, not precision settings, not file format generation. It is what kind of thing the file knows about the part. One knows the exact shape; the other knows a finite set of flat panels that come close.

Which raises the obvious question: why trade the richer file for the poorer one at all? Because the next machine in the chain reads triangles, not surfaces. A slicer, a printer and most downstream tools take a triangle list and nothing else; a STEP file handed to them has to be tessellated first anyway. Converting is therefore a deliberate downgrade with a purpose — you keep the STEP file as the master and let it regenerate the mesh whenever the number needs to change. The 18-part assembly on this site is 433,606 bytes of STEP, and the same file produces 7,372 triangles / 368,684 bytes at Normal and 21,116 triangles / 1,055,884 bytes at Fine. Neither STL can be turned back into the master; both can be re-made from it, under 84 + 50 × triangles, as often as you like.

One STEP master and the two different STL meshes it can regenerate On the left a box for the 433,606-byte STEP file describing 18 parts. Arrows lead to two output bars, one for Normal at 7,372 triangles and 368,684 bytes, one for Fine at 21,116 triangles and 1,055,884 bytes. Both bars are on a shared byte scale, and no arrow points back. One master, two meshes, no way back The same STEP file, converted twice. Bar length is output bytes, 200 px = 1,055,884. STEP — the master as1-oc-214.stp, 18 parts 433,606 bytes Normal 7,372 triangles · 368,684 bytes Fine 21,116 · 1,055,884 bytes Both obey 84 + 50 × triangles. Neither can be re-made into the master — no arrow points back.
Two meshes from one master. The triangle counts and byte sizes are re-converted by npm test from as1-oc-214.stp.

That claim about readable text is worth showing instead of asserting, so here is one whole line out of the cone this site converts as a test, copied from the file unchanged:

#15=CONICAL_SURFACE('',#102,0.450944881889764,0.785398163397449);

That is the complete definition of a curved surface. It is a placement (#102), a radius of 0.450944881889764, and a half-angle of 0.785398163397449 radians — 45°, which the file rounds to fifteen digits. There is no triangle anywhere in that line, and none anywhere in the file it came from. Every triangle further down this page — 286, 516 and 2,142 of them on this cone — is invented later, by the tessellator, out of that one sentence.

The same cylindrical surface as an exact description and as a triangle approximation On the left a smooth cylinder outline labelled STEP, stored as a radius and a height. On the right the same outline rebuilt from straight line segments labelled STL, where each straight segment is one flat triangle edge. STEP: an exact description radius and height stored once, exactly change the radius, it is still one exact number STL: an approximation 8 straight segments drawn how many you get is a quality choice, and the surface is now only near the real one
The difference in one picture. The left outline is the kind of thing a STEP file can write down: a radius, and it stays exact no matter how big. The right outline is the kind of thing an STL file can write down: a run of straight segments, and how many of them is a decision somebody made before you ever opened the file. Every figure in this page follows from that one asymmetry.

Where the difference shows up as a number

Since the two formats describe different kinds of thing, their file sizes are not comparable and a ratio between them means very little on its own. But side by side over the same seven test files, the sizes tell you something concrete: the direction of the size change depends on the shape, not on the quality of the conversion. Flat geometry shrinks dramatically, because a plane costs the same few bytes whether the file describes it as a surface or as two triangles. Curved geometry grows, because describing it as triangles costs more bytes than describing it as a radius.

Source bytes against output STL bytes at Normal, measured by npm test over the project's own test files. The last column is output divided by input and is recomputed from the raw byte counts.
Test fileSource bytesNormal triOutput STLOutput ÷ source
simple-cube.stp8,01012684 B0.09×
cube-10x10.stp9,13812684 B0.07×
cube-10x10.igs (IGES)11,42112684 B0.06×
rounded-cube.step20,532562,884 B0.14×
conical-surface.step9,39151625,884 B2.76×
as1_pe_203.stp (18 parts)136,6636,088304,484 B2.23×
as1-oc-214.stp (18 parts)433,6067,372368,684 B0.85×

Read the first three rows and the last two rows as two different phenomena. The cubes are 8–12 KB of exact geometry that collapses into 684 bytes of triangles, because a box has six planes and each plane is two triangles. The cone and the assemblies run the other way: an output larger than its input, because the exact surface was cheap to describe and the triangles are not. The 18-part assembly is the clearest case. Its STEP file is 136,663 bytes and the STL that comes out is 304,484 bytes, a factor of 2.23, and the same part through a different AP protocol lands at 433,606 bytes of STEP for 368,684 bytes of STL. Neither number says anything about whether the conversion was good. The container question goes one level deeper: the same 18-part assembly’s 7,372 triangles cost 368,684 bytes in a binary STL but 1,392,852 bytes as ASCII text, and the size page now draws the assembly’s three containers — STEP source, binary STL, ASCII STL — to a single scale.

Output size against source size for a flat cube and a conical surface, drawn to one byte scale Both pairs are drawn to the same scale of 24 pixels per kilobyte. A cube with a 9,138-byte source has a teal bar of 219 pixels and produces a 684-byte STL, an orange bar of 16 pixels, roughly one thirteenth the size. A cone with a 9,391-byte source has a teal bar of 225 pixels and produces a 25,884-byte STL, an orange bar of 621 pixels, roughly two and a half times larger. Flat geometry shrinks. Curved geometry grows. both pairs drawn to one scale: 24 px = 1,000 B cube-10x10.stp 9,138 B STEP in 684 B STL out — 0.07× conical-surface.step 9,391 B STEP in 25,884 B STL out — 2.76×
Two files of almost the same source size, opposite outcomes. The top pair is the teal STEP input with the orange STL it produces; the bottom pair is the same drawing for a curved part. Both pairs are drawn to the same scale — 24 pixels per kilobyte — so the orange bar really is thirteen times shorter on the cube and two and a half times longer than its teal bar on the cone. Same converter, same preset, same format pair, and the two sources differ by 253 bytes. The size difference is telling you about the shape, not about the conversion.

The number that actually matters: triangle count

If you keep one idea from this page, keep this one. An STL is a triangle count. A binary STL stores an 80-byte header, a 4-byte triangle count, and then exactly 50 bytes per triangle, so the whole file size is decided by the triangle count and nothing else:

The binary STL size identity
Identitybytes = 84 + 50 × triangles
Invertedtriangles = (bytes − 84) ÷ 50
Worked exampleA 10 mm cube converts to 12 triangles, so 84 + 50 × 12 = 684 bytes. The IGES file describing the same solid also comes to 684 bytes, from the same 12 triangles.
Why it is trustworthyThe engine vendor ships a reference cube-10x10.stl next to the cube-10x10.stp it converts from. Our run of that STEP gives 12 triangles, and the vendor’s own file is 684 bytes on disk. Two independent artefacts, one identity.

This is also why a bigger STL is not a better one. If two files of the same part differ in size, they differ in triangle count, which means a finer setting ran — not that the conversion was more correct.

Why the triangle count is a choice, not a fact

Because surfaces are being sampled, the number of triangles is set by how finely you asked. This converter offers three settings, and they diverge exactly where you would expect: on curvature.

Triangle counts at each quality setting, measured by npm test. Fine ÷ Draft is recomputed from the raw counts rather than trusted.
Test fileShapeDraft triNormal triFine triFine ÷ Draft
simple-cube.stpFlat cube1212121.0×
cube-10x10.stpFlat cube1212121.0×
cube-10x10.igs (IGES)Flat cube1212121.0×
rounded-cube.stepRounded edges40561403.5×
conical-surface.stepCurved surface2865162,1427.5×
as1_pe_203.stp (18 parts)Assembly3,8486,08817,8484.6×
as1-oc-214.stp (18 parts)Assembly4,9007,37221,1164.3×

Two things to take from it. A flat part cannot identify the setting — all three cubes read 12 across every quality, because a flat face needs exactly two triangles no matter how precisely you ask. And the settings separate fastest on the hardest geometry: Draft to Fine multiplies the cone by 7.5 and the rounded cube by 3.5, while leaving the flat cubes untouched. If you want to know which setting actually ran, convert something curved.

Triangle counts for a flat cube, a rounded cube and a cone at three quality settings, each row scaled to its own Draft bar Each row is scaled so its own Draft bar is the same length, which is what makes the rows comparable. The flat cube reads 12, 12 and 12, so all three bars are equal length and the row is labelled 1.0 times. The rounded cube goes 40, 56, 140, so its bars are 1.0, 1.4 and 3.5 times its Draft bar. The cone goes 286, 516 and 2,142, so its bars are 1.0, 1.8 and 7.5 times its Draft bar and the Fine bar is the longest in the whole figure. Each row scaled to its own Draft bar, so the ratios are comparable Draft Normal Fine Fine ÷ Draft Flat cube 12 12 12 1.0× Rounded cube 40 56 140 3.5× Cone 286 516 2,142 7.5× Bar length is relative to each shape’s own Draft count, not to the shapes above it. 2,142 and 12 cannot share one axis, so the three rows are never on the same scale.
The quality setting is invisible until the geometry curves. Each row is scaled to its own Draft bar, because a flat cube and a cone cannot share an axis — 12 against 2,142 would hide the flat cube entirely. Read the ratios instead. The flat cube is three identical bars: 12, 12, 12, a factor of 1.0, so on a box you cannot tell the settings apart at all. The rounded cube separates to 3.5× and the cone to 7.5× — 286 triangles against 2,142 for the same cone. If a setting seems to make no difference, check whether your part has any curved surface to give it something to spend triangles on.

Why there is no way back

Reading the question “can I convert STL to STEP?” as a request for a missing feature would be a mistake, so here is the actual reason it is not a feature.

STEP to STL is sampling: the exact surfaces already exist and you are deciding how finely to walk them. STL to STEP is reconstruction: you have a list of flat triangles and you would have to work out which surfaces a human author originally intended. Many different surfaces fit the same triangles. A tessellator that chose 12 panels around a curve and one that chose 2,142 produce triangles that differ slightly, and both are perfectly good tessellations of the same cone. Nothing in the STL file records which one happened, so there is no correct answer to recover.

What that means in practice is a housekeeping point rather than a limitation to work around: keep the STEP file. The STL is disposable, because you can regenerate it from the STEP in seconds with the converter on the front page. The reverse is not true of the STEP file, and it never was.

The same two-line summary, read at a glance:

What survives the STEP to STL boundary, at a glance
GeometrySurvives — as flat triangles sampled from the exact surfaces, at whatever fineness the quality preset chose.
MetadataDoes not survive. An STL record is 50 bytes of coordinates and a normal, with no field for units, colour, material, part names or the feature tree. Even the colour and material data an AP214 file carries is dropped before meshing — the flavours page follows where it goes.

A one-line answer is where this comparison usually stops, and the itemised one is six times longer for a reason. The two-row version a rival page prints — geometry supported, metadata not — reads as a single loss. Itemised, it is six: units are gone, because the 50-byte record has no field to say a coordinate of 10 is millimetres rather than inches; colour is gone at two stages, dropped from an AP214 file before meshing and then with nowhere to be stored; material goes with the colour; part names and the feature tree go at the boundary, since a triangulation has no parameters left to change; and tolerance is gone in a different sense, because the mesh you received is one sample of a surface that could have been sampled at any fineness, which makes re-running the conversion the only way back. One of the six is recoverable by repeating the conversion. The other five are not, and that is the difference between a table written to be glanced at and one written to be checked.

Does that list fork when the input is IGES? It does not, and none of the six is a STEP-specific loss. Four of them sit in the writer — the 50-byte record has no field for colour, material, part names or a feature tree, whoever wrote the mesh — and the other two sit after tessellation: the declared unit is applied before meshing, and tolerance is a property of the sample rather than of the container it arrived in. Both routes cross the same boundary into the same writer.

The six losses, each checked against both inputs. “Same” means the loss happens on the STL side, after the format boundary, so the source format cannot change it.
LossWhere it happensSTEP inIGES in
UnitsNo unit field in the 50-byte recordDeclared unit applied first, then droppedSame — declared on the file’s own records, then dropped
ColourDropped before meshing, nowhere to store itAP214 colour does not reach the meshSame — colour records stop at the boundary
MaterialSame 50 bytes of coordinates and a normalNot carriedSame
Part namesA triangulation has no name fieldNot carriedSame
Feature treeNo parameters left to re-driveNot carriedSame
ToleranceThe mesh is one sample of a surfaceRe-run the conversion to change itSame

That the two inputs land on one output is not a symmetry argument, so here it is as a measurement. One 10 mm solid, written twice, converted at the same preset:

One solid, two containers, one STL. Every cell is re-measured by npm test from the two sample files.
cube-10x10.stpcube-10x10.igs
Source bytes9,13811,421
Triangles at Normal1212
Output STL684 B684 B
Edges, each used twice18 / 1818 / 18
Connected pieces11
Bounding box10 × 10 × 10 mm10 × 10 × 10 mm

The two inputs differ by 2,283 bytes and the outputs differ by nothing countable. 11,421 is 25% more source than 9,138, and both still come out as 684 bytes, because the output size is fixed by the triangle count rather than by what the container cost. One caveat keeps that honest: the two 684-byte files are not identical byte for byte — 9 of the 684 differ, the first at offset 487, because two triangles of one face are split along the opposite diagonal and a third starts at a different corner. That is a tessellation choice, not a format loss, which is why the rule here is to count triangles rather than diff bytes. The byte-by-byte map lives on the verification page, which owns the same-value comparison; this page only had to answer whether the six-item list forks by input format, and it does not.

And colour is two separate questions. A STEP file can carry colour per solid — it is one of the things an AP214 file may hold — but the boundary drops it before meshing. The STL side then has nowhere to put it: the 50-byte record is coordinates and a normal only. Two vendor variants, VisCAM and SolidView, added a per-face colour field to that record; they are extensions some tools write, not part of the STL format, and the writer on this page emits neither — its binary output is exactly 84 + 50 × triangles with no colour bytes. So a converter that lists colour as a STEP feature and also says STL cannot store it is describing both halves correctly; what it cannot do is hand the colour across.

Two containers of different sizes meeting one writer and one output STEP at 9,138 bytes and IGES at 11,421 bytes both feed the same 84 plus 50 times triangle writer. Two lists show where the six losses sit: two are applied before meshing, four have no field in the 50-byte record. Both outputs are 12 triangles and 684 bytes. Six losses, two locations, one output The list does not fork by input format; the order inside it does. STEP in — 9,138 B of text IGES in — 11,421 B of text One writer: 84-byte header + 50 bytes per triangle, no colour field. Units are applied here, off a declared scale; tolerance is a preset, not a stored value. Already gone before meshing: 1 units declaration, 2 colour & material No field in 50 bytes: 3 part names, 4 feature tree, 5 tolerance, 6 the NURBS surface itself Output: 12 triangles · 684 B · 10 mm box, both inputs
Both containers cross the same boundary. Two of the six items are decided before meshing, four have no field to land in, and the output is 684 bytes either way — the 2,283-byte difference between the sources does not reach the mesh. Drawn from the table above and from the byte counts in tests/engine-table.js.

What each side keeps, counted

The six-item list above is a list of losses; this is the same list with a quantity against each row. Every number in the table can be re-run from the project’s own sample files, and the last column says who decided the outcome: the format, because the 50-byte record has no field for the item, or this writer, because the freedom sat on our side of the boundary. The two are worth separating, since only one of them is ours to change.

What each side keeps, and the quantity that lets you check it. “Format” means the 50-byte STL record has no field for the item; “This writer” and “This page” mean the outcome was a choice made here. Every count is re-measured by npm test from the sample files.
ItemSTEP sideSTL sideCounted hereDecided by
UnitsDeclared inside the file; the inch pair writes 39.370078740157No unit field at allBoth proof cubes measure 1000 × 1000 × 1000 mmFormat
ColourAn AP214 file may carry it per solidDropped before meshing, nowhere to store itOutput is exactly 84 + 50 × triangles, with no colour bytesFormat
MaterialMay be carried with the colourGoes with the colourThe same identity, with no material bytesFormat
Part namesNamed solids in an assemblyNo name field18 solids in, none named outFormat
Feature treePresent, re-drivableNo parameters leftNothing to re-drive; only vertices remainFormat
ToleranceThe surface is exactOne sample of that surfaceCone: 286 / 516 / 2,142 trianglesFormat
Parts18 solids declaredOne triangle list in one file18 parts → 7,372 triangles → 368,684 BThis writer
Axes and originAs the model authored themUnchanged200 × 150 × 84 mm, no rotation or centringThis page
ResolutionNot applicable — the surfaces are exact0.005 / 0.3 at NormalRounded cube: 40 / 56 / 140 trianglesThis page

Six of the nine rows are decided by the format and three by this page. Units, colour, material, part names, the feature tree and tolerance have no field in the 50-byte record, so no writer can carry them across, and nothing on this side of the boundary can be edited to get them back. The other three sit on the writer’s side: this writer merges the 18 solids into one triangle list, leaves the axes and the origin where the author put them, and samples at 0.02 / 0.005 / 0.001 of the bounding box. These are this page’s own choices, not a CAD standard — the orientation page covers the axes, the triangle page covers the budget, and the reverse-direction page covers why merging and sampling cannot be undone. What the format-table page calls a catalogue rather than a capability is the same split read from the other side.

Six rows decided by the format and three by this writer Two boxes. The left box, headed The format decides, lists six items that have no field in the 50-byte record: units, colour, material, part names, the feature tree and tolerance. The right box, headed This page decides, lists parts, axes and origin, and resolution. A note underneath counts the worked examples: 18 solids become 7,372 triangles and 84 + 50 times 7,372 = 368,684 bytes, and the flat cube becomes 12 triangles and 84 + 50 times 12 = 684 bytes. Six belong to the format, three to this page Same conversion, two kinds of limit: one nobody can lift, one chosen here. The format decides — no field in the record Units Colour Material Part names Feature tree Tolerance This page decides Parts Axes and origin Resolution Counted: 18 solids → 7,372 triangles → 84 + 50 × 7,372 = 368,684 B. The flat cube: 12 triangles → 84 + 50 × 12 = 684 B. Same identity on both. Merging, axes and sampling are this page’s own choices, not a CAD standard.
The nine rows of the table above, split by who decides. Six of them have no field in the 50-byte STL record, so no writer can carry them across; the three on the right were choices made here. The two counted lines are re-run by npm test from as1-oc-214.stp and cube-10x10.stp.

The block below is the shortest reproducible digest on this page: three lines, each re-run by npm test from a sample file, and each an identity rather than a measurement you have to trust.

Three reproducible identities behind the table above
Assembly18 solids → 7,372 triangles at Normal → 84 + 50 × 7,372 = 368,684 bytes, from a 433,606-byte STEP file.
Flat part12 triangles → 84 + 50 × 12 = 684 bytes, from 9,138 bytes of STEP and again from 11,421 bytes of IGES.
Unit pairThe inch copy writes coordinates as 39.370078740157 = 1000 ÷ 25.4, and both copies measure 1000 × 1000 × 1000 mm.

What survives, counted, is geometry only: the 18-part assembly arrives as 18 solids and 433,606 bytes and leaves as one triangle list of 7,372 triangles and 368,684 bytes, which is exactly 84 + 50 × 7,372 bytes with no colour, material, part-name or unit bytes left over. Units, colour, material, part names, the feature tree and the tolerance value have no field in the 50-byte record, so those six are decided by the format. Merging 18 solids into one file, keeping the axes and sampling at 0.02 / 0.005 / 0.001 are this page's own choices, not a CAD standard.

The unit surprise, which is really the format talking

An STL record is 50 bytes of coordinates and a normal. There is nowhere in that record to say whether a coordinate of 10 means 10 mm or 10 inches. That is not an oversight in your file; it is the format. Which is why unit errors are recognisable when they happen: they arrive as a clean factor of 25.4, the number of millimetres in an inch, rather than as a vague drift. The cases that produce it are worked through in the units page.

Unit handling measured from the test files
Unit hereEverything is measured in millimetres, the engine default. The unit declared inside your STEP file is applied before you see a number.
Proof pairTwo geometrically identical cubes: one declares UNIT('INCH') and writes its coordinates as multiples of 39.370078740157 (= 1000 ÷ 25.4), the other declares millimetres and writes 1000. Both measure 1000 × 1000 × 1000 mm after the declared unit is applied.
OrientationNothing is rotated, aligned, centred or re-scaled. Coordinates land in the STL in the system the model already used, so laying the part flat for printing is your slicer’s job.
Large assembliesThe 18-part AP203 model measures 5080 × 2209.8 × 3810 mm and the AP214 model 200 × 150 × 84 mm. Both declare millimetres and neither is rescaled on the way out.

One more difference worth knowing: the mesh can be open

A STEP file can describe a solid that is not actually closed, and this converter triangulates rather than repairs. So a gap in the source leaves as the same gap in the STL, and a file that looks fine can still be unprintable. There is a number that settles it: count the mesh edges. A closed shell has every edge shared by exactly two triangles.

Our IGES test cube is a solid, so it should close, and it does — 18 distinct edges across 12 triangles, every one of them used exactly twice, forming one connected piece. The arithmetic generalises: 12 triangles carry 12 × 3 = 36 edge-uses, and a closed mesh uses each edge twice, so 36 ÷ 2 = 18. Any edge used exactly once is a hole, and it arrived that way in the STEP file rather than being introduced by the conversion. The verification page walks through this check and the other four in detail. The complete count — the divide-by-two identity run in both directions, the three edge buckets including the non-manifold case, and what to actually do about a hole — is expanded on the holes page.

What this converter reads, stated plainly

It reads STEP and IGES — .step, .stp, .iges and .igs — and writes STL. Anything narrower than that is out of scope, because the limit sits in the engine rather than in the website.

The list of formats it refuses is documented once, on the verification page, together with the control group the probe runs against, the set of readers actually linked into the shipped WebAssembly build, and why the conclusion is labelled an inference instead of a proof. This page points at that statement rather than repeating it, so there is one place to correct if the engine ever changes.

The whole difference on one screen

What each format stores and what the conversion costs
STEP storesExact surfaces — a cylinder as a radius. Readable text, editable in a CAD tool, carries units and a feature tree.
STL storesTriangles. A flat list of three points each, with no units, no colour, no material and no part names.
The conversionOne-way and lossy. Surfaces are sampled into triangles, and the exact definition does not survive.
Size relationshipNo fixed direction. Flat parts shrink (9,138 B → 684 B), curved parts grow (9,391 B → 25,884 B). Size follows triangle count, nothing else.
Triangle countChosen, not discovered: 12 on a cube at every setting, 286–2,142 on a cone. Output bytes = 84 + 50 × triangles.
Going backNot a conversion but a reconstruction. Keep the STEP file; the STL is disposable and regenerable.
Editing an STLPossible but not parametric: 50 bytes per triangle means no radius and no feature tree to re-drive, so change the dimension upstream and regenerate.
UnitsMillimetres, with the STEP file’s declared unit applied first. The STL does not record the unit, so a misread shows up as a clean 25.4× error.

If you arrived with an STL and a question about turning it back into something editable, the honest answer is that the tessellation is the best available record of that shape and the surfaces are gone. Keep the STEP file next time, and this conversion stops being a one-way door.

Editing the file, and editing the part

“Can I edit an STL file?” deserves a straight answer, because the honest one is more useful than a refusal: you can, and it will not do what you want. Moving a vertex or deleting a face is a legal edit. What is not available is the thing an edit is normally for — changing a dimension and having the shape follow.

The reason sits in the byte layout already described above. An STL record is 50 bytes of coordinates and a normal, so a fillet exists only as the set of flat triangles that happen to approximate it. There is no radius to change and no feature tree to re-drive it, which means the only way to make that fillet bigger is to move every triangle touching it, by hand, and hope the neighbours still meet. Our 10 mm cube makes the scale of this concrete: 12 triangles and 684 bytes is everything the file knows about the shape.

So the workflow that survives contact with a real part is the one that edits upstream. Change the dimension in the CAD tool, re-export, and re-run the STEP to STL converter — the edit stays parametric and the triangle count follows from the geometry rather than from your mouse. The workflow page walks through that order. And a related question that comes up in the same breath is file size: an STL is not expected to be smaller than its source, because flat geometry shrinks while curved geometry grows, and neither direction means the conversion went badly.

Where these numbers come from

The converter on the front page reports the bounding box, triangle count and solid-part count for your own file after every run, so you can check any of this against your own part. To confirm that what you got back matches what you converted, work through the five verification checks — they need nothing but the two files. More of what is here is indexed on the learn page, and the about page states who runs the site and what it will not do. Every byte and triangle count quoted on this page belongs to the measured table on the front page, re-run by npm test.