I've been tapering off maintenance since 2016 or so, but it has a more actively-maintained fork over at https://github.com/nsfm/stibium (albeit with heavy LLM assistance, because it's 2026!)
YMMV – I haven't used it or closely inspected the changes, but have corresponded with the author, who seems genuinely dedicated in the success of the project.
libfive [1] was the follow-up kernel, written in C++, with a big emphasis on fast evaluation and robust meshing. It's also in maintenance mode, but was shipped in a handful of commercial CAD tools.
In 2020, I wrote a SIGGRAPH paper [2] about doing implicit surface rendering on the GPU. This was a fun and exciting experience! This used libfive for the frontend, then did all of the compute-heavy rendering work on the GPU.
I then got tired of dealing with C++ and rewrote everything in Rust, which is what I've been using ever since: Fidget [3] is the new kernel and Halfspace [4] is the new IDE. This is what I'm actively working on – the Halfspace blog post just went up a few weeks ago, and I've been implementing / improving a GPU rendering backend in Fidget (with a backlog of several more blog posts).
In between, I nerd-sniped a bunch of people into writing their own f-rep evaluation engines [5] and gave a talk about the whole "independent research" thing [6].
[2] https://www.mattkeeter.com/projects/siggraph/
[3] https://www.mattkeeter.com/projects/fidget/
[4] https://www.mattkeeter.com/projects/halfspace/
I'm certainly not an expert in these fields, but what's your angle on techniques like raymarching?
Raymarching is great, and I love the work being done by the demoscene / Inigo Quilez / etc! I don't talk about it as much because my libraries usually have slightly different goals.
Most common raymarching strategies put limitations on your function, e.g. you need Lipschitz continuity to guarantee that you don't hit the model when doing ray steps. This property are pretty easy to break by accident (e.g. just scaling the model requires a correction factor), so you have to be careful with how you bend and twist the underlying math expression. If you're doing a single demo (or have a known library of good shapes), you can get away with it, but there's less flexibility.
The goal of my infrastructure is to support basically any math expression, no matter how poorly-behaved (although I really would appreciate C0 continuity), so I like the guarantees [1] of interval arithmetic.
That being said, the boundary is fuzzy. On one side, you can do raytracing with interval math [2], instead of point samples. From the other side, my more recent GPU rendering uses Z-sorting of spatial regions, so still using 3D intervals but walking them from the camera backwards (no blog post yet, sorry).
[1] Fidget doesn't actually change FPU rounding modes, so it's not absolutely guaranteed, but ehhhhhhh
I will note the following projects which have made recent advancements:
- OpenSCAD --- the hopefully final Release Candidate for the long-awaited update is now available: https://openscad.org/downloads.html#rc
- PythonSCAD --- for folks who want variables which change and so forth: https://www.pythonscad.org/
- CADquery --- https://cadquery.github.io/
- Build123D --- https://github.com/gumyr/build123d
Longer list/discussion at: https://github.com/Irev-Dev/curated-code-cad
Also, a more recent project by Matt Keeter, Halfspace was announced recently but didn't get much discussion here:
I don't want to create files using some application that's just vibe-coded and won't be supported for very long. I'm sure that's not the case for some of these, but the prospect of finding the best software and verifying that it's here to stay seems like more work than just sticking with Fusion and OnShape.
Maybe I'm wrong about this, but I see multiple posts about some new drafting or design tool every day, and the cost of integrating them into any existing workflow seems high.
So, integration isn't really the difficult part if everybody generates files in the same format.
Until now.
I've spent the last 7 months working on my Aetheris geometry kernel because I wanted to have a CAD software that uses STEP, specifically, AP242, as its native format instead of just an exchange format. Very happy to say that I've succeeded, as you can add dimensions and GD&T to STEP 203/214 files and convert them to 242 directly.
Directly editing an existing STEP file is still limited to moving through holes around though, but there is no reason why more advanced editing couldn't be done.
there is (was?) also libfive (and its "studio") from Keeter in-between: https://news.ycombinator.com/item?id=26930822
That's an ironic take in that the most prolific CAD software in use, AutoCAD, has supported a a lisp dialect, named AutoLISP[0], natively as an alternative runtime for more than four decades. It is so prolific in the CAD industry, that other vendors have even adopted compatibility with the language.
It is heartening to see CAD referenced in relation to drafting tables. I spend much of my time trying to educate new CAD users about the different solutions offered between the 'drafting table' metaphor and the 'world model' metaphor present in most CAD applications.
Discussion of FreeCAD adding it here: https://forum.freecad.org/viewtopic.php?t=49989
I'm less sure about this chronology but I think the Evans & Sutherland CAD systems were some of the first examples of multiple graphics coordinate systems that were the progenitor of overlapping windows and the desktop metaphor.
I haven't really used the constructive geometry approaches to CAD, but I've been learning CAD recently through OnShape, and really appreciated how easy were all the operations I wanted to do with it. I've heard that the purely constructive geometry approaches of the OpenSCAD type can make certain operations more complicated to implement.
I make RapidCAM.app so have an appreciation for the amount of work Antimony must have been to get to that point.
If you could add support for SolveSpace's 2D sketcher, and also bevels/fillets, then this might actually be useful.
The awful thing about OpenSCAD is what one can model in it is directly limited to ones fluency and facility with using math to position, stretch, add, and subtract cubes, spheres, cylineders, and cones.
There is an entire book series on using it didactically:
- Geometry: https://www.goodreads.com/book/show/58059196-make
- Trigonometry: https://www.goodreads.com/book/show/123127774-make
- Calculus: https://www.goodreads.com/book/show/61739368-make
and there is a new book on Physics: https://www.makershed.com/products/make-physics
I hesitate a bit to call code-based CAD "a toy", but there are a lot of times where what I think I actually want is some kind of, sorry for the phrasing here, fusion of Fusion 360 and OpenSCAD. The Fusion timeline is pretty phenomenal and having the ability to do something like code steps and manual "click on all of the edges you want to put a fillet on" steps interwoven seems like it has a lot of potential for my "ultimate CAD workflow". The timeline part is kind of the magic that unlocks the whole thing:
- update a parameter or a piece of code, triggering a recompute - see that the fillet operation is now missing an edge - rewind the timeline, tweak the fillet edge set - fast-forward the timeline to let the rest of the code blocks re-execute
Things like MakerWorld let you upload parametric OpenSCAD files and that's cool and all, but for my own uses I don't care if I need to use the "insert a manual step in the timeline" feature occasionally. OpenSCAD on its own doesn't have that and the idea of trying to do "operations as code" in Fusion (there is a scripting interface) is not super appealing as-is.
Being able to use hand-created objects as function inputs seems pretty powerful too. As an example, instead of needing to manually specify all of the points to make a polygon that I'm going to do a bunch of OpenSCAD extrudes with, just referencing a sketch earlier in the timeline. My current OpenSCAD "hack" for that is to draw those in FreeCAD as DXFs and then import them, but it's not a smooth workflow at all.
At the risk of spamming this thread, check out FluidCad. It has excellent GUI based cad tools, and those same tools generate the equivalent 'code cad' for each operation. Of course you can also use 'code first' instead.
I think it's really exciting, and while it's early in development it is already very usable.
https://studio.flet.dev/run/bicQWc3Aul
do you know of a traditional CAD program which could be used to drive such designs/projects in a useful fashion? I'm currently contemplating a re-write to use a Domain Specific Language....
https://github.com/yuechen-li-dev/Aetheris
One of my goals when I built the kernel is I want to make building a pro grade CAD software as easy as wrapping a web frontend around the Aetheris libraries. It's still very much an aspirational goal though.
CAD systems were clearly meant as a software tool for the kind of workflow previously done by hand, by draftsmen, involving printed blueprints. And a Lisp was exposed for user interaction about as early as you can get. When I interacted with it myself it felt like I was dealing with a REPL exposed by a Lisp VM (ported to an IBM PC class machine in the MS-DOS era) that also happened to have a graphics renderer and screen display. And I note the OP's college student "thesis" paper alone was written over 30 years after AutoCAD shipped to my family's home.
So I am not clear if the OP is just ignorant of CAD's history, or they are making an intentionally baiting and misleading claim.