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

How to convert STEP to STL, in order

This is the whole procedure on one screen, in the order the steps actually matter. Every number below was measured on the machine that wrote this page, and npm test re-runs each one. Nothing here is a rule of thumb.

  1. Check the extension. .step, .stp, .iges or .igs. The extension picks the reader, and STEP and IGES take different code paths.
  2. Confirm the unit is what you expect. Numbers come out in millimetres by default, the default path touches no coordinate, and the part is never rotated, aligned, centred or rescaled.
  3. Choose a quality setting. Normal for printing, Draft to check fit on an assembly, Fine for a fillet that still looks faceted. The setting costs nothing on flat parts.
  4. Predict the output before you convert. A flat cube is 12 triangles and 684 bytes at every setting. A cone is 286, 516 or 2,142. File size is 84 + 50 × triangles, so the triangle count tells you the byte size.
  5. Convert in the browser. Parsing and tessellation run on your own machine. Nothing is uploaded, and there is no queue.
  6. Verify the output. Check the file size against the triangle count, and check the mesh is closed. The verification page has all six checks with numbers.

Steps 1–4 are decisions. Steps 5–6 are the conversion itself and the proof it worked. Most bad STEP to STL results are decided in the first four, before a single triangle exists, which is why they are the ones worth being precise about.

The extension decides everything downstream

Two format families, four extensions, two readers. A .step or .stp file goes to the STEP reader; .iges or .igs goes to the IGES reader. Nothing else is accepted, and that is a property of the engine rather than a policy setting: the shipped WebAssembly build links readers for STEP, IGES, BREP and a generic fallback, and no importer for anything else.

If your file has any other extension, stop there rather than renaming it. Renaming does not convert anything; it just moves the problem to step 5, where the reader will fail on content that is not the format its name claims. Export from your CAD tool instead.

.step and .stp are the same format with a different spelling — both are ISO 10303-21 text and both go to the same reader, so the extension changes nothing about the result. A site that publishes a separate page for each spelling is duplicating a landing page, not offering a second pipeline. What actually differs between two STEP files is what the exporting tool wrote inside them, such as the AP203 or AP214 flavour; that is a property of the file, not of its three letters, and the flavours page measures the difference on two real assemblies.

Four extensions, two readers, one output Four file extensions in two groups. .step and .stp both point to the STEP reader; .iges and .igs both point to the IGES reader. Both readers feed the same tessellation step, and the output is one STL file. The extension picks a reader, not a pipeline .step .stp same ISO 10303-21 text, one reader .iges .igs surface-based, second reader STEP reader solids and surfaces IGES reader → one STL binary, 84 + 50 × n
Two spellings, one reader. .step and .stp are the same format, so a page per spelling is a duplicate landing page rather than a second pipeline; .iges and .igs take the other reader and can leave surfaces as separate pieces. The binary size rule is the one the file-size page proves: 84 + 50 × triangles.

One difference between the two paths is worth knowing before you trust an IGES result: IGES stores surfaces rather than a solid. Surfaces that do not actually meet in the file stay separate pieces in the output, so a multi-piece result from an IGES source is not automatically a fault. Nothing later in the pipeline merges them either: the pipeline page lists what the middle of the conversion does and does not do.

IGES is also a text format, whatever a converter’s summary table says. In the 27 October 2026 read, one tracked pairing page labels its IGS entry “Binary” in the format table while the same page’s description calls IGES a human-readable text-based format — the label contradicts the sentence beside it. The reader here goes by the file’s content, not by that label: our IGES test cube carries the same 12 triangles / 684 bytes as the STEP cube at every preset, and the verification page is where the accepted extensions are listed.

A compressed STEP file is the same text inside a wrapper, not a second format. A pairing page read on gives that container its own extension row, calls it a compressed STEP file and files it under a generic binary MIME type — a row that describes the packaging rather than the payload. Unpack it and the payload is the same ISO 10303-21 text this page’s reader already parses; what changes is how many bytes travel, not what has to be understood. That is why the accepted list above stays at four spellings and the container is not one of them: a reader is handed text, so something has to unpack the container first, and a service that accepts it is running one extra step before the step this page describes.

One payload in two envelopes: the plain STEP extensions and a compressed container On the left, .step and .stp hold ISO 10303-21 text and go straight to the STEP reader. On the right the same text sits inside a compressed container with its own extension; unpack it and the payload reaches the same reader. Both end at one binary STL sized 84 + 50 times the triangle count. The wrapper changes the bytes, not the reader .step / .stp ISO 10303-21 text, plain same text, compressed one extra unpack step STEP reader the same one, either way both envelopes → one binary STL 84 + 50 × triangles the plain pair measures 12 triangles → 684 bytes
Packaging is not a format. The plain .step/.stp pair and a compressed container hold the same ISO 10303-21 payload; the container only adds an unpack step before the reader this page describes, which is why the accepted list stays at four spellings. The output rule does not move: the 10 mm cube measures 12 triangles / 684 bytes, and 684 = 84 + 50 × 12.

Three layers, and only one of them is a format. A format table squeezes three different things into one row: the payload, which is the ISO 10303-21 text describing the geometry; the container, which is whatever wrapper the bytes happen to travel in; and the reader, which is the code that parses a payload into shapes. A plain .step has no wrapper at all. A compressed spelling puts the same payload inside one. Only the payload decides which reader runs, and the wrapper is undone before that reader is handed anything.

Keep the three apart and each checkable quantity lands in its own column. The container moves the byte count. It does not move the reader count: the file still needs the STEP reader, and one unpack step is not a second format. It does not move the triangle count either, because the shape described inside the text is the same shape. That distinction is countable at the output end even though this converter never sees a container.

Input bytes and output bytes are not the same quantity. The 10 mm cube arrives here as 9,138 bytes of STEP text and leaves as 12 triangles in a 684-byte binary STL. Those two numbers cannot be compared with each other: 684 is fixed by the triangle count alone, 684 = 84 + 50 × 12, so any file that tessellates to 12 triangles produces exactly 684 bytes whatever its input was written and packaged like.

That is where a container fits. It changes the number of bytes that travel; it cannot change either number this page counts — one reader, twelve triangles. This page prints no compression ratio, because this converter does not accept the container and there is nothing here to measure. Accepting one would mean unpacking it first: one more step before step 5, not a fourth entry in the reader list. That is why the accepted list above stays at four spellings.

Which STEP flavour? The two assemblies in the cost table below are the two flavours a STEP file can declare: as1_pe_203.stp is AP203 and as1-oc-214.stp is AP214. AP203 is the older, geometry-focused exchange protocol; AP214 adds colour and material assignments on top of the same solid geometry. For STL this changes nothing in the pipeline — the same STEP reader takes both and tessellation runs the same way, and whatever AP214 adds beyond geometry is dropped on the way to the mesh, as the verification page’s colour check shows. The flavour decides what travels inside the file, not how the triangles are produced.

Units: the file’s declared unit in, millimetres out by default

Millimetres are the default output and the default path leaves every coordinate alone, so the number you see is the number the engine measured. Separately, the converter applies the unit declared inside your file before it reports anything — that is not the same as assuming millimetres, and the difference is worth proving rather than asserting.

We built a control pair for it: two geometrically identical 1,000 mm cubes, one declaring UNIT('INCH') with its coordinates written as multiples of 39.370078740157 (which is exactly 1000 ÷ 25.4), and one declaring millimetres directly. Both read back as a 1,000 × 1,000 × 1,000 mm bounding box. The declaration inside the file is what decides, and it is honoured.

What the converter does and does not change
Unit of outputMillimetres by default. The unit declared in the STEP file is applied first.
The inch optionDivides the coordinate values by 25.4 on the way out. It re-expresses numbers; it does not scale the geometry, and it does not add or remove a triangle.
Position and axesThe part is not rotated, aligned, centred or scaled. A 200 × 150 × 84 mm assembly stays 200 × 150 × 84 mm. The measurements behind that line are on the orientation and origin page.
If the size is wrongA clean factor of 25.4 means the file was read in the wrong unit, not converted badly.

The quality choice, and what it costs before you spend it

Each setting is a pair of numbers: a linear deviation and an angular deviation. Draft is 0.02 and 0.5, Normal is 0.005 and 0.3, Fine is 0.001 and 0.1. These are this site’s own choices, not a CAD standard, and they are compared against the shipped worker’s values by npm test so the two copies cannot drift apart.

The important thing about that pair is that you cannot reason about the result from either number alone — you can only measure it. So here is what each setting actually produced, on real files, with this engine.

What decides the triangle count when the page offers no setting at all? Whichever default the tool shipped with — and that number is not on the page, so you cannot read it before you convert. A conversion page can be built with a drop zone and one button and nothing else; nothing about that layout is dishonest, but it moves the quality decision off the page. On this page the opposite rule holds: every preset is named by the count it produced, so the choice is made against a number rather than against a word. If you meet a page with no control of any kind, convert once and count the triangles in the file you get back — the triangle-count page shows how to read that number out of the bytes, and the verification page says what to check next.

If you are comparing these two numbers with a figure you read somewhere else, three things have to match before the comparison means anything. First, the linear value here is a ratio of the model’s bounding box, not a millimetre figure: the worker asks the kernel for linearDeflectionType: 'bounding_box_ratio', so 0.005 asks for a deflection of 0.5% of the model’s bounding box rather than a fixed distance in space. That is why scaling a part up does not buy it a denser mesh — the cone on this page keeps its 516 triangles at Normal at 27.033 mm and again at 2,703.298 mm, because the tolerance grew with the part. A CAD tool that asks for a chord height in millimetres, or a print service that recommends a fixed decimal “distance”, is asking for a different quantity with the same small shape. Second, the angular value is in radians: 0.5 is 28.6°, 0.3 is 17.2° and 0.1 is 5.7°, so the step from Normal to Fine is a much larger change in angle than the digits suggest. Third, the pair is simply named differently from tool to tool — chord height, deviation, tolerance and deflection all describe some version of the first number — which is why no value travels: the one figure that does is the triangle count the conversion actually produced.

If a page prints its medium tier as a number of degrees, which half of the pair is that? The angular half. 0.5 rad here is 28.6°, so a page whose middle setting reads “about 30 degrees” is quoting a value that nearly coincides with Normal on this site — while any linear half it also carries is a different quantity under a different name, and cannot be checked against 0.005 at all. That wording was read on one tracked site’s resolution article on 2026-11-03, and it is the reason this page keeps both numbers side by side instead of one tier name.

What each setting produced on each test file, measured with this engine in Node.js; npm test re-runs every cell and fails on a mismatch. Bytes are binary STL size.
Test fileShapeDraft triNormal triFine triFine ÷ DraftNormal bytesFine bytes
simple-cube.stpFlat cube1212121.0×684 B684 B
cube-10x10.stpFlat cube1212121.0×684 B684 B
cube-10x10.igs (IGES)Flat cube1212121.0×684 B684 B
rounded-cube.stepRounded edges40561403.5×2,884 B7,084 B
conical-surface.stepCurved surface2865162,1427.5×25,884 B107,184 B
as1_pe_203.stp (18 parts)Assembly3,8486,08817,8484.6×304,484 B892,484 B
as1-oc-214.stp (18 parts)Assembly4,9007,37221,1164.3×368,684 B1,055,884 B

A flat face costs two triangles at every quality setting, while a curved face costs hundreds Two rows of bars. The first row is a flat cube measured at 12 triangles under Draft, Normal and Fine, with three identical bars and a ratio of 1.0 times. The second row is a conical surface measured at 286, 516 and 2,142 triangles, a ratio of 7.5 times. Each row is scaled to its own first bar, so the rows are not on a shared axis. Flat stays 12. Curved moves 7.5×. Draft Normal Fine Flat cube 12 12 12 1.0× Cone 286 516 2,142 7.5× Each row is scaled to its own Draft bar. 2,142 and 12 cannot share one axis, so the two rows are never drawn to the same scale — read the ratios. A flat face is stored exactly; only a curved face has to be invented.
One row is a health check, the other is a quality dial. The flat cube reads 12 under all three settings, so the setting cannot change a planar face and any extra geometry on a flat face is a fault in the file. The cone reads 286, 516 and 2,142, a factor of 7.5 from Draft to Fine, so on a curved face the same file legitimately produces very different meshes. Both rows are drawn to their own first bar, which is why their bar lengths are not comparable — the ratios within a row are the measurement.

Read that table as a cost, not a menu. Going Draft to Fine multiplies the cone by 7.5 and the assemblies by roughly 4.3–4.6, while leaving the flat cubes untouched. If your part is mostly flat, Fine is free; if it is mostly curved, Fine is a real cost and you should look at the preview before accepting it. What that cost means in bytes is drawn to scale on the file-size page — the cone's 286 to 2,142 triangles are 14,384 to 107,184 bytes by the fixed 84 + 50 × triangles identity. And where the parts themselves separate — the engine reports the assembly as per-solid meshes, 18 solids with 5 distinct per-part counts that add up to the 7,372 total — that walk is measured on the no-CAD page.

Two STEP flavours, one pipeline: each assembly keeps its own triangle counts at every preset Two rows of bars. The first row is the AP203 assembly as1_pe_203.stp, measured at 3,848 triangles under Draft, 6,088 under Normal and 17,848 under Fine. The second row is the AP214 assembly as1-oc-214.stp, measured at 4,900, 7,372 and 21,116 triangles under the same three settings. Each row is scaled to its own Fine bar, so the rows are not on a shared axis. The figure shows that the STEP flavour changes what is inside the file, not how the mesh is produced. Two flavours, one pipeline. Draft Normal Fine AP203 3,848 6,088 17,848 AP214 4,900 7,372 21,116 as1_pe_203.stp is AP203, as1-oc-214.stp is AP214. Each row is scaled to its own Fine bar, so bar lengths are never comparable across rows — read the counts. Same reader, same tessellation: the flavour changes what travels inside the file, not how the mesh is produced.
Two STEP flavours, one pipeline. The two verified assemblies are the two flavours a STEP file can declare: AP203 on the first row, AP214 on the second. Each row is drawn to its own Fine bar, which is why the bar lengths are not comparable across rows — the counts are the measurement. AP214 adds colour and material data on top of the same solid geometry; the same reader takes both files, the tessellation runs the same way, and anything beyond geometry is dropped on the way to the mesh.

Predicting the count before you convert

For a flat part you can predict the answer exactly: a cube is 12 triangles, because six flat faces need exactly two each, and no closed solid can use fewer. 684 bytes, every time, at every setting.

For a curved part you can predict the byte size from any triangle count, because the binary STL layout is fixed at 84 bytes of header plus 50 bytes per triangle. What you cannot do is look at a STEP file and derive its triangle count from its byte size — the two are unrelated, and the table above shows a 9,391-byte cone producing a 107,184-byte STL at Fine. Curvature, not file size, drives the count.

Scaling the part up does not give you a finer mesh

This is the most useful thing we measured, and it is not what the setting names suggest. The presets are expressed as a ratio of the part’s own size, which reads like “bigger part, same relative accuracy, more triangles”. We tested that directly instead of assuming it.

We took one curved solid and scaled the entire solid to 100× its size. Measured at Normal, the bounding box went from 27.033 mm to 2,703.298 mm — a clean 100× on all three axes — and the triangle counts did not move at all:

The same curved solid at 1× and at 100× its size, converted with this engine at all three shipped settings.
SettingTriangles at 1×Triangles at 100×Bytes at 1×Bytes at 100×
Draft28628614,384 B14,384 B
Normal51651625,884 B25,884 B
Fine2,1422,142107,184 B107,184 B

Same triangles, same bytes, hundred times the physical size. Enlarging a model is not a way to get a better mesh in this engine. If your mesh looks faceted, the fix is the quality setting, not a bigger model.

The same curved solid converted at its original size and at 100 times that size, at Draft, Normal and Fine Two rows of three bars. The top row is the curved solid at its original size, the bottom row is the same solid scaled to 100 times its size, with a bounding box of 2,703.298 mm instead of 27.033 mm. Every bar in the lower row is exactly the same length as the bar above it in the top row: 20, 36 and 150 pixels, which is 286, 516 and 2,142 triangles. One hundred times the physical size produces an identical mesh. Same curved solid, 1× and 100× its size — the bars are identical Draft Normal Fine At 1× 286 516 2,142 At 100× 286 516 2,142 At Normal: bounding box 7.000 × 27.033 × 26.957 mm at 1×, 700.000 × 2,703.298 × 2,695.739 mm at 100×. Bar length = triangles ÷ 286 × 20 px, one shared scale across both rows. The bounding box grew 100×. Not one triangle was added.
A hundred times the size, an identical mesh. Both rows are drawn to one shared scale, so the bars are not merely close — they are the same length, because the triangle counts are the same: 286 at Draft, 516 at Normal, 2,142 at Fine, with identical byte sizes. The bounding box underneath grew from 27.033 mm to 2,703.298 mm. Scaling a model up buys nothing here.

We are deliberately not going further than that, and here is the honest reason. The presets name their linear deviation as a bounding_box_ratio, which implies a physical tolerance of “ratio × the part’s size”. We could not confirm that arithmetic: passing the same value as absolute instead produces identical triangle counts, so the wrapper does not visibly distinguish the two modes on our test files. The scale invariance above is measured; any formula behind it is not, so we do not print one.

Which of the two numbers actually binds

Because the two numbers interact, one of them can stop mattering entirely. Holding the cone at each angular value and varying only the linear value gives:

Triangle counts for the cone at three angular values and three linear values
Angular valuelinear 0.02linear 0.005linear 0.001
0.1 (Fine)2,1422,1422,142
0.3 (Normal)5045161,318
1.0 (relaxed)1864081,318

Read the top row. At the angular value Fine uses, the linear value makes no difference at all — 0.02, 0.005 and 0.001 all give 2,142 triangles, because the angular constraint is already the tighter one. Drop it to 0.3 and linear starts to matter; relax it to 1.0 and linear takes over completely and the counts fall to 186 and 408.

The practical consequence: you cannot predict the output by arithmetic on the two numbers, which is exactly why step 4 exists. Convert, look at the count, and only then decide whether to pay for a finer setting.

The conversion itself

Drop the file on the STEP to STL converter. Parsing and tessellation run in your tab as occt-import-js 0.0.23, a WebAssembly build of the OpenCASCADE kernel. The file is read on your machine and is never uploaded; there is no server-side step and no queue. That also means the result comes from your own hardware rather than from a remote service, which is a fair trade for a file that never leaves the tab. The kernel is also the only CAD component involved, so a machine with no CAD package installed is not an obstacle — opening a STEP file without CAD is quantified on its own page.

The two ends of this step are fixed, whatever you choose in between: what goes in is one of the four extensions from step 1, and what comes out is one .stl file — binary by default, ASCII if you switch it. A .stl file is an output here, never an input. The format page explains why that direction cannot be reversed, so this page does not restate it. Which station in the pipeline is the one that writes the format, and where the first byte of the file exists, is measured on the station page.

The page reports three numbers after every run, and they are the ones to look at before you download: the bounding box in millimetres (compare it to the size you know), the triangle count, and the solid-part count. For an assembly the part count is the useful one — our two 18-part test files both report 18, and every part lands in the single STL you download.

If your file is refused, it is not a quality problem. No setting will make an unreadable file readable, and no setting will repair a broken model: this triangulates, it does not fix geometry that arrived with holes or self-intersections.

Three promises, three different strengths. When converters compete on privacy, listen for which promise is actually being made. The weakest is “we delete your file after conversion” — the file still travels to a server, and the promise covers only what happens afterwards. Stronger is “we do not store your files” — still an upload; the promise is about retention, not transport. The strongest is the one this step makes: the file never leaves the tab, because parsing and tessellation run on your own hardware. The first two are policies that can change or misfire; the third is an architecture, and this project's browser test suite re-checks it on every build — a conversion must make no request beyond the page origin. There is also a fourth rung above the third: an architecture claim plus evidence you can check yourself — a per-request list and a published test you can re-run. The upload-safety page grades all four rungs and gives you a one-minute network-panel self-check you can run against any converter, this one included.

Verify, because finished is not the same as correct

The single cheapest check costs nothing: a binary STL is 84 + 50 × triangles bytes, so subtract 84 from the file size and divide what is left by 50. If that recovers the triangle count the converter reported, the download is intact. There is no rounding in that identity, so any mismatch is a real fault rather than a rounding artefact.

Then check the mesh is closed by counting edges: every edge shared by exactly two triangles means a watertight solid, and an edge used once is a hole. A cube gives 12 triangles across 18 distinct edges, and that arithmetic generalises to any closed solid: 12 × 3 = 36 edge-uses, divided by two, is 18.

Both checks, plus the unit check, the curvature check and the reader check, are laid out with their numbers on the STEP to STL verification page.

The whole thing on one screen

The six steps and the number each one produces
1. Extension.step, .stp, .iges, .igs. Decides the reader. Nothing else is read.
2. UnitsMillimetres out by default, axes unchanged. A 25.4× error means a unit mismatch, not a bad conversion.
3. QualityDraft 0.02/0.5, Normal 0.005/0.3, Fine 0.001/0.1. Costs nothing on flat parts, 7.5× on a cone.
4. Expected outputFlat cube 12 tri / 684 B at every setting. Cone 286–2,142 tri. Bytes = 84 + 50 × triangles.
5. ConvertRuns in your tab. Reports bounding box, triangle count and part count. Nothing uploaded.
6. Verify(size − 84) ÷ 50 recovers the triangle count. Every edge used twice means closed.

Scaling the model up does not belong in that list, because it changes nothing: 100× the size returned identical counts and identical bytes at all three settings.

Where these numbers come from

The verification page covers step 6 in full, and STEP vs STL covers what the two formats actually store. This page is the order of operations and the numbers each step produces. Every byte and triangle count quoted on this page belongs to the measured table on the front page, re-run by npm test.