Most CAD files record a finished shape. This one records the intent that produced it.
Embedded with the team deciding what a new representation of the physical world is allowed to say.
What CAD forgets
Every mainstream CAD format records the answer: surfaces, triangles, a finished boundary. Everything about why the shape is that shape sits outside the file. The load it carries, the material it is made from, the tolerance it has to hold, the objective someone was optimising for. That knowledge lives in a spreadsheet, a slide, or an engineer’s head.
So every downstream tool reverse-engineers intent from geometry, and every design change starts the guessing over. Analysis is a separate step from design: you draw, export, simulate, read a number, come back and adjust. The loop never actually closes.
Differentiable all the way down
The company’s format carries the parameters, materials, objectives, and physical constraints that produced a design, with the geometry itself written as fields in a differentiable numerical framework rather than as a boundary.
That one decision changes what a design tool can do. Because the shape is differentiable, a physics objective can be differentiated with respect to the shape itself, and the whole design loop becomes a single gradient graph. An optimizer stops searching a catalogue of variants and starts moving the design. Drawing something and solving for it become the same operation.
A design also stops being one artifact. It becomes a program that emits a family of them, with the constraints travelling alongside. Meshes exist only at export, for the machine that has to cut or print the thing.
What we were trusted with
We were brought in to help take the platform from research code to something outside engineers could build on. We did not stay in an advisory chair, and the remit did not stay there either.
We work inside their team, alongside their engineers, and the calls we are in the room for are the structural ones: the schema and versioning contract for the core interchange format, the architecture of the platform itself and where each part of it runs, the engineering standards every repository is held to, and where the representation should go next.
A format is a platform, or it is just a file
A representation nobody outside the building can read is a research artifact. Turning one into something a stranger can depend on is its own body of work, and most of it is invisible from the outside.
It means a written contract for how the format changes and a conformance corpus that proves an implementation honours it. Release discipline and gates across every repository, so what ships is what was tested. Pipelines and infrastructure that carry design data at real volume rather than at demo scale. Documentation and licensing that let someone contribute without asking permission first. None of it is glamorous, and without it the ideas above stay in the lab.
Where the work runs is a commercial question
A company planning to open its core has to answer an awkward one: if the format and the tools are free, what does anyone pay for? That is an architecture question before it is a pricing question, and the answer is a boundary. The reasoning loop runs on hosted infrastructure, because usage limits and billing are only enforceable somewhere a customer cannot edit them. Put that boundary in the wrong place and an open core is either unsellable or not really open.
Everything else stays where it belongs. An engineer’s design code is not a folder you can sync, it is a pinned execution environment that has to run where it lives. So the engineer’s machine opens a single outbound connection to the platform rather than the platform reaching into the machine: no ports opened, no firewall exemptions, nothing for an enterprise security review to refuse. Rendering stays on the hardware already sitting on the desk, because it is free, instant and there.
Unit economics is an input to that design, not a finance exercise done afterwards. What gets re-read on every turn, what gets cached, what never leaves the laptop: those decide whether a seat is profitable. Design the loop without that in view and you get a system that works and cannot be sold.
The calls we made
A file format is a promise you cannot make retroactively. Once other people’s files exist, every compatibility decision becomes a negotiation with your own past. The versioning contract and the conformance corpus came before external adoption, so the promise was made first and the users came second.
If tolerance, material behaviour, and design objectives live in whichever tool happens to be open, every consumer reimplements them and they quietly drift apart. Put them in the format and every tool downstream inherits the same physics. That is a schema decision with engineering consequences, which is exactly the kind that gets made badly when nobody in the room has designed a real part.
A file that carries an executable command is a macro in a document, and everyone learned how that ends. It should carry a reference instead: which model produced it, at which version, with which settings, and a fingerprint to check. One change, three results. No executable payload. Files that move between machines. And the provenance record the format did not have, which turns out to be what every later question about trust and authorisation hangs off.
The plan assumed a hosted accelerator fleet, and behind it sandboxing, tenant isolation, and a standing decision to refuse co-tenancy. Nothing in the codebase justified any of it. The solves that exist finish on a laptop, and the one measured resource problem was memory rather than compute. So long jobs run as ordinary CPU batch until a measurement says otherwise, and an entire workstream disappeared with the assumption. The most valuable architecture decisions are usually the ones that remove something.
What the format can express is the ceiling on every product ever built on top of it. So the roadmap question is not which features to ship this quarter. It is what the model should be able to say. Get that narrow and no amount of product work recovers it.
Where it is going
Into the representation itself. Parts move, so the model has to describe kinematics. Physics does not arrive one field at a time, so it has to describe coupled behaviour. And nothing gets manufactured to its nominal dimension, so it has to describe tolerance as a first-class property rather than a note on a drawing. Each of those is a decision about what this new way of describing the physical world is allowed to describe.
A file that stores a shape becomes a file that stores the argument for the shape.
A file format is a set of claims about what the physical world is allowed to be. Deciding those claims needs someone who has designed real parts under real tolerances, not only someone who has written parsers.