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.
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.
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.
| Test file | Source bytes | Normal tri | Output STL | Output ÷ source |
|---|---|---|---|---|
| simple-cube.stp | 8,010 | 12 | 684 B | 0.09× |
| cube-10x10.stp | 9,138 | 12 | 684 B | 0.07× |
| cube-10x10.igs (IGES) | 11,421 | 12 | 684 B | 0.06× |
| rounded-cube.step | 20,532 | 56 | 2,884 B | 0.14× |
| conical-surface.step | 9,391 | 516 | 25,884 B | 2.76× |
| as1_pe_203.stp (18 parts) | 136,663 | 6,088 | 304,484 B | 2.23× |
| as1-oc-214.stp (18 parts) | 433,606 | 7,372 | 368,684 B | 0.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.
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:
| Identity | bytes = 84 + 50 × triangles |
|---|---|
| Inverted | triangles = (bytes − 84) ÷ 50 |
| Worked example | A 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 trustworthy | The 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.
| Test file | Shape | Draft tri | Normal tri | Fine tri | Fine ÷ Draft |
|---|---|---|---|---|---|
| simple-cube.stp | Flat cube | 12 | 12 | 12 | 1.0× |
| cube-10x10.stp | Flat cube | 12 | 12 | 12 | 1.0× |
| cube-10x10.igs (IGES) | Flat cube | 12 | 12 | 12 | 1.0× |
| rounded-cube.step | Rounded edges | 40 | 56 | 140 | 3.5× |
| conical-surface.step | Curved surface | 286 | 516 | 2,142 | 7.5× |
| as1_pe_203.stp (18 parts) | Assembly | 3,848 | 6,088 | 17,848 | 4.6× |
| as1-oc-214.stp (18 parts) | Assembly | 4,900 | 7,372 | 21,116 | 4.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.
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.
- This converter reads STEP and IGES and writes STL. Extensions
.step,.stp,.igesand.igsgo in; STL comes out. An STL cannot be dropped back in, and we would rather say so than pretend. - The loss is real and worth naming. Exact radii, the feature tree your CAD tool attached, part names, colours and materials all stop existing at the boundary. Faces and edges survive only as triangle boundaries.
- The reverse conversion is a different kind of tool. One exists, and it is a legitimate thing to want — it reconstructs a surface by fitting, and the fit is an interpretation rather than a recovery. That is a decision to make deliberately with a tool built for it, not a checkbox here.
The same two-line summary, read at a glance:
| Geometry | Survives — as flat triangles sampled from the exact surfaces, at whatever fineness the quality preset chose. |
|---|---|
| Metadata | Does 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.
| Loss | Where it happens | STEP in | IGES in |
|---|---|---|---|
| Units | No unit field in the 50-byte record | Declared unit applied first, then dropped | Same — declared on the file’s own records, then dropped |
| Colour | Dropped before meshing, nowhere to store it | AP214 colour does not reach the mesh | Same — colour records stop at the boundary |
| Material | Same 50 bytes of coordinates and a normal | Not carried | Same |
| Part names | A triangulation has no name field | Not carried | Same |
| Feature tree | No parameters left to re-drive | Not carried | Same |
| Tolerance | The mesh is one sample of a surface | Re-run the conversion to change it | Same |
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:
| cube-10x10.stp | cube-10x10.igs | |
|---|---|---|
| Source bytes | 9,138 | 11,421 |
| Triangles at Normal | 12 | 12 |
| Output STL | 684 B | 684 B |
| Edges, each used twice | 18 / 18 | 18 / 18 |
| Connected pieces | 1 | 1 |
| Bounding box | 10 × 10 × 10 mm | 10 × 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.
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.
| Item | STEP side | STL side | Counted here | Decided by |
|---|---|---|---|---|
| Units | Declared inside the file; the inch pair writes 39.370078740157 | No unit field at all | Both proof cubes measure 1000 × 1000 × 1000 mm | Format |
| Colour | An AP214 file may carry it per solid | Dropped before meshing, nowhere to store it | Output is exactly 84 + 50 × triangles, with no colour bytes | Format |
| Material | May be carried with the colour | Goes with the colour | The same identity, with no material bytes | Format |
| Part names | Named solids in an assembly | No name field | 18 solids in, none named out | Format |
| Feature tree | Present, re-drivable | No parameters left | Nothing to re-drive; only vertices remain | Format |
| Tolerance | The surface is exact | One sample of that surface | Cone: 286 / 516 / 2,142 triangles | Format |
| Parts | 18 solids declared | One triangle list in one file | 18 parts → 7,372 triangles → 368,684 B | This writer |
| Axes and origin | As the model authored them | Unchanged | 200 × 150 × 84 mm, no rotation or centring | This page |
| Resolution | Not applicable — the surfaces are exact | 0.005 / 0.3 at Normal | Rounded cube: 40 / 56 / 140 triangles | This 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.
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.
| Assembly | 18 solids → 7,372 triangles at Normal → 84 + 50 × 7,372 = 368,684 bytes, from a 433,606-byte STEP file. |
|---|---|
| Flat part | 12 triangles → 84 + 50 × 12 = 684 bytes, from 9,138 bytes of STEP and again from 11,421 bytes of IGES. |
| Unit pair | The 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 here | Everything is measured in millimetres, the engine default. The unit declared inside your STEP file is applied before you see a number. |
|---|---|
| Proof pair | Two 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. |
| Orientation | Nothing 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 assemblies | The 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
| STEP stores | Exact surfaces — a cylinder as a radius. Readable text, editable in a CAD tool, carries units and a feature tree. |
|---|---|
| STL stores | Triangles. A flat list of three points each, with no units, no colour, no material and no part names. |
| The conversion | One-way and lossy. Surfaces are sampled into triangles, and the exact definition does not survive. |
| Size relationship | No 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 count | Chosen, not discovered: 12 on a cube at every setting, 286–2,142 on a cone. Output bytes = 84 + 50 × triangles. |
| Going back | Not a conversion but a reconstruction. Keep the STEP file; the STL is disposable and regenerable. |
| Editing an STL | Possible but not parametric: 50 bytes per triangle means no radius and no feature tree to re-drive, so change the dimension upstream and regenerate. |
| Units | Millimetres, 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
Published · Last updated
- Every source byte count, triangle count and output size — produced by running the shipped engine (occt-import-js 0.0.23, a WebAssembly build of OpenCASCADE) in Node.js over the project’s own test files.
npm testre-runs every row of both tables on this page, diffs each figure, and re-checks the 12-triangle cube end-to-end in a headless browser. The output ÷ source column and the Fine ÷ Draft column are recomputed from the raw numbers rather than trusted. - 84 + 50 × triangles — the published binary STL record layout, cross-checked against the reference STL shipped with the engine vendor’s own test set.
- 25.4, and the inch/mm proof pair — 25.4 is the exact number of millimetres in an inch. The pair is two geometrically identical cubes, one declaring
UNIT('INCH')and one declaring millimetres;npm testasserts both bounding boxes and the inch declaration. - The STEP / IGES pair behind the six-loss table —
cube-10x10.stpis 9,138 bytes andcube-10x10.igsis 11,421, andnpm testconverts both, asserting 12 triangles, a 684-byte STL, 18 edges each used twice, one piece and a 10 mm box on each route. The 2,283-byte input gap is the difference of the two file sizes; the 9 differing output bytes and offset 487 are recomputed byte by byte. - The counted block and the nine-row table — every quantity is re-derived by
npm testfrom the project’s own sample files: 18 parts and 7,372 triangles at Normal fromas1-oc-214.stp, 433,606 source bytes and a 368,684-byte output from the shipped writer, 12 triangles and 684 bytes fromcube-10x10.stpand again fromcube-10x10.igs, 40 / 56 / 140 fromrounded-cube.step, 286 / 516 / 2,142 fromconical-surface.step, and 39.370078740157 as 1000 ÷ 25.4 in the inch/mm pair. The 200 × 150 × 84 mm box is the assembly’s own bounding box at Normal. - The 18-edge closed shell — computed from the merged triangle list the shipped writer produces, by counting each undirected edge and how many triangles use it.
- The unsupported-format list — not re-published on this page. It comes from
node tests/format-support.js, which probes each format against the same reader dispatch behind a known-good STEP control, and the verdict together with its reasoning chain is stated on check 5 of the verification page.
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.
Sponsored link: Creality’s official store (3D printers, scanners, filament and parts) is an affiliate partner — clicking it may earn this site a commission. It changes nothing about the converter; see what sponsored links mean here.