DEV Community: cy cy

Printing auxetic lattices: generating gyroid and diamond TPMS meshes with real density control

cy cy — Tue, 27 Oct 2026 19:38:51 +0000

Auxetic lattices are the structures that get wider when you stretch them — the opposite of ordinary materials. That property makes them excellent for cushioning, prosthetic liners, lightweight panels and things that need to conform under load. The good news: the two most useful families (gyroid and diamond, both Triply Periodic Minimal Surfaces) fit in about 30 lines of Python, and print fine on a stock FDM machine.

Here's how to generate them, and the density trap that most generators don't tell you about.

The math is one formula per lattice

A TPMS is defined by an implicit equation f(x, y, z) = t. Sweep t and you get nested surfaces through the volume. The two workhorses:

import numpy as np

def gyroid_field(X, Y, Z):
    return (np.sin(X) * np.cos(Y) +
            np.sin(Y) * np.cos(Z) +
            np.sin(Z) * np.cos(X))

def diamond_field(X, Y, Z):
    return (np.cos(X) * np.cos(Y) +
            np.cos(Y) * np.cos(Z) +
            np.cos(Z) * np.cos(X))

The solid is everything where f < t (or > t, depending on which phase you want).

From field to printable STL: marching cubes on a padded grid

from skimage import measure
import trimesh

def lattice_to_mesh(field_fn, size_mm=30.0, n=96, t=0.0):
    xs = np.linspace(-np.pi * 2, np.pi * 2, n)
    X, Y, Z = np.meshgrid(xs, xs, xs, indexing="ij")
    solid = (field_fn(X, Y, Z) < t).astype(float)
    # zero-pad: marching cubes MUST see closed boundaries or your mesh leaks
    padded = np.pad(solid, 1)
    spacing = size_mm / n
    verts, faces, _, _ = measure.marching_cubes(padded, level=0.5, spacing=(spacing,) * 3)
    mesh = trimesh.Trimesh(vertices=verts, faces=faces, process=False)
    if mesh.volume < 0:
        mesh.invert()
    return mesh

Two details that decide whether the print works:

Pad before marching cubes. Without the pad, surfaces touching the array edge stay open — the slicer sees a leaky shell and the print fails in ways that waste hours.
Run fix_normals with multibody=True. Depending on t, a TPMS has disconnected solid regions; a single-body normal fix flips the wrong walls.

The density trap: target ≠ measured

You'd think "set t so 50% of the voxels are solid, get 50% density." You don't. The isosurface cuts through the boundary voxels, and the faceted surface carves away material, so the printed mesh measures noticeably lighter than the voxel target.

I measured this on gyroid at three target fractions:

target	measured (mesh volume)
0.30	~0.27
0.50	~0.43
0.70	~0.64

Roughly a 3–15% loss depending on density — monotonic and predictable, which means you can calibrate: pick the target that lands where you actually want. If a generator reports only the target fraction, it's hiding the number that matters. Measure the mesh volume, not the voxel count.

(t isn't linear in density either — I pick it from the voxel histogram, scanning candidate levels until the histogram fraction matches the target.)

What to print first

A 30 mm cube of gyroid at measured ~0.43 is a good first test: prints without supports (the surfaces self-support at shallow angles almost everywhere), and you can feel the auxetic behavior by pulling opposite faces. Diamond at 0.3 is the stiff-but-light option.

If you want the pipeline without assembling it — level calibration, both lattices, Blender import, and measured-vs-target density reporting per part — that's my LatticeGen plugin (includes a Blender bridge), and PrintIQ adds bed packing and slicer time estimates on top. The pre-print mesh checks behind them are free in stl-precheck.

Start at 0.3–0.45 measured density: that's the sweet spot where auxetic behavior shows up without needing support material.

Your slicer is done, but your G-code isn't: three post-processing passes that fix real prints

cy cy — Tue, 27 Oct 2026 19:22:55 +0000

Slicers output a generic approximation: they know your printer's name, not its personality. The vibration on your worn X rails, the part-cooling duct you printed yourself, the PETG that strings at exactly your shop's humidity — none of that is in the slicer's model of the world.

The usual answer is "change the profile settings," but some fixes are positional: they apply to specific layers, specific moves, specific segments. That means post-processing the G-code. Here are the three passes that have earned their keep, with the core Python for each. All of them work line-by-line on the sliced output, so they compose cleanly with any slicer.

Pass 1: Z-hop, with per-segment control

Z-hop prevents the nozzle from dragging across a finished surface during travel. But a hop applied everywhere burns blob marks into top surfaces (the hop-down re-melts them) and adds hours to tall prints.

The fix: enable hops only where they help. The trap everyone hits: when you insert lines into G-code read via readlines(), every line already ends with \n — your inserted lines must carry their own newline or the next instruction gets glued onto yours:

def with_hops(lines, hop_mm=0.4):
    out = []
    z = None
    for raw in lines:
        if raw.startswith("G1 ") and " Z" in raw:
            z = float(raw.split(" Z")[1].split(" ")[0])
            out.append(f"G1 Z{z + hop_mm:.3f} F3000 ; hop up\n")
            out.append(raw)
            out.append(f"G1 Z{z:.3f} F3000 ; hop down\n")
        else:
            out.append(raw)
    return out

(In real use you gate this on whether the move is a travel move — G0 or a G1 without extrusion — not on every Z change.)

Pass 2: A fan-speed floor

Many profiles drop the part fan to 0% for the first layers (correct — adhesion) and then forget the floor at the other end: bridges and small perimeters need maximum cooling, and some profiles ask for 40% where your geometry needs 100%.

A floor pass enforces "from layer N onward, never below S%":

def with_fan_floor(lines, from_layer=3, min_pct=60):
    out, layer = [], 0
    for raw in lines:
        if raw.startswith(";LAYER:") or raw.startswith("; layer"):
            layer += 1
        if raw.startswith("M106") and layer >= from_layer:
            s = int(raw.split("S")[1].split(" ")[0]) if "S" in raw else 255
            raw = f"M106 S{max(s, int(255 * min_pct / 100))} ; fan floor\n"
        out.append(raw)
    return out

Note the parser assumptions: layer markers differ between Cura (;LAYER:), PrusaSlicer (; layer_change) and Orca — handle the ones your slicer emits, and verify on real output, not on memory.

Pass 3: Speed scaling with a cap

First prints on a new machine: scale everything down. Later: you discover your printer's actual speed ceiling is lower than the profile's ambition. Both are a global multiplier with a cap on absolute values:

def scale_speeds(lines, mult=0.7, cap_mm_min=6000):
    out = []
    for raw in lines:
        if raw.startswith(("G0 ", "G1 ")) and " F" in raw:
            head, rest = raw.split(" F", 1)
            f_tok = rest.split(" ")[0]
            f = min(int(float(f_tok) * mult), cap_mm_min)
            raw = f"{head} F{f} {rest[len(f_tok) + 1:]}"
        out.append(raw)
    return out

The habit that saves prints

Whatever you post-process, re-read the result with a G-code viewer (or your slicer's preview) before it touches the printer. A malformed edit doesn't usually fail loudly — it just does something almost right for 6 hours and then destroys the print at hour 7.

I ended up packaging these three passes (plus print-time re-estimation and stats) into a small zero-dependency CLI: G-code Tuner. It refuses to write output it can't parse cleanly, which is the part that actually matters at 2 AM.

If you want the pre-print half of the story — checking the mesh itself before slicing — the five checks are free and open source in stl-precheck, and the full auto-fix toolkit is Mesh Rescue.

Same rule as always: preview the modified G-code before you commit a long print to it.

The 10-minute STL pre-print checklist that saves failed prints

cy cy — Tue, 27 Oct 2026 18:28:09 +0000

You know the story: it's late, you slice the model, start the print, go to bed — and wake up to spaghetti, a detached first layer, or a shape that has a hole in it that the slicer silently "fixed" by creating a mess.

Almost every failed print I've had traces back to one of five problems that are detectable before slicing. Here's the checklist I run on every mesh now, with the Python one-liners for each. Total time: about 10 minutes, often less.

All snippets use trimesh (pip install trimesh numpy).

1. Is the mesh watertight?

A mesh with holes will confuse your slicer: it has to guess where the surface is, and some slicers guess badly.

import trimesh
m = trimesh.load("part.stl", force="mesh")
print(m.is_watertight)   # False = the slicer is going to improvise

If it's not watertight, don't panic — most holes from bad boolean ops or exports can be closed automatically:

from trimesh.repair import fill_holes
for _ in range(4):
    if m.is_watertight: break
    fill_holes(m); m.merge_vertices(); m.remove_unreferenced_vertices()
print(m.is_watertight)

2. Are the normals consistent — and pointing outward?

Inconsistent winding makes slicers produce walls of zero thickness. Flipped normals make the slicer think your solid is the void.

from trimesh.repair import fix_winding, fix_normals
fix_winding(m)            # make all faces agree on direction
fix_normals(m, multibody=True)  # orient normals outward
print(m.volume)           # must be POSITIVE now; negative = inside-out mesh

If the volume is negative after this, invert: m.invert().

3. Is the scale sane?

STL is unitless. A model exported in meters prints 1000x too small; one from some CAD tools comes in at 0.001mm and the slicer refuses it or scales it "helpfully".

import numpy as np
bbox = m.bounds[1] - m.bounds[0]
print([round(v, 2) for v in bbox])   # expecting something like [40.0, 25.0, 12.0] mm

Rule of thumb: for typical FDM parts, the largest dimension should be between ~5 and ~300 mm. Outside that range, suspect units.

4. How much overhang are you signing up for?

Only faces that point downward beyond ~45° need support — vertical walls print fine unsupported, and the face resting on the bed obviously doesn't count. A quick, honest estimate:

up = np.array([0, 0, 1.0])
nz = m.face_normals[:, 2]                     # downward faces have nz < 0
centers_z = m.triangles.mean(axis=1)[:, 2]
bed_z = float(m.bounds[0][2]) + 0.01          # ignore the bed-adjacent face
needs = (nz < -0.707) & (centers_z > bed_z)   # down-facing, beyond 45 deg, off the bed
frac = m.area_faces[needs].sum() / m.area_faces.sum()
print(f"{frac:.1%} of the surface needs support")

(The naive version of this check — abs(nz) < 0.707 — wrongly flags every vertical wall of a box as overhang. Walls are fine; it's downward-facing surfaces that cost you filament.)

Above ~3–5%: either rotate the part (try several orientations and pick the smallest fraction) or plan for supports. This single check has saved me the most filament.

5. Degenerate faces and duplicate geometry

Exports from CAD boolean operations often contain zero-area faces and duplicated triangles. They don't always break the print, but they make every downstream tool slower and some slicers choke on them.

m.update_faces(~np.isclose(m.area_faces, 0.0))
m.merge_vertices()
m.remove_unreferenced_vertices()

Wrapping it into one command

Before the paid part: the five checks above are free and open source as stl-precheck — a single-file CLI with a PASS/ATTENTION verdict and JSON output for batch use.

After running these by hand a dozen times, I packaged the whole checklist into a small CLI: Mesh Rescue — one command prints the full diagnostic report, auto-fixes what's safely fixable (holes, winding, duplicates, orientation), and scores your print-bed orientation with a support estimate. It also refuses to output anything when the mesh is too damaged to trust, rather than producing a silently-bad file.

For the step after slicing, G-code Tuner post-processes G-code (z-hop cleanup, fan speed floors, speed caps) with sanity-checked edits — the kind of tweaks that otherwise mean hand-editing 40,000 lines of G-code.

The honest caveats

Automatic hole-filling works for simple gaps; big structural holes need manual repair.
The overhang estimate is area-based — it doesn't know about bridges (which are often printable) or tiny cosmetic overhangs (which are fine unsupported).
Always dry-run the fixed mesh through your slicer before committing to a long print.

Print the checklist, not the spaghetti. If you end up building anything on top of these snippets, I'd love to hear what you added.