CadQuery –- A Python parametric CAD scripting framework based on OCCT

I tried this a couple of months ago, I found what it's trying to do very pleasant to use but the tooling around it is very annoying. The up-to-date version 2 isn't on pypi, conda is thoroughly unpleasant to have as an environment. There seems to be a drive to using it inside it's own editor https://github.com/CadQuery/CQ-editor while nice seems like wasted engineering effort in developing an editor when the language needs so much work. I didn't have much success structuring cad into modules as they wouldn't import well.

The point IMO of parametric cad in an existing language is to use the ecosystem. Lots of choices in this project make that really hard.

I made this keyboard case with CadQuery. In the long run I'm working towards generating cases (and PCBs) for keyboards with many parameters available for configuration (e.g. number of columns, number of rows, number and position of thumb keys, case style, rotary encoders, etc).

https://imgur.com/a/VfOyAjP

https://github.com/possibilities/unkeyboard

Note I chose a somewhat non-idiomatic approach (in terms of cadquery) writing this and I'm new to python.

Slight aside, does anyone know of a more modern open source parametric CAD kernel than OpenCascade (which this is built on)?

When I have looked into it before it seems to be criticised for being somewhat dated and not have the power and developer ease as Parasolid (which costs big bucks). Having both a software and mechanical engineering background (I spent a lot of time in SolidWorks) I regularly get the itch to try and combine the two and create a CAD tool.

I started parametric geometry or CAD with AutoLISP, but you were tied to AutoCAD. Then I found Blender in the late 90's and early 2000's, and used Python to do some cool stuff. FreeCAD was my next attempt at using the engine without the GUI, but most of my daytime work in engineering is on Autodesk Fusion or Inventor, or in Rhino. Then I found Rosetta[1], a cool attempt at creating a geometry grammar and a backend for popular CAD programs like AutoCAD or Rhino. You code in Rosetta, a Racket DSL/library, and it renders in the CAD backend. I actually used it to generate a spherical truss dome that I could analyze structurally, change parameters, and reload in the analysis. I was almost at the point of doing my own version of generative design assist that Autodesk now has working. I started to think about writing a backend for FreeCAD, because I prefer Lisps over python for creative coding. I'll have to check CadQuery out now that it has moved from FreeCAD to OCCT. I still like writing AutoLISP for fun. Still not a fan of python for no good reason other than the biased reason that Lisp makes me happy, and python doesn't. CadQuery's Jupyter interface seems like a good sandbox to experiment with if the speed is good for iterative or historical design.

[1] http://web.ist.utl.pt/antonio.menezes.leitao/Rosetta/index.h...

One thing that kept me using OpenSCAD was the section of additional modules for it, including a decent involute gear creator. For those of you diving into CadQuery, here’s the equivalent: https://github.com/meadiode/cq_gears

This is absolutely an impressive toolset, because it provides a bridge between the CSG => STL world (OpenSCAD, boolean operations, cutting shapes out of other shapes) and the STEP world of GUI CAD (faces, fillets, chamfers).

I struggle with GUI CAD and I'm still learning all of this stuff at the most noddy level, but I am very conscious that I will want to send stuff out to be manufactured one day, and that means I have to be able to get beyond STL to STEP. So I am going to be spending more time with CADQuery and trying to use what it helps me visualise in FreeCAD as well.

There is now a FreeCad workbench for CadQuery 2.0 which I have not yet tried:

https://github.com/jpmlt/freecad-cadquery2-workbench

When I read parametric CAD I was hoping to see a tool that can automatically assemble full floor plans from just XYZ dimensions. Wiring, plumbing, structure, lighting, insulation, etc. Everything maybe except paint color. It's just another constraint solver, not sure why that doesn't exist yet and why we need to cough up billions in engineering and architecture costs every year.

With a tool that can provide normalized, structured data corresponding to buildings, then for sure we could save on manufacturing too, every wall panel +- the same you could mass produce them. With a clever concept with datacenter-like floating floor you could even change and adapt the rooms (including plumbing) to suit needs without having to rebuild.

For anyone interested in this, I would also recommend checking out the [antimony project](https://github.com/mkeeter/antimony). It's a parametric modeling program, but you can also pretty easily produce new scripts for its visual nodes.

Also: Discussion from 2020 September (134 points / 46 comments): https://news.ycombinator.com/item?id=24520014

Cut and paste of a recent comment I made in a similar thread:

I've started to switch to Cadquery from OpenSCAD because OpenSCAD lacks proper fillets and chamfers.

I usually prefer the CSG (arithmetic tree of union/difference/intersection + transforms + base shape leaves) to model 3D objects, as opposed to Cadquery's "draw on 2D surfaces and extrude" approach, but OpenSCAD's lack of fillets / chamfers combined with the "everything is a polygonal mesh" approach of the rendering engine is just too limiting.

Cadquery has a lot of potential (the underlying engine uses a traditional hierarchical NURBS BREP, IIUC), but it also has a lot of shortcomings:

Here are some I've bumped into:

     . very strange "stack-based" model. For complex objects, it's hard to wrap your head around it, and the workflow it forces on you as a user does not always fit your mental model of the object.

     . the underlying hierarchical nature of the object (the BREP) is forcibly hidden from the user, which leads to kafka-esque situations when one wants to e.g. select parts of an object.

     . selecting parts (faces and edges) in a object is a nightmare. cadquery has "selectors", which are a) its own weird little DSL b) very difficult to use on complex shapes c) does not support name-based retrieval: can't label things and get to them later by name.

See this github issue for example: https://github.com/dcowden/cadquery/issues/29

     - the UI (cq-editor) is unusable for real-world work: no perspective rendering, no graduations in ortho views, no way to measure things on the object, no way to examine the BREP, etc ... Generally speaking, the UI is only a visualizer, and does not let you query / inspect the model in any detailed way.

     - fine-grain control over tessellation (conversion to mesh) is lacking.

     - good for modeling mechanical parts / lousy for modeling anything organic-looking

     - importing external models that don't fit the cadquery BREP-based represention is basically impossible.

TL;DR: a nice tool to add to your belt, but not a very mature environment yet, and certainly can't replace OpenSCAD yet.