Blendtopo

Topology optimization: stiff, lightweight parts inside Blender

Blendtopo turns a block of "where material is allowed" into a stiff, lightweight, organic structure — entirely inside Blender. Mark where your part is held and where the forces act, press Run, and watch it grow a load-bearing shape you can export and 3D-print. No CAD seat, no separate FEA tool, nothing to pip-install.

How it works (the whole workflow is four meshes and a button)

1. Select your build-volume mesh and click Set Build Space from Active. It's shown as wireframe so you can see the result form inside it.
2. Add Bearing for each support — a small helper mesh marking where the part is anchored. Tick which axes are held (X/Y/Z).
3. Add Load for each force — a helper mesh plus a force vector (e.g. 0, 0, -1 for straight down).
4. (optional) Add Exclusion for keep-out volumes — bolt holes, clearances.
5. Set Volume Fraction (how much material to keep) and press Run Optimization.

The structure appears almost immediately as a rough shape and refines over a coarse-to-fine schedule, redrawing every iteration so it visibly morphs into its final form. The solve runs on a background thread, so you can keep orbiting the viewport while it works.

What you get

• A watertight, manifold mesh — capped flush where the structure meets the build-space boundary — ready to export to STL and slice.
• Optimize Mesh one-click post-process: smooth + decimate into a clean, low-poly body (adjustable).
• Every iteration is kept in a "Blendtopo Results" collection so you can scrub back; ESC stops early and keeps the latest; Continue runs more iterations from where you stopped.

Key controls

• Final Resolution and Refine Levels — detail vs. speed.
• Filter Radius — minimum feature size (smaller = finer struts).
• Iso Level — how much of the density to show as surface.
• Preview — smooth (organic) or blocky (fast).
• Convergence / Iterations per Level — how hard each stage works.

Built to stay fast on fine grids

The finite-element solve is matrix-free (no global matrix assembled) and preconditioned by a geometric multigrid V-cycle. In testing, the solver iteration count stayed essentially flat (~10) from ~2k to ~29k degrees of freedom, where plain diagonal preconditioning grew from ~85 to ~228. If an NVIDIA GPU and CuPy are present, it uses them automatically — after a startup self-test that falls back to CPU if anything doesn't match.

Requirements

• Blender 4.2+. No external Python packages required (runs on Blender's bundled NumPy).
• Optional: a CUDA GPU + CuPy for extra speed.

Free and open source

GPL-3.0. Source, releases, issues and a short technical write-up: https://github.com/RandomLambda/Blendtopo

This is an early release — bug reports and example .blend files are very welcome.

A good first test

Add a Cube as the build space, scale it long; add a small cube at one end as a bearing (all axes fixed) and another at the far end as a load (0, 0, -1); set Volume Fraction ~0.2 and Run. You'll get a classic cantilever in seconds.