Text-to-CAD: Risks and Opportunities

This page summarizes the projects mentioned and recommended in the original post on news.ycombinator.com

Our great sponsors
  • InfluxDB - Power Real-Time Data Analytics at Scale
  • WorkOS - The modern identity platform for B2B SaaS
  • SaaSHub - Software Alternatives and Reviews
  • fornjot

    Early-stage b-rep CAD kernel, written in the Rust programming language.

    I agree 100%.

    Truck[1] and Fornjot[2] are recent attempts in the Rust space, both are WIP.

    But both seem to be going the traditional way. I.e. B-Rep that can be converted to (trimmed) NURBS.

    I think if one wanted to incorporate the last 50 years of computer science, particularly computer graphics, one needed to broaden the feature set considerably.

    You need support for precision subdivision surface modeling with variable radius creases (either via reverse subdivision where you make sure the limit surface pass through given constraints or using an interpolating subivision scheme that but has the same perks as e.g. Catmull-Clark).

    Then you need to have SDF modeling ofc.

    Possibly point based representations. If only as inputs.

    And traditional B-Rep.

    Finally, the kernel should be able to go back and forth lossless between these representations wherever possible.

    And everything must be node-based, like e.g. Houdini. Completely non-destructive.

    [1] https://github.com/ricosjp/truck

    [2] https://github.com/hannobraun/fornjot

  • manifold

    Geometry library for topological robustness (by elalish)

    I think the interesting thing about CAD kernel is that there are different representations and limitations to each representation. You have triangular (or polygonal) mesh, BREP which uses NURBS, SDF which is based on functional representation. I have experience working with triangular meshes and SDF so here are my opinions about them, please correct me if I am wrong:

    Triangular mesh is conceptually simple, but requires many faces to approximate curved surfaces with high precision (you may be able to use subdivision surface in some cases but intersection/union in those cases are more challenging). Also, for more complicated models, floating point errors really add up and you either have to use an exact representation (which is really slow) or try some other approaches which can be robust w.r.t. errors (e.g. https://github.com/elalish/manifold but it is really hard to get right). Another disadvantage comparing with BREP is the lack of constraint solving, which i

  • InfluxDB

    Power Real-Time Data Analytics at Scale. Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.

  • pythonocc-core

    Python package for 3D CAD/BIM/PLM/CAM

    It seems a bizarre statement to state that OpenCASCADE isn't fully capable. Its the only OS licensed kernel that'll read a STEP file. Also "modern foundation" is a misleading statement, any CAD kernel bearing any kind of relevance seems implying a codebase that's been around for a quarter century. Like it or not OpenCASCADE is the hand that was dealt. I've worked with the technology [1] extensively and it provided the underpinnings for a startup I've founded [2]. pythonocc is the bees knees, it allows you to develop a proper CAD app. Don't take my word for it, but see also the many publications that have built on the tech [3]

    [1] https://github.com/tpaviot/pythonocc-core

  • awesome-cadquery

    A curated list of CadQuery code and resources.

    cadquery wraps OCC (OpenCascades) but used to wrap freeCAD. Here's a LEGO interlocking block brick in cadquery: https://cadquery.readthedocs.io/en/latest/examples.html#lego... . Awesome-cadquery: https://github.com/CadQuery/awesome-cadquery )

    cadquery and thus also jupyter-cadquery now have support for build123d.

    gumyr/build123d

  • build123d

    A python CAD programming library

    https://github.com/gumyr/build123d :

    > Build123d is a python-based, parametric, boundary representation (BREP) modeling framework for 2D and 3D CAD. It's built on the Open Cascade geometric kernel and allows for the creation of complex models using a simple and intuitive python syntax. Build123d can be used to create models for 3D printing, CNC machining, laser cutting, and other manufacturing processes. Models can be exported to a wide variety of popular CAD tools such as FreeCAD and SolidWorks.

    > Build123d could be considered as an evolution of CadQuery where the somewhat restrictive Fluent API (method chaining) is replaced with stateful context managers* - e.g. with blocks - thus enabling the full python toolbox: for loops, references to objects, object sorting and filtering, etc.*

    "Build123d: A Python CAD programming library" (2023) https://news.ycombinator.com/item?id=37576296

    BREP: Boundary representation: https://en.wikipedia.org/wiki/Boundary_representation

    Manim, Blender, PhysX, o3de, [FEM, CFD, [thermal, fluidic,] engineering]: https://github.com/ManimCommunity/manim/issues/3362

    NURBS: Non-Uniform Rational B-Splines: https://en.wikipedia.org/wiki/Non-uniform_rational_B-spline

    NURBS for COMPAS: https://github.com/gramaziokohler/compas_nurbs :

    > This package is inspired by the NURBS-Python package, however uses a NumPy-based backend for better performance.

    > Curve, and Surface are non-uniform non-rational B-Spline geometries (NUBS), RationalCurve, and RationalSurface are non-uniform rational B-Spline Geometries (NURBS). They all built upon the class BSpline. Coordinates have to be in 3D space (x, y, z)

    test_curve.py, test_surface.py

    https://github.com/compas-dev

    compas_rhino, compas_blender

    Blender docs > Modeling Surfaces; NURBs implementation, limits, challenges:

  • manim

    A community-maintained Python framework for creating mathematical animations. (by ManimCommunity)

    https://github.com/gumyr/build123d :

    > Build123d is a python-based, parametric, boundary representation (BREP) modeling framework for 2D and 3D CAD. It's built on the Open Cascade geometric kernel and allows for the creation of complex models using a simple and intuitive python syntax. Build123d can be used to create models for 3D printing, CNC machining, laser cutting, and other manufacturing processes. Models can be exported to a wide variety of popular CAD tools such as FreeCAD and SolidWorks.

    > Build123d could be considered as an evolution of CadQuery where the somewhat restrictive Fluent API (method chaining) is replaced with stateful context managers* - e.g. with blocks - thus enabling the full python toolbox: for loops, references to objects, object sorting and filtering, etc.*

    "Build123d: A Python CAD programming library" (2023) https://news.ycombinator.com/item?id=37576296

    BREP: Boundary representation: https://en.wikipedia.org/wiki/Boundary_representation

    Manim, Blender, PhysX, o3de, [FEM, CFD, [thermal, fluidic,] engineering]: https://github.com/ManimCommunity/manim/issues/3362

    NURBS: Non-Uniform Rational B-Splines: https://en.wikipedia.org/wiki/Non-uniform_rational_B-spline

    NURBS for COMPAS: https://github.com/gramaziokohler/compas_nurbs :

    > This package is inspired by the NURBS-Python package, however uses a NumPy-based backend for better performance.

    > Curve, and Surface are non-uniform non-rational B-Spline geometries (NUBS), RationalCurve, and RationalSurface are non-uniform rational B-Spline Geometries (NURBS). They all built upon the class BSpline. Coordinates have to be in 3D space (x, y, z)

    test_curve.py, test_surface.py

    https://github.com/compas-dev

    compas_rhino, compas_blender

    Blender docs > Modeling Surfaces; NURBs implementation, limits, challenges:

  • compas_nurbs

    NURBS for COMPAS

    https://github.com/gumyr/build123d :

    > Build123d is a python-based, parametric, boundary representation (BREP) modeling framework for 2D and 3D CAD. It's built on the Open Cascade geometric kernel and allows for the creation of complex models using a simple and intuitive python syntax. Build123d can be used to create models for 3D printing, CNC machining, laser cutting, and other manufacturing processes. Models can be exported to a wide variety of popular CAD tools such as FreeCAD and SolidWorks.

    > Build123d could be considered as an evolution of CadQuery where the somewhat restrictive Fluent API (method chaining) is replaced with stateful context managers* - e.g. with blocks - thus enabling the full python toolbox: for loops, references to objects, object sorting and filtering, etc.*

    "Build123d: A Python CAD programming library" (2023) https://news.ycombinator.com/item?id=37576296

    BREP: Boundary representation: https://en.wikipedia.org/wiki/Boundary_representation

    Manim, Blender, PhysX, o3de, [FEM, CFD, [thermal, fluidic,] engineering]: https://github.com/ManimCommunity/manim/issues/3362

    NURBS: Non-Uniform Rational B-Splines: https://en.wikipedia.org/wiki/Non-uniform_rational_B-spline

    NURBS for COMPAS: https://github.com/gramaziokohler/compas_nurbs :

    > This package is inspired by the NURBS-Python package, however uses a NumPy-based backend for better performance.

    > Curve, and Surface are non-uniform non-rational B-Spline geometries (NUBS), RationalCurve, and RationalSurface are non-uniform rational B-Spline Geometries (NURBS). They all built upon the class BSpline. Coordinates have to be in 3D space (x, y, z)

    test_curve.py, test_surface.py

    https://github.com/compas-dev

    compas_rhino, compas_blender

    Blender docs > Modeling Surfaces; NURBs implementation, limits, challenges:

  • WorkOS

    The modern identity platform for B2B SaaS. The APIs are flexible and easy-to-use, supporting authentication, user identity, and complex enterprise features like SSO and SCIM provisioning.

  • truck

    Truck is a Rust CAD Kernel.

    I agree 100%.

    Truck[1] and Fornjot[2] are recent attempts in the Rust space, both are WIP.

    But both seem to be going the traditional way. I.e. B-Rep that can be converted to (trimmed) NURBS.

    I think if one wanted to incorporate the last 50 years of computer science, particularly computer graphics, one needed to broaden the feature set considerably.

    You need support for precision subdivision surface modeling with variable radius creases (either via reverse subdivision where you make sure the limit surface pass through given constraints or using an interpolating subivision scheme that but has the same perks as e.g. Catmull-Clark).

    Then you need to have SDF modeling ofc.

    Possibly point based representations. If only as inputs.

    And traditional B-Rep.

    Finally, the kernel should be able to go back and forth lossless between these representations wherever possible.

    And everything must be node-based, like e.g. Houdini. Completely non-destructive.

    [1] https://github.com/ricosjp/truck

    [2] https://github.com/hannobraun/fornjot

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts