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>
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_listandintersect_rsolidunify the same-domain faces and edges of their result by default (clean=True, asunion_rsolidalways did; history and tags follow; the raw result is kept when the unified one would be invalid;clean=Falsereturns 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).cleanis 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: nodeps.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 plainuv syncbuilds without Visual Studio or hand-setCMAKE_*variables;uvrebuilds only whensrc/cppchanges. - A
Partholds 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 profilesimplecad-part-definition-3withsolid_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_rassemblyraised). 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 raisesSeveralOpenBodiesErrornaming them. The editor draws them side by side ("N open solids") and itsuse_as_productmakes the Part from the one you choose. Several solids as a deliverable are one Part each in an Assembly.
Fixed
fillet_rsolid/chamfer_rsolidraise 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 cellno 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.cppincludes<algorithm>) and MinGW (_USE_MATH_DEFINES;build_occt.pypicks Ninja when a MinGWg++is the compiler); the macOS wheels are built onmacos-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_rsurfacedataread 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) andrebuild_curve_redge/rfacereturn 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_rcurvatureandsample_surface_risocurvesgive 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 throughuse, 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 withvalue 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
VarandExprbehave 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, andr == 5.0isTrue(it wasFalse). 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)andjson.dumps(var)still raise. Seesrc/cpp/docs/DEVIATIONS.md; the matrix test issrc/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.wrappedis an OCP shape when OCP is installed (theverifyextra), 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.wrappedis false), so a change made to it (aBRepBuilderAPI_Transform,BRepTools.Clean) does not reach the SDK's shape, which is unlike CadQuery's live handle and unlike 2.2.6, where.wrappedwas the shape itself. To use a result, convert it back withsimplecadapi._glue.bridge.ocp_to_native. Without OCP it stays the SDK's own OCCT shape.SCA_WRAPPED=native|ocpchooses, and is read on each access. The SDK's own Python layers takeshape._native_wrapped, which is always the native one, and the functions that take a raw shape (theinspect.brepqueries, the STEP export, the geometry helpers ofsimplecadapi.kernel) accept either.- Editor kernel: the cells keep what they made (
simplecadapi.runtime.cache._CellMemory, 12 results;SCA_NO_CELL_MEMORY=1turns 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_metadataandauto_tag_faceschange 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 runand the tests do not). With a marimo whosecache_attempt_from_hashhas another signature than the one this was written for, a line on stderr says so and the memory is off.SCA_EDITOR_TRACE=1withSCA_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_previewtakesomit=for the parts to leave out; a post that is not a readable preview is answered400(409is only for parts the server does not hold), and the server replaces the model it holds as one value; the editor keeps parts insimplecadapi.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=1prints how long each step of a settle takes. usekeeps 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=1turns 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 newOPEN_STROKEon the six-axis arm rebuilds in 4.2 s instead of 6.4 s. Children with a computedusepath 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
previewevent, 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/lateststays 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=1turns it off).cached_meshruns 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.packper point; the bytes are identical.
Added
simplecadapi.verify(to_ocp,from_ocp) and theverifyextra (pip install "simplecadapi[verify]", OCP 7.9 without VTK) for verifier scripts. With OCP installedshape.wrappedis an OCP shape itself (see Changed), so both routes work;to_ocp/from_ocpare the explicit ones. The SDK itself still never imports OCP. The skill gainsreferences/discipline/verifier-scripts.mdwith the recipes (volume, bounds, validity, point in solid, distance, overlap) and a verifier skeleton.
Removed
- The
femextra (gmshandccx2paraview[VTK]) and the README steps that used it; thegmshextra 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 asmake_cut_rsolid_listand 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.brepis part of the default install and renders with the built-in software renderer: VTK is no longer needed,matplotlibis a core dependency, and theinspectextra 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_rsolidno 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 tocut_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-gordonandpy-slvs; theSCA_BACKENDswitch.
2.2.6.post2 — 2026-10-21
Changed
- Operators:
scale_rsolidandtransform_rsolidare implemented inoperators/transform.py,boolean_rsolidlistinoperators/boolean.py, andoffset_rsolid,draft_rsolid,extrude_taper_rsolid,extrude_until_rsolidandsweep_multisection_rsolidinoperators/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 aDeprecationWarningthat 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_rsolidlisthad no doc at all. - Skill API docs of
NotebookRun,run_notebookandadd_bspline_rsketchcaught up with the code (through,productandtimeout; a partial run'sproductisNone; 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 asscad.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] scaranges and the add-on commands accept a post-release version such as2.2.6.post1(it sorts after2.2.6and before2.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 Adepends on the definition ofA(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 plainimport 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
usecalls 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_JOBSsets 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 NOTEBOOKswitches the running editor to another notebook of the workspace and waits for its kernel, so the followingsca cellwrites go through instead of refusing. The write commands take--opento switch and write in one step (--wait, orSCA_EDITOR_OPEN_WAIT, raises the boot wait; default 120s)./api/cellsreportskernelso 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.pngby hand.
Changed
- Cache:
cryptographyships 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 cellfinds the editor through a container's proxy environment: the recorded url is always the loopback (--host 0.0.0.0included), the health check and the editor calls bypasshttp_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 Nruns the first N cells only (a stage, numbered the way the editor numbers cells),--no-productruns a work-in-progress notebook that has no product yet, and--timeout SECONDSfails 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/runreport 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 namessca cell ls(SCA_EDITOR_CALL_TIMEOUTraises the wait, default 300s). - Inspect: printing a
BRepInspectionshows a one-line summary; the full record isto_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 cellis the only way to change a regular cell;dof=0says 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 cellcommand, 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_andnode_modules,venv,site-packages,build,distare skipped.
2.2.3 — 2026-10-14
Added
- Editor:
sca cell ls|get|put|insert|rm|runedits 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 areGET /api/cellsandPOST /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.functioncell 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.(andscad.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 asname=and Tab moves between them; inside a call the parameters not given yet complete asname=(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 editon an empty directory is usable.
Fixed
- Editor: the cell editors rebuilt their configuration on every render (a new
onChangeandbasicSetupeach 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-modeworkspace of the standalone sca-web-editor), and its skill workflowreverse-engineering-studio.md.sca editreplaces the standalone editor; STEP reconstruction continues through the inspection API and thestep-reconstructionworkflow.
Added
-
Modeling:
scale, affinetransform, signedoffset,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 ineditor-web/; needs theeditorextra). It runs a workspace's notebooks in a marimo kernel with the SDK's own cell executor, so the editor,sca runandrun_notebookshare one runtime, and marimo's dataflow decides what a parameter change reruns. -
Editor: picking in the viewport writes a selection cell of
scad.qlselectors (selected_<kind>[_<i>],selected_item); edits autosave to the notebook file;sca snapshotand.sca-editor/snapshot.json+viewport.pngtell 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 formatSCAPREV1), 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 ituses are rerun from their files.sca lsreports 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.workspacealso 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 runreports 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
inputsdata 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
returnstatements 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
drawingextra. 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.installresolves the destination through the addon config/env chain (default~/.agents/skills, nosca initrequired), refuses to overwrite an existing directory, and--forceonly permits replacing a directory whoseSKILL.mddeclares 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 bothcommand_prefixandcheck_cmd. Newsca 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; newsca addon use <name> <cmd>runs a command inside the addon's declared environment. sca init(#2): creates the addon home and wires ascashim plus a PATH block into new shells (--no-shellskips the wiring).- Error guidance overhaul (#1): all SDK exceptions share one
SimpleCADErrorroot, 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-exportentry points are gone; the same commands live undersca cacheandsca 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-unavailableevidence entry instead of silently missing, and the budget is tunable viaSCA_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.