# ImplicitCAD reads.scad and adds rounded unions and variable twist

> ImplicitCAD is an AGPL-3.0 Haskell CAD program that parses a modified OpenSCAD language and also exposes a Haskell API, adding rounded unions, twisted extrusions and rounding on the extrusion itself. The README describes it as very much a work in progress, ready for beta testers.

**Haskell-Things/ImplicitCAD** — A math-inspired CAD program in haskell. CSG, bevels, and shells; 2D & 3D geometry; 2D gcode generation...

- Repository: https://github.com/Haskell-Things/ImplicitCAD
- Website: https://implicitcad.org/
- Stars: 1,586 · Forks: 148
- Language: JavaScript
- License: AGPL-3.0
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/haskell-things-implicitcad

## Rounded unions are the reason the language was extended

ImplicitCAD is a programmatic CAD, which means objects are described in text using variables, control structures and abstraction, so version control and reuse work the way they do in software. The geometry is built with constructive solid geometry, unions, intersections and differences of simpler shapes.

Plain CSG has a well known problem: where two solids meet you get a crease, and the crease reads as a manufacturing artefact. ImplicitCAD's answer is a radius parameter on union, so the interface between two objects becomes a fillet instead of an edge. The README's second example is the difference in three characters:

```c
//example2.escad -- A rounded union of a square and a circle.
union(r=14) {
        square([80,80]);
        translate ([80,80]) circle(30);
}
```

Compare that with the first example, which is the same two shapes with a bare `union()`. That comparison is the clearest possible statement of what this project adds to OpenSCAD, and it is the first thing to try if you are evaluating it.

Because `union(r=14)` is not valid OpenSCAD, the README recommends saving non-compatible code with a `.escad` extension, Extended OpenSCAD, keeping it distinct from `.scad` files. That convention is a practical warning: a file that renders here may not render in OpenSCAD, and the extension is the only marker you get.

## Twist can be a function, which is not something a constant keyword gives you

Extrusion is where the second extension shows. `linear_extrude` takes `height`, `center` and `twist`, and the `twist` value is not limited to a constant. The README makes this explicit: you make `twist` a function, and the convention is degrees, following OpenSCAD.

The progression runs from a straight extrusion of five rounded circles, through a constant twist of 90 degrees, to a variable twist given as a cosine of height:

```c
// example5.escad -- the variably twisted extruded product of the union of 5 circles.
linear_extrude (height = 40, center=true, twist(h) = 35*cos(h*2*pi/60)) {
        union ( r = 8) {
                circle (10);
                translate ([22,0]) circle (10);
                translate ([0,22]) circle (10);
                translate ([-22,0]) circle (10);
                translate ([0,-22]) circle (10);
        }
}
```

The README says this extension goes further, allowing twisting at non-constant rates and even reversing direction, which a linear ramp cannot do.

Rounding is available on the extrusion itself as well, with an `r` parameter, and the README notes the two compose. The seventh example combines `twist=90` and `r=5` on the same rounded union, which is the case you would reach for when a fillet meets a sweep.

## Beyond CSG: currying, map, and a real loop with output

The author describes the language additions as coming from a functional programming background, and the examples are short. Function currying:

```c
// Example9.escad -- function currying.
f = max(4);
echo(f(5));
echo(max(4,5));
```

A higher order function over a list:

```c
// Example10.escad -- map!.
echo(map(cos, [0, pi/2, pi]));
```

And a real loop with assignment, which produces actual console output rather than geometry:

```c
// Example8.escad -- variable assignment in loops.
a = 5;
for (c = [1, 2, 3]) {
        echo(c);
        a = a*c;
        echo(a);
}
```

That last example prints 1.0, 5.0, 2.0, 10.0, 3.0, 30.0, followed by `Nothing to render`. The final line is a small but telling detail: a script that computes and prints without producing geometry is not an error, it just has nothing to show you.

Together these mean the language is a real scripting environment rather than a thin layer over geometry. That is what makes parametric work practical, and it is also what makes the tool harder to hand to a non-programmer than OpenSCAD is.

## The same model is available as a Haskell API

The README states that everything in the ExtOpenSCAD examples can be done through the Haskell API, and shows the union of a square and a circle as a Haskell definition rather than a script:

```haskell
-- Example 11 - the union of a square and a circle.
import Graphics.Implicit

out = union [
    squareR 0 True (80, 80)
```

The `Examples/` directory carries this through to number 26, with paired files where a concept exists in both languages: `example11.hs` and `example13-e.escad`, `example16.hs` and `example18.escad`, and so on. `example26-Polyhedron.scad` suggests polyhedron support, and `example15.scad` and `example21.scad` are plain `.scad` files, which is the compatibility check you would run first.

The repository layout reinforces that there are two halves. `Graphics/` holds the library, `implicit-interpreter/` holds the ExtOpenSCAD front end, and `programs/` holds the executables. `Tools.md` and `docs/` cover the tooling, and `CHANGELOG.md` and `CONTRIBUTORS` are present at the root.

For someone using Haskell already, the library half is the more interesting product: a symbolic geometry layer where a shape is a function that returns a distance, with CSG implemented as arithmetic on those functions. That representation is what makes rounding and variable twist expressible at all.

## Cabal, Nix and a Makefile that hardcodes the author's disk paths

The build is described for three toolchains. The package is on Hackage as `implicit`, with badges for the Hackage version and the dependency count. `implicit.cabal` and `cabal.project` are at the root, alongside `Makefile-OldCabal`, `stack.yaml`, `default.nix`, `shell.nix` and `overlay.nix` for Nix users, and `cabal.project.local.ci` for the CI build.

The Makefile is where a warning belongs. It is written for cabal-install 1.24 or later and derives a build root from architecture, OS and GHC version. The `stl2ps` variable points at `/disk4/faikvm.com/stltools/stltools/stl2ps.py`, while `convert` expects ImageMagick's command on the path. There is also a `FIXME` comment attached to the `OS=linux` line saying the detection does not work on other operating systems.

So the Makefile targets Linux, on the author's machine, for generating the README images and running shell based tests. It is not the route to use for a normal build. `cabal` or the `shell.nix` is.

The executables it drives tell you what ships. `extopenscad` is the interpreter you run.escad files through, and `implicitsnap` is described in the Makefile as the binary that listens for requests via http and acts as the backend of the website.

## Beta status, a three year gap between tags, and a six month silence

The README's own assessment is the most useful sentence in it: ImplicitCAD is very much a work in progress, the author considers it ready for beta testers, and greatly appreciates bug reports. That is the maintainer telling you the correct expectations.

The dates reinforce it. Releases are v0.4.1.0 on 2023-12-18, v0.4.0.0 on 2022-06-12, and v0.3.0.0 on 2020-01-26. The last push to the repository was on 2026-04-13. There is about six months between that push and now. The repository is not archived and the CI workflow badge is present, so this reads as a slow project rather than a dead one.

The licence is AGPL-3.0, which is the decision with the widest consequences. For personal and research use it costs you nothing. For anything shipped to users over a network, AGPL's terms reach further than permissive licences do, and you should read the licence text rather than take a summary from anyone, including this page.

The README also points at OpenSCAD as the traditional example of programmatic CAD, and hosts discussion on Libera Chat IRC under #ImplicitCAD.

## Conclusion

Adopt ImplicitCAD if you already write OpenSCAD and want rounded unions or a twisting extrusion, since those are the two features the README shows no OpenSCAD equivalent for, and if you are willing to keep .escad files separate from .scad ones. Do not adopt it for production output: the author states it is very much a work in progress and considers it ready for beta testers. Before building, check the release gap, since v0.4.1.0 is dated 2023-12-18 while the last push was 2026-04-13, and read the AGPL-3.0 terms if you intend to link it from a closed source tool.

## FAQ

### How do I run an OpenSCAD file with ImplicitCAD?

Save it and run `extopenscad example1.scad`, which produces `example1.svg`. Normal OpenSCAD code should work, and files shipped with the project are in the `Examples/` directory.

### What does ImplicitCAD add to the OpenSCAD language?

Rounded unions via `union(r=14)`, rounding on extrusions via `r=5` on `linear_extrude`, and a `twist` that can be a function rather than a constant. The README recommends saving such files with a `.escad` extension since they are not backwards compatible with OpenSCAD.

### Is ImplicitCAD production ready?

The README says ImplicitCAD is very much a work in progress and that the author considers it ready for beta testers. The latest release is v0.4.1.0 from 2023-12-18 and the last push was on 2026-04-13.

## Sources

- [Haskell-Things/ImplicitCAD on GitHub](https://github.com/Haskell-Things/ImplicitCAD)
- [License: AGPL-3.0](https://github.com/Haskell-Things/ImplicitCAD/blob/master/LICENSE)
- [Project website](https://implicitcad.org/)
- [README](https://github.com/Haskell-Things/ImplicitCAD/blob/master/README.md)
- [Releases](https://github.com/Haskell-Things/ImplicitCAD/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/haskell-things-implicitcad