Scripting API

viewer.info() sync

Returns facts about the model currently loaded in the viewer. No analysis is run, so this is instant and safe to call as often as you like. When no model is loaded, hasModel is False and sizeMm is None.

None.

A mesh-info object.

i = viewer.info()
if i["hasModel"]:
    print("%d faces, %.1f mm tall" % (i["faceCount"], i["sizeMm"]["z"]))

See also: load_url().

viewer.load_url(url) async

Fetches a model from a URL and loads it into the viewer — the same path as the address bar's “paste a model URL” field. The fetch happens in your browser; nothing is sent to a MeshTune server. The call resolves once the model is actually on screen, so the next line can safely analyze it.

True once the model is loaded and framed; False if the URL is invalid or the fetch fails.

if await viewer.load_url("https://raw.githubusercontent.com/you/repo/main/bracket.stl"):
    print(viewer.info()["faceCount"], "faces loaded")
else:
    print("Could not load that URL")

See also: info().

viewer.analyze_thickness(…) async

Runs wall-thickness analysis and paints the red → amber → green heat map onto the model — identical to clicking Run Analysis in the Wall Thickness panel. The panel's legend, summary, and zoom-to-thinnest populate too. All distances are in millimetres.

A thickness-result object.

passed is False whenever any point falls below min_mm. A handful of points at sharp edges is usually noise rather than a real thin wall — pass an island_mm2 to ignore them.

res = await viewer.analyze_thickness(min_mm=0.8, max_mm=3.0, island_mm2=1.0)
print("backend:", res["backend"])
print("min wall: %.3f mm" % res["minWallMm"])
print("verdict :", "PASS" if res["passed"] else f'{res["nViolating"]} thin points')

See also: run_analysis(), thickness-result object.

viewer.run_analysis() async

Runs every mesh-quality check at once — the equivalent of the viewer's Run Analysis button — and fills the Mesh Analysis panel. Always forces a fresh run.

None.

A dict mapping each check id to its check-result object. Keys: colocated, degenerate, isolated, holes, nonManifoldEdge, nonManifoldVertex, flippedFaces, selfIntersection.

checks = await viewer.run_analysis()
problems = [c["name"] for c in checks.values() if not c["ok"]]
print("Issues:", ", ".join(problems) if problems else "none — mesh is clean")

See also: the individual detect_*() functions, check-result object.

The detect_*() functions async

Each mesh-quality check is also a standalone function, so you can run just the one you care about and branch on the result. They all take no parameters and return a check-result object.

viewer.detect_holes() async error

Finds boundary loops where the surface isn't closed — “open holes”. A printable solid must be watertight, so any hole is a blocker. MeshTune traces each full hole perimeter; in the panel the boundary is highlighted in the 3D view.

None.

A check-result object (id = "holes").

holes = await viewer.detect_holes()
print("watertight" if holes["ok"] else f'{holes["found"]} open holes')

See also: run_analysis().

viewer.detect_self_intersection() async error

Finds faces that physically pass through one another. Self-intersections must be resolved before a model can be printed as a watertight solid, and they often confuse slicers and boolean operations. This is the heaviest check; on very large meshes it may report severity = "skipped".

None.

A check-result object (id = "selfIntersection").

si = await viewer.detect_self_intersection()
if not si["ok"]:
    print(si["found"], "self-intersections; first at", si["issues"][0])

See also: detect_holes(), run_analysis().

viewer.detect_non_manifold_edges() async error

Finds edges shared by more than two faces. Most slicers can't make sense of this topology — a watertight solid has every edge shared by exactly two faces. Highlighted as yellow lines in the 3D view.

None.

A check-result object (id = "nonManifoldEdge").

See also: detect_non_manifold_vertices(), run_analysis().

viewer.detect_non_manifold_vertices() async error

Finds “bowtie” vertices where two otherwise-disconnected fans of faces meet at a single point. Like non-manifold edges, these break the watertight-solid assumption and trip up slicers and repair tools. Marked with a yellow crosshair.

None.

A check-result object (id = "nonManifoldVertex").

See also: detect_non_manifold_edges(), run_analysis().

viewer.detect_flipped_faces() async error

Finds triangles whose winding order (and therefore normal) is inconsistent with their neighbours. Flipped faces cause shading artefacts and make a slicer disagree about what's inside vs. outside the solid.

None.

A check-result object (id = "flippedFaces").

See also: run_analysis().

viewer.detect_degenerate_faces() async warning

Finds zero-area triangles — faces whose vertices are collinear or coincident. They carry no surface and can produce slicing artefacts, so they're best removed. A warning rather than a hard error.

None.

A check-result object (id = "degenerate").

See also: run_analysis().

viewer.detect_isolated_vertices() async warning

Finds vertices that aren't attached to any face — leftover data that bloats the mesh without contributing geometry. Harmless to print but worth cleaning up. A warning.

None.

A check-result object (id = "isolated").

See also: detect_duplicate_vertices(), run_analysis().

viewer.detect_duplicate_vertices() async warning

Finds multiple vertices sitting at the exact same position. Merging them (“welding”) gives correct, connected topology and a smaller, cleaner mesh. A warning rather than an error.

None.

A check-result object (id = "colocated").

See also: detect_isolated_vertices(), run_analysis().

viewer.load_sample() async

Loads MeshTune's bundled sample model — handy for trying a script without your own file. Resolves once the model is in the scene.

None.

True once loaded.

await viewer.load_sample()
print(viewer.info()["faceCount"], "faces")

See also: load_url().

viewer.detect_overhangs(critical_angle=45) sync

Highlights every surface steeper than the critical angle — the faces a printer would struggle to print unsupported — and reports how much of the model is affected. Paints the overhang heatmap on the model (green = safe, red = overhang), the same as the Overhangs panel, evaluated in the model's current orientation. Returns immediately (no await).

An overhang-result object, or None if no model is loaded.

oh = viewer.detect_overhangs(critical_angle=50)
print("%.1f%% overhang (%.1f cm2)" % (oh["percent"], oh["areaCm2"]))

See also: analyze_thickness(), drop_to_bed().

viewer.volume_mass(…) sync

Computes the model's solid volume and surface area, and estimates printed weight, filament length, material cost, and print time. Any argument left as None uses the Volume & Mass panel's current value, so you can override just what you need.

A volume-mass object, or None if no model is loaded.

vm = viewer.volume_mass(density=1.24, infill=20)
print("%.1f g, %.2f m filament, ~%d min" % (vm["massG"], vm["filamentM"], vm["printTimeMin"]))

See also: check_build_volume().

viewer.check_build_volume(…) sync

Checks whether the model fits inside a printer's build volume, comparing its real-world size against the envelope. Pass a named printer preset, or explicit x/y/z dimensions in mm; with no arguments it uses the Build Volume panel's current dimensions.

A build-volume object, or None if no model is loaded.

bv = viewer.check_build_volume(printer="prusa-mk4s")
print("fits" if bv["fits"] else "too big", "%.0f x %.0f x %.0f mm" % (
    bv["modelMm"]["x"], bv["modelMm"]["y"], bv["modelMm"]["z"]))

See also: resize(), volume_mass().

viewer.drop_to_bed() sync

Rests the model flat on the Z=0 build plate and centers its footprint over the origin — the standard print-bed placement. Moves the model only (no geometry change); the new pose is reflected in subsequent analyses and exports.

None.

True if it ran (a model is loaded), else False.

viewer.drop_to_bed()

See also: detect_overhangs().

viewer.resize(…) sync

Scales the model proportionally — either by a uniform factor or to a target dimension on one axis. The scale is applied to the display and baked into any subsequent export. Pass exactly one of the arguments.

A size object with the new real size, or None if no model is loaded or the input is invalid. With no arguments, returns the current size unchanged.

sz = viewer.resize(x=120)   # scale so X = 120 mm (proportional)
print("now %.1f x %.1f x %.1f mm" % (sz["x"], sz["y"], sz["z"]))

See also: check_build_volume(), export().

viewer.export(format="stl") async

Exports the displayed model and triggers a browser download. The current pose (orientation, drop-to-bed, gizmo edits) and any resize are baked into the file, in real file units (mm).

The downloaded filename (e.g. "part.stl"). Raises if no model is loaded or the format is unsupported.

name = await viewer.export("stl")
print("saved", name)

See also: screenshot(), resize().

viewer.screenshot() sync

Captures the current 3D view and downloads it as a transparent-background PNG (the navigation overlay is excluded — a clean shot of just the model).

None.

The downloaded filename (e.g. "part.png"). Raises if no model is loaded.

viewer.screenshot()

See also: export().