Files
make-cad/CHANGELOG.md
T
Ni Jingzhe afb63fc375 release: 2.3.0 (includes the never-published 2.2.9)
DECISION: release the one-solid Part, the Windows build fix and the three issue fixes (#87, #88, #89) as 2.3.0. Not 2.2.10:
the owner chose 2.3.0. 2.2.9 is skipped; it was prepared on dev but never tagged or published (no v2.2.9 tag, nothing on PyPI,
the dry run of its workflow published nothing), so there is nothing to withdraw.

WHY A MINOR VERSION
- It removes interface of the withdrawn 2.2.8 (`bodies=`, `Part.multi_body`, profile 3), adds keywords (`clean=` on three
  booleans), and widens the exporters' input.
- It changes a default: `cut_rsolid`, `cut_rsolid_list` and `intersect_rsolid` unify their result, so the topology and the
  fingerprint of a body that used to keep a split face change.
- It breaks a recorded format on purpose: `clean` is a required parameter of the three recorded operations, a graph recorded
  before 2.3.0 is rejected on replay and has to be recorded again (the owner's rule: no branches for old formats).

WHAT CHANGES
- pyproject.toml, uv.lock (the simplecadapi package entry), docs/skill/SKILL.md and docs/skill/references/SDK_OVERVIEW.md:
  2.2.9 -> 2.3.0.
- CHANGELOG.md: the 2.2.9 entry becomes 2.3.0 (2026-11-12) and gains the four changes; "Fixed" gains the blend validity check.
- docs/updates/2.3.0.md and 2.3.0.zh-CN.md replace the 2.2.9 notes (deleted): everything the 2.2.9 notes said, then the booleans,
  the exporters and read-only runs, the fingerprints, and the Windows build. The release workflow turns them into the release
  page.

Checked: test_skill_lint and test_auto_docs_gen pass; the release workflow checks that the tag equals the pyproject version
(v2.3.0). test_skill_build::test_files_without_directives_copied_verbatim fails on the base commit as well (a Windows encoding
problem of this machine). The code of dev was green in CI at 8c482366 before this commit; this commit changes no code.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-12 14:47:57 +08:00

38 KiB

Changelog

All notable changes to SimpleCADAPI are documented here. Per-version user-facing notes live in docs/updates/ (English and 中文).

2.3.0 — 2026-11-12

Follows 2.2.7. 2.2.8 was withdrawn (yanked on PyPI) and the 2.2.9 prepared to replace it was never published: both are in 2.3.0. User-facing notes: docs/updates/2.3.0.md.

Changed

  • cut_rsolid, cut_rsolid_list and intersect_rsolid unify the same-domain faces and edges of their result by default (clean=True, as union_rsolid always did; history and tags follow; the raw result is kept when the unified one would be invalid; clean=False returns the raw result). A cut through the side of a box with a cylinder left the cylinder wall split along its seam, and OCCT fillets an edge along such a face wrongly (#88). clean is a recorded parameter of the three operations: a graph recorded before 2.3.0 has none and is rejected on replay (record it again). Bodies built with such a cut have fewer faces and edges, and different fingerprints.
  • The exporters (export_product_package_to_step / stl / obj / mjcf, the FreeCAD translator) also take the result of a build or its definition, packaged in memory without the scene projection (#89): 1.85 s -> 0.26 s for a 36-hole plate.
  • run_notebook(path, cache=False) writes nothing beside the notebook: no deps.json, no state directory, so it runs where the source directory is read-only (#89). The skill allows a plain script for a task that asks for a single script (R3 exception).
  • Geometry fingerprints quantize through a noise-tolerant _q (#87); a fingerprint of a body with a value on a quantization boundary changes once, and a topology snapshot recorded before does not restore.
  • The build backend is tools/build_backend/scad_build.py (scikit-build-core plus toolchain and OpenCASCADE detection on Windows): a plain uv sync builds without Visual Studio or hand-set CMAKE_* variables; uv rebuilds only when src/cpp changes.
  • A Part holds exactly one solid again. The multi-body Part of the withdrawn 2.2.8 release (make_part_rpart(bodies=...), Part.multi_body, scad.part_shape, inspect_body_overlaps_rlist, BodyOverlapWarning, part definition profile simplecad-part-definition-3 with solid_cache.bodies) is removed: a Part is the unit an assembly places, mates and gives connectors to, and a Part of several bodies could do none of that (no connectors, explode_rassembly raised). Several solids that exist side by side while a model is built (a tool next to its body) are ordinary notebook values: a part notebook with one open solid still gets the implicit Part; with several there is no product and the run raises SeveralOpenBodiesError naming them. The editor draws them side by side ("N open solids") and its use_as_product makes the Part from the one you choose. Several solids as a deliverable are one Part each in an Assembly.

Fixed

  • fillet_rsolid / chamfer_rsolid raise when OCCT returns a solid it calls invalid while the input was valid (they used to return it, #88); a fillet that fails on split faces says so instead of blaming the radius.
  • On Windows sca cell no longer kills the editor it talks to: the editor pid is probed without signalling it (os.kill(pid, 0) terminates the process on Windows).
  • Building from source with GCC 14 (operators_promote.cpp includes <algorithm>) and MinGW (_USE_MATH_DEFINES; build_occt.py picks Ninja when a MinGW g++ is the compiler); the macOS wheels are built on macos-15 (still targeting macOS 14.0).

2.2.8 — 2026-11-09

User-facing notes: docs/updates/2.2.8.md.

Added

  • Editing existing curves and surfaces as recorded operations (the SDK half of NURBS control-point editing): inspect_curve_rcurvedata / inspect_surface_rsurfacedata read degree, poles, weights, knots and trimming; set_*_poles, move_*_poles, set_*_weights, insert_*_knot, elevate_*_degree (curves _redge, surfaces _rface), convert_to_bspline_redge/rface (the explicit step for lines, circles, planes, cylinders) and rebuild_curve_redge/rface return a new shape, record a topology delta (tags and references follow the face and its edges) and replay from model JSON. A trimmed face keeps its trimming. sample_curve_rcurvature and sample_surface_risocurves give an editor a curvature comb and clipped isocurves.

Changed

  • The editor offers its code mode only. Manual modelling (features, sketches, assemblies by buttons and dialogs) is built but switched off (editor-web/src/lib/manual-mode.ts) until it has a plan of its own: no mode switch, command bar or manual keys (/, W, Space, Ctrl+Z on features, 6). The viewport keeps what was made for it: three's WebGPURenderer (WebGL 2 as the fallback), level of detail (a part seen up close is tessellated again by the kernel from the in-memory BREP, POST /api/preview/refine), instanced parts, BVH picking, and smooth shading from exact surface normals.

Fixed

  • A stable reference into a face or shell body (no solid) resolves; it raised cannot resolve QL selector scope.

2.2.7 — 2026-10-30

Fixed

  • The editor starts with whatever model file is on disk: a model kept by an older build that leaves parts out, or a damaged one, is not restored (and no longer stops the kernel from starting, which showed as "starting the kernel" for ever), and a model that leaves parts out is not filed.
  • A cache entry that names classes which no longer exist (written by an older build: No module named 'simplecadapi._native') is deleted and written again. marimo restores such a value as a stub; the runner dropped the cache for the run and ran again without it, which neither read nor wrote entries, so the same stubs came back on every later run and every cell ran every time. A notebook with such entries (a child run through use, the six-axis arm's gripper) now takes 0.8 s instead of 3.3-6 s once the entries are replaced. A stub for any other reason (a value that cannot be pickled) keeps the old behaviour.
  • A cell whose value is cached but whose lineage record is missing now runs once and writes both again. It used to run on every call and never repair the record (the cell stayed active nowhere, so nothing was saved), which showed as a notebook that never hit its cache, such as a child notebook run through use.
  • Editor: a slider drag that pauses and is then released no longer rebuilds twice. The page sends the value when the drag pauses and again on release; the server now skips a value the model already has (unless the last run failed, when the same value is a retry).
  • A cached cell whose lineage record belongs to another graph is a cache miss and runs again. A part-family member (use("child.py", id="member")) with such a record used to fail with value contains graph node '...' not owned by active graph 'member'. A restored cell no longer overwrites its record, and a record is only written under the id its cache belongs to.
  • A failed fillet or chamfer, and a ql cardinality error, carry their diagnostic picture again (as in 2.2.6): the failing edge(s) as orange lines, or the matched faces orange and the near misses purple. 2.2.7b1 drew pictures for failed booleans only. Highlighted faces are shaded with the standard material, so the palette colours read as before.
  • A refused preview post names what the editor server said (HTTP 400: damaged preview: ...) instead of only the status line.

Changed

  • Var and Expr behave like numbers where Python asks for one: int, round, floor/ceil, comparisons (r > 3), max/min/sorted, range(n), [0] * n, lst[n - 1], //, %, f"{r:.2f}", str, and numpy scalars as operands now work, and r == 5.0 is True (it was False). Arithmetic still builds the formula; these decisions read the value the expression has now. A ql predicate with a Var-derived value (ql.prop("geom.length", ">=", 2 * math.pi * radius)) matches, where 2.2.6 matched nothing. bool(var) and json.dumps(var) still raise. See src/cpp/docs/DEVIATIONS.md; the matrix test is src/cpp/tests/python/test_expr_numeric_protocol.py.
  • A handled failure that used to leave no trace now prints a [sca] ... line on stderr: the preview warm-up, an unreadable lineage record, a cache entry that could not be deleted, a preview frame that could not be built, a notebook that could not be signed, and a kept model that is damaged and is built again.
  • shape.wrapped is an OCP shape when OCP is installed (the verify extra), of the class of its kind (TopoDS_Solid, TopoDS_Face, ...), as it is in CadQuery: the OCCT code an agent writes for verifier scripts runs as written (BRepGProp.VolumeProperties_s(solid.wrapped, props)). It is a copy made through BinTools, with its location and orientation: every access makes a new one (s.wrapped is s.wrapped is false), so a change made to it (a BRepBuilderAPI_Transform, BRepTools.Clean) does not reach the SDK's shape, which is unlike CadQuery's live handle and unlike 2.2.6, where .wrapped was the shape itself. To use a result, convert it back with simplecadapi._glue.bridge.ocp_to_native. Without OCP it stays the SDK's own OCCT shape. SCA_WRAPPED=native|ocp chooses, and is read on each access. The SDK's own Python layers take shape._native_wrapped, which is always the native one, and the functions that take a raw shape (the inspect.brep queries, the STEP export, the geometry helpers of simplecadapi.kernel) accept either.
  • Editor kernel: the cells keep what they made (simplecadapi.runtime.cache._CellMemory, 12 results; SCA_NO_CELL_MEMORY=1 turns it off). marimo unpickles an entry while it answers the cache lookup, which is about a second for each of the six-axis arm's assemblies; the kernel now asks its memory right after the cell's key is hashed and before the disk, and hands out the same objects when the entry is one this process holds. Only plain data and the SDK's value types are kept. They are functional except for the semantic state of a shape: apply_tag, set_metadata and auto_tag_faces change the shape they are called on and return the same object, so a later cell that tags a shape it received would change what the producing cell has kept (the disk copy has none of it). Every root of shapes now counts its writes (AnyShape._semantic_revision); an entry whose counts moved since it was kept is dropped and the next restore reads the disk copy as before. Reading a shape or consuming it in an operator does not count. Parts and assemblies are followed to their bodies and components. The limit is twelve entries, not a number of bytes, and costs about 300 MB on the six-axis arm; only the editor's kernel has a memory (sca run and the tests do not). With a marimo whose cache_attempt_from_hash has another signature than the one this was written for, a line on stderr says so and the memory is off. SCA_EDITOR_TRACE=1 with SCA_EDITOR_TRACE_FILE=<path> writes what the cache did with each cell and how long each part took.
  • The saved parameter values in a cell's digest follow what the cell reads. A value the notebook's parameter cell defines used to be part of the digest of every cell below that cell, so changing one joint angle changed the digest of the cell that builds the parts and every cell after it. It is now part of the digest of the cell that defines it, of the cells that read it, and of the cells that read from those. On the six-axis arm a joint angle that has not been seen before takes 2.3-2.7 s to show instead of 5.7-6.5 s, and one that has been seen takes 0.6 s instead of 5.5 s. The digests of cells of a notebook that has saved parameter values are not those of the previous version, so the first run after the upgrade builds those notebooks again once.
  • Editor: the preview is incremental. A model's parts are identified by the content of their geometry, so the kernel posts only the parts the server does not hold, the server sends each page only the parts that page lacks (a page that joins late, or asks with preview.resync, is given the whole model), and the page builds geometry only for new parts and reuses the rest. On the six-axis arm a joint angle now moves 115 KB instead of 6.26 MB: the kernel's post takes 17 ms instead of 285-610 ms, the page handles the frame in 2-5 ms with no long task, and from the last cell to the model on screen it takes 0.36-0.41 s instead of 1.3-3.2 s. simplecadapi.scene.preview.encode_preview takes omit= for the parts to leave out; a post that is not a readable preview is answered 400 (409 is only for parts the server does not hold), and the server replaces the model it holds as one value; the editor keeps parts in simplecadapi.editor.preview_parts.PartStore.
  • Editor: the signature that files a model on disk is taken beside the build, not before it, and the server replies to the kernel's post before filing the model and writing the snapshot. SCA_EDITOR_TRACE=1 prints how long each step of a settle takes.
  • use keeps the product of the last run of each child notebook in the process and hands it out again while the child's static digest (source, header, local modules, input files, the children it uses) and the overrides are unchanged (simplecadapi.runtime.usememo; SCA_NO_USE_MEMO=1 turns it off). One entry per (notebook, id): the run's nodes are registered by graph id, so the entry is the last run's, and two notebooks that run under one graph id replace each other's entry. The editor's kernel is a long-lived process, so a new OPEN_STROKE on the six-axis arm rebuilds in 4.2 s instead of 6.4 s. Children with a computed use path and overrides that are not plain data are not kept. Prefetch no longer starts workers for what is kept.
  • Editor: the model is pushed over the WebSocket with the preview event, in one binary frame (<u32 big-endian N><N bytes of JSON envelope><SCAPREV1 preview>), and a page that joins late is given it on connect: no second HTTP request for it. A model already on screen still travels as the bare notice (unchanged: true). GET /api/preview/latest stays for agents and tools.
  • Editor: the model reaches the page sooner after the last cell. A settle makes one call into the kernel instead of three (the cells are listed in the call that publishes the preview), the duplicate settle a boot used to run is gone, and the settle debounce is 0.12 s. On the six-axis arm the time from the last cell to the preview event went from about 0.83 s (plus a second, redundant round of 0.27 s) to about 0.36 s.
  • Editor: parts are tessellated in the background while the next cell computes (simplecadapi.scene.prewarm; SCA_NO_PREVIEW_WARM=1 turns it off). cached_mesh runs without the interpreter lock for that; a failure is recorded on the shape back under the lock.
  • Preview edge polylines are keyed with one numpy pass instead of one struct.pack per point; the bytes are identical.

Added

  • simplecadapi.verify (to_ocp, from_ocp) and the verify extra (pip install "simplecadapi[verify]", OCP 7.9 without VTK) for verifier scripts. With OCP installed shape.wrapped is an OCP shape itself (see Changed), so both routes work; to_ocp / from_ocp are the explicit ones. The SDK itself still never imports OCP. The skill gains references/discipline/verifier-scripts.md with the recipes (volume, bounds, validity, point in solid, distance, overlap) and a verifier skeleton.

Removed

  • The fem extra (gmsh and ccx2paraview[VTK]) and the README steps that used it; the gmsh extra stays. VTK is no longer in the lock file at all.

2.2.7b1 — 2026-10-24

Added

  • cut_rsolid_list(base, *tools): the boolean cut that keeps every piece. A slot through a bar returns both halves, a tool that encloses the body returns an empty list. Recorded as make_cut_rsolid_list and replayable.
  • Prebuilt wheels for Linux x86_64, Linux aarch64, macOS arm64 and Windows x86_64, each for Python 3.10-3.13, built by the release workflow against one static OpenCASCADE 7.9.3.

Changed

  • simplecadapi.inspect.brep is part of the default install and renders with the built-in software renderer: VTK is no longer needed, matplotlib is a core dependency, and the inspect extra is an empty alias.
  • The geometry engine is C++ on OpenCASCADE, shipped in the wheel as simplecadapi._cpp; one distribution, one import package. The public API is unchanged, and the previous test suite passes (three tests that relied on a dropped sliver of a tangent cut now use a tool clear of the wall).
  • Every message the library writes is English; the tag-validation and semantic-query errors render in full with possible causes and fixes.
  • macOS wheels require macOS 14 or later.

Fixed

  • cut_rsolid no longer drops pieces silently. When a cut split the body it returned only the first piece (a slot through a 100x20x10 bar reported half the volume); it now raises and points to cut_rsolid_list. A tool that only touches a wall tangentially (a cylinder of radius 2 at (3, 3) in a 10x10 block) leaves a separate sliver and now raises too.

Removed

  • Dependencies cadquery-ocp, ocp-gordon and py-slvs; the SCA_BACKEND switch.

2.2.6.post2 — 2026-10-21

Changed

  • Operators: scale_rsolid and transform_rsolid are implemented in operators/transform.py, boolean_rsolidlist in operators/boolean.py, and offset_rsolid, draft_rsolid, extrude_taper_rsolid, extrude_until_rsolid and sweep_multisection_rsolid in operators/features.py, next to the operators of their family. from simplecadapi import ... is unchanged. The one-feature modules they were first written in (operators.deformation, draft, section_features, limited_extrusion) remain as aliases: importing a name from them still works and raises a DeprecationWarning that names the new place.

Fixed

  • Skill API docs: the documentation generator listed its source files and public functions by hand and had never been told about those four modules, so the docs of the eight operators above were kept by hand and deleted by the generator's clean-up. operators/ is now discovered, a function the package exports is public, the content of the hand-written docs (examples, error conditions, replay notes) is in the docstrings, and tests check that every public operator has a doc and that the committed docs are exactly what the generator writes. boolean_rsolidlist had no doc at all.
  • Skill API docs of NotebookRun, run_notebook and add_bspline_rsketch caught up with the code (through, product and timeout; a partial run's product is None; closed B-splines).

2.2.6.post1 — 2026-10-21

Fixed

  • Editor: the parameter panel reads scad.var(name="j1", default=0.0, ...) — the keyword form — as well as scad.var("j1", 0.0, ...). Before, only the second positional argument was taken as the default, so keyword declarations never showed up as parameters.
  • Add-ons: [compat] sca ranges and the add-on commands accept a post-release version such as 2.2.6.post1 (it sorts after 2.2.6 and before 2.2.7); the parser rejected it.

Changed

Cache and runtime speed, measured on the desktop six-axis arm (cold 80.5 s to 34.6 s, no change 23.6 s to 4.0 s, one joint edited 18.2 s to 3.0 s, cache 1.7 GB to 96 MB):

  • Restoring a cached shape is cheaper: adding a child to a shape no longer refreshes its whole subtree's tag cache unless a tag can pass down, and a restore finds entities by position and refreshes each tag cache once. A restored shape is then built when something first uses it, so a cached value that no running cell reads is never built; pickling it again hands back what it was restored from.
  • The cell cache stores less and compresses it: no values for a cell's private (_name) variables, geometry bytes and cache entries zlib-compressed (level 1). Entries written before are still read.
  • scad.var(...) values and the expressions made from them are keyed by content, so a cell that reads one parameter is no longer redone because another one, defined in the same cell, changed (marimo keyed any object it cannot hash by the code of the cell that made it).
  • A cell that does from lib.dims import A depends on the definition of A (and what it reads, across local modules), not on the whole file. A module the analysis cannot prove (calls or loops at top level, star imports, a name defined twice, a plain import lib.dims) still depends on the whole file.
  • A cell that runs a notebook with use("child.py") (a literal path) is keyed by what that child is (its text, the modules it imports, the notebooks it uses in turn) instead of by everything a run recorded: editing one child redoes the cell that uses it and not those that use its siblings, and the editor kernel caches such cells too (it ran them live before). A path computed at run time still depends on what a run recorded.
  • The use calls a cell is about to make (literal path; arguments made of values it reads, float(...), notebook_id()) are started together in worker processes, which fill the notebooks' caches; the cell then finds them built. OpenCASCADE keeps the interpreter lock, so these are processes, not threads. SCA_JOBS sets how many (default: the smaller of 4 and the cores; 1 turns it off). Workers are only started when the builds they take off the cell's hands are worth the seconds a worker takes to start (a notebook remembers how long it last took to build), and a notebook that has not changed since it last ran is not started at all. A notebook's state directory is locked between processes while it runs.
  • Editor: a slider drag is sent when it pauses (250 ms) or ends, not step by step; clicks and number-box commits still go at once.

2.2.6 — 2026-10-19

Added

  • Editor: sca cell open NOTEBOOK switches the running editor to another notebook of the workspace and waits for its kernel, so the following sca cell writes go through instead of refusing. The write commands take --open to switch and write in one step (--wait, or SCA_EDITOR_OPEN_WAIT, raises the boot wait; default 120s). /api/cells reports kernel so a caller can tell a booted notebook from one still opening.
  • Editor: sca viewport [WORKSPACE] [--out PATH] reports where the viewport image lives (path, age, size) and copies it out, instead of reading .sca-editor/viewport.png by hand.

Changed

  • Cache: cryptography ships as a dependency, so the notebook cache keeps marimo's manifest signing and verification on instead of silently degrading to unsigned, unverified entries (the "LazyLoader verification='on' degraded to 'off'" warning).
  • Editor: a refused write now names sca cell open NOTEBOOK (or --open) as the way out, and the bundled skill's editor-collaboration reference says so.

2.2.5 — 2026-10-15

Fixed

  • Editor: sca cell finds the editor through a container's proxy environment: the recorded url is always the loopback (--host 0.0.0.0 included), the health check and the editor calls bypass http_proxy, and a record whose server does not answer is an error naming the record and the url instead of a silent "no editor is running". A record whose pid is gone reports the stale record and the remedy. A fallback to reading the file says so on stderr.

Added

  • Run: sca run --through N runs the first N cells only (a stage, numbered the way the editor numbers cells), --no-product runs a work-in-progress notebook that has no product yet, and --timeout SECONDS fails a run that takes longer (off by default).
  • Editor: a failing or blocked cell's report names its upstream cells (failing ones first), with marimo's own dependency semantics.

Changed

  • Editor: sca cell put/insert/run report the console output and every cell left unhealthy by the change, and the dependents a write made stale are run, not left stale. A write whose rerun outlives the call says the edit was applied and names sca cell ls (SCA_EDITOR_CALL_TIMEOUT raises the wait, default 300s).
  • Inspect: printing a BRepInspection shows a one-line summary; the full record is to_dict() / .faces / .edges.
  • Runs are quieter: the cache loaders' degraded-state warnings no longer print at WARNING, and the render paths switch VTK's warning display off process-wide (this also hides VTK chatter from code run in the same process); a real failure is still raised and named.
  • Skill: while an editor runs, sca cell is the only way to change a regular cell; dof=0 says the constraint system closed, not that the shape is right (mirror solutions); modeling projects are version-controlled with git.

2.2.4 — 2026-10-15

Fixed

  • Editor: a failed publish is reported again on every run someone asked for — a page rerun, an agent sca cell command, a change to the notebook file, a module reload, a parameter commit — so the page's "building the model" veil lifts with the reason instead of waiting out its fallback. The once-per-identical-message dedup stays for the parameter burst. A page that connects after the failure is told the last error at the end of the connection handshake.

Changed

  • Editor: the header's button that opened the raw marimo editor is gone.
  • Skill: the editor docs state which notebooks the workspace scan lists — subfolders of any depth are scanned; names starting with . or _ and node_modules, venv, site-packages, build, dist are skipped.

2.2.3 — 2026-10-14

Added

  • Editor: sca cell ls|get|put|insert|rm|run edits the open notebook's cells through the running editor (found by <workspace>/.sca-editor/server.json): the page shows the change live, with no reload, the cell runs, and the command prints its status, errors and output. sca new NAME [--kind part|assembly] writes a notebook the editor then lists, leaving the person's view alone. The routes behind them are GET /api/cells and POST /api/cells/{edit,insert,delete,run}.
  • Editor: a change to the open notebook's file made by someone else (an agent) is noticed within a second and applied cell by cell (edited cells are updated and run again, added or removed cells appear or go), without a reload; a changed setup or @app.function cell restarts the kernel. Notebooks added to or removed from the workspace appear in the list by themselves.

Fixed

  • Editor: an edit made in the editor no longer writes over what an agent saved to the same notebook file. If a cell was edited in both places, the file's version is kept and the editor's unsaved text goes to the log.

2.2.2 — 2026-10-14

Added

  • Editor: code completion from the SDK itself. scad. (and scad.ql., scad.std.gear., ql.) lists the real functions with their signatures and docstrings; accepting one, or typing ( after a known name, writes the call with every required parameter as name= and Tab moves between them; inside a call the parameters not given yet complete as name= (required first). The names come from the running package (GET /api/sdk), so they cannot drift from the code.
  • Editor: a new action in the workspace tab starts a notebook from the SDK's template (a part, or an assembly that uses the first two parts of the workspace), with the name checked as you type. An empty workspace opens on that form, so sca edit on an empty directory is usable.

Fixed

  • Editor: the cell editors rebuilt their configuration on every render (a new onChange and basicSetup each time), which dropped any snippet in progress and could disturb typing; both are stable now.

2.2.1 — 2026-10-13

The first stable release of the 2.2 line (2.2.0b1 was a pre-release): everything below was added since 2.1.4, the notebook runtime of 2.2.0b1 included.

Removed

  • Re-Studio, the reverse-engineering studio (the Re-mode workspace of the standalone sca-web-editor), and its skill workflow reverse-engineering-studio.md. sca edit replaces the standalone editor; STEP reconstruction continues through the inspection API and the step-reconstruction workflow.

Added

  • Modeling: scale, affine transform, signed offset, draft, tapered and until-limited extrusions and multisection sweeps are recorded features, and boolean results can keep every output of a set operation; graph nodes keep ordered input references so a replay selects the same entities.

  • tools/research/build123dftc: an execution-based build123d to FTC converter (isolated tracing, exact profile reconstruction, generated notebooks and assemblies) with independent geometry and STEP acceptance. It is research tooling, not part of the installed package.

  • Editor: light mode. The editor follows the system theme and a button in the header cycles system, light and dark (remembered); the 3D viewport, edges, grid, axes and the code editor switch with it, in place, without reloading the model or losing the camera and selection.

  • sca edit [WORKSPACE]: the web editor, now part of the SDK (simplecadapi.editor, UI sources in editor-web/; needs the editor extra). It runs a workspace's notebooks in a marimo kernel with the SDK's own cell executor, so the editor, sca run and run_notebook share one runtime, and marimo's dataflow decides what a parameter change reruns.

  • Editor: picking in the viewport writes a selection cell of scad.ql selectors (selected_<kind>[_<i>], selected_item); edits autosave to the notebook file; sca snapshot and .sca-editor/snapshot.json + viewport.png tell a coding agent what is selected and shown. Ground grid and axis gizmo in a Z-up CAD frame; cells fold to their step name and can run all cells above.

  • Editor: a log dock along the bottom replaces the error line in the header. It lists what happened and what failed (with the time), and while cells are re-evaluated shows how many of them are done, which one is running and for how long; each cell shows running/queued/blocked. A module that does not compile is reported as the cause ("setup failed — SyntaxError ...").

  • Editor: models reach the viewport as a live preview straight from the solids (simplecadapi.scene.preview, wire format SCAPREV1), without building a package; a picked entity's details are fetched on demand. Solids no longer carry an eagerly built mesh (modeling is about 20% faster).

  • Editor: the local modules a notebook imports (shared dimensions, helpers) are listed in the workspace, with the notebooks that use them, and open in a module view: source (autosaved) plus the dataclass fields (and top-level constants with a # ui: comment) as parameter controls. Editing a module, there or on disk, reloads it in the kernel and reruns the open notebook; the notebooks it uses are rerun from their files. sca ls reports each notebook's modules.

  • Notebook parameters: the numbers, bools and scad.vars of a # ---- params ---- cell are discoverable (sca params, simplecadapi.runtime.params.list_parameters) with an optional trailing # ui: slider(min, max, step=, unit=, label=) comment to pick the control. Existing notebooks need no change.

  • sca ls [DIR] lists the SimpleCAD notebooks under a directory (id, part or assembly, the notebooks each uses); simplecadapi.runtime.workspace also parses # ---- feature: ... ---- headers.

  • simplecadapi.runtime.live: project the running kernel's product to a .scadpkg (live_package, publish_live).

  • Editor: a cell's run button is a stop button while the kernel runs the cell (the header's run-all too); stopping interrupts the kernel. Switching back to a notebook shows its last model and cells at once when nothing it depends on changed (the editor remembers each notebook's last published package, keyed by a digest of its files), while the kernel boots.

Changed

  • Volumes and centres of mass integrate NURBS by knot spans (Gauss-Kronrod) instead of the fixed-order routine: exact for rational patches (a sewn 80 mm cube measures 512000 mm3, the old routine overshot by ~19 mm3) and safe on affine-transformed trims. A degenerate blend result now measures 0 and is still reported as BlendVolumeViolation.
  • The cell cache is per cell: an entry is stored under a digest of the local modules, child notebooks and input files that cell depends on (and what the cells it reads from depend on), no longer one digest for the whole notebook. A changed module recomputes the cells that read it and restores the rest; going back to an earlier value restores everything. The editor kernel uses the same cache. sca run reports the same cell statuses; caches written by earlier versions are ignored and removed.
  • Building a package is about twice as fast: the render mesh of a face is computed with numpy in the profile's fixed operation order (the bytes, and so every content hash, are unchanged).
  • Editor: parameters of local modules and inputs data files are watched.

Fixed

  • Editor: switching notebooks quickly no longer ends on the wrong one or reports open failed: Connection refused: opens are ordered, a superseded open stops its kernel quietly, and the list highlights the notebook being opened at once. A kernel for a notebook with inline dependencies no longer waits for marimo's sandbox prompt ("marimo not ready after 60s"); opening a notebook no longer publishes its model before its cells ran; a page refreshed after an unchanged publish shows the model; the viewport redraws after a panel resize; edges stay visible where a coarse mesh would hide them.
  • ql.vertices() resolves through solids, faces and wires (it found nothing unless the scope was an edge).
  • The editor no longer rewrites a notebook when a cell is run unchanged, and keeps return statements inside the functions a cell defines.
  • The notebook executor no longer fails on cells that are not part of the notebook (the editor's scratch cell raised KeyError).

Changed

  • pymupdf is no longer a default-install dependency: it is optional under the new drawing extra. The engineering-drawing family is the only user: vector-PDF drawing inspection, and DXF -> PNG rendering (via ezdxf's drawing backend). import simplecadapi, modeling, STEP export, and VTK rendering all work without it. Drawing functions without pymupdf raise an ImportError naming the extra: pip install 'simplecadapi[drawing]'.

2.1.3 — 2026-09-18

The addon ecosystem leaves the beta line: one stable sca CLI, addon runtime state that survives updates, structured error guidance, and a wheel that ships the Agent Skill source for installation on any machine.

Added

  • sca skill targets|install (#4): compile the bundled Agent Skill for a harness target and install it into the skills directory. The wheel ships the uncompiled skill source tree (docs/skill + skillproj.toml) and compilation happens at install time, so pip users no longer need a repository checkout. install resolves the destination through the addon config/env chain (default ~/.agents/skills, no sca init required), refuses to overwrite an existing directory, and --force only permits replacing a directory whose SKILL.md declares the same skill name.
  • Addon runtime state outside the payload (#3): provisioned environments and caches live under ~/.sca/runtimes/<name>, survive addon updates, and are removed with the addon; the {runtime_dir} placeholder now resolves in both command_prefix and check_cmd. New sca addon check [name] re-probes a runtime immediately and refreshes the cached registry state.
  • Addon v2 standard (#2): the repository name, the descriptor, and the skill frontmatter must share one name; [runtime].command_prefix (with {addon_dir} / {runtime_dir} placeholders) is prepended to commands; new sca addon use <name> <cmd> runs a command inside the addon's declared environment.
  • sca init (#2): creates the addon home and wires a sca shim plus a PATH block into new shells (--no-shell skips the wiring).
  • Error guidance overhaul (#1): all SDK exceptions share one SimpleCADError root, and failures across sketch solve, assembly solve, boolean, blend, sweep/loft, and QL selection report structured, measured, repairable diagnostics with evidence rendering (edge highlights, four-iso views); zero-hit highlight guards name the tags that are actually available.

Changed

  • One command line: the historical simplecad-cache / simplecad-export entry points are gone; the same commands live under sca cache and sca export (#2).

Fixed

  • Diagnostic evidence rendering no longer crashes the process or vanishes silently: GL work is kept out of the failure path's render thread (the crash-isolated worker subprocess is used on every platform there), a render that cannot finish within its budget is reported as a named render-unavailable evidence entry instead of silently missing, and the budget is tunable via SCA_DIAGNOSTIC_RENDER_BUDGET (tests use 60 s; the agent-facing default stays 15 s).
  • Windows build blockers: binary file opens, guarded directory fsync, and evidence-based stale-lock handling.
  • Translator: unified geometry signatures and SolidWorks 2023 support.

2.1.2 — 2026-09-10

Script-anchored part cache: the @scad.part / @scad.assemble anchor is the builder's source directory (.simplecad/ beside the script); no pyproject.toml required for standalone scripts. histjson emitter keyword-only arguments. See 2.1.2 update notes.

2.1.1 — 2026-09-09

Tooling patch; the SDK public API is unchanged. See 2.1.1 update notes.

2.1.0 — 2026-09-07

The SDK becomes an agent-first CAD toolkit: the QL selection language, persistent tagging, durable .scadpkg product packages, standard parts, multi-backend translation (FreeCAD, SolidWorks, Fusion), and the Agent Skill. See 2.1.0 update notes.