
Search GitHub for 3d product configurator open source code and something runnable turns up before lunch. Clone a repo, run two commands, and a model spins in the browser with a panel of options down one side. It feels like the hard part is finished. For a demo of a game controller in three colourways, it is.
The repos tend to be honest about themselves, which is worth noticing. A WebGL configurator template that has been cited in more blog posts than most commercial products opens with a line saying realism is not the aim of the project. An open CPQ index maintained on GitHub tags a good share of its entries as UI libraries rather than platforms, and writes the shortfall into the table: configuration only, no pricing engine. Nobody is hiding anything. What gets handed over is real code, and the distance between that code and a working sales tool is where projects get stuck.
The gap is geometry, not JavaScript
That distance starts with geometry, not with JavaScript. Every repo expects a mesh, usually glTF or STL, and the mesh has to come from somewhere. In a manufacturer's case it comes from CAD that was never built for a browser: assemblies with a thousand parts, hardware modelled down to the thread, fillets nobody will ever see at product-page scale. Somebody has to decimate it, bake the materials, separate the parts that need to move independently, and produce a variant for every state the configurator will show. Open source gives you a loader. It does not give you the asset pipeline, and the asset pipeline is usually the largest single line in the budget. We have written separately about what model work actually costs once a product line goes beyond a handful of SKUs.
Options are easy, constraints are not
The options layer is next, and this is where the word "configurator" starts doing two jobs. A repo ships a structure for options, whether that is an array in code or a JSON file somebody edits by hand. Your product has constraints instead. This finish is unavailable on that size. This motor cannot be paired with that voltage. Upgrading the frame forces a different mounting plate and changes the price by a step rather than a multiple. The first version of those rules is easy to write. The version after eighteen months of product changes, sales exceptions, and one region-specific requirement is the one that decides whether the tool survives, and every open source build inherits that work with nobody assigned to it.
The harder question is who edits the rules in month seven. Not who wrote them. Who edits them, on a Tuesday, when someone in product management wants to withdraw an option for a week. In an open source setup that person either learns the codebase or files a ticket and waits. Most teams discover this only after the developer who built the thing has moved to another project, which is a normal thing for developers to do and a fatal thing for a tool that depends on one of them.

A template has never met a real catalogue
Performance is the point where a template stops resembling production. Demo scenes hold twenty meshes and one light. A real catalogue page holds four hundred meshes, a few compressed textures at 2K, and whatever the page builder adds on top. Browsers forgive a lot on a developer laptop and very little on a mid-range Android phone over hotel wifi. The fixes exist, from instancing to deferred loading, and none of them are in the template, because a template has no reason to include them.
Integration is the quiet one. A 3d product configurator open source build that cannot talk to the ERP is a brochure with better lighting. Getting an order out of an open source build and into a pricing or production system means writing the mapping yourself, and the mapping is where the details live: unit conventions, rounding, tax treatment, the field your ERP insists on calling something else. Plenty of these builds stop at a JSON blob in a database, and a JSON blob is not an order.
What happens after launch
The part nobody puts in a README is what happens after launch. A configurator is not finished when it goes live. Prices move. A promotion runs for two weeks and has to be reversible. A distributor needs a version with their own margin built in. Two new models arrive in spring and one is discontinued without warning. Somebody has to own that schedule, and in an open source deployment that somebody is whoever your team can spare. We have run through the checks worth doing on a live build for teams already in that position.
Where open source genuinely wins
Where open source genuinely wins is narrower than its reputation suggests, and worth being clear about. A catalogue with a dozen products, options that do not interact, no pricing logic, and an audience of internal sales staff is served well by a template. So is a proof of concept built to settle an argument in a meeting. So is a team with two capable front-end developers who want to own the code long term and have the roadmap to justify it. None of those are insults. They are the situations the code was written for.
The cost that never appears on a project plan is decision time. Someone senior has to sit in a room and decide what the rules actually are, and that work exists whichever route you take. Open source does not remove it. It removes the invoice, so the work hides inside salaries and reappears later as a launch that keeps slipping by a fortnight at a time.
There is a licensing argument that usually gets skipped too. Open source is chosen for independence, and the independence is real until the code needs a change nobody on staff can make. At that point independence is gone either way. The only question left is whether the person you now depend on answers email on a Friday.
What the licence fee does not cover
Where it stops is the first time a rule has to be agreed with someone in operations, or the first time a configured order has to land in an ERP without a person retyping it. At that point you are no longer shopping for a renderer. The question changes into who is accountable when the pricing is wrong the week before a trade show, and that question has nothing to do with which repo you started from.
This is also why open source estimates and commercial quotes are so hard to compare. An open source project looks cheap on day one and keeps charging in small instalments: a week here to rebuild an asset, three days there to chase a bug inside a dependency, and an unplanned hire the month the original developer leaves. A quote that looks triple the price often includes the parts nobody priced into the free option. We wrote about reading two proposals side by side for exactly this reason.
The test worth running
If you are weighing a build your own product configurator route, the useful test is not technical. Ask which five things will change about your product range in the next year, and who will change the tool when they do. If the answer is a named person with time on their schedule, open source is a reasonable starting point. A shrug is the other answer, and it means the licence fee was never the expensive part.
The honest summary is that 3d product configurator open source code solves the rendering problem, and rendering was rarely the reason these projects failed. What fails is maintenance, mostly. The asset pipeline and the handoff to whoever makes the thing account for the rest. Judge a route by how it handles those three, not by how quickly a model spins on the first afternoon. If you have a repo open in another tab and a product line that does not fit it, send both over and we will tell you where the seam is.
FAQ
Q: Is there a complete open source product configurator we can deploy as-is?
No, and the projects themselves tend to say so. The more complete ones are complete inside their own platform, whether that is Odoo or WooCommerce. Deploy them as-is and you get that platform's idea of a product, with your catalogue bent to fit it. The gap shows up at the first rule your business actually needs.
Q: Can we start with an open source configurator and hire specialists later?
That works when the starting point is a prototype rather than a live sales channel. Once real customers and real orders run through it, replacing the foundation means migrating rules, assets, and any integrations built on top, and that migration usually costs more than building correctly the first time.
Q: What does an open source configurator really cost over three years?
Licence cost is zero and total cost is not. The recurring items are asset production, rule maintenance, dependency upgrades, hosting, and the replacement cost when the original developer leaves. Teams that track it usually find the three-year figure closer to a mid-range commercial build than to the "free" they budgeted for.
Q: Does open source at least guarantee we own the code?
You own your copy of it, which is a real advantage for data control and long-term independence. Ownership is not the same as capacity, though. Code you cannot maintain is a liability with a nice licence attached.
English
繁體中文

