manifold

LuaCAD models solids in Lua rather than the OpenSCAD language, with operator overloading for CSG (`a + b`, `a - b`, `a * b`). It ships with a CLI and a desktop app, including a preview area and a text editor. I've always been a big fan of OpenSCAD, but the SCAD language itself is unfortunately quite cobbled-together and is a very poorly designed programming language. LuaCAD takes all the good parts of OpenSCAD and combines them with one of the best scripting languages. It has now completely replaced OpenSCAD for me, and I think it provides a better experience than OpenSCAD for all use cases. I'd love to hear any reasons why LuaCAD shouldn't fully replace OpenSCAD! It’s fully open source and you can find the repo here: https://github.com/ad-si/LuaCAD Tech stack: - It's implemented in Rust and uses mlua (https://github.com/mlua-rs/mlua) to

The difference is that my Manifold library uses a different definition of what constitutes a manifold mesh: https://github.com/elalish/manifold/wiki/Manifold-Library#ma.... By being a purely topological definition, there is no implicit assumption that vertices with the same coordinates are connected. As such we can still generate a 2-manifold even in the "impossible" cases. The more important difference though, is that our library can still handle epsilon-valid self-intersecting meshes, rather than just reporting an error. This is critical in practice because meshes are stored, transported, and transformed in floating-point, so even the formally-proven non-self-intersecting results of the library under discussion will not necessarily be valid input for it anymore after a round-trip through a file format or a rotation. Still, these are det

How does it compare against https://github.com/elalish/manifold in performance and zero corruption? I spent a lot of time making elalish/manifold work in Godot Engine and it is now a method in Blender too. https://manifoldcad.org If it helps, feel free to use the apache2 licensed unit tests that were generated in manifold development https://github.com/elalish/manifold/tree/master/test

Text to CAD doesn't need papers. You can literally just try it and see that it works well with the frontier models. If you want reification/meshing I recommend [1] which is what Godot uses. You can throw the results in a physics engine in an afternoon and see for yourself. This wasn't obvious a year ago, but today CAD literally reduces to Simon Wilson's pelican test, since CAD is largely a matter of functional CSG, and CSG is really not that different from SVG. It's just one more dimension, which it turns out is not a problem. LLMs consistently one-shot CSG based video game levels with interesting physics puzzles (citing myself). Given this I'm willing to conclude that the frontier models are good at automated CAD if given the correct harness. But I guess a lot of people don't know this yet. [1] https://github.com/elalish/manifold

Thank you! The CAD kernel is written by me apart from the boolean solver for the meshes which is the superb https://github.com/elalish/manifold To explain a bit more as "do your own kernel" is usually considered more mad than mad-science - this is not done on a whim. I spent over a decade doing CAD at Trimble, developing base tech and CAD offerings (including Tekla Structures and SketchUp). Happy to discuss the architecture more. OpenCASCADE is included as part of STEP importer though. Solvespace is a nice reference! One can already use it as prestep to modeling - just export the output as STL or SVG and import it :).

As part of my donated work in Godot Engine, my approach is to improve manifold https://github.com/elalish/manifold to get a "geometric kernel" I think I've succeeded and many CAD tools use manifold for geometric kernels on 3d boundary meshes. I was able to get Godot Engine and Blender to adopt elalish/manifold. List of CAD tools that adopted elalish/manifold. OpenSCAD Blender IFCjs Nomad Sculpt Grid.Space badcad Godot Engine OCADml Flitter BRL-CAD PolygonJS Spherene Babylon.js trimesh Gypsum Valence 3D bitbybit.dev PythonOpenSCAD Conversation AnchorSCAD Dactyl Web Configurator Arcol Bento3D SKÅPA Cadova BREP.io Otterplans Bracket Engineer

Based on a geometry engine written in C++ ... https://github.com/elalish/manifold

It's using a constructive solid geometry system. You can add and subtract volumes. Making a hole is subtracting a volume. This has classically been numeric roundoff hell, where points that should coincide and surfaces which should touch don't get handled properly due to numerical error. The geometry engine is Manifold, which guarantees watertight meshes from boolean operations. Ah. That's what's doing the constructive solid geometry. Here's the 2009 PhD thesis behind the object merge and difference algorithms inside Manifold. Nice. At last, soundness. This is a long-standing problem. And now there's an open source implementation. Manifold itself is in C++, not Rust, though. None of this is parametric. That's a different problem. That's where you put in constraints such as A is perpendicular to B, B is 100mm from C, etc., and the constrai

Unfortunately, using a geometry kernel [1] that operates on triangle meshes means this is a no-go for serious CAD usage. [1]: https://github.com/elalish/manifold

Manifold is impressive, lots of info here: https://github.com/elalish/manifold

Also you can use the new backend by writing C++: https://github.com/elalish/manifold Which avoids using the OpenSCAD language, but also means you can't use BOSL2. Might as well use FreeCAD.

It's switched to a new backend https://github.com/elalish/manifold Which you can also use directly instead by writing C++. Trivial operations are two orders of magnitude faster and complex ones every faster.

I am curious how the last algorithm is an order of magnitude faster than the one based on sorting. There is no benchmark data, and ideally there should be data for different mesh sizes, as that affects the timing a lot (cache vs RAM). I work on https://github.com/elalish/manifold which works with triangular meshes, and one of the slowest operations we currently have is halfedge pairing, I am interested in making it faster. We are already using parallel merge sort for the stable sort, switching to parallel radix sort which works well on random distribution is not helping and I think we are currently bandwidth bound. If building an edge list for each vertex can improve cache locality and reduce bandwidth, that will be very interesting.