#API reference

tscad is one package with subpath exports. Everything is typed, and hovering in your editor shows the same documentation. Lengths are mm, angles are degrees, Z is up.

The elements themselves (<box>, <extrude>, ...) are listed in the element reference.

#tscad

#Models and compiling

#JSX, components, context

#Parameters

export const params = defineParams({
  width: { type: "number", default: 40, min: 10, max: 120, step: 1, unit: "mm", label: "Width", group: "Size" },
  holes: { type: "int", default: 4, min: 0, max: 12 },
  rounded: { type: "boolean", default: true },
  style: { type: "choice", default: "round", options: ["round", "square"] },
  label: { type: "text", default: "tscad", maxLength: 12 },
  tint: { type: "color", default: "#4f7cac" },
})
export default function Model(p: ParamValues<typeof params>) { /* p.style: "round" | "square" */ }

#Selectors

edges and faces (class Sel) give .top() .bottom() .vertical() .circles(axis?) .radius(r) .parallel(axis) .perpendicular(axis) .max(axis) .min(axis) .within(min, max) .index(...), chained with .and() .or() .not(). Strings work too: ">Z or |Z". See Selectors. Also exported: parseSelector(string), toSelector(like), SelectorSyntaxError, and the type SelectorLike.

#Paths, units, materials, text

#Sketches and assemblies

sketchPath() (a fluent path builder whose .d goes into <path d>), sketchRef and sketchRefs (handles for constraint sketches). For assemblies: anchorRef, assemblyRefs, and isAnchorRef. See Constraint sketches and Assemblies.

#tscad/parts

The parts library has fastener holes as cutting tools pointing −Z from z = 0 (Hole, CounterboreHole, CountersinkHole, TapHole), hardware (NutTrap, HeatSetInsert, Standoff), standard parts with ISO dimensions (Bolt with its own cutter, Nut, Washer, SetScrew, DowelPin, Bearing, ShaftCollar, clearance(); see docs/parts.md), patterns (BoltPattern, MountHoles, mountPatterns), profiles (Extrusion2020, HexPrism), and ISO data (metric, metricData(size), metricSizes). Each component's props are in the parts reference.

#tscad/kernel

const kernel = await loadKernel()                 // shared session; loadKernel(wasm) for another
const r = await kernel.evaluate(document, { tolerance?, noMesh? })
r.parts                                           // { name, ok, empty, error?, volume, area, bbox, counts, warnings, millis, cached }[]
await kernel.mesh("part")                         // MeshArrays (typed arrays) of the last evaluation
await kernel.meshAt("part", 0.01)                 // finer mesh, for export
await kernel.step(["part"])                       // STEP AP242 text
await kernel.pickEdge("part", i)                  // { kind, points, radius?, direction?, suggestions: { selector, count }[] }
await kernel.pickFace("part", i)

The session caches subtrees by structural equality: unchanged parts of the tree are not recomputed. When a native build exists (bun scripts/build-native.ts, written to native/<platform>-<arch>/), loadKernel() uses it through bun:ffi; it's 2–3× faster than the WebAssembly build. TSCAD_NATIVE_LIB points at a library elsewhere. A kernel panic throws KernelPanic, and the session is rebuilt. MeshArrays = { positions, normals, indices, faceIds, edgePoints, edgeCounts, edgeIds }.

#tscad/export

exportModel(kernel, parts, format, { tolerance? = 0.01, binary? }) → Uint8Array | string for "step" | "stl" | "3mf" | "glb" | "obj". The individual writers toSTL(parts, { binary }), to3MF, toGLB and toOBJ take { name, color?, mesh }[]. Constants: EXPORT_FORMATS, MIME_TYPES, DEFAULT_EXPORT_TOLERANCE.

#tscad/render

renderPNG(parts, { width = 1200, height = 800, view = "iso", background = "dark", edges = true, projection, shadow, margin, ssaa }) → PNG bytes. renderImage gives raw RGBA. view is a named view (iso, front, top, …) or { azimuth, elevation } in degrees.

#tscad/drawing

The inputs are compile(...).drawings (from <drawing> elements), loops, or { name, loops }. A Drawing can also carry open paths (chains that are never closed, such as sheet-metal bend lines: LINE/ARC or an open POLYLINE in DXF, an unfilled <path> in SVG) and notes (DrawingNote { at, text, size, angle? }: real TEXT entities in DXF, <text> in SVG), both included in the bounds.

#tscad/check

See Checks & testing.

#tscad/testing

evaluateModel(model, params?) → ModelResult, which has ok, volume(), mass(), size(), bbox(), mesh(), printability(), watertight() and interference(). The matchers toEvaluate, toHaveVolume, toFitIn, toHaveNoInterference (async) and toBePrintable are registered on import. paramCombos(schema, { method, samples, seed, max, only, fixed }) and forEachParamCombo generate parameter sweeps. See Checks & testing.

#tscad/mcp

runMcpServer({ stdin?, stdout?, log? }) serves MCP over stdio; it is the same server as tscad mcp. createMcpHandler() handles one parsed message at a time. TOOLS lists the tool definitions. elementsMarkdown(), partsMarkdown(), lookupReference(name) and referenceEntries() give the generated element reference. See MCP server.

#tscad/convert

convertScad(source, { name }) → { tsx, warnings }. It turns an OpenSCAD model into a tscad module: Customizer variables become defineParams, modules become components, and 2D booleans under linear_extrude become sketch booleans. A source that doesn't parse throws ScadSyntaxError, with the line. The CLI is tscad convert in.scad -o out.tsx. See Converting OpenSCAD.

#tscad/ir

The IR types are generated from the Rust kernel: Document, Part, Node, Curve, Selector, Axis, EvalResult, PartResult, PickInfo. See Architecture.