ImpliSolid

ImpliSolid is a leading Geometric Shape Modelling library suitable for use as the solid modelling engine for 3D printing and other engineering uses, using Implicit Surfaces modelling (aka F-REP).

Up to my knowledge as of 2025, it is the only open-source mesh generator supporting implicit surfaces with sharp edges.

The main use case for ImpliSolid has been 3D Printing in mind. It is equally suitable for industry-grade manufacturing applications 🏗️, CAD/CAM, SDF, stochastic modelling of surfaces, design of organic shapes, scalable 🏠 Architectural_geometry modelling (siutable for parametric and modular architecture), solid modelling (water-tight guarantee: Topologically Closedness, Geometry-Consistent), any mesh generation, STL-to-SDF (for general-purpose mesh fixing and optimisaiton) Finite Element mesh generation for surfaces, Neural Implicit Surfaces Learning (Multi-view Reconstruction, implicit surface reconstruction, learning of implicit surfaces), PArametric Architecture, Gnerative 3D Design, Procedural 3D Design etc.

• Key Features:

  • ⭐️ Supports ✨ sharp edges ✨
  • ⭐️ Curvature-based Adaptive meshing
    • adaptive subdivision and decimation
    • Dual meshing
    • QEM

• Other features:

  • ⭐️ Compute efficiency
    • CPU efficient
    • Memory efficient
    • Cache efficient
    • Stable
    • robust
    • Feels light
  • ⭐️ Responsive, low-latency
  • ⭐️ Built-in progressive mesh generation
    • Low-poly to detailed mesh and curvature-adaptive mesh
    • Distributed: can offload to web-workers using message-passing
    • Suitable for live-coding
  • ⭐️ Custom run-time functions (see live coding demo mp5 editor)
  • ⭐️ Seamless integration with web, slicer

Languages: C++ (native), Python (native), Javascript. Targets: Native executable (LLVM), Javascript (frontend browser), WebAssembly, NodeJS (backend). ImpliSolid use is not limited to browsers. It is implementated in C++ (native), Python (native) and JavaScript.

ImpliSolid uses very efficient calculations to provide instant polygonisation of Implicit Surfaces efficient eniough to run on your browser using CPU only.

The main strength is its ability to work efficiently with sharp edges. It also uses adaptive subdivition for smooth and perfect curved surfaces. These are achieved using relatively lower resolution meshes.

• Performance: It uses "vectorised" numerical calulations (loop tiling, loop blocking for cache optimisation) to achieve higher speed by utilising Instruction Pipelining and L1/L2 caches in modern CPUs. This enables it to be useful on consumer and home computers.

<!-- This enables it to be useful on consumer and home computers on browser without GPU.-->

LLVM’s built-in CGO generates performant javascript, webassembly and native CPU code. Dynamic Programming is used to improve speed of graph algorithms.

| | | |------:|:-------| | Implisolid homepage: | homepage | | Github: | sohale/implisolid | | An interactive live demo:| mp5 editor |

<!-- | An interactive editor: | [link defunct](https://api-project-1000362687695.appspot.com/mp5interactive/mp5_json_code.html) | -->

Photo: Two objects 3D-printed on Ultimaker 2, using a slicer written from scratch based on ImpliSolid 3D. December 2016. (See MP5 Slicer for details)

Currently two open-source projects that use this library:

• mp5-private, i.e. the WeDesign.Live (incubated)
• mp5slicer A slicer for 3D printing (incubated)

Science

ImpliSolid uses academic research on the polygonization algorithm such as the algorithm by Ohtake & Belyaev.

<!-- https://dl.acm.org/doi/10.1145/882262.882293 -->

Dynamic Mesh Optimization for Polygonized Implicit Surfaces with Sharp Features. [1]: Ohtake & Belyaev 2002. Mesh Optimization for Polygonized Isosurfaces. Yutaka Ohtake, Alexander G. Belyaev. 25 July 2002. https://doi.org/10.1111/1467-8659.00529

[2]: Ohtake, Belyaev & Pasko 2003. Ohtake, Y., Belyaev, A. & Pasko, A. Dynamic mesh optimization for polygonized implicit surfaces with sharp features. Visual Computer 19, 115–126 (2003). https://doi.org/10.1007/s00371-002-0181-z Yutaka Ohtake, Alexander Belyaev, Alexander Pasko.

[3]: Ohtake & Belyaev 2002 (b). Dual/Primal mesh optimization for polygonized implicit surfaces. Proceedings of the seventh ACM symposium on Solid modeling and applications. June 2002. dblp https://doi.org/10.1145/566282.566308

E2E demo

For single-click execution in your computer (tested on Ubuntu and MacOS), run:

git clone git@github.com:sohale/implisolid.git
cd implisolid/
bash ./scripts/e2e-test-builds.bash

This will run and end-to-end demo: Pulls the code, compiles the code for Emscripten. Then launches a web server and runs a demo on browser like this. The interactive live demo instantly polygonises the objects and visualises them as the mp5 file is edited.

Architectural Structure

"Implisolid current architecture (Some proposed changes shown in purple)

<!-- Need decouple into independent interoperable parts (low level vectorised stuff/basic structures, the "simplical complexes" layer (includes the mesh). Separate the js parts that use ThreeJS (half-way) from the rest. NodeJS-based unit tests need to be able to test the web-worker functionality.) --> <!-- Thank you "Echan" for solution: https://stackoverflow.com/questions/52063556/add-image-to-github-readme-md-from-google-drive -->

Implemenation

ImpliSolid is implemented for JavaSCript, C++, Python.

JavaScript

Implicit can be compiled into JavaScript using Emscripten.

The Javascript compile target part can run on Browser, or NodeJS, or as a Web Worker.

Implisolid was originally intended for use in Browsers without need to any serverside.

ImpliSolid will soon be available in WebAssembly (tutorial comming soon).

The npm is available from here (will be moved).

Architecture

The IMPLICIT javascript library is a wrapper for the library for browser: js + threejs. It has three levels, each with a separate API. The final version will have 5 levels. Levels 1 and 2 are independent of ThreeJS, hence can be used in NodeJS or as a WebWorker. Only the Highest level API (level 3) uses Three.JS (For example see: mp5_json_code.html and demo1-deploy.sh, mcc2_3js_r79.js or this code fragment).

• A variant version builds objects incrementally.

• A variant builds objects incrementally in Web Worker of browser (see implisolid_worker.js).

• The main target can be compiled using scripts/build-emscripten.sh

• A web-assembly version will be available soon.

C++

ImpliSolid is written in modern C++.

The C++ implementation can be used standalone for modern C++ compilers such as g++ and clang. The main target is compiled into JavaScript using Emscripten.

Python

Two Python implementations are already available:

1. As a native Python implementation
2. As a Python binding that connects to a binary compilation of the C++ version.

Available targets

List of platforms with scripts (to install and compile):

• JavaScript (browser, formerly called asm.js)
• JavaScript, WebWorker version
• WebAssembly (comming soon)
• JavaScript on npm (comming soon)
• JavaScript (browser) using Docker (comming soon)
• Python binding (recommended)
• Python native (requires dependencies such as VTK or Mayavi)
• Clang / LLVM
• Native C++: g++ (see script)

Stargazers

Contributors

<a href="https://github.com/sohale/implisolid/graphs/contributors"> <img src="https://contrib.rocks/image?repo=sohale/implisolid" /> </a>

Tutorials:

E2E demo

For single-click execution in your computer (tested on Ubuntu and MacOS), run:

git clone git@github.com:sohale/implisolid.git
cd implisolid/
bash ./scripts/e2e-test-builds.bash

This will run and end-to-end demo: Pulls the code, compiles the code for Emscripten. Then launches a web server and runs a demo on browser like this. The interactive live demo instantly polygonises the objects and visualise