# JSCAD: Parametric 2D and 3D Modeling in Plain JavaScript

> JSCAD is an MIT-licensed set of modular JavaScript tools for creating parametric 2D and 3D designs. It runs as a hosted browser editor, a self-hosted web UI, a Node.js CLI, or a collection of individual npm packages under the @jscad scope.

**jscad/OpenJSCAD.org** — JSCAD is an open source set of modular, browser and command line tools for creating parametric 2D and 3D designs with JavaScript code. It provides a quick, precise and reproducible method for generating 3D models, and is especially useful for creating ready-to-print 3D designs.

- Repository: https://github.com/jscad/OpenJSCAD.org
- Website: https://openjscad.xyz/
- Stars: 3,247 · Forks: 565
- Language: JavaScript
- License: MIT
- Published: 2026-09-24 · Updated: 2026-09-24 · Language: en
- Canonical page: https://hysenlabs.com/projects/jscad-openjscad-org

## JavaScript as the only language you need for parametric design

JSCAD, previously distributed under the name OpenJSCAD, targets engineers and developers who are already comfortable with JavaScript and want to produce precise, reproducible 3D and 2D geometry without switching to a domain-specific CAD language. A parametric model in JSCAD is a JavaScript module that calls geometry functions and exports a result. The same module runs in a browser, in Node.js, or as input to a CLI pipeline. That portability is the core design bet: code-first modeling with no proprietary scripting syntax.

The project began as a fork of Joost Nieuwenhuijse's OpenJsCAD and has since moved well past its origin. It now serves as a monorepo, maintained by a group of volunteers organized under the JSCAD Organization on GitHub, covering everything from geometry primitives to file-format I/O packages to a browser-based development environment.

## Constructive Solid Geometry and the modular package split

JSCAD builds geometry through Constructive Solid Geometry, the same approach used by OpenSCAD and most parametric CAD kernels. Shapes are created as primitive solids or 2D polygons and combined through Boolean operations: union, subtraction, intersection. The CSG library that JSCAD rests on was originally contributed by Evan Wallace, Eduard Bespalov, Joost Nieuwenhuijse, and Alexandre Girard.

From version 2.0.0 onward, the repository is organized as a monorepo managed with Lerna-Lite. Each concern lives in its own package under the packages/ directory: the modeling engine in packages/modeling, the web interface in packages/web, the CLI in packages/cli, file I/O adapters under packages/io, and rendering utilities under packages/utils. Every one of these is published to npm under the @jscad scope, which means you can import just the modeling package into an existing Node.js project without pulling in the rendering or web dependencies.

The workspaces declared in package.json list the current top-level packages: cli, core, examples, io/* (several format-specific sub-packages), modeling, utils/* (including the regl-renderer), and web. This separation is deliberate. If your agent or build system only needs to convert geometry to a file format, it does not have to carry the browser UI as a dependency.

## Running JSCAD: from the hosted editor to a local web server

There are five ways to use JSCAD, and they are not mutually exclusive.

The quickest path requires nothing installed. The hosted editor at openjscad.xyz works in Chrome, Edge, Firefox, Opera, and Safari. You paste or type JavaScript, the browser renders the 3D model in real time, and you can export immediately. This is sufficient for one-off designs.

For teams who want to run the editor on their own infrastructure, the packages/web package contains a self-hosted web UI. To start the development server from the repository root:

```bash
npm run web
```

That npm script, defined in the root package.json, runs `cd ./packages/web && npm run dev`. It starts the development server for the web interface. Teams distributing JSCAD internally can follow the notes in packages/web/README.md to build a production bundle instead.

The CLI in packages/cli lets server-side Node.js scripts render geometry without a browser. The desktop application in packages/desktop is described explicitly in the README as pre-pre-alpha work in progress. It exists, but the README's own framing sets the expectation: it is not ready for any workflow that requires stability.

For embedding geometry generation in a larger project, the @jscad packages on npm are the right entry point. The full list is at npmjs.com/org/jscad.

## The monorepo structure: what Lerna-Lite manages

The repository root contains a package.json at version 2.0.0 with no runtime dependencies of its own. All production logic lives in the sub-packages. The devDependencies at the root cover tooling: Lerna-Lite for workspace orchestration and versioning, AVA for testing, jsdoc for API reference generation, and standardx for linting.

Common operations are available as npm scripts at the root. Running `npm run test` delegates to `lerna run --stream test` across all packages. Running `npm run lint` applies standardx to every JavaScript file under packages/. The `npm run docs` script generates JSDoc output using jsdoc.json at the root.

Publishing is handled through `lerna publish` with the `--conventional-commits` flag, which derives version bumps from commit messages following the Conventional Commits format. Because there are no GitHub Releases on this repository, version history lives in CHANGELOG.md and in npm rather than in the GitHub Releases tab.

The top-level .travis.yml points to a Travis CI configuration for continuous integration, though the README's Travis badge links to the older integration setup. Teams forking the monorepo for custom forks should check which CI configuration is currently active before relying on the badge status.

## Where JSCAD becomes the wrong tool

JSCAD's design choices create real constraints. The desktop application is the most visible one: the README explicitly calls it pre-pre-alpha. There is no version with a stable desktop release. Teams building tools that require a packaged, shippable desktop application cannot rely on that package today.

The web editor has no built-in version control or project management. Designs are JavaScript files, so an engineer does version them in any standard git workflow, but the editor itself does not manage file history the way dedicated CAD platforms do. Large teams working on shared models need to handle that coordination outside the tool.

JSCAD's CSG kernel works well for models built from Boolean operations on primitives, but complex freeform surfaces, NURBS curves, or subdivision meshes are not part of the JSCAD geometry model. Projects requiring those capabilities need a different kernel entirely.

Finally, the library of pre-built community models is smaller than what exists for OpenSCAD or commercial CAD tools. Engineers who expect to find existing parametric parts and adapt them rather than writing from scratch will find fewer ready-made modules.

## JSCAD versus OpenSCAD: the language choice is the real decision

OpenSCAD is the most direct point of comparison. Both tools use CSG, both target parametric, code-driven 3D modeling, and both produce output suitable for 3D printing. The difference that matters is the language: OpenSCAD has its own domain-specific language that resembles C but is separate from any general-purpose programming ecosystem. JSCAD uses plain JavaScript.

For a developer already writing Node.js tooling, that distinction is meaningful. A JSCAD model can be required as a module, tested with a standard JavaScript test runner, and composed with other npm packages. The same code that defines geometry can call a network API, read a database, or use a math library from npm. OpenSCAD's language does not have that kind of external interop.

The trade-off is ecosystem depth. OpenSCAD has a larger community library of pre-built parts, a longer history, and a desktop application that is stable and widely distributed. Engineers who already know OpenSCAD and whose models are primarily composed from community-contributed parts have no particular reason to migrate. The choice comes down to whether JavaScript interoperability is worth more than a larger existing parts catalog.

## Conclusion

JSCAD suits developers who already write JavaScript and want parametric 3D modeling without learning a separate CAD language. Engineers who need a mature, full-featured CAD environment with a large ecosystem of existing models will find OpenSCAD's community or commercial tools better suited to that workflow. Before adopting JSCAD, check that the @jscad packages for the I/O formats your pipeline requires are available at npmjs.com/org/jscad, and verify that the desktop app's pre-alpha status does not affect your deployment target.

## FAQ

### How do I use JSCAD without installing anything?

Go to openjscad.xyz in any modern browser. The hosted editor works in Chrome, Edge, Firefox, Opera, and Safari. You can write JavaScript models and render them immediately with no local setup.

### Can I use individual JSCAD packages in a Node.js project without the full monorepo?

Yes. All JSCAD packages are published to npm under the @jscad scope. You can install only the packages your project needs, such as the modeling package, without pulling in the browser UI or CLI dependencies. The full list is at npmjs.com/org/jscad.

### What is the difference between JSCAD and OpenJSCAD?

JSCAD was previously known as OpenJSCAD. The repository at jscad/OpenJSCAD.org is the current home of the project, and the name was shortened to JSCAD. The hosted editor remains available at openjscad.xyz.

## Sources

- [Issues](https://github.com/jscad/OpenJSCAD.org/issues)
- [jscad/OpenJSCAD.org on GitHub](https://github.com/jscad/OpenJSCAD.org)
- [License: MIT](https://github.com/jscad/OpenJSCAD.org/blob/master/LICENSE)
- [Project website](https://openjscad.xyz/)
- [README](https://github.com/jscad/OpenJSCAD.org/blob/master/README.md)

---

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