Command reference

Generated by cargo xtask book from solvecraft-cli commands (300 commands). Every command runs the same way from the toolbar, a script, solvecraft-cli exec <id> '<json>', the control channel and MCP. Parameters marked ? are optional; expr is a number or an expression with units.

SOLID › CREATE

sketch.create Create Sketch
plane: XY|XZ|YZ | {origin, x_dir, y_dir} | {face: [x,y,z]} (planar face at point), offset?: expr, name?
solid.extrude Extrude (E)
distance: expr (or through_all: true); taper?: angle expr; sketch?: id|name (default: active or last sketch); profiles?: all | [index] | [[curve ids]] | [{point:[x,y]}]; face?: [x,y,z] (extrude a planar body face instead of a sketch profile); direction?: positive|negative|symmetric; distance2?; start_offset?; to?: [x,y,z] (To Object: a face, vertex or point; to_offset?: expr past it); from?: [x,y,z] (From Object: start at that face or point); operation?: new|join|cut|intersect|auto (cut into a body, join out of one, else new); targets?: [body]; name?; body_name?
solid.revolve Revolve
axis: sketch line id | x | y (sketch axes) | X|Y|Z (world); angle?: expr (default 360 deg); angle2?: expr (Two Sides: the other side's angle); direction?: symmetric (angle split either side); to?: [x,y,z] (To Object: turn until that face, vertex or point); sketch?, profiles? | face: [x,y,z] (a planar body face as the profile), operation?, targets?, name?, body_name?
solid.sweep Sweep
sketch: profile sketch; profiles?; path_sketch: sketch; path: [curve ids in order]; operation?
solid.loft Loft
sections: [{sketch, profiles?} | {sketch, point: id} (an apex)] (2 or more, in order); operation?
solid.box Box
length, width, height: expr; corner?: [x,y,z] | center?: [x,y,z]; operation?
solid.cylinder Cylinder
radius | diameter, height: expr; base?: [x,y,z]; axis?: [x,y,z]; operation?
solid.sphere Sphere
radius | diameter: expr; center?: [x,y,z]; operation?
solid.torus Torus
major, minor: expr (radii); center?; operation?
solid.pattern.rectangular Rectangular Pattern
features: [names] | bodies: [names] | components: [names]; dir1: [x,y,z]; count1; spacing1; dir2?, count2?, spacing2?
solid.pattern.circular Circular Pattern
features: [names] | bodies: [names] | components: [names]; axis: X|Y|Z | {origin, dir}; count; angle? (default 360 deg)
solid.pattern.path Pattern on Path
features: [names] | bodies: [names]; path_sketch: sketch; path: [curve ids in order]; count; spacing (between instances) | distance (first to last); orientation?: identical|path; flip?: bool
solid.mirror Mirror
features: [names] | bodies: [names] (combine?: join with the original); plane: XY|XZ|YZ | {origin, x_dir, y_dir}
solid.hole Hole (H)
position: [x,y,z] on a face | sketch + points: [sketch point ids] (one hole each, perpendicular to the sketch) | sketch alone (every sketch point: standalone points and circle centres); direction?: [x,y,z] (default: into the face); diameter | thread (a tapped hole: the tap drill, major − pitch) | clearance: "M6" with fit?: close|normal|loose (ISO 273); depth? (default through all) | to?: [x,y,z] (To Object: drill to that face or point); type?: simple|drilled|counterbore|countersink; tip_angle?; cb_diameter?, cb_depth?; cs_diameter?, cs_angle?; thread?: "M6" (cosmetic)
solid.pipe Pipe
path_sketch: sketch; path: [curve ids in order]; diameter: expr; wall?: expr (hollow); operation?, targets?, name?, body_name?
solid.bounding_solid Bounding Solid
bodies?: [names] (default: all); margin?: expr; name?, body_name?
solid.thread Thread
face: [x,y,z] on a cylindrical face; designation?: ISO metric ("M8", "M8x1"; default: the size that fits); length?: expr (default: the whole face). Cosmetic: the model is unchanged, model.threads lists it
SurfaceSculpt Boundary Fill
tools: [bodies]; cells: [[x,y,z] a point inside each cell to fill (a cell: inside some tools, outside the rest)]; operation?: new|join|cut|intersect; remove_tools?: bool
solid.coil Coil
diameter; two of revolutions (or turns), height, pitch; section_size; section?: circular|square; section_position?: inside|center|outside; base?: [x,y,z]; axis?: X|Y|Z|[x,y,z] (default Z); start_angle?; clockwise?: bool; operation?, targets?, name?, body_name?
solid.rib Rib
sketch, curves: [open curve ids, in order]; thickness (across the sketch plane); depth? (default: to the next face); flip?: bool (fill to the other side)
solid.web Web
sketch, curves: [open curve ids] (one wall each); thickness; depth? (default: to the next face); flip?: bool
solid.emboss Emboss
sketch (on a planar face), profiles?; depth; mode?: emboss|deboss (default emboss); targets?
joint.origin Joint Origin
name?, occurrence?: id|name (default: from the pick), face: [x,y,z] (centre of a planar face) | circle: [x,y,z] (centre of a round end) | point: [x,y,z], z?: [x,y,z]

SOLID › MODIFY

solid.fillet Fillet (F)
edges: [[x,y,z] point on edge | {body, index}]; radius: expr; body?; type?: constant|chord (radius is the width across)|variable (radius at the end nearest start, radius2 at the other); radius2?; start?: [x,y,z]
solid.chamfer Chamfer
edges: [[x,y,z] | {body, index}]; distance: expr; distance2?: expr (along the second face) | angle?: expr (from the first face); flip?: bool (which face is first: by default the one facing up most); body?
solid.combine Combine
target: body; tools: [body]; operation?: join|cut|intersect; keep_tools?: bool; new_component?: bool (the result goes into a new component; component_name?)
solid.scale Scale
bodies: [names]; factor: expr | factors: [x, y, z] exprs; origin?: [x,y,z]
face.delete Delete Face
faces: [[x,y,z] points on the faces]; body?. The neighbouring planes close the gap, as when a rounded edge, hole or boss is taken off
solid.offset_face Offset Face
faces: [[x,y,z] points on planar faces]; distance: expr (positive: outward); body?
solid.shell Shell
faces: [[x,y,z] points on the faces to remove]; thickness: expr; direction?: inside|outside|both; tangent_chain?: bool (also open faces joined smoothly to the picked ones); body?
solid.draft Draft
faces: [[x,y,z]]; angle: expr; neutral: XY|XZ|YZ|plane name|{origin, normal}; pull?: [x,y,z] (default: neutral plane normal); body?
solid.split_face Split Face
faces: [[x,y,z] points on the faces to split]; body?; and the splitting tool: plane: XY|XZ|YZ|plane name|{origin, normal} — or tool: {body, point} (a face of a body, its surface extended) — or sketch: id or name (its curves, along the sketch's normal)
solid.split_body Split Body
body: name; plane: XY|XZ|YZ|plane name|{origin, normal} — or tool: {body, point} (a face of a body, its surface extended)
solid.press_pull Press Pull (Q)
face: [x,y,z] and distance: expr (positive adds material, negative cuts), or edges: [[x,y,z]…] and distance (a fillet)
solid.move Move/Copy (M)
bodies: [names]; translate?: [x,y,z] (exprs or numbers); axis?: [x,y,z]; angle?: expr
solid.replace_face Replace Face
faces: [[x,y,z] points on planar faces]; target: plane (XY|XZ|YZ|construction plane|{origin, normal}) | target_face: [x,y,z] on a parallel planar face; body?
solid.align Align
bodies: [names]; from: [x,y,z] | {snap: vertex|edge_mid|face_center|circle_center, at: [x,y,z]} | from_face: [x,y,z]; to: (the same) | to_face: [x,y,z] (faces also turn to meet); flip?: bool
solid.remove Remove
bodies: [names] (removed from here on in the timeline)
timeline.compute_all Compute All
timeline.delete Delete (Delete)
features: [id or name] (a sketch takes its dependent features with it)
parameters.change Change Parameters
name, expression (number or text), unit?: mm|cm|m|in|ft|deg|rad|"" (new parameters default to their value's unit), comment?, favorite?: bool, new_name?: rename (references follow); or delete: name
material.assign Physical Material
bodies: [names]; material: name (Steel, Aluminum, ABS Plastic, …; `material.list`)
appearance.assign Appearance (A)
bodies?: [names]; faces?: [[x,y,z] on faces] (body?: which body, default the nearest); components?: [names or ids, or occurrence names]; appearance?: library name (appearance.library) | color: "#rrggbb" or [r, g, b] (0–255), opacity? (0–1, default 1); neither (or color: null): clear, so the face follows its body, the body its component, the component its material

SOLID › CONSTRUCT

construct.plane.offset Offset Plane
base: XY|XZ|YZ|plane name; offset: expr; name?
construct.plane.at_angle Plane at Angle
base: XY|XZ|YZ|plane name; axis: X|Y|Z|{origin, dir}; angle: expr; name?
construct.axis.through_cylinder Axis Through Cylinder/Cone/Torus
face: ref (a cylinder, cone or torus face, or a circular edge); name?
construct.axis.normal_to_face Axis Perpendicular To Face
face: ref; point: ref (the axis goes through it, square to the face); name?
construct.axis.two_planes Axis Through Two Planes
a, b: plane or planar face refs; name?
construct.axis.two_points Axis Through Two Points
a, b: point refs (vertices, sketch points, points); name?
construct.axis.edge Axis Through Edge
edge: ref (a straight edge or sketch line); name?
construct.point.vertex Point At Vertex
point: ref (vertex, sketch point, point); name?
construct.point.two_edges Point Through Two Edges
a, b: edge or line refs (where they meet, or come closest); name?
construct.point.three_planes Point Through Three Planes
a, b, c: plane or planar face refs; name?
construct.point.center Point At Center Of Circle/Sphere/Torus
of: ref (circular edge, sketch circle or arc, sphere or torus face); name?
construct.point.edge_plane Point At Edge And Plane
edge: edge or line ref; plane: plane or planar face ref; name?
construct.point.along_path Point Along Path
path: edge or sketch curve ref; t: expr, 0…1 along it (default 0.5); name?
construct.plane.midplane Midplane
a, b: plane or planar face refs (halfway between; bisecting when they meet at an angle); name?
construct.plane.two_edges Plane Through Two Edges
a, b: straight edge or line refs in one plane; name?
construct.plane.three_points Plane Through Three Points
a, b, c: point refs; name?
construct.plane.tangent Tangent Plane
face: ref (cylinder, cone, sphere or torus); at?: [x,y,z] where it touches (default: the face pick); name?
construct.plane.along_path Plane Along Path
path: edge or sketch curve ref; t: expr, 0…1 along it (default 0.5); name? The plane is square to the path there

SOLID › ASSEMBLE

component.create New Component
name?, parent?: component id or name (default: the active one); activate?: bool (default true)
joint.create Joint (J)
type: rigid|revolute|slider|cylindrical|pin_slot|planar|ball; a, b: joint origins ({occurrence, face|circle|point: [x,y,z] in world} | origin name); values?: [angles in deg or expressions, distances]; limits?: [[min, max] | null…]; flip?: bool; offset?; angle?; name?
joint.as_built As-Built Joint
type, a: occurrence, b: occurrence (stay where they are); at?: joint origin (default: b's origin) — the joint's frame
joint.rigid_group Rigid Group
occurrences: [ids or names] (move together, as they are)
joint.drive Drive Joints
joint: id|name; value | values: [angles in deg or expressions, distances] (clamped to the limits)
joint.motion_link Motion Link
a, b: joints; ratio (b = ratio · a + offset); offset?; ia?, ib?: value indices (default 0)
contact.enable_sets Enable Contact Sets
enabled?: bool (default true) — driving joints and motion studies stop where bodies in one contact set would pass through each other
contact.enable_all Enable All Contact
every occurrence takes part in contact (one set of all)
contact.disable_all Disable Contact
contact off
contact.create New Contact Set
occurrences: [ids or names] (two or more); name?
motion.study Motion Study
name?; study? (edit an existing one); steps? (timeline length, default 100); keys: [{joint, index?, points: [[step, value], …]}] (values: degrees for angles, mm for distances, or expressions)
explode.create Exploded View
name?; scale? (automatic: each occurrence pushed away from the assembly's centre by scale × its offset, default 1); moves?: [{occurrence, translate: [x,y,z]}] (instead of automatic)

SOLID › POSITION

component.capture_position Capture Position
keeps pending occurrence moves
component.revert_position Revert Position
drops pending occurrence moves

SOLID › INSPECT

inspect.interference Interference
bodies?: [names] (default: all, in world placement) → pairs that overlap with the overlap volume, area, bounding box and centre
inspect.measure Measure (I)
bodies?: [names] (default all); or items: [1-2 selections] → length/area/volume, minimum distance (from, to) and angle
inspect.section Section Analysis
plane: XY|XZ|YZ | {origin, normal}; offset?: expr along the normal; flip?: bool; or clear: true

SOLID › CONFIGURE

config.configure Configure
params?: [parameter names]; features?: [feature names] (columns to add; with no rows yet, a "Default" row takes the current values)
config.table Display Configuration Table
→ columns (param:<name> or suppress:<feature>), rows, the active row and whether the design still matches it

SOLID › INSERT

parts.fastener Insert Fastener
the Insert Part dialog's command (same as parts.insert): family, size, length?, at?|point?+direction?, name?
file.insert_step Insert STEP
path: .step/.stp file (its bodies join the design as an Import base feature); name?
file.insert_mesh Insert Mesh
path: .3mf or .stl file (its meshes join the design as mesh bodies); name?

SKETCH › FINISH SKETCH

sketch.finish Finish Sketch
sketch.finish_auto_constrain Finish with AutoConstrain
like AutoConstrain, then Finish Sketch

SKETCH › CREATE

sketch.line Line (L)
points: [[x,y] | "l1.end" | {at, ref}…], closed?: bool, construction?: bool, ids?: [..], infer?: bool (add horizontal/vertical)
sketch.rectangle.two_point 2-Point Rectangle (R)
p0, p1: opposite corners [x,y]; construction?
sketch.rectangle.three_point 3-Point Rectangle
p0, p1: first edge; p2: point on the opposite edge
sketch.rectangle.center Center Rectangle
center, corner
sketch.circle.center Center Diameter Circle (C)
center: [x,y] or point ref, radius | diameter: number
sketch.circle.two_point 2-Point Circle
p0, p1: diameter ends
sketch.circle.three_point 3-Point Circle
p0, p1, p2
sketch.arc.three_point 3-Point Arc
start, end, through
sketch.arc.center_point Center Point Arc
center, start, end (counter-clockwise from start) | center, start, sweep: signed degrees
sketch.polygon.inscribed Inscribed Polygon
center, radius (to vertices), sides, angle?: deg
sketch.polygon.circumscribed Circumscribed Polygon
center, radius (to edge midpoints), sides, angle?: deg
sketch.polygon.edge Edge Polygon
p0, p1: one edge, sides
sketch.slot.center_to_center Center to Center Slot
p0, p1: arc centres, width
sketch.slot.overall Overall Slot
p0, p1: overall ends, width
sketch.point Point
point: [x,y], id?
sketch.dimension Sketch Dimension (D)
entities: [refs], type?: auto|distance|horizontal|vertical|length|radius|diameter|angle, value?: number or expression (default: current)
sketch.construction Normal/Construction (X)
curves: [ids], value?: bool (default: construction unless all of them already are)
sketch.line.midpoint Midpoint Line
mid: [x,y] or point ref, end: [x,y]; construction?
sketch.arc.tangent Tangent Arc
start: end point of a line or arc ("l1.end"), end: [x,y]; curve?: the curve to be tangent to (default: the one ending at start)
sketch.circle.two_tangent 2-Tangent Circle
curves: [two lines/circles/arcs], radius | diameter: expr, near: [x,y] (which of the solutions)
sketch.circle.three_tangent 3-Tangent Circle
curves: [three lines/circles/arcs], near: [x,y] (which of the solutions)
sketch.slot.center_point Center Point Slot
center: slot centre, end: one arc centre, width
sketch.slot.arc_three_point Three Point Arc Slot
start, through, end: points on the centre arc, width
sketch.slot.arc_center Center Point Arc Slot
center, start: centre arc start, end: direction of the centre arc end (counter-clockwise), width
sketch.ellipse Ellipse
center, major: end of the major axis [x,y], minor: a point the ellipse passes through on the minor side [x,y] | minor_radius
sketch.spline.fit_point Fit Point Spline
points: [[x,y] or point refs…] (2…500): the spline passes through them
sketch.spline.control_point Control Point Spline
points: control points (2…500), cubic
sketch.spline.control_point_5 Control Point Spline (Degree 5)
points: control points (2…500), degree 5
sketch.conic Conic Curve
start, end, apex: [x,y] or point refs; rho?: 0…1 (default 0.5: parabola)
sketch.text Text
text: string (\n breaks lines), at: baseline start [x,y], height?: capital height mm (default 5), angle?: deg
sketch.constrainer Sketch Constrainer
entities: [one or two sketch entity ids]: applies the constraint the geometry nearly has (horizontal/vertical, parallel, perpendicular, collinear, coincident, concentric, equal, tangent)
sketch.mirror Mirror
entities: [curve/point ids], line: mirror line id (symmetry constraints are added)
sketch.pattern.circular Circular Pattern
entities: [ids], center: [x,y] or point ref, count: 2…500, angle?: total deg (default 360)
sketch.pattern.rectangular Rectangular Pattern
entities: [ids], dir?: [x,y] (default x), count, spacing; count2?, spacing2? (perpendicular direction)
sketch.project Project (P)
refs: [{edge: [x,y,z], body?} | {face: [x,y,z], body?} (its edge loops) | {body: name} (silhouette) | {vertex: [x,y,z], body?} | {sketch, curve} | {sketch, point} | "origin" | {axis: X|Y|Z} | {plane: XY|XZ|YZ|name}]
sketch.intersect Intersect
refs: [{body}, {face: [x,y,z], body?}, {edge: [x,y,z], body?}, {sketch, curve}]: section curves (or points) with the sketch plane, linked
sketch.include_3d Include 3D Geometry
refs: like Project (edges, vertices, sketch curves and points); curves out of the sketch plane are flattened onto it
sketch.project_to_surface Project To Surface
curves: [{sketch, curve}…] (curves of other sketches), face: [x,y,z] point on the target face, body?: projected along the active sketch's normal onto the face, as linked 3D curves
sketch.intersection_curve Intersection Curve
a, b: {body} | {face: [x,y,z], body?}: where they meet, as linked 3D curves
sketch.spun_profile Spun Profile
body: name, axis: a line of the active sketch (curve id) | X|Y|Z: the body's outline revolved about the axis, in the sketch plane
sketch.isoparametric_curve Isoparametric Curve
face: [x,y,z] point on the face (the curve passes through it), body?, direction?: u|v|[x,y,z] (default u): linked 3D curve
sketch.fit_curves_to_section Fit Curves to Mesh Section
body: name (a mesh or solid body): its section with the sketch plane, fitted with lines and arcs, as normal (unlinked) geometry

SKETCH › CONSTRAINTS

sketch.constraint.horizontal_vertical Horizontal/Vertical
line: id | points: [a, b]; mode?: horizontal|vertical
sketch.constraint.coincident Coincident
a: point, b: point or curve
sketch.constraint.tangent Tangent
a, b: curves
sketch.constraint.equal Equal
a, b: lines or circles/arcs
sketch.constraint.parallel Parallel
a, b: lines
sketch.constraint.perpendicular Perpendicular
a, b: lines
sketch.constraint.fix Fix/UnFix
entity: point or curve | entities: [points and curves]; fixed?: bool (default: fix them all unless all are fixed, then unfix)
sketch.constraint.midpoint MidPoint
point, line
sketch.constraint.concentric Concentric
a, b: circles/arcs
sketch.constraint.collinear Collinear
a, b: lines
sketch.constraint.symmetry Symmetry
a, b: points, line: symmetry line
sketch.constraint.curvature Curvature
a, b: two curves sharing an end point (curvature continuous, G2)
sketch.constraint.polygon Polygon
lines: [line ids] of a closed chain: equal sides with every corner on one circle (a regular polygon)
sketch.auto_constrain AutoConstrain
tolerance?: mm (default 0.01), angle_tolerance?: deg (default 1), dimensions?: bool (default true): infer constraints, then dimension until fully constrained
sketch.auto_constrain_from_datum AutoConstrain from datum
datum: point ref (default origin); like AutoConstrain with positions measured from the datum

SKETCH › MODIFY

sketch.blend_curve Blend Curve
a, b: end points of two curves ("l1.end", "a2.start"): a smooth (tangent) spline joining them
sketch.fillet Fillet
point: corner shared by two curves ("l1.end") | a, b: two lines or arcs meeting at a corner; radius: expr
sketch.chamfer.equal_distance Equal Distance Chamfer
point | a, b: a corner of two lines; distance
sketch.chamfer.distance_angle Distance and Angle Chamfer
point | a, b: a corner of two lines; distance: along a, angle: deg from a
sketch.chamfer.two_distance Two Distance Chamfer
point | a, b: a corner of two lines; distance: along a, distance2: along b
sketch.offset Offset (O)
curves: [ids], distance: number (positive = left of the chain, or toward `side`), side?: [x,y], chain?: bool (default true: the connected chain)
sketch.trim Trim (T)
curve: id, at: [x,y] (the piece to remove: between the nearest intersections around it)
sketch.extend Extend
curve: id, at: [x,y] near the end to extend (to the nearest curve)
sketch.break Break
curve: id, at: [x,y] (split at the nearest intersections around it) | params: split at points: [[x,y]…]
sketch.scale Sketch Scale
entities: [curve/point ids], base: [x,y] or point ref, factor: number

SKETCH › INSERT

sketch.insert_dxf Insert DXF
path | text: ASCII DXF (blocks expanded); at?: [x,y] offset, scale?, tolerance?: mm within which ends join (default 0.0001); plane?: (when no sketch is active, a new sketch on it; default XY)
sketch.insert_svg Insert SVG
path | text: SVG; at?: [x,y] offset, scale?, tolerance?: mm within which ends join (default 0.0001); plane?: (when no sketch is active, a new sketch on it; default XY)
canvas.insert Canvas
path | data (base64 PNG or JPEG); plane?: XY|XZ|YZ|{face: [x,y,z]}|… (default XY); center?: [x,y] on the plane, or at?: [x,y,z]; width?: mm (default 100); angle?: deg; opacity?: 0…1 (default 0.5); flip?; name?
canvas.decal Decal
path | data; face: [x,y,z] on a planar face (the image is centred there); width?: mm; angle?: deg; opacity?: (default 1)
canvas.edit Edit Canvas
canvas: id or name; center?, width?, angle?: deg, opacity?, flip?, visible?, name?

SKETCH › INSPECT

inspect.curvature_comb Curvature Comb Analysis
curves?: [sketch curve ids] (sketch?: id|name, default active) | edges?: [[x,y,z] points on body edges]; density?: teeth per curve (default 40), scale?: comb length per unit curvature (default auto)
inspect.minimum_radius Minimum Radius Analysis
curves?: [sketch curve ids] (sketch?) | edges?: [[x,y,z]…] | faces?: [[x,y,z]…] (default: every face of every body); the smallest radius of curvature of each and where it is
inspect.isocurve Isocurve Analysis
faces: [[x,y,z]…] points on faces; count?: curves each way (default 8): the faces' isoparametric curves
inspect.center_of_mass Center of Mass
bodies?: [names] (default all): the centre of mass (uniform density) of each and of all together
inspect.zebra Zebra Analysis
stripes?: number across the view (default 12); clear?: true turns the analysis off
inspect.draft Draft Analysis
pull?: [x,y,z] direction (default Z); angle?: degrees (default 1); clear?: true turns the analysis off
inspect.environment_map Environment Map Analysis
clear?: true turns the analysis off
inspect.accessibility Accessibility Analysis
direction?: [x,y,z] the tool comes from (default Z, from above); clear?: true turns the analysis off
inspect.curvature_map Curvature Map Analysis
radius?: mm shown red (default: a tenth of the model's size); clear?: true turns the analysis off

SURFACE › CREATE

surface.patch Patch
sketch?: id|name and profiles? (planar patches of sketch regions) | edges: [[x,y,z]] (points on a closed loop of a body's edges) and body?; name?, body_name?
surface.thicken Thicken
bodies: [surface names]; thickness: expr (negative: against the normal); symmetric?: bool; operation?: new|join|cut|intersect; targets?

SURFACE › MODIFY

surface.stitch Stitch
bodies: [names] (surfaces sewn into the first; a solid when they close); tolerance?: expr (default: tight)
surface.extend Extend
body: planar surface name; edges: [[x,y,z]] (points on straight edges to push out); distance: expr
surface.trim Trim
body: surface name; plane: XY|XZ|YZ|plane name|{origin, normal} or tool: {body, point} (a face, its surface extended); keep: [x,y,z] (a point on the side to keep)

SHEET METAL › CREATE

sheet.flange Flange
base: sketch + profiles? (rule?, flip?) | contour: sketch + curves (open chain of lines) + distance (rule?, flip?, reverse?) | edge: edges: [[x,y,z] on top/bottom edges] + height (to the outer face), angle? (default 90 deg), radius? (default: rule), position?: inside|outside|middle, flip?, body?; type?: base|edge|contour (default from the inputs)
sheet.hem Hem
edges: [[x,y,z] on sheet edges]; length (to the outer face); gap? (inner radius, default: rule); flip?; body?
sheet.fold Fold
line: sketch + curve (a sketch line on the sheet's base face; followed when the sketch changes) or points: [[x,y,z], [x,y,z]]; angle? (default 90 deg); radius? (default: rule); position?: centerline|start|end|mould (where the line sits in the bend, default centerline); fixed?: [x,y,z] on the side that stays (default: the larger side); flip? (fold the other way); body?
sheet.convert Convert to Sheet Metal
body; face: [x,y,z] on its large flat face (a plate of even thickness); rule?
sheet.flat_pattern Create Flat Pattern
body? → flat size, outline loops and cut-outs (flat coordinates), bend lines and the bend table

SHEET METAL › MODIFY

sheet.unfold Unfold
body? (default: the last sheet body) — all bends
sheet.refold Refold
body? (default: the last unfolded sheet)
sheet.manage_rules Sheet Metal Rules
name (new or existing); thickness?, k_factor?, bend_radius?, relief_width?, relief_depth?, corner_relief?, hem_gap?, gap? (expressions; `Thickness` is the rule's); active?: bool; delete?: bool

PLASTIC › CREATE

plastic.boss Boss
position: [x,y,z] on a face; direction? (default: out of the face); diameter, height; hole_diameter?, hole_depth? (default: to the face); draft? (angle), fillet? (root radius); ribs? (count), rib_thickness?, rib_length? (out from the wall), rib_offset? (below the top); body?
plastic.lip Lip
face: [x,y,z] on the rim face of a shelled body; width, height; type?: lip|groove; gap? (groove clearance); side?: inside|outside (which rim edge); body?
plastic.snap_fit Snap Fit
position: [x,y,z] on a face; direction? (default: out of the face); hook: [x,y,z] (the catch's direction); length, thickness, width, catch_depth, catch_length; body?
plastic.rest Rest
position: [x,y,z] on a face (the rest's centre); direction? (default: out of the face); width (round: the diameter); length? (a rectangle, along `along`); along?: [x,y,z]; height; draft? (angle; default: the body's plastic rule); thickness? (wall of a hollow rest); body?

PLASTIC › SETUP

plastic.manage_rules Manage Plastic Rules
name (library or new rule; a new one starts from `from`, default ABS (1.5mm)); from?; material?; thickness?, nominal_radius?, clearance?, knife_edge?, reveal_height?, thickness_variation?, draft?, max_thickness?, min_thickness?, min_draft? (expressions; `Thickness` is the rule's); active?: bool (rule for bodies without one); delete?: bool (a design rule; a library rule goes back to the library values)
plastic.assign_rule Assign Plastic Rule
bodies: [names]; rule: name (empty: no rule) — plastic features on these bodies take its draft and clearance as defaults

Other: sketch.*

sketch.edit Edit Sketch
sketch: id or name
sketch.delete Delete Sketch Entities
entities: [curve, point or constraint ids]
sketch.move_point Drag Sketch Point
point: ref, to: [x,y]
sketch.drag Drag Sketch Geometry
entity: point or curve, from: [x,y] where it was grabbed, to: [x,y]: a point goes to `to`, a line (spline, conic) slides by to - from, a circle or arc grabbed on its edge takes the radius to `to`; the rest moves as little as it can
sketch.dimension_text Move Dimension Text
dimension: constraint id or parameter name; at: [x,y] text centre (sketch coordinates) | reset: true (default place)
sketch.options Sketch Palette Options
sketch?: id|name (default active); any of show_profile, show_points, show_dimensions, show_constraints, show_projected, grid, snap, slice, sketch_3d: bool. Returns them all
sketch.chain Chain
curve: id: the curves joined to it end to end (what a double-click selects)
sketch.solve Solve Sketch
reports the solver status and degrees of freedom
sketch.centerline Centerline
curves: [line ids], value?: bool (default toggles): centerline line type (not in profiles; an axis)
sketch.edit_text Edit Text
link: the text's link id (or entity: one of its curves), text?, at?, height?, angle?: deg
sketch.toggle_driven Toggle Driven Dimension
constraint: dimension id, driven?: bool (default toggles); a driving dimension gets a parameter with its current value
sketch.glyphs Constraint Glyphs
sketch?: id|name: every constraint with where to draw its glyph (sketch coordinates)
sketch.snap Snap Inference
at: [x,y], from?: [x,y] (previous click), radius?: mm (snap distance, default 1): what a click there would snap to and infer
sketch.export_dxf Save As DXF
sketch?: id|name (default active); path?: file to write (else the DXF text is returned)
sketch.line3d 3D Line
points: [[x,y,z]…] world points (2 or more): one 3D line per segment, joined end to end (needs 3D Sketch on)
sketch.spline3d 3D Spline
points: [[x,y,z]…] world fit points (2 or more): a smooth 3D curve through them (needs 3D Sketch on)
sketch.point3d 3D Point
point: [x,y,z] world point (needs 3D Sketch on)
sketch.move3d Move 3D Point
wire: drawn 3D curve or point id, index?: fit point (default 0), to: [x,y,z] | by: [dx,dy,dz]; points joined to it move too
sketch.move Move/Copy Sketch Entities
entities: [ids], translate?: [dx,dy], angle?: deg, center?: [x,y], copy?: bool
sketch.break_link Break Link
link?: link id (j1) | entities?: [curve or point ids]: linked geometry becomes normal sketch geometry
sketch.auto_project Auto-Project Edges on Reference
value?: bool (default toggles): project a face's edges when a sketch is created on it
sketch.redefine Redefine Sketch Plane
sketch: id or name; plane: XY|XZ|YZ | construction plane name | {face: [x,y,z]} | {origin, normal} (the sketch keeps its geometry)
sketch.inspect Inspect Sketch
sketch?: id|name (default active)

Other: canvas.*

canvas.calibrate Calibrate Canvas
canvas: id or name; a, b: two points on the canvas plane [x,y]; distance: their true distance (mm): scales the image about a
canvas.delete Delete Canvas
canvas: id or name

Other: sheet.*

sheet.rules List Sheet Metal Rules
→ rules with their expressions and values, and the active one
sheet.export_dxf Export Flat Pattern as DXF
body?, path? → DXF (mm): OUTLINE, BEND_UP and BEND_DOWN (centre lines) layers

Other: plastic.*

plastic.rules List Plastic Rules
→ rules with their expressions and values, the active rule and the rules assigned to bodies

Other: component.*

component.from_bodies Create Components from Bodies
bodies: [names] → one new component per body, named after it
component.activate Activate Component
component: id or name (0 or "root" for the design)
component.list List Components
component.rename Rename Component
component, name
component.delete Delete Component
component: deletes it, its subcomponents, occurrences and features
component.move_bodies Move Bodies to Component
bodies: [names], component
component.move_sketches Move Sketches to Component
sketches: [ids or names], component
component.paste_new Paste New
component: copied with its features into a new, independent component; translate?: [x,y,z]

Other: occurrence.*

occurrence.copy Paste (Instance)
component (or occurrence): what to place again; parent?: component (default: the same parent); translate?: [x,y,z]
occurrence.move Move Occurrence
occurrence; translate?: [x,y,z]; axis?: [x,y,z], angle?: radians or "30 deg", origin?: [x,y,z]; capture?: bool (default true; false keeps it pending until Capture Position)
occurrence.ground Ground
occurrence; grounded?: bool (default toggles)

Other: joint.*

joint.limits Joint Limits
joint; index?: value index (default 0); min?, max? (omit both to clear)
joint.edit Edit Joint
joint; type?, flip?, offset?, angle?, suppressed?, name?
joint.delete Delete Joint
joint: id|name (or origin: name, link: index)
joint.list List Joints
→ joints (type, occurrences, values, limits), origins, links, degrees of freedom, conflicts
joint.solve Solve Joints
re-place the occurrences from the joints → conflicts, errors, dof

Other: contact.*

contact.edit Edit Contact Set
set: id|name; occurrences?; name?; suppressed?: bool; delete?: bool
contact.list List Contact Sets
→ sets, enabled, all
contact.check Check Contact
→ pairs in contact sets that pass through each other now

Other: motion.*

motion.play Play Motion Study
study: id|name; step (0…steps) — sets the joints to the study's values there (contact sets stop them) → positions
motion.export Export Motion Study
study; samples? (default steps + 1); path? (.json or .csv) → occurrence positions per step (the design is not changed)
motion.list List Motion Studies
motion.delete Delete Motion Study
study

Other: explode.*

explode.show Show Exploded View
view: id|name (or none: back to the assembled placement) — shown only; the design keeps its placements
explode.list List Exploded Views
explode.delete Delete Exploded View
view

Other: config.*

config.column Configuration Column
param? | feature? (name); delete?: bool
config.row Configuration Row
name; from? (row to copy; default the current values); values?: {param name or feature name: expression or true/false}; rename?; delete?: bool
config.activate Activate Configuration
row: name — sets its parameter values and suppressions

Other: parts.*

parts.library Standard Parts
family? → families (name, standard, sizes, lengths) and, with family, each size's dimensions (mm)
parts.insert Insert Part
family (socket_head_cap_screw | hex_bolt | hex_nut | washer | set_screw | dowel_pin | bearing); size ("M6", or "608" for bearings); length? (mm; screws, bolts, set screws, pins; default a standard length near 2.5 d); at?: [x,y,z] on a hole's rim or wall (the part seats on the hole's face with a rigid joint) | point?: [x,y,z] with direction?: [x,y,z] (no joint); name?
parts.resize Change Part Size
component: id|name of an inserted part; size?; length? — rebuilds it (joints keep it seated)

Other: body.*

body.rename Rename Body
body: its name, name: the new name (features that use the body follow)

Other: browser.*

browser.group New Group
folder: bodies|sketches|construction; component?: id (default 0); name?; items?: [keys] (they leave other groups)
browser.ungroup Ungroup
group: id (its items go back to the folder)
browser.rename_group Rename Group
group: id, name
browser.move Move Browser Items
folder, component?, items: [keys]; group?: id (into it; omit to take them out of groups); before?: key (position in the group)
browser.order Order Browser Items
folder, component?, order: [keys] (the folder's items in display order)

Other: document.*

document.units Change Design Units
units: mm|cm|m|in|ft (display and unit-less parameters; values keep their meaning)
document.inspect Inspect Design
measure?: bool (include body measurements)

Other: view.*

view.save New Named View
name?; camera: {target: [x,y,z], yaw, pitch, distance, fov?} (replaces a view of the same name)
view.rename Rename Named View
view: name, name
view.delete Delete Named View
view: name
view.list List Named Views

Other: selection.*

selection.delete Delete
items?: [selection items]; components?, occurrences?, canvases?: [ids or names]; dry_run?: bool → deleted, would_fail, skipped (one undo step)

Other: edit.*

edit.undo Undo (Ctrl+Z)
edit.redo Redo (Ctrl+Y)

Other: timeline.*

timeline.rename Rename
feature: id|name, name
timeline.rollback Move Timeline Marker
position: number of features to keep active (omit = end)
timeline.roll_to Roll History Marker
position: number of features to keep active (omit = end) | feature: id|name (the marker goes right after it)
timeline.reorder Reorder Feature
feature: id|name, position: its new index; refused when a feature that worked would fail
timeline.redefine Edit Feature
feature: id|name, command: the feature's command id, params: its parameters (the feature is rebuilt in place)
timeline.dependents Feature Dependents
feature: id|name → features deleted with it, and features that would fail without it
timeline.suppress Suppress Feature
feature: id|name, suppressed?: bool (default toggles)
timeline.edit Edit Feature
feature: id|name, set: {fields to change, e.g. {"extent": {"distance": "30"}}}
timeline.copy Copy Features
features: [ids or names] (in timeline order on paste)
timeline.paste Paste Features
translate?: [x,y,z] (moves the copies' geometry); the copies go at the marker

Other: select.*

select.set Select
items: [{type: body|edge|face|feature|sketch_curve|sketch_point|profile, …}], add?: bool
select.clear Clear Selection

Other: parameters.*

parameters.list List Parameters
favorites?: bool (only favourites), filter?: all|user|sketch|feature|favorites → parameters (name, expression, unit, value in its unit, source, feature/input, comment, favorite, uses, used_by, error) and cycles
parameters.add Add User Parameter
name, expression, unit?, comment?, favorite?: bool
parameters.rename Rename Parameter
name, new_name (expressions, feature inputs and dimensions that use it follow)
parameters.delete Delete Parameter
name (refused while something uses it; the error lists the users)
parameters.favorite Favourite Parameter
name, favorite?: bool (default true)
parameters.comment Comment Parameter
name, comment
parameters.users Parameter Users
name → users (parameters, feature inputs, dimensions) and the features it drives
parameters.graph Parameter Graph
→ nodes, edges [user, used] (users include Feature:<name>), cycles, errors
parameters.export Export Parameters
format?: csv|json (default csv, or from the path), path?: write to a file → text
parameters.import Import Parameters
text: CSV (header with name, expression, unit?, comment?) or JSON [{name, expression, unit?, comment?}] | path; all or nothing
parameters.complete Complete Expression
prefix?: the text before the cursor → word, suggestions [{text, kind: parameter|function|unit|constant, detail}]

Other: expr.*

expr.evaluate Evaluate Expression
expression, kind?: length|angle|unitless (or unit?: mm|in|deg…) → ok, value (mm/rad), display_value, references, error

Other: file.*

file.new New Design (Ctrl+N)
name?
file.save Save (Ctrl+S)
path? (default: current file)
file.save_as Save As
path
file.export Export
path; format?: stl|stla|obj|step|3mf (default from extension); bodies?: [names]
file.save_mesh Save As Mesh
path; bodies?: [names]; ascii?: bool

Other: doc.*

doc.open Open (Ctrl+O)
path: .solvecraft design, or a .step/.stp file (opens as a new design)
doc.recovery_list Recoverable Designs
dir? (default: the recovery folder) → designs autosaved by apps that crashed or closed with unsaved changes
doc.recover Recover Design
id (from doc.recovery_list); dir?; discard?: bool (delete the entry once open) — opens it with its file path, unsaved
doc.recovery_discard Discard Recovered Design
id, or all: true; dir?

Other: model.*

model.edges List Edges
body: name
model.faces List Faces
body: name
model.threads List Threads

Other: appearance.*

appearance.library Appearance Library
→ the built-in appearances (name, colour, opacity)
appearance.list List Appearances
body?: name → assigned appearances; with body, its resolved look and its faces' (face index, look)

Other: material.*

material.list List Materials

Other: engine.*

engine.commands List Commands

Keyboard shortcuts

SolveCraft