Why did old converters upload your CAD model? The resurfacing era and the compute wall

An upload form looks like a choice a service made about your file. In the era this page is about, it was the opposite: a description of which machine could finish the work. The service's own help pages survived on the Wayback Machine, and they answer the two questions a user would ask — why must I upload, and why is there a limit on my free file — in the operator's own words. This page reads those answers, then measures what the same job costs now that it fits in a browser tab.

The short answer

The work being sold was not a format swap, it was resurfacing — an engine reinterpreting every surface of the model into a printable solid — and the desktop machines of 2005–2009 could not run it. When your own computer cannot finish a job, the job has to happen somewhere else, so the model travelled to the operator's server and came back a few minutes later. That arrangement had a price, and the price was charged to the operator, not to you: which is exactly why the free tier stopped at a fixed polygon count. The 100,000-polygon cap was not a property of the STL format and not an arbitrary act of meanness — it was a ceiling the operator put on how much server time it was willing to pay for on your behalf. Today the same class of job runs inside the tab on this site, because the kernel that does it now ships as a 7,604,031-byte WebAssembly file instead of a rack of desktop machines.

The operator's own answer to "why do I have to upload?"

The clearest answer is not written by anyone today; it is in the service's own FAQ, archived on 27 January 2009. The question is asked bluntly — Why do I have to upload my model? — and the first sentence of the answer is the cause: resurfacing a model is “a very computationally intensive task”. Then the requirement itself: running it on your machine would need “several Gigabytes of RAM free and a fast processor”. And then the reason the requirement mattered: that is “certainly not a requirement for SketchUp or many other CAD programs”, so most of the people holding a model did not have the machine. The operator states the design decision plainly: “We chose to make our software bring remote computing power to your desktop.” A follow-up question in the same FAQ — will the pro version surface files on my machine? — gets a one-word answer, No, followed by the same commitment to remote processing. The upload was not a convenience or a lock-in; it was the architecture, because the alternative was asking every customer to buy several gigabytes of RAM.

The polygon cap was a compute bill

The second question is the one that reads like a limitation on you: Why is there a 100,000 polygon limit? The answer given in the same 2009 FAQ ties the number straight to money. Free files were capped because “processing time costs us money. We actually pay to process your free files.” The operator calls that number “a somewhat arbitrary limit on how much we can give away” — arbitrary as a value, but not as a boundary: it is the point past which server time stops being affordable. The same answer explains which files fail even below the cap, and the reasoning is about output rather than inputs: a whole cityscape or a high-fidelity model of a bridge would not produce a good result (the operator asks, reasonably, how you would print the cables), because the service was tuned for what fits inside one build of a 3D printer. The recommended workaround is telling: divide the model into smaller parts and surface them one at a time. Splitting a file to stay under a server limit is the fingerprint of compute that is metered by the job.

2005: upload-and-wait was the product from day one

The FAQ that explains the upload is dated 2009, but the upload was not a later addition. The homepage archived on 24 January 2005 already advertises the service as “operational NOW!” and describes the identical flow: create a user account, upload a file, submit it for processing, and in a few minutes the output file is ready to review. Three years before anyone wrote down why the file had to travel, the travel was already the product. That ordering matters, because it rules out the reading that the upload was introduced to capture data or to upsell — it was there because it was the only way the work could be done at all. The same era's paid, seat-based converters sold the identical job to engineering firms, and the free web of the 2010s could not read a STEP file at all without them (the format boards of the mesh era quantify that gap: a 51-extension input list with no CAD format on it, and a published success rate of 75.8% even on formats the free tools did read).

What changed: the kernel moved into the tab

Uploading was a workaround for a machine that was too small. The machine got small enough to ship. This site serves the OpenCASCADE kernel — the same class of geometry kernel desktop CAD packages are built on — as a WebAssembly file of 7,604,031 bytes (7.25 MiB), fetched once per session from this site's own folder. A worker thread in your tab parses the STEP file and tessellates it, and the STL is written by the browser with nothing uploaded. The numbers are measured by the test suite on every run, and the same suite refuses to publish this page if they move: a flat 10 mm cube stays 12 triangles and 684 bytes at every quality setting, a cone runs 286 → 2,142 triangles from Draft to Fine, and an 18-part assembly measuring 433,606 bytes of STEP comes back as 7,372 triangles in a 368,684-byte STL at Normal, or 21,116 triangles at Fine. That last file is worth sitting with: it is a whole multi-part assembly, and the full Fine tessellation finishes inside a single tab — the exact job whose polygon budget used to be capped because server time cost the operator money.

The same lesson, twelve years earlier

One line in the 2009 FAQ could have been written today on this site. After describing what resurfacing produces, the operator adds a warning in parentheses: a common misunderstanding is that “STL = 3D printable; this is simply not true”. That is the identical claim the holes page makes with an edge count instead of an assertion — a closed shell spends every edge exactly twice, twelve triangles make thirty-six edge-uses and therefore eighteen edges, and a tool that only relays a mesh will hand you the hole back. The format did not change between 2009 and now, the geometry did not change, and the honest answer did not change. What changed is who has to run the machine.

Questions this page answers

Why did old online converters require an upload?

Because the operation was resurfacing, and the era's desktop machines could not run it. The operator's own FAQ, archived on 27 January 2009, answers the question "Why do I have to upload my model?" with the compute requirement: resurfacing was a very computationally intensive task, and running it locally would need several Gigabytes of RAM free and a fast processor — hardware that is certainly not a requirement for SketchUp or many other CAD programs. The upload was not a business preference; it was the only machine in the room that could finish the job.

Why was there a polygon limit on free conversions?

Because the compute bill was the operator's, not yours. The same 2009 FAQ answers "Why is there a 100,000 polygon limit?" by tying the cap to cost — processing time costs us money, we actually pay to process your free files — and calls the number a somewhat arbitrary limit on how much we can give away. The limit was an economic ceiling on server time, not a property of the file format, which is why the recommended workaround was to divide a large model into smaller parts and convert them one at a time.

When did online converters start uploading models?

At least as early as 2005. An archived copy of the service's homepage from 24 January 2005 announces that CADSPAN online translation is operational NOW, and describes the flow: set up a user account, upload files, submit them for processing, and in a few minutes the output file is ready to review. Upload-and-wait was the shape of the product from its first public day, three years before the FAQ that explained why it had to be.

Can the same conversion run without a server today?

For the files this site measures, yes. The OpenCASCADE kernel ships as a 7,604,031-byte WebAssembly file that is fetched once per session from this site's own folder; a worker in the tab parses the STEP file and tessellates it. The measured counts: a flat 10 mm cube stays 12 triangles and 684 bytes at every quality setting, a cone runs 286 to 2,142 triangles from Draft to Fine, and an 18-part assembly converts to 7,372 triangles in a 368,684-byte STL at Normal, or 21,116 triangles at Fine, with nothing uploaded. Whether that holds for every file is not something this page claims; it holds for the ones the test suite runs every day.

Where these numbers come from

• “very computationally intensive”, “several Gigabytes of RAM free and a fast processor”, “certainly not a requirement for SketchUp” — the archived help FAQ of 27 January 2009, kept in this project's research folder; the test suite reads the file and requires each quoted phrase before the page may print it.
• “processing time costs us money”, “we actually pay to process your free files”, 100,000 polygons — the same 2009 FAQ, quoted from the same file, dated as the 2008–2009 snapshot it is.
• “operational NOW!” and the account-and-upload flow — the archived homepage of 24 January 2005, read from the same research folder.
• 0.02 / 0.05 / 0.07 thickness values — the archived thickness calculator of 26 October 2008; the suite reads the file and requires the three numbers.
• Today's numbers — the kernel file's length on disk, the flat cube's 12 triangles and 684 bytes, the cone's 286/516/2,142 across the presets, and the 18-part assembly's 4,900 → 7,372 → 21,116 triangle counts with their 245,084 / 368,684 / 1,055,884 byte outputs, all measured by the project's own test files on every run.

npm test

The command above re-runs every number on this page. The mesh-era page keeps the format-board history of what free tools could not read; the upload-safety page covers the promises today's upload converters make and how to check them; the no-CAD page covers what running the kernel in the tab costs; the verification page owns the format rejection list and the six output checks; and the converter is where a STEP file meets the kernel that used to need a server.