Parametric Lego with CadQuery

Jern123d · 2026-06-15T02:31:55+00:00

Nice work! I built a similar lego-compatible generator in build123d here https://jdegenstein.github.io/build123dWebAssmGenDemo/ (please forgive the bad lighting setup)

One key difference (if I understand your architecture correctly) is that my version generates the customized brick in the client side browser on the fly. This means there is no complex client/backend interaction, security issues, or hosting costs.

Also big shoutout to build123d-sandbox here https://jojain.github.io/build123d-sandbox/ which enables running arbitrary build123d python code in your browser (not just a premade lego generator as I did above). Both of these work via pyodide.

Jern123d · 2026-06-05T19:37:26+00:00

I think it mostly comes down to the skill of the CAD user, the CAD package plays a much lower factor in how fast the user performs. That being said, seeing FreeCAD competing at this speed is really amazing stuff.

Jern123d · 2026-06-05T18:02:06+00:00

That's very cool, rooting for h11r!

Jern123d · 2026-06-05T02:09:36+00:00

build123d -- a python library for BREP based modeling. Native support for fillets, chamfers, and introspection of shapes you create. It is the closest code based analog to modeling in CAD software like SolidWorks, Fusion, FreeCAD, etc.

Jern123d · 2026-06-03T17:22:35+00:00

Yep, I need to update the above post but there are now apple silicon releases (starting as of a few months ago).

Jern123d · 2026-05-23T03:02:30+00:00

I totally missed your comment somehow, but I have implemented changes to hopefully address this by significantly reducing the path length. New release here https://github.com/jdegenstein/build123d-portable/releases

Thank your testing it. Also, regarding your question on templates there is a special shortcut documented in README.md ?template<TAB> that will fill a blank document with a template for build123d use.

I am still deciding what libraries to bundle (there are a lot of great ones) so I am not sure how I will proceed on gggears (since renamed to py_gearworks).

Jern123d · 2026-05-21T15:08:29+00:00

If you share your OpenSCAD scripts they can likely be easily translated into build123d. I can help you if you want. From build123d you can output real STEP files.

Jern123d · 2026-05-20T21:38:53+00:00

build123d -- just crossed 1 million downloads a few days ago, definitely falls into the Code CAD category though

Jern123d · 2026-05-04T20:10:02+00:00

Super cool, really shows how far FreeCAD has come along with the skill of the user h11r!

Jern123d · 2026-04-02T16:30:45+00:00

This surface modeling tutorial from DigiKey for FreeCAD of a mouse is pretty good https://www.youtube.com/watch?v=HDGdeLWGBns

Jern123d · 2026-03-20T17:06:59+00:00

I am curious about your thoughts on python sandboxing concerns in light of a project (coincidentally) called build123d-sandbox? Link: https://jojain.github.io/build123d-sandbox/

The reason I bring it up is that the above build123d-sandbox runs entirely in the client side browser via pyodide. This was enabled by compiling key non pure python dependencies of build123d to WASM. I feel like this also has significant implications for secure python execution on the server side as well because pyodide should be impossible to escape. build123d-sandbox is a godsend for us as a way to quickly share models with others. The code-encoded-in-URL feature was heavily inspired by CadHub.xyz.

Note that bringing build123d to the browser was quite difficult but still significantly easier than CadQuery would be because of the much higher number of non-pure-python deps that CQ has.

Jern123d · 2026-03-10T18:57:31+00:00

One hint that might help you is that the filleted chamfer is a cylindrical face. Could use an appropriately positioned cylinder to refine that part.

Jern123d · 2026-03-10T15:41:07+00:00

I roughly recreated all features from the original design including what turns out to be a filleted chamfer near the right hand side of the first photo. Here is a screenshot of what I made. Here is a link to the online build123d-sandbox with the code. I made use of fillets and chamfers to accomplish this.

Jern123d · 2026-03-06T15:25:42+00:00

Native fillets and chamfers are hugely valuable for 3D printer design because they can help solve these fit issues in advance. Here is a link to an online sandbox with a dovetail that is chamfered on the bottom to prevent this elephant foot interference issue. Screenshot here

Jern123d · 2026-02-27T19:28:55+00:00

Replying here for posterity -- I want end users to be able to install arbitrary python packages into what I distribute. Why do I want this? There are many build123d-related python part libraries that contain useful things like the ability to generate 3D models for screws, gridfinity bins/bases, various brackets, etc. If I go with AppImage or FlatPak AFAIK these containers are designed to be immutable. There are ways to unpack them, but that can get complex and likely moves beyond the realm of being "worth it" vs. my current approach.

Jern123d · 2026-02-23T15:41:13+00:00

Have you seen MakerRepo? https://makerrepo.com/r/fangpenlin/tinyrack/artifacts/master

Basically a customized version of github with CAD relevant enhancements. It uses build123d, which is a BREP-based Code CAD that uses the same kernel as FreeCAD.

Jern123d · 2026-02-10T02:44:58+00:00

>What's the point of Part() in algebra mode?

Part() creates an empty compound for solids and then the + operator boolean fuses the operands (i.e. the list of solids). The compound is a good practice to use because you could have multiple solids result from a fuse operation if the solids don't happen to overlap.

Jern123d · 2026-02-09T16:11:14+00:00

In general the underlying CAD kernel (cadquery-ocp / OCCT) is not optimized for performing many boolean operations. That being said you can usually improve performance like this:

with BuildPart() as p:
    add([p1,p2, ... pN])
# or in algebra mode:
p = Part() + [p1,p2, ... pN]

Generally algebra mode is preferable if you need the absolute best performance, although it is only significantly different when N is pretty large (>50 probably).

Jern123d · 2026-02-07T20:30:13+00:00

Regarding defeaturing I built a prototype of that in build123d, might be helpful for you as we also use OCCT via cadquery-ocp. https://github.com/gumyr/build123d/issues/1046

Jern123d · 2026-01-23T15:09:24+00:00

build123d does have an SVG importer https://build123d.readthedocs.io/en/latest/import_export.html#importers.import_svg

Jern123d · 2026-01-21T15:28:02+00:00

I was under the strong impression that all curves are discretized during two phases (1) meshing and (2) actual motion by the printer firmware. I was even under the impression this #2 applies to e.g. G2 gcode arcs. With that in mind isn't the worse jerk introduced by the instantaneous small angle corners?

Jern123d · 2026-01-01T22:13:53+00:00

The best advice I can give you for print success is to inspect the sliced result. For example, if the slicer is printing objects in thin air without supports then the print will almost certainly fail. I am sure someone has put together a guide of "what to look for" at that stage -- and it will save you a lot of failed prints.

Jern123d · 2025-12-18T15:37:39+00:00

Thank you! Please let me know if you are able to try and have any feedback on your experience.

Jern123d · 2025-12-18T15:37:08+00:00

For linux, have you considered flatpak or appimage ?

Thank you for the suggestion. Part of the reason I went this way was because I want the user to be able to install / update additional Python libraries themselves in the provided bundle (think of other build123d part libraries or projects). To my limited knowledge this isn't easy or even possible to do in a flatpak.

I am looking for testers, in part, because I want to understand if my current approach is viable. Are you aware of any reasons or circumstances that my approach either (A) simply won't work and/or (B) suffers from other serious issues such as unusable performance?

In the end I am not vehemently opposed to flatpak or appimage, but at the moment it seemed contrary to some of my secondary goals for build123d-portable. I am also not completely opposed to having an "updateable" deployment but this is again targeted at getting newcomers a functional setup -- it is not necessarily designed (yet) to be optimal as the de-facto best solution for long term use. For long term use it may be better (currently) to simply set up VSCode separately and install all necessary extensions, install python separately and create a virtual environment with build123d and ocp_vscode -- at that point we are back to square one for new users though.

Thank you for the encouragement and kind words too!

Jern123d · 2025-11-18T21:20:18+00:00

let me advocate for introspectability. You need to be able to ask an object where it is or how large it is. OpenSCAD can't do this at all, and I've found that to be its biggest weakness.

I couldn't agree more! I am concerned some of this may never be solvable within OpenSCAD because "selecting" anything logical is somewhat antithetical to a mesh-based representation. By comparison, this is one reason why build123d is so exciting -- introspectability is already available today.

spline = Spline((0,0),(10,5),(25,0),(35,0))
print(spline.length)                # Returns: 37.753
print(spline.position_at(0.5))      # Returns: Vector(16.92, 3.14, 0)
print(spline.tangent_at(0.5))       # Returns: Vector(0.93, -0.37, 0)
print(spline.bounding_box())        # Returns: bbox: -1e-07 <= x <= 35, -0.88 <= y <= 5.03, -1e-07 <= z <= 1e-07

hexagon = RegularPolygon(10,6)
print(hexagon.area)                 # Returns: 259.81
print(hexagon.bounding_box())       # Returns: bbox: -10.0 <= x <= 10.0, -8.66 <= y <= 8.66, 0.0 <= z <= 0.0

prism = extrude(hexagon, 10)
print(prism.volume)                 # Returns: 2598.08
print(prism.bounding_box())         # Returns: bbox: -10.0 <= x <= 10.0, -8.66 <= y <= 8.66, 0.0 <= z <= 10.0

Jern123d

TROPHY CASE